f90wrap_fidasim.f90

! Module libfida defined in file fidasim.f90

subroutine f90wrap_interpolcoeffs1d__get__i(this, f90wrap_i)
    use libfida, only: interpolcoeffs1d
    implicit none
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs1d_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_i
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_i = this_ptr%p%i
end subroutine f90wrap_interpolcoeffs1d__get__i

subroutine f90wrap_interpolcoeffs1d__set__i(this, f90wrap_i)
    use libfida, only: interpolcoeffs1d
    implicit none
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs1d_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%i = f90wrap_i
end subroutine f90wrap_interpolcoeffs1d__set__i

subroutine f90wrap_interpolcoeffs1d__get__b1(this, f90wrap_b1)
    use libfida, only: interpolcoeffs1d
    implicit none
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs1d_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_b1
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_b1 = this_ptr%p%b1
end subroutine f90wrap_interpolcoeffs1d__get__b1

subroutine f90wrap_interpolcoeffs1d__set__b1(this, f90wrap_b1)
    use libfida, only: interpolcoeffs1d
    implicit none
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs1d_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_b1
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%b1 = f90wrap_b1
end subroutine f90wrap_interpolcoeffs1d__set__b1

subroutine f90wrap_interpolcoeffs1d__get__b2(this, f90wrap_b2)
    use libfida, only: interpolcoeffs1d
    implicit none
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs1d_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_b2
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_b2 = this_ptr%p%b2
end subroutine f90wrap_interpolcoeffs1d__get__b2

subroutine f90wrap_interpolcoeffs1d__set__b2(this, f90wrap_b2)
    use libfida, only: interpolcoeffs1d
    implicit none
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs1d_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_b2
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%b2 = f90wrap_b2
end subroutine f90wrap_interpolcoeffs1d__set__b2

subroutine f90wrap_interpolcoeffs1d_initialise(this)
    use libfida, only: interpolcoeffs1d
    implicit none
    
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    type(interpolcoeffs1d_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_interpolcoeffs1d_initialise

subroutine f90wrap_interpolcoeffs1d_finalise(this)
    use libfida, only: interpolcoeffs1d
    implicit none
    
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    type(interpolcoeffs1d_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_interpolcoeffs1d_finalise

subroutine f90wrap_interpolcoeffs2d__get__i(this, f90wrap_i)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_i
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_i = this_ptr%p%i
end subroutine f90wrap_interpolcoeffs2d__get__i

subroutine f90wrap_interpolcoeffs2d__set__i(this, f90wrap_i)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%i = f90wrap_i
end subroutine f90wrap_interpolcoeffs2d__set__i

subroutine f90wrap_interpolcoeffs2d__get__j(this, f90wrap_j)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_j
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_j = this_ptr%p%j
end subroutine f90wrap_interpolcoeffs2d__get__j

subroutine f90wrap_interpolcoeffs2d__set__j(this, f90wrap_j)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_j
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%j = f90wrap_j
end subroutine f90wrap_interpolcoeffs2d__set__j

subroutine f90wrap_interpolcoeffs2d__get__b11(this, f90wrap_b11)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_b11
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_b11 = this_ptr%p%b11
end subroutine f90wrap_interpolcoeffs2d__get__b11

subroutine f90wrap_interpolcoeffs2d__set__b11(this, f90wrap_b11)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_b11
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%b11 = f90wrap_b11
end subroutine f90wrap_interpolcoeffs2d__set__b11

subroutine f90wrap_interpolcoeffs2d__get__b12(this, f90wrap_b12)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_b12
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_b12 = this_ptr%p%b12
end subroutine f90wrap_interpolcoeffs2d__get__b12

subroutine f90wrap_interpolcoeffs2d__set__b12(this, f90wrap_b12)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_b12
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%b12 = f90wrap_b12
end subroutine f90wrap_interpolcoeffs2d__set__b12

subroutine f90wrap_interpolcoeffs2d__get__b21(this, f90wrap_b21)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_b21
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_b21 = this_ptr%p%b21
end subroutine f90wrap_interpolcoeffs2d__get__b21

subroutine f90wrap_interpolcoeffs2d__set__b21(this, f90wrap_b21)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_b21
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%b21 = f90wrap_b21
end subroutine f90wrap_interpolcoeffs2d__set__b21

subroutine f90wrap_interpolcoeffs2d__get__b22(this, f90wrap_b22)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_b22
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_b22 = this_ptr%p%b22
end subroutine f90wrap_interpolcoeffs2d__get__b22

subroutine f90wrap_interpolcoeffs2d__set__b22(this, f90wrap_b22)
    use libfida, only: interpolcoeffs2d
    implicit none
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_b22
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%b22 = f90wrap_b22
end subroutine f90wrap_interpolcoeffs2d__set__b22

subroutine f90wrap_interpolcoeffs2d_initialise(this)
    use libfida, only: interpolcoeffs2d
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_interpolcoeffs2d_initialise

subroutine f90wrap_interpolcoeffs2d_finalise(this)
    use libfida, only: interpolcoeffs2d
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    type(interpolcoeffs2d_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_interpolcoeffs2d_finalise

subroutine f90wrap_beamgrid__get__nx(this, f90wrap_nx)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nx
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nx = this_ptr%p%nx
end subroutine f90wrap_beamgrid__get__nx

subroutine f90wrap_beamgrid__set__nx(this, f90wrap_nx)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nx
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nx = f90wrap_nx
end subroutine f90wrap_beamgrid__set__nx

subroutine f90wrap_beamgrid__get__ny(this, f90wrap_ny)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_ny
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ny = this_ptr%p%ny
end subroutine f90wrap_beamgrid__get__ny

subroutine f90wrap_beamgrid__set__ny(this, f90wrap_ny)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_ny
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ny = f90wrap_ny
end subroutine f90wrap_beamgrid__set__ny

subroutine f90wrap_beamgrid__get__nz(this, f90wrap_nz)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nz = this_ptr%p%nz
end subroutine f90wrap_beamgrid__get__nz

subroutine f90wrap_beamgrid__set__nz(this, f90wrap_nz)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nz = f90wrap_nz
end subroutine f90wrap_beamgrid__set__nz

subroutine f90wrap_beamgrid__get__xmin(this, f90wrap_xmin)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_xmin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_xmin = this_ptr%p%xmin
end subroutine f90wrap_beamgrid__get__xmin

subroutine f90wrap_beamgrid__set__xmin(this, f90wrap_xmin)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_xmin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%xmin = f90wrap_xmin
end subroutine f90wrap_beamgrid__set__xmin

subroutine f90wrap_beamgrid__get__xmax(this, f90wrap_xmax)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_xmax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_xmax = this_ptr%p%xmax
end subroutine f90wrap_beamgrid__get__xmax

subroutine f90wrap_beamgrid__set__xmax(this, f90wrap_xmax)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_xmax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%xmax = f90wrap_xmax
end subroutine f90wrap_beamgrid__set__xmax

subroutine f90wrap_beamgrid__get__ymin(this, f90wrap_ymin)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_ymin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ymin = this_ptr%p%ymin
end subroutine f90wrap_beamgrid__get__ymin

subroutine f90wrap_beamgrid__set__ymin(this, f90wrap_ymin)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_ymin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ymin = f90wrap_ymin
end subroutine f90wrap_beamgrid__set__ymin

subroutine f90wrap_beamgrid__get__ymax(this, f90wrap_ymax)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_ymax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ymax = this_ptr%p%ymax
end subroutine f90wrap_beamgrid__get__ymax

subroutine f90wrap_beamgrid__set__ymax(this, f90wrap_ymax)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_ymax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ymax = f90wrap_ymax
end subroutine f90wrap_beamgrid__set__ymax

subroutine f90wrap_beamgrid__get__zmin(this, f90wrap_zmin)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_zmin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_zmin = this_ptr%p%zmin
end subroutine f90wrap_beamgrid__get__zmin

subroutine f90wrap_beamgrid__set__zmin(this, f90wrap_zmin)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_zmin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%zmin = f90wrap_zmin
end subroutine f90wrap_beamgrid__set__zmin

subroutine f90wrap_beamgrid__get__zmax(this, f90wrap_zmax)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_zmax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_zmax = this_ptr%p%zmax
end subroutine f90wrap_beamgrid__get__zmax

subroutine f90wrap_beamgrid__set__zmax(this, f90wrap_zmax)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_zmax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%zmax = f90wrap_zmax
end subroutine f90wrap_beamgrid__set__zmax

subroutine f90wrap_beamgrid__get__alpha(this, f90wrap_alpha)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_alpha
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_alpha = this_ptr%p%alpha
end subroutine f90wrap_beamgrid__get__alpha

subroutine f90wrap_beamgrid__set__alpha(this, f90wrap_alpha)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_alpha
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%alpha = f90wrap_alpha
end subroutine f90wrap_beamgrid__set__alpha

subroutine f90wrap_beamgrid__get__beta(this, f90wrap_beta)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_beta
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_beta = this_ptr%p%beta
end subroutine f90wrap_beamgrid__get__beta

subroutine f90wrap_beamgrid__set__beta(this, f90wrap_beta)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_beta
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%beta = f90wrap_beta
end subroutine f90wrap_beamgrid__set__beta

subroutine f90wrap_beamgrid__get__gamma(this, f90wrap_gamma)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_gamma
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_gamma = this_ptr%p%gamma
end subroutine f90wrap_beamgrid__get__gamma

subroutine f90wrap_beamgrid__set__gamma(this, f90wrap_gamma)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_gamma
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%gamma = f90wrap_gamma
end subroutine f90wrap_beamgrid__set__gamma

subroutine f90wrap_beamgrid__get__drmin(this, f90wrap_drmin)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_drmin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_drmin = this_ptr%p%drmin
end subroutine f90wrap_beamgrid__get__drmin

subroutine f90wrap_beamgrid__set__drmin(this, f90wrap_drmin)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_drmin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%drmin = f90wrap_drmin
end subroutine f90wrap_beamgrid__set__drmin

subroutine f90wrap_beamgrid__get__dv(this, f90wrap_dv)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dv
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dv = this_ptr%p%dv
end subroutine f90wrap_beamgrid__get__dv

subroutine f90wrap_beamgrid__set__dv(this, f90wrap_dv)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dv
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dv = f90wrap_dv
end subroutine f90wrap_beamgrid__set__dv

subroutine f90wrap_beamgrid__get__volume(this, f90wrap_volume)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_volume
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_volume = this_ptr%p%volume
end subroutine f90wrap_beamgrid__get__volume

subroutine f90wrap_beamgrid__set__volume(this, f90wrap_volume)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_volume
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%volume = f90wrap_volume
end subroutine f90wrap_beamgrid__set__volume

subroutine f90wrap_beamgrid__get__ntrack(this, f90wrap_ntrack)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_ntrack
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ntrack = this_ptr%p%ntrack
end subroutine f90wrap_beamgrid__get__ntrack

subroutine f90wrap_beamgrid__set__ntrack(this, f90wrap_ntrack)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_ntrack
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ntrack = f90wrap_ntrack
end subroutine f90wrap_beamgrid__set__ntrack

subroutine f90wrap_beamgrid__get__ngrid(this, f90wrap_ngrid)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_ngrid
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ngrid = this_ptr%p%ngrid
end subroutine f90wrap_beamgrid__get__ngrid

subroutine f90wrap_beamgrid__set__ngrid(this, f90wrap_ngrid)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_ngrid
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ngrid = f90wrap_ngrid
end subroutine f90wrap_beamgrid__set__ngrid

subroutine f90wrap_beamgrid__array__origin(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%origin)
    dloc = loc(this_ptr%p%origin)
end subroutine f90wrap_beamgrid__array__origin

subroutine f90wrap_beamgrid__array__center(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%center)
    dloc = loc(this_ptr%p%center)
end subroutine f90wrap_beamgrid__array__center

subroutine f90wrap_beamgrid__array__dr(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%dr)
    dloc = loc(this_ptr%p%dr)
end subroutine f90wrap_beamgrid__array__dr

subroutine f90wrap_beamgrid__array__lwh(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%lwh)
    dloc = loc(this_ptr%p%lwh)
end subroutine f90wrap_beamgrid__array__lwh

subroutine f90wrap_beamgrid__array__basis(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%basis)
    dloc = loc(this_ptr%p%basis)
end subroutine f90wrap_beamgrid__array__basis

subroutine f90wrap_beamgrid__array__inv_basis(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%inv_basis)
    dloc = loc(this_ptr%p%inv_basis)
end subroutine f90wrap_beamgrid__array__inv_basis

subroutine f90wrap_beamgrid__array__xc(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%xc)) then
        dshape(1:1) = shape(this_ptr%p%xc)
        dloc = loc(this_ptr%p%xc)
    else
        dloc = 0
    end if
end subroutine f90wrap_beamgrid__array__xc

subroutine f90wrap_beamgrid__array__yc(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%yc)) then
        dshape(1:1) = shape(this_ptr%p%yc)
        dloc = loc(this_ptr%p%yc)
    else
        dloc = 0
    end if
end subroutine f90wrap_beamgrid__array__yc

subroutine f90wrap_beamgrid__array__zc(this, nd, dtype, dshape, dloc)
    use libfida, only: beamgrid
    implicit none
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    integer, intent(in) :: this(2)
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%zc)) then
        dshape(1:1) = shape(this_ptr%p%zc)
        dloc = loc(this_ptr%p%zc)
    else
        dloc = 0
    end if
end subroutine f90wrap_beamgrid__array__zc

subroutine f90wrap_beamgrid_initialise(this)
    use libfida, only: beamgrid
    implicit none
    
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_beamgrid_initialise

subroutine f90wrap_beamgrid_finalise(this)
    use libfida, only: beamgrid
    implicit none
    
    type beamgrid_ptr_type
        type(beamgrid), pointer :: p => NULL()
    end type beamgrid_ptr_type
    type(beamgrid_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_beamgrid_finalise

subroutine f90wrap_interpolationgrid__get__nr(this, f90wrap_nr)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nr = this_ptr%p%nr
end subroutine f90wrap_interpolationgrid__get__nr

subroutine f90wrap_interpolationgrid__set__nr(this, f90wrap_nr)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nr = f90wrap_nr
end subroutine f90wrap_interpolationgrid__set__nr

subroutine f90wrap_interpolationgrid__get__nz(this, f90wrap_nz)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nz = this_ptr%p%nz
end subroutine f90wrap_interpolationgrid__get__nz

subroutine f90wrap_interpolationgrid__set__nz(this, f90wrap_nz)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nz = f90wrap_nz
end subroutine f90wrap_interpolationgrid__set__nz

subroutine f90wrap_interpolationgrid__get__dr(this, f90wrap_dr)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dr = this_ptr%p%dr
end subroutine f90wrap_interpolationgrid__get__dr

subroutine f90wrap_interpolationgrid__set__dr(this, f90wrap_dr)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dr = f90wrap_dr
end subroutine f90wrap_interpolationgrid__set__dr

subroutine f90wrap_interpolationgrid__get__dz(this, f90wrap_dz)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dz = this_ptr%p%dz
end subroutine f90wrap_interpolationgrid__get__dz

subroutine f90wrap_interpolationgrid__set__dz(this, f90wrap_dz)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dz = f90wrap_dz
end subroutine f90wrap_interpolationgrid__set__dz

subroutine f90wrap_interpolationgrid__get__da(this, f90wrap_da)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_da
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_da = this_ptr%p%da
end subroutine f90wrap_interpolationgrid__get__da

subroutine f90wrap_interpolationgrid__set__da(this, f90wrap_da)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in)   :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_da
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%da = f90wrap_da
end subroutine f90wrap_interpolationgrid__set__da

subroutine f90wrap_interpolationgrid__array__r(this, nd, dtype, dshape, dloc)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in) :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%r)) then
        dshape(1:1) = shape(this_ptr%p%r)
        dloc = loc(this_ptr%p%r)
    else
        dloc = 0
    end if
end subroutine f90wrap_interpolationgrid__array__r

subroutine f90wrap_interpolationgrid__array__z(this, nd, dtype, dshape, dloc)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in) :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%z)) then
        dshape(1:1) = shape(this_ptr%p%z)
        dloc = loc(this_ptr%p%z)
    else
        dloc = 0
    end if
end subroutine f90wrap_interpolationgrid__array__z

subroutine f90wrap_interpolationgrid__array__r2d(this, nd, dtype, dshape, dloc)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in) :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%r2d)) then
        dshape(1:2) = shape(this_ptr%p%r2d)
        dloc = loc(this_ptr%p%r2d)
    else
        dloc = 0
    end if
end subroutine f90wrap_interpolationgrid__array__r2d

subroutine f90wrap_interpolationgrid__array__z2d(this, nd, dtype, dshape, dloc)
    use libfida, only: interpolationgrid
    implicit none
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    integer, intent(in) :: this(2)
    type(interpolationgrid_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%z2d)) then
        dshape(1:2) = shape(this_ptr%p%z2d)
        dloc = loc(this_ptr%p%z2d)
    else
        dloc = 0
    end if
end subroutine f90wrap_interpolationgrid__array__z2d

subroutine f90wrap_interpolationgrid_initialise(this)
    use libfida, only: interpolationgrid
    implicit none
    
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    type(interpolationgrid_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_interpolationgrid_initialise

subroutine f90wrap_interpolationgrid_finalise(this)
    use libfida, only: interpolationgrid
    implicit none
    
    type interpolationgrid_ptr_type
        type(interpolationgrid), pointer :: p => NULL()
    end type interpolationgrid_ptr_type
    type(interpolationgrid_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_interpolationgrid_finalise

subroutine f90wrap_profiles__get__dene(this, f90wrap_dene)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dene
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dene = this_ptr%p%dene
end subroutine f90wrap_profiles__get__dene

subroutine f90wrap_profiles__set__dene(this, f90wrap_dene)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dene
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dene = f90wrap_dene
end subroutine f90wrap_profiles__set__dene

subroutine f90wrap_profiles__get__denp(this, f90wrap_denp)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_denp
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_denp = this_ptr%p%denp
end subroutine f90wrap_profiles__get__denp

subroutine f90wrap_profiles__set__denp(this, f90wrap_denp)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_denp
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%denp = f90wrap_denp
end subroutine f90wrap_profiles__set__denp

subroutine f90wrap_profiles__get__denimp(this, f90wrap_denimp)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_denimp
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_denimp = this_ptr%p%denimp
end subroutine f90wrap_profiles__get__denimp

subroutine f90wrap_profiles__set__denimp(this, f90wrap_denimp)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_denimp
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%denimp = f90wrap_denimp
end subroutine f90wrap_profiles__set__denimp

subroutine f90wrap_profiles__get__denf(this, f90wrap_denf)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_denf
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_denf = this_ptr%p%denf
end subroutine f90wrap_profiles__get__denf

subroutine f90wrap_profiles__set__denf(this, f90wrap_denf)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_denf
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%denf = f90wrap_denf
end subroutine f90wrap_profiles__set__denf

subroutine f90wrap_profiles__get__te(this, f90wrap_te)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_te
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_te = this_ptr%p%te
end subroutine f90wrap_profiles__get__te

subroutine f90wrap_profiles__set__te(this, f90wrap_te)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_te
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%te = f90wrap_te
end subroutine f90wrap_profiles__set__te

subroutine f90wrap_profiles__get__ti(this, f90wrap_ti)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_ti
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ti = this_ptr%p%ti
end subroutine f90wrap_profiles__get__ti

subroutine f90wrap_profiles__set__ti(this, f90wrap_ti)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_ti
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ti = f90wrap_ti
end subroutine f90wrap_profiles__set__ti

subroutine f90wrap_profiles__get__zeff(this, f90wrap_zeff)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_zeff
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_zeff = this_ptr%p%zeff
end subroutine f90wrap_profiles__get__zeff

subroutine f90wrap_profiles__set__zeff(this, f90wrap_zeff)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_zeff
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%zeff = f90wrap_zeff
end subroutine f90wrap_profiles__set__zeff

subroutine f90wrap_profiles__get__vr(this, f90wrap_vr)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_vr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_vr = this_ptr%p%vr
end subroutine f90wrap_profiles__get__vr

subroutine f90wrap_profiles__set__vr(this, f90wrap_vr)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_vr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%vr = f90wrap_vr
end subroutine f90wrap_profiles__set__vr

subroutine f90wrap_profiles__get__vt(this, f90wrap_vt)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_vt
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_vt = this_ptr%p%vt
end subroutine f90wrap_profiles__get__vt

subroutine f90wrap_profiles__set__vt(this, f90wrap_vt)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_vt
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%vt = f90wrap_vt
end subroutine f90wrap_profiles__set__vt

subroutine f90wrap_profiles__get__vz(this, f90wrap_vz)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_vz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_vz = this_ptr%p%vz
end subroutine f90wrap_profiles__get__vz

subroutine f90wrap_profiles__set__vz(this, f90wrap_vz)
    use libfida, only: profiles
    implicit none
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    integer, intent(in)   :: this(2)
    type(profiles_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_vz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%vz = f90wrap_vz
end subroutine f90wrap_profiles__set__vz

subroutine f90wrap_profiles_initialise(this)
    use libfida, only: profiles
    implicit none
    
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    type(profiles_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_profiles_initialise

subroutine f90wrap_profiles_finalise(this)
    use libfida, only: profiles
    implicit none
    
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    type(profiles_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_profiles_finalise

subroutine f90wrap_localprofiles__get__in_plasma(this, f90wrap_in_plasma)
    use libfida, only: localprofiles
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    integer, intent(in)   :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    logical, intent(out) :: f90wrap_in_plasma
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_in_plasma = this_ptr%p%in_plasma
end subroutine f90wrap_localprofiles__get__in_plasma

subroutine f90wrap_localprofiles__set__in_plasma(this, f90wrap_in_plasma)
    use libfida, only: localprofiles
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    integer, intent(in)   :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    logical, intent(in) :: f90wrap_in_plasma
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%in_plasma = f90wrap_in_plasma
end subroutine f90wrap_localprofiles__set__in_plasma

subroutine f90wrap_localprofiles__get__machine_coords(this, &
    f90wrap_machine_coords)
    use libfida, only: localprofiles
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    integer, intent(in)   :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    logical, intent(out) :: f90wrap_machine_coords
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_machine_coords = this_ptr%p%machine_coords
end subroutine f90wrap_localprofiles__get__machine_coords

subroutine f90wrap_localprofiles__set__machine_coords(this, &
    f90wrap_machine_coords)
    use libfida, only: localprofiles
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    integer, intent(in)   :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    logical, intent(in) :: f90wrap_machine_coords
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%machine_coords = f90wrap_machine_coords
end subroutine f90wrap_localprofiles__set__machine_coords

subroutine f90wrap_localprofiles__array__pos(this, nd, dtype, dshape, dloc)
    use libfida, only: localprofiles
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    integer, intent(in) :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%pos)
    dloc = loc(this_ptr%p%pos)
end subroutine f90wrap_localprofiles__array__pos

subroutine f90wrap_localprofiles__array__uvw(this, nd, dtype, dshape, dloc)
    use libfida, only: localprofiles
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    integer, intent(in) :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%uvw)
    dloc = loc(this_ptr%p%uvw)
end subroutine f90wrap_localprofiles__array__uvw

subroutine f90wrap_localprofiles__array__vrot(this, nd, dtype, dshape, dloc)
    use libfida, only: localprofiles
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    integer, intent(in) :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%vrot)
    dloc = loc(this_ptr%p%vrot)
end subroutine f90wrap_localprofiles__array__vrot

subroutine f90wrap_localprofiles__get__c(this, f90wrap_c)
    use libfida, only: localprofiles, interpolcoeffs2d
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_c(2)
    type(interpolcoeffs2d_ptr_type) :: c_ptr
    
    this_ptr = transfer(this, this_ptr)
    c_ptr%p => this_ptr%p%c
    f90wrap_c = transfer(c_ptr,f90wrap_c)
end subroutine f90wrap_localprofiles__get__c

subroutine f90wrap_localprofiles__set__c(this, f90wrap_c)
    use libfida, only: localprofiles, interpolcoeffs2d
    implicit none
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(localprofiles_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_c(2)
    type(interpolcoeffs2d_ptr_type) :: c_ptr
    
    this_ptr = transfer(this, this_ptr)
    c_ptr = transfer(f90wrap_c,c_ptr)
    this_ptr%p%c = c_ptr%p
end subroutine f90wrap_localprofiles__set__c

subroutine f90wrap_localprofiles_initialise(this)
    use libfida, only: localprofiles
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_localprofiles_initialise

subroutine f90wrap_localprofiles_finalise(this)
    use libfida, only: localprofiles
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_localprofiles_finalise

subroutine f90wrap_emfields__get__br(this, f90wrap_br)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_br
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_br = this_ptr%p%br
end subroutine f90wrap_emfields__get__br

subroutine f90wrap_emfields__set__br(this, f90wrap_br)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_br
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%br = f90wrap_br
end subroutine f90wrap_emfields__set__br

subroutine f90wrap_emfields__get__bt(this, f90wrap_bt)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_bt
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_bt = this_ptr%p%bt
end subroutine f90wrap_emfields__get__bt

subroutine f90wrap_emfields__set__bt(this, f90wrap_bt)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_bt
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%bt = f90wrap_bt
end subroutine f90wrap_emfields__set__bt

subroutine f90wrap_emfields__get__bz(this, f90wrap_bz)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_bz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_bz = this_ptr%p%bz
end subroutine f90wrap_emfields__get__bz

subroutine f90wrap_emfields__set__bz(this, f90wrap_bz)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_bz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%bz = f90wrap_bz
end subroutine f90wrap_emfields__set__bz

subroutine f90wrap_emfields__get__er(this, f90wrap_er)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_er
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_er = this_ptr%p%er
end subroutine f90wrap_emfields__get__er

subroutine f90wrap_emfields__set__er(this, f90wrap_er)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_er
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%er = f90wrap_er
end subroutine f90wrap_emfields__set__er

subroutine f90wrap_emfields__get__et(this, f90wrap_et)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_et
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_et = this_ptr%p%et
end subroutine f90wrap_emfields__get__et

subroutine f90wrap_emfields__set__et(this, f90wrap_et)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_et
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%et = f90wrap_et
end subroutine f90wrap_emfields__set__et

subroutine f90wrap_emfields__get__ez(this, f90wrap_ez)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_ez
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ez = this_ptr%p%ez
end subroutine f90wrap_emfields__get__ez

subroutine f90wrap_emfields__set__ez(this, f90wrap_ez)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_ez
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ez = f90wrap_ez
end subroutine f90wrap_emfields__set__ez

subroutine f90wrap_emfields__get__dbr_dr(this, f90wrap_dbr_dr)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dbr_dr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dbr_dr = this_ptr%p%dbr_dr
end subroutine f90wrap_emfields__get__dbr_dr

subroutine f90wrap_emfields__set__dbr_dr(this, f90wrap_dbr_dr)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dbr_dr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dbr_dr = f90wrap_dbr_dr
end subroutine f90wrap_emfields__set__dbr_dr

subroutine f90wrap_emfields__get__dbr_dz(this, f90wrap_dbr_dz)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dbr_dz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dbr_dz = this_ptr%p%dbr_dz
end subroutine f90wrap_emfields__get__dbr_dz

subroutine f90wrap_emfields__set__dbr_dz(this, f90wrap_dbr_dz)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dbr_dz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dbr_dz = f90wrap_dbr_dz
end subroutine f90wrap_emfields__set__dbr_dz

subroutine f90wrap_emfields__get__dbt_dr(this, f90wrap_dbt_dr)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dbt_dr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dbt_dr = this_ptr%p%dbt_dr
end subroutine f90wrap_emfields__get__dbt_dr

subroutine f90wrap_emfields__set__dbt_dr(this, f90wrap_dbt_dr)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dbt_dr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dbt_dr = f90wrap_dbt_dr
end subroutine f90wrap_emfields__set__dbt_dr

subroutine f90wrap_emfields__get__dbt_dz(this, f90wrap_dbt_dz)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dbt_dz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dbt_dz = this_ptr%p%dbt_dz
end subroutine f90wrap_emfields__get__dbt_dz

subroutine f90wrap_emfields__set__dbt_dz(this, f90wrap_dbt_dz)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dbt_dz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dbt_dz = f90wrap_dbt_dz
end subroutine f90wrap_emfields__set__dbt_dz

subroutine f90wrap_emfields__get__dbz_dr(this, f90wrap_dbz_dr)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dbz_dr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dbz_dr = this_ptr%p%dbz_dr
end subroutine f90wrap_emfields__get__dbz_dr

subroutine f90wrap_emfields__set__dbz_dr(this, f90wrap_dbz_dr)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dbz_dr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dbz_dr = f90wrap_dbz_dr
end subroutine f90wrap_emfields__set__dbz_dr

subroutine f90wrap_emfields__get__dbz_dz(this, f90wrap_dbz_dz)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dbz_dz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dbz_dz = this_ptr%p%dbz_dz
end subroutine f90wrap_emfields__get__dbz_dz

subroutine f90wrap_emfields__set__dbz_dz(this, f90wrap_dbz_dz)
    use libfida, only: emfields
    implicit none
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    integer, intent(in)   :: this(2)
    type(emfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dbz_dz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dbz_dz = f90wrap_dbz_dz
end subroutine f90wrap_emfields__set__dbz_dz

subroutine f90wrap_emfields_initialise(this)
    use libfida, only: emfields
    implicit none
    
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    type(emfields_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_emfields_initialise

subroutine f90wrap_emfields_finalise(this)
    use libfida, only: emfields
    implicit none
    
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    type(emfields_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_emfields_finalise

subroutine f90wrap_localemfields__get__in_plasma(this, f90wrap_in_plasma)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    logical, intent(out) :: f90wrap_in_plasma
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_in_plasma = this_ptr%p%in_plasma
end subroutine f90wrap_localemfields__get__in_plasma

subroutine f90wrap_localemfields__set__in_plasma(this, f90wrap_in_plasma)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    logical, intent(in) :: f90wrap_in_plasma
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%in_plasma = f90wrap_in_plasma
end subroutine f90wrap_localemfields__set__in_plasma

subroutine f90wrap_localemfields__get__machine_coords(this, &
    f90wrap_machine_coords)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    logical, intent(out) :: f90wrap_machine_coords
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_machine_coords = this_ptr%p%machine_coords
end subroutine f90wrap_localemfields__get__machine_coords

subroutine f90wrap_localemfields__set__machine_coords(this, &
    f90wrap_machine_coords)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    logical, intent(in) :: f90wrap_machine_coords
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%machine_coords = f90wrap_machine_coords
end subroutine f90wrap_localemfields__set__machine_coords

subroutine f90wrap_localemfields__get__b_abs(this, f90wrap_b_abs)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_b_abs
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_b_abs = this_ptr%p%b_abs
end subroutine f90wrap_localemfields__get__b_abs

subroutine f90wrap_localemfields__set__b_abs(this, f90wrap_b_abs)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_b_abs
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%b_abs = f90wrap_b_abs
end subroutine f90wrap_localemfields__set__b_abs

subroutine f90wrap_localemfields__get__e_abs(this, f90wrap_e_abs)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_e_abs
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_e_abs = this_ptr%p%e_abs
end subroutine f90wrap_localemfields__get__e_abs

subroutine f90wrap_localemfields__set__e_abs(this, f90wrap_e_abs)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_e_abs
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%e_abs = f90wrap_e_abs
end subroutine f90wrap_localemfields__set__e_abs

subroutine f90wrap_localemfields__array__pos(this, nd, dtype, dshape, dloc)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in) :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%pos)
    dloc = loc(this_ptr%p%pos)
end subroutine f90wrap_localemfields__array__pos

subroutine f90wrap_localemfields__array__uvw(this, nd, dtype, dshape, dloc)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in) :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%uvw)
    dloc = loc(this_ptr%p%uvw)
end subroutine f90wrap_localemfields__array__uvw

subroutine f90wrap_localemfields__array__b_norm(this, nd, dtype, dshape, dloc)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in) :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%b_norm)
    dloc = loc(this_ptr%p%b_norm)
