scale_interp_vert.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
#include "scalelib.h"
module scale_interp_vert
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
  use scale_io
  use scale_prof
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public procedure
  !
  public :: interp_vert_setcoef
  public :: interp_vert_xi2z
  public :: interp_vert_xih2zh
  public :: interp_vert_z2xi
  public :: interp_vert_zh2xih
 
  public :: interp_vert_alloc_pres
  public :: interp_vert_dealloc_pres
  public :: interp_vert_setcoef_pres
  public :: interp_vert_xi2p
  public :: interp_vert_xih2p
  public :: interp_vert_finalize
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  logical, public :: interp_available = .false. 
 
  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  ! full level
  integer,  private, allocatable :: interp_xi2z_idx   (:,:,:,:)
  real(rp), private, allocatable :: interp_xi2z_coef  (:,  :,:)
  integer,  private, allocatable :: interp_z2xi_idx   (:,:,:,:)
  real(rp), private, allocatable :: interp_z2xi_coef  (:,  :,:)
 
  integer,  private, allocatable :: interp_xi2p_idx   (:,:,:,:)
  real(rp), private, allocatable :: interp_xi2p_coef  (:,  :,:)
 
  ! half level
  integer,  private, allocatable :: interp_xih2zh_idx (:,:,:,:)
  real(rp), private, allocatable :: interp_xih2zh_coef(:,  :,:)
  integer,  private, allocatable :: interp_zh2xih_idx (:,:,:,:)
  real(rp), private, allocatable :: interp_zh2xih_coef(:,  :,:)
 
  integer,  private, allocatable :: interp_xih2p_idx  (:,:,:,:)
  real(rp), private, allocatable :: interp_xih2p_coef (:,  :,:)
 
  ! log pressure
  real(rp), private, allocatable :: lnpres (:,:,:)
  real(rp), private, allocatable :: lnpresh(:,:,:)
  real(rp), private, allocatable :: lnpaxis(:)
 
 
  !-----------------------------------------------------------------------------
