magnetic_response.f

Go to the documentation of this file.

!*******************************************************************************
!
!  Note separating the Doxygen comment block here so detailed decription is
!  found in the Module not the file.
!
!*******************************************************************************
 
      MODULE magnetic_response
      USE compression
      USE stel_kinds, only: rprec
      USE profiler
 
      IMPLICIT NONE
 
!*******************************************************************************
!  magnetic_response module parameters
!*******************************************************************************
!  NOTE: When changing this version changes, the select statement in
!  magnetic_construct_netcdf of magnetic.f in the V3FIT needs to be updated. ???
!  FIXME Check if this is true. The versioning should probably be handeled
!  internally here.
 
!  Currnet version -------------------------------------------------------------
      CHARACTER (len=*), PARAMETER ::                                          &
     &   magnetic_response_current = 'MRC 2015-04-27'
!  Previous versions -----------------------------------------------------------
      CHARACTER (len=*), PARAMETER ::                                          &
     &   magnetic_response_20140928 = 'MRC 2014-09-28'
 
      INTEGER, PARAMETER :: magnetic_response_len = 80
 
      INTEGER, PARAMETER :: magnetic_response_use_coil_flag   = 1
      INTEGER, PARAMETER :: magnetic_response_use_plasma_flag = 2
      INTEGER, PARAMETER :: magnetic_response_stell_sym_flag  = 3
      INTEGER, PARAMETER :: magnetic_response_use_shell_flag  = 4
      INTEGER, PARAMETER :: magnetic_response_is_point_flag   = 5
 
!  NETCDF file variable names --------------------------------------------------
      CHARACTER (len=*), PARAMETER :: nc_flags = 'mddc_mrf_flags'
 
!  Identification Variables ----------------------------------------------------
      CHARACTER (len=*), PARAMETER :: nc_name = 'mddc_mrf_code_name'
      CHARACTER (len=*), PARAMETER :: nc_version =                             &
     &   'mddc_mrf_code_version'
      CHARACTER (len=*), PARAMETER :: nc_date = 'mddc_mrf_date_run'
      CHARACTER (len=*), PARAMETER :: nc_coil_id =                             &
     &   'mddc_mrf_field_coils_id'
 
!  Coil Responce Function Variables --------------------------------------------
      CHARACTER (len=*), PARAMETER :: nc_n_field_cg =                          &
     &   'mddc_mrf_n_field_cg'
      CHARACTER (len=*), PARAMETER :: nc_inductance =                          &
     &   'mddc_mrf_rdiag_coilg_1'
      CHARACTER (len=*), PARAMETER :: nc_current_scale =                       &
     &   'mddc_mrf_extcur_mg'
 
!  Plasma Response Grid Variables ----------------------------------------------
      CHARACTER (len=*), PARAMETER :: nc_num_t = 'mddc_mrf_kp'
      CHARACTER (len=*), PARAMETER :: nc_num_r = 'mddc_mrf_ir'
      CHARACTER (len=*), PARAMETER :: nc_num_z = 'mddc_mrf_jz'
      CHARACTER (len=*), PARAMETER :: nc_rmin = 'mddc_mrf_rmin'
      CHARACTER (len=*), PARAMETER :: nc_rmax = 'mddc_mrf_rmax'
      CHARACTER (len=*), PARAMETER :: nc_zmin = 'mddc_mrf_zmin'
      CHARACTER (len=*), PARAMETER :: nc_zmax = 'mddc_mrf_zmax'
      CHARACTER (len=*), PARAMETER :: nc_n_field_periods =                     &
     &   'mddc_mrf_n_field_periods'
 
      CHARACTER (len=*), PARAMETER :: nc_stell_sym =                           &
     &   'mddc_mrf_lstell_sym'
 
      CHARACTER (len=*), PARAMETER :: nc_a_r = 'mddc_mrf_a_r'
      CHARACTER (len=*), PARAMETER :: nc_a_f = 'mddc_mrf_a_f'
      CHARACTER (len=*), PARAMETER :: nc_a_z = 'mddc_mrf_a_z'
 
!  Conducting Shell Response Arrays --------------------------------------------
      CHARACTER (len=*), PARAMETER :: nc_use_shell =                           &
     &   'mddc_mrf_use_con_shell'
      CHARACTER (len=*), PARAMETER :: nc_num_t_shell =                         &
     &   'mddc_mrf_kp_shell'
 
      CHARACTER (len=*), PARAMETER :: nc_a_s_r = 'mddc_mrf_a_s_r'
      CHARACTER (len=*), PARAMETER :: nc_a_s_f = 'mddc_mrf_a_s_f'
      CHARACTER (len=*), PARAMETER :: nc_a_s_z = 'mddc_mrf_a_s_z'
 
