equilibrium.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 equilibrium
      USE vacuum_equilibrium
      USE siesta_equilibrium
 
      IMPLICIT NONE
 
!*******************************************************************************
!  equilibrium module parameters
!*******************************************************************************
      INTEGER, PARAMETER :: equilibrium_no_type     = -1
      INTEGER, PARAMETER :: equilibrium_vmec_type   = 0
      INTEGER, PARAMETER :: equilibrium_vacuum_type = 1
      INTEGER, PARAMETER :: equilibrium_siesta_type = 2
 
!*******************************************************************************
!  DERIVED-TYPE DECLARATIONS
!  1) equilibrium base class
!
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      TYPE equilibrium_class
         INTEGER                      :: type = equilibrium_no_type
         LOGICAL                      :: force_solve
         TYPE (vmec_class), POINTER   :: vmec => null()
         TYPE (vacuum_class), POINTER :: vacuum => null()
         TYPE (siesta_class), POINTER :: siesta => null()
      END TYPE
 
!*******************************************************************************
!  INTERFACE BLOCKS
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_construct
         MODULE PROCEDURE equilibrium_construct_vmec,                          &
     &                    equilibrium_construct_vacuum,                        &
     &                    equilibrium_construct_siesta
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_set_magnetic_cache
         MODULE PROCEDURE equilibrium_set_magnetic_cache_response,             &
     &                    equilibrium_set_magnetic_cache_point
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_ne
         MODULE PROCEDURE equilibrium_get_ne_cart,                             &
     &                    equilibrium_get_ne_radial
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_gp_ne
         MODULE PROCEDURE equilibrium_get_gp_ne_ij,                            &
     &                    equilibrium_get_gp_ne_pi,                            &
     &                    equilibrium_get_gp_ne_pp
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_te
         MODULE PROCEDURE equilibrium_get_te_cart,                             &
     &                    equilibrium_get_te_radial
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_gp_te
         MODULE PROCEDURE equilibrium_get_gp_te_ij,                            &
     &                    equilibrium_get_gp_te_pi,                            &
     &                    equilibrium_get_gp_te_pp
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_ti
         MODULE PROCEDURE equilibrium_get_ti_cart,                             &
     &                    equilibrium_get_ti_radial
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_gp_ti
         MODULE PROCEDURE equilibrium_get_gp_ti_ij,                            &
     &                    equilibrium_get_gp_ti_pi,                            &
     &                    equilibrium_get_gp_ti_pp
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_ze
         MODULE PROCEDURE equilibrium_get_ze_cart,                             &
     &                    equilibrium_get_ze_radial
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_sxrem
         MODULE PROCEDURE equilibrium_get_sxrem_cart,                          &
     &                    equilibrium_get_sxrem_radial
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_gp_sxrem
         MODULE PROCEDURE equilibrium_get_gp_sxrem_ij,                         &
     &                    equilibrium_get_gp_sxrem_pi,                         &
     &                    equilibrium_get_gp_sxrem_pp
      END INTERFACE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      INTERFACE equilibrium_get_p
         MODULE PROCEDURE equilibrium_get_p_cart,                              &
     &                    equilibrium_get_p_radial
      END INTERFACE
 
      CONTAINS
!*******************************************************************************
!  CONSTRUCTION SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_construct_vmec(vmec_object, force_solve)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), POINTER :: equilibrium_construct_vmec
      TYPE (vmec_class), POINTER        :: vmec_object
      LOGICAL, INTENT(in)               :: force_solve
 
!  local variables
      REAL (rprec)                      :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      ALLOCATE(equilibrium_construct_vmec)
 
      equilibrium_construct_vmec%type = equilibrium_vmec_type
      equilibrium_construct_vmec%vmec => vmec_object
      equilibrium_construct_vmec%force_solve = force_solve
 
      CALL profiler_set_stop_time('equilibrium_construct_vmec',                &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_construct_vacuum(vacuum_object, force_solve)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), POINTER :: equilibrium_construct_vacuum
      TYPE (vacuum_class), POINTER      :: vacuum_object
      LOGICAL, INTENT(in)               :: force_solve
 
!  local variables
      REAL (rprec)                      :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      ALLOCATE(equilibrium_construct_vacuum)
 
      equilibrium_construct_vacuum%type = equilibrium_vacuum_type
      equilibrium_construct_vacuum%vacuum => vacuum_object
      equilibrium_construct_vacuum%force_solve = force_solve
 
      CALL profiler_set_stop_time('equilibrium_construct_vacuum',              &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_construct_siesta(siesta_object, force_solve)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), POINTER :: equilibrium_construct_siesta
      TYPE (siesta_class), POINTER      :: siesta_object
      LOGICAL, INTENT(in)               :: force_solve
 
!  local variables
      REAL (rprec)                      :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      ALLOCATE(equilibrium_construct_siesta)
 
      equilibrium_construct_siesta%type = equilibrium_siesta_type
      equilibrium_construct_siesta%siesta => siesta_object
      equilibrium_construct_siesta%force_solve = force_solve
 
      CALL profiler_set_stop_time('equilibrium_construct_siesta',              &
     &                            start_time)
 
      END FUNCTION
 