contains
  !-----------------------------------------------------------------------------
  subroutine interp_vert_setcoef( &
       KA, KS, KE, &
       IA, IS, IE, &
       JA, JS, JE, &
       TOPO_exist, &
       Xi, Xih,    &
       Z,  Zh      )
    use scale_interp, only: &
       interp_factor1d
    implicit none
    integer,  intent(in)  :: ka, ks, ke
    integer,  intent(in)  :: ia, is, ie
    integer,  intent(in)  :: ja, js, je
    logical,  intent(in)  :: topo_exist
    real(rp), intent(in)  :: xi (  ka)
    real(rp), intent(in)  :: xih(0:ka)
    real(rp), intent(in)  :: z  (  ka,ia,ja)
    real(rp), intent(in)  :: zh (0:ka,ia,ja)
 
    integer :: i, j
    !---------------------------------------------------------------------------
 
    log_newline
    log_info("INTERP_VERT_setcoef",*) 'Setup'
    log_info("INTERP_VERT_setcoef",*) 'No namelists.'
 
    interp_available = topo_exist
 
    log_newline
    log_info("INTERP_VERT_setcoef",*) 'Topography exists & interpolation has meaning? : ', interp_available
 
    ! full level
 
    allocate( interp_xi2z_idx(ka,2,ia,ja) )
    allocate( interp_xi2z_coef(ka,  ia,ja) )
    allocate( interp_z2xi_idx(ka,2,ia,ja) )
    allocate( interp_z2xi_coef(ka,  ia,ja) )
    !$acc enter data create(INTERP_xi2z_idx, INTERP_xi2z_coef, INTERP_z2xi_idx, INTERP_z2xi_coef)
 
    !$acc data copyin(Z, Xi)
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(JA,IA,KA,KS,KE,Xi,Z,INTERP_xi2z_idx,INTERP_xi2z_coef)
    !$acc kernels
    !$acc loop independent
    do j = 1, ja
    !$acc loop independent
    do i = 1, ia
       call interp_factor1d( ka, ks, ke, ka, ks, ke, &
                             z(:,i,j), xi(:),           & ! (in)
                             interp_xi2z_idx(:,:,i,j), & ! (out)
                             interp_xi2z_coef(:,  i,j), & ! (out)
                             flag_extrap = .true.       ) ! (in)
    enddo
    enddo
    !$acc end kernels
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(JA,IA,KA,KS,KE,Z,Xi,INTERP_z2xi_idx,INTERP_z2xi_coef)
    !$acc kernels
    !$acc loop independent
    do j = 1, ja
    !$acc loop independent
    do i = 1, ia
       call interp_factor1d( ka, ks, ke, ka, ks, ke, &
                             xi(:), z(:,i,j),           & ! (in)
                             interp_z2xi_idx(:,:,i,j), & ! (out)
                             interp_z2xi_coef(:,  i,j), & ! (out)
                             flag_extrap = .true.       ) ! (in)
    enddo
    enddo
    !$acc end kernels
 
    !$acc end data
 
    ! half level
 
    allocate( interp_xih2zh_idx(ka,2,ia,ja) )
    allocate( interp_xih2zh_coef(ka,  ia,ja) )
    allocate( interp_zh2xih_idx(ka,2,ia,ja) )
    allocate( interp_zh2xih_coef(ka,  ia,ja) )
    !$acc enter data create(INTERP_xih2zh_idx, INTERP_xih2zh_coef, INTERP_zh2xih_idx, INTERP_zh2xih_coef)
 
    !$acc data copyin(Zh, Xih)
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(JA,IA,KA,KS,KE,Xih,Zh,INTERP_xih2zh_idx,INTERP_xih2zh_coef)
    !$acc kernels
    !$acc loop independent
    do j = 1, ja
    !$acc loop independent
    do i = 1, ia
       call interp_factor1d( ka, ks-1, ke, ka, ks-1, ke, &
                             zh(1:,i,j), xih(1:),         & ! (in)
                             interp_xih2zh_idx(:,:,i,j), & ! (out)
                             interp_xih2zh_coef(:,  i,j), & ! (out)
                             flag_extrap = .false.        ) ! (in)
    enddo
    enddo
    !$acc end kernels
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(JA,IA,KA,KS,KE,Xih,Zh,INTERP_zh2xih_idx,INTERP_zh2xih_coef)
    !$acc kernels
    !$acc loop independent
    do j = 1, ja
    !$acc loop independent
    do i = 1, ia
       call interp_factor1d( ka, ks-1, ke, ka, ks-1, ke, &
                             xih(1:), zh(1:,i,j),         & ! (in)
                             interp_zh2xih_idx(:,:,i,j), & ! (out)
                             interp_zh2xih_coef(:,  i,j), & ! (out)
                             flag_extrap = .true.         ) ! (in)
    enddo
    enddo
    !$acc end kernels
 
    !$acc end data
 
    return
  end subroutine interp_vert_setcoef
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_xi2z( &
       KA, KS, KE, &
       IA, IS, IE, &
       JA, JS, JE, &
       Xi,         &
       Z,          &
       var,        &
       var_Z       )
    use scale_interp, only: &
       interp_interp1d
    implicit none
    integer,  intent(in)  :: ka, ks, ke
    integer,  intent(in)  :: ia, is, ie
    integer,  intent(in)  :: ja, js, je
    real(rp), intent(in)  :: xi   (ka)
    real(rp), intent(in)  :: z    (ka,ia,ja)
    real(rp), intent(in)  :: var  (ka,ia,ja)
    real(rp), intent(out) :: var_z(ka,ia,ja)
 
#ifdef _OPENACC
    real(rp) :: workr(ka,7)
    integer  :: worki(ka,2)