end subroutine f90wrap_localemfields__array__b_norm

subroutine f90wrap_localemfields__array__a_norm(this, nd, dtype, dshape, dloc)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in) :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%a_norm)
    dloc = loc(this_ptr%p%a_norm)
end subroutine f90wrap_localemfields__array__a_norm

subroutine f90wrap_localemfields__array__c_norm(this, nd, dtype, dshape, dloc)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in) :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%c_norm)
    dloc = loc(this_ptr%p%c_norm)
end subroutine f90wrap_localemfields__array__c_norm

subroutine f90wrap_localemfields__array__e_norm(this, nd, dtype, dshape, dloc)
    use libfida, only: localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in) :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%e_norm)
    dloc = loc(this_ptr%p%e_norm)
end subroutine f90wrap_localemfields__array__e_norm

subroutine f90wrap_localemfields__get__c(this, f90wrap_c)
    use libfida, only: interpolcoeffs2d, localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_c(2)
    type(interpolcoeffs2d_ptr_type) :: c_ptr
    
    this_ptr = transfer(this, this_ptr)
    c_ptr%p => this_ptr%p%c
    f90wrap_c = transfer(c_ptr,f90wrap_c)
end subroutine f90wrap_localemfields__get__c

subroutine f90wrap_localemfields__set__c(this, f90wrap_c)
    use libfida, only: interpolcoeffs2d, localemfields
    implicit none
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    integer, intent(in)   :: this(2)
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_c(2)
    type(interpolcoeffs2d_ptr_type) :: c_ptr
    
    this_ptr = transfer(this, this_ptr)
    c_ptr = transfer(f90wrap_c,c_ptr)
    this_ptr%p%c = c_ptr%p
end subroutine f90wrap_localemfields__set__c

subroutine f90wrap_localemfields_initialise(this)
    use libfida, only: localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_localemfields_initialise

subroutine f90wrap_localemfields_finalise(this)
    use libfida, only: localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(localemfields_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_localemfields_finalise

subroutine f90wrap_equilibrium__array__mask(this, nd, dtype, dshape, dloc)
    use libfida, only: equilibrium
    implicit none
    type equilibrium_ptr_type
        type(equilibrium), pointer :: p => NULL()
    end type equilibrium_ptr_type
    integer, intent(in) :: this(2)
    type(equilibrium_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%mask)) then
        dshape(1:2) = shape(this_ptr%p%mask)
        dloc = loc(this_ptr%p%mask)
    else
        dloc = 0
    end if
end subroutine f90wrap_equilibrium__array__mask

subroutine f90wrap_equilibrium_initialise(this)
    use libfida, only: equilibrium
    implicit none
    
    type equilibrium_ptr_type
        type(equilibrium), pointer :: p => NULL()
    end type equilibrium_ptr_type
    type(equilibrium_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_equilibrium_initialise

subroutine f90wrap_equilibrium_finalise(this)
    use libfida, only: equilibrium
    implicit none
    
    type equilibrium_ptr_type
        type(equilibrium), pointer :: p => NULL()
    end type equilibrium_ptr_type
    type(equilibrium_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_equilibrium_finalise

subroutine f90wrap_fastiondistribution__get__nenergy(this, f90wrap_nenergy)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nenergy = this_ptr%p%nenergy
end subroutine f90wrap_fastiondistribution__get__nenergy

subroutine f90wrap_fastiondistribution__set__nenergy(this, f90wrap_nenergy)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nenergy = f90wrap_nenergy
end subroutine f90wrap_fastiondistribution__set__nenergy

subroutine f90wrap_fastiondistribution__get__npitch(this, f90wrap_npitch)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_npitch
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_npitch = this_ptr%p%npitch
end subroutine f90wrap_fastiondistribution__get__npitch

subroutine f90wrap_fastiondistribution__set__npitch(this, f90wrap_npitch)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_npitch
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%npitch = f90wrap_npitch
end subroutine f90wrap_fastiondistribution__set__npitch

subroutine f90wrap_fastiondistribution__get__nr(this, f90wrap_nr)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nr = this_ptr%p%nr
end subroutine f90wrap_fastiondistribution__get__nr

subroutine f90wrap_fastiondistribution__set__nr(this, f90wrap_nr)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nr = f90wrap_nr
end subroutine f90wrap_fastiondistribution__set__nr

subroutine f90wrap_fastiondistribution__get__nz(this, f90wrap_nz)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nz = this_ptr%p%nz
end subroutine f90wrap_fastiondistribution__get__nz

subroutine f90wrap_fastiondistribution__set__nz(this, f90wrap_nz)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nz = f90wrap_nz
end subroutine f90wrap_fastiondistribution__set__nz

subroutine f90wrap_fastiondistribution__get__de(this, f90wrap_de)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_de
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_de = this_ptr%p%de
end subroutine f90wrap_fastiondistribution__get__de

subroutine f90wrap_fastiondistribution__set__de(this, f90wrap_de)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_de
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%de = f90wrap_de
end subroutine f90wrap_fastiondistribution__set__de

subroutine f90wrap_fastiondistribution__get__dp(this, f90wrap_dp)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dp
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dp = this_ptr%p%dp
end subroutine f90wrap_fastiondistribution__get__dp

subroutine f90wrap_fastiondistribution__set__dp(this, f90wrap_dp)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dp
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dp = f90wrap_dp
end subroutine f90wrap_fastiondistribution__set__dp

subroutine f90wrap_fastiondistribution__get__dr(this, f90wrap_dr)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dr = this_ptr%p%dr
end subroutine f90wrap_fastiondistribution__get__dr

subroutine f90wrap_fastiondistribution__set__dr(this, f90wrap_dr)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dr = f90wrap_dr
end subroutine f90wrap_fastiondistribution__set__dr

subroutine f90wrap_fastiondistribution__get__dz(this, f90wrap_dz)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dz = this_ptr%p%dz
end subroutine f90wrap_fastiondistribution__get__dz

subroutine f90wrap_fastiondistribution__set__dz(this, f90wrap_dz)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dz = f90wrap_dz
end subroutine f90wrap_fastiondistribution__set__dz

subroutine f90wrap_fastiondistribution__get__emin(this, f90wrap_emin)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_emin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_emin = this_ptr%p%emin
end subroutine f90wrap_fastiondistribution__get__emin

subroutine f90wrap_fastiondistribution__set__emin(this, f90wrap_emin)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_emin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%emin = f90wrap_emin
end subroutine f90wrap_fastiondistribution__set__emin

subroutine f90wrap_fastiondistribution__get__emax(this, f90wrap_emax)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_emax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_emax = this_ptr%p%emax
end subroutine f90wrap_fastiondistribution__get__emax

subroutine f90wrap_fastiondistribution__set__emax(this, f90wrap_emax)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_emax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%emax = f90wrap_emax
end subroutine f90wrap_fastiondistribution__set__emax

subroutine f90wrap_fastiondistribution__get__e_range(this, f90wrap_e_range)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_e_range
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_e_range = this_ptr%p%e_range
end subroutine f90wrap_fastiondistribution__get__e_range

subroutine f90wrap_fastiondistribution__set__e_range(this, f90wrap_e_range)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_e_range
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%e_range = f90wrap_e_range
end subroutine f90wrap_fastiondistribution__set__e_range

subroutine f90wrap_fastiondistribution__get__pmin(this, f90wrap_pmin)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_pmin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_pmin = this_ptr%p%pmin
end subroutine f90wrap_fastiondistribution__get__pmin

subroutine f90wrap_fastiondistribution__set__pmin(this, f90wrap_pmin)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_pmin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%pmin = f90wrap_pmin
end subroutine f90wrap_fastiondistribution__set__pmin

subroutine f90wrap_fastiondistribution__get__pmax(this, f90wrap_pmax)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_pmax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_pmax = this_ptr%p%pmax
end subroutine f90wrap_fastiondistribution__get__pmax

subroutine f90wrap_fastiondistribution__set__pmax(this, f90wrap_pmax)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_pmax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%pmax = f90wrap_pmax
end subroutine f90wrap_fastiondistribution__set__pmax

subroutine f90wrap_fastiondistribution__get__p_range(this, f90wrap_p_range)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_p_range
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_p_range = this_ptr%p%p_range
end subroutine f90wrap_fastiondistribution__get__p_range

subroutine f90wrap_fastiondistribution__set__p_range(this, f90wrap_p_range)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_p_range
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%p_range = f90wrap_p_range
end subroutine f90wrap_fastiondistribution__set__p_range

subroutine f90wrap_fastiondistribution__get__n_tot(this, f90wrap_n_tot)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_n_tot
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_tot = this_ptr%p%n_tot
end subroutine f90wrap_fastiondistribution__get__n_tot

subroutine f90wrap_fastiondistribution__set__n_tot(this, f90wrap_n_tot)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in)   :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_n_tot
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_tot = f90wrap_n_tot
end subroutine f90wrap_fastiondistribution__set__n_tot

subroutine f90wrap_fastiondistribution__array__energy(this, nd, dtype, dshape, &
    dloc)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in) :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%energy)) then
        dshape(1:1) = shape(this_ptr%p%energy)
        dloc = loc(this_ptr%p%energy)
    else
        dloc = 0
    end if
end subroutine f90wrap_fastiondistribution__array__energy

subroutine f90wrap_fastiondistribution__array__pitch(this, nd, dtype, dshape, &
    dloc)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in) :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%pitch)) then
        dshape(1:1) = shape(this_ptr%p%pitch)
        dloc = loc(this_ptr%p%pitch)
    else
        dloc = 0
    end if
end subroutine f90wrap_fastiondistribution__array__pitch

subroutine f90wrap_fastiondistribution__array__r(this, nd, dtype, dshape, dloc)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in) :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%r)) then
        dshape(1:1) = shape(this_ptr%p%r)
        dloc = loc(this_ptr%p%r)
    else
        dloc = 0
    end if
end subroutine f90wrap_fastiondistribution__array__r

subroutine f90wrap_fastiondistribution__array__z(this, nd, dtype, dshape, dloc)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in) :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%z)) then
        dshape(1:1) = shape(this_ptr%p%z)
        dloc = loc(this_ptr%p%z)
    else
        dloc = 0
    end if
end subroutine f90wrap_fastiondistribution__array__z

subroutine f90wrap_fastiondistribution__array__denf(this, nd, dtype, dshape, &
    dloc)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in) :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%denf)) then
        dshape(1:2) = shape(this_ptr%p%denf)
        dloc = loc(this_ptr%p%denf)
    else
        dloc = 0
    end if
end subroutine f90wrap_fastiondistribution__array__denf

subroutine f90wrap_fastiondistribution__array__f(this, nd, dtype, dshape, dloc)
    use libfida, only: fastiondistribution
    implicit none
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    integer, intent(in) :: this(2)
    type(fastiondistribution_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 4
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%f)) then
        dshape(1:4) = shape(this_ptr%p%f)
        dloc = loc(this_ptr%p%f)
    else
        dloc = 0
    end if
end subroutine f90wrap_fastiondistribution__array__f

subroutine f90wrap_fastiondistribution_initialise(this)
    use libfida, only: fastiondistribution
    implicit none
    
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    type(fastiondistribution_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_fastiondistribution_initialise

subroutine f90wrap_fastiondistribution_finalise(this)
    use libfida, only: fastiondistribution
    implicit none
    
    type fastiondistribution_ptr_type
        type(fastiondistribution), pointer :: p => NULL()
    end type fastiondistribution_ptr_type
    type(fastiondistribution_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_fastiondistribution_finalise

subroutine f90wrap_fastion__get__cross_grid(this, f90wrap_cross_grid)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    logical, intent(out) :: f90wrap_cross_grid
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_cross_grid = this_ptr%p%cross_grid
end subroutine f90wrap_fastion__get__cross_grid

subroutine f90wrap_fastion__set__cross_grid(this, f90wrap_cross_grid)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    logical, intent(in) :: f90wrap_cross_grid
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%cross_grid = f90wrap_cross_grid
end subroutine f90wrap_fastion__set__cross_grid

subroutine f90wrap_fastion__get__r(this, f90wrap_r)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_r
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_r = this_ptr%p%r
end subroutine f90wrap_fastion__get__r

subroutine f90wrap_fastion__set__r(this, f90wrap_r)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_r
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%r = f90wrap_r
end subroutine f90wrap_fastion__set__r

subroutine f90wrap_fastion__get__z(this, f90wrap_z)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_z
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_z = this_ptr%p%z
end subroutine f90wrap_fastion__get__z

subroutine f90wrap_fastion__set__z(this, f90wrap_z)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_z
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%z = f90wrap_z
end subroutine f90wrap_fastion__set__z

subroutine f90wrap_fastion__get__phi_enter(this, f90wrap_phi_enter)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_phi_enter
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_phi_enter = this_ptr%p%phi_enter
end subroutine f90wrap_fastion__get__phi_enter

subroutine f90wrap_fastion__set__phi_enter(this, f90wrap_phi_enter)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_phi_enter
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%phi_enter = f90wrap_phi_enter
end subroutine f90wrap_fastion__set__phi_enter

subroutine f90wrap_fastion__get__delta_phi(this, f90wrap_delta_phi)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_delta_phi
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_delta_phi = this_ptr%p%delta_phi
end subroutine f90wrap_fastion__get__delta_phi

subroutine f90wrap_fastion__set__delta_phi(this, f90wrap_delta_phi)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_delta_phi
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%delta_phi = f90wrap_delta_phi
end subroutine f90wrap_fastion__set__delta_phi

subroutine f90wrap_fastion__get__energy(this, f90wrap_energy)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_energy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_energy = this_ptr%p%energy
end subroutine f90wrap_fastion__get__energy

subroutine f90wrap_fastion__set__energy(this, f90wrap_energy)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_energy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%energy = f90wrap_energy
end subroutine f90wrap_fastion__set__energy

subroutine f90wrap_fastion__get__pitch(this, f90wrap_pitch)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_pitch
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_pitch = this_ptr%p%pitch
end subroutine f90wrap_fastion__get__pitch

subroutine f90wrap_fastion__set__pitch(this, f90wrap_pitch)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_pitch
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%pitch = f90wrap_pitch
end subroutine f90wrap_fastion__set__pitch

subroutine f90wrap_fastion__get__vabs(this, f90wrap_vabs)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_vabs
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_vabs = this_ptr%p%vabs
end subroutine f90wrap_fastion__get__vabs

subroutine f90wrap_fastion__set__vabs(this, f90wrap_vabs)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_vabs
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%vabs = f90wrap_vabs
end subroutine f90wrap_fastion__set__vabs

subroutine f90wrap_fastion__get__vr(this, f90wrap_vr)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_vr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_vr = this_ptr%p%vr
end subroutine f90wrap_fastion__get__vr

subroutine f90wrap_fastion__set__vr(this, f90wrap_vr)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_vr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%vr = f90wrap_vr
end subroutine f90wrap_fastion__set__vr

subroutine f90wrap_fastion__get__vt(this, f90wrap_vt)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_vt
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_vt = this_ptr%p%vt
end subroutine f90wrap_fastion__get__vt

subroutine f90wrap_fastion__set__vt(this, f90wrap_vt)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_vt
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%vt = f90wrap_vt
end subroutine f90wrap_fastion__set__vt

subroutine f90wrap_fastion__get__vz(this, f90wrap_vz)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_vz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_vz = this_ptr%p%vz
end subroutine f90wrap_fastion__get__vz

subroutine f90wrap_fastion__set__vz(this, f90wrap_vz)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_vz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%vz = f90wrap_vz
end subroutine f90wrap_fastion__set__vz

subroutine f90wrap_fastion__get__weight(this, f90wrap_weight)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_weight
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_weight = this_ptr%p%weight
end subroutine f90wrap_fastion__get__weight

subroutine f90wrap_fastion__set__weight(this, f90wrap_weight)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_weight
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%weight = f90wrap_weight
end subroutine f90wrap_fastion__set__weight

subroutine f90wrap_fastion__get__class(this, f90wrap_class)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_class
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_class = this_ptr%p%class
end subroutine f90wrap_fastion__get__class

subroutine f90wrap_fastion__set__class(this, f90wrap_class)
    use libfida, only: fastion
    implicit none
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in)   :: this(2)
    type(fastion_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_class
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%class = f90wrap_class
end subroutine f90wrap_fastion__set__class

subroutine f90wrap_fastion_initialise(this)
    use libfida, only: fastion
    implicit none
    
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    type(fastion_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_fastion_initialise

subroutine f90wrap_fastion_finalise(this)
    use libfida, only: fastion
    implicit none
    
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    type(fastion_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_fastion_finalise

subroutine f90wrap_fastionparticles__get__nparticle(this, f90wrap_nparticle)
    use libfida, only: fastionparticles
    implicit none
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    integer, intent(in)   :: this(2)
    type(fastionparticles_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nparticle
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nparticle = this_ptr%p%nparticle
end subroutine f90wrap_fastionparticles__get__nparticle

subroutine f90wrap_fastionparticles__set__nparticle(this, f90wrap_nparticle)
    use libfida, only: fastionparticles
    implicit none
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    integer, intent(in)   :: this(2)
    type(fastionparticles_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nparticle
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nparticle = f90wrap_nparticle
end subroutine f90wrap_fastionparticles__set__nparticle

subroutine f90wrap_fastionparticles__get__nclass(this, f90wrap_nclass)
    use libfida, only: fastionparticles
    implicit none
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    integer, intent(in)   :: this(2)
    type(fastionparticles_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nclass
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nclass = this_ptr%p%nclass
end subroutine f90wrap_fastionparticles__get__nclass

subroutine f90wrap_fastionparticles__set__nclass(this, f90wrap_nclass)
    use libfida, only: fastionparticles
    implicit none
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    integer, intent(in)   :: this(2)
    type(fastionparticles_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nclass
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nclass = f90wrap_nclass
end subroutine f90wrap_fastionparticles__set__nclass

subroutine f90wrap_fastionparticles__array_getitem__fast_ion(f90wrap_this, &
    f90wrap_i, fast_ionitem)
    
    use libfida, only: fastionparticles, fastion
    implicit none
    
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(fastionparticles_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(out) :: fast_ionitem(2)
    type(fastion_ptr_type) :: fast_ion_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%fast_ion)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%fast_ion)) then
            call f90wrap_abort("array index out of range")
        else
            fast_ion_ptr%p => this_ptr%p%fast_ion(f90wrap_i)
            fast_ionitem = transfer(fast_ion_ptr,fast_ionitem)
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_fastionparticles__array_getitem__fast_ion

subroutine f90wrap_fastionparticles__array_setitem__fast_ion(f90wrap_this, &
    f90wrap_i, fast_ionitem)
    
    use libfida, only: fastionparticles, fastion
    implicit none
    
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(fastionparticles_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(in) :: fast_ionitem(2)
    type(fastion_ptr_type) :: fast_ion_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%fast_ion)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%fast_ion)) then
            call f90wrap_abort("array index out of range")
        else
            fast_ion_ptr = transfer(fast_ionitem,fast_ion_ptr)
            this_ptr%p%fast_ion(f90wrap_i) = fast_ion_ptr%p
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_fastionparticles__array_setitem__fast_ion

subroutine f90wrap_fastionparticles__array_len__fast_ion(f90wrap_this, &
    f90wrap_n)
    
    use libfida, only: fastionparticles, fastion
    implicit none
    
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    integer, intent(out) :: f90wrap_n
    integer, intent(in) :: f90wrap_this(2)
    type(fastionparticles_ptr_type) :: this_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%fast_ion)) then
        f90wrap_n = size(this_ptr%p%fast_ion)
    else
        f90wrap_n = 0
    end if
end subroutine f90wrap_fastionparticles__array_len__fast_ion

subroutine f90wrap_fastionparticles_initialise(this)
    use libfida, only: fastionparticles
    implicit none
    
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    type(fastionparticles_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_fastionparticles_initialise

subroutine f90wrap_fastionparticles_finalise(this)
    use libfida, only: fastionparticles
    implicit none
    
    type fastionparticles_ptr_type
        type(fastionparticles), pointer :: p => NULL()
    end type fastionparticles_ptr_type
    type(fastionparticles_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_fastionparticles_finalise

subroutine f90wrap_neutralbeam__get__name(this, f90wrap_name)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    character(25), intent(out) :: f90wrap_name
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_name = this_ptr%p%name
end subroutine f90wrap_neutralbeam__get__name

subroutine f90wrap_neutralbeam__set__name(this, f90wrap_name)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    character(25), intent(in) :: f90wrap_name
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%name = f90wrap_name
end subroutine f90wrap_neutralbeam__set__name

subroutine f90wrap_neutralbeam__get__shape(this, f90wrap_shape)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_shape
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_shape = this_ptr%p%shape
end subroutine f90wrap_neutralbeam__get__shape

subroutine f90wrap_neutralbeam__set__shape(this, f90wrap_shape)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_shape
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%shape = f90wrap_shape
end subroutine f90wrap_neutralbeam__set__shape

subroutine f90wrap_neutralbeam__get__widy(this, f90wrap_widy)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_widy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_widy = this_ptr%p%widy
end subroutine f90wrap_neutralbeam__get__widy

subroutine f90wrap_neutralbeam__set__widy(this, f90wrap_widy)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_widy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%widy = f90wrap_widy
end subroutine f90wrap_neutralbeam__set__widy

subroutine f90wrap_neutralbeam__get__widz(this, f90wrap_widz)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_widz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_widz = this_ptr%p%widz
end subroutine f90wrap_neutralbeam__get__widz

subroutine f90wrap_neutralbeam__set__widz(this, f90wrap_widz)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_widz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%widz = f90wrap_widz
end subroutine f90wrap_neutralbeam__set__widz

subroutine f90wrap_neutralbeam__get__focy(this, f90wrap_focy)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_focy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_focy = this_ptr%p%focy
end subroutine f90wrap_neutralbeam__get__focy

subroutine f90wrap_neutralbeam__set__focy(this, f90wrap_focy)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_focy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%focy = f90wrap_focy
end subroutine f90wrap_neutralbeam__set__focy

subroutine f90wrap_neutralbeam__get__focz(this, f90wrap_focz)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_focz
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_focz = this_ptr%p%focz
end subroutine f90wrap_neutralbeam__get__focz

subroutine f90wrap_neutralbeam__set__focz(this, f90wrap_focz)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_focz
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%focz = f90wrap_focz
end subroutine f90wrap_neutralbeam__set__focz

subroutine f90wrap_neutralbeam__get__einj(this, f90wrap_einj)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_einj
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_einj = this_ptr%p%einj
end subroutine f90wrap_neutralbeam__get__einj

subroutine f90wrap_neutralbeam__set__einj(this, f90wrap_einj)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_einj
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%einj = f90wrap_einj
end subroutine f90wrap_neutralbeam__set__einj

subroutine f90wrap_neutralbeam__get__pinj(this, f90wrap_pinj)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_pinj
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_pinj = this_ptr%p%pinj
end subroutine f90wrap_neutralbeam__get__pinj

subroutine f90wrap_neutralbeam__set__pinj(this, f90wrap_pinj)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_pinj
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%pinj = f90wrap_pinj
end subroutine f90wrap_neutralbeam__set__pinj

subroutine f90wrap_neutralbeam__get__vinj(this, f90wrap_vinj)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_vinj
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_vinj = this_ptr%p%vinj
end subroutine f90wrap_neutralbeam__get__vinj

subroutine f90wrap_neutralbeam__set__vinj(this, f90wrap_vinj)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_vinj
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%vinj = f90wrap_vinj
end subroutine f90wrap_neutralbeam__set__vinj

subroutine f90wrap_neutralbeam__get__alpha(this, f90wrap_alpha)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_alpha
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_alpha = this_ptr%p%alpha
end subroutine f90wrap_neutralbeam__get__alpha

subroutine f90wrap_neutralbeam__set__alpha(this, f90wrap_alpha)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_alpha
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%alpha = f90wrap_alpha
end subroutine f90wrap_neutralbeam__set__alpha

subroutine f90wrap_neutralbeam__get__beta(this, f90wrap_beta)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_beta
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_beta = this_ptr%p%beta
end subroutine f90wrap_neutralbeam__get__beta

subroutine f90wrap_neutralbeam__set__beta(this, f90wrap_beta)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_beta
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%beta = f90wrap_beta
end subroutine f90wrap_neutralbeam__set__beta

subroutine f90wrap_neutralbeam__array__divy(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%divy)
    dloc = loc(this_ptr%p%divy)
end subroutine f90wrap_neutralbeam__array__divy

subroutine f90wrap_neutralbeam__array__divz(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%divz)
    dloc = loc(this_ptr%p%divz)
end subroutine f90wrap_neutralbeam__array__divz

subroutine f90wrap_neutralbeam__array__current_fractions(this, nd, dtype, &
    dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%current_fractions)
    dloc = loc(this_ptr%p%current_fractions)
end subroutine f90wrap_neutralbeam__array__current_fractions

subroutine f90wrap_neutralbeam__array__src(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%src)
    dloc = loc(this_ptr%p%src)
end subroutine f90wrap_neutralbeam__array__src

subroutine f90wrap_neutralbeam__array__axis(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%axis)
    dloc = loc(this_ptr%p%axis)
end subroutine f90wrap_neutralbeam__array__axis

subroutine f90wrap_neutralbeam__get__naperture(this, f90wrap_naperture)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_naperture
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_naperture = this_ptr%p%naperture
end subroutine f90wrap_neutralbeam__get__naperture

subroutine f90wrap_neutralbeam__set__naperture(this, f90wrap_naperture)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in)   :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_naperture
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%naperture = f90wrap_naperture
end subroutine f90wrap_neutralbeam__set__naperture

subroutine f90wrap_neutralbeam__array__ashape(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 5
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%ashape)) then
        dshape(1:1) = shape(this_ptr%p%ashape)
        dloc = loc(this_ptr%p%ashape)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutralbeam__array__ashape

subroutine f90wrap_neutralbeam__array__awidy(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%awidy)) then
        dshape(1:1) = shape(this_ptr%p%awidy)
        dloc = loc(this_ptr%p%awidy)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutralbeam__array__awidy

subroutine f90wrap_neutralbeam__array__awidz(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%awidz)) then
        dshape(1:1) = shape(this_ptr%p%awidz)
        dloc = loc(this_ptr%p%awidz)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutralbeam__array__awidz