!*******************************************************************************
!  DESTRUCTION SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_destruct(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), POINTER :: this
 
!  Start of executable code
      IF (ASSOCIATED(this%vmec)) THEN
         CALL vmec_destruct(this%vmec)
         this%vmec => null()
      END IF
 
      IF (ASSOCIATED(this%vacuum)) THEN
         CALL vacuum_destruct(this%vacuum)
         this%vacuum => null()
      END IF
 
      IF (ASSOCIATED(this%siesta)) THEN
         CALL siesta_destruct(this%siesta)
         this%siesta => null()
      END IF
 
      this%type = equilibrium_no_type
      this%force_solve = .false.
 
      DEALLOCATE(this)
 
      END SUBROUTINE
 
!*******************************************************************************
!  SETTER SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_set_param(this, id, i_index, j_index,             &
     &                                 value, eq_comm, state_flags)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(inout) :: this
      INTEGER, INTENT(in)                     :: id
      INTEGER, INTENT(in)                     :: i_index
      INTEGER, INTENT(in)                     :: j_index
      REAL (rprec), INTENT(in)                :: value
      INTEGER, INTENT(in)                     :: eq_comm
      INTEGER, INTENT(inout)                  :: state_flags
 
!  local variables
      REAL (rprec)                            :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
!  Set param needs to come first so that function gets executed. Otherwise, when
!  this%not_converged was true, the expression will evaluate to false all the
!  time and not bother calling vmec_set_param.
         CASE (equilibrium_vmec_type)
            CALL vmec_set_param(this%vmec, id, i_index, j_index, value,        &
     &                          eq_comm, state_flags)
 
         CASE (equilibrium_vacuum_type)
            CALL vacuum_set_param(this%vacuum, id, i_index, value)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_set_param(this%siesta, id, i_index, j_index,           &
     &                            value, eq_comm, state_flags)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_set_param', start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_set_magnetic_cache_response(this,                 &
     &                                                  response_object,       &
     &                                                  state_flags)
      USE magnetic_response
      USE model_state
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(inout)    :: this
      TYPE (magnetic_response_class), INTENT(in) :: response_object
      INTEGER, INTENT(in)                        :: state_flags
 
!  local variables
      REAL (rprec)                               :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_set_magnetic_cache(this%vmec, response_object)
 
!  If the equilibrium is already converged, compute the magnetic cache as well.
            IF (.not.btest(state_flags, model_state_vmec_flag)) THEN
               CALL vmec_set_magnetic_cache(this%vmec)
            END IF
 
         CASE (equilibrium_siesta_type)
            CALL siesta_set_magnetic_cache(this%siesta, response_object)
 
!  If the equilibrium is already converged, compute the magnetic cache as well.
            IF (.not.btest(state_flags, model_state_siesta_flag)) THEN
               CALL siesta_set_magnetic_cache(this%siesta)
            END IF
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_set_magnetic_cache_response', start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_set_magnetic_cache_point(this, use_axi,           &
     &                                                state_flags)
      USE model_state
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(inout) :: this
      LOGICAL, INTENT(in)                     :: use_axi
      INTEGER, INTENT(in)                     :: state_flags
 
!  local variables
      REAL (rprec)                            :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_set_magnetic_cache(this%vmec, use_axi)
 
!  If the equilibrium is already converged, compute the magnetic cache as well.
            IF (.not.btest(state_flags, model_state_vmec_flag)) THEN
               CALL vmec_set_magnetic_cache(this%vmec)
            END IF
 
         CASE (equilibrium_siesta_type)
            CALL siesta_set_magnetic_cache(this%siesta, use_axi)
 
!  If the equilibrium is already converged, compute the magnetic cache as well.
            IF (.not.btest(state_flags, model_state_siesta_flag)) THEN
               CALL siesta_set_magnetic_cache(this%siesta)
            END IF
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_set_magnetic_cache_point', start_time)
 
      END SUBROUTINE
 
!*******************************************************************************
!  GETTER SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_param_id(this, param_name)
 
      IMPLICIT NONE
 
!  Declare Arguments
      INTEGER :: equilibrium_get_param_id
      TYPE (equilibrium_class), INTENT(in) :: this
      CHARACTER (len=*), INTENT(in)        :: param_name
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_param_id =                                         &
     &         vmec_get_param_id(this%vmec, param_name)
 
         CASE (equilibrium_vacuum_type)
            equilibrium_get_param_id =                                         &
     &         vacuum_get_param_id(this%vacuum, param_name)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_param_id =                                         &
     &         siesta_get_param_id(this%siesta, param_name)
 
         CASE DEFAULT
            equilibrium_get_param_id = data_no_id
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_param_id',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_param_value(this, id, i_index, j_index)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_param_value
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: id
      INTEGER, INTENT(in)                  :: i_index
      INTEGER, INTENT(in)                  :: j_index
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_param_value =                                      &
     &         vmec_get_param_value(this%vmec, id, i_index, j_index)
 
         CASE (equilibrium_vacuum_type)
            equilibrium_get_param_value =                                      &
     &         vacuum_get_param_value(this%vacuum, id, i_index)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_param_value =                                      &
     &         siesta_get_param_value(this%siesta, id, i_index, j_index)
 
         CASE DEFAULT
            equilibrium_get_param_value = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_param_value',               &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_param_name(this, id)
 
      IMPLICIT NONE
 