#endif
 
    integer  :: i, j
    !---------------------------------------------------------------------------
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(KA,KS,KE,IS,IE,JS,JE) &
    !$omp shared(Xi,Z,var,var_Z) &
    !$omp shared(INTERP_xi2z_idx,INTERP_xi2z_coef)
    !$acc kernels copyin(Xi, Z, var) copyout(var_Z)
    !$acc loop independent
    do j = js, je
    !$acc loop independent private(workr,worki)
    do i = is, ie
       call interp_interp1d( ka, ks, ke, ka, ks, ke, &
#ifdef _OPENACC
                             workr(:,:), worki(:,:), &
#endif
                             interp_xi2z_idx(:,:,i,j), & ! (in)
                             interp_xi2z_coef(:,  i,j), & ! (in)
                             z(:,i,j), xi(:),           & ! (in)
                             var(:,i,j),                & ! (in)
                             var_z(:,i,j)               ) ! (out)
    end do
    end do
    !$acc end kernels
 
    return
  end subroutine interp_vert_xi2z
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_z2xi( &
       KA, KS, KE, &
       IA, IS, IE, &
       JA, JS, JE, &
       Z,          &
       Xi,         &
       var,        &
       var_Xi      )
    use scale_interp, only: &
       interp_interp1d
    implicit none
    integer,  intent(in)  :: ka, ks, ke
    integer,  intent(in)  :: ia, is, ie
    integer,  intent(in)  :: ja, js, je
    real(rp), intent(in)  :: z     (ka,ia,ja)
    real(rp), intent(in)  :: xi    (ka)
    real(rp), intent(in)  :: var   (ka,ia,ja)
    real(rp), intent(out) :: var_xi(ka,ia,ja)
 
#ifdef _OPENACC
    real(rp) :: workr(ka,7)
    integer  :: worki(ka,2)
#endif
 
    integer :: i, j
    !---------------------------------------------------------------------------
 
    call prof_rapstart('INTERP_interp',3)
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(KA,KS,KE,IS,IE,JS,JE) &
    !$omp shared(Z,Xi,var,var_Xi) &
    !$omp shared(INTERP_z2xi_idx,INTERP_z2xi_coef)
    !$acc kernels copyin(Z, Xi, var) copyout(var_Xi)
    !$acc loop independent
    do j = js, je
    !$acc loop independent private(workr,worki)
    do i = is, ie
       call interp_interp1d( ka, ks, ke, ka, ks, ke, &
#ifdef _OPENACC
                             workr(:,:), worki(:,:), &
#endif
                             interp_z2xi_idx(:,:,i,j), & ! (in)
                             interp_z2xi_coef(:,  i,j), & ! (in)
                             xi(:), z(:,i,j),           & ! (in)
                             var(:,i,j),                & ! (in)
                             var_xi(:,i,j)              ) ! (out)
    end do
    end do
    !$acc end kernels
 
    call prof_rapend  ('INTERP_interp',3)
 
    return
  end subroutine interp_vert_z2xi
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_xih2zh( &
       KA, KS, KE, &
       IA, IS, IE, &
       JA, JS, JE, &
       Xih,        &
       Zh,         &
       var,        &
       var_Z       )
    use scale_interp, only: &
       interp_interp1d
    implicit none
    integer,  intent(in)  :: ka, ks, ke
    integer,  intent(in)  :: ia, is, ie
    integer,  intent(in)  :: ja, js, je
    real(rp), intent(in)  :: xih  (0:ka)
    real(rp), intent(in)  :: zh   (0:ka,ia,ja)
    real(rp), intent(in)  :: var  (ka,ia,ja)
    real(rp), intent(out) :: var_z(ka,ia,ja)
 
    real(rp) :: zht(ka)
    real(rp) :: xiht(ka)
#ifdef _OPENACC
    real(rp) :: workr(ka,7)
    integer  :: worki(ka,2)