subroutine f90wrap_neutralbeam__array__aoffy(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%aoffy)) then
        dshape(1:1) = shape(this_ptr%p%aoffy)
        dloc = loc(this_ptr%p%aoffy)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutralbeam__array__aoffy

subroutine f90wrap_neutralbeam__array__aoffz(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%aoffz)) then
        dshape(1:1) = shape(this_ptr%p%aoffz)
        dloc = loc(this_ptr%p%aoffz)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutralbeam__array__aoffz

subroutine f90wrap_neutralbeam__array__adist(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%adist)) then
        dshape(1:1) = shape(this_ptr%p%adist)
        dloc = loc(this_ptr%p%adist)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutralbeam__array__adist

subroutine f90wrap_neutralbeam__array__basis(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%basis)
    dloc = loc(this_ptr%p%basis)
end subroutine f90wrap_neutralbeam__array__basis

subroutine f90wrap_neutralbeam__array__inv_basis(this, nd, dtype, dshape, dloc)
    use libfida, only: neutralbeam
    implicit none
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    integer, intent(in) :: this(2)
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%inv_basis)
    dloc = loc(this_ptr%p%inv_basis)
end subroutine f90wrap_neutralbeam__array__inv_basis

subroutine f90wrap_neutralbeam_initialise(this)
    use libfida, only: neutralbeam
    implicit none
    
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_neutralbeam_initialise

subroutine f90wrap_neutralbeam_finalise(this)
    use libfida, only: neutralbeam
    implicit none
    
    type neutralbeam_ptr_type
        type(neutralbeam), pointer :: p => NULL()
    end type neutralbeam_ptr_type
    type(neutralbeam_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_neutralbeam_finalise

subroutine f90wrap_atomiccrosssection__get__nenergy(this, f90wrap_nenergy)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nenergy = this_ptr%p%nenergy
end subroutine f90wrap_atomiccrosssection__get__nenergy

subroutine f90wrap_atomiccrosssection__set__nenergy(this, f90wrap_nenergy)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nenergy = f90wrap_nenergy
end subroutine f90wrap_atomiccrosssection__set__nenergy

subroutine f90wrap_atomiccrosssection__get__logemin(this, f90wrap_logemin)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logemin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logemin = this_ptr%p%logemin
end subroutine f90wrap_atomiccrosssection__get__logemin

subroutine f90wrap_atomiccrosssection__set__logemin(this, f90wrap_logemin)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logemin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logemin = f90wrap_logemin
end subroutine f90wrap_atomiccrosssection__set__logemin

subroutine f90wrap_atomiccrosssection__get__logemax(this, f90wrap_logemax)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logemax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logemax = this_ptr%p%logemax
end subroutine f90wrap_atomiccrosssection__get__logemax

subroutine f90wrap_atomiccrosssection__set__logemax(this, f90wrap_logemax)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logemax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logemax = f90wrap_logemax
end subroutine f90wrap_atomiccrosssection__set__logemax

subroutine f90wrap_atomiccrosssection__get__n_max(this, f90wrap_n_max)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_n_max
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_max = this_ptr%p%n_max
end subroutine f90wrap_atomiccrosssection__get__n_max

subroutine f90wrap_atomiccrosssection__set__n_max(this, f90wrap_n_max)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_n_max
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_max = f90wrap_n_max
end subroutine f90wrap_atomiccrosssection__set__n_max

subroutine f90wrap_atomiccrosssection__get__m_max(this, f90wrap_m_max)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_m_max
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_m_max = this_ptr%p%m_max
end subroutine f90wrap_atomiccrosssection__get__m_max

subroutine f90wrap_atomiccrosssection__set__m_max(this, f90wrap_m_max)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_m_max
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%m_max = f90wrap_m_max
end subroutine f90wrap_atomiccrosssection__set__m_max

subroutine f90wrap_atomiccrosssection__get__dloge(this, f90wrap_dloge)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dloge
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dloge = this_ptr%p%dloge
end subroutine f90wrap_atomiccrosssection__get__dloge

subroutine f90wrap_atomiccrosssection__set__dloge(this, f90wrap_dloge)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dloge
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dloge = f90wrap_dloge
end subroutine f90wrap_atomiccrosssection__set__dloge

subroutine f90wrap_atomiccrosssection__get__minlog_cross(this, &
    f90wrap_minlog_cross)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_minlog_cross
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_minlog_cross = this_ptr%p%minlog_cross
end subroutine f90wrap_atomiccrosssection__get__minlog_cross

subroutine f90wrap_atomiccrosssection__set__minlog_cross(this, &
    f90wrap_minlog_cross)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_minlog_cross
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%minlog_cross = f90wrap_minlog_cross
end subroutine f90wrap_atomiccrosssection__set__minlog_cross

subroutine f90wrap_atomiccrosssection__array__log_cross(this, nd, dtype, dshape, &
    dloc)
    use libfida, only: atomiccrosssection
    implicit none
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in) :: this(2)
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 3
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%log_cross)) then
        dshape(1:3) = shape(this_ptr%p%log_cross)
        dloc = loc(this_ptr%p%log_cross)
    else
        dloc = 0
    end if
end subroutine f90wrap_atomiccrosssection__array__log_cross

subroutine f90wrap_atomiccrosssection_initialise(this)
    use libfida, only: atomiccrosssection
    implicit none
    
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_atomiccrosssection_initialise

subroutine f90wrap_atomiccrosssection_finalise(this)
    use libfida, only: atomiccrosssection
    implicit none
    
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    type(atomiccrosssection_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_atomiccrosssection_finalise

subroutine f90wrap_atomicrates__get__nenergy(this, f90wrap_nenergy)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nenergy = this_ptr%p%nenergy
end subroutine f90wrap_atomicrates__get__nenergy

subroutine f90wrap_atomicrates__set__nenergy(this, f90wrap_nenergy)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nenergy = f90wrap_nenergy
end subroutine f90wrap_atomicrates__set__nenergy

subroutine f90wrap_atomicrates__get__logemin(this, f90wrap_logemin)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logemin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logemin = this_ptr%p%logemin
end subroutine f90wrap_atomicrates__get__logemin

subroutine f90wrap_atomicrates__set__logemin(this, f90wrap_logemin)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logemin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logemin = f90wrap_logemin
end subroutine f90wrap_atomicrates__set__logemin

subroutine f90wrap_atomicrates__get__logemax(this, f90wrap_logemax)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logemax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logemax = this_ptr%p%logemax
end subroutine f90wrap_atomicrates__get__logemax

subroutine f90wrap_atomicrates__set__logemax(this, f90wrap_logemax)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logemax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logemax = f90wrap_logemax
end subroutine f90wrap_atomicrates__set__logemax

subroutine f90wrap_atomicrates__get__ntemp(this, f90wrap_ntemp)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_ntemp
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ntemp = this_ptr%p%ntemp
end subroutine f90wrap_atomicrates__get__ntemp

subroutine f90wrap_atomicrates__set__ntemp(this, f90wrap_ntemp)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_ntemp
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ntemp = f90wrap_ntemp
end subroutine f90wrap_atomicrates__set__ntemp

subroutine f90wrap_atomicrates__get__logtmin(this, f90wrap_logtmin)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logtmin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logtmin = this_ptr%p%logtmin
end subroutine f90wrap_atomicrates__get__logtmin

subroutine f90wrap_atomicrates__set__logtmin(this, f90wrap_logtmin)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logtmin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logtmin = f90wrap_logtmin
end subroutine f90wrap_atomicrates__set__logtmin

subroutine f90wrap_atomicrates__get__logtmax(this, f90wrap_logtmax)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logtmax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logtmax = this_ptr%p%logtmax
end subroutine f90wrap_atomicrates__get__logtmax

subroutine f90wrap_atomicrates__set__logtmax(this, f90wrap_logtmax)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logtmax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logtmax = f90wrap_logtmax
end subroutine f90wrap_atomicrates__set__logtmax

subroutine f90wrap_atomicrates__get__n_max(this, f90wrap_n_max)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_n_max
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_max = this_ptr%p%n_max
end subroutine f90wrap_atomicrates__get__n_max

subroutine f90wrap_atomicrates__set__n_max(this, f90wrap_n_max)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_n_max
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_max = f90wrap_n_max
end subroutine f90wrap_atomicrates__set__n_max

subroutine f90wrap_atomicrates__get__m_max(this, f90wrap_m_max)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_m_max
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_m_max = this_ptr%p%m_max
end subroutine f90wrap_atomicrates__get__m_max

subroutine f90wrap_atomicrates__set__m_max(this, f90wrap_m_max)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_m_max
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%m_max = f90wrap_m_max
end subroutine f90wrap_atomicrates__set__m_max

subroutine f90wrap_atomicrates__get__dloge(this, f90wrap_dloge)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dloge
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dloge = this_ptr%p%dloge
end subroutine f90wrap_atomicrates__get__dloge

subroutine f90wrap_atomicrates__set__dloge(this, f90wrap_dloge)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dloge
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dloge = f90wrap_dloge
end subroutine f90wrap_atomicrates__set__dloge

subroutine f90wrap_atomicrates__get__dlogt(this, f90wrap_dlogt)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dlogt
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dlogt = this_ptr%p%dlogt
end subroutine f90wrap_atomicrates__get__dlogt

subroutine f90wrap_atomicrates__set__dlogt(this, f90wrap_dlogt)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dlogt
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dlogt = f90wrap_dlogt
end subroutine f90wrap_atomicrates__set__dlogt

subroutine f90wrap_atomicrates__get__minlog_rate(this, f90wrap_minlog_rate)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_minlog_rate
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_minlog_rate = this_ptr%p%minlog_rate
end subroutine f90wrap_atomicrates__get__minlog_rate

subroutine f90wrap_atomicrates__set__minlog_rate(this, f90wrap_minlog_rate)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_minlog_rate
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%minlog_rate = f90wrap_minlog_rate
end subroutine f90wrap_atomicrates__set__minlog_rate

subroutine f90wrap_atomicrates__array__ab(this, nd, dtype, dshape, dloc)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in) :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%ab)
    dloc = loc(this_ptr%p%ab)
end subroutine f90wrap_atomicrates__array__ab

subroutine f90wrap_atomicrates__array__log_rate(this, nd, dtype, dshape, dloc)
    use libfida, only: atomicrates
    implicit none
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in) :: this(2)
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 5
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%log_rate)) then
        dshape(1:5) = shape(this_ptr%p%log_rate)
        dloc = loc(this_ptr%p%log_rate)
    else
        dloc = 0
    end if
end subroutine f90wrap_atomicrates__array__log_rate

subroutine f90wrap_atomicrates_initialise(this)
    use libfida, only: atomicrates
    implicit none
    
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_atomicrates_initialise

subroutine f90wrap_atomicrates_finalise(this)
    use libfida, only: atomicrates
    implicit none
    
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    type(atomicrates_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_atomicrates_finalise

subroutine f90wrap_atomictransitions__get__nenergy(this, f90wrap_nenergy)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nenergy = this_ptr%p%nenergy
end subroutine f90wrap_atomictransitions__get__nenergy

subroutine f90wrap_atomictransitions__set__nenergy(this, f90wrap_nenergy)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nenergy = f90wrap_nenergy
end subroutine f90wrap_atomictransitions__set__nenergy

subroutine f90wrap_atomictransitions__get__logemin(this, f90wrap_logemin)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logemin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logemin = this_ptr%p%logemin
end subroutine f90wrap_atomictransitions__get__logemin

subroutine f90wrap_atomictransitions__set__logemin(this, f90wrap_logemin)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logemin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logemin = f90wrap_logemin
end subroutine f90wrap_atomictransitions__set__logemin

subroutine f90wrap_atomictransitions__get__logemax(this, f90wrap_logemax)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logemax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logemax = this_ptr%p%logemax
end subroutine f90wrap_atomictransitions__get__logemax

subroutine f90wrap_atomictransitions__set__logemax(this, f90wrap_logemax)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logemax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logemax = f90wrap_logemax
end subroutine f90wrap_atomictransitions__set__logemax

subroutine f90wrap_atomictransitions__get__ntemp(this, f90wrap_ntemp)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_ntemp
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ntemp = this_ptr%p%ntemp
end subroutine f90wrap_atomictransitions__get__ntemp

subroutine f90wrap_atomictransitions__set__ntemp(this, f90wrap_ntemp)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_ntemp
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ntemp = f90wrap_ntemp
end subroutine f90wrap_atomictransitions__set__ntemp

subroutine f90wrap_atomictransitions__get__logtmin(this, f90wrap_logtmin)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logtmin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logtmin = this_ptr%p%logtmin
end subroutine f90wrap_atomictransitions__get__logtmin

subroutine f90wrap_atomictransitions__set__logtmin(this, f90wrap_logtmin)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logtmin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logtmin = f90wrap_logtmin
end subroutine f90wrap_atomictransitions__set__logtmin

subroutine f90wrap_atomictransitions__get__logtmax(this, f90wrap_logtmax)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logtmax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logtmax = this_ptr%p%logtmax
end subroutine f90wrap_atomictransitions__get__logtmax

subroutine f90wrap_atomictransitions__set__logtmax(this, f90wrap_logtmax)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logtmax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logtmax = f90wrap_logtmax
end subroutine f90wrap_atomictransitions__set__logtmax

subroutine f90wrap_atomictransitions__get__n_max(this, f90wrap_n_max)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_n_max
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_max = this_ptr%p%n_max
end subroutine f90wrap_atomictransitions__get__n_max

subroutine f90wrap_atomictransitions__set__n_max(this, f90wrap_n_max)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_n_max
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_max = f90wrap_n_max
end subroutine f90wrap_atomictransitions__set__n_max

subroutine f90wrap_atomictransitions__get__m_max(this, f90wrap_m_max)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_m_max
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_m_max = this_ptr%p%m_max
end subroutine f90wrap_atomictransitions__get__m_max

subroutine f90wrap_atomictransitions__set__m_max(this, f90wrap_m_max)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_m_max
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%m_max = f90wrap_m_max
end subroutine f90wrap_atomictransitions__set__m_max

subroutine f90wrap_atomictransitions__get__dloge(this, f90wrap_dloge)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dloge
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dloge = this_ptr%p%dloge
end subroutine f90wrap_atomictransitions__get__dloge

subroutine f90wrap_atomictransitions__set__dloge(this, f90wrap_dloge)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dloge
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dloge = f90wrap_dloge
end subroutine f90wrap_atomictransitions__set__dloge

subroutine f90wrap_atomictransitions__get__dlogt(this, f90wrap_dlogt)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dlogt
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dlogt = this_ptr%p%dlogt
end subroutine f90wrap_atomictransitions__get__dlogt

subroutine f90wrap_atomictransitions__set__dlogt(this, f90wrap_dlogt)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dlogt
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dlogt = f90wrap_dlogt
end subroutine f90wrap_atomictransitions__set__dlogt

subroutine f90wrap_atomictransitions__get__minlog_pop(this, f90wrap_minlog_pop)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_minlog_pop
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_minlog_pop = this_ptr%p%minlog_pop
end subroutine f90wrap_atomictransitions__get__minlog_pop

subroutine f90wrap_atomictransitions__set__minlog_pop(this, f90wrap_minlog_pop)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_minlog_pop
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%minlog_pop = f90wrap_minlog_pop
end subroutine f90wrap_atomictransitions__set__minlog_pop

subroutine f90wrap_atomictransitions__get__minlog_depop(this, &
    f90wrap_minlog_depop)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_minlog_depop
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_minlog_depop = this_ptr%p%minlog_depop
end subroutine f90wrap_atomictransitions__get__minlog_depop

subroutine f90wrap_atomictransitions__set__minlog_depop(this, &
    f90wrap_minlog_depop)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_minlog_depop
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%minlog_depop = f90wrap_minlog_depop
end subroutine f90wrap_atomictransitions__set__minlog_depop

subroutine f90wrap_atomictransitions__array__ab(this, nd, dtype, dshape, dloc)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in) :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%ab)
    dloc = loc(this_ptr%p%ab)
end subroutine f90wrap_atomictransitions__array__ab

subroutine f90wrap_atomictransitions__array__log_pop(this, nd, dtype, dshape, &
    dloc)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in) :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 5
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%log_pop)) then
        dshape(1:5) = shape(this_ptr%p%log_pop)
        dloc = loc(this_ptr%p%log_pop)
    else
        dloc = 0
    end if
end subroutine f90wrap_atomictransitions__array__log_pop

subroutine f90wrap_atomictransitions__array__log_depop(this, nd, dtype, dshape, &
    dloc)
    use libfida, only: atomictransitions
    implicit none
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in) :: this(2)
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 4
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%log_depop)) then
        dshape(1:4) = shape(this_ptr%p%log_depop)
        dloc = loc(this_ptr%p%log_depop)
    else
        dloc = 0
    end if
end subroutine f90wrap_atomictransitions__array__log_depop

subroutine f90wrap_atomictransitions_initialise(this)
    use libfida, only: atomictransitions
    implicit none
    
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_atomictransitions_initialise

subroutine f90wrap_atomictransitions_finalise(this)
    use libfida, only: atomictransitions
    implicit none
    
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    type(atomictransitions_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_atomictransitions_finalise

subroutine f90wrap_nuclearrates__get__nbranch(this, f90wrap_nbranch)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_nbranch
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nbranch = this_ptr%p%nbranch
end subroutine f90wrap_nuclearrates__get__nbranch

subroutine f90wrap_nuclearrates__set__nbranch(this, f90wrap_nbranch)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_nbranch
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nbranch = f90wrap_nbranch
end subroutine f90wrap_nuclearrates__set__nbranch

subroutine f90wrap_nuclearrates__get__nenergy(this, f90wrap_nenergy)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nenergy = this_ptr%p%nenergy
end subroutine f90wrap_nuclearrates__get__nenergy

subroutine f90wrap_nuclearrates__set__nenergy(this, f90wrap_nenergy)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nenergy = f90wrap_nenergy
end subroutine f90wrap_nuclearrates__set__nenergy

subroutine f90wrap_nuclearrates__get__logemin(this, f90wrap_logemin)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logemin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logemin = this_ptr%p%logemin
end subroutine f90wrap_nuclearrates__get__logemin

subroutine f90wrap_nuclearrates__set__logemin(this, f90wrap_logemin)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logemin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logemin = f90wrap_logemin
end subroutine f90wrap_nuclearrates__set__logemin

subroutine f90wrap_nuclearrates__get__logemax(this, f90wrap_logemax)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logemax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logemax = this_ptr%p%logemax
end subroutine f90wrap_nuclearrates__get__logemax

subroutine f90wrap_nuclearrates__set__logemax(this, f90wrap_logemax)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logemax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logemax = f90wrap_logemax
end subroutine f90wrap_nuclearrates__set__logemax

subroutine f90wrap_nuclearrates__get__ntemp(this, f90wrap_ntemp)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_ntemp
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ntemp = this_ptr%p%ntemp
end subroutine f90wrap_nuclearrates__get__ntemp

subroutine f90wrap_nuclearrates__set__ntemp(this, f90wrap_ntemp)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_ntemp
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ntemp = f90wrap_ntemp
end subroutine f90wrap_nuclearrates__set__ntemp

subroutine f90wrap_nuclearrates__get__logtmin(this, f90wrap_logtmin)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logtmin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logtmin = this_ptr%p%logtmin
end subroutine f90wrap_nuclearrates__get__logtmin

subroutine f90wrap_nuclearrates__set__logtmin(this, f90wrap_logtmin)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logtmin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logtmin = f90wrap_logtmin
end subroutine f90wrap_nuclearrates__set__logtmin

subroutine f90wrap_nuclearrates__get__logtmax(this, f90wrap_logtmax)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_logtmax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_logtmax = this_ptr%p%logtmax
end subroutine f90wrap_nuclearrates__get__logtmax

subroutine f90wrap_nuclearrates__set__logtmax(this, f90wrap_logtmax)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_logtmax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%logtmax = f90wrap_logtmax
end subroutine f90wrap_nuclearrates__set__logtmax

subroutine f90wrap_nuclearrates__get__dloge(this, f90wrap_dloge)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dloge
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dloge = this_ptr%p%dloge
end subroutine f90wrap_nuclearrates__get__dloge

subroutine f90wrap_nuclearrates__set__dloge(this, f90wrap_dloge)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dloge
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dloge = f90wrap_dloge
end subroutine f90wrap_nuclearrates__set__dloge

subroutine f90wrap_nuclearrates__get__dlogt(this, f90wrap_dlogt)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dlogt
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dlogt = this_ptr%p%dlogt
end subroutine f90wrap_nuclearrates__get__dlogt

subroutine f90wrap_nuclearrates__set__dlogt(this, f90wrap_dlogt)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dlogt
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dlogt = f90wrap_dlogt
end subroutine f90wrap_nuclearrates__set__dlogt

subroutine f90wrap_nuclearrates__get__minlog_rate(this, f90wrap_minlog_rate)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_minlog_rate
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_minlog_rate = this_ptr%p%minlog_rate
end subroutine f90wrap_nuclearrates__get__minlog_rate

subroutine f90wrap_nuclearrates__set__minlog_rate(this, f90wrap_minlog_rate)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_minlog_rate
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%minlog_rate = f90wrap_minlog_rate
end subroutine f90wrap_nuclearrates__set__minlog_rate

subroutine f90wrap_nuclearrates__array__bt_amu(this, nd, dtype, dshape, dloc)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in) :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%bt_amu)
    dloc = loc(this_ptr%p%bt_amu)
end subroutine f90wrap_nuclearrates__array__bt_amu

subroutine f90wrap_nuclearrates__array__log_rate(this, nd, dtype, dshape, dloc)
    use libfida, only: nuclearrates
    implicit none
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in) :: this(2)
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 3
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%log_rate)) then
        dshape(1:3) = shape(this_ptr%p%log_rate)
        dloc = loc(this_ptr%p%log_rate)
    else
        dloc = 0
    end if
end subroutine f90wrap_nuclearrates__array__log_rate

subroutine f90wrap_nuclearrates_initialise(this)
    use libfida, only: nuclearrates
    implicit none
    
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_nuclearrates_initialise

subroutine f90wrap_nuclearrates_finalise(this)
    use libfida, only: nuclearrates
    implicit none
    
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    type(nuclearrates_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_nuclearrates_finalise

subroutine f90wrap_atomictables__get__h_h_cx_cross(this, f90wrap_h_h_cx_cross)
    use libfida, only: atomictables, atomiccrosssection
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_h_h_cx_cross(2)
    type(atomiccrosssection_ptr_type) :: h_h_cx_cross_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_h_cx_cross_ptr%p => this_ptr%p%h_h_cx_cross
    f90wrap_h_h_cx_cross = transfer(h_h_cx_cross_ptr,f90wrap_h_h_cx_cross)
end subroutine f90wrap_atomictables__get__h_h_cx_cross

subroutine f90wrap_atomictables__set__h_h_cx_cross(this, f90wrap_h_h_cx_cross)
    use libfida, only: atomictables, atomiccrosssection
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_h_h_cx_cross(2)
    type(atomiccrosssection_ptr_type) :: h_h_cx_cross_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_h_cx_cross_ptr = transfer(f90wrap_h_h_cx_cross,h_h_cx_cross_ptr)
    this_ptr%p%h_h_cx_cross = h_h_cx_cross_ptr%p
end subroutine f90wrap_atomictables__set__h_h_cx_cross

subroutine f90wrap_atomictables__get__h_h_cx_rate(this, f90wrap_h_h_cx_rate)
    use libfida, only: atomictables, atomicrates
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_h_h_cx_rate(2)
    type(atomicrates_ptr_type) :: h_h_cx_rate_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_h_cx_rate_ptr%p => this_ptr%p%h_h_cx_rate
    f90wrap_h_h_cx_rate = transfer(h_h_cx_rate_ptr,f90wrap_h_h_cx_rate)
end subroutine f90wrap_atomictables__get__h_h_cx_rate

subroutine f90wrap_atomictables__set__h_h_cx_rate(this, f90wrap_h_h_cx_rate)
    use libfida, only: atomictables, atomicrates
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_h_h_cx_rate(2)
    type(atomicrates_ptr_type) :: h_h_cx_rate_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_h_cx_rate_ptr = transfer(f90wrap_h_h_cx_rate,h_h_cx_rate_ptr)
    this_ptr%p%h_h_cx_rate = h_h_cx_rate_ptr%p
end subroutine f90wrap_atomictables__set__h_h_cx_rate

subroutine f90wrap_atomictables__get__h_h(this, f90wrap_h_h)
    use libfida, only: atomictables, atomictransitions
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_h_h(2)
    type(atomictransitions_ptr_type) :: h_h_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_h_ptr%p => this_ptr%p%h_h
    f90wrap_h_h = transfer(h_h_ptr,f90wrap_h_h)
end subroutine f90wrap_atomictables__get__h_h

subroutine f90wrap_atomictables__set__h_h(this, f90wrap_h_h)
    use libfida, only: atomictables, atomictransitions
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_h_h(2)
    type(atomictransitions_ptr_type) :: h_h_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_h_ptr = transfer(f90wrap_h_h,h_h_ptr)
    this_ptr%p%h_h = h_h_ptr%p
end subroutine f90wrap_atomictables__set__h_h

subroutine f90wrap_atomictables__get__h_e(this, f90wrap_h_e)
    use libfida, only: atomictables, atomictransitions
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_h_e(2)
    type(atomictransitions_ptr_type) :: h_e_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_e_ptr%p => this_ptr%p%h_e
    f90wrap_h_e = transfer(h_e_ptr,f90wrap_h_e)
end subroutine f90wrap_atomictables__get__h_e

subroutine f90wrap_atomictables__set__h_e(this, f90wrap_h_e)
    use libfida, only: atomictables, atomictransitions
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_h_e(2)
    type(atomictransitions_ptr_type) :: h_e_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_e_ptr = transfer(f90wrap_h_e,h_e_ptr)
    this_ptr%p%h_e = h_e_ptr%p
end subroutine f90wrap_atomictables__set__h_e

subroutine f90wrap_atomictables__get__h_aq(this, f90wrap_h_aq)
    use libfida, only: atomictables, atomictransitions
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_h_aq(2)
    type(atomictransitions_ptr_type) :: h_aq_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_aq_ptr%p => this_ptr%p%h_aq
    f90wrap_h_aq = transfer(h_aq_ptr,f90wrap_h_aq)
end subroutine f90wrap_atomictables__get__h_aq

subroutine f90wrap_atomictables__set__h_aq(this, f90wrap_h_aq)
    use libfida, only: atomictables, atomictransitions
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_h_aq(2)
    type(atomictransitions_ptr_type) :: h_aq_ptr
    
    this_ptr = transfer(this, this_ptr)
    h_aq_ptr = transfer(f90wrap_h_aq,h_aq_ptr)
    this_ptr%p%h_aq = h_aq_ptr%p
end subroutine f90wrap_atomictables__set__h_aq

subroutine f90wrap_atomictables__array__einstein(this, nd, dtype, dshape, dloc)
    use libfida, only: atomictables
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    integer, intent(in) :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%einstein)
    dloc = loc(this_ptr%p%einstein)
