V3FIT
magnetic.f
Go to the documentation of this file.
1 !*******************************************************************************
4 !
5 ! Note separating the Doxygen comment block here so detailed decription is
6 ! found in the Module not the file.
7 !
11 !*******************************************************************************
12 
13  MODULE magnetic
14  USE stel_kinds, only: rprec
15  USE magnetic_response
16  USE profiler
17  USE signal
18 
19  IMPLICIT NONE
20 
21 !*******************************************************************************
22 ! magnetic module parameters
23 !*******************************************************************************
25  INTEGER, PARAMETER :: magnetic_force_coil_flag = 1
27  INTEGER, PARAMETER :: magnetic_3d_flag = 2
28 
29 !*******************************************************************************
30 ! DERIVED-TYPE DECLARATIONS
31 ! 1) magnetic base class
32 !
33 !*******************************************************************************
34 !-------------------------------------------------------------------------------
38 !-------------------------------------------------------------------------------
39  TYPE, EXTENDS(signal_class) :: magnetic_class
41  INTEGER :: control_flags
43  TYPE (magnetic_response_class), POINTER :: response => null()
44  CONTAINS
45  PROCEDURE :: &
46  & get_modeled_signal_last => magnetic_get_modeled_signal
47  PROCEDURE :: &
48  & get_type => magnetic_get_type
49  PROCEDURE :: &
50  & get_header => magnetic_get_header
51  final :: magnetic_destruct
52  END TYPE
53 
54 !*******************************************************************************
55 ! INTERFACE BLOCKS
56 !*******************************************************************************
57 !-------------------------------------------------------------------------------
60 !-------------------------------------------------------------------------------
61  INTERFACE magnetic_class
62  MODULE PROCEDURE magnetic_construct_netcdf
63  END INTERFACE
64 
65  CONTAINS
66 !*******************************************************************************
67 ! CONSTRUCTION SUBROUTINES
68 !*******************************************************************************
69 !-------------------------------------------------------------------------------
87 !-------------------------------------------------------------------------------
88  FUNCTION magnetic_construct_netcdf(mdsig_iou, use_coil_response, &
89  & force_coil_reponse, &
90  & use_3D_only, svd_cut_off)
91  USE ezcdf
92  USE v3_utilities
93 
94  IMPLICIT NONE
95 
96 ! Declare Arguments
97  class(magnetic_class), POINTER :: magnetic_construct_netcdf
98  INTEGER, INTENT(in) :: mdsig_iou
99  LOGICAL, INTENT(in) :: use_coil_response
100  LOGICAL, INTENT(in) :: force_coil_reponse
101  LOGICAL, INTENT(in) :: use_3d_only
102  REAL (rprec), INTENT(in) :: svd_cut_off
103 
104 ! local variables
105  INTEGER, DIMENSION(3) :: dim_lengths
106  LOGICAL :: temp_flag
107  REAL (rprec) :: start_time
108 
109 ! Start of executable code
110  start_time = profiler_get_start_time()
111 
112  ALLOCATE(magnetic_construct_netcdf)
113 
114  magnetic_construct_netcdf%response => &
115  & magnetic_response_construct(mdsig_iou, svd_cut_off)
116 
117  magnetic_construct_netcdf%control_flags = 0
118 
119  IF (force_coil_reponse) THEN
120  CALL assert(magnetic_response_use_coil( &
121  & magnetic_construct_netcdf%response), &
122  & 'Cannot force coil response. Coil responses ' // &
123  & 'not found in mdsig file.')
124  magnetic_construct_netcdf%control_flags = &
125  & ibset(magnetic_construct_netcdf%control_flags, &
126  & magnetic_force_coil_flag)
127  END IF
128 
129  IF (use_3d_only) THEN
130  magnetic_construct_netcdf%control_flags = &
131  & ibset(magnetic_construct_netcdf%control_flags, &
132  & magnetic_3d_flag)
133  END IF
134 
135 ! Check if using the coil response for this diagnostic. If not using it clear
136 ! the responce flag bit.
137  IF (.not.use_coil_response) THEN
138  CALL magnetic_response_clr_use_coil( &
139  & magnetic_construct_netcdf%response)
140  END IF
141 
142  CALL profiler_set_stop_time('magnetic_construct_netcdf', &
143  & start_time)
144 
145  END FUNCTION
146 
147 !*******************************************************************************
148 ! DESTRUCTION SUBROUTINES
149 !*******************************************************************************
150 !-------------------------------------------------------------------------------
156 !-------------------------------------------------------------------------------
157  SUBROUTINE magnetic_destruct(this)
158 
159  IMPLICIT NONE
160 
161 ! Declare Arguments
162  TYPE (magnetic_class), INTENT(inout) :: this
163 
164 ! Start of executable code
165  IF (ASSOCIATED(this%response)) THEN
166  CALL magnetic_response_destruct(this%response)
167  this%response => null()
168  END IF
169 
170  END SUBROUTINE
171 
172 !*******************************************************************************
173 ! GETTER SUBROUTINES
174 !*******************************************************************************
175 !-------------------------------------------------------------------------------
186 !-------------------------------------------------------------------------------
187  FUNCTION magnetic_get_modeled_signal(this, a_model, sigma, &
188  & last_value)
189  USE model
190 
191  IMPLICIT NONE
192 
193 ! Declare Arguments
194  REAL (rprec), DIMENSION(4) :: magnetic_get_modeled_signal
195  CLASS (magnetic_class), INTENT(inout) :: this
196  TYPE (model_class), POINTER :: a_model
197  REAL (rprec), DIMENSION(4), INTENT(out) :: sigma
198  REAL (rprec), DIMENSION(4), INTENT(in) :: last_value
199 
200 ! local variables
201  REAL (rprec) :: start_time
202 
203 ! Start of executable code
204  start_time = profiler_get_start_time()
205 
206  sigma = 0.0
207 
208  IF (btest(a_model%state_flags, model_state_vmec_flag) .or. &
209  & btest(a_model%state_flags, model_state_siesta_flag) .or. &
210  & btest(a_model%state_flags, model_state_shift_flag) .or. &
211  & btest(a_model%state_flags, model_state_signal_flag)) THEN
212 
213  IF (magnetic_response_is_point(this%response)) THEN
214  magnetic_get_modeled_signal = &
215  & magnetic_get_modeled_signal_point(this, a_model, sigma)
216  ELSE
217  magnetic_get_modeled_signal = &
218  & magnetic_get_modeled_signal_coil(this, a_model, sigma)
219  END IF
220 
221  CALL this%scale_and_offset(a_model, &
222  & magnetic_get_modeled_signal(1))
223  ELSE
224  magnetic_get_modeled_signal = last_value
225  END IF
226 
227  CALL profiler_set_stop_time('magnetic_get_modeled_signal', &
228  & start_time)
229 
230  END FUNCTION
231 
232 !-------------------------------------------------------------------------------
237 !-------------------------------------------------------------------------------
241 !-------------------------------------------------------------------------------
251 !-------------------------------------------------------------------------------
252  FUNCTION magnetic_get_modeled_signal_point(this, a_model, sigma)
253  USE model
254 
255  IMPLICIT NONE
256 
257 ! Declare Arguments
258  REAL (rprec), DIMENSION(4) :: magnetic_get_modeled_signal_point
259  TYPE (magnetic_class), INTENT(in) :: this
260  TYPE (model_class), INTENT(in) :: a_model
261  REAL (rprec), DIMENSION(4), INTENT(out) :: sigma
262 
263 ! local variables
264  REAL (rprec), DIMENSION(3) :: b_field
265  REAL (rprec) :: start_time
266 
267 ! Start of executable code
268  start_time = profiler_get_start_time()
269 
270  magnetic_get_modeled_signal_point = 0.0
271 
272  b_field = equilibrium_get_ext_b_plasma(a_model%equilibrium, &
273  & this%response%position, &
274  & .false.)
275 
276  magnetic_get_modeled_signal_point(2) = &
277  & dot_product(b_field, this%response%direction)
278 
279 ! Axisymmetric component.
280  IF (btest(this%control_flags, magnetic_3d_flag)) THEN
281  b_field = equilibrium_get_ext_b_plasma(a_model%equilibrium, &
282  & this%response%position, &
283  & .true.)
284 
285  magnetic_get_modeled_signal_point(4) = &
286  & dot_product(b_field, this%response%direction)
287  END IF
288 
289 ! Coil Pickup -----------------------------------------------------------------
290  magnetic_get_modeled_signal_point(3) = &
291  & magnetic_get_modeled_signal_coil_pickup(this, a_model)
292 
293 ! Total Signal ----------------------------------------------------------------
294 
295 ! Add plasma signals and induced signal to create total signal.
296  IF (magnetic_response_use_coil(this%response)) THEN
297  magnetic_get_modeled_signal_point(1) = &
298  & sum(magnetic_get_modeled_signal_point(2:3))
299  ELSE
300  magnetic_get_modeled_signal_point(1) = &
301  & magnetic_get_modeled_signal_point(2)
302  END IF
303 
304 ! Subtract off the axisymmtric component. When not using the 3D only signal
305 ! the value stored in the forth position is zero so there is no need to check
306 ! the flag.
307  magnetic_get_modeled_signal_point(1) = &
308  & magnetic_get_modeled_signal_point(1) - &
309  & magnetic_get_modeled_signal_point(4)
310 
311  sigma = 0.0
312 
313  CALL profiler_set_stop_time('magnetic_get_modeled_signal_point', &
314  & start_time)
315 
316  END FUNCTION
317 
318 !-------------------------------------------------------------------------------
331 !-------------------------------------------------------------------------------
336 !-------------------------------------------------------------------------------
346 !-------------------------------------------------------------------------------
347  FUNCTION magnetic_get_modeled_signal_coil(this, a_model, sigma)
348  USE model
349  USE bivariate
350  USE v3_utilities, only: err_warn
351 
352  IMPLICIT NONE
353 
354 ! Declare Arguments
355  REAL (rprec), DIMENSION(4) :: magnetic_get_modeled_signal_coil
356  TYPE (magnetic_class), INTENT(in) :: this
357  TYPE (model_class), INTENT(in) :: a_model
358  REAL (rprec), DIMENSION(4), INTENT(out) :: sigma
359 
360 ! local variables
361  INTEGER :: phi, num_phi, r, z
362  INTEGER :: numrvol, numzvol
363  TYPE (bivariate_type), POINTER :: bivariate_object
364  REAL (rprec), DIMENSION(:), ALLOCATABLE :: rgrid
365  REAL (rprec), DIMENSION(:), ALLOCATABLE :: zgrid
366  REAL (rprec), DIMENSION(:,:,:), POINTER :: rvolgrid
367  REAL (rprec), DIMENSION(:,:,:), POINTER :: zvolgrid
368  REAL (rprec), DIMENSION(:,:,:), POINTER :: jrvolgrid
369  REAL (rprec), DIMENSION(:,:,:), POINTER :: jphivolgrid
370  REAL (rprec), DIMENSION(:,:,:), POINTER :: jzvolgrid
371  REAL (rprec), DIMENSION(:,:), POINTER :: krgrid
372  REAL (rprec), DIMENSION(:,:), POINTER :: kphigrid
373  REAL (rprec), DIMENSION(:,:), POINTER :: kzgrid
374  REAL (rprec), DIMENSION(:,:), ALLOCATABLE :: response_rvol
375  REAL (rprec), DIMENSION(:,:), ALLOCATABLE :: response_phivol
376  REAL (rprec), DIMENSION(:,:), ALLOCATABLE :: response_zvol
377  REAL (rprec), DIMENSION(:,:), ALLOCATABLE :: sumrz
378  REAL (rprec), DIMENSION(:), ALLOCATABLE :: sumphi
379  INTEGER :: num_r, num_z
380 
381  REAL (rprec) :: start_time
382 
383 ! Start of executable code
384  start_time = profiler_get_start_time()
385 
386  magnetic_get_modeled_signal_coil = 0.0
387 
388 ! Calculate the plasma only signal from the response function.
389 ! Get the volume integration grid points.
390 ! NOTE: Do not deallocate any of these arrays. They are owned by the
391 ! equilibrium
392  rvolgrid => &
393  & equilibrium_get_magnetic_volume_rgrid(a_model%equilibrium)
394  zvolgrid => &
395  & equilibrium_get_magnetic_volume_zgrid(a_model%equilibrium)
396  jrvolgrid => &
397  & equilibrium_get_magnetic_volume_jrgrid(a_model%equilibrium)
398  jphivolgrid => &
399  & equilibrium_get_magnetic_volume_jphigrid(a_model%equilibrium)
400  jzvolgrid => &
401  & equilibrium_get_magnetic_volume_jzgrid(a_model%equilibrium)
402 
403 ! The equilibrium may return null pointers indicating the lack of a plasma.
404  IF (ASSOCIATED(rvolgrid) .and. ASSOCIATED(zvolgrid) .and. &
405  & ASSOCIATED(jrvolgrid) .and. ASSOCIATED(jphivolgrid) .and. &
406  & ASSOCIATED(jzvolgrid)) THEN
407 
408 ! Allocate space for the interpolated response functions. Only need two
409 ! dimensions because the interpolation is performed one phi position at a time.
410  numrvol = SIZE(rvolgrid, 1)
411  numzvol = SIZE(rvolgrid, 2)
412  ALLOCATE(response_rvol(numrvol, numzvol))
413  ALLOCATE(response_phivol(numrvol, numzvol))
414  ALLOCATE(response_zvol(numrvol, numzvol))
415 
416 ! Allocate work arrays to hold the results of the integration.
417  num_phi = SIZE(this%response%a_r)
418  ALLOCATE(sumrz(numrvol, numzvol))
419  ALLOCATE(sumphi(num_phi))
420 
421 ! Create the r and z gridpoints for the magnetic response function.
424  num_r = compression_get_dimension1(this%response%a_r(1)%p)
425  ALLOCATE(rgrid(num_r))
426  DO r = 1, num_r
427  rgrid(r) = this%response%rmin &
428  & + (r - 1)*(this%response%rmax - this%response%rmin) &
429  & / (num_r - 1)
430  END DO
431 
432  num_z = compression_get_dimension2(this%response%a_r(1)%p)
433  ALLOCATE(zgrid(num_z))
434  DO z = 1, num_z
435  zgrid(z) = this%response%zmin &
436  & + (z - 1)*(this%response%zmax - this%response%zmin) &
437  & / (num_z - 1)
438  END DO
439 
440 ! Create a bivariate object to do the interpolation.
441  bivariate_object => bivariate_construct(numrvol, numzvol)
442 
443 ! Sum over grid points for each toroidal plane
444  DO phi = 1, num_phi
445  CALL bivariate_set_grids(bivariate_object, &
446  & rvolgrid(:,:,phi), &
447  & zvolgrid(:,:,phi), &
448  & rgrid, zgrid)
449 
450 ! Interpolate from the diagnotic grid points to the volume grid points.
451  CALL compression_decompress(this%response%a_r(phi)%p)
452  CALL bivariate_get_4pt(bivariate_object, &
453  & this%response%a_r(phi)%p%data_buffer, &
454  & response_rvol)
455  CALL compression_cleanup(this%response%a_r(phi)%p)
456 
457  CALL compression_decompress(this%response%a_f(phi)%p)
458  CALL bivariate_get_4pt(bivariate_object, &
459  & this%response%a_f(phi)%p%data_buffer, &
460  & response_phivol)
461  CALL compression_cleanup(this%response%a_f(phi)%p)
462 
463  CALL compression_decompress(this%response%a_z(phi)%p)
464  CALL bivariate_get_4pt(bivariate_object, &
465  & this%response%a_z(phi)%p%data_buffer, &
466  & response_zvol)
467  CALL compression_cleanup(this%response%a_z(phi)%p)
468 
469 ! J_plasma * A_diag
470 ! First compute the rz grid signal. Then compute the signal for a single phi
471 ! plane. Over the radial component, the ends need to be taken as half.
472  sumrz = jrvolgrid(:,:,phi)*response_rvol &
473  & + jphivolgrid(:,:,phi)*response_phivol &
474  & + jzvolgrid(:,:,phi)*response_zvol
475  sumphi(phi) = sum(sumrz(2:numrvol - 1,:)) &
476  & + sum(sumrz(1,:) + sumrz(numrvol,:))/2.0
477  END DO
478 
479  CALL bivariate_destruct(bivariate_object)
480 
481 ! Correct for stellarator symetry.
482  magnetic_get_modeled_signal_coil(2) = sum(sumphi)
483  IF (magnetic_response_is_stell_sym(this%response)) THEN
484  magnetic_get_modeled_signal_coil(2) &
485  & = magnetic_get_modeled_signal_coil(2) &
486  & - (sumphi(1) + sumphi(num_phi))/2.0
487  END IF
488 
489 ! Finish integration with the volume element.
490  magnetic_get_modeled_signal_coil(2) &
491  & = magnetic_get_modeled_signal_coil(2) &
492  & * equilibrium_get_volume_int_element(a_model%equilibrium)
493 
494 ! Deallocate work arrays.
495 ! NOTE: Do not deallocate any of the vol grid arrays that were obtained from
496 ! the equilibrium_get_magnetic_volume_*grid routines. These arrays are owned by
497 ! by the equilibrium.
498  DEALLOCATE(response_rvol, response_phivol, response_zvol)
499  DEALLOCATE(sumrz, sumphi)
500  DEALLOCATE(rgrid, zgrid)
501 
502  END IF
503 
504 ! Conducting Shell ------------------------------------------------------------
505  IF (magnetic_response_use_shell(this%response)) THEN
506 
507  num_phi = compression_get_dimension2(this%response%a_s_r)
508 
509  krgrid => &
510  & equilibrium_get_con_surface_krgrid(a_model%equilibrium)
511  kphigrid => &
512  & equilibrium_get_con_surface_kphigrid(a_model%equilibrium)
513  kzgrid => &
514  & equilibrium_get_con_surface_kzgrid(a_model%equilibrium)
515 
516  IF (ASSOCIATED(krgrid) .and. ASSOCIATED(kphigrid) .and. &
517  & ASSOCIATED(kzgrid)) THEN
518  ALLOCATE(sumphi(num_phi))
519 
520  CALL compression_decompress(this%response%a_s_r)
521  CALL compression_decompress(this%response%a_s_f)
522  CALL compression_decompress(this%response%a_s_z)
523 
524  DO phi = 1, num_phi
525  sumphi(phi) &
526  & = sum(krgrid(:,phi)* &
527  & this%response%a_s_r%data_buffer(:,phi)) &
528  & + sum(kphigrid(:,phi)* &
529  & this%response%a_s_f%data_buffer(:,phi)) &
530  & + sum(kzgrid(:,phi)* &
531  & this%response%a_s_z%data_buffer(:,phi))
532  END DO
533 
534  CALL compression_cleanup(this%response%a_s_r)
535  CALL compression_cleanup(this%response%a_s_f)
536  CALL compression_cleanup(this%response%a_s_z)
537 
538 ! Correct for stellarator symetry.
539  magnetic_get_modeled_signal_coil(4) = sum(sumphi)
540  IF (magnetic_response_is_stell_sym(this%response)) THEN
541  magnetic_get_modeled_signal_coil(4) &
542  & = magnetic_get_modeled_signal_coil(4) &
543  & - (sumphi(1) + sumphi(num_phi))/2.0
544  END IF
545 
546 ! Finish integration with the area element.
547  magnetic_get_modeled_signal_coil(4) &
548  & = magnetic_get_modeled_signal_coil(4) &
549  & * equilibrium_get_area_int_element(a_model%equilibrium)
550 
551  DEALLOCATE(sumphi)
552  END IF
553 
554  END IF
555 
556 ! Coil Pickup -----------------------------------------------------------------
557  magnetic_get_modeled_signal_coil(3) = &
558  & magnetic_get_modeled_signal_coil_pickup(this, a_model)
559 
560 ! Total Signal ----------------------------------------------------------------
561 
562 ! Add plasma signals and induced signal to create total signal.
563  IF (magnetic_response_use_coil(this%response)) THEN
564  magnetic_get_modeled_signal_coil(1) = &
565  & sum(magnetic_get_modeled_signal_coil(2:3))
566  ELSE
567  magnetic_get_modeled_signal_coil(1) = &
568  & magnetic_get_modeled_signal_coil(2)
569  END IF
570 
571 ! Add shell currents if used.
572  IF (magnetic_response_use_shell(this%response)) THEN
573  magnetic_get_modeled_signal_coil(1) &
574  & = magnetic_get_modeled_signal_coil(1) &
575  & + magnetic_get_modeled_signal_coil(4)
576  END IF
577 
578  sigma = 0.0
579 
580  CALL profiler_set_stop_time('magnetic_get_modeled_signal_coil', &
581  & start_time)
582 
583  END FUNCTION
584 
585 !-------------------------------------------------------------------------------
595 !-------------------------------------------------------------------------------
596  FUNCTION magnetic_get_modeled_signal_coil_pickup(this, a_model)
597  USE model
598 
599  IMPLICIT NONE
600 
601 ! Declare Arguments
602  Real (rprec) :: magnetic_get_modeled_signal_coil_pickup
603  TYPE (magnetic_class), INTENT(in) :: this
604  TYPE (model_class), INTENT(in) :: a_model
605 
606 ! local variables
607  LOGICAL :: scale_current
608  INTEGER :: num_currents
609  REAL (rprec), DIMENSION(:), POINTER :: extcur
610  REAL (rprec) :: start_time
611 
612 ! Start of executable code
613  start_time = profiler_get_start_time()
614 
615  magnetic_get_modeled_signal_coil_pickup = 0.0
616 
617  IF (magnetic_response_use_coil(this%response)) THEN
618  IF (btest(this%control_flags, magnetic_force_coil_flag)) THEN
619  num_currents = SIZE(this%response%inductance)
620  ELSE
621  num_currents = -1
622  END IF
623 
624 ! Calculate the induced signal from external currents.
625  extcur => equilibrium_get_ext_currents(a_model%equilibrium, &
626  & num_currents, &
627  & scale_current)
628 
629 ! If there are no external current extcur will be a null pointer.
630  IF (ASSOCIATED(extcur)) THEN
631 
632 ! Make sure we don't go out of bounds on any array.
633  num_currents = min(SIZE(extcur), &
634  & SIZE(this%response%inductance))
635  IF (num_currents .lt. this%response%n_field_cg) THEN
636  CALL err_warn('magnetic_get_modeled_signal_coil: ' // &
637  & 'mdsig_file expected more currents')
638  END IF
639 
640  IF (scale_current) THEN
641  magnetic_get_modeled_signal_coil_pickup = dot_product( &
642  & this%response%inductance(1:num_currents), &
643  & extcur(1:num_currents)/this%response%current_scale)
644  ELSE
645  magnetic_get_modeled_signal_coil_pickup = dot_product( &
646  & this%response%inductance(1:num_currents), &
647  & extcur(1:num_currents))
648  END IF
649  END IF
650  END IF
651 
652  CALL profiler_set_stop_time( &
653  & 'magnetic_get_modeled_signal_coil_pickup', start_time)
654 
655  END FUNCTION
656 
657 !-------------------------------------------------------------------------------
665 !-------------------------------------------------------------------------------
666  FUNCTION magnetic_get_type(this)
667  USE data_parameters
668 
669  IMPLICIT NONE
670 
671 ! Declare Arguments
672  CHARACTER (len=data_name_length) :: magnetic_get_type
673  CLASS (magnetic_class), INTENT(in) :: this
674 
675 ! local variables
676  REAL (rprec) :: start_time
677 
678 ! Start of executable code
679  start_time = profiler_get_start_time()
680 
681  magnetic_get_type = 'mddc'
682 
683  CALL profiler_set_stop_time('magnetic_get_type', start_time)
684 
685  END FUNCTION
686 
687 !-------------------------------------------------------------------------------
696 !-------------------------------------------------------------------------------
697  SUBROUTINE magnetic_get_header(this, header)
698  USE data_parameters
699 
700  IMPLICIT NONE
701 
702 ! Declare Arguments
703  class(magnetic_class), INTENT(in) :: this
704  CHARACTER (len=data_name_length), DIMENSION(7), INTENT(inout) :: &
705  & header
706 
707 ! local variables
708  REAL (rprec) :: start_time
709 
710 ! Start of executable code
711  start_time = profiler_get_start_time()
712 
713  header(1) = 'plasma only'
714  header(2) = 'eq currents'
715 
716 ! Default to the 4th label as the axi symmtric only signal.
717  IF (magnetic_response_use_shell(this%response)) THEN
718  header(3) = 'shell currents'
719  ELSE
720  header(3) = 'Axi signal'
721  END IF
722 
723  header(4) = 'model_sig(1)'
724  header(5) = 'model_sig(2)'
725  header(6) = 'model_sig(3)'
726  header(7) = 'model_sig(4)'
727 
728  CALL profiler_set_stop_time('magnetic_get_header', start_time)
729 
730  END SUBROUTINE
731 
732  END MODULE
profiler
Defines functions for measuring an tabulating performance of function and subroutine calls....
Definition: profiler.f:13
magnetic_response::magnetic_response_construct
Interface for the construction of magnetic_response_class types using magnetic_response_construct_new...
Definition: magnetic_response.f:216
magnetic_response::magnetic_response_use_shell
logical function magnetic_response_use_shell(this)
Checks if the conducting shell flag is set.
Definition: magnetic_response.f:831
magnetic::magnetic_get_modeled_signal
real(rprec) function, dimension(4) magnetic_get_modeled_signal(this, a_model, sigma, last_value)
Calculates the modeled signal.
Definition: magnetic.f:189
magnetic::magnetic_get_modeled_signal_coil
real(rprec) function, dimension(4) magnetic_get_modeled_signal_coil(this, a_model, sigma)
Calculates the coil modeled signal.
Definition: magnetic.f:348
magnetic
Defines the base class of the type magnetic_class.
Definition: magnetic.f:13
model
Defines the base class of the type model_class. The model contains information not specific to the eq...
Definition: model.f:59
magnetic::magnetic_get_header
subroutine magnetic_get_header(this, header)
Gets a discription of the model and model sigma array indices.
Definition: magnetic.f:698
magnetic_response::magnetic_response_is_stell_sym
logical function magnetic_response_is_stell_sym(this)
Checks if the stellarator symmetric flag is set.
Definition: magnetic_response.f:769
magnetic::magnetic_class
Base class representing a magnetic signal.
Definition: magnetic.f:39
bivariate::bivariate_construct
type(bivariate_type) function, pointer bivariate_construct(ns, nu)
Construct a bivariate_type object.
Definition: bivariate.f:76
magnetic::magnetic_3d_flag
integer, parameter magnetic_3d_flag
Bit position for the force coil response flag.
Definition: magnetic.f:27
bivariate::bivariate_type
An object containing persistent data for the bivariate interpolation.
Definition: bivariate.f:27
v3_utilities::assert
Definition: v3_utilities.f:55
bivariate::bivariate_destruct
subroutine bivariate_destruct(this)
Deconstruct a bivariate_type object.
Definition: bivariate.f:118
magnetic::magnetic_get_modeled_signal_point
real(rprec) function, dimension(4) magnetic_get_modeled_signal_point(this, a_model, sigma)
Calculates the point modeled signal.
Definition: magnetic.f:253
magnetic::magnetic_get_modeled_signal_coil_pickup
real(rprec) function magnetic_get_modeled_signal_coil_pickup(this, a_model)
Gets the model signal contribution from the external coils.
Definition: magnetic.f:597
bivariate::bivariate_set_grids
Interface for the setting of bivariate_type types either using bivariate_set_grids_1d or bivariate_se...
Definition: bivariate.f:57
magnetic::magnetic_construct_netcdf
class(magnetic_class) function, pointer magnetic_construct_netcdf(mdsig_iou, use_coil_response, force_coil_reponse, use_3D_only, svd_cut_off)
Construct a magnetic_class object containing a magnetic_response::magnetic_response_class object.
Definition: magnetic.f:91
profiler::profiler_get_start_time
real(rprec) function profiler_get_start_time()
Gets the start time of profiled function.
Definition: profiler.f:194
model::model_class
Base class representing a model.
Definition: model.f:141
magnetic_response::magnetic_response_is_point
logical function magnetic_response_is_point(this)
Checks if the coil response flag is set.
Definition: magnetic_response.f:922
magnetic_response::magnetic_response_destruct
subroutine magnetic_response_destruct(this)
Deconstruct a magnetic_response_class object.
Definition: magnetic_response.f:695
magnetic::magnetic_force_coil_flag
integer, parameter magnetic_force_coil_flag
Bit position for the use coil response flag.
Definition: magnetic.f:25
magnetic_response::magnetic_response_class
Base class representing a magnetic signal response function.
Definition: magnetic_response.f:140
data_parameters
This modules contains parameters used by equilibrium models.
Definition: data_parameters.f:10
bivariate::bivariate_get_4pt
subroutine bivariate_get_4pt(this, resp_rz, resp_su)
Interpolate points on to responce function grid.
Definition: bivariate.f:391
magnetic_response::magnetic_response_use_coil
logical function magnetic_response_use_coil(this)
Checks if the coil response flag is set.
Definition: magnetic_response.f:862
profiler::profiler_set_stop_time
subroutine profiler_set_stop_time(symbol_name, start_time)
Gets the end time of profiled function.
Definition: profiler.f:121
magnetic::magnetic_destruct
subroutine magnetic_destruct(this)
Deconstruct a magnetic_class object.
Definition: magnetic.f:158
magnetic_response
Defines the base class of the type magnetic_response_class.
Definition: magnetic_response.f:11
signal::signal_class
Base class representing a signal.
Definition: signal.f:33
bivariate
This modules contains routines for interpolating points inside a grid. This was originally written by...
Definition: bivariate.f:12
magnetic_response::magnetic_response_clr_use_coil
subroutine magnetic_response_clr_use_coil(this)
Clears the coil response bit.
Definition: magnetic_response.f:893
signal
Defines the base class of the type signal_class.
Definition: signal.f:14
magnetic::magnetic_get_type
character(len=data_name_length) function magnetic_get_type(this)
Gets a discription of the magnetic type.
Definition: magnetic.f:667
Generated on Thu Mar 5 2020 15:49:26 for V3FIT by   doxygen 1.8.17