#endif
 
    integer  :: i, j, k
    !---------------------------------------------------------------------------
 
    !$acc data copyin(Zh, var) copyout(var_Z) create(Xiht)
 
    !$kernels
    do k = ks-1, ke
       xiht(k) = xih(k)
    end do
    !$end kernels
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(KA,KS,KE,IS,IE,JS,JE) &
    !$omp shared(Xih,Xiht,Zh,var,var_Z) &
    !$omp shared(INTERP_xih2zh_idx,INTERP_xih2zh_coef) &
    !$omp private(Zht)
    !$acc kernels
    !$acc loop independent
    do j = js, je
    !$acc loop independent private(workr,worki,Zht)
    do i = is, ie
       do k = ks-1, ke
          zht(k) = zh(k,i,j)
       end do
       call interp_interp1d( ka, ks-1, ke, ka, ks-1, ke, &
#ifdef _OPENACC
                             workr(:,:), worki(:,:), &
#endif
                             interp_xih2zh_idx(:,:,i,j), & ! (in)
                             interp_xih2zh_coef(:,  i,j), & ! (in)
                             zht(:), xiht(:),             & ! (in)
                             var(:,i,j),                  & ! (in)
                             var_z(:,i,j)                 ) ! (out)
    enddo
    enddo
    !$acc end kernels
 
    !$acc end data
 
    return
  end subroutine interp_vert_xih2zh
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_zh2xih( &
       KA, KS, KE, &
       IA, IS, IE, &
       JA, JS, JE, &
       Zh,         &
       Xih,        &
       var,        &
       var_Xi      )
    use scale_interp, only: &
       interp_interp1d
    implicit none
    integer,  intent(in)  :: ka, ks, ke
    integer,  intent(in)  :: ia, is, ie
    integer,  intent(in)  :: ja, js, je
    real(rp), intent(in)  :: zh   (0:ka,ia,ja)
    real(rp), intent(in)  :: xih  (0:ka)
    real(rp), intent(in)  :: var   (ka,ia,ja)
    real(rp), intent(out) :: var_xi(ka,ia,ja)
 
    real(rp) :: zht(ka)
    real(rp) :: xiht(ka)
#ifdef _OPENACC
    real(rp) :: workr(ka,7)
    integer  :: worki(ka,2)
#endif
 
    integer  :: k, i, j
    !---------------------------------------------------------------------------
 
    !$acc data copyin(Zh, Xih, var) copyout(var_Xi) create(Xih)
 
    !$kernels
    do k = ks-1, ke
       xiht(k) = xih(k)
    end do
    !$end kernels
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(KA,KS,KE,IS,IE,JS,JE) &
    !$omp shared(Zh,Xih,Xiht,var,var_Xi) &
    !$omp shared(INTERP_zh2xih_idx,INTERP_zh2xih_coef) &
    !$omp private(Zht)
    !$acc kernels
    !$acc loop independent
    do j = js, je
    !$acc loop independent private(workr,worki,Zht)
    do i = is, ie
       do k = ks-1, ke
          zht(k) = zh(k,i,j)
       end do
       call interp_interp1d( ka, ks-1, ke, ka, ks-1, ke, &
#ifdef _OPENACC
                             workr(:,:), worki(:,:), &
#endif
                             interp_zh2xih_idx(:,:,i,j), & ! (in)
                             interp_zh2xih_coef(:,  i,j), & ! (in)
                             xiht(:), zht(:),             & ! (in)
                             var(:,i,j),                  & ! (in)
                             var_xi(:,i,j)                ) ! (out)
    enddo
    enddo
    !$acc end kernels
 
    !$acc end data
 
    return
  end subroutine interp_vert_zh2xih
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_alloc_pres( &
       Kpres, KA, IA, JA )
    implicit none
    integer,  intent(in) :: kpres
    integer,  intent(in) :: ka
    integer,  intent(in) :: ia
    integer,  intent(in) :: ja
    !---------------------------------------------------------------------------
 
    allocate( interp_xi2p_idx(kpres,2,ia,ja) )
    allocate( interp_xi2p_coef(kpres,  ia,ja) )
    allocate( interp_xih2p_idx(kpres,2,ia,ja) )
    allocate( interp_xih2p_coef(kpres,  ia,ja) )
    !$acc enter data create(INTERP_xi2p_idx, INTERP_xi2p_coef, INTERP_xih2p_idx, INTERP_xih2p_coef)
 
    allocate( lnpres(ka,ia,ja) )
    allocate( lnpresh(ka,ia,ja) )
    allocate( lnpaxis(kpres)    )
    !$acc enter data create(LnPRES, LnPRESh, LnPaxis)
 
    return
  end subroutine interp_vert_alloc_pres
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_dealloc_pres
    implicit none
    !---------------------------------------------------------------------------
 
    !$acc exit data delete(INTERP_xi2p_idx, INTERP_xi2p_coef, INTERP_xih2p_idx, INTERP_xih2p_coef)
    deallocate( interp_xi2p_idx   )
    deallocate( interp_xi2p_coef  )
    deallocate( interp_xih2p_idx  )
    deallocate( interp_xih2p_coef )
 
    !$acc exit data delete(LnPRES, LnPRESh, LnPaxis)
    deallocate( lnpres  )
    deallocate( lnpresh )
    deallocate( lnpaxis )
 
    return
  end subroutine interp_vert_dealloc_pres
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_setcoef_pres( &
       Kpres,      &
       KA, KS, KE, &
       IA, IS, IE, &
       JA, JS, JE, &
       PRES,       &
       PRESh,      &
       SFC_PRES,   &
       Paxis       )
    use scale_interp, only: &
       interp_factor1d
    implicit none
 
    integer,  intent(in)  :: kpres
    integer,  intent(in)  :: ka, ks, ke
    integer,  intent(in)  :: ia, is, ie
    integer,  intent(in)  :: ja, js, je
    real(rp), intent(in)  :: pres    (  ka,ia,ja) ! pressure in Xi coordinate [Pa]
    real(rp), intent(in)  :: presh   (0:ka,ia,ja) ! pressure in Xi coordinate [Pa], layer interface
    real(rp), intent(in)  :: sfc_pres(     ia,ja) ! surface pressure          [Pa]
    real(rp), intent(in)  :: paxis   (kpres)      ! pressure level to output  [Pa]
 
    integer :: k, i, j
    !---------------------------------------------------------------------------
 
    !$acc data copyin(PRES, PRESh, SFC_PRES, Paxis)
 
    ! full level
 