end subroutine f90wrap_atomictables__array__einstein

subroutine f90wrap_atomictables__get__d_d(this, f90wrap_d_d)
    use libfida, only: atomictables, nuclearrates
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_d_d(2)
    type(nuclearrates_ptr_type) :: d_d_ptr
    
    this_ptr = transfer(this, this_ptr)
    d_d_ptr%p => this_ptr%p%d_d
    f90wrap_d_d = transfer(d_d_ptr,f90wrap_d_d)
end subroutine f90wrap_atomictables__get__d_d

subroutine f90wrap_atomictables__set__d_d(this, f90wrap_d_d)
    use libfida, only: atomictables, nuclearrates
    implicit none
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer, intent(in)   :: this(2)
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_d_d(2)
    type(nuclearrates_ptr_type) :: d_d_ptr
    
    this_ptr = transfer(this, this_ptr)
    d_d_ptr = transfer(f90wrap_d_d,d_d_ptr)
    this_ptr%p%d_d = d_d_ptr%p
end subroutine f90wrap_atomictables__set__d_d

subroutine f90wrap_atomictables_initialise(this)
    use libfida, only: atomictables
    implicit none
    
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_atomictables_initialise

subroutine f90wrap_atomictables_finalise(this)
    use libfida, only: atomictables
    implicit none
    
    type atomictables_ptr_type
        type(atomictables), pointer :: p => NULL()
    end type atomictables_ptr_type
    type(atomictables_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_atomictables_finalise

subroutine f90wrap_lineofsight__get__sigma_pi(this, f90wrap_sigma_pi)
    use libfida, only: lineofsight
    implicit none
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(in)   :: this(2)
    type(lineofsight_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_sigma_pi
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_sigma_pi = this_ptr%p%sigma_pi
end subroutine f90wrap_lineofsight__get__sigma_pi

subroutine f90wrap_lineofsight__set__sigma_pi(this, f90wrap_sigma_pi)
    use libfida, only: lineofsight
    implicit none
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(in)   :: this(2)
    type(lineofsight_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_sigma_pi
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%sigma_pi = f90wrap_sigma_pi
end subroutine f90wrap_lineofsight__set__sigma_pi

subroutine f90wrap_lineofsight__get__spot_size(this, f90wrap_spot_size)
    use libfida, only: lineofsight
    implicit none
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(in)   :: this(2)
    type(lineofsight_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_spot_size
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_spot_size = this_ptr%p%spot_size
end subroutine f90wrap_lineofsight__get__spot_size

subroutine f90wrap_lineofsight__set__spot_size(this, f90wrap_spot_size)
    use libfida, only: lineofsight
    implicit none
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(in)   :: this(2)
    type(lineofsight_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_spot_size
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%spot_size = f90wrap_spot_size
end subroutine f90wrap_lineofsight__set__spot_size

subroutine f90wrap_lineofsight__array__lens(this, nd, dtype, dshape, dloc)
    use libfida, only: lineofsight
    implicit none
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(in) :: this(2)
    type(lineofsight_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%lens)
    dloc = loc(this_ptr%p%lens)
end subroutine f90wrap_lineofsight__array__lens

subroutine f90wrap_lineofsight__array__axis(this, nd, dtype, dshape, dloc)
    use libfida, only: lineofsight
    implicit none
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(in) :: this(2)
    type(lineofsight_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%axis)
    dloc = loc(this_ptr%p%axis)
end subroutine f90wrap_lineofsight__array__axis

subroutine f90wrap_lineofsight_initialise(this)
    use libfida, only: lineofsight
    implicit none
    
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    type(lineofsight_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_lineofsight_initialise

subroutine f90wrap_lineofsight_finalise(this)
    use libfida, only: lineofsight
    implicit none
    
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    type(lineofsight_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_lineofsight_finalise

subroutine f90wrap_loselement__get__id(this, f90wrap_id)
    use libfida, only: loselement
    implicit none
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    integer, intent(in)   :: this(2)
    type(loselement_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_id
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_id = this_ptr%p%id
end subroutine f90wrap_loselement__get__id

subroutine f90wrap_loselement__set__id(this, f90wrap_id)
    use libfida, only: loselement
    implicit none
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    integer, intent(in)   :: this(2)
    type(loselement_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_id
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%id = f90wrap_id
end subroutine f90wrap_loselement__set__id

subroutine f90wrap_loselement__get__length(this, f90wrap_length)
    use libfida, only: loselement
    implicit none
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    integer, intent(in)   :: this(2)
    type(loselement_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_length
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_length = this_ptr%p%length
end subroutine f90wrap_loselement__get__length

subroutine f90wrap_loselement__set__length(this, f90wrap_length)
    use libfida, only: loselement
    implicit none
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    integer, intent(in)   :: this(2)
    type(loselement_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_length
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%length = f90wrap_length
end subroutine f90wrap_loselement__set__length

subroutine f90wrap_loselement_initialise(this)
    use libfida, only: loselement
    implicit none
    
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    type(loselement_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_loselement_initialise

subroutine f90wrap_loselement_finalise(this)
    use libfida, only: loselement
    implicit none
    
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    type(loselement_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_loselement_finalise

subroutine f90wrap_losinters__get__nchan(this, f90wrap_nchan)
    use libfida, only: losinters
    implicit none
    type losinters_ptr_type
        type(losinters), pointer :: p => NULL()
    end type losinters_ptr_type
    integer, intent(in)   :: this(2)
    type(losinters_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_nchan
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nchan = this_ptr%p%nchan
end subroutine f90wrap_losinters__get__nchan

subroutine f90wrap_losinters__set__nchan(this, f90wrap_nchan)
    use libfida, only: losinters
    implicit none
    type losinters_ptr_type
        type(losinters), pointer :: p => NULL()
    end type losinters_ptr_type
    integer, intent(in)   :: this(2)
    type(losinters_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_nchan
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nchan = f90wrap_nchan
end subroutine f90wrap_losinters__set__nchan

subroutine f90wrap_losinters__array_getitem__los_elem(f90wrap_this, f90wrap_i, &
    los_elemitem)
    
    use libfida, only: losinters, loselement
    implicit none
    
    type losinters_ptr_type
        type(losinters), pointer :: p => NULL()
    end type losinters_ptr_type
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(losinters_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(out) :: los_elemitem(2)
    type(loselement_ptr_type) :: los_elem_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%los_elem)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%los_elem)) then
            call f90wrap_abort("array index out of range")
        else
            los_elem_ptr%p => this_ptr%p%los_elem(f90wrap_i)
            los_elemitem = transfer(los_elem_ptr,los_elemitem)
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_losinters__array_getitem__los_elem

subroutine f90wrap_losinters__array_setitem__los_elem(f90wrap_this, f90wrap_i, &
    los_elemitem)
    
    use libfida, only: losinters, loselement
    implicit none
    
    type losinters_ptr_type
        type(losinters), pointer :: p => NULL()
    end type losinters_ptr_type
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(losinters_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(in) :: los_elemitem(2)
    type(loselement_ptr_type) :: los_elem_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%los_elem)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%los_elem)) then
            call f90wrap_abort("array index out of range")
        else
            los_elem_ptr = transfer(los_elemitem,los_elem_ptr)
            this_ptr%p%los_elem(f90wrap_i) = los_elem_ptr%p
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_losinters__array_setitem__los_elem

subroutine f90wrap_losinters__array_len__los_elem(f90wrap_this, f90wrap_n)
    
    use libfida, only: losinters, loselement
    implicit none
    
    type losinters_ptr_type
        type(losinters), pointer :: p => NULL()
    end type losinters_ptr_type
    type loselement_ptr_type
        type(loselement), pointer :: p => NULL()
    end type loselement_ptr_type
    integer, intent(out) :: f90wrap_n
    integer, intent(in) :: f90wrap_this(2)
    type(losinters_ptr_type) :: this_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%los_elem)) then
        f90wrap_n = size(this_ptr%p%los_elem)
    else
        f90wrap_n = 0
    end if
end subroutine f90wrap_losinters__array_len__los_elem

subroutine f90wrap_losinters_initialise(this)
    use libfida, only: losinters
    implicit none
    
    type losinters_ptr_type
        type(losinters), pointer :: p => NULL()
    end type losinters_ptr_type
    type(losinters_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_losinters_initialise

subroutine f90wrap_losinters_finalise(this)
    use libfida, only: losinters
    implicit none
    
    type losinters_ptr_type
        type(losinters), pointer :: p => NULL()
    end type losinters_ptr_type
    type(losinters_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_losinters_finalise

subroutine f90wrap_spectralchords__get__nchan(this, f90wrap_nchan)
    use libfida, only: spectralchords
    implicit none
    type spectralchords_ptr_type
        type(spectralchords), pointer :: p => NULL()
    end type spectralchords_ptr_type
    integer, intent(in)   :: this(2)
    type(spectralchords_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_nchan
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nchan = this_ptr%p%nchan
end subroutine f90wrap_spectralchords__get__nchan

subroutine f90wrap_spectralchords__set__nchan(this, f90wrap_nchan)
    use libfida, only: spectralchords
    implicit none
    type spectralchords_ptr_type
        type(spectralchords), pointer :: p => NULL()
    end type spectralchords_ptr_type
    integer, intent(in)   :: this(2)
    type(spectralchords_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_nchan
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nchan = f90wrap_nchan
end subroutine f90wrap_spectralchords__set__nchan

subroutine f90wrap_spectralchords__array_getitem__los(f90wrap_this, f90wrap_i, &
    lositem)
    
    use libfida, only: spectralchords, lineofsight
    implicit none
    
    type spectralchords_ptr_type
        type(spectralchords), pointer :: p => NULL()
    end type spectralchords_ptr_type
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(spectralchords_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(out) :: lositem(2)
    type(lineofsight_ptr_type) :: los_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%los)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%los)) then
            call f90wrap_abort("array index out of range")
        else
            los_ptr%p => this_ptr%p%los(f90wrap_i)
            lositem = transfer(los_ptr,lositem)
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_spectralchords__array_getitem__los

subroutine f90wrap_spectralchords__array_setitem__los(f90wrap_this, f90wrap_i, &
    lositem)
    
    use libfida, only: spectralchords, lineofsight
    implicit none
    
    type spectralchords_ptr_type
        type(spectralchords), pointer :: p => NULL()
    end type spectralchords_ptr_type
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(spectralchords_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(in) :: lositem(2)
    type(lineofsight_ptr_type) :: los_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%los)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%los)) then
            call f90wrap_abort("array index out of range")
        else
            los_ptr = transfer(lositem,los_ptr)
            this_ptr%p%los(f90wrap_i) = los_ptr%p
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_spectralchords__array_setitem__los

subroutine f90wrap_spectralchords__array_len__los(f90wrap_this, f90wrap_n)
    
    use libfida, only: spectralchords, lineofsight
    implicit none
    
    type spectralchords_ptr_type
        type(spectralchords), pointer :: p => NULL()
    end type spectralchords_ptr_type
    type lineofsight_ptr_type
        type(lineofsight), pointer :: p => NULL()
    end type lineofsight_ptr_type
    integer, intent(out) :: f90wrap_n
    integer, intent(in) :: f90wrap_this(2)
    type(spectralchords_ptr_type) :: this_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%los)) then
        f90wrap_n = size(this_ptr%p%los)
    else
        f90wrap_n = 0
    end if
end subroutine f90wrap_spectralchords__array_len__los

subroutine f90wrap_spectralchords__array__radius(this, nd, dtype, dshape, dloc)
    use libfida, only: spectralchords
    implicit none
    type spectralchords_ptr_type
        type(spectralchords), pointer :: p => NULL()
    end type spectralchords_ptr_type
    integer, intent(in) :: this(2)
    type(spectralchords_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%radius)) then
        dshape(1:1) = shape(this_ptr%p%radius)
        dloc = loc(this_ptr%p%radius)
    else
        dloc = 0
    end if
end subroutine f90wrap_spectralchords__array__radius

subroutine f90wrap_spectralchords_initialise(this)
    use libfida, only: spectralchords
    implicit none
    
    type spectralchords_ptr_type
        type(spectralchords), pointer :: p => NULL()
    end type spectralchords_ptr_type
    type(spectralchords_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_spectralchords_initialise

subroutine f90wrap_spectralchords_finalise(this)
    use libfida, only: spectralchords
    implicit none
    
    type spectralchords_ptr_type
        type(spectralchords), pointer :: p => NULL()
    end type spectralchords_ptr_type
    type(spectralchords_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_spectralchords_finalise

subroutine f90wrap_boundedplane__get__shape(this, f90wrap_shape)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_shape
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_shape = this_ptr%p%shape
end subroutine f90wrap_boundedplane__get__shape

subroutine f90wrap_boundedplane__set__shape(this, f90wrap_shape)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_shape
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%shape = f90wrap_shape
end subroutine f90wrap_boundedplane__set__shape

subroutine f90wrap_boundedplane__get__hh(this, f90wrap_hh)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_hh
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_hh = this_ptr%p%hh
end subroutine f90wrap_boundedplane__get__hh

subroutine f90wrap_boundedplane__set__hh(this, f90wrap_hh)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_hh
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%hh = f90wrap_hh
end subroutine f90wrap_boundedplane__set__hh

subroutine f90wrap_boundedplane__get__hw(this, f90wrap_hw)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_hw
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_hw = this_ptr%p%hw
end subroutine f90wrap_boundedplane__get__hw

subroutine f90wrap_boundedplane__set__hw(this, f90wrap_hw)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_hw
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%hw = f90wrap_hw
end subroutine f90wrap_boundedplane__set__hw

subroutine f90wrap_boundedplane__array__origin(this, nd, dtype, dshape, dloc)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in) :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%origin)
    dloc = loc(this_ptr%p%origin)
end subroutine f90wrap_boundedplane__array__origin

subroutine f90wrap_boundedplane__array__basis(this, nd, dtype, dshape, dloc)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in) :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%basis)
    dloc = loc(this_ptr%p%basis)
end subroutine f90wrap_boundedplane__array__basis

subroutine f90wrap_boundedplane__array__inv_basis(this, nd, dtype, dshape, dloc)
    use libfida, only: boundedplane
    implicit none
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in) :: this(2)
    type(boundedplane_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%inv_basis)
    dloc = loc(this_ptr%p%inv_basis)
end subroutine f90wrap_boundedplane__array__inv_basis

subroutine f90wrap_boundedplane_initialise(this)
    use libfida, only: boundedplane
    implicit none
    
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    type(boundedplane_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_boundedplane_initialise

subroutine f90wrap_boundedplane_finalise(this)
    use libfida, only: boundedplane
    implicit none
    
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    type(boundedplane_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_boundedplane_finalise

subroutine f90wrap_npadetector__get__detector(this, f90wrap_detector)
    use libfida, only: boundedplane, npadetector
    implicit none
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(npadetector_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_detector(2)
    type(boundedplane_ptr_type) :: detector_ptr
    
    this_ptr = transfer(this, this_ptr)
    detector_ptr%p => this_ptr%p%detector
    f90wrap_detector = transfer(detector_ptr,f90wrap_detector)
end subroutine f90wrap_npadetector__get__detector

subroutine f90wrap_npadetector__set__detector(this, f90wrap_detector)
    use libfida, only: boundedplane, npadetector
    implicit none
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(npadetector_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_detector(2)
    type(boundedplane_ptr_type) :: detector_ptr
    
    this_ptr = transfer(this, this_ptr)
    detector_ptr = transfer(f90wrap_detector,detector_ptr)
    this_ptr%p%detector = detector_ptr%p
end subroutine f90wrap_npadetector__set__detector

subroutine f90wrap_npadetector__get__aperture(this, f90wrap_aperture)
    use libfida, only: boundedplane, npadetector
    implicit none
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(npadetector_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_aperture(2)
    type(boundedplane_ptr_type) :: aperture_ptr
    
    this_ptr = transfer(this, this_ptr)
    aperture_ptr%p => this_ptr%p%aperture
    f90wrap_aperture = transfer(aperture_ptr,f90wrap_aperture)
end subroutine f90wrap_npadetector__get__aperture

subroutine f90wrap_npadetector__set__aperture(this, f90wrap_aperture)
    use libfida, only: boundedplane, npadetector
    implicit none
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    integer, intent(in)   :: this(2)
    type(npadetector_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_aperture(2)
    type(boundedplane_ptr_type) :: aperture_ptr
    
    this_ptr = transfer(this, this_ptr)
    aperture_ptr = transfer(f90wrap_aperture,aperture_ptr)
    this_ptr%p%aperture = aperture_ptr%p
end subroutine f90wrap_npadetector__set__aperture

subroutine f90wrap_npadetector_initialise(this)
    use libfida, only: npadetector
    implicit none
    
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    type(npadetector_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_npadetector_initialise

subroutine f90wrap_npadetector_finalise(this)
    use libfida, only: npadetector
    implicit none
    
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    type(npadetector_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_npadetector_finalise

subroutine f90wrap_npaprobability__get__p(this, f90wrap_p)
    use libfida, only: npaprobability
    implicit none
    type npaprobability_ptr_type
        type(npaprobability), pointer :: p => NULL()
    end type npaprobability_ptr_type
    integer, intent(in)   :: this(2)
    type(npaprobability_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_p
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_p = this_ptr%p%p
end subroutine f90wrap_npaprobability__get__p

subroutine f90wrap_npaprobability__set__p(this, f90wrap_p)
    use libfida, only: npaprobability
    implicit none
    type npaprobability_ptr_type
        type(npaprobability), pointer :: p => NULL()
    end type npaprobability_ptr_type
    integer, intent(in)   :: this(2)
    type(npaprobability_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_p
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%p = f90wrap_p
end subroutine f90wrap_npaprobability__set__p

subroutine f90wrap_npaprobability__get__pitch(this, f90wrap_pitch)
    use libfida, only: npaprobability
    implicit none
    type npaprobability_ptr_type
        type(npaprobability), pointer :: p => NULL()
    end type npaprobability_ptr_type
    integer, intent(in)   :: this(2)
    type(npaprobability_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_pitch
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_pitch = this_ptr%p%pitch
end subroutine f90wrap_npaprobability__get__pitch

subroutine f90wrap_npaprobability__set__pitch(this, f90wrap_pitch)
    use libfida, only: npaprobability
    implicit none
    type npaprobability_ptr_type
        type(npaprobability), pointer :: p => NULL()
    end type npaprobability_ptr_type
    integer, intent(in)   :: this(2)
    type(npaprobability_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_pitch
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%pitch = f90wrap_pitch
end subroutine f90wrap_npaprobability__set__pitch

subroutine f90wrap_npaprobability__array__eff_rd(this, nd, dtype, dshape, dloc)
    use libfida, only: npaprobability
    implicit none
    type npaprobability_ptr_type
        type(npaprobability), pointer :: p => NULL()
    end type npaprobability_ptr_type
    integer, intent(in) :: this(2)
    type(npaprobability_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%eff_rd)
    dloc = loc(this_ptr%p%eff_rd)
end subroutine f90wrap_npaprobability__array__eff_rd

subroutine f90wrap_npaprobability__array__dir(this, nd, dtype, dshape, dloc)
    use libfida, only: npaprobability
    implicit none
    type npaprobability_ptr_type
        type(npaprobability), pointer :: p => NULL()
    end type npaprobability_ptr_type
    integer, intent(in) :: this(2)
    type(npaprobability_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%dir)
    dloc = loc(this_ptr%p%dir)
end subroutine f90wrap_npaprobability__array__dir

subroutine f90wrap_npaprobability_initialise(this)
    use libfida, only: npaprobability
    implicit none
    
    type npaprobability_ptr_type
        type(npaprobability), pointer :: p => NULL()
    end type npaprobability_ptr_type
    type(npaprobability_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_npaprobability_initialise

subroutine f90wrap_npaprobability_finalise(this)
    use libfida, only: npaprobability
    implicit none
    
    type npaprobability_ptr_type
        type(npaprobability), pointer :: p => NULL()
    end type npaprobability_ptr_type
    type(npaprobability_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_npaprobability_finalise

subroutine f90wrap_npachords__get__nchan(this, f90wrap_nchan)
    use libfida, only: npachords
    implicit none
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    integer, intent(in)   :: this(2)
    type(npachords_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_nchan
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nchan = this_ptr%p%nchan
end subroutine f90wrap_npachords__get__nchan

subroutine f90wrap_npachords__set__nchan(this, f90wrap_nchan)
    use libfida, only: npachords
    implicit none
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    integer, intent(in)   :: this(2)
    type(npachords_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_nchan
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nchan = f90wrap_nchan
end subroutine f90wrap_npachords__set__nchan

subroutine f90wrap_npachords__array_getitem__det(f90wrap_this, f90wrap_i, &
    detitem)
    
    use libfida, only: npachords, npadetector
    implicit none
    
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(npachords_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(out) :: detitem(2)
    type(npadetector_ptr_type) :: det_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%det)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%det)) then
            call f90wrap_abort("array index out of range")
        else
            det_ptr%p => this_ptr%p%det(f90wrap_i)
            detitem = transfer(det_ptr,detitem)
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_npachords__array_getitem__det

subroutine f90wrap_npachords__array_setitem__det(f90wrap_this, f90wrap_i, &
    detitem)
    
    use libfida, only: npachords, npadetector
    implicit none
    
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(npachords_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(in) :: detitem(2)
    type(npadetector_ptr_type) :: det_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%det)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%det)) then
            call f90wrap_abort("array index out of range")
        else
            det_ptr = transfer(detitem,det_ptr)
            this_ptr%p%det(f90wrap_i) = det_ptr%p
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_npachords__array_setitem__det

subroutine f90wrap_npachords__array_len__det(f90wrap_this, f90wrap_n)
    
    use libfida, only: npachords, npadetector
    implicit none
    
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    type npadetector_ptr_type
        type(npadetector), pointer :: p => NULL()
    end type npadetector_ptr_type
    integer, intent(out) :: f90wrap_n
    integer, intent(in) :: f90wrap_this(2)
    type(npachords_ptr_type) :: this_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%det)) then
        f90wrap_n = size(this_ptr%p%det)
    else
        f90wrap_n = 0
    end if
end subroutine f90wrap_npachords__array_len__det

subroutine f90wrap_npachords__array__radius(this, nd, dtype, dshape, dloc)
    use libfida, only: npachords
    implicit none
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    integer, intent(in) :: this(2)
    type(npachords_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%radius)) then
        dshape(1:1) = shape(this_ptr%p%radius)
        dloc = loc(this_ptr%p%radius)
    else
        dloc = 0
    end if
end subroutine f90wrap_npachords__array__radius

subroutine f90wrap_npachords__array__hit(this, nd, dtype, dshape, dloc)
    use libfida, only: npachords
    implicit none
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    integer, intent(in) :: this(2)
    type(npachords_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 3
    dtype = 5
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%hit)) then
        dshape(1:3) = shape(this_ptr%p%hit)
        dloc = loc(this_ptr%p%hit)
    else
        dloc = 0
    end if
end subroutine f90wrap_npachords__array__hit

subroutine f90wrap_npachords_initialise(this)
    use libfida, only: npachords
    implicit none
    
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    type(npachords_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_npachords_initialise

subroutine f90wrap_npachords_finalise(this)
    use libfida, only: npachords
    implicit none
    
    type npachords_ptr_type
        type(npachords), pointer :: p => NULL()
    end type npachords_ptr_type
    type(npachords_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_npachords_finalise

subroutine f90wrap_npaparticle__get__detector(this, f90wrap_detector)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_detector
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_detector = this_ptr%p%detector
end subroutine f90wrap_npaparticle__get__detector

subroutine f90wrap_npaparticle__set__detector(this, f90wrap_detector)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_detector
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%detector = f90wrap_detector
end subroutine f90wrap_npaparticle__set__detector

subroutine f90wrap_npaparticle__get__xi(this, f90wrap_xi)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_xi
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_xi = this_ptr%p%xi
end subroutine f90wrap_npaparticle__get__xi

subroutine f90wrap_npaparticle__set__xi(this, f90wrap_xi)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_xi
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%xi = f90wrap_xi
end subroutine f90wrap_npaparticle__set__xi

subroutine f90wrap_npaparticle__get__yi(this, f90wrap_yi)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_yi
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_yi = this_ptr%p%yi
end subroutine f90wrap_npaparticle__get__yi

subroutine f90wrap_npaparticle__set__yi(this, f90wrap_yi)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_yi
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%yi = f90wrap_yi
end subroutine f90wrap_npaparticle__set__yi

subroutine f90wrap_npaparticle__get__zi(this, f90wrap_zi)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_zi
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_zi = this_ptr%p%zi
end subroutine f90wrap_npaparticle__get__zi

subroutine f90wrap_npaparticle__set__zi(this, f90wrap_zi)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_zi
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%zi = f90wrap_zi
end subroutine f90wrap_npaparticle__set__zi

subroutine f90wrap_npaparticle__get__xf(this, f90wrap_xf)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_xf
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_xf = this_ptr%p%xf
end subroutine f90wrap_npaparticle__get__xf

subroutine f90wrap_npaparticle__set__xf(this, f90wrap_xf)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_xf
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%xf = f90wrap_xf
end subroutine f90wrap_npaparticle__set__xf

subroutine f90wrap_npaparticle__get__yf(this, f90wrap_yf)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_yf
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_yf = this_ptr%p%yf
end subroutine f90wrap_npaparticle__get__yf

subroutine f90wrap_npaparticle__set__yf(this, f90wrap_yf)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_yf
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%yf = f90wrap_yf
end subroutine f90wrap_npaparticle__set__yf

subroutine f90wrap_npaparticle__get__zf(this, f90wrap_zf)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_zf
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_zf = this_ptr%p%zf
end subroutine f90wrap_npaparticle__get__zf

subroutine f90wrap_npaparticle__set__zf(this, f90wrap_zf)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_zf
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%zf = f90wrap_zf
end subroutine f90wrap_npaparticle__set__zf

subroutine f90wrap_npaparticle__get__weight(this, f90wrap_weight)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_weight
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_weight = this_ptr%p%weight
end subroutine f90wrap_npaparticle__get__weight

subroutine f90wrap_npaparticle__set__weight(this, f90wrap_weight)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_weight
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%weight = f90wrap_weight
end subroutine f90wrap_npaparticle__set__weight

subroutine f90wrap_npaparticle__get__energy(this, f90wrap_energy)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_energy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_energy = this_ptr%p%energy
end subroutine f90wrap_npaparticle__get__energy

subroutine f90wrap_npaparticle__set__energy(this, f90wrap_energy)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_energy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%energy = f90wrap_energy
end subroutine f90wrap_npaparticle__set__energy

subroutine f90wrap_npaparticle__get__pitch(this, f90wrap_pitch)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_pitch
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_pitch = this_ptr%p%pitch
end subroutine f90wrap_npaparticle__get__pitch

subroutine f90wrap_npaparticle__set__pitch(this, f90wrap_pitch)
    use libfida, only: npaparticle
    implicit none
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in)   :: this(2)
    type(npaparticle_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_pitch
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%pitch = f90wrap_pitch
end subroutine f90wrap_npaparticle__set__pitch

subroutine f90wrap_npaparticle_initialise(this)
    use libfida, only: npaparticle
    implicit none
    
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    type(npaparticle_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_npaparticle_initialise

subroutine f90wrap_npaparticle_finalise(this)
    use libfida, only: npaparticle
    implicit none
    
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    type(npaparticle_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_npaparticle_finalise

subroutine f90wrap_nparesults__get__nchan(this, f90wrap_nchan)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in)   :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nchan
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nchan = this_ptr%p%nchan
end subroutine f90wrap_nparesults__get__nchan

subroutine f90wrap_nparesults__set__nchan(this, f90wrap_nchan)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in)   :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nchan
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nchan = f90wrap_nchan
end subroutine f90wrap_nparesults__set__nchan

subroutine f90wrap_nparesults__get__npart(this, f90wrap_npart)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in)   :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_npart
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_npart = this_ptr%p%npart
end subroutine f90wrap_nparesults__get__npart

subroutine f90wrap_nparesults__set__npart(this, f90wrap_npart)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in)   :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_npart
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%npart = f90wrap_npart
end subroutine f90wrap_nparesults__set__npart

subroutine f90wrap_nparesults__get__nmax(this, f90wrap_nmax)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in)   :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nmax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nmax = this_ptr%p%nmax
end subroutine f90wrap_nparesults__get__nmax

subroutine f90wrap_nparesults__set__nmax(this, f90wrap_nmax)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in)   :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nmax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nmax = f90wrap_nmax
end subroutine f90wrap_nparesults__set__nmax

subroutine f90wrap_nparesults__get__nenergy(this, f90wrap_nenergy)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in)   :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nenergy = this_ptr%p%nenergy
end subroutine f90wrap_nparesults__get__nenergy

subroutine f90wrap_nparesults__set__nenergy(this, f90wrap_nenergy)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in)   :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nenergy
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nenergy = f90wrap_nenergy
end subroutine f90wrap_nparesults__set__nenergy

subroutine f90wrap_nparesults__array_getitem__part(f90wrap_this, f90wrap_i, &
    partitem)
    
    use libfida, only: npaparticle, nparesults
    implicit none
    
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(out) :: partitem(2)
    type(npaparticle_ptr_type) :: part_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%part)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%part)) then
            call f90wrap_abort("array index out of range")
        else
            part_ptr%p => this_ptr%p%part(f90wrap_i)
            partitem = transfer(part_ptr,partitem)
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_nparesults__array_getitem__part

subroutine f90wrap_nparesults__array_setitem__part(f90wrap_this, f90wrap_i, &
    partitem)
    
    use libfida, only: npaparticle, nparesults
    implicit none
    
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(in) :: f90wrap_this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_i
    integer, intent(in) :: partitem(2)
    type(npaparticle_ptr_type) :: part_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%part)) then
        if (f90wrap_i < 1 .or. f90wrap_i > size(this_ptr%p%part)) then
            call f90wrap_abort("array index out of range")
        else
            part_ptr = transfer(partitem,part_ptr)
            this_ptr%p%part(f90wrap_i) = part_ptr%p
        endif
    else
        call f90wrap_abort("derived type array not allocated")
    end if
end subroutine f90wrap_nparesults__array_setitem__part

subroutine f90wrap_nparesults__array_len__part(f90wrap_this, f90wrap_n)
    
    use libfida, only: npaparticle, nparesults
    implicit none
    
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    integer, intent(out) :: f90wrap_n
    integer, intent(in) :: f90wrap_this(2)
    type(nparesults_ptr_type) :: this_ptr
    
    this_ptr = transfer(f90wrap_this, this_ptr)
    if (allocated(this_ptr%p%part)) then
        f90wrap_n = size(this_ptr%p%part)
    else
        f90wrap_n = 0
    end if
end subroutine f90wrap_nparesults__array_len__part

subroutine f90wrap_nparesults__array__energy(this, nd, dtype, dshape, dloc)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in) :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%energy)) then
        dshape(1:1) = shape(this_ptr%p%energy)
        dloc = loc(this_ptr%p%energy)
    else
        dloc = 0
    end if