!  Declare Arguments
      CHARACTER(len=data_name_length) :: equilibrium_get_param_name
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: id
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_param_name =                                       &
     &         vmec_get_param_name(this%vmec, id)
 
         CASE (equilibrium_vacuum_type)
            equilibrium_get_param_name =                                       &
     &         vacuum_get_param_name(this%vacuum, id)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_param_name =                                       &
     &         siesta_get_param_name(this%siesta, id)
 
         CASE DEFAULT
            equilibrium_get_param_name = ''
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_param_name',                &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_ne_num_hyper_param(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      INTEGER :: equilibrium_get_gp_ne_num_hyper_param
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_ne_num_hyper_param =                            &
     &         vmec_get_gp_ne_num_hyper_param(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_ne_num_hyper_param =                            &
     &         siesta_get_gp_ne_num_hyper_param(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_gp_ne_num_hyper_param = 0
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_gp_ne_num_hyper_param', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ne_af(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:), POINTER  :: equilibrium_get_ne_af
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ne_af => vmec_get_ne_af(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_ne_af => siesta_get_ne_af(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_ne_af => null()
 
      END SELECT
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_ne_ij(this, i, j)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_ne_ij
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: i
      INTEGER, INTENT(in)                  :: j
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_ne_ij = vmec_get_gp_ne(this%vmec, i, j)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_ne_ij = siesta_get_gp_ne(this%siesta,           &
     &                                                  i, j)
 
         CASE DEFAULT
            equilibrium_get_gp_ne_ij = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_ne_ij',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_ne_pi(this, x_cart, i)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_ne_pi
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      INTEGER, INTENT(in)                    :: i
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_ne_pi = vmec_get_gp_ne(this%vmec,               &
     &                                                x_cart, i)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_ne_pi = siesta_get_gp_ne(this%siesta,           &
     &                                                  x_cart, i)
 
         CASE DEFAULT
            equilibrium_get_gp_ne_pi = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_ne_pi',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_ne_pp(this, x_cart, y_cart)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_ne_pp
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      REAL (rprec), DIMENSION(3), INTENT(in) :: y_cart
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_ne_pp = vmec_get_gp_ne(this%vmec,               &
     &                                                x_cart, y_cart)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_ne_pp = siesta_get_gp_ne(this%siesta,           &
     &                                                  x_cart, y_cart)
 
         CASE DEFAULT
            equilibrium_get_gp_ne_pp = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_ne_pp',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ne_cart(this, x_cart)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_ne_cart
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ne_cart = vmec_get_ne(this%vmec, x_cart)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_ne_cart = siesta_get_ne(this%siesta, x_cart)
 
         CASE DEFAULT
            equilibrium_get_ne_cart = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ne_cart',                   &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ne_radial(this, r)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_ne_radial
      TYPE (equilibrium_class), INTENT(in) :: this
      REAL (rprec), INTENT(in)             :: r
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ne_radial = vmec_get_ne(this%vmec, r)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_ne_radial = siesta_get_ne(this%siesta, r)
 
         CASE DEFAULT
            equilibrium_get_ne_radial = 0.0
 
         END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ne_radial',                 &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_te_num_hyper_param(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      INTEGER :: equilibrium_get_gp_te_num_hyper_param
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_te_num_hyper_param =                            &
     &         vmec_get_gp_te_num_hyper_param(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_te_num_hyper_param =                            &
     &         siesta_get_gp_te_num_hyper_param(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_gp_te_num_hyper_param = 0
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_gp_te_num_hyper_param', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_te_af(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:), POINTER  :: equilibrium_get_te_af
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_te_af => vmec_get_te_af(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_te_af => siesta_get_te_af(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_te_af => null()
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_te_af', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_te_ij(this, i, j)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_te_ij
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: i
      INTEGER, INTENT(in)                  :: j
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_te_ij = vmec_get_gp_te(this%vmec, i, j)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_te_ij = siesta_get_gp_te(this%siesta,           &
     &                                                  i, j)
 
         CASE DEFAULT
            equilibrium_get_gp_te_ij = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_te_ij',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_te_pi(this, x_cart, i)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_te_pi
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      INTEGER, INTENT(in)                    :: i
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_te_pi = vmec_get_gp_te(this%vmec,               &
     &                                                x_cart, i)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_te_pi = siesta_get_gp_te(this%siesta,           &
     &                                                  x_cart, i)
 
         CASE DEFAULT
            equilibrium_get_gp_te_pi = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_te_pi',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_te_pp(this, x_cart, y_cart)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_te_pp
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      REAL (rprec), DIMENSION(3), INTENT(in) :: y_cart
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_te_pp = vmec_get_gp_te(this%vmec,               &
     &                                                x_cart, y_cart)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_te_pp = siesta_get_gp_te(this%siesta,           &
     &                                                  x_cart, y_cart)
 
         CASE DEFAULT
            equilibrium_get_gp_te_pp = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_te_pp',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_te_cart(this, x_cart)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_te_cart
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_te_cart = vmec_get_te(this%vmec, x_cart)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_te_cart = siesta_get_te(this%siesta, x_cart)
 
         CASE DEFAULT
            equilibrium_get_te_cart = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_te_cart',                   &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_te_radial(this, r)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_te_radial
      TYPE (equilibrium_class), INTENT(in) :: this
      REAL (rprec), INTENT(in)             :: r
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_te_radial = vmec_get_te(this%vmec, r)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_te_radial = siesta_get_te(this%siesta, r)
 
         CASE DEFAULT
            equilibrium_get_te_radial = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_te_radial',                 &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_ti_num_hyper_param(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      INTEGER :: equilibrium_get_gp_ti_num_hyper_param
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_ti_num_hyper_param =                            &
     &         vmec_get_gp_ti_num_hyper_param(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_ti_num_hyper_param =                            &
     &         siesta_get_gp_ti_num_hyper_param(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_gp_ti_num_hyper_param = 0
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_gp_ti_num_hyper_param', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ti_af(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:), POINTER  :: equilibrium_get_ti_af
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ti_af => vmec_get_ti_af(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_ti_af => siesta_get_ti_af(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_ti_af => null()
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ti_af', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_ti_ij(this, i, j)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_ti_ij
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: i
      INTEGER, INTENT(in)                  :: j
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_ti_ij = vmec_get_gp_ti(this%vmec, i, j)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_ti_ij = siesta_get_gp_ti(this%siesta,           &
     &                                                  i, j)
 
         CASE DEFAULT
            equilibrium_get_gp_ti_ij = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_ti_ij',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_ti_pi(this, x_cart, i)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_ti_pi
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      INTEGER, INTENT(in)                    :: i
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_ti_pi = vmec_get_gp_ti(this%vmec,               &
     &                                                x_cart, i)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_ti_pi = siesta_get_gp_ti(this%siesta,           &
     &                                                  x_cart, i)
 
         CASE DEFAULT
            equilibrium_get_gp_ti_pi = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_ti_pi',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_ti_pp(this, x_cart, y_cart)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_ti_pp
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      REAL (rprec), DIMENSION(3), INTENT(in) :: y_cart
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_ti_pp = vmec_get_gp_ti(this%vmec,               &
     &                                                x_cart, y_cart)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_ti_pp = siesta_get_gp_ti(this%siesta,           &
     &                                                  x_cart, y_cart)
 
         CASE DEFAULT
            equilibrium_get_gp_ti_pp = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_ti_pp',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ti_cart(this, x_cart)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_ti_cart
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ti_cart = vmec_get_ti(this%vmec, x_cart)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_ti_cart = siesta_get_ti(this%siesta, x_cart)
 
         CASE DEFAULT
            equilibrium_get_ti_cart = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ti_cart',                   &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ti_radial(this, r)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_ti_radial
      TYPE (equilibrium_class), INTENT(in) :: this
      REAL (rprec), INTENT(in)             :: r
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ti_radial = vmec_get_ti(this%vmec, r)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_ti_radial = siesta_get_ti(this%siesta, r)
 
         CASE DEFAULT
            equilibrium_get_ti_radial = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ti_radial',                 &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ze_cart(this, x_cart)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_ze_cart
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ze_cart = vmec_get_ze(this%vmec, x_cart)
 
! @TODO add ze to siesta
!         CASE (equilibrium_siesta_type)
!            equilibrium_get_ze_cart = siesta_get_ze(this%siesta, x_cart)
 
         CASE DEFAULT
            equilibrium_get_ze_cart = 1.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ze_cart',                   &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ze_radial(this, r)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_ze_radial
      TYPE (equilibrium_class), INTENT(in) :: this
      REAL (rprec), INTENT(in)             :: r
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ze_radial = vmec_get_ze(this%vmec, r)
 
! @TODO add ze to siesta
!         CASE (equilibrium_siesta_type)
!            equilibrium_get_ze_radial = siesta_get_ze(this%siesta, r)
 
         CASE DEFAULT
            equilibrium_get_ze_radial = 1.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ze_radial',                 &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_sxrem_num_hyper_param(this, index)
 
      IMPLICIT NONE
 
!  Declare Arguments
      INTEGER :: equilibrium_get_gp_sxrem_num_hyper_param
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: index
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_sxrem_num_hyper_param =                         &
     &         vmec_get_gp_sxrem_num_hyper_param(this%vmec, index)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_sxrem_num_hyper_param =                         &
     &         siesta_get_gp_sxrem_num_hyper_param(this%siesta, index)
 
         CASE DEFAULT
            equilibrium_get_gp_sxrem_num_hyper_param = 0
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_gp_sxrem_num_hyper_param', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_sxrem_af(this, index)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:), POINTER  :: equilibrium_get_sxrem_af
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: index
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_sxrem_af => vmec_get_sxrem_af(this%vmec,           &
     &                                                    index)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_sxrem_af => siesta_get_sxrem_af(this%siesta,       &
     &                                                      index)
 
         CASE DEFAULT
            equilibrium_get_sxrem_af => null()
 
      END SELECT
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_sxrem_ij(this, i, j, index)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_sxrem_ij
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: i
      INTEGER, INTENT(in)                  :: j
      INTEGER, INTENT(in)                  :: index
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_sxrem_ij =                                      &
     &         vmec_get_gp_sxrem(this%vmec, i, j, index)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_sxrem_ij =                                      &
     &         siesta_get_gp_sxrem(this%siesta, i, j, index)
 
         CASE DEFAULT
            equilibrium_get_gp_sxrem_ij = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_sxrem_ij',               &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_sxrem_pi(this, x_cart, i, index)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_sxrem_pi
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      INTEGER, INTENT(in)                    :: i
      INTEGER, INTENT(in)                    :: index
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_sxrem_pi =                                      &
     &         vmec_get_gp_sxrem(this%vmec, x_cart, i, index)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_sxrem_pi =                                      &
     &         siesta_get_gp_sxrem(this%siesta, x_cart, i, index)
 
         CASE DEFAULT
            equilibrium_get_gp_sxrem_pi = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_sxrem_pi',                &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_gp_sxrem_pp(this, x_cart, y_cart, index)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_gp_sxrem_pp
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      REAL (rprec), DIMENSION(3), INTENT(in) :: y_cart
      INTEGER, INTENT(in)                    :: index
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_gp_sxrem_pp =                                      &
     &         vmec_get_gp_sxrem(this%vmec, x_cart, y_cart, index)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_gp_sxrem_pp =                                      &
     &         siesta_get_gp_sxrem(this%siesta, x_cart, y_cart, index)
 
         CASE DEFAULT
            equilibrium_get_gp_sxrem_pp = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_gp_sxrem_pp',               &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_sxrem_cart(this, x_cart, index)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_sxrem_cart
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      INTEGER, INTENT(in)                    :: index
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_sxrem_cart = vmec_get_sxrem(this%vmec,             &
     &                                                  x_cart, index)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_sxrem_cart = siesta_get_sxrem(this%siesta,         &
     &                                                    x_cart, index)
 
         CASE DEFAULT
            equilibrium_get_sxrem_cart = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_sxrem_cart',                &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_sxrem_radial(this, r, index)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_sxrem_radial
      TYPE (equilibrium_class), INTENT(in) :: this
      REAL (rprec), INTENT(in)             :: r
      INTEGER, INTENT(in)                  :: index
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_sxrem_radial = vmec_get_sxrem(this%vmec,           &
     &                                                    r, index)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_sxrem_radial = siesta_get_sxrem(this%siesta,       &
     &                                                      r, index)
 
         CASE DEFAULT
            equilibrium_get_sxrem_radial = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_sxrem_radial',              &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_p_cart(this, x_cart)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_p_cart
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_p_cart = vmec_get_p(this%vmec, x_cart)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_p_cart = siesta_get_p(this%siesta, x_cart,         &
     &                                            .false.)
 
         CASE DEFAULT
            equilibrium_get_p_cart = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_p_cart', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_p_radial(this, r)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_p_radial
      TYPE (equilibrium_class), INTENT(in) :: this
      REAL (rprec), INTENT(in)             :: r
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_p_radial = vmec_get_p(this%vmec, r)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_p_radial = siesta_get_p(this%siesta, r,            &
     &                                              .false.)
 
         CASE DEFAULT
            equilibrium_get_p_radial = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_p_radial',                  &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_b_vec(this, x_cart, cyl)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(3) :: equilibrium_get_b_vec
      TYPE (equilibrium_class), INTENT(in)   :: this
      REAL (rprec), DIMENSION(3), INTENT(in) :: x_cart
      LOGICAL, INTENT(in)                    :: cyl
 
!  local variables
      REAL (rprec)                           :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_b_vec = vmec_get_b_vec(this%vmec, x_cart,          &
     &                                             cyl)
 
         CASE (equilibrium_vacuum_type)
            equilibrium_get_b_vec = vacuum_get_b_vec(this%vacuum,              &
     &                                               x_cart, cyl)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_b_vec = siesta_get_b_vec(this%siesta,              &
     &                                               x_cart, cyl)
 
         CASE DEFAULT
            equilibrium_get_b_vec = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_B_vec', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_int_b_dphi(this, r, theta)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_int_b_dphi
      TYPE (equilibrium_class), INTENT(in) :: this
      REAL (rprec), INTENT(in)             :: r
      REAL (rprec), INTENT(in)             :: theta
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_int_b_dphi =                                       &
     &         vmec_get_int_b_dphi(this%vmec, r, theta)
 
         CASE (equilibrium_vacuum_type)
            equilibrium_get_int_b_dphi =                                       &
     &         vacuum_get_int_b_dphi(this%vacuum, r, theta)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_int_b_dphi =                                       &
     &         siesta_get_int_b_dphi(this%siesta, r, theta)
 
         CASE DEFAULT
            equilibrium_get_int_b_dphi = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_Int_B_dphi',                &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_plasma_edge(this, phi, r, z)
 
      IMPLICIT NONE
 
!  Declare Arguments
      INTEGER :: equilibrium_get_plasma_edge
      TYPE (equilibrium_class), INTENT(in)             :: this
      REAL (rprec), INTENT (in)                        :: phi
      REAL (rprec), DIMENSION(:), POINTER              :: r
      REAL (rprec), DIMENSION(:), POINTER              :: z
 
!  local variables
      REAL (rprec)                                     :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_plasma_edge =                                      &
     &         vmec_get_plasma_edge(this%vmec, phi, r, z)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_plasma_edge =                                      &
     &         siesta_get_plasma_edge(this%siesta, phi, r, z)
 
         CASE DEFAULT
            equilibrium_get_plasma_edge = 0
            r => null()
            z => null()
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_plasma_edge',               &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_magnetic_volume_rgrid(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:,:,:), POINTER ::                               &
     &   equilibrium_get_magnetic_volume_rgrid
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_magnetic_volume_rgrid =>                           &
     &         vmec_get_magnetic_volume_rgrid(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_magnetic_volume_rgrid =>                           &
     &         siesta_get_magnetic_volume_rgrid(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_magnetic_volume_rgrid => null()
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_magnetic_volume_rgrid', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_magnetic_volume_zgrid(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:,:,:), POINTER ::                               &
     &   equilibrium_get_magnetic_volume_zgrid
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_magnetic_volume_zgrid =>                           &
     &         vmec_get_magnetic_volume_zgrid(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_magnetic_volume_zgrid =>                           &
     &         siesta_get_magnetic_volume_zgrid(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_magnetic_volume_zgrid => null()
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_magnetic_volume_zgrid', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_magnetic_volume_jrgrid(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:,:,:), POINTER ::                               &
     &   equilibrium_get_magnetic_volume_jrgrid
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_magnetic_volume_jrgrid =>                          &
     &         vmec_get_magnetic_volume_jrgrid(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_magnetic_volume_jrgrid =>                          &
     &         siesta_get_magnetic_volume_jrgrid(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_magnetic_volume_jrgrid => null()
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_magnetic_volume_jrgrid', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_magnetic_volume_jphigrid(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:,:,:), POINTER ::                               &
     &   equilibrium_get_magnetic_volume_jphigrid
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_magnetic_volume_jphigrid =>                        &
     &         vmec_get_magnetic_volume_jphigrid(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_magnetic_volume_jphigrid =>                        &
     &         siesta_get_magnetic_volume_jphigrid(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_magnetic_volume_jphigrid => null()
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_magnetic_volume_jphigrid', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_magnetic_volume_jzgrid(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:,:,:), POINTER ::                               &
     &   equilibrium_get_magnetic_volume_jzgrid
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_magnetic_volume_jzgrid =>                          &
     &         vmec_get_magnetic_volume_jzgrid(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_magnetic_volume_jzgrid =>                          &
     &         siesta_get_magnetic_volume_jzgrid(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_magnetic_volume_jzgrid => null()
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_magnetic_volume_jzgrid', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_volume_int_element(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_volume_int_element
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
        CASE (equilibrium_vmec_type)
            equilibrium_get_volume_int_element =                               &
     &         vmec_get_volume_int_element(this%vmec)
 
        CASE (equilibrium_siesta_type)
           equilibrium_get_volume_int_element =                               &
     &         siesta_get_volume_int_element(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_volume_int_element = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_volume_int_element',        &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_con_surface_krgrid(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:,:), POINTER ::                                 &
     &   equilibrium_get_con_surface_krgrid
      TYPE (equilibrium_class), INTENT(in)  :: this
 
!  local variables
      REAL (rprec)                          :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_con_surface_krgrid =>                              &
     &         vmec_get_con_surface_krgrid(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_con_surface_krgrid =>                              &
     &         siesta_get_con_surface_krgrid(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_con_surface_krgrid => null()
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_con_surface_krgrid', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_con_surface_kphigrid(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:,:), POINTER ::                                 &
     &   equilibrium_get_con_surface_kphigrid
      TYPE (equilibrium_class), INTENT(in)  :: this
 
!  local variables
      REAL (rprec)                          :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_con_surface_kphigrid =>                            &
     &         vmec_get_con_surface_kphigrid(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_con_surface_kphigrid =>                            &
     &         siesta_get_con_surface_kphigrid(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_con_surface_kphigrid => null()
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_con_surface_kphigrid', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_con_surface_kzgrid(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:,:), POINTER ::                                 &
     &   equilibrium_get_con_surface_kzgrid
      TYPE (equilibrium_class), INTENT(in)  :: this
 
!  local variables
      REAL (rprec)                          :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_con_surface_kzgrid =>                              &
     &         vmec_get_con_surface_kzgrid(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_con_surface_kzgrid =>                              &
     &         siesta_get_con_surface_kzgrid(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_con_surface_kzgrid => null()
 
      END SELECT
 
      CALL profiler_set_stop_time(                                             &
     &        'equilibrium_get_con_surface_kzgrid', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_area_int_element(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec) :: equilibrium_get_area_int_element
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_area_int_element =                                 &
     &         vmec_get_area_int_element(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_area_int_element =                                 &
     &         siesta_get_area_int_element(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_area_int_element = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_area_int_element',          &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ext_currents(this, num_currents,                &
     &                                      scale_currents)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(:), POINTER  ::                                  &
     &   equilibrium_get_ext_currents
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER                              :: num_currents
      LOGICAL, INTENT(out)                 :: scale_currents
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ext_currents =>                                    &
     &         vmec_get_ext_currents(this%vmec, num_currents,                  &
     &                               scale_currents)
 
         CASE (equilibrium_vacuum_type)
!  Vacuum equilibira always return currents. No need to force it.
            equilibrium_get_ext_currents =>                                    &
     &         vacuum_get_ext_currents(this%vacuum, scale_currents)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_ext_currents =>                                    &
     &         siesta_get_ext_currents(this%siesta, num_currents,              &
     &                                 scale_currents)
 
         CASE DEFAULT
            scale_currents = .false.
            equilibrium_get_ext_currents => null()
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ext_currents',              &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_ext_b_plasma(this, position, axi_only)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAL (rprec), DIMENSION(3) :: equilibrium_get_ext_b_plasma
      TYPE (equilibrium_class), INTENT(in) :: this
      REAL (rprec), DIMENSION(3)           :: position
      LOGICAL, INTENT(in)                  :: axi_only
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_ext_b_plasma =                                     &
     &         vmec_get_ext_b_plasma(this%vmec, position, axi_only)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_ext_b_plasma =                                     &
     &         siesta_get_ext_b_plasma(this%siesta, position, axi_only)
 
         CASE DEFAULT
            equilibrium_get_ext_b_plasma = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_ext_b_plasma',              &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_grid_size(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      INTEGER :: equilibrium_get_grid_size
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_grid_size = vmec_get_grid_size(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_grid_size =                                        &
     &         siesta_get_grid_size(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_grid_size = 0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_grid_size',                 &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_grid_start(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAl (rprec) :: equilibrium_get_grid_start
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_grid_start = vmec_get_grid_start(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_grid_start =                                       &
     &         siesta_get_grid_start(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_grid_start = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_grid_start',                &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_get_grid_stop(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      REAl (rprec) :: equilibrium_get_grid_stop
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_get_grid_stop = vmec_get_grid_stop(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_get_grid_stop =                                        &
     &         siesta_get_grid_stop(this%siesta)
 
         CASE DEFAULT
            equilibrium_get_grid_stop = 0.0
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_get_grid_stop',                 &
     &                            start_time)
 
      END FUNCTION
 
!*******************************************************************************
!  QUERY SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_is_scaler_value(this, id)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: equilibrium_is_scaler_value
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: id
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_is_scaler_value =                                      &
     &         vmec_is_scaler_value(this%vmec, id)
 
         CASE (equilibrium_siesta_type)
            equilibrium_is_scaler_value =                                      &
     &         siesta_is_scaler_value(this%siesta, id)
 
         CASE DEFAULT
            equilibrium_is_scaler_value = .false.
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_is_scaler_value',               &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_is_1d_array(this, id)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: equilibrium_is_1d_array
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: id
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_is_1d_array = vmec_is_1d_array(this%vmec, id)
 
         CASE (equilibrium_vacuum_type)
            equilibrium_is_1d_array = vacuum_is_1d_array(this%vacuum,          &
     &                                                   id)
 
         CASE (equilibrium_siesta_type)
            equilibrium_is_1d_array = siesta_is_1d_array(this%siesta,          &
     &                                                   id)
 
         CASE DEFAULT
            equilibrium_is_1d_array = .false.
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_is_1d_array', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_is_2d_array(this, id)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: equilibrium_is_2d_array
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: id
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_is_2d_array = vmec_is_2d_array(this%vmec, id)
 
         CASE (equilibrium_siesta_type)
            equilibrium_is_2d_array = siesta_is_2d_array(this%siesta,          &
     &                                                   id)
 
         CASE DEFAULT
            equilibrium_is_2d_array = .false.
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_is_2d_array', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_is_recon_param(this, id)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: equilibrium_is_recon_param
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: id
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_is_recon_param =                                       &
     &         vmec_is_recon_param(this%vmec, id)
 
         CASE (equilibrium_vacuum_type)
            equilibrium_is_recon_param =                                       &
     &         vacuum_is_recon_param(this%vacuum, id)
 
         CASE (equilibrium_siesta_type)
            equilibrium_is_recon_param =                                       &
     &         siesta_is_recon_param(this%siesta, id)
 
         CASE DEFAULT
            equilibrium_is_recon_param = .false.
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_is_recon_param',                &
     &                            start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_is_using_point(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL :: equilibrium_is_using_point
      TYPE (equilibrium_class), INTENT(in) :: this
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_is_using_point = vmec_is_using_point(this%vmec)
 
         CASE (equilibrium_siesta_type)
            equilibrium_is_using_point =                                       &
     &         siesta_is_using_point(this%siesta)
 
         CASE DEFAULT
            equilibrium_is_using_point = .false.
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_is_using_point',                &
     &                            start_time)
 
      END FUNCTION
 
!*******************************************************************************
!  UTILITY SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      FUNCTION equilibrium_converge(this, num_iter, iou, eq_comm,              &
     &                              state_flags)
 
      IMPLICIT NONE
 
!  Declare Arguments
      LOGICAL                                 :: equilibrium_converge
      TYPE (equilibrium_class), INTENT(inout) :: this
      INTEGER, INTENT(inout)                  :: num_iter
      INTEGER, INTENT(in)                     :: iou
      INTEGER, INTENT(in)                     :: eq_comm
      INTEGER, INTENT(in)                     :: state_flags
 
!  local variables
      INTEGER                                 :: error
      INTEGER                                 :: eq_rank
      REAL (rprec)                            :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
#if defined(MPI_OPT)
      CALL mpi_bcast(num_iter, 1, mpi_integer, 0, eq_comm, error)
#endif
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            equilibrium_converge = vmec_converge(this%vmec, num_iter,          &
     &                                           iou, eq_comm)
 
         CASE (equilibrium_siesta_type)
            equilibrium_converge = siesta_converge(this%siesta,                &
     &                                             num_iter, iou,              &
     &                                             eq_comm, state_flags)
 
         CASE DEFAULT
            equilibrium_converge = .false.
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_converge', start_time)
 
      END FUNCTION
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_read_vac_file(this, index, eq_comm)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: index
      INTEGER, INTENT(in)                  :: eq_comm
 
!  Start of executable code
       SELECT CASE (this%type)
 
          CASE (equilibrium_vmec_type)
             CALL vmec_read_vac_file(this%vmec, index, eq_comm)
 
          CASE (equilibrium_siesta_type)
             CALL siesta_read_vac_file(this%siesta, index, eq_comm)
 
       END SELECT
 
       END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_save_state(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(inout) :: this
 
!  local variables
      REAL (rprec)                            :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_save_state(this%vmec)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_save_state(this%siesta)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_save_state', start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_reset_state(this)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(inout) :: this
 
!  local variables
      REAL (rprec)                            :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_reset_state(this%vmec)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_reset_state(this%siesta)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_reset_state',                   &
     &                            start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_write(this, iou)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: iou
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_write(this%vmec, iou)
 
         CASE (equilibrium_vacuum_type)
            CALL vacuum_write(this%vacuum, iou)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_write(this%siesta, iou)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_write', start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_write_input(this, current_step)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER                              :: current_step
 
!  local variables
      REAL (rprec)                            :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_write_input(this%vmec, current_step)
 
         CASE (equilibrium_vacuum_type)
            CALL vacuum_write_input(this%vacuum, current_step)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_write_input(this%siesta, current_step)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_write_input', start_time)
 
      END SUBROUTINE
 
!*******************************************************************************
!  NETCDF SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_def_result(this, result_ncid,                     &
     &                                  maxnsetps_dim_id)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: result_ncid
      INTEGER, INTENT(in)                  :: maxnsetps_dim_id
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_def_result(this%vmec, result_ncid,                       &
     &                           maxnsetps_dim_id)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_def_result(this%siesta, result_ncid,                   &
     &                             maxnsetps_dim_id)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_def_result', start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_write_init_data(this, result_ncid)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: result_ncid
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_write_init_data(this%vmec, result_ncid)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_write_init_data(this%siesta, result_ncid)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_write_init_data',               &
     &                            start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_write_step_data(this, result_ncid,                &
     &                                       current_step)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: result_ncid
      INTEGER, INTENT(in)                  :: current_step
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_write_step_data(this%vmec, result_ncid,                  &
     &                                current_step)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_write_step_data(this%siesta, result_ncid,              &
     &                                  current_step)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_write_step_data',               &
     &                            start_time)
 
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_restart(this, result_ncid, current_step)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(in) :: this
      INTEGER, INTENT(in)                  :: result_ncid
      INTEGER, INTENT(in)                  :: current_step
 
!  local variables
      REAL (rprec)                         :: start_time
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_restart(this%vmec, result_ncid, current_step)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_restart(this%siesta, result_ncid, current_step)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_restart', start_time)
 
      END SUBROUTINE
 
!*******************************************************************************
!  MPI SUBROUTINES
!*******************************************************************************
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_sync_state(this, recon_comm)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(inout) :: this
      INTEGER, INTENT(in)                     :: recon_comm
 
#if defined(MPI_OPT)
!  local variables
      REAL (rprec)                            :: start_time
      INTEGER                                 :: error
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_sync_state(this%vmec, recon_comm)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_sync_state(this%siesta, recon_comm)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_sync_state', start_time)
 
#endif
      END SUBROUTINE
 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
      SUBROUTINE equilibrium_sync_child(this, index, recon_comm)
 
      IMPLICIT NONE
 
!  Declare Arguments
      TYPE (equilibrium_class), INTENT(inout) :: this
      INTEGER, INTENT(in)                     :: index
      INTEGER, INTENT(in)                     :: recon_comm
 
#if defined(MPI_OPT)
!  local variables
      REAL (rprec)                            :: start_time
      INTEGER                                 :: mpi_rank
      INTEGER                                 :: error
 
!  Start of executable code
      start_time = profiler_get_start_time()
 
      CALL mpi_comm_rank(recon_comm, mpi_rank, error)
 
      SELECT CASE (this%type)
 
         CASE (equilibrium_vmec_type)
            CALL vmec_sync_child(this%vmec, index, recon_comm)
 
         CASE (equilibrium_siesta_type)
            CALL siesta_sync_child(this%siesta, index, recon_comm)
 
      END SELECT
 
      CALL profiler_set_stop_time('equilibrium_sync_child', start_time)
 
#endif
      END SUBROUTINE
 
      END MODULE