!OCL SERIAL
    !$acc kernels
    do k = 1, kpres
       lnpaxis(k) = - log( paxis(k) )
    end do
    !$acc end kernels
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(KA,KS,KE,Kpres,IS,IE,JS,JE) &
    !$omp shared(PRES,LnPRES,LnPaxis) &
    !$omp shared(INTERP_xi2p_idx,INTERP_xi2p_coef)
    !$acc kernels
    !$acc loop independent
    do j = js, je
    !$acc loop independent
    do i = is, ie
       do k = ks, ke
          lnpres(k,i,j) = - log( pres(k,i,j) )
       end do
       call interp_factor1d( ka, ks, ke, kpres, 1, kpres, &
                             lnpres(:,i,j), lnpaxis(:), & ! (in)
                             interp_xi2p_idx(:,:,i,j), & ! (out)
                             interp_xi2p_coef(:,  i,j), & ! (out)
                             flag_extrap = .false.      ) ! (in)
    enddo
    enddo
    !$acc end kernels
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(KA,KS,KE,Kpres,IS,IE,JS,JE) &
    !$omp shared(PRESh,LnPRESh,LnPaxis) &
    !$omp shared(INTERP_xih2p_idx,INTERP_xih2p_coef)
    !$acc kernels
    !$acc loop independent
    do j = js, je
    !$acc loop independent
    do i = is, ie
       do k = ks-1, ke
          lnpresh(k,i,j) = - log( presh(k,i,j) )
       end do
       call interp_factor1d( ka, ks-1, ke, kpres, 1, kpres, &
                             lnpresh(:,i,j), lnpaxis(:), & ! (in)
                             interp_xih2p_idx(:,:,i,j), & ! (out)
                             interp_xih2p_coef(:,  i,j), & ! (out)
                             flag_extrap = .false.       ) ! (in)
    enddo
    enddo
    !$acc end kernels
 
    !$acc end data
 
    return
  end subroutine interp_vert_setcoef_pres
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_xi2p( &
       Kpres,      &
       KA, KS, KE, &
       IA, IS, IE, &
       JA, JS, JE, &
       var,        &
       var_P       )
    use scale_interp, only: &
       interp_interp1d
    implicit none
    integer,  intent(in)  :: kpres
    integer,  intent(in)  :: ka, ks, ke
    integer,  intent(in)  :: ia, is, ie
    integer,  intent(in)  :: ja, js, je
    real(rp), intent(in)  :: var  (ka   ,ia,ja)
    real(rp), intent(out) :: var_p(kpres,ia,ja)
 