end subroutine f90wrap_nparesults__array__energy

subroutine f90wrap_nparesults__array__flux(this, nd, dtype, dshape, dloc)
    use libfida, only: nparesults
    implicit none
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    integer, intent(in) :: this(2)
    type(nparesults_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 3
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%flux)) then
        dshape(1:3) = shape(this_ptr%p%flux)
        dloc = loc(this_ptr%p%flux)
    else
        dloc = 0
    end if
end subroutine f90wrap_nparesults__array__flux

subroutine f90wrap_nparesults_initialise(this)
    use libfida, only: nparesults
    implicit none
    
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    type(nparesults_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_nparesults_initialise

subroutine f90wrap_nparesults_finalise(this)
    use libfida, only: nparesults
    implicit none
    
    type nparesults_ptr_type
        type(nparesults), pointer :: p => NULL()
    end type nparesults_ptr_type
    type(nparesults_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_nparesults_finalise

subroutine f90wrap_birthprofile__get__cnt(this, f90wrap_cnt)
    use libfida, only: birthprofile
    implicit none
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    integer, intent(in)   :: this(2)
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(out) :: f90wrap_cnt
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_cnt = this_ptr%p%cnt
end subroutine f90wrap_birthprofile__get__cnt

subroutine f90wrap_birthprofile__set__cnt(this, f90wrap_cnt)
    use libfida, only: birthprofile
    implicit none
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    integer, intent(in)   :: this(2)
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(in) :: f90wrap_cnt
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%cnt = f90wrap_cnt
end subroutine f90wrap_birthprofile__set__cnt

subroutine f90wrap_birthprofile__array__neut_type(this, nd, dtype, dshape, dloc)
    use libfida, only: birthprofile
    implicit none
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    integer, intent(in) :: this(2)
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 5
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%neut_type)) then
        dshape(1:1) = shape(this_ptr%p%neut_type)
        dloc = loc(this_ptr%p%neut_type)
    else
        dloc = 0
    end if
end subroutine f90wrap_birthprofile__array__neut_type

subroutine f90wrap_birthprofile__array__ri(this, nd, dtype, dshape, dloc)
    use libfida, only: birthprofile
    implicit none
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    integer, intent(in) :: this(2)
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%ri)) then
        dshape(1:2) = shape(this_ptr%p%ri)
        dloc = loc(this_ptr%p%ri)
    else
        dloc = 0
    end if
end subroutine f90wrap_birthprofile__array__ri

subroutine f90wrap_birthprofile__array__vi(this, nd, dtype, dshape, dloc)
    use libfida, only: birthprofile
    implicit none
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    integer, intent(in) :: this(2)
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%vi)) then
        dshape(1:2) = shape(this_ptr%p%vi)
        dloc = loc(this_ptr%p%vi)
    else
        dloc = 0
    end if
end subroutine f90wrap_birthprofile__array__vi

subroutine f90wrap_birthprofile__array__ind(this, nd, dtype, dshape, dloc)
    use libfida, only: birthprofile
    implicit none
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    integer, intent(in) :: this(2)
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 5
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%ind)) then
        dshape(1:2) = shape(this_ptr%p%ind)
        dloc = loc(this_ptr%p%ind)
    else
        dloc = 0
    end if
end subroutine f90wrap_birthprofile__array__ind

subroutine f90wrap_birthprofile__array__dens(this, nd, dtype, dshape, dloc)
    use libfida, only: birthprofile
    implicit none
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    integer, intent(in) :: this(2)
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 4
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%dens)) then
        dshape(1:4) = shape(this_ptr%p%dens)
        dloc = loc(this_ptr%p%dens)
    else
        dloc = 0
    end if
end subroutine f90wrap_birthprofile__array__dens

subroutine f90wrap_birthprofile_initialise(this)
    use libfida, only: birthprofile
    implicit none
    
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_birthprofile_initialise

subroutine f90wrap_birthprofile_finalise(this)
    use libfida, only: birthprofile
    implicit none
    
    type birthprofile_ptr_type
        type(birthprofile), pointer :: p => NULL()
    end type birthprofile_ptr_type
    type(birthprofile_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_birthprofile_finalise

subroutine f90wrap_spectra__array__brems(this, nd, dtype, dshape, dloc)
    use libfida, only: spectra
    implicit none
    type spectra_ptr_type
        type(spectra), pointer :: p => NULL()
    end type spectra_ptr_type
    integer, intent(in) :: this(2)
    type(spectra_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%brems)) then
        dshape(1:2) = shape(this_ptr%p%brems)
        dloc = loc(this_ptr%p%brems)
    else
        dloc = 0
    end if
end subroutine f90wrap_spectra__array__brems

subroutine f90wrap_spectra__array__bes(this, nd, dtype, dshape, dloc)
    use libfida, only: spectra
    implicit none
    type spectra_ptr_type
        type(spectra), pointer :: p => NULL()
    end type spectra_ptr_type
    integer, intent(in) :: this(2)
    type(spectra_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 3
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%bes)) then
        dshape(1:3) = shape(this_ptr%p%bes)
        dloc = loc(this_ptr%p%bes)
    else
        dloc = 0
    end if
end subroutine f90wrap_spectra__array__bes

subroutine f90wrap_spectra__array__fida(this, nd, dtype, dshape, dloc)
    use libfida, only: spectra
    implicit none
    type spectra_ptr_type
        type(spectra), pointer :: p => NULL()
    end type spectra_ptr_type
    integer, intent(in) :: this(2)
    type(spectra_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 3
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%fida)) then
        dshape(1:3) = shape(this_ptr%p%fida)
        dloc = loc(this_ptr%p%fida)
    else
        dloc = 0
    end if
end subroutine f90wrap_spectra__array__fida

subroutine f90wrap_spectra_initialise(this)
    use libfida, only: spectra
    implicit none
    
    type spectra_ptr_type
        type(spectra), pointer :: p => NULL()
    end type spectra_ptr_type
    type(spectra_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_spectra_initialise

subroutine f90wrap_spectra_finalise(this)
    use libfida, only: spectra
    implicit none
    
    type spectra_ptr_type
        type(spectra), pointer :: p => NULL()
    end type spectra_ptr_type
    type(spectra_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_spectra_finalise

subroutine f90wrap_neutronrate__array__rate(this, nd, dtype, dshape, dloc)
    use libfida, only: neutronrate
    implicit none
    type neutronrate_ptr_type
        type(neutronrate), pointer :: p => NULL()
    end type neutronrate_ptr_type
    integer, intent(in) :: this(2)
    type(neutronrate_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%rate)) then
        dshape(1:1) = shape(this_ptr%p%rate)
        dloc = loc(this_ptr%p%rate)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutronrate__array__rate

subroutine f90wrap_neutronrate__array__weight(this, nd, dtype, dshape, dloc)
    use libfida, only: neutronrate
    implicit none
    type neutronrate_ptr_type
        type(neutronrate), pointer :: p => NULL()
    end type neutronrate_ptr_type
    integer, intent(in) :: this(2)
    type(neutronrate_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 4
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%weight)) then
        dshape(1:4) = shape(this_ptr%p%weight)
        dloc = loc(this_ptr%p%weight)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutronrate__array__weight

subroutine f90wrap_neutronrate_initialise(this)
    use libfida, only: neutronrate
    implicit none
    
    type neutronrate_ptr_type
        type(neutronrate), pointer :: p => NULL()
    end type neutronrate_ptr_type
    type(neutronrate_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_neutronrate_initialise

subroutine f90wrap_neutronrate_finalise(this)
    use libfida, only: neutronrate
    implicit none
    
    type neutronrate_ptr_type
        type(neutronrate), pointer :: p => NULL()
    end type neutronrate_ptr_type
    type(neutronrate_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_neutronrate_finalise

subroutine f90wrap_neutraldensity__array__dens(this, nd, dtype, dshape, dloc)
    use libfida, only: neutraldensity
    implicit none
    type neutraldensity_ptr_type
        type(neutraldensity), pointer :: p => NULL()
    end type neutraldensity_ptr_type
    integer, intent(in) :: this(2)
    type(neutraldensity_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 5
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%dens)) then
        dshape(1:5) = shape(this_ptr%p%dens)
        dloc = loc(this_ptr%p%dens)
    else
        dloc = 0
    end if
end subroutine f90wrap_neutraldensity__array__dens

subroutine f90wrap_neutraldensity_initialise(this)
    use libfida, only: neutraldensity
    implicit none
    
    type neutraldensity_ptr_type
        type(neutraldensity), pointer :: p => NULL()
    end type neutraldensity_ptr_type
    type(neutraldensity_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_neutraldensity_initialise

subroutine f90wrap_neutraldensity_finalise(this)
    use libfida, only: neutraldensity
    implicit none
    
    type neutraldensity_ptr_type
        type(neutraldensity), pointer :: p => NULL()
    end type neutraldensity_ptr_type
    type(neutraldensity_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_neutraldensity_finalise

subroutine f90wrap_fidaweights__array__mean_f(this, nd, dtype, dshape, dloc)
    use libfida, only: fidaweights
    implicit none
    type fidaweights_ptr_type
        type(fidaweights), pointer :: p => NULL()
    end type fidaweights_ptr_type
    integer, intent(in) :: this(2)
    type(fidaweights_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 3
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%mean_f)) then
        dshape(1:3) = shape(this_ptr%p%mean_f)
        dloc = loc(this_ptr%p%mean_f)
    else
        dloc = 0
    end if
end subroutine f90wrap_fidaweights__array__mean_f

subroutine f90wrap_fidaweights__array__weight(this, nd, dtype, dshape, dloc)
    use libfida, only: fidaweights
    implicit none
    type fidaweights_ptr_type
        type(fidaweights), pointer :: p => NULL()
    end type fidaweights_ptr_type
    integer, intent(in) :: this(2)
    type(fidaweights_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 4
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%weight)) then
        dshape(1:4) = shape(this_ptr%p%weight)
        dloc = loc(this_ptr%p%weight)
    else
        dloc = 0
    end if
end subroutine f90wrap_fidaweights__array__weight

subroutine f90wrap_fidaweights_initialise(this)
    use libfida, only: fidaweights
    implicit none
    
    type fidaweights_ptr_type
        type(fidaweights), pointer :: p => NULL()
    end type fidaweights_ptr_type
    type(fidaweights_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_fidaweights_initialise

subroutine f90wrap_fidaweights_finalise(this)
    use libfida, only: fidaweights
    implicit none
    
    type fidaweights_ptr_type
        type(fidaweights), pointer :: p => NULL()
    end type fidaweights_ptr_type
    type(fidaweights_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_fidaweights_finalise

subroutine f90wrap_npaweights__array__attenuation(this, nd, dtype, dshape, dloc)
    use libfida, only: npaweights
    implicit none
    type npaweights_ptr_type
        type(npaweights), pointer :: p => NULL()
    end type npaweights_ptr_type
    integer, intent(in) :: this(2)
    type(npaweights_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 5
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%attenuation)) then
        dshape(1:5) = shape(this_ptr%p%attenuation)
        dloc = loc(this_ptr%p%attenuation)
    else
        dloc = 0
    end if
end subroutine f90wrap_npaweights__array__attenuation

subroutine f90wrap_npaweights__array__cx(this, nd, dtype, dshape, dloc)
    use libfida, only: npaweights
    implicit none
    type npaweights_ptr_type
        type(npaweights), pointer :: p => NULL()
    end type npaweights_ptr_type
    integer, intent(in) :: this(2)
    type(npaweights_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 5
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%cx)) then
        dshape(1:5) = shape(this_ptr%p%cx)
        dloc = loc(this_ptr%p%cx)
    else
        dloc = 0
    end if
end subroutine f90wrap_npaweights__array__cx

subroutine f90wrap_npaweights__array__emissivity(this, nd, dtype, dshape, dloc)
    use libfida, only: npaweights
    implicit none
    type npaweights_ptr_type
        type(npaweights), pointer :: p => NULL()
    end type npaweights_ptr_type
    integer, intent(in) :: this(2)
    type(npaweights_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 4
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%emissivity)) then
        dshape(1:4) = shape(this_ptr%p%emissivity)
        dloc = loc(this_ptr%p%emissivity)
    else
        dloc = 0
    end if
end subroutine f90wrap_npaweights__array__emissivity

subroutine f90wrap_npaweights__array__weight(this, nd, dtype, dshape, dloc)
    use libfida, only: npaweights
    implicit none
    type npaweights_ptr_type
        type(npaweights), pointer :: p => NULL()
    end type npaweights_ptr_type
    integer, intent(in) :: this(2)
    type(npaweights_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 3
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%weight)) then
        dshape(1:3) = shape(this_ptr%p%weight)
        dloc = loc(this_ptr%p%weight)
    else
        dloc = 0
    end if
end subroutine f90wrap_npaweights__array__weight