!  Point Diagnostic ------------------------------------------------------------
      CHARACTER (len=*), PARAMETER :: nc_position =                            &
     &   'mddc_mrf_position'
      CHARACTER (len=*), PARAMETER :: nc_direction =                           &
     &   'mddc_mrf_direction'
 
!*******************************************************************************
!  DERIVED-TYPE DECLARATIONS
!  1) magnetic base class
!
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      TYPE magnetic_response_class
         INTEGER                               :: flags
 
!  Identification Variables ----------------------------------------------------
         CHARACTER (len=magnetic_response_len) :: name
         CHARACTER (len=magnetic_response_len) :: version
         CHARACTER (len=magnetic_response_len) :: date
         CHARACTER (len=magnetic_response_len) :: coil_id
 
!  Coil Responce Function Variables --------------------------------------------
         INTEGER                             :: n_field_cg
         REAL (rprec), DIMENSION(:), POINTER :: inductance => null()
         REAL (rprec), DIMENSION(:), POINTER :: current_scale => null()
 
!  Plasma Response Grid Variables ----------------------------------------------
         INTEGER                            :: num_t
         REAL (rprec)                       :: rmin
         REAL (rprec)                       :: rmax
         REAL (rprec)                       :: zmin
         REAL (rprec)                       :: zmax
 
         INTEGER                            :: n_field_periods
 
         INTEGER                            :: num_t_shell
 
!  Plasma Response Arrays ------------------------------------------------------
         TYPE (compression_pointer), DIMENSION(:), POINTER ::                  &
     &      a_r => null()
         TYPE (compression_pointer), DIMENSION(:), POINTER ::                  &
     &      a_f => null()
         TYPE (compression_pointer), DIMENSION(:), POINTER ::                  &
     &      a_z => null()
 
!  Conducting Shell Response Arrays --------------------------------------------
         TYPE (compression_class), POINTER :: a_s_r => null()
         TYPE (compression_class), POINTER :: a_s_f => null()
         TYPE (compression_class), POINTER :: a_s_z => null()
 
!  Point Diagnostic Response ---------------------------------------------------
!  Use the mutual inductance array to store the vacuum field response.
         REAL (rprec), DIMENSION(3) :: position
         REAL (rprec), DIMENSION(3) :: direction
      END TYPE
 
!*******************************************************************************
!  INTERFACE BLOCKS
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE magnetic_response_construct
         MODULE PROCEDURE magnetic_response_construct_new,                     &
     &                    magnetic_response_construct_point,                   &
     &                    magnetic_response_construct_netcdf
      END INTERFACE
 
      CONTAINS
!*******************************************************************************
!  CONSTRUCTION SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION magnetic_response_construct_new(name, date,                     &
     &                                         coil_id, inductance,            &
     &                                         current_scale,                  &
     &                                         num_t, num_t_shell,             &
     &                                         rmin, rmax, zmin, zmax,         &
     &                                         n_field_periods,                &
     &                                         stell_sym, a_r, a_f, a_z,       &
     &                                         a_s_r, a_s_f, a_s_z,            &
     &                                         svd_cut_off)
      USE v3_utilities
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (magnetic_response_class), POINTER                                  &
     &   :: magnetic_response_construct_new
      CHARACTER (len=*), INTENT(in)           :: name
      CHARACTER (len=*), INTENT(in)           :: date
      CHARACTER (len=*), INTENT(in)           :: coil_id
      REAL (rprec), DIMENSION(:), POINTER     :: inductance
      REAL (rprec), DIMENSION(:), POINTER     :: current_scale
      INTEGER, INTENT(in)                     :: num_t
      INTEGER, INTENT(in)                     :: num_t_shell
      REAL (rprec), INTENT(in)                :: rmin
      REAL (rprec), INTENT(in)                :: rmax
      REAL (rprec), INTENT(in)                :: zmin
      REAL (rprec), INTENT(in)                :: zmax
      INTEGER, INTENT(in)                     :: n_field_periods
      LOGICAL, INTENT(in)                     :: stell_sym
      REAL (rprec), DIMENSION(:,:,:), POINTER :: a_r
      REAL (rprec), DIMENSION(:,:,:), POINTER :: a_f
      REAL (rprec), DIMENSION(:,:,:), POINTER :: a_z
      REAL (rprec), DIMENSION(:,:), POINTER   :: a_s_r
      REAL (rprec), DIMENSION(:,:), POINTER   :: a_s_f
      REAL (rprec), DIMENSION(:,:), POINTER   :: a_s_z
      REAL (rprec), INTENT(in)                :: svd_cut_off
 
!  local variables
      INTEGER                                 :: phi
      REAL (rprec)                            :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      ALLOCATE(magnetic_response_construct_new)
 
      magnetic_response_construct_new%flags = 0
 