#ifdef _OPENACC
    real(rp) :: workr(ka,7)
    integer  :: worki(ka,2)
#endif
 
    integer :: i, j
    !---------------------------------------------------------------------------
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(KA,KS,KE,Kpres,IS,IE,JS,JE) &
    !$omp shared(LnPRES,LnPaxis,var,var_P) &
    !$omp shared(INTERP_xi2p_idx,INTERP_xi2p_coef)
    !$acc kernels copyin(var) copyout(var_P)
    !$acc loop independent
    do j = js, je
    !$acc loop independent private(workr,worki)
    do i = is, ie
       call interp_interp1d( ka, ks, ke, kpres, 1, kpres, &
#ifdef _OPENACC
                             workr(:,:), worki(:,:), &
#endif
                             interp_xi2p_idx(:,:,i,j), & ! (in)
                             interp_xi2p_coef(:,  i,j), & ! (in)
                             lnpres(:,i,j), lnpaxis(:), & ! (in)
                             var(:,i,j),                & ! (in)
                             var_p(:,i,j)               ) ! (out)
    enddo
    enddo
    !$acc end kernels
 
    return
  end subroutine interp_vert_xi2p
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_xih2p( &
       Kpres,      &
       KA, KS, KE, &
       IA, IS, IE, &
       JA, JS, JE, &
       var,        &
       var_P       )
    use scale_interp, only: &
       interp_interp1d
    implicit none
 
    integer,  intent(in)  :: kpres
    integer,  intent(in)  :: ka, ks, ke
    integer,  intent(in)  :: ia, is, ie
    integer,  intent(in)  :: ja, js, je
    real(rp), intent(in)  :: var  (ka   ,ia,ja)
    real(rp), intent(out) :: var_p(kpres,ia,ja)
 
#ifdef _OPENACC
    real(rp) :: workr(ka,7)
    integer  :: worki(ka,2)
#endif
 
    integer :: k, i, j
    !---------------------------------------------------------------------------
 
    !$omp parallel do default(none) OMP_SCHEDULE_ collapse(2) &
    !$omp shared(KA,KS,KE,Kpres,IS,IE,JS,JE) &
    !$omp shared(LnPRESh,LnPaxis,var,var_P) &
    !$omp shared(INTERP_xih2p_idx,INTERP_xih2p_coef)
    !$acc kernels copyin(var) copyout(var_P)
    !$acc loop independent
    do j = js, je
    !$acc loop independent private(workr,worki)
    do i = is, ie
       call interp_interp1d( ka, ks-1, ke, kpres, 1, kpres, &
#ifdef _OPENACC
                             workr(:,:), worki(:,:), &
#endif
                             interp_xih2p_idx(:,:,i,j), & ! (in)
                             interp_xih2p_coef(:,  i,j), & ! (in)
                             lnpresh(:,i,j), lnpaxis(:), & ! (in)
                             var(:,i,j),                 & ! (in)
                             var_p(:,i,j)                ) ! (out)
    enddo
    enddo
    !$acc end kernels
 
    return
  end subroutine interp_vert_xih2p
 
  !-----------------------------------------------------------------------------
  subroutine interp_vert_finalize
    implicit none
    !---------------------------------------------------------------------------
 
    !$acc exit data delete(INTERP_xi2z_idx, INTERP_xi2z_coef, INTERP_z2xi_idx, INTERP_z2xi_coef)
    deallocate( interp_xi2z_idx  )
    deallocate( interp_xi2z_coef )
    deallocate( interp_z2xi_idx  )
    deallocate( interp_z2xi_coef )
 
    !$acc exit data delete(INTERP_xih2zh_idx, INTERP_xih2zh_coef, INTERP_zh2xih_idx, INTERP_zh2xih_coef)
    deallocate( interp_xih2zh_idx  )
    deallocate( interp_xih2zh_coef )
    deallocate( interp_zh2xih_idx  )
    deallocate( interp_zh2xih_coef )
 
    return
  end subroutine interp_vert_finalize
 
end module scale_interp_vert