subroutine f90wrap_npaweights__array__flux(this, nd, dtype, dshape, dloc)
    use libfida, only: npaweights
    implicit none
    type npaweights_ptr_type
        type(npaweights), pointer :: p => NULL()
    end type npaweights_ptr_type
    integer, intent(in) :: this(2)
    type(npaweights_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    if (allocated(this_ptr%p%flux)) then
        dshape(1:2) = shape(this_ptr%p%flux)
        dloc = loc(this_ptr%p%flux)
    else
        dloc = 0
    end if
end subroutine f90wrap_npaweights__array__flux

subroutine f90wrap_npaweights_initialise(this)
    use libfida, only: npaweights
    implicit none
    
    type npaweights_ptr_type
        type(npaweights), pointer :: p => NULL()
    end type npaweights_ptr_type
    type(npaweights_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_npaweights_initialise

subroutine f90wrap_npaweights_finalise(this)
    use libfida, only: npaweights
    implicit none
    
    type npaweights_ptr_type
        type(npaweights), pointer :: p => NULL()
    end type npaweights_ptr_type
    type(npaweights_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_npaweights_finalise

subroutine f90wrap_simulationinputs__get__shot_number(this, f90wrap_shot_number)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_shot_number
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_shot_number = this_ptr%p%shot_number
end subroutine f90wrap_simulationinputs__get__shot_number

subroutine f90wrap_simulationinputs__set__shot_number(this, f90wrap_shot_number)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_shot_number
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%shot_number = f90wrap_shot_number
end subroutine f90wrap_simulationinputs__set__shot_number

subroutine f90wrap_simulationinputs__get__time(this, f90wrap_time)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_time
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_time = this_ptr%p%time
end subroutine f90wrap_simulationinputs__get__time

subroutine f90wrap_simulationinputs__set__time(this, f90wrap_time)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_time
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%time = f90wrap_time
end subroutine f90wrap_simulationinputs__set__time

subroutine f90wrap_simulationinputs__get__runid(this, f90wrap_runid)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(out) :: f90wrap_runid
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_runid = this_ptr%p%runid
end subroutine f90wrap_simulationinputs__get__runid

subroutine f90wrap_simulationinputs__set__runid(this, f90wrap_runid)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(in) :: f90wrap_runid
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%runid = f90wrap_runid
end subroutine f90wrap_simulationinputs__set__runid

subroutine f90wrap_simulationinputs__get__result_dir(this, f90wrap_result_dir)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(out) :: f90wrap_result_dir
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_result_dir = this_ptr%p%result_dir
end subroutine f90wrap_simulationinputs__get__result_dir

subroutine f90wrap_simulationinputs__set__result_dir(this, f90wrap_result_dir)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(in) :: f90wrap_result_dir
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%result_dir = f90wrap_result_dir
end subroutine f90wrap_simulationinputs__set__result_dir

subroutine f90wrap_simulationinputs__get__tables_file(this, f90wrap_tables_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(out) :: f90wrap_tables_file
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_tables_file = this_ptr%p%tables_file
end subroutine f90wrap_simulationinputs__get__tables_file

subroutine f90wrap_simulationinputs__set__tables_file(this, f90wrap_tables_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(in) :: f90wrap_tables_file
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%tables_file = f90wrap_tables_file
end subroutine f90wrap_simulationinputs__set__tables_file

subroutine f90wrap_simulationinputs__get__geometry_file(this, &
    f90wrap_geometry_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(out) :: f90wrap_geometry_file
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_geometry_file = this_ptr%p%geometry_file
end subroutine f90wrap_simulationinputs__get__geometry_file

subroutine f90wrap_simulationinputs__set__geometry_file(this, &
    f90wrap_geometry_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(in) :: f90wrap_geometry_file
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%geometry_file = f90wrap_geometry_file
end subroutine f90wrap_simulationinputs__set__geometry_file

subroutine f90wrap_simulationinputs__get__equilibrium_file(this, &
    f90wrap_equilibrium_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(out) :: f90wrap_equilibrium_file
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_equilibrium_file = this_ptr%p%equilibrium_file
end subroutine f90wrap_simulationinputs__get__equilibrium_file

subroutine f90wrap_simulationinputs__set__equilibrium_file(this, &
    f90wrap_equilibrium_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(in) :: f90wrap_equilibrium_file
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%equilibrium_file = f90wrap_equilibrium_file
end subroutine f90wrap_simulationinputs__set__equilibrium_file

subroutine f90wrap_simulationinputs__get__distribution_file(this, &
    f90wrap_distribution_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(out) :: f90wrap_distribution_file
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_distribution_file = this_ptr%p%distribution_file
end subroutine f90wrap_simulationinputs__get__distribution_file

subroutine f90wrap_simulationinputs__set__distribution_file(this, &
    f90wrap_distribution_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(in) :: f90wrap_distribution_file
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%distribution_file = f90wrap_distribution_file
end subroutine f90wrap_simulationinputs__set__distribution_file

subroutine f90wrap_simulationinputs__get__neutrals_file(this, &
    f90wrap_neutrals_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(out) :: f90wrap_neutrals_file
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_neutrals_file = this_ptr%p%neutrals_file
end subroutine f90wrap_simulationinputs__get__neutrals_file

subroutine f90wrap_simulationinputs__set__neutrals_file(this, &
    f90wrap_neutrals_file)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    character(1024), intent(in) :: f90wrap_neutrals_file
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%neutrals_file = f90wrap_neutrals_file
end subroutine f90wrap_simulationinputs__set__neutrals_file

subroutine f90wrap_simulationinputs__get__n_fida(this, f90wrap_n_fida)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(out) :: f90wrap_n_fida
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_fida = this_ptr%p%n_fida
end subroutine f90wrap_simulationinputs__get__n_fida

subroutine f90wrap_simulationinputs__set__n_fida(this, f90wrap_n_fida)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(in) :: f90wrap_n_fida
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_fida = f90wrap_n_fida
end subroutine f90wrap_simulationinputs__set__n_fida

subroutine f90wrap_simulationinputs__get__n_npa(this, f90wrap_n_npa)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(out) :: f90wrap_n_npa
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_npa = this_ptr%p%n_npa
end subroutine f90wrap_simulationinputs__get__n_npa

subroutine f90wrap_simulationinputs__set__n_npa(this, f90wrap_n_npa)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(in) :: f90wrap_n_npa
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_npa = f90wrap_n_npa
end subroutine f90wrap_simulationinputs__set__n_npa

subroutine f90wrap_simulationinputs__get__n_nbi(this, f90wrap_n_nbi)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(out) :: f90wrap_n_nbi
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_nbi = this_ptr%p%n_nbi
end subroutine f90wrap_simulationinputs__get__n_nbi

subroutine f90wrap_simulationinputs__set__n_nbi(this, f90wrap_n_nbi)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(in) :: f90wrap_n_nbi
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_nbi = f90wrap_n_nbi
end subroutine f90wrap_simulationinputs__set__n_nbi

subroutine f90wrap_simulationinputs__get__n_dcx(this, f90wrap_n_dcx)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(out) :: f90wrap_n_dcx
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_dcx = this_ptr%p%n_dcx
end subroutine f90wrap_simulationinputs__get__n_dcx

subroutine f90wrap_simulationinputs__set__n_dcx(this, f90wrap_n_dcx)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(in) :: f90wrap_n_dcx
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_dcx = f90wrap_n_dcx
end subroutine f90wrap_simulationinputs__set__n_dcx

subroutine f90wrap_simulationinputs__get__n_halo(this, f90wrap_n_halo)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(out) :: f90wrap_n_halo
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_halo = this_ptr%p%n_halo
end subroutine f90wrap_simulationinputs__get__n_halo

subroutine f90wrap_simulationinputs__set__n_halo(this, f90wrap_n_halo)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(in) :: f90wrap_n_halo
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_halo = f90wrap_n_halo
end subroutine f90wrap_simulationinputs__set__n_halo

subroutine f90wrap_simulationinputs__get__n_birth(this, f90wrap_n_birth)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(out) :: f90wrap_n_birth
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_n_birth = this_ptr%p%n_birth
end subroutine f90wrap_simulationinputs__get__n_birth

subroutine f90wrap_simulationinputs__set__n_birth(this, f90wrap_n_birth)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(8), intent(in) :: f90wrap_n_birth
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%n_birth = f90wrap_n_birth
end subroutine f90wrap_simulationinputs__set__n_birth

subroutine f90wrap_simulationinputs__get__calc_spec(this, f90wrap_calc_spec)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_spec
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_spec = this_ptr%p%calc_spec
end subroutine f90wrap_simulationinputs__get__calc_spec

subroutine f90wrap_simulationinputs__set__calc_spec(this, f90wrap_calc_spec)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_spec
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_spec = f90wrap_calc_spec
end subroutine f90wrap_simulationinputs__set__calc_spec

subroutine f90wrap_simulationinputs__get__calc_brems(this, f90wrap_calc_brems)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_brems
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_brems = this_ptr%p%calc_brems
end subroutine f90wrap_simulationinputs__get__calc_brems

subroutine f90wrap_simulationinputs__set__calc_brems(this, f90wrap_calc_brems)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_brems
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_brems = f90wrap_calc_brems
end subroutine f90wrap_simulationinputs__set__calc_brems

subroutine f90wrap_simulationinputs__get__calc_bes(this, f90wrap_calc_bes)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_bes
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_bes = this_ptr%p%calc_bes
end subroutine f90wrap_simulationinputs__get__calc_bes

subroutine f90wrap_simulationinputs__set__calc_bes(this, f90wrap_calc_bes)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_bes
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_bes = f90wrap_calc_bes
end subroutine f90wrap_simulationinputs__set__calc_bes

subroutine f90wrap_simulationinputs__get__calc_fida(this, f90wrap_calc_fida)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_fida
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_fida = this_ptr%p%calc_fida
end subroutine f90wrap_simulationinputs__get__calc_fida

subroutine f90wrap_simulationinputs__set__calc_fida(this, f90wrap_calc_fida)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_fida
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_fida = f90wrap_calc_fida
end subroutine f90wrap_simulationinputs__set__calc_fida

subroutine f90wrap_simulationinputs__get__load_neutrals(this, &
    f90wrap_load_neutrals)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_load_neutrals
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_load_neutrals = this_ptr%p%load_neutrals
end subroutine f90wrap_simulationinputs__get__load_neutrals

subroutine f90wrap_simulationinputs__set__load_neutrals(this, &
    f90wrap_load_neutrals)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_load_neutrals
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%load_neutrals = f90wrap_load_neutrals
end subroutine f90wrap_simulationinputs__set__load_neutrals

subroutine f90wrap_simulationinputs__get__calc_npa(this, f90wrap_calc_npa)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_npa
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_npa = this_ptr%p%calc_npa
end subroutine f90wrap_simulationinputs__get__calc_npa

subroutine f90wrap_simulationinputs__set__calc_npa(this, f90wrap_calc_npa)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_npa
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_npa = f90wrap_calc_npa
end subroutine f90wrap_simulationinputs__set__calc_npa

subroutine f90wrap_simulationinputs__get__calc_fida_wght(this, &
    f90wrap_calc_fida_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_fida_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_fida_wght = this_ptr%p%calc_fida_wght
end subroutine f90wrap_simulationinputs__get__calc_fida_wght

subroutine f90wrap_simulationinputs__set__calc_fida_wght(this, &
    f90wrap_calc_fida_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_fida_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_fida_wght = f90wrap_calc_fida_wght
end subroutine f90wrap_simulationinputs__set__calc_fida_wght

subroutine f90wrap_simulationinputs__get__calc_npa_wght(this, &
    f90wrap_calc_npa_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_npa_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_npa_wght = this_ptr%p%calc_npa_wght
end subroutine f90wrap_simulationinputs__get__calc_npa_wght

subroutine f90wrap_simulationinputs__set__calc_npa_wght(this, &
    f90wrap_calc_npa_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_npa_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_npa_wght = f90wrap_calc_npa_wght
end subroutine f90wrap_simulationinputs__set__calc_npa_wght

subroutine f90wrap_simulationinputs__get__calc_birth(this, f90wrap_calc_birth)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_birth
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_birth = this_ptr%p%calc_birth
end subroutine f90wrap_simulationinputs__get__calc_birth

subroutine f90wrap_simulationinputs__set__calc_birth(this, f90wrap_calc_birth)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_birth
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_birth = f90wrap_calc_birth
end subroutine f90wrap_simulationinputs__set__calc_birth

subroutine f90wrap_simulationinputs__get__calc_neutron(this, &
    f90wrap_calc_neutron)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_calc_neutron
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_calc_neutron = this_ptr%p%calc_neutron
end subroutine f90wrap_simulationinputs__get__calc_neutron

subroutine f90wrap_simulationinputs__set__calc_neutron(this, &
    f90wrap_calc_neutron)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_calc_neutron
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%calc_neutron = f90wrap_calc_neutron
end subroutine f90wrap_simulationinputs__set__calc_neutron

subroutine f90wrap_simulationinputs__get__no_flr(this, f90wrap_no_flr)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_no_flr
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_no_flr = this_ptr%p%no_flr
end subroutine f90wrap_simulationinputs__get__no_flr

subroutine f90wrap_simulationinputs__set__no_flr(this, f90wrap_no_flr)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_no_flr
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%no_flr = f90wrap_no_flr
end subroutine f90wrap_simulationinputs__set__no_flr

subroutine f90wrap_simulationinputs__get__dump_dcx(this, f90wrap_dump_dcx)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_dump_dcx
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dump_dcx = this_ptr%p%dump_dcx
end subroutine f90wrap_simulationinputs__get__dump_dcx

subroutine f90wrap_simulationinputs__set__dump_dcx(this, f90wrap_dump_dcx)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_dump_dcx
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dump_dcx = f90wrap_dump_dcx
end subroutine f90wrap_simulationinputs__set__dump_dcx

subroutine f90wrap_simulationinputs__get__verbose(this, f90wrap_verbose)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_verbose
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_verbose = this_ptr%p%verbose
end subroutine f90wrap_simulationinputs__get__verbose

subroutine f90wrap_simulationinputs__set__verbose(this, f90wrap_verbose)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_verbose
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%verbose = f90wrap_verbose
end subroutine f90wrap_simulationinputs__set__verbose

subroutine f90wrap_simulationinputs__get__ab(this, f90wrap_ab)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_ab
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ab = this_ptr%p%ab
end subroutine f90wrap_simulationinputs__get__ab

subroutine f90wrap_simulationinputs__set__ab(this, f90wrap_ab)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_ab
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ab = f90wrap_ab
end subroutine f90wrap_simulationinputs__set__ab

subroutine f90wrap_simulationinputs__get__impurity_charge(this, &
    f90wrap_impurity_charge)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_impurity_charge
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_impurity_charge = this_ptr%p%impurity_charge
end subroutine f90wrap_simulationinputs__get__impurity_charge

subroutine f90wrap_simulationinputs__set__impurity_charge(this, &
    f90wrap_impurity_charge)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_impurity_charge
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%impurity_charge = f90wrap_impurity_charge
end subroutine f90wrap_simulationinputs__set__impurity_charge

subroutine f90wrap_simulationinputs__get__ai(this, f90wrap_ai)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_ai
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ai = this_ptr%p%ai
end subroutine f90wrap_simulationinputs__get__ai

subroutine f90wrap_simulationinputs__set__ai(this, f90wrap_ai)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_ai
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ai = f90wrap_ai
end subroutine f90wrap_simulationinputs__set__ai

subroutine f90wrap_simulationinputs__get__dist_type(this, f90wrap_dist_type)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_dist_type
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dist_type = this_ptr%p%dist_type
end subroutine f90wrap_simulationinputs__get__dist_type

subroutine f90wrap_simulationinputs__set__dist_type(this, f90wrap_dist_type)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_dist_type
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dist_type = f90wrap_dist_type
end subroutine f90wrap_simulationinputs__set__dist_type

subroutine f90wrap_simulationinputs__get__nlambda(this, f90wrap_nlambda)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nlambda
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nlambda = this_ptr%p%nlambda
end subroutine f90wrap_simulationinputs__get__nlambda

subroutine f90wrap_simulationinputs__set__nlambda(this, f90wrap_nlambda)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nlambda
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nlambda = f90wrap_nlambda
end subroutine f90wrap_simulationinputs__set__nlambda

subroutine f90wrap_simulationinputs__get__dlambda(this, f90wrap_dlambda)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_dlambda
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_dlambda = this_ptr%p%dlambda
end subroutine f90wrap_simulationinputs__get__dlambda

subroutine f90wrap_simulationinputs__set__dlambda(this, f90wrap_dlambda)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_dlambda
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%dlambda = f90wrap_dlambda
end subroutine f90wrap_simulationinputs__set__dlambda

subroutine f90wrap_simulationinputs__get__lambdamin(this, f90wrap_lambdamin)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_lambdamin
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_lambdamin = this_ptr%p%lambdamin
end subroutine f90wrap_simulationinputs__get__lambdamin

subroutine f90wrap_simulationinputs__set__lambdamin(this, f90wrap_lambdamin)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_lambdamin
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%lambdamin = f90wrap_lambdamin
end subroutine f90wrap_simulationinputs__set__lambdamin

subroutine f90wrap_simulationinputs__get__lambdamax(this, f90wrap_lambdamax)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_lambdamax
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_lambdamax = this_ptr%p%lambdamax
end subroutine f90wrap_simulationinputs__get__lambdamax

subroutine f90wrap_simulationinputs__set__lambdamax(this, f90wrap_lambdamax)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_lambdamax
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%lambdamax = f90wrap_lambdamax
end subroutine f90wrap_simulationinputs__set__lambdamax

subroutine f90wrap_simulationinputs__get__ne_wght(this, f90wrap_ne_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_ne_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_ne_wght = this_ptr%p%ne_wght
end subroutine f90wrap_simulationinputs__get__ne_wght

subroutine f90wrap_simulationinputs__set__ne_wght(this, f90wrap_ne_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_ne_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%ne_wght = f90wrap_ne_wght
end subroutine f90wrap_simulationinputs__set__ne_wght

subroutine f90wrap_simulationinputs__get__np_wght(this, f90wrap_np_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_np_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_np_wght = this_ptr%p%np_wght
end subroutine f90wrap_simulationinputs__get__np_wght

subroutine f90wrap_simulationinputs__set__np_wght(this, f90wrap_np_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_np_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%np_wght = f90wrap_np_wght
end subroutine f90wrap_simulationinputs__set__np_wght

subroutine f90wrap_simulationinputs__get__nphi_wght(this, f90wrap_nphi_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nphi_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nphi_wght = this_ptr%p%nphi_wght
end subroutine f90wrap_simulationinputs__get__nphi_wght

subroutine f90wrap_simulationinputs__set__nphi_wght(this, f90wrap_nphi_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nphi_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nphi_wght = f90wrap_nphi_wght
end subroutine f90wrap_simulationinputs__set__nphi_wght

subroutine f90wrap_simulationinputs__get__nlambda_wght(this, &
    f90wrap_nlambda_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(out) :: f90wrap_nlambda_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_nlambda_wght = this_ptr%p%nlambda_wght
end subroutine f90wrap_simulationinputs__get__nlambda_wght

subroutine f90wrap_simulationinputs__set__nlambda_wght(this, &
    f90wrap_nlambda_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    integer(4), intent(in) :: f90wrap_nlambda_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%nlambda_wght = f90wrap_nlambda_wght
end subroutine f90wrap_simulationinputs__set__nlambda_wght

subroutine f90wrap_simulationinputs__get__emax_wght(this, f90wrap_emax_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_emax_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_emax_wght = this_ptr%p%emax_wght
end subroutine f90wrap_simulationinputs__get__emax_wght

subroutine f90wrap_simulationinputs__set__emax_wght(this, f90wrap_emax_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_emax_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%emax_wght = f90wrap_emax_wght
end subroutine f90wrap_simulationinputs__set__emax_wght

subroutine f90wrap_simulationinputs__get__lambdamin_wght(this, &
    f90wrap_lambdamin_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_lambdamin_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_lambdamin_wght = this_ptr%p%lambdamin_wght
end subroutine f90wrap_simulationinputs__get__lambdamin_wght

subroutine f90wrap_simulationinputs__set__lambdamin_wght(this, &
    f90wrap_lambdamin_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_lambdamin_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%lambdamin_wght = f90wrap_lambdamin_wght
end subroutine f90wrap_simulationinputs__set__lambdamin_wght

subroutine f90wrap_simulationinputs__get__lambdamax_wght(this, &
    f90wrap_lambdamax_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_lambdamax_wght
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_lambdamax_wght = this_ptr%p%lambdamax_wght
end subroutine f90wrap_simulationinputs__get__lambdamax_wght

subroutine f90wrap_simulationinputs__set__lambdamax_wght(this, &
    f90wrap_lambdamax_wght)
    use libfida, only: simulationinputs
    implicit none
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    integer, intent(in)   :: this(2)
    type(simulationinputs_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_lambdamax_wght
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%lambdamax_wght = f90wrap_lambdamax_wght
end subroutine f90wrap_simulationinputs__set__lambdamax_wght

subroutine f90wrap_simulationinputs_initialise(this)
    use libfida, only: simulationinputs
    implicit none
    
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    type(simulationinputs_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_simulationinputs_initialise

subroutine f90wrap_simulationinputs_finalise(this)
    use libfida, only: simulationinputs
    implicit none
    
    type simulationinputs_ptr_type
        type(simulationinputs), pointer :: p => NULL()
    end type simulationinputs_ptr_type
    type(simulationinputs_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_simulationinputs_finalise

subroutine f90wrap_particletrack__get__time(this, f90wrap_time)
    use libfida, only: particletrack
    implicit none
    type particletrack_ptr_type
        type(particletrack), pointer :: p => NULL()
    end type particletrack_ptr_type
    integer, intent(in)   :: this(2)
    type(particletrack_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_time
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_time = this_ptr%p%time
end subroutine f90wrap_particletrack__get__time

subroutine f90wrap_particletrack__set__time(this, f90wrap_time)
    use libfida, only: particletrack
    implicit none
    type particletrack_ptr_type
        type(particletrack), pointer :: p => NULL()
    end type particletrack_ptr_type
    integer, intent(in)   :: this(2)
    type(particletrack_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_time
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%time = f90wrap_time
end subroutine f90wrap_particletrack__set__time

subroutine f90wrap_particletrack__get__flux(this, f90wrap_flux)
    use libfida, only: particletrack
    implicit none
    type particletrack_ptr_type
        type(particletrack), pointer :: p => NULL()
    end type particletrack_ptr_type
    integer, intent(in)   :: this(2)
    type(particletrack_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_flux
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_flux = this_ptr%p%flux
end subroutine f90wrap_particletrack__get__flux

subroutine f90wrap_particletrack__set__flux(this, f90wrap_flux)
    use libfida, only: particletrack
    implicit none
    type particletrack_ptr_type
        type(particletrack), pointer :: p => NULL()
    end type particletrack_ptr_type
    integer, intent(in)   :: this(2)
    type(particletrack_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_flux
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%flux = f90wrap_flux
end subroutine f90wrap_particletrack__set__flux

subroutine f90wrap_particletrack__array__ind(this, nd, dtype, dshape, dloc)
    use libfida, only: particletrack
    implicit none
    type particletrack_ptr_type
        type(particletrack), pointer :: p => NULL()
    end type particletrack_ptr_type
    integer, intent(in) :: this(2)
    type(particletrack_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 5
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%ind)
    dloc = loc(this_ptr%p%ind)
end subroutine f90wrap_particletrack__array__ind

subroutine f90wrap_particletrack__array__pos(this, nd, dtype, dshape, dloc)
    use libfida, only: particletrack
    implicit none
    type particletrack_ptr_type
        type(particletrack), pointer :: p => NULL()
    end type particletrack_ptr_type
    integer, intent(in) :: this(2)
    type(particletrack_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%pos)
    dloc = loc(this_ptr%p%pos)
end subroutine f90wrap_particletrack__array__pos

subroutine f90wrap_particletrack_initialise(this)
    use libfida, only: particletrack
    implicit none
    
    type particletrack_ptr_type
        type(particletrack), pointer :: p => NULL()
    end type particletrack_ptr_type
    type(particletrack_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_particletrack_initialise

subroutine f90wrap_particletrack_finalise(this)
    use libfida, only: particletrack
    implicit none
    
    type particletrack_ptr_type
        type(particletrack), pointer :: p => NULL()
    end type particletrack_ptr_type
    type(particletrack_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_particletrack_finalise

subroutine f90wrap_gyrosurface__get__v(this, f90wrap_v)
    use libfida, only: gyrosurface
    implicit none
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in)   :: this(2)
    type(gyrosurface_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_v
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_v = this_ptr%p%v
end subroutine f90wrap_gyrosurface__get__v

subroutine f90wrap_gyrosurface__set__v(this, f90wrap_v)
    use libfida, only: gyrosurface
    implicit none
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in)   :: this(2)
    type(gyrosurface_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_v
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%v = f90wrap_v
end subroutine f90wrap_gyrosurface__set__v

subroutine f90wrap_gyrosurface__get__omega(this, f90wrap_omega)
    use libfida, only: gyrosurface
    implicit none
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in)   :: this(2)
    type(gyrosurface_ptr_type) :: this_ptr
    real(8), intent(out) :: f90wrap_omega
    
    this_ptr = transfer(this, this_ptr)
    f90wrap_omega = this_ptr%p%omega
end subroutine f90wrap_gyrosurface__get__omega

subroutine f90wrap_gyrosurface__set__omega(this, f90wrap_omega)
    use libfida, only: gyrosurface
    implicit none
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in)   :: this(2)
    type(gyrosurface_ptr_type) :: this_ptr
    real(8), intent(in) :: f90wrap_omega
    
    this_ptr = transfer(this, this_ptr)
    this_ptr%p%omega = f90wrap_omega
end subroutine f90wrap_gyrosurface__set__omega

subroutine f90wrap_gyrosurface__array__axes(this, nd, dtype, dshape, dloc)
    use libfida, only: gyrosurface
    implicit none
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in) :: this(2)
    type(gyrosurface_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%axes)
    dloc = loc(this_ptr%p%axes)
end subroutine f90wrap_gyrosurface__array__axes

subroutine f90wrap_gyrosurface__array__center(this, nd, dtype, dshape, dloc)
    use libfida, only: gyrosurface
    implicit none
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in) :: this(2)
    type(gyrosurface_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:1) = shape(this_ptr%p%center)
    dloc = loc(this_ptr%p%center)
end subroutine f90wrap_gyrosurface__array__center

subroutine f90wrap_gyrosurface__array__a(this, nd, dtype, dshape, dloc)
    use libfida, only: gyrosurface
    implicit none
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in) :: this(2)
    type(gyrosurface_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%a)
    dloc = loc(this_ptr%p%a)
end subroutine f90wrap_gyrosurface__array__a

subroutine f90wrap_gyrosurface__array__basis(this, nd, dtype, dshape, dloc)
    use libfida, only: gyrosurface
    implicit none
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in) :: this(2)
    type(gyrosurface_ptr_type) :: this_ptr
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 2
    dtype = 12
    this_ptr = transfer(this, this_ptr)
    dshape(1:2) = shape(this_ptr%p%basis)
    dloc = loc(this_ptr%p%basis)
end subroutine f90wrap_gyrosurface__array__basis

subroutine f90wrap_gyrosurface_initialise(this)
    use libfida, only: gyrosurface
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    type(gyrosurface_ptr_type) :: this_ptr
    integer, intent(out), dimension(2) :: this
    allocate(this_ptr%p)
    this = transfer(this_ptr, this)
end subroutine f90wrap_gyrosurface_initialise

subroutine f90wrap_gyrosurface_finalise(this)
    use libfida, only: gyrosurface
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    type(gyrosurface_ptr_type) :: this_ptr
    integer, intent(in), dimension(2) :: this
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_gyrosurface_finalise

subroutine f90wrap_print_banner
    use libfida, only: print_banner
    implicit none
    
    call print_banner()
end subroutine f90wrap_print_banner

subroutine f90wrap_read_inputs
    use libfida, only: read_inputs
    implicit none
    
    call read_inputs()
end subroutine f90wrap_read_inputs

subroutine f90wrap_make_beam_grid
    use libfida, only: make_beam_grid
    implicit none
    
    call make_beam_grid()
end subroutine f90wrap_make_beam_grid

subroutine f90wrap_read_beam
    use libfida, only: read_beam
    implicit none
    
    call read_beam()
end subroutine f90wrap_read_beam

subroutine f90wrap_read_chords
    use libfida, only: read_chords
    implicit none
    
    call read_chords()
end subroutine f90wrap_read_chords

subroutine f90wrap_read_npa
    use libfida, only: read_npa
    implicit none
    
    call read_npa()
end subroutine f90wrap_read_npa

subroutine f90wrap_read_equilibrium
    use libfida, only: read_equilibrium
    implicit none
    
    call read_equilibrium()
end subroutine f90wrap_read_equilibrium

subroutine f90wrap_read_f(fid, error)
    use libfida, only: read_f
    implicit none
    
    integer(4), intent(inout) :: fid
    integer, intent(out) :: error
    call read_f(fid=fid, error=error)
end subroutine f90wrap_read_f

subroutine f90wrap_read_mc(fid, error)
    use libfida, only: read_mc
    implicit none
    
    integer(4), intent(inout) :: fid
    integer, intent(out) :: error
    call read_mc(fid=fid, error=error)
end subroutine f90wrap_read_mc

subroutine f90wrap_read_distribution
    use libfida, only: read_distribution
    implicit none
    
    call read_distribution()
end subroutine f90wrap_read_distribution

subroutine f90wrap_read_atomic_cross(fid, grp, cross)
    use libfida, only: read_atomic_cross, atomiccrosssection
    implicit none
    
    type atomiccrosssection_ptr_type
        type(atomiccrosssection), pointer :: p => NULL()
    end type atomiccrosssection_ptr_type
    integer(4), intent(in) :: fid
    character(*), intent(in) :: grp
    type(atomiccrosssection_ptr_type) :: cross_ptr
    integer, intent(in), dimension(2) :: cross
    cross_ptr = transfer(cross, cross_ptr)
    call read_atomic_cross(fid=fid, grp=grp, cross=cross_ptr%p)
end subroutine f90wrap_read_atomic_cross

subroutine f90wrap_read_atomic_rate(fid, grp, b_amu, t_amu, rates)
    use libfida, only: read_atomic_rate, atomicrates
    implicit none
    
    type atomicrates_ptr_type
        type(atomicrates), pointer :: p => NULL()
    end type atomicrates_ptr_type
    integer(4), intent(in) :: fid
    character(*), intent(in) :: grp
    real(8), dimension(2), intent(in) :: b_amu
    real(8), intent(in) :: t_amu
    type(atomicrates_ptr_type) :: rates_ptr
    integer, intent(in), dimension(2) :: rates
    rates_ptr = transfer(rates, rates_ptr)
    call read_atomic_rate(fid=fid, grp=grp, b_amu=b_amu, t_amu=t_amu, &
        rates=rates_ptr%p)
end subroutine f90wrap_read_atomic_rate

subroutine f90wrap_read_atomic_transitions(fid, grp, b_amu, t_amu, rates)
    use libfida, only: atomictransitions, read_atomic_transitions
    implicit none
    
    type atomictransitions_ptr_type
        type(atomictransitions), pointer :: p => NULL()
    end type atomictransitions_ptr_type
    integer(4), intent(in) :: fid
    character(*), intent(in) :: grp
    real(8), dimension(2), intent(in) :: b_amu
    real(8), intent(in) :: t_amu
    type(atomictransitions_ptr_type) :: rates_ptr
    integer, intent(in), dimension(2) :: rates
    rates_ptr = transfer(rates, rates_ptr)
    call read_atomic_transitions(fid=fid, grp=grp, b_amu=b_amu, t_amu=t_amu, &
        rates=rates_ptr%p)
end subroutine f90wrap_read_atomic_transitions

subroutine f90wrap_read_nuclear_rates(fid, grp, rates)
    use libfida, only: read_nuclear_rates, nuclearrates
    implicit none
    
    type nuclearrates_ptr_type
        type(nuclearrates), pointer :: p => NULL()
    end type nuclearrates_ptr_type
    integer(4), intent(in) :: fid
    character(*), intent(in) :: grp
    type(nuclearrates_ptr_type) :: rates_ptr
    integer, intent(in), dimension(2) :: rates
    rates_ptr = transfer(rates, rates_ptr)
    call read_nuclear_rates(fid=fid, grp=grp, rates=rates_ptr%p)
end subroutine f90wrap_read_nuclear_rates

subroutine f90wrap_read_tables
    use libfida, only: read_tables
    implicit none
    
    call read_tables()
end subroutine f90wrap_read_tables

subroutine f90wrap_write_beam_grid(id, error)
    use libfida, only: write_beam_grid
    implicit none
    
    integer(4), intent(inout) :: id
    integer, intent(out) :: error
    call write_beam_grid(id=id, error=error)
end subroutine f90wrap_write_beam_grid

subroutine f90wrap_write_birth_profile
    use libfida, only: write_birth_profile
    implicit none
    
    call write_birth_profile()
end subroutine f90wrap_write_birth_profile

subroutine f90wrap_write_dcx
    use libfida, only: write_dcx
    implicit none
    
    call write_dcx()
end subroutine f90wrap_write_dcx

subroutine f90wrap_write_neutrals
    use libfida, only: write_neutrals
    implicit none
    
    call write_neutrals()
end subroutine f90wrap_write_neutrals

subroutine f90wrap_write_npa
    use libfida, only: write_npa
    implicit none
    
    call write_npa()
end subroutine f90wrap_write_npa

subroutine f90wrap_write_spectra
    use libfida, only: write_spectra
    implicit none
    
    call write_spectra()
end subroutine f90wrap_write_spectra

subroutine f90wrap_write_neutrons
    use libfida, only: write_neutrons
    implicit none
    
    call write_neutrons()
end subroutine f90wrap_write_neutrons

subroutine f90wrap_write_fida_weights
    use libfida, only: write_fida_weights
    implicit none
    
    call write_fida_weights()
end subroutine f90wrap_write_fida_weights

subroutine f90wrap_write_npa_weights
    use libfida, only: write_npa_weights
    implicit none
    
    call write_npa_weights()
end subroutine f90wrap_write_npa_weights

subroutine f90wrap_read_neutrals
    use libfida, only: read_neutrals
    implicit none
    
    call read_neutrals()
end subroutine f90wrap_read_neutrals

subroutine f90wrap_approx_eq(x, y, ret_a, tol)
    use libfida, only: approx_eq
    implicit none
    
    real(8), intent(in) :: x
    real(8), intent(in) :: y
    logical, intent(out) :: ret_a
    real(8), intent(in) :: tol
    ret_a = approx_eq(x=x, y=y, tol=tol)
end subroutine f90wrap_approx_eq

subroutine f90wrap_approx_ge(x, y, ret_a, tol)
    use libfida, only: approx_ge
    implicit none
    
    real(8), intent(in) :: x
    real(8), intent(in) :: y
    logical, intent(out) :: ret_a
    real(8), intent(in) :: tol
    ret_a = approx_ge(x=x, y=y, tol=tol)
end subroutine f90wrap_approx_ge

subroutine f90wrap_approx_le(x, y, ret_a, tol)
    use libfida, only: approx_le
    implicit none
    
    real(8), intent(in) :: x
    real(8), intent(in) :: y
    logical, intent(out) :: ret_a
    real(8), intent(in) :: tol
    ret_a = approx_le(x=x, y=y, tol=tol)
end subroutine f90wrap_approx_le

subroutine f90wrap_cross_product(u, ret_s, v)
    use libfida, only: cross_product
    implicit none
    
    real(8), dimension(3), intent(in) :: u
    real(8), dimension(3), intent(out) :: ret_s
    real(8), dimension(3), intent(in) :: v
    ret_s = cross_product(u=u, v=v)
end subroutine f90wrap_cross_product

subroutine f90wrap_tb_zyx(alpha, beta, gamma, basis, inv_basis)
    use libfida, only: tb_zyx
    implicit none
    
    real(8), intent(in) :: alpha
    real(8), intent(in) :: beta
    real(8), intent(in) :: gamma
    real(8), dimension(3,3), intent(inout) :: basis
    real(8), dimension(3,3), optional, intent(inout) :: inv_basis
    call tb_zyx(alpha=alpha, beta=beta, gamma=gamma, basis=basis, &
        inv_basis=inv_basis)
end subroutine f90wrap_tb_zyx

subroutine f90wrap_line_basis(r0, v0, basis, inv_basis)
    use libfida, only: line_basis
    implicit none
    
    real(8), dimension(3), intent(in) :: r0
    real(8), dimension(3), intent(in) :: v0
    real(8), dimension(3,3), intent(inout) :: basis
    real(8), dimension(3,3), optional, intent(inout) :: inv_basis
    call line_basis(r0=r0, v0=v0, basis=basis, inv_basis=inv_basis)
end subroutine f90wrap_line_basis

subroutine f90wrap_plane_basis(center, redge, tedge, basis, inv_basis)
    use libfida, only: plane_basis
    implicit none
    
    real(8), dimension(3), intent(in) :: center
    real(8), dimension(3), intent(in) :: redge
    real(8), dimension(3), intent(in) :: tedge
    real(8), dimension(3,3), intent(inout) :: basis
    real(8), dimension(3,3), optional, intent(inout) :: inv_basis
    call plane_basis(center=center, redge=redge, tedge=tedge, basis=basis, &
        inv_basis=inv_basis)
end subroutine f90wrap_plane_basis

subroutine f90wrap_line_plane_intersect(l0, l, p0, n, p, t)
    use libfida, only: line_plane_intersect
    implicit none
    
    real(8), dimension(3), intent(in) :: l0
    real(8), dimension(3), intent(in) :: l
    real(8), dimension(3), intent(in) :: p0
    real(8), dimension(3), intent(in) :: n
    real(8), dimension(3), intent(inout) :: p
    real(8), intent(out) :: t
    call line_plane_intersect(l0=l0, l=l, p0=p0, n=n, p=p, t=t)
end subroutine f90wrap_line_plane_intersect

subroutine f90wrap_in_boundary(bplane, ret_in_b, p)
    use libfida, only: in_boundary, boundedplane
    implicit none
    
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    type(boundedplane_ptr_type) :: bplane_ptr
    integer, intent(in), dimension(2) :: bplane
    logical, intent(out) :: ret_in_b
    real(8), dimension(3), intent(in) :: p
    bplane_ptr = transfer(bplane, bplane_ptr)
    ret_in_b = in_boundary(bplane=bplane_ptr%p, p=p)
end subroutine f90wrap_in_boundary

subroutine f90wrap_boundary_edge(bplane, bedge, nb, n0, n1)
    use libfida, only: boundary_edge, boundedplane
    implicit none
    
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    type(boundedplane_ptr_type) :: bplane_ptr
    integer, intent(in), dimension(2) :: bplane
    real(8), intent(inout), dimension(n0,n1) :: bedge
    integer, intent(out) :: nb
    integer :: n0
    !f2py intent(hide), depend(bedge) :: n0 = shape(bedge,0)
    integer :: n1
    !f2py intent(hide), depend(bedge) :: n1 = shape(bedge,1)
    bplane_ptr = transfer(bplane, bplane_ptr)
    call boundary_edge(bplane=bplane_ptr%p, bedge=bedge, nb=nb)
end subroutine f90wrap_boundary_edge

subroutine f90wrap_gyro_surface(fields, energy, pitch, gs)
    use libfida, only: gyro_surface, gyrosurface, localemfields
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(in), dimension(2) :: fields
    real(8), intent(in) :: energy
    real(8), intent(in) :: pitch
    type(gyrosurface_ptr_type) :: gs_ptr
    integer, intent(out), dimension(2) :: gs
    fields_ptr = transfer(fields, fields_ptr)
    allocate(gs_ptr%p)
    call gyro_surface(fields=fields_ptr%p, energy=energy, pitch=pitch, gs=gs_ptr%p)
    gs = transfer(gs_ptr, gs)
end subroutine f90wrap_gyro_surface

subroutine f90wrap_line_gyro_surface_intersect(r0, v0, gs, t)
    use libfida, only: line_gyro_surface_intersect, gyrosurface
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    real(8), dimension(3), intent(in) :: r0
    real(8), dimension(3), intent(in) :: v0
    type(gyrosurface_ptr_type) :: gs_ptr
    integer, intent(in), dimension(2) :: gs
    real(8), dimension(2), intent(inout) :: t
    gs_ptr = transfer(gs, gs_ptr)
    call line_gyro_surface_intersect(r0=r0, v0=v0, gs=gs_ptr%p, t=t)
end subroutine f90wrap_line_gyro_surface_intersect

subroutine f90wrap_gyro_surface_coordinates(gs, p, u)
    use libfida, only: gyro_surface_coordinates, gyrosurface
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    type(gyrosurface_ptr_type) :: gs_ptr
    integer, intent(in), dimension(2) :: gs
    real(8), dimension(3), intent(in) :: p
    real(8), dimension(2), intent(inout) :: u
    gs_ptr = transfer(gs, gs_ptr)
    call gyro_surface_coordinates(gs=gs_ptr%p, p=p, u=u)
end subroutine f90wrap_gyro_surface_coordinates

subroutine f90wrap_gyro_trajectory(gs, theta, ri, vi)
    use libfida, only: gyro_trajectory, gyrosurface
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    type(gyrosurface_ptr_type) :: gs_ptr
    integer, intent(in), dimension(2) :: gs
    real(8), intent(in) :: theta
    real(8), dimension(3) :: ri
    real(8), dimension(3) :: vi
    gs_ptr = transfer(gs, gs_ptr)
    call gyro_trajectory(gs=gs_ptr%p, theta=theta, ri=ri, vi=vi)
end subroutine f90wrap_gyro_trajectory

subroutine f90wrap_in_gyro_surface(gs, ret_in_gs, p)
    use libfida, only: in_gyro_surface, gyrosurface
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    type(gyrosurface_ptr_type) :: gs_ptr
    integer, intent(in), dimension(2) :: gs
    logical, intent(out) :: ret_in_gs
    real(8), dimension(3), intent(in) :: p
    gs_ptr = transfer(gs, gs_ptr)
    ret_in_gs = in_gyro_surface(gs=gs_ptr%p, p=p)
end subroutine f90wrap_in_gyro_surface

subroutine f90wrap_gyro_range(b, gs, gyrange, nrange)
    use libfida, only: gyro_range, gyrosurface, boundedplane
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    type boundedplane_ptr_type
        type(boundedplane), pointer :: p => NULL()
    end type boundedplane_ptr_type
    type(boundedplane_ptr_type) :: b_ptr
    integer, intent(in), dimension(2) :: b
    type(gyrosurface_ptr_type) :: gs_ptr
    integer, intent(in), dimension(2) :: gs
    real(8), dimension(2,4), intent(inout) :: gyrange
    integer, intent(out) :: nrange
    b_ptr = transfer(b, b_ptr)
    gs_ptr = transfer(gs, gs_ptr)
    call gyro_range(b=b_ptr%p, gs=gs_ptr%p, gyrange=gyrange, nrange=nrange)
end subroutine f90wrap_gyro_range

subroutine f90wrap_npa_gyro_range(ichan, gs, gyrange, nrange)
    use libfida, only: gyrosurface, npa_gyro_range
    implicit none
    
    type gyrosurface_ptr_type
        type(gyrosurface), pointer :: p => NULL()
    end type gyrosurface_ptr_type
    integer, intent(in) :: ichan
    type(gyrosurface_ptr_type) :: gs_ptr
    integer, intent(in), dimension(2) :: gs
    real(8), dimension(2,4), intent(inout) :: gyrange
    integer, intent(out) :: nrange
    gs_ptr = transfer(gs, gs_ptr)
    call npa_gyro_range(ichan=ichan, gs=gs_ptr%p, gyrange=gyrange, nrange=nrange)
end subroutine f90wrap_npa_gyro_range

subroutine f90wrap_hit_npa_detector(r0, v0, d_index, rd, det)
    use libfida, only: hit_npa_detector
    implicit none
    
    real(8), dimension(3), intent(in) :: r0
    real(8), dimension(3), intent(in) :: v0
    integer, intent(out) :: d_index
    real(8), dimension(3), optional, intent(inout) :: rd
    integer, intent(in), optional :: det
    call hit_npa_detector(r0=r0, v0=v0, d_index=d_index, rd=rd, det=det)
end subroutine f90wrap_hit_npa_detector

subroutine f90wrap_xyz_to_uvw(xyz, uvw)
    use libfida, only: xyz_to_uvw
    implicit none
    
    real(8), dimension(3), intent(in) :: xyz
    real(8), dimension(3), intent(inout) :: uvw
    call xyz_to_uvw(xyz=xyz, uvw=uvw)
end subroutine f90wrap_xyz_to_uvw

subroutine f90wrap_uvw_to_xyz(uvw, xyz)
    use libfida, only: uvw_to_xyz
    implicit none
    
    real(8), dimension(3), intent(in) :: uvw
    real(8), dimension(3), intent(inout) :: xyz
    call uvw_to_xyz(uvw=uvw, xyz=xyz)
end subroutine f90wrap_uvw_to_xyz

subroutine f90wrap_grid_intersect(r0, v0, length, r_enter, r_exit, center_in, &
    lwh_in)
    use libfida, only: grid_intersect
    implicit none
    
    real(8), dimension(3), intent(in) :: r0
    real(8), dimension(3), intent(in) :: v0
    real(8), intent(out) :: length
    real(8), dimension(3), intent(inout) :: r_enter
    real(8), dimension(3), intent(inout) :: r_exit
    real(8), dimension(3), intent(in), optional :: center_in
    real(8), dimension(3), intent(in), optional :: lwh_in
    call grid_intersect(r0=r0, v0=v0, length=length, r_enter=r_enter, r_exit=r_exit, &
        center_in=center_in, lwh_in=lwh_in)
end subroutine f90wrap_grid_intersect

subroutine f90wrap_in_grid(ret_ing, xyz)
    use libfida, only: in_grid
    implicit none
    
    logical, intent(out) :: ret_ing
    real(8), dimension(3), intent(in) :: xyz
    ret_ing = in_grid(xyz=xyz)
end subroutine f90wrap_in_grid

subroutine f90wrap_circle_grid_intersect(r0, e1, e2, radius, phi_enter, &
    phi_exit)
    use libfida, only: circle_grid_intersect
    implicit none
    
    real(8), dimension(3), intent(in) :: r0
    real(8), dimension(3), intent(in) :: e1
    real(8), dimension(3), intent(in) :: e2
    real(8), intent(in) :: radius
    real(8), intent(out) :: phi_enter
    real(8), intent(out) :: phi_exit
    call circle_grid_intersect(r0=r0, e1=e1, e2=e2, radius=radius, &
        phi_enter=phi_enter, phi_exit=phi_exit)
end subroutine f90wrap_circle_grid_intersect

subroutine f90wrap_get_indices(pos, ind)
    use libfida, only: get_indices
    implicit none
    
    real(8), dimension(3), intent(in) :: pos
    integer(4), dimension(3), intent(inout) :: ind
    call get_indices(pos=pos, ind=ind)
end subroutine f90wrap_get_indices

subroutine f90wrap_get_position(ind, pos)
    use libfida, only: get_position
    implicit none
    
    integer(4), dimension(3), intent(in) :: ind
    real(8), dimension(3), intent(inout) :: pos
    call get_position(ind=ind, pos=pos)
end subroutine f90wrap_get_position

subroutine f90wrap_in_plasma(xyz, inp, machine_coords, coeffs, uvw_out)
    use libfida, only: interpolcoeffs2d, in_plasma
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    real(8), dimension(3), intent(in) :: xyz
    logical, intent(out) :: inp
    logical, intent(in), optional :: machine_coords
    type(interpolcoeffs2d_ptr_type) :: coeffs_ptr
    integer, optional, intent(out), dimension(2) :: coeffs
    real(8), dimension(3), optional, intent(inout) :: uvw_out
    allocate(coeffs_ptr%p)
    call in_plasma(xyz=xyz, inp=inp, machine_coords=machine_coords, &
        coeffs=coeffs_ptr%p, uvw_out=uvw_out)
    coeffs = transfer(coeffs_ptr, coeffs)
end subroutine f90wrap_in_plasma

subroutine f90wrap_get_plasma(plasma, pos, ind)
    use libfida, only: localprofiles, get_plasma
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: plasma_ptr
    integer, intent(out), dimension(2) :: plasma
    real(8), dimension(3), intent(in), optional :: pos
    integer(4), dimension(3), intent(in), optional :: ind
    allocate(plasma_ptr%p)
    call get_plasma(plasma=plasma_ptr%p, pos=pos, ind=ind)
    plasma = transfer(plasma_ptr, plasma)
end subroutine f90wrap_get_plasma

subroutine f90wrap_calc_perp_vectors(b, a, c)
    use libfida, only: calc_perp_vectors
    implicit none
    
    real(8), dimension(3), intent(in) :: b
    real(8), dimension(3), intent(inout) :: a
    real(8), dimension(3), intent(inout) :: c
    call calc_perp_vectors(b=b, a=a, c=c)
end subroutine f90wrap_calc_perp_vectors

subroutine f90wrap_get_fields(fields, pos, ind, machine_coords)
    use libfida, only: get_fields, localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(out), dimension(2) :: fields
    real(8), dimension(3), intent(in), optional :: pos
    integer(4), dimension(3), intent(in), optional :: ind
    logical, intent(in), optional :: machine_coords
    allocate(fields_ptr%p)
    call get_fields(fields=fields_ptr%p, pos=pos, ind=ind, &
        machine_coords=machine_coords)
    fields = transfer(fields_ptr, fields)
end subroutine f90wrap_get_fields

subroutine f90wrap_get_distribution(fbeam, denf, pos, ind, coeffs, n0, n1)
    use libfida, only: interpolcoeffs2d, get_distribution
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    real(8), intent(inout), dimension(n0,n1) :: fbeam
    real(8), intent(out) :: denf
    real(8), dimension(3), intent(in), optional :: pos
    integer(4), dimension(3), intent(in), optional :: ind
    type(interpolcoeffs2d_ptr_type) :: coeffs_ptr
    integer, optional, intent(in), dimension(2) :: coeffs
    integer :: n0
    !f2py intent(hide), depend(fbeam) :: n0 = shape(fbeam,0)
    integer :: n1
    !f2py intent(hide), depend(fbeam) :: n1 = shape(fbeam,1)
    if (present(coeffs)) then
        coeffs_ptr = transfer(coeffs, coeffs_ptr)
    else
        coeffs_ptr%p => null()
    end if
    call get_distribution(fbeam=fbeam, denf=denf, pos=pos, ind=ind, &
        coeffs=coeffs_ptr%p)
end subroutine f90wrap_get_distribution

subroutine f90wrap_get_ep_denf(energy, pitch, denf, pos, ind, coeffs)
    use libfida, only: interpolcoeffs2d, get_ep_denf
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    real(8), intent(in) :: energy
    real(8), intent(in) :: pitch
    real(8), intent(out) :: denf
    real(8), dimension(3), intent(in), optional :: pos
    integer(4), dimension(3), intent(in), optional :: ind
    type(interpolcoeffs2d_ptr_type) :: coeffs_ptr
    integer, optional, intent(in), dimension(2) :: coeffs
    if (present(coeffs)) then
        coeffs_ptr = transfer(coeffs, coeffs_ptr)
    else
        coeffs_ptr%p => null()
    end if
    call get_ep_denf(energy=energy, pitch=pitch, denf=denf, pos=pos, ind=ind, &
        coeffs=coeffs_ptr%p)
end subroutine f90wrap_get_ep_denf

subroutine f90wrap_store_neutrals(ind, neut_type, dens, vn, store_iter, n0)
    use libfida, only: store_neutrals
    implicit none
    
    integer(4), dimension(3), intent(in) :: ind
    integer, intent(in) :: neut_type
    real(8), intent(in), dimension(n0) :: dens
    real(8), dimension(3), intent(in) :: vn
    logical, intent(in), optional :: store_iter
    integer :: n0
    !f2py intent(hide), depend(dens) :: n0 = shape(dens,0)
    call store_neutrals(ind=ind, neut_type=neut_type, dens=dens, vn=vn, &
        store_iter=store_iter)
end subroutine f90wrap_store_neutrals

subroutine f90wrap_store_births(ind, neut_type, dflux)
    use libfida, only: store_births
    implicit none
    
    integer(4), dimension(3), intent(in) :: ind
    integer(4), intent(in) :: neut_type
    real(8), intent(in) :: dflux
    call store_births(ind=ind, neut_type=neut_type, dflux=dflux)
end subroutine f90wrap_store_births

subroutine f90wrap_store_npa(det, ri, rf, vn, flux, orbit_class)
    use libfida, only: store_npa
    implicit none
    
    integer, intent(in) :: det
    real(8), dimension(3), intent(in) :: ri
    real(8), dimension(3), intent(in) :: rf
    real(8), dimension(3), intent(in) :: vn
    real(8), intent(in) :: flux
    integer, intent(in), optional :: orbit_class
    call store_npa(det=det, ri=ri, rf=rf, vn=vn, flux=flux, orbit_class=orbit_class)
end subroutine f90wrap_store_npa

subroutine f90wrap_bb_cx_rates(denn, vi, vn, rates, n0, n1)
    use libfida, only: bb_cx_rates
    implicit none
    
    real(8), intent(in), dimension(n0) :: denn
    real(8), dimension(3), intent(in) :: vi
    real(8), dimension(3), intent(in) :: vn
    real(8), intent(inout), dimension(n1) :: rates
    integer :: n0
    !f2py intent(hide), depend(denn) :: n0 = shape(denn,0)
    integer :: n1
    !f2py intent(hide), depend(rates) :: n1 = shape(rates,0)
    call bb_cx_rates(denn=denn, vi=vi, vn=vn, rates=rates)
end subroutine f90wrap_bb_cx_rates

subroutine f90wrap_bt_cx_rates(plasma, denn, vi, i_type, rates, n0, n1)
    use libfida, only: localprofiles, bt_cx_rates
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: plasma_ptr
    integer, intent(in), dimension(2) :: plasma
    real(8), intent(in), dimension(n0) :: denn
    real(8), dimension(3), intent(in) :: vi
    integer, intent(in) :: i_type
    real(8), intent(inout), dimension(n1) :: rates
    integer :: n0
    !f2py intent(hide), depend(denn) :: n0 = shape(denn,0)
    integer :: n1
    !f2py intent(hide), depend(rates) :: n1 = shape(rates,0)
    plasma_ptr = transfer(plasma, plasma_ptr)
    call bt_cx_rates(plasma=plasma_ptr%p, denn=denn, vi=vi, i_type=i_type, &
        rates=rates)
end subroutine f90wrap_bt_cx_rates

subroutine f90wrap_get_neutron_rate(plasma, eb, rate)
    use libfida, only: get_neutron_rate, localprofiles
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: plasma_ptr
    integer, intent(in), dimension(2) :: plasma
    real(8), intent(in) :: eb
    real(8), intent(out) :: rate
    plasma_ptr = transfer(plasma, plasma_ptr)
    call get_neutron_rate(plasma=plasma_ptr%p, eb=eb, rate=rate)
end subroutine f90wrap_get_neutron_rate

subroutine f90wrap_get_beam_cx_rate(ind, pos, v_ion, i_type, types, prob, n0, &
    n1)
    use libfida, only: get_beam_cx_rate
    implicit none
    
    integer(4), dimension(3), intent(in) :: ind
    real(8), dimension(3), intent(in) :: pos
    real(8), dimension(3), intent(in) :: v_ion
    integer, intent(in) :: i_type
    integer(4), intent(in), dimension(n0) :: types
    real(8), intent(inout), dimension(n1) :: prob
    integer :: n0
    !f2py intent(hide), depend(types) :: n0 = shape(types,0)
    integer :: n1
    !f2py intent(hide), depend(prob) :: n1 = shape(prob,0)
    call get_beam_cx_rate(ind=ind, pos=pos, v_ion=v_ion, i_type=i_type, types=types, &
        prob=prob)
end subroutine f90wrap_get_beam_cx_rate

subroutine f90wrap_get_rate_matrix(plasma, i_type, eb, rmat, n0, n1)
    use libfida, only: get_rate_matrix, localprofiles
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: plasma_ptr
    integer, intent(in), dimension(2) :: plasma
    integer, intent(in) :: i_type
    real(8), intent(in) :: eb
    real(8), intent(inout), dimension(n0,n1) :: rmat
    integer :: n0
    !f2py intent(hide), depend(rmat) :: n0 = shape(rmat,0)
    integer :: n1
    !f2py intent(hide), depend(rmat) :: n1 = shape(rmat,1)
    plasma_ptr = transfer(plasma, plasma_ptr)
    call get_rate_matrix(plasma=plasma_ptr%p, i_type=i_type, eb=eb, rmat=rmat)
end subroutine f90wrap_get_rate_matrix

subroutine f90wrap_colrad(plasma, i_type, vn, dt, states, dens, photons, n0, n1, &
    n2)
    use libfida, only: colrad, localprofiles
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: plasma_ptr
    integer, intent(in), dimension(2) :: plasma
    integer, intent(in) :: i_type
    real(8), intent(in), dimension(n0) :: vn
    real(8), intent(in) :: dt
    real(8), intent(inout), dimension(n1) :: states
    real(8), intent(inout), dimension(n2) :: dens
    real(8), intent(out) :: photons
    integer :: n0
    !f2py intent(hide), depend(vn) :: n0 = shape(vn,0)
    integer :: n1
    !f2py intent(hide), depend(states) :: n1 = shape(states,0)
    integer :: n2
    !f2py intent(hide), depend(dens) :: n2 = shape(dens,0)
    plasma_ptr = transfer(plasma, plasma_ptr)
    call colrad(plasma=plasma_ptr%p, i_type=i_type, vn=vn, dt=dt, states=states, &
        dens=dens, photons=photons)
end subroutine f90wrap_colrad

subroutine f90wrap_attenuate(ri, rf, vi, states, dstep_in, n0)
    use libfida, only: attenuate
    implicit none
    
    real(8), dimension(3), intent(in) :: ri
    real(8), dimension(3), intent(in) :: rf
    real(8), dimension(3), intent(in) :: vi
    real(8), intent(inout), dimension(n0) :: states
    real(8), intent(in), optional :: dstep_in
    integer :: n0
    !f2py intent(hide), depend(states) :: n0 = shape(states,0)
    call attenuate(ri=ri, rf=rf, vi=vi, states=states, dstep_in=dstep_in)
end subroutine f90wrap_attenuate

subroutine f90wrap_spectrum(vecp, vi, fields, sigma_pi, photons, dlength, &
    lambda_, intensity, n0, n1)
    use libfida, only: spectrum, localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    real(8), dimension(3), intent(in) :: vecp
    real(8), dimension(3), intent(in) :: vi
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(in), dimension(2) :: fields
    real(8), intent(in) :: sigma_pi
    real(8), intent(in) :: photons
    real(8), intent(in) :: dlength
    real(8), intent(inout), dimension(n0) :: lambda_
    real(8), intent(inout), dimension(n1) :: intensity
    integer :: n0
    !f2py intent(hide), depend(lambda_) :: n0 = shape(lambda_,0)
    integer :: n1
    !f2py intent(hide), depend(intensity) :: n1 = shape(intensity,0)
    fields_ptr = transfer(fields, fields_ptr)
    call spectrum(vecp=vecp, vi=vi, fields=fields_ptr%p, sigma_pi=sigma_pi, &
        photons=photons, dlength=dlength, lambda=lambda_, intensity=intensity)
end subroutine f90wrap_spectrum

subroutine f90wrap_store_bes_photons(pos, vi, photons, neut_type)
    use libfida, only: store_bes_photons
    implicit none
    
    real(8), dimension(3), intent(in) :: pos
    real(8), dimension(3), intent(in) :: vi
    real(8), intent(in) :: photons
    integer, intent(in) :: neut_type
    call store_bes_photons(pos=pos, vi=vi, photons=photons, neut_type=neut_type)
end subroutine f90wrap_store_bes_photons

subroutine f90wrap_store_fida_photons(pos, vi, photons, orbit_class)
    use libfida, only: store_fida_photons
    implicit none
    
    real(8), dimension(3), intent(in) :: pos
    real(8), dimension(3), intent(in) :: vi
    real(8), intent(in) :: photons
    integer, intent(in), optional :: orbit_class
    call store_fida_photons(pos=pos, vi=vi, photons=photons, &
        orbit_class=orbit_class)
end subroutine f90wrap_store_fida_photons

subroutine f90wrap_store_neutrons(rate, orbit_class)
    use libfida, only: store_neutrons
    implicit none
    
    real(8), intent(in) :: rate
    integer, intent(in), optional :: orbit_class
    call store_neutrons(rate=rate, orbit_class=orbit_class)
end subroutine f90wrap_store_neutrons

subroutine f90wrap_store_fw_photons_at_chan(ichan, eind, pind, vp, vi, fields, &
    dlength, sigma_pi, denf, photons)
    use libfida, only: store_fw_photons_at_chan, localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, intent(in) :: ichan
    integer, intent(in) :: eind
    integer, intent(in) :: pind
    real(8), dimension(3), intent(in) :: vp
    real(8), dimension(3), intent(in) :: vi
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(in), dimension(2) :: fields
    real(8), intent(in) :: dlength
    real(8), intent(in) :: sigma_pi
    real(8), intent(in) :: denf
    real(8), intent(in) :: photons
    fields_ptr = transfer(fields, fields_ptr)
    call store_fw_photons_at_chan(ichan=ichan, eind=eind, pind=pind, vp=vp, vi=vi, &
        fields=fields_ptr%p, dlength=dlength, sigma_pi=sigma_pi, denf=denf, &
        photons=photons)
end subroutine f90wrap_store_fw_photons_at_chan

subroutine f90wrap_store_fw_photons(eind, pind, pos, vi, denf, photons)
    use libfida, only: store_fw_photons
    implicit none
    
    integer, intent(in) :: eind
    integer, intent(in) :: pind
    real(8), dimension(3), intent(in) :: pos
    real(8), dimension(3), intent(in) :: vi
    real(8), intent(in) :: denf
    real(8), intent(in) :: photons
    call store_fw_photons(eind=eind, pind=pind, pos=pos, vi=vi, denf=denf, &
        photons=photons)
end subroutine f90wrap_store_fw_photons

subroutine f90wrap_get_nlaunch(nr_markers, papprox, papprox_tot, nlaunch, n0, &
    n1, n2, n3, n4, n5)
    use libfida, only: get_nlaunch
    implicit none
    
    integer(8), intent(in) :: nr_markers
    real(8), intent(in), dimension(n0,n1,n2) :: papprox
    real(8), intent(in) :: papprox_tot
    real(8), intent(inout), dimension(n3,n4,n5) :: nlaunch
    integer :: n0
    !f2py intent(hide), depend(papprox) :: n0 = shape(papprox,0)
    integer :: n1
    !f2py intent(hide), depend(papprox) :: n1 = shape(papprox,1)
    integer :: n2
    !f2py intent(hide), depend(papprox) :: n2 = shape(papprox,2)
    integer :: n3
    !f2py intent(hide), depend(nlaunch) :: n3 = shape(nlaunch,0)
    integer :: n4
    !f2py intent(hide), depend(nlaunch) :: n4 = shape(nlaunch,1)
    integer :: n5
    !f2py intent(hide), depend(nlaunch) :: n5 = shape(nlaunch,2)
    call get_nlaunch(nr_markers=nr_markers, papprox=papprox, &
        papprox_tot=papprox_tot, nlaunch=nlaunch)
end subroutine f90wrap_get_nlaunch

subroutine f90wrap_pitch_to_vec(pitch, gyroangle, fields, vi_norm)
    use libfida, only: pitch_to_vec, localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    real(8), intent(in) :: pitch
    real(8), intent(in) :: gyroangle
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(in), dimension(2) :: fields
    real(8), dimension(3), intent(inout) :: vi_norm
    fields_ptr = transfer(fields, fields_ptr)
    call pitch_to_vec(pitch=pitch, gyroangle=gyroangle, fields=fields_ptr%p, &
        vi_norm=vi_norm)
end subroutine f90wrap_pitch_to_vec

subroutine f90wrap_gyro_step(vi, fields, r_gyro)
    use libfida, only: gyro_step, localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    real(8), dimension(3), intent(in) :: vi
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(in), dimension(2) :: fields
    real(8), dimension(3), intent(inout) :: r_gyro
    fields_ptr = transfer(fields, fields_ptr)
    call gyro_step(vi=vi, fields=fields_ptr%p, r_gyro=r_gyro)
end subroutine f90wrap_gyro_step

subroutine f90wrap_gyro_correction(fields, energy, pitch, rp, vp, phi_in)
    use libfida, only: localemfields, gyro_correction
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(in), dimension(2) :: fields
    real(8), intent(in) :: energy
    real(8), intent(in) :: pitch
    real(8), dimension(3), intent(inout) :: rp
    real(8), dimension(3), intent(inout) :: vp
    real(8), intent(in), optional :: phi_in
    fields_ptr = transfer(fields, fields_ptr)
    call gyro_correction(fields=fields_ptr%p, energy=energy, pitch=pitch, rp=rp, &
        vp=vp, phi_in=phi_in)
end subroutine f90wrap_gyro_correction

subroutine f90wrap_gyro_radius(fields, energy, ret_gyro_rad, pitch)
    use libfida, only: localemfields, gyro_radius
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(in), dimension(2) :: fields
    real(8), intent(in) :: energy
    real(8), intent(out) :: ret_gyro_rad
    real(8), intent(in) :: pitch
    fields_ptr = transfer(fields, fields_ptr)
    ret_gyro_rad = gyro_radius(fields=fields_ptr%p, energy=energy, pitch=pitch)
end subroutine f90wrap_gyro_radius

subroutine f90wrap_mc_fastion(ind, fields, eb, ptch, denf)
    use libfida, only: mc_fastion, localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    integer, dimension(3), intent(in) :: ind
    type(localemfields_ptr_type) :: fields_ptr
    integer, intent(out), dimension(2) :: fields
    real(8), intent(out) :: eb
    real(8), intent(out) :: ptch
    real(8), intent(out) :: denf
    allocate(fields_ptr%p)
    call mc_fastion(ind=ind, fields=fields_ptr%p, eb=eb, ptch=ptch, denf=denf)
    fields = transfer(fields_ptr, fields)
end subroutine f90wrap_mc_fastion

subroutine f90wrap_mc_halo(ind, vhalo, ri, plasma_in)
    use libfida, only: localprofiles, mc_halo
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    integer, dimension(3), intent(in) :: ind
    real(8), dimension(3), intent(inout) :: vhalo
    real(8), dimension(3), optional, intent(inout) :: ri
    type(localprofiles_ptr_type) :: plasma_in_ptr
    integer, optional, intent(in), dimension(2) :: plasma_in
    if (present(plasma_in)) then
        plasma_in_ptr = transfer(plasma_in, plasma_in_ptr)
    else
        plasma_in_ptr%p => null()
    end if
    call mc_halo(ind=ind, vhalo=vhalo, ri=ri, plasma_in=plasma_in_ptr%p)
end subroutine f90wrap_mc_halo

subroutine f90wrap_mc_nbi(vnbi, efrac, rnbi, err)
    use libfida, only: mc_nbi
    implicit none
    
    real(8), dimension(3), intent(inout) :: vnbi
    integer, intent(in) :: efrac
    real(8), dimension(3), intent(inout) :: rnbi
    logical, intent(out) :: err
    call mc_nbi(vnbi=vnbi, efrac=efrac, rnbi=rnbi, err=err)
end subroutine f90wrap_mc_nbi

subroutine f90wrap_ndmc
    use libfida, only: ndmc
    implicit none
    
    call ndmc()
end subroutine f90wrap_ndmc

subroutine f90wrap_bremsstrahlung
    use libfida, only: bremsstrahlung
    implicit none
    
    call bremsstrahlung()
end subroutine f90wrap_bremsstrahlung

subroutine f90wrap_dcx
    use libfida, only: dcx
    implicit none
    
    call dcx()
end subroutine f90wrap_dcx

subroutine f90wrap_halo
    use libfida, only: halo
    implicit none
    
    call halo()
end subroutine f90wrap_halo

subroutine f90wrap_fida_f
    use libfida, only: fida_f
    implicit none
    
    call fida_f()
end subroutine f90wrap_fida_f

subroutine f90wrap_fida_mc
    use libfida, only: fida_mc
    implicit none
    
    call fida_mc()
end subroutine f90wrap_fida_mc

subroutine f90wrap_npa_f
    use libfida, only: npa_f
    implicit none
    
    call npa_f()
end subroutine f90wrap_npa_f

subroutine f90wrap_npa_mc
    use libfida, only: npa_mc
    implicit none
    
    call npa_mc()
end subroutine f90wrap_npa_mc

subroutine f90wrap_neutron_f
    use libfida, only: neutron_f
    implicit none
    
    call neutron_f()
end subroutine f90wrap_neutron_f

subroutine f90wrap_neutron_mc
    use libfida, only: neutron_mc
    implicit none
    
    call neutron_mc()
end subroutine f90wrap_neutron_mc

subroutine f90wrap_fida_weights_mc
    use libfida, only: fida_weights_mc
    implicit none
    
    call fida_weights_mc()
end subroutine f90wrap_fida_weights_mc

subroutine f90wrap_fida_weights_los
    use libfida, only: fida_weights_los
    implicit none
    
    call fida_weights_los()
end subroutine f90wrap_fida_weights_los

subroutine f90wrap_npa_weights
    use libfida, only: npa_weights
    implicit none
    
    call npa_weights()
end subroutine f90wrap_npa_weights

subroutine f90wrap_pp_assign(p1, p2)
    use libfida, only: profiles, assignment(=)
    implicit none
    
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    type(profiles_ptr_type) :: p1_ptr
    integer, intent(in), dimension(2) :: p1
    type(profiles_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p1_ptr = transfer(p1, p1_ptr)
    p2_ptr = transfer(p2, p2_ptr)
    p1=p1_ptr%p = p2=p2_ptr%p
end subroutine f90wrap_pp_assign

subroutine f90wrap_lpp_assign(p1, p2)
    use libfida, only: profiles, localprofiles, assignment(=)
    implicit none
    
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: p1_ptr
    integer, intent(in), dimension(2) :: p1
    type(profiles_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p1_ptr = transfer(p1, p1_ptr)
    p2_ptr = transfer(p2, p2_ptr)
    p1=p1_ptr%p = p2=p2_ptr%p
end subroutine f90wrap_lpp_assign

subroutine f90wrap_plp_assign(p1, p2)
    use libfida, only: profiles, assignment(=), localprofiles
    implicit none
    
    type profiles_ptr_type
        type(profiles), pointer :: p => NULL()
    end type profiles_ptr_type
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(profiles_ptr_type) :: p1_ptr
    integer, intent(in), dimension(2) :: p1
    type(localprofiles_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p1_ptr = transfer(p1, p1_ptr)
    p2_ptr = transfer(p2, p2_ptr)
    p1=p1_ptr%p = p2=p2_ptr%p
end subroutine f90wrap_plp_assign

subroutine f90wrap_lplp_assign(p1, p2)
    use libfida, only: localprofiles, assignment(=)
    implicit none
    
    type localprofiles_ptr_type
        type(localprofiles), pointer :: p => NULL()
    end type localprofiles_ptr_type
    type(localprofiles_ptr_type) :: p1_ptr
    integer, intent(in), dimension(2) :: p1
    type(localprofiles_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p1_ptr = transfer(p1, p1_ptr)
    p2_ptr = transfer(p2, p2_ptr)
    p1=p1_ptr%p = p2=p2_ptr%p
end subroutine f90wrap_lplp_assign

subroutine f90wrap_ff_assign(p1, p2)
    use libfida, only: assignment(=), emfields
    implicit none
    
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    type(emfields_ptr_type) :: p1_ptr
    integer, intent(in), dimension(2) :: p1
    type(emfields_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p1_ptr = transfer(p1, p1_ptr)
    p2_ptr = transfer(p2, p2_ptr)
    p1=p1_ptr%p = p2=p2_ptr%p
end subroutine f90wrap_ff_assign

subroutine f90wrap_lff_assign(p1, p2)
    use libfida, only: assignment(=), emfields, localemfields
    implicit none
    
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(localemfields_ptr_type) :: p1_ptr
    integer, intent(in), dimension(2) :: p1
    type(emfields_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p1_ptr = transfer(p1, p1_ptr)
    p2_ptr = transfer(p2, p2_ptr)
    p1=p1_ptr%p = p2=p2_ptr%p
end subroutine f90wrap_lff_assign

subroutine f90wrap_flf_assign(p1, p2)
    use libfida, only: assignment(=), emfields, localemfields
    implicit none
    
    type emfields_ptr_type
        type(emfields), pointer :: p => NULL()
    end type emfields_ptr_type
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(emfields_ptr_type) :: p1_ptr
    integer, intent(in), dimension(2) :: p1
    type(localemfields_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p1_ptr = transfer(p1, p1_ptr)
    p2_ptr = transfer(p2, p2_ptr)
    p1=p1_ptr%p = p2=p2_ptr%p
end subroutine f90wrap_flf_assign

subroutine f90wrap_lflf_assign(p1, p2)
    use libfida, only: assignment(=), localemfields
    implicit none
    
    type localemfields_ptr_type
        type(localemfields), pointer :: p => NULL()
    end type localemfields_ptr_type
    type(localemfields_ptr_type) :: p1_ptr
    integer, intent(in), dimension(2) :: p1
    type(localemfields_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p1_ptr = transfer(p1, p1_ptr)
    p2_ptr = transfer(p2, p2_ptr)
    p1=p1_ptr%p = p2=p2_ptr%p
end subroutine f90wrap_lflf_assign

subroutine f90wrap_fast_ion_assign(p1, p2)
    use libfida, only: assignment(=), fastion
    implicit none
    
    type fastion_ptr_type
        type(fastion), pointer :: p => NULL()
    end type fastion_ptr_type
    type(fastion_ptr_type) :: p1_ptr
    integer, intent(out), dimension(2) :: p1
    type(fastion_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p2_ptr = transfer(p2, p2_ptr)
    allocate(p1_ptr%p)
    p1=p1_ptr%p = p2=p2_ptr%p
    p1 = transfer(p1_ptr, p1)
end subroutine f90wrap_fast_ion_assign

subroutine f90wrap_npa_part_assign(p1, p2)
    use libfida, only: npaparticle, assignment(=)
    implicit none
    
    type npaparticle_ptr_type
        type(npaparticle), pointer :: p => NULL()
    end type npaparticle_ptr_type
    type(npaparticle_ptr_type) :: p1_ptr
    integer, intent(out), dimension(2) :: p1
    type(npaparticle_ptr_type) :: p2_ptr
    integer, intent(in), dimension(2) :: p2
    p2_ptr = transfer(p2, p2_ptr)
    allocate(p1_ptr%p)
    p1=p1_ptr%p = p2=p2_ptr%p
    p1 = transfer(p1_ptr, p1)
end subroutine f90wrap_npa_part_assign

subroutine f90wrap_interpol1d_coeff(xmin, dx, nx, xout, c, err)
    use libfida, only: interpolcoeffs1d, interpol_coeff
    implicit none
    
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    real(8), intent(in) :: xmin
    real(8), intent(in) :: dx
    integer, intent(in) :: nx
    real(8), intent(in) :: xout
    type(interpolcoeffs1d_ptr_type) :: c_ptr
    integer, intent(out), dimension(2) :: c
    integer, intent(out), optional :: err
    allocate(c_ptr%p)
    call interpol_coeff(xmin=xmin, dx=dx, nx=nx, xout=xout, c=c_ptr%p, err=err)
    c = transfer(c_ptr, c)
end subroutine f90wrap_interpol1d_coeff

subroutine f90wrap_interpol1d_coeff_arr(x, xout, c, err, n0)
    use libfida, only: interpolcoeffs1d, interpol_coeff
    implicit none
    
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    real(8), intent(in), dimension(n0) :: x
    real(8), intent(in) :: xout
    type(interpolcoeffs1d_ptr_type) :: c_ptr
    integer, intent(out), dimension(2) :: c
    integer, intent(out), optional :: err
    integer :: n0
    !f2py intent(hide), depend(x) :: n0 = shape(x,0)
    allocate(c_ptr%p)
    call interpol_coeff(x=x, xout=xout, c=c_ptr%p, err=err)
    c = transfer(c_ptr, c)
end subroutine f90wrap_interpol1d_coeff_arr

subroutine f90wrap_interpol2d_coeff(xmin, dx, nx, ymin, dy, ny, xout, yout, c, &
    err)
    use libfida, only: interpolcoeffs2d, interpol_coeff
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    real(8), intent(in) :: xmin
    real(8), intent(in) :: dx
    integer, intent(in) :: nx
    real(8), intent(in) :: ymin
    real(8), intent(in) :: dy
    integer, intent(in) :: ny
    real(8), intent(in) :: xout
    real(8), intent(in) :: yout
    type(interpolcoeffs2d_ptr_type) :: c_ptr
    integer, intent(out), dimension(2) :: c
    integer, intent(out), optional :: err
    allocate(c_ptr%p)
    call interpol_coeff(xmin=xmin, dx=dx, nx=nx, ymin=ymin, dy=dy, ny=ny, xout=xout, &
        yout=yout, c=c_ptr%p, err=err)
    c = transfer(c_ptr, c)
end subroutine f90wrap_interpol2d_coeff

subroutine f90wrap_interpol2d_coeff_arr(x, y, xout, yout, c, err, n0, n1)
    use libfida, only: interpolcoeffs2d, interpol_coeff
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    real(8), intent(in), dimension(n0) :: x
    real(8), intent(in), dimension(n1) :: y
    real(8), intent(in) :: xout
    real(8), intent(in) :: yout
    type(interpolcoeffs2d_ptr_type) :: c_ptr
    integer, intent(out), dimension(2) :: c
    integer, intent(out), optional :: err
    integer :: n0
    !f2py intent(hide), depend(x) :: n0 = shape(x,0)
    integer :: n1
    !f2py intent(hide), depend(y) :: n1 = shape(y,0)
    allocate(c_ptr%p)
    call interpol_coeff(x=x, y=y, xout=xout, yout=yout, c=c_ptr%p, err=err)
    c = transfer(c_ptr, c)
end subroutine f90wrap_interpol2d_coeff_arr

subroutine f90wrap_interpol1d_arr(x, y, xout, yout, err, coeffs, n0, n1)
    use libfida, only: interpolcoeffs1d, interpol
    implicit none
    
    type interpolcoeffs1d_ptr_type
        type(interpolcoeffs1d), pointer :: p => NULL()
    end type interpolcoeffs1d_ptr_type
    real(8), intent(in), dimension(n0) :: x
    real(8), intent(in), dimension(n1) :: y
    real(8), intent(in) :: xout
    real(8), intent(out) :: yout
    integer, intent(out), optional :: err
    type(interpolcoeffs1d_ptr_type) :: coeffs_ptr
    integer, optional, intent(in), dimension(2) :: coeffs
    integer :: n0
    !f2py intent(hide), depend(x) :: n0 = shape(x,0)
    integer :: n1
    !f2py intent(hide), depend(y) :: n1 = shape(y,0)
    if (present(coeffs)) then
        coeffs_ptr = transfer(coeffs, coeffs_ptr)
    else
        coeffs_ptr%p => null()
    end if
    call interpol(x=x, y=y, xout=xout, yout=yout, err=err, coeffs=coeffs_ptr%p)
end subroutine f90wrap_interpol1d_arr

subroutine f90wrap_interpol2d_arr(x, y, z, xout, yout, zout, err, coeffs, n0, &
    n1, n2, n3)
    use libfida, only: interpolcoeffs2d, interpol
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    real(8), intent(in), dimension(n0) :: x
    real(8), intent(in), dimension(n1) :: y
    real(8), intent(in), dimension(n2,n3) :: z
    real(8), intent(in) :: xout
    real(8), intent(in) :: yout
    real(8), intent(out) :: zout
    integer, intent(out), optional :: err
    type(interpolcoeffs2d_ptr_type) :: coeffs_ptr
    integer, optional, intent(in), dimension(2) :: coeffs
    integer :: n0
    !f2py intent(hide), depend(x) :: n0 = shape(x,0)
    integer :: n1
    !f2py intent(hide), depend(y) :: n1 = shape(y,0)
    integer :: n2
    !f2py intent(hide), depend(z) :: n2 = shape(z,0)
    integer :: n3
    !f2py intent(hide), depend(z) :: n3 = shape(z,1)
    if (present(coeffs)) then
        coeffs_ptr = transfer(coeffs, coeffs_ptr)
    else
        coeffs_ptr%p => null()
    end if
    call interpol(x=x, y=y, z=z, xout=xout, yout=yout, zout=zout, err=err, &
        coeffs=coeffs_ptr%p)
end subroutine f90wrap_interpol2d_arr

subroutine f90wrap_interpol2d_2d_arr(x, y, z, xout, yout, zout, err, coeffs, n0, &
    n1, n2, n3, n4, n5, n6, n7)
    use libfida, only: interpolcoeffs2d, interpol
    implicit none
    
    type interpolcoeffs2d_ptr_type
        type(interpolcoeffs2d), pointer :: p => NULL()
    end type interpolcoeffs2d_ptr_type
    real(8), intent(in), dimension(n0) :: x
    real(8), intent(in), dimension(n1) :: y
    real(8), intent(in), dimension(n2,n3,n4,n5) :: z
    real(8), intent(in) :: xout
    real(8), intent(in) :: yout
    real(8), intent(inout), dimension(n6,n7) :: zout
    integer, intent(out), optional :: err
    type(interpolcoeffs2d_ptr_type) :: coeffs_ptr
    integer, optional, intent(in), dimension(2) :: coeffs
    integer :: n0
    !f2py intent(hide), depend(x) :: n0 = shape(x,0)
    integer :: n1
    !f2py intent(hide), depend(y) :: n1 = shape(y,0)
    integer :: n2
    !f2py intent(hide), depend(z) :: n2 = shape(z,0)
    integer :: n3
    !f2py intent(hide), depend(z) :: n3 = shape(z,1)
    integer :: n4
    !f2py intent(hide), depend(z) :: n4 = shape(z,2)
    integer :: n5
    !f2py intent(hide), depend(z) :: n5 = shape(z,3)
    integer :: n6
    !f2py intent(hide), depend(zout) :: n6 = shape(zout,0)
    integer :: n7
    !f2py intent(hide), depend(zout) :: n7 = shape(zout,1)
    if (present(coeffs)) then
        coeffs_ptr = transfer(coeffs, coeffs_ptr)
    else
        coeffs_ptr%p => null()
    end if
    call interpol(x=x, y=y, z=z, xout=xout, yout=yout, zout=zout, err=err, &
        coeffs=coeffs_ptr%p)
end subroutine f90wrap_interpol2d_2d_arr

subroutine f90wrap_libfida__get__version(f90wrap_version)
    use libfida, only: libfida_version => version
    implicit none
    character(30), intent(out) :: f90wrap_version
    
    f90wrap_version = libfida_version
end subroutine f90wrap_libfida__get__version

subroutine f90wrap_libfida__set__version(f90wrap_version)
    use libfida, only: libfida_version => version
    implicit none
    character(30), intent(in) :: f90wrap_version
    
    libfida_version = f90wrap_version
end subroutine f90wrap_libfida__set__version

subroutine f90wrap_libfida__get__charlim(f90wrap_charlim)
    use libfida, only: libfida_charlim => charlim
    implicit none
    integer, intent(out) :: f90wrap_charlim
    
    f90wrap_charlim = libfida_charlim
end subroutine f90wrap_libfida__get__charlim

subroutine f90wrap_libfida__get__namelist_file(f90wrap_namelist_file)
    use libfida, only: libfida_namelist_file => namelist_file
    implicit none
    character(1024), intent(out) :: f90wrap_namelist_file
    
    f90wrap_namelist_file = libfida_namelist_file
end subroutine f90wrap_libfida__get__namelist_file

subroutine f90wrap_libfida__set__namelist_file(f90wrap_namelist_file)
    use libfida, only: libfida_namelist_file => namelist_file
    implicit none
    character(1024), intent(in) :: f90wrap_namelist_file
    
    libfida_namelist_file = f90wrap_namelist_file
end subroutine f90wrap_libfida__set__namelist_file

subroutine f90wrap_libfida__get__nbif_type(f90wrap_nbif_type)
    use libfida, only: libfida_nbif_type => nbif_type
    implicit none
    integer, intent(out) :: f90wrap_nbif_type
    
    f90wrap_nbif_type = libfida_nbif_type
end subroutine f90wrap_libfida__get__nbif_type

subroutine f90wrap_libfida__get__nbih_type(f90wrap_nbih_type)
    use libfida, only: libfida_nbih_type => nbih_type
    implicit none
    integer, intent(out) :: f90wrap_nbih_type
    
    f90wrap_nbih_type = libfida_nbih_type
end subroutine f90wrap_libfida__get__nbih_type

subroutine f90wrap_libfida__get__nbit_type(f90wrap_nbit_type)
    use libfida, only: libfida_nbit_type => nbit_type
    implicit none
    integer, intent(out) :: f90wrap_nbit_type
    
    f90wrap_nbit_type = libfida_nbit_type
end subroutine f90wrap_libfida__get__nbit_type

subroutine f90wrap_libfida__get__halo_type(f90wrap_halo_type)
    use libfida, only: libfida_halo_type => halo_type
    implicit none
    integer, intent(out) :: f90wrap_halo_type
    
    f90wrap_halo_type = libfida_halo_type
end subroutine f90wrap_libfida__get__halo_type

subroutine f90wrap_libfida__get__fida_type(f90wrap_fida_type)
    use libfida, only: libfida_fida_type => fida_type
    implicit none
    integer, intent(out) :: f90wrap_fida_type
    
    f90wrap_fida_type = libfida_fida_type
end subroutine f90wrap_libfida__get__fida_type

subroutine f90wrap_libfida__get__brems_type(f90wrap_brems_type)
    use libfida, only: libfida_brems_type => brems_type
    implicit none
    integer, intent(out) :: f90wrap_brems_type
    
    f90wrap_brems_type = libfida_brems_type
end subroutine f90wrap_libfida__get__brems_type

subroutine f90wrap_libfida__get__ntypes(f90wrap_ntypes)
    use libfida, only: libfida_ntypes => ntypes
    implicit none
    integer, intent(out) :: f90wrap_ntypes
    
    f90wrap_ntypes = libfida_ntypes
end subroutine f90wrap_libfida__get__ntypes

subroutine f90wrap_libfida__get__beam_ion(f90wrap_beam_ion)
    use libfida, only: libfida_beam_ion => beam_ion
    implicit none
    integer, intent(out) :: f90wrap_beam_ion
    
    f90wrap_beam_ion = libfida_beam_ion
end subroutine f90wrap_libfida__get__beam_ion

subroutine f90wrap_libfida__get__thermal_ion(f90wrap_thermal_ion)
    use libfida, only: libfida_thermal_ion => thermal_ion
    implicit none
    integer, intent(out) :: f90wrap_thermal_ion
    
    f90wrap_thermal_ion = libfida_thermal_ion
end subroutine f90wrap_libfida__get__thermal_ion

subroutine f90wrap_libfida__get__e_amu(f90wrap_e_amu)
    use libfida, only: libfida_e_amu => e_amu
    implicit none
    real(8), intent(out) :: f90wrap_e_amu
    
    f90wrap_e_amu = libfida_e_amu
end subroutine f90wrap_libfida__get__e_amu

subroutine f90wrap_libfida__get__h_1_amu(f90wrap_h_1_amu)
    use libfida, only: libfida_h_1_amu => h_1_amu
    implicit none
    real(8), intent(out) :: f90wrap_h_1_amu
    
    f90wrap_h_1_amu = libfida_h_1_amu
end subroutine f90wrap_libfida__get__h_1_amu

subroutine f90wrap_libfida__get__h_2_amu(f90wrap_h_2_amu)
    use libfida, only: libfida_h_2_amu => h_2_amu
    implicit none
    real(8), intent(out) :: f90wrap_h_2_amu
    
    f90wrap_h_2_amu = libfida_h_2_amu
end subroutine f90wrap_libfida__get__h_2_amu

subroutine f90wrap_libfida__get__b5_amu(f90wrap_b5_amu)
    use libfida, only: libfida_b5_amu => b5_amu
    implicit none
    real(8), intent(out) :: f90wrap_b5_amu
    
    f90wrap_b5_amu = libfida_b5_amu
end subroutine f90wrap_libfida__get__b5_amu

subroutine f90wrap_libfida__get__c6_amu(f90wrap_c6_amu)
    use libfida, only: libfida_c6_amu => c6_amu
    implicit none
    real(8), intent(out) :: f90wrap_c6_amu
    
    f90wrap_c6_amu = libfida_c6_amu
end subroutine f90wrap_libfida__get__c6_amu

subroutine f90wrap_libfida__get__mass_u(f90wrap_mass_u)
    use libfida, only: libfida_mass_u => mass_u
    implicit none
    real(8), intent(out) :: f90wrap_mass_u
    
    f90wrap_mass_u = libfida_mass_u
end subroutine f90wrap_libfida__get__mass_u

subroutine f90wrap_libfida__get__e0(f90wrap_e0)
    use libfida, only: libfida_e0 => e0
    implicit none
    real(8), intent(out) :: f90wrap_e0
    
    f90wrap_e0 = libfida_e0
end subroutine f90wrap_libfida__get__e0

subroutine f90wrap_libfida__get__pi(f90wrap_pi)
    use libfida, only: libfida_pi => pi
    implicit none
    real(8), intent(out) :: f90wrap_pi
    
    f90wrap_pi = libfida_pi
end subroutine f90wrap_libfida__get__pi

subroutine f90wrap_libfida__get__c0(f90wrap_c0)
    use libfida, only: libfida_c0 => c0
    implicit none
    real(8), intent(out) :: f90wrap_c0
    
    f90wrap_c0 = libfida_c0
end subroutine f90wrap_libfida__get__c0

subroutine f90wrap_libfida__get__h_planck(f90wrap_h_planck)
    use libfida, only: libfida_h_planck => h_planck
    implicit none
    real(8), intent(out) :: f90wrap_h_planck
    
    f90wrap_h_planck = libfida_h_planck
end subroutine f90wrap_libfida__get__h_planck

subroutine f90wrap_libfida__get__lambda0(f90wrap_lambda0)
    use libfida, only: libfida_lambda0 => lambda0
    implicit none
    real(8), intent(out) :: f90wrap_lambda0
    
    f90wrap_lambda0 = libfida_lambda0
end subroutine f90wrap_libfida__get__lambda0

subroutine f90wrap_libfida__get__v2_to_e_per_amu(f90wrap_v2_to_e_per_amu)
    use libfida, only: libfida_v2_to_e_per_amu => v2_to_e_per_amu
    implicit none
    real(8), intent(out) :: f90wrap_v2_to_e_per_amu
    
    f90wrap_v2_to_e_per_amu = libfida_v2_to_e_per_amu
end subroutine f90wrap_libfida__get__v2_to_e_per_amu

subroutine f90wrap_libfida__get__n_stark(f90wrap_n_stark)
    use libfida, only: libfida_n_stark => n_stark
    implicit none
    integer, intent(out) :: f90wrap_n_stark
    
    f90wrap_n_stark = libfida_n_stark
end subroutine f90wrap_libfida__get__n_stark

subroutine f90wrap_libfida__get__nlevs(f90wrap_nlevs)
    use libfida, only: libfida_nlevs => nlevs
    implicit none
    integer, intent(out) :: f90wrap_nlevs
    
    f90wrap_nlevs = libfida_nlevs
end subroutine f90wrap_libfida__get__nlevs

subroutine f90wrap_libfida__get__colrad_threshold(f90wrap_colrad_threshold)
    use libfida, only: libfida_colrad_threshold => colrad_threshold
    implicit none
    real(8), intent(out) :: f90wrap_colrad_threshold
    
    f90wrap_colrad_threshold = libfida_colrad_threshold
end subroutine f90wrap_libfida__get__colrad_threshold

subroutine f90wrap_libfida__set__colrad_threshold(f90wrap_colrad_threshold)
    use libfida, only: libfida_colrad_threshold => colrad_threshold
    implicit none
    real(8), intent(in) :: f90wrap_colrad_threshold
    
    libfida_colrad_threshold = f90wrap_colrad_threshold
end subroutine f90wrap_libfida__set__colrad_threshold

subroutine f90wrap_libfida__array__halo_iter_dens(dummy_this, nd, dtype, dshape, &
    dloc)
    use hdf5_extra
    use utilities
    use hdf5
    use eigensystem
    use libfida, only: libfida_halo_iter_dens => halo_iter_dens
    use h5lt
    implicit none
    integer, intent(in) :: dummy_this(2)
    integer, intent(out) :: nd
    integer, intent(out) :: dtype
    integer, dimension(10), intent(out) :: dshape
    integer*8, intent(out) :: dloc
    
    nd = 1
    dtype = 12
    dshape(1:1) = shape(libfida_halo_iter_dens)
    dloc = loc(libfida_halo_iter_dens)
end subroutine f90wrap_libfida__array__halo_iter_dens

subroutine f90wrap_libfida__get__nbi_outside(f90wrap_nbi_outside)
    use libfida, only: libfida_nbi_outside => nbi_outside
    implicit none
    integer, intent(out) :: f90wrap_nbi_outside
    
    f90wrap_nbi_outside = libfida_nbi_outside
end subroutine f90wrap_libfida__get__nbi_outside

subroutine f90wrap_libfida__set__nbi_outside(f90wrap_nbi_outside)
    use libfida, only: libfida_nbi_outside => nbi_outside
    implicit none
    integer, intent(in) :: f90wrap_nbi_outside
    
    libfida_nbi_outside = f90wrap_nbi_outside
end subroutine f90wrap_libfida__set__nbi_outside

! End of module libfida defined in file fidasim.f90