!  Identification Variables ----------------------------------------------------
      magnetic_response_construct_new%name = name
      magnetic_response_construct_new%version =                                &
     &   magnetic_response_current
      magnetic_response_construct_new%date = date
      magnetic_response_construct_new%coil_id = coil_id
 
!  Coil Responce Function Variables --------------------------------------------
      IF (ASSOCIATED(inductance)) THEN
         magnetic_response_construct_new%flags =                               &
     &      ibset(magnetic_response_construct_new%flags,                       &
     &            magnetic_response_use_coil_flag)
 
         ALLOCATE(magnetic_response_construct_new%inductance(                  &
     &               SIZE(inductance)))
         magnetic_response_construct_new%inductance = inductance
         magnetic_response_construct_new%n_field_cg = SIZE(inductance)
      END IF
 
      IF (ASSOCIATED(current_scale)) THEN
         ALLOCATE(magnetic_response_construct_new%current_scale(               &
     &               SIZE(current_scale)))
         magnetic_response_construct_new%current_scale = current_scale
      END IF
 
!  Plasma Response Grid Variables ----------------------------------------------
      magnetic_response_construct_new%num_t = num_t
      magnetic_response_construct_new%num_t_shell = num_t_shell
      magnetic_response_construct_new%rmin = rmin
      magnetic_response_construct_new%rmax = rmax
      magnetic_response_construct_new%zmin = zmin
      magnetic_response_construct_new%zmax = zmax
      magnetic_response_construct_new%n_field_periods = n_field_periods
 
      IF (stell_sym) THEN
         magnetic_response_construct_new%flags =                               &
     &      ibset(magnetic_response_construct_new%flags,                       &
     &            magnetic_response_stell_sym_flag)
      END IF
 
!  Plasma Response Arrays ------------------------------------------------------
      IF (ASSOCIATED(a_r)) THEN
         magnetic_response_construct_new%flags =                               &
     &      ibset(magnetic_response_construct_new%flags,                       &
     &            magnetic_response_use_plasma_flag)
 
         CALL assert(ASSOCIATED(a_f), 'a_f response function not ' //          &
     &                                'allocated')
         CALL assert(ASSOCIATED(a_z), 'a_z response function not ' //          &
     &                                'allocated')
 
         ALLOCATE(magnetic_response_construct_new%a_r(SIZE(a_r, 3)))
         ALLOCATE(magnetic_response_construct_new%a_f(SIZE(a_r, 3)))
         ALLOCATE(magnetic_response_construct_new%a_z(SIZE(a_r, 3)))
 
         DO phi = 1, SIZE(a_r, 3)
            magnetic_response_construct_new%a_r(phi)%p =>                      &
     &         compression_construct(a_r(:,:,phi), svd_cut_off)
            magnetic_response_construct_new%a_f(phi)%p =>                      &
     &         compression_construct(a_f(:,:,phi), svd_cut_off)
            magnetic_response_construct_new%a_z(phi)%p =>                      &
     &         compression_construct(a_z(:,:,phi), svd_cut_off)
         END DO
      END IF
 
!  Conducting Shell Response Arrays --------------------------------------------
      IF (ASSOCIATED(a_s_r)) THEN
         magnetic_response_construct_new%flags =                               &
     &      ibset(magnetic_response_construct_new%flags,                       &
     &            magnetic_response_use_shell_flag)
 
         CALL assert(ASSOCIATED(a_s_f), 'a_s_f response function ' //          &
     &                                  'not allocated')
         CALL assert(ASSOCIATED(a_s_z), 'a_s_z response function ' //          &
     &                                  'not allocated')
 
         magnetic_response_construct_new%a_s_r =>                              &
     &      compression_construct(a_s_r, svd_cut_off)
         magnetic_response_construct_new%a_s_f =>                              &
     &      compression_construct(a_s_f, svd_cut_off)
         magnetic_response_construct_new%a_s_z =>                              &
     &      compression_construct(a_s_z, svd_cut_off)
      END IF
 
      CALL profiler_set_stop_time('magnetic_response_construct_new',           &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION magnetic_response_construct_point(name, date,                   &
     &                                           coil_id, position,            &
     &                                           direction, vacuum,            &
     &                                           current_scale)
      USE v3_utilities
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (magnetic_response_class), POINTER                                  &
     &   :: magnetic_response_construct_point
      CHARACTER (len=*), INTENT(in)       :: name
      CHARACTER (len=*), INTENT(in)       :: date
      CHARACTER (len=*), INTENT(in)       :: coil_id
      REAL (rprec), DIMENSION(3)          :: position
      REAL (rprec), DIMENSION(3)          :: direction
      REAL (rprec), DIMENSION(:), POINTER :: vacuum
      REAL (rprec), DIMENSION(:), POINTER :: current_scale
 
!  local variables
      REAL (rprec)                            :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      ALLOCATE(magnetic_response_construct_point)
 
      magnetic_response_construct_point%flags = 0
 
      magnetic_response_construct_point%flags =                                &
     &   ibset(magnetic_response_construct_point%flags,                        &
     &         magnetic_response_is_point_flag)
 
!  Identification Variables ----------------------------------------------------
      magnetic_response_construct_point%name = name
      magnetic_response_construct_point%version =                              &
     &   magnetic_response_current
      magnetic_response_construct_point%date = date
      magnetic_response_construct_point%coil_id = coil_id
 
!  Geometric Variables ---------------------------------------------------------
      magnetic_response_construct_point%position = position
      magnetic_response_construct_point%direction = direction
 
!  Coil Responce Function Variables --------------------------------------------
      IF (ASSOCIATED(vacuum)) THEN
         magnetic_response_construct_point%flags =                             &
     &      ibset(magnetic_response_construct_point%flags,                     &
     &            magnetic_response_use_coil_flag)
 
         ALLOCATE(magnetic_response_construct_point%inductance(                &
     &               SIZE(vacuum)))
         magnetic_response_construct_point%inductance = vacuum
         magnetic_response_construct_point%n_field_cg = SIZE(vacuum)
      END IF
 
      IF (ASSOCIATED(current_scale)) THEN
         ALLOCATE(magnetic_response_construct_point%current_scale(             &
     &               SIZE(current_scale)))
         magnetic_response_construct_point%current_scale = current_scale
      END IF
 
      CALL profiler_set_stop_time('magnetic_response_construct_point',         &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION magnetic_response_construct_netcdf(mdsig_iou,                   &
     &                                            svd_cut_off)
      USE ezcdf
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (magnetic_response_class), POINTER ::                               &
     &   magnetic_response_construct_netcdf
      INTEGER, INTENT(in)                        :: mdsig_iou
      REAL (rprec), INTENT(in)                   :: svd_cut_off
 
!  local variables
      REAL(rprec), DIMENSION(:,:,:), ALLOCATABLE :: temp_buffer
      LOGICAL                                    :: temp_logical
      INTEGER, DIMENSION(3)                      :: dim_lengths
      INTEGER                                    :: phi
      REAL (rprec)                               :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      ALLOCATE(magnetic_response_construct_netcdf)
 
!  Identification Variables ----------------------------------------------------
      CALL cdf_read(mdsig_iou, nc_name,                                        &
     &              magnetic_response_construct_netcdf%name)
      CALL cdf_read(mdsig_iou, nc_version,                                     &
     &              magnetic_response_construct_netcdf%version)
      CALL cdf_read(mdsig_iou, nc_date,                                        &
     &              magnetic_response_construct_netcdf%date)
      CALL cdf_read(mdsig_iou, nc_coil_id,                                     &
     &              magnetic_response_construct_netcdf%coil_id)
 
!  Check the version code verison. If the version is 'MRC 2015-04-27' or later,
!  there is a flag variable that indicates the contents of the file.
      magnetic_response_construct_netcdf%flags = 0
 
      SELECT CASE (trim(magnetic_response_construct_netcdf%version))
 
         CASE (magnetic_response_current)
!  This version adds the new point diagnostic. The format of the netcdf mdsig
!  file has been modified to hold bit packed flags to determine what is or isn't
!  present in the netcdf file.
            CALL cdf_read(mdsig_iou, nc_flags,                                 &
     &                    magnetic_response_construct_netcdf%flags)
 
         CASE (magnetic_response_20140928)
!  This version added the option for a coducting shell. Options were stored as
!  logicals.
            CALL cdf_read(mdsig_iou, nc_use_shell, temp_logical)
            IF (temp_logical) THEN
               magnetic_response_construct_netcdf%flags =                      &
     &            ibset(magnetic_response_construct_netcdf%flags,              &
     &                  magnetic_response_use_shell_flag)
            END IF
 
            CALL cdf_read(mdsig_iou, nc_stell_sym, temp_logical)
            IF (temp_logical) THEN
               magnetic_response_construct_netcdf%flags =                      &
     &            ibset(magnetic_response_construct_netcdf%flags,              &
     &                  magnetic_response_stell_sym_flag)
            END IF
 
!  The mutual inductance and plasma response are expected.
            magnetic_response_construct_netcdf%flags =                         &
     &         ibset(magnetic_response_construct_netcdf%flags,                 &
     &               magnetic_response_use_coil_flag)
 
            magnetic_response_construct_netcdf%flags =                         &
     &         ibset(magnetic_response_construct_netcdf%flags,                 &
     &               magnetic_response_use_plasma_flag)
 
         CASE DEFAULT
!  This is the orginal format. Options were stored as logicals.
            CALL cdf_read(mdsig_iou, nc_stell_sym, temp_logical)
            IF (temp_logical) THEN
               magnetic_response_construct_netcdf%flags =                      &
     &            ibset(magnetic_response_construct_netcdf%flags,              &
     &                  magnetic_response_stell_sym_flag)
            END IF
 
!  The mutual inductance and plasma response are expected.
            magnetic_response_construct_netcdf%flags =                         &
     &         ibset(magnetic_response_construct_netcdf%flags,                 &
     &               magnetic_response_use_coil_flag)
 
            magnetic_response_construct_netcdf%flags =                         &
     &         ibset(magnetic_response_construct_netcdf%flags,                 &
     &               magnetic_response_use_plasma_flag)
 
      END SELECT
 
!  Coil Responce Function Variables --------------------------------------------
      IF (btest(magnetic_response_construct_netcdf%flags,                      &
     &          magnetic_response_use_coil_flag)) THEN
         CALL cdf_read(mdsig_iou, nc_n_field_cg,                               &
     &                 magnetic_response_construct_netcdf%n_field_cg)
 
         ALLOCATE(magnetic_response_construct_netcdf%inductance(               &
     &               magnetic_response_construct_netcdf%n_field_cg))
         CALL cdf_read(mdsig_iou, nc_inductance,                               &
     &                 magnetic_response_construct_netcdf%inductance)
 
         ALLOCATE(magnetic_response_construct_netcdf%current_scale(            &
     &               magnetic_response_construct_netcdf%n_field_cg))
         CALL cdf_read(mdsig_iou, nc_current_scale,                            &
     &                 magnetic_response_construct_netcdf%current_scale)
      END IF
 
!  Plasma Response Grid Variables ----------------------------------------------
      IF (btest(magnetic_response_construct_netcdf%flags,                      &
     &          magnetic_response_use_plasma_flag)) THEN
         CALL cdf_read(mdsig_iou, nc_num_t,                                    &
     &                 magnetic_response_construct_netcdf%num_t)
         CALL cdf_read(mdsig_iou, nc_rmin,                                     &
     &                 magnetic_response_construct_netcdf%rmin)
         CALL cdf_read(mdsig_iou, nc_rmax,                                     &
     &                 magnetic_response_construct_netcdf%rmax)
         CALL cdf_read(mdsig_iou, nc_zmin,                                     &
     &                 magnetic_response_construct_netcdf%zmin)
         CALL cdf_read(mdsig_iou, nc_zmax,                                     &
     &                 magnetic_response_construct_netcdf%zmax)
         CALL cdf_read(mdsig_iou, nc_n_field_periods,                          &
     &           magnetic_response_construct_netcdf%n_field_periods)
 
         CALL cdf_inquire(mdsig_iou, nc_a_r, dim_lengths)
         ALLOCATE(temp_buffer(dim_lengths(1),                                  &
     &                        dim_lengths(2),                                  &
     &                        dim_lengths(3)))
 
         CALL cdf_read(mdsig_iou, nc_a_r, temp_buffer)
         ALLOCATE(magnetic_response_construct_netcdf%a_r(                      &
     &               dim_lengths(3)))
         DO phi = 1, dim_lengths(3)
            magnetic_response_construct_netcdf%a_r(phi)%p =>                   &
     &         compression_construct(temp_buffer(:,:,phi), svd_cut_off)
         END DO
 
         CALL cdf_read(mdsig_iou, nc_a_f, temp_buffer)
         ALLOCATE(magnetic_response_construct_netcdf%a_f(                      &
     &               dim_lengths(3)))
         DO phi = 1, dim_lengths(3)
            magnetic_response_construct_netcdf%a_f(phi)%p =>                   &
     &         compression_construct(temp_buffer(:,:,phi), svd_cut_off)
         END DO
 
         CALL cdf_read(mdsig_iou, nc_a_z, temp_buffer)
         ALLOCATE(magnetic_response_construct_netcdf%a_z(                      &
     &               dim_lengths(3)))
         DO phi = 1, dim_lengths(3)
            magnetic_response_construct_netcdf%a_z(phi)%p =>                   &
     &         compression_construct(temp_buffer(:,:,phi), svd_cut_off)
         END DO
 
         DEALLOCATE(temp_buffer)
      END IF
 
!  Conducting Shell Response Arrays --------------------------------------------
      IF (btest(magnetic_response_construct_netcdf%flags,                      &
     &          magnetic_response_use_shell_flag)) THEN
         CALL cdf_read(mdsig_iou, nc_num_t_shell,                              &
     &                 magnetic_response_construct_netcdf%num_t_shell)
 
         CALL cdf_inquire(mdsig_iou, nc_a_s_r, dim_lengths(1:2))
         ALLOCATE(temp_buffer(1,dim_lengths(1),dim_lengths(2)))
 
         CALL cdf_read(mdsig_iou, nc_a_s_r, temp_buffer(1,:,:))
         magnetic_response_construct_netcdf%a_s_r =>                           &
     &      compression_construct(temp_buffer(1,:,:), svd_cut_off)
 
         CALL cdf_read(mdsig_iou, nc_a_s_f, temp_buffer(1,:,:))
         magnetic_response_construct_netcdf%a_s_f =>                           &
     &      compression_construct(temp_buffer(1,:,:), svd_cut_off)
 
         CALL cdf_read(mdsig_iou, nc_a_s_z, temp_buffer(1,:,:))
         magnetic_response_construct_netcdf%a_s_z =>                           &
     &      compression_construct(temp_buffer(1,:,:), svd_cut_off)
 
         DEALLOCATE(temp_buffer)
      END IF
 
!  Point Diagnostic Response ---------------------------------------------------
      IF (btest(magnetic_response_construct_netcdf%flags,                      &
     &          magnetic_response_is_point_flag)) THEN
         CALL cdf_read(mdsig_iou, nc_position,                                 &
     &                 magnetic_response_construct_netcdf%position)
 
         CALL cdf_read(mdsig_iou, nc_direction,                                &
     &                 magnetic_response_construct_netcdf%direction)
      END IF
 
      CALL profiler_set_stop_time('magnetic_response_construct_netcdf',        &
     &                            start_time)
 
      END FUNCTION
 
!*******************************************************************************
!  DESTRUCTION SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE magnetic_response_destruct(this)
 
!  Declare Arguments
      TYPE (magnetic_response_class), POINTER :: this
 
!  local variables
      INTEGER                                 :: phi
 
!  Start of executable code
      IF (ASSOCIATED(this%inductance)) THEN
         DEALLOCATE(this%inductance)
         this%inductance => null()
      END IF
 
      IF (ASSOCIATED(this%current_scale)) THEN
         DEALLOCATE(this%current_scale)
         this%current_scale => null()
      END IF
 
      IF (ASSOCIATED(this%a_r)) THEN
         DO phi = 1, SIZE(this%a_r)
            CALL compression_destruct(this%a_r(phi)%p)
         END DO
         DEALLOCATE(this%a_r)
         this%a_r => null()
      END IF
 
      IF (ASSOCIATED(this%a_f)) THEN
         DO phi = 1, SIZE(this%a_f)
            CALL compression_destruct(this%a_f(phi)%p)
         END DO
         DEALLOCATE(this%a_f)
         this%a_f => null()
      END IF
 
      IF (ASSOCIATED(this%a_z)) THEN
         DO phi = 1, SIZE(this%a_z)
            CALL compression_destruct(this%a_z(phi)%p)
         END DO
         DEALLOCATE(this%a_z)
         this%a_z => null()
      END IF
 
      IF (ASSOCIATED(this%a_s_r)) THEN
         CALL compression_destruct(this%a_s_r)
         this%a_s_r => null()
      END IF
 
      IF (ASSOCIATED(this%a_s_f)) THEN
         CALL compression_destruct(this%a_s_f)
         this%a_s_f => null()
      END IF
 
      IF (ASSOCIATED(this%a_s_z)) THEN
         CALL compression_destruct(this%a_s_z)
         this%a_s_z => null()
      END IF
 
      DEALLOCATE(this)
 
      END SUBROUTINE
 
!*******************************************************************************
!  QUERY SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION magnetic_response_is_stell_sym(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: magnetic_response_is_stell_sym
      TYPE (magnetic_response_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                               :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      magnetic_response_is_stell_sym =                                         &
     &   btest(this%flags, magnetic_response_stell_sym_flag)
 
      CALL profiler_set_stop_time('magnetic_response_is_stell_sym',            &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION magnetic_response_use_plasma(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: magnetic_response_use_plasma
      TYPE (magnetic_response_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                               :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      magnetic_response_use_plasma =                                           &
     &   btest(this%flags, magnetic_response_use_plasma_flag)
 
      CALL profiler_set_stop_time('magnetic_response_use_plasma',              &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION magnetic_response_use_shell(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: magnetic_response_use_shell
      TYPE (magnetic_response_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                               :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      magnetic_response_use_shell =                                            &
     &   btest(this%flags, magnetic_response_use_shell_flag)
 
      CALL profiler_set_stop_time('magnetic_response_use_shell',               &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION magnetic_response_use_coil(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: magnetic_response_use_coil
      TYPE (magnetic_response_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                               :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      magnetic_response_use_coil =                                             &
     &   btest(this%flags, magnetic_response_use_coil_flag)
 
      CALL profiler_set_stop_time('magnetic_response_use_coil',                &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE magnetic_response_clr_use_coil(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (magnetic_response_class), INTENT(inout) :: this
 
!  local variables
      REAL (rprec)                                  :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      this%flags = ibclr(this%flags, magnetic_response_use_coil_flag)
 
      CALL profiler_set_stop_time('magnetic_response_clr_use_coil',            &
     &                            start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION magnetic_response_is_point(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: magnetic_response_is_point
      TYPE (magnetic_response_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                               :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      magnetic_response_is_point =                                             &
     &   btest(this%flags, magnetic_response_is_point_flag)
 
      CALL profiler_set_stop_time('magnetic_response_is_point',                &
     &                            start_time)
 
      END FUNCTION
 
!*******************************************************************************
!  NETCDF SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE magnetic_response_define(this, mdsig_iou)
      USE ezcdf
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (magnetic_response_class), INTENT(in)  :: this
      INTEGER, INTENT(in)                         :: mdsig_iou
 
!  local variables
      REAL (rprec), DIMENSION(:,:,:), ALLOCATABLE :: temp_buffer
      INTEGER                                     :: phi
      REAL (rprec)                                :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
!  Define Variables ------------------------------------------------------------
      CALL cdf_define(mdsig_iou, nc_flags, this%flags)
 
!  Identification Variables ----------------------------------------------------
      CALL cdf_define(mdsig_iou, nc_name, this%name)
      CALL cdf_define(mdsig_iou, nc_version, this%version)
      CALL cdf_define(mdsig_iou, nc_date, this%date)
      CALL cdf_define(mdsig_iou, nc_coil_id, this%coil_id)
 
!  Coil Responce Function Variables --------------------------------------------
      IF (btest(this%flags, magnetic_response_use_coil_flag)) THEN
         CALL cdf_define(mdsig_iou, nc_n_field_cg, this%n_field_cg)
         CALL cdf_define(mdsig_iou, nc_inductance, this%inductance)
         CALL cdf_define(mdsig_iou, nc_current_scale,                          &
     &                   this%current_scale)
      END IF
 
!  Plasma Response Grid Variables ----------------------------------------------
      IF (btest(this%flags, magnetic_response_use_plasma_flag)) THEN
         CALL cdf_define(mdsig_iou, nc_num_t, this%num_t)
         CALL cdf_define(mdsig_iou, nc_rmin, this%rmin)
         CALL cdf_define(mdsig_iou, nc_rmax, this%rmax)
         CALL cdf_define(mdsig_iou, nc_zmin, this%zmin)
         CALL cdf_define(mdsig_iou, nc_zmax, this%zmax)
         CALL cdf_define(mdsig_iou, nc_n_field_periods,                        &
     &                   this%n_field_periods)
 
!  Decompress a single response function phi plane to get the r z dimensions.
!  Then define the netcdf variables based off a temp buffer. All response
!  function directions should have the same dimensions.
         ALLOCATE(temp_buffer(compression_get_dimension1(this%a_r(1)%p),       &
     &                        compression_get_dimension2(this%a_r(1)%p),       &
     &                        SIZE(this%a_r)))
 
         CALL cdf_define(mdsig_iou, nc_a_r, temp_buffer)
         CALL cdf_define(mdsig_iou, nc_a_f, temp_buffer)
         CALL cdf_define(mdsig_iou, nc_a_z, temp_buffer)
 
         DEALLOCATE(temp_buffer)
      END IF
 
!  Conducting Shell Response Arrays --------------------------------------------
      IF (btest(this%flags, magnetic_response_use_shell_flag)) THEN
         CALL cdf_define(mdsig_iou, nc_num_t_shell, this%num_t_shell)
 
!  Decompress a single conducting shell response function phi plane to get the
!  data buffer. All shell response function directions should have the same
!  dimensions.
         ALLOCATE(temp_buffer(1,                                               &
     &               compression_get_dimension1(this%a_s_r),                   &
     &               compression_get_dimension2(this%a_s_r)))
 
         CALL cdf_define(mdsig_iou, nc_a_s_r, temp_buffer(1,:,:))
         CALL cdf_define(mdsig_iou, nc_a_s_f, temp_buffer(1,:,:))
         CALL cdf_define(mdsig_iou, nc_a_s_z, temp_buffer(1,:,:))
 
         DEALLOCATE(temp_buffer)
      END IF
 
!  Point Diagnostic Response ---------------------------------------------------
      IF (btest(this%flags, magnetic_response_is_point_flag)) THEN
         CALL cdf_define(mdsig_iou, nc_position, this%position)
         CALL cdf_define(mdsig_iou, nc_direction, this%direction)
      END IF
 
      CALL profiler_set_stop_time('magnetic_response_define',                  &
     &                            start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE magnetic_response_write(this, mdsig_iou)
      USE ezcdf
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (magnetic_response_class), INTENT(in)  :: this
      INTEGER, INTENT(in)                         :: mdsig_iou
 
!  local variables
      REAL (rprec), DIMENSION(:,:,:), ALLOCATABLE :: temp_buffer
      INTEGER                                     :: phi
      REAL (rprec)                                :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
!  Define Variables ------------------------------------------------------------
      CALL cdf_write(mdsig_iou, nc_flags, this%flags)
 
!  Identification Variables ----------------------------------------------------
      CALL cdf_write(mdsig_iou, nc_name, this%name)
      CALL cdf_write(mdsig_iou, nc_version, this%version)
      CALL cdf_write(mdsig_iou, nc_date, this%date)
      CALL cdf_write(mdsig_iou, nc_coil_id, this%coil_id)
 
!  Coil Responce Function Variables --------------------------------------------
      IF (btest(this%flags, magnetic_response_use_coil_flag)) THEN
         CALL cdf_write(mdsig_iou, nc_n_field_cg, this%n_field_cg)
         CALL cdf_write(mdsig_iou, nc_inductance, this%inductance)
         CALL cdf_write(mdsig_iou, nc_current_scale, this%current_scale)
      END IF
 
!  Plasma Response Grid Variables ----------------------------------------------
      IF (btest(this%flags, magnetic_response_use_plasma_flag)) THEN
         CALL cdf_write(mdsig_iou, nc_num_t, this%num_t)
         CALL cdf_write(mdsig_iou, nc_rmin, this%rmin)
         CALL cdf_write(mdsig_iou, nc_rmax, this%rmax)
         CALL cdf_write(mdsig_iou, nc_zmin, this%zmin)
         CALL cdf_write(mdsig_iou, nc_zmax, this%zmax)
         CALL cdf_write(mdsig_iou, nc_n_field_periods,                         &
     &                  this%n_field_periods)
 
!  Need to decompress all the response function planes to and write the data
!  buffers to a temp buffer. Decompress the r direction first to get the r z
!  dimensions to allocate the temp buffer.
         CALL compression_decompress(this%a_r(1)%p)
         ALLOCATE(temp_buffer(SIZE(this%a_r(1)%p%data_buffer, 1),              &
     &                        SIZE(this%a_r(1)%p%data_buffer, 2),              &
     &                        SIZE(this%a_r)))
 
         temp_buffer(:,:,1) = this%a_r(1)%p%data_buffer
         CALL compression_cleanup(this%a_r(1)%p)
         DO phi = 2, SIZE(this%a_r)
            CALL compression_decompress(this%a_r(phi)%p)
            temp_buffer(:,:,phi) = this%a_r(phi)%p%data_buffer
            CALL compression_cleanup(this%a_r(phi)%p)
         END DO
         CALL cdf_write(mdsig_iou, nc_a_r, temp_buffer)
 
         DO phi = 1, SIZE(this%a_f)
            CALL compression_decompress(this%a_f(phi)%p)
            temp_buffer(:,:,phi) = this%a_f(phi)%p%data_buffer
            CALL compression_cleanup(this%a_f(phi)%p)
         END DO
         CALL cdf_write(mdsig_iou, nc_a_f, temp_buffer)
 
         DO phi = 1, SIZE(this%a_z)
            CALL compression_decompress(this%a_z(phi)%p)
            temp_buffer(:,:,phi) = this%a_z(phi)%p%data_buffer
            CALL compression_cleanup(this%a_z(phi)%p)
         END DO
         CALL cdf_write(mdsig_iou, nc_a_z, temp_buffer)
 
         DEALLOCATE(temp_buffer)
      END IF
 
!  Conducting Shell Response Arrays --------------------------------------------
      IF (btest(this%flags, magnetic_response_use_shell_flag)) THEN
         CALL cdf_write(mdsig_iou, nc_num_t_shell, this%num_t_shell)
 
!  Decompress each shell response function direction then write the data buffer.
         CALL compression_decompress(this%a_s_r)
         CALL cdf_write(mdsig_iou, nc_a_s_r, this%a_s_r%data_buffer)
         CALL compression_cleanup(this%a_s_r)
 
         CALL compression_decompress(this%a_s_f)
         CALL cdf_write(mdsig_iou, nc_a_s_f, this%a_s_f%data_buffer)
         CALL compression_cleanup(this%a_s_f)
 
         CALL compression_decompress(this%a_s_z)
         CALL cdf_write(mdsig_iou, nc_a_s_z, this%a_s_z%data_buffer)
         CALL compression_cleanup(this%a_s_z)
      END IF
 
!  Point Diagnostic Response ---------------------------------------------------
      IF (btest(this%flags, magnetic_response_is_point_flag)) THEN
         CALL cdf_write(mdsig_iou, nc_position, this%position)
         CALL cdf_write(mdsig_iou, nc_direction, this%direction)
      END IF
 
      CALL profiler_set_stop_time('magnetic_response_write', start_time)
 
      END SUBROUTINE
 
      END MODULE