scale_atm_dyn_dgm_driver_nonhydro3d.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!> module FElib / Fluid dyn solver / Atmosphere / driver (3D nonhydrostatic model)
!!
!! @par Description
!!      Driver module for 3D nonhydrostatic dynamical core based on DGM 
!!
!! @author Yuta Kawai, Team SCALE
!<
!-------------------------------------------------------------------------------
#include "scaleFElib.h"
module scale_atm_dyn_dgm_driver_nonhydro3d
  !-----------------------------------------------------------------------------
  !
  !++ Used modules
  !
  use scale_precision
  use scale_io
  use scale_prc
  use scale_prof
  use scale_const, only: &
    grav => const_grav,  &
    rdry => const_rdry,  &
    cpdry => const_cpdry, &
    cvdry => const_cvdry, &
    pres00 => const_pre00  
 
  use scale_timeint_rk, only: timeint_rk
  use scale_sparsemat, only: sparsemat
 
  use scale_mesh_base3d, only: meshbase3d
  use scale_localmesh_base, only: localmeshbase
  use scale_localmesh_2d, only: localmesh2d
  use scale_localmesh_3d, only: localmesh3d
  use scale_element_base, only: &
    elementbase, elementbase2d, elementbase3d
  use scale_element_hexahedral, only: hexahedralelement
  use scale_element_operation_base, only: elementoperationbase3d
  use scale_meshfield_base, only: &
    meshfieldbase, meshfield2d, meshfield3d
 
  use scale_element_modalfilter, only: &
    modalfilter
 
  use scale_model_mesh_manager, only: modelmesh3d
  use scale_model_var_manager, only: &
    modelvarmanager, variableinfo
 
  use scale_atm_dyn_dgm_driver_base, only: &
    atmdyndgmdriver_base3d, atmdyndgmdriver_base3d_init, atmdyndgmdriver_base3d_final
 
  use scale_atm_dyn_dgm_nonhydro3d_common, only: &
    prgvar_num, &
    dens_vid => prgvar_ddens_id, therm_vid => prgvar_therm_id,&
    momx_vid => prgvar_momx_id, momy_vid => prgvar_momy_id,   &
    momz_vid => prgvar_momz_id,                               &
    auxvar_num, &
    preshyd_vid => auxvar_preshydro_id, denshyd_vid => auxvar_denshydro_id,                 &
    thermhyd_vid => auxvar_thermhydro_id,                                                   &
    preshyd_ref_vid => auxvar_preshydro_ref_id,                                             &
    cptot_vid => auxvar_cptot_id, cvtot_vid => auxvar_cvtot_id, rtot_vid => auxvar_rtot_id, &
    pres_vid => auxvar_pres_id,                                                             &
    phytend_dens_id, phytend_momx_id, phytend_momy_id, phytend_momz_id, phytend_rhot_id,    &
    phytend_rhoh_id,                                                                        &
    atm_dyn_dgm_nonhydro3d_common_calc_pressure
 
  !- REGIONAL / RHOT / HEVE
  use scale_atm_dyn_dgm_nonhydro3d_rhot_heve, only: &
    atm_dyn_dgm_nonhydro3d_rhot_heve_init,          &
    atm_dyn_dgm_nonhydro3d_rhot_heve_final,         &
    atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend_asis, &
    atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend,      &
    atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend_cco
  use scale_atm_dyn_dgm_nonhydro3d_rhot_heve_gpu, only: &
    atm_dyn_dgm_nonhydro3d_rhot_heve_gpu_init,          &
    atm_dyn_dgm_nonhydro3d_rhot_heve_gpu_final,         &
    atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend_gpu,      &
    atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend_gpu2
  use scale_atm_dyn_dgm_nonhydro3d_rhot_heve_numflux, only: &
    atm_dyn_dgm_nonhydro3d_rhot_heve_add_bnd_contrib_generalvc
 
  !- REGIONAL / ETOT / HEVE
  use scale_atm_dyn_dgm_nonhydro3d_etot_heve, only: &
    atm_dyn_dgm_nonhydro3d_etot_heve_init,          &
    atm_dyn_dgm_nonhydro3d_etot_heve_final,         &
    atm_dyn_dgm_nonhydro3d_etot_heve_cal_tend
    
  !- REGIONAL / RHOT / HEVI
  use scale_atm_dyn_dgm_nonhydro3d_rhot_hevi, only: &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_init,          &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_final,         &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_cal_tend_asis, &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_cal_vi_asis,   &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_cal_tend,      &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_cal_vi
 
  !- REGIONAL / ETOT / HEVI
  use scale_atm_dyn_dgm_nonhydro3d_etot_hevi, only: &
    atm_dyn_dgm_nonhydro3d_etot_hevi_init,          &
    atm_dyn_dgm_nonhydro3d_etot_hevi_final,         &
    atm_dyn_dgm_nonhydro3d_etot_hevi_cal_tend,      &
    atm_dyn_dgm_nonhydro3d_etot_hevi_cal_vi
 
  !- REGIONAL / RHOT / HEVE SPLITFORM
  use scale_atm_dyn_dgm_nonhydro3d_rhot_heve_splitform, only: &
    atm_dyn_dgm_nonhydro3d_rhot_heve_splitform_init,          &
    atm_dyn_dgm_nonhydro3d_rhot_heve_splitform_final,         &
    atm_dyn_dgm_nonhydro3d_rhot_heve_splitform_cal_tend
 
  !- REGIONAL / RHOT / HEVI SPLITFORM
  use scale_atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform, only: &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform_init,          &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform_final,         &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform_cal_tend,      &
    atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform_cal_vi    
  
  !- GLOBAL / RHOT / HEVE
  use scale_atm_dyn_dgm_globalnonhydro3d_rhot_heve, only: &
    atm_dyn_dgm_globalnonhydro3d_rhot_heve_init,                      &
    atm_dyn_dgm_globalnonhydro3d_rhot_heve_final,                     &
    atm_dyn_dgm_globalnh3d_rhot_heve_cal_tend_shallow_atm_asis,       &
    atm_dyn_dgm_globalnonhydro3d_rhot_heve_cal_tend_shallow_atm,      &
    atm_dyn_dgm_globalnonhydro3d_rhot_heve_cal_tend_deep_atm
  use scale_atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu, only: &
    atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu_init,                 &
    atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu_cal_tend_shallow_atm, &
    atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu_cal_tend_deep_atm,    &
    atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu_final
  
  !- GLOBAL / ETOT / HEVE
  use scale_atm_dyn_dgm_globalnonhydro3d_etot_heve, only: &
    atm_dyn_dgm_globalnonhydro3d_etot_heve_init,          &
    atm_dyn_dgm_globalnonhydro3d_etot_heve_final,         &
    atm_dyn_dgm_globalnonhydro3d_etot_heve_cal_tend
 
  !- GLOBAL / RHOT / HEVI
  use scale_atm_dyn_dgm_globalnonhydro3d_rhot_hevi, only:  &
    atm_dyn_dgm_globalnonhydro3d_rhot_hevi_init,           &
    atm_dyn_dgm_globalnonhydro3d_rhot_hevi_final,          &
    atm_dyn_dgm_globalnonhydro3d_rhot_hevi_cal_tend_asis,  &
    atm_dyn_dgm_globalnonhydro3d_rhot_hevi_cal_vi_asis,    &
    atm_dyn_dgm_globalnonhydro3d_rhot_hevi_cal_tend,       &
    atm_dyn_dgm_globalnonhydro3d_rhot_hevi_cal_vi
  
  !- GLOBAL / ETOT / HEVI
  use scale_atm_dyn_dgm_globalnonhydro3d_etot_hevi, only:  &
    atm_dyn_dgm_globalnonhydro3d_etot_hevi_init,           &
    atm_dyn_dgm_globalnonhydro3d_etot_hevi_final,          &
    atm_dyn_dgm_globalnonhydro3d_etot_hevi_cal_tend,       &
    atm_dyn_dgm_globalnonhydro3d_etot_hevi_cal_vi
  
  !- NONE
  use scale_atm_dyn_dgm_none, only: &
    atm_dyn_dgm_none_init,          &
    atm_dyn_dgm_none_final,         &
    atm_dyn_dgm_none_cal_tend
  
  !---------
  use scale_atm_dyn_dgm_bnd, only: atmdynbnd
  use scale_atm_dyn_dgm_spongelayer, only: atmdynspongelayer
 
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public type & procedure
  !
 
  abstract interface    
    subroutine atm_dyn_nonhydro3d_cal_tend_ex( &
      DENS_dt, MOMX_dt, MOMY_dt, MOMZ_dt, RHOT_dt,           & ! (out)
      ddens_, momx_, momy_, momz_, therm_, dpres_,           & ! (in) 
      dens_hyd, pres_hyd, pres_hyd_ref, therm_hyd, coriolis, & ! (in)
      rtot, cvtot, cptot,                                    & ! (in)
      dphyddx, dphyddy,                                      & ! (in)
      element3d_operation, dx, dy, dz, sx, sy, sz, lift,     & ! (in)
      lmesh, elem, lmesh2d, elem2d ) ! (in)
 
      import rp
      import localmesh3d
      import elementbase3d
      import localmesh2d
      import elementbase2d
      import elementoperationbase3d
      import sparsemat
      implicit none
 
      class(LocalMesh3D), intent(in) :: lmesh
      class(ElementBase3D), intent(in) :: elem
      class(LocalMesh2D), intent(in) :: lmesh2D
      class(ElementBase2D), intent(in) :: elem2D
      class(ElementOperationBase3D), intent(in) :: element3D_operation
      type(SparseMat), intent(in) :: Dx, Dy, Dz, Sx, Sy, Sz, Lift
      real(RP), intent(out) :: DENS_dt(elem%Np,lmesh%NeA)
      real(RP), intent(out) :: MOMX_dt(elem%Np,lmesh%NeA)
      real(RP), intent(out) :: MOMY_dt(elem%Np,lmesh%NeA)
      real(RP), intent(out) :: MOMZ_dt(elem%Np,lmesh%NeA)
      real(RP), intent(out) :: RHOT_dt(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: DDENS_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMX_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMY_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMZ_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: THERM_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: DPRES_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: DENS_hyd(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: PRES_hyd(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: PRES_hyd_ref(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: THERM_hyd(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: CORIOLIS(elem2D%Np,lmesh2D%NeA)
      real(RP), intent(in)  :: Rtot(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: CVtot(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: CPtot(elem%Np,lmesh%NeA)
      real(RP), intent(in) :: DPhydDx(elem%Np,lmesh%NeA)
      real(RP), intent(in) :: DPhydDy(elem%Np,lmesh%NeA)
    end subroutine atm_dyn_nonhydro3d_cal_tend_ex
  end interface
 
  abstract interface    
    subroutine atm_dyn_nonhydro3d_cal_vi( &
      DENS_dt, MOMX_dt, MOMY_dt, MOMZ_dt, RHOT_dt,             & ! (out)
      ddens_, momx_, momy_, momz_, therm_, dens_hyd, pres_hyd, & ! (in)
      ddens0_, momx0_, momy0_, momz0_, therm0_,                & ! (in) 
      rtot, cvtot, cptot,                                      & ! (in)
      element3d_operation, dz, lift,                           & ! (in)
      impl_fac, dt,                                            & ! (in)
      lmesh, elem, lmesh2d, elem2d )
  
      import rp
      import localmesh3d
      import elementbase3d
      import localmesh2d
      import elementbase2d
      import modalfilter
      import elementoperationbase3d
      import sparsemat
      implicit none
  
      class(LocalMesh3D), intent(in) :: lmesh
      class(ElementBase3D), intent(in) :: elem
      class(LocalMesh2D), intent(in) :: lmesh2D
      class(ElementBase2D), intent(in) :: elem2D
      real(RP), intent(out) :: DENS_dt(elem%Np,lmesh%NeA)
      real(RP), intent(out) :: MOMX_dt(elem%Np,lmesh%NeA)
      real(RP), intent(out) :: MOMY_dt(elem%Np,lmesh%NeA)
      real(RP), intent(out) :: MOMZ_dt(elem%Np,lmesh%NeA)
      real(RP), intent(out) :: RHOT_dt(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: DDENS_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMX_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMY_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMZ_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: THERM_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: DENS_hyd(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: PRES_hyd(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: DDENS0_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMX0_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMY0_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: MOMZ0_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: THERM0_(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: Rtot(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: CVtot(elem%Np,lmesh%NeA)
      real(RP), intent(in)  :: CPtot(elem%Np,lmesh%NeA)
      class(ElementOperationBase3D), intent(in) :: element3D_operation
      class(SparseMat), intent(in) :: Dz, Lift
      real(RP), intent(in) :: impl_fac
      real(RP), intent(in) :: dt
    end subroutine atm_dyn_nonhydro3d_cal_vi
  end interface
 
  abstract interface    
    subroutine atm_dyn_nonhydro3d_final()
    end subroutine atm_dyn_nonhydro3d_final
  end interface 
 
  !> Derived type to provide a driver of dynamical core with the atmospheric nonhydrostatic equations
  type, extends(atmdyndgmdriver_base3d), public :: atmdyndgmdriver_nonhydro3d
    integer :: eqs_typeid                   !< Type ID of equation system
    logical :: entot_conserve_scheme_flag   !< Flag whether total energy is a prognostic variable
 
    ! element-wise modal filter
    logical :: modalfilter_flag             !< Flag wheter modal filtering is applied
    type(modalfilter) :: modal_filter_3d
    type(modalfilter) :: modal_filter_v1d
 
    type(modalfilter) :: modal_filterh1d
    type(modalfilter) :: modal_filterv1d
 
    ! sponge layer
    type(atmdynspongelayer) :: sponge_layer
    logical :: spongelayer_flag              !< Flag wheter sponge layer is applied
 
    ! diagnostic variables
    type(meshfield3d), allocatable :: aux_dynvars3d(:)
    type(modelvarmanager) :: auxdynvar3d_manager
    integer :: auxdynvar3d_commid
 
    ! boundary condition
    type(atmdynbnd) :: boundary_cond
 
    ! HEVI soler
    logical :: hevi_flag                     !< Flag wheter HEVI is applied
    logical :: hevi_use_lapack_flag          !< Flag wheter lapack is used in HEVI solver
 
    ! data communication with MPI
    logical :: hide_mpi_comm_flag            !< Flag wheter hiding MPI communication is performed
 
    procedure(atm_dyn_nonhydro3d_cal_vi), pointer, nopass :: cal_vi => null()
    procedure(atm_dyn_nonhydro3d_cal_tend_ex), pointer, nopass :: cal_tend_ex => null()
    procedure(atm_dyn_nonhydro3d_final), pointer, nopass :: dynsolver_final => null()
  contains
    procedure :: init => atmdyndgmdriver_nonhydro3d_init
    procedure :: final => atmdyndgmdriver_nonhydro3d_final
    procedure :: update => atmdyndgmdriver_nonhydro3d_update
    procedure :: is_thermvar_rhot => atmdyndgmdriver_nonhydro3d_is_thermvar_rhot    
    procedure :: calc_pressure => atmdyndgmdriver_nonhydro3d_calc_pressure
    procedure :: update_therm_hyd => atmdyndgmdriver_nonhydro3d_update_thermhyd
    procedure :: update_phyd_hgrad => atmdyndgmdriver_nonhydro3d_update_phyd_hgrad
  end type atmdyndgmdriver_nonhydro3d
 
  !-----------------------------------------------------------------------------
  !
  !++ Public procedures
  !
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  integer, public, parameter :: eqs_typeid_none                      = 0
  integer, public, parameter :: eqs_typeid_nonhyd3d_heve             = 1
  integer, public, parameter :: eqs_typeid_nonhyd3d_heve_entot       = 2
  integer, public, parameter :: eqs_typeid_globalnonhyd3d_heve       = 3
  integer, public, parameter :: eqs_typeid_globalnonhyd3d_heve_entot = 4
  integer, public, parameter :: eqs_typeid_nonhyd3d_splitform_heve   = 5
  integer, public, parameter :: eqs_typeid_nonhyd3d_hevi             = 6
  integer, public, parameter :: eqs_typeid_nonhyd3d_hevi_entot       = 7
  integer, public, parameter :: eqs_typeid_globalnonhyd3d_hevi       = 8
  integer, public, parameter :: eqs_typeid_globalnonhyd3d_hevi_entot = 9
  integer, public, parameter :: eqs_typeid_nonhyd3d_splitform_hevi   = 10  
 
  !-
  integer, public, parameter :: auxdynvars3d_dpres_id    = 1
  integer, public, parameter :: auxdynvars3d_dphyddx_id  = 2
  integer, public, parameter :: auxdynvars3d_dphyddy_id  = 3
  integer, public, parameter :: auxdynvars3d_num         = 3
 
  type(variableinfo), public :: atmos_dyn_auxdynvars3d_vinfo(auxdynvars3d_num)
  DATA atmos_dyn_auxdynvars3d_vinfo / &
    variableinfo( auxdynvars3d_dpres_id, 'DPRES', '',      &
                  '1',  3, 'XYZ',  ''                   ), &  
    variableinfo( auxdynvars3d_dphyddx_id, 'DPhydDx', '',  &
                  '1',  3, 'XYZ',  ''                   ), &  
    variableinfo( auxdynvars3d_dphyddy_id, 'DPhydDy', '',  &
                  '1',  3, 'XYZ',  ''                    ) /
 
  !-----------------------------------------------------------------------------
  !
  !++ Private procedures & variables
  !
  !-------------------
 
  private :: add_phy_tend
  private :: add_phy_tend_new
  private :: setup_modalfilter
  
contains
!> Initialize a object to provide a driver of atmospheric dynamical core
!!
!! @param eqs_type_name Name of governing equation
!! @param tint_type_name Name of temporal scheme
!! @param sponge_layer_flag Flag whether sponge layer is applied
!! @param modal_filter_flag Flag whether modal filtering is applied
!! @param hide_mpi_comm_flag Flag whether hiding MPI communication is performed
!! @param model_mesh3D Object managing 3D model mesh
!OCL SERIAL  
  subroutine atmdyndgmdriver_nonhydro3d_init( this, &
    eqs_type_name, tint_type_name, dtsec,           &
    sponge_layer_flag, modal_filter_flag,           &
    hide_mpi_comm_flag, &
    model_mesh3D )
 
    use scale_mesh_cubedspheredom3d, only: meshcubedspheredom3d
    implicit none
 
    class(atmdyndgmdriver_nonhydro3d), intent(inout) :: this
    character(len=*), intent(in) :: eqs_type_name
    character(len=*), intent(in) :: tint_type_name
    real(dp), intent(in) :: dtsec
    logical, intent(in) :: sponge_layer_flag
    logical, intent(in) :: modal_filter_flag
    logical, intent(in) :: hide_mpi_comm_flag
    class(modelmesh3d), intent(inout), target :: model_mesh3d
 
    class(meshbase3d), pointer :: mesh3d
    class(localmesh3d), pointer :: lcmesh
    integer :: domid
    class(hexahedralelement), pointer :: refelem3d
    class(elementbase), pointer :: refelem
    class(meshcubedspheredom3d), pointer :: gm_mesh3d
 
    integer :: iv
    !-----------------------------------------------------------------------------
 
    mesh3d => model_mesh3d%ptr_mesh
    select type( mesh3d )
    class is (meshcubedspheredom3d)
      gm_mesh3d => mesh3d
    end select
 
    call atmdyndgmdriver_base3d_init( this, &
      prgvar_num,                           &
      tint_type_name, dtsec,                &
      mesh3d                                )
 
    this%ENTOT_CONSERVE_SCHEME_FLAG = .false.
    this%hevi_flag                  = .false.
    this%hide_mpi_comm_flag         = hide_mpi_comm_flag
 
    select case(eqs_type_name)
    !-- NONE ------------------
    case("NONE")
      this%EQS_TYPEID = eqs_typeid_none
      call atm_dyn_dgm_none_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_none_cal_tend
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_none_final
    !-- HEVE ------------------
    case("NONHYDRO3D_HEVE_ASIS", "NONHYDRO3D_RHOT_HEVE_ASIS")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_heve
      call atm_dyn_dgm_nonhydro3d_rhot_heve_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend_asis
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_heve_final
    case("NONHYDRO3D_HEVE", "NONHYDRO3D_RHOT_HEVE")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_heve
      call atm_dyn_dgm_nonhydro3d_rhot_heve_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_heve_final
    case("NONHYDRO3D_HEVE_GPU")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_heve
      call atm_dyn_dgm_nonhydro3d_rhot_heve_gpu_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend_gpu
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_heve_gpu_final
    case("NONHYDRO3D_HEVE_GPU2")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_heve
      call atm_dyn_dgm_nonhydro3d_rhot_heve_gpu_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend_gpu2
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_heve_gpu_final
    case("NONHYDRO3D_HEVE_CCO")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_heve
      call atm_dyn_dgm_nonhydro3d_rhot_heve_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_heve_cal_tend_cco
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_heve_final
    case("NONHYDRO3D_ETOT_HEVE")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_heve_entot
      call atm_dyn_dgm_nonhydro3d_etot_heve_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_etot_heve_cal_tend
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_etot_heve_final
      this%ENTOT_CONSERVE_SCHEME_FLAG = .true.
    case("GLOBALNONHYDRO3D_HEVE_ASIS", "GLOBALNONHYDRO3D_RHOT_HEVE_ASIS")
      this%EQS_TYPEID = eqs_typeid_globalnonhyd3d_heve
      call atm_dyn_dgm_globalnonhydro3d_rhot_heve_init( mesh3d )
      if ( gm_mesh3d%shallow_approx ) then
        this%cal_tend_ex => atm_dyn_dgm_globalnh3d_rhot_heve_cal_tend_shallow_atm_asis
      else
        this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_rhot_heve_cal_tend_deep_atm
      end if
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_globalnonhydro3d_rhot_heve_final
    case("GLOBALNONHYDRO3D_HEVE", "GLOBALNONHYDRO3D_RHOT_HEVE")
      this%EQS_TYPEID = eqs_typeid_globalnonhyd3d_heve
      call atm_dyn_dgm_globalnonhydro3d_rhot_heve_init( mesh3d )
      if ( gm_mesh3d%shallow_approx ) then
        this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_rhot_heve_cal_tend_shallow_atm
      else
        this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_rhot_heve_cal_tend_deep_atm
      end if
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_globalnonhydro3d_rhot_heve_final
    case("GLOBALNONHYDRO3D_HEVE_GPU", "GLOBALNONHYDRO3D_RHOT_HEVE_GPU")
      this%EQS_TYPEID = eqs_typeid_globalnonhyd3d_heve
      call atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu_init( mesh3d )
      if ( gm_mesh3d%shallow_approx ) then
        this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu_cal_tend_shallow_atm
      else
        this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu_cal_tend_deep_atm
      end if
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_globalnonhydro3d_rhot_heve_gpu_final
    case("GLOBALNONHYDRO3D_ETOT_HEVE")
      this%EQS_TYPEID = eqs_typeid_globalnonhyd3d_heve_entot
      call atm_dyn_dgm_globalnonhydro3d_etot_heve_init( mesh3d )
      if ( .not. gm_mesh3d%shallow_approx ) then
        log_error("AtmDynDGMDriver_nonhydro3d_Init",*) 'EQS Type:', eqs_type_name, 'Deep atmosphere is not supported. Check!'
        call prc_abort  
      end if
      this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_etot_heve_cal_tend
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_globalnonhydro3d_etot_heve_final
      this%ENTOT_CONSERVE_SCHEME_FLAG = .true.
    case("NONHYDRO3D_HEVE_SPLITFORM", "NONHYDRO3D_RHOT_HEVE_SPLITFORM")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_splitform_heve
      call atm_dyn_dgm_nonhydro3d_rhot_heve_splitform_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_heve_splitform_cal_tend
      this%cal_vi => null()
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_heve_splitform_final
    !-- HEVI ------------------
    case("NONHYDRO3D_HEVI_ASIS", "NONHYDRO3D_RHOT_HEVI_ASIS") 
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_hevi
      call atm_dyn_dgm_nonhydro3d_rhot_hevi_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_hevi_cal_tend_asis
      this%cal_vi => atm_dyn_dgm_nonhydro3d_rhot_hevi_cal_vi_asis
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_hevi_final
      this%hevi_flag = .true.
    case("NONHYDRO3D_HEVI", "NONHYDRO3D_RHOT_HEVI") 
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_hevi
      call atm_dyn_dgm_nonhydro3d_rhot_hevi_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_hevi_cal_tend
      this%cal_vi => atm_dyn_dgm_nonhydro3d_rhot_hevi_cal_vi
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_hevi_final
      this%hevi_flag = .true.
    case("NONHYDRO3D_ETOT_HEVI")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_hevi_entot
      call atm_dyn_dgm_nonhydro3d_etot_hevi_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_etot_hevi_cal_tend
      this%cal_vi => atm_dyn_dgm_nonhydro3d_etot_hevi_cal_vi
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_etot_hevi_final
      this%ENTOT_CONSERVE_SCHEME_FLAG = .true.
      this%hevi_flag = .true.
    case("GLOBALNONHYDRO3D_HEVI_ASIS", "GLOBALNONHYDRO3D_RHOT_HEVI_ASIS")
      this%EQS_TYPEID = eqs_typeid_globalnonhyd3d_hevi
      call atm_dyn_dgm_globalnonhydro3d_rhot_hevi_init( mesh3d )
      if ( .not. gm_mesh3d%shallow_approx ) then
        log_error("AtmDynDGMDriver_nonhydro3d_Init",*) 'EQS Type:', eqs_type_name, 'Deep atmosphere is not supported. Check!'
        call prc_abort  
      end if
      this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_rhot_hevi_cal_tend_asis
      this%cal_vi => atm_dyn_dgm_globalnonhydro3d_rhot_hevi_cal_vi_asis
      this%dynsolver_final => atm_dyn_dgm_globalnonhydro3d_rhot_hevi_final
      this%hevi_flag = .true.
    case("GLOBALNONHYDRO3D_HEVI", "GLOBALNONHYDRO3D_RHOT_HEVI")
      this%EQS_TYPEID = eqs_typeid_globalnonhyd3d_hevi
      call atm_dyn_dgm_globalnonhydro3d_rhot_hevi_init( mesh3d )
      if ( .not. gm_mesh3d%shallow_approx ) then
        log_error("AtmDynDGMDriver_nonhydro3d_Init",*) 'EQS Type:', eqs_type_name, 'Deep atmosphere is not supported. Check!'
        call prc_abort  
      end if
      this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_rhot_hevi_cal_tend
      this%cal_vi => atm_dyn_dgm_globalnonhydro3d_rhot_hevi_cal_vi
      this%dynsolver_final => atm_dyn_dgm_globalnonhydro3d_rhot_hevi_final
      this%hevi_flag = .true.
    case("GLOBALNONHYDRO3D_ETOT_HEVI")
      this%EQS_TYPEID = eqs_typeid_globalnonhyd3d_hevi_entot
      call atm_dyn_dgm_globalnonhydro3d_etot_hevi_init( mesh3d )
      if ( .not. gm_mesh3d%shallow_approx ) then
        log_error("AtmDynDGMDriver_nonhydro3d_Init",*) 'EQS Type:', eqs_type_name, 'Deep atmosphere is not supported. Check!'
        call prc_abort  
      end if
      this%cal_tend_ex => atm_dyn_dgm_globalnonhydro3d_etot_hevi_cal_tend
      this%cal_vi => atm_dyn_dgm_globalnonhydro3d_etot_hevi_cal_vi
      this%dynsolver_final => atm_dyn_dgm_globalnonhydro3d_etot_hevi_final
      this%ENTOT_CONSERVE_SCHEME_FLAG = .true.
      this%hevi_flag = .true.
    case("NONHYDRO3D_HEVI_SPLITFORM", "NONHYDRO3D_RHOT_HEVI_SPLITFORM")
      this%EQS_TYPEID = eqs_typeid_nonhyd3d_splitform_hevi
      call atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform_init( mesh3d )
      this%cal_tend_ex => atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform_cal_tend
      this%cal_vi => atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform_cal_vi
      this%dynsolver_final => atm_dyn_dgm_nonhydro3d_rhot_hevi_splitform_final
      this%hevi_flag = .true.
    case default
      log_error("AtmDynDGMDriver_nonhydro3d_Init",*) 'Invalid EQS_TYPE in namelist PARAM_ATMOS_DYN. Check!'
      call prc_abort
    end select
    
    !- Initialize variables
 
    call this%AUXDYNVAR3D_manager%Init()
    allocate( this%AUX_DYNVARS3D(auxdynvars3d_num) )
 
    do iv = 1, auxdynvars3d_num
      call this%AUXDYNVAR3D_manager%Regist( &
        atmos_dyn_auxdynvars3d_vinfo(iv), mesh3d,  & 
        this%AUX_DYNVARS3D(iv),                    & 
        .false., fill_zero=.true.                  ) 
    end do
 
    !- Setup halo data communication for DPRES
    call model_mesh3d%Create_communicator( &
      1, 0, 0,                         & ! (in) 
      this%AUXDYNVAR3D_manager,        & ! (in)
      this%AUX_DYNVARS3D,              & ! (in)
      this%AUXDYNVAR3D_commid,         & ! (out)
      field_list_is=1, field_list_ie=1 ) ! (in)
 
 
    !- initialize an object to manage boundary conditions
    call this%boundary_cond%Init()
    call this%boundary_cond%SetBCInfo( mesh3d )
 
    !- initialize an object to manage sponge layer
    this%SPONGELAYER_FLAG = sponge_layer_flag
    if (this%SPONGELAYER_FLAG) then
      call this%sponge_layer%Init( mesh3d, dtsec )
    end if
 
    !- initialize an object to manage modal filter
    this%MODALFILTER_FLAG = modal_filter_flag
    if (this%MODALFILTER_FLAG) then
      refelem => mesh3d%refElem
      select type(refelem)
      class is (hexahedralelement)
        refelem3d => refelem
      end select
 
      call setup_modalfilter( this, refelem3d, model_mesh3d%element3D_operation )
    end if
 
    return
  end subroutine atmdyndgmdriver_nonhydro3d_init
 
  !> Get a flag whether density-weighted potential temperature is used for a prognostic thermodynamic variable
!OCL SERIAL
  function atmdyndgmdriver_nonhydro3d_is_thermvar_rhot( this ) result(ret)
    implicit none
 
    class(atmdyndgmdriver_nonhydro3d), intent(inout) :: this
    logical :: ret
    !-----------------------------------------------------------------------------
 
    if ( this%ENTOT_CONSERVE_SCHEME_FLAG ) then
      ret = .false.
    else
      ret = .true.
    end if
    return
  end function atmdyndgmdriver_nonhydro3d_is_thermvar_rhot
 
  !> Update the prognostic variables for the non-hydrostatic 3D atmospheric dynamical core
!OCL SERIAL
  subroutine atmdyndgmdriver_nonhydro3d_update( this, &
    PROG_VARS, AUX_VARS, PHYTENDS,                       &
    DENS_TRC, DENS0_TRC,                                 &
    MFLX_x_tavg, MFLX_y_tavg, MFLX_z_tavg,               &
    ALPH_DENS_M_tavg, ALPH_DENS_P_tavg,                  &
    Coriolis,                                            &
    element_operation,                                   &
    Dx, Dy, Dz, Sx, Sy, Sz, Lift, mesh3D                 )
 
    use scale_tracer, only: &
      qa, tracer_advc, tracer_name
    use scale_atm_dyn_dgm_trcadvect3d_heve, only: &
      atm_dyn_dgm_trcadvect3d_save_massflux
  
    use scale_model_var_manager, only: modelvarmanager
    use scale_atm_dyn_dgm_modalfilter, only: &
      atm_dyn_dgm_modalfilter_apply
 
    use scale_timeint_rk, only: timeint_rk_var
    implicit none
 
    class(atmdyndgmdriver_nonhydro3d), intent(inout) :: this
    class(meshbase3d), intent(in), target :: mesh3d
    class(modelvarmanager), intent(inout) :: prog_vars
    class(modelvarmanager), intent(inout) :: aux_vars
    class(modelvarmanager), intent(inout) :: phytends
    type(meshfield3d), intent(inout) :: dens_trc
    type(meshfield3d), intent(inout) :: dens0_trc
    type(meshfield3d), intent(inout) :: mflx_x_tavg
    type(meshfield3d), intent(inout) :: mflx_y_tavg
    type(meshfield3d), intent(inout) :: mflx_z_tavg
    type(meshfield3d), intent(inout) :: alph_dens_m_tavg
    type(meshfield3d), intent(inout) :: alph_dens_p_tavg
    class(meshfield2d), intent(in) :: coriolis
    class(elementoperationbase3d), intent(in) :: element_operation
    type(sparsemat), intent(in) :: dx, dy, dz
    type(sparsemat), intent(in) :: sx, sy, sz
    type(sparsemat), intent(in) :: lift
 
    integer :: rkstage
    integer :: tintbuf_ind
    real(rp) :: dt
    real(rp) :: implicit_fac
 
    real(rp) :: tavg_coef_mflxz(this%tint(1)%nstage)
 
    class(localmesh3d), pointer :: lcmesh3d
    integer :: n
    integer :: ke
 
    class(meshfield3d), pointer :: ddens, momx, momy, momz, therm
    class(meshfield3d), pointer :: pres_hyd, pres_hyd_ref, dens_hyd, therm_hyd, rtot, cvtot, cptot, pres
    class(meshfield3d), pointer :: dens_tp, momx_tp, momy_tp, momz_tp, rhot_tp, rhoh_p
    class(meshfield3d), pointer :: dpres, dphyddx, dphyddy
 
    type(timeint_rk_var) :: rkvar_list(5,mesh3d%local_mesh_num)
    integer :: rkvar_ids(5)
 
    logical :: do_wait
    !-----------------------------------------------------------------------------
    
    !-
    call prof_rapstart( 'ATM_DYN_update_pre', 2)
    call prog_vars%Get3D( dens_vid , ddens )
    call prog_vars%Get3D( therm_vid, therm )
    call prog_vars%Get3D( momz_vid , momz  )
    call prog_vars%Get3D( momx_vid , momx  )
    call prog_vars%Get3D( momy_vid , momy  )
 
    call aux_vars%Get3D( preshyd_vid, pres_hyd )
    call aux_vars%Get3D( denshyd_vid, dens_hyd )
    call aux_vars%Get3D( thermhyd_vid, therm_hyd )
    call aux_vars%Get3D( preshyd_ref_vid, pres_hyd_ref )
    call aux_vars%Get3D( pres_vid, pres )
    call aux_vars%Get3D( rtot_vid, rtot )
    call aux_vars%Get3D( cvtot_vid, cvtot )
    call aux_vars%Get3D( cptot_vid, cptot )
 
    call phytends%Get3D( phytend_dens_id, dens_tp )
    call phytends%Get3D( phytend_momx_id, momx_tp )
    call phytends%Get3D( phytend_momy_id, momy_tp )
    call phytends%Get3D( phytend_momz_id, momz_tp )
    call phytends%Get3D( phytend_rhot_id, rhot_tp )
    call phytends%Get3D( phytend_rhoh_id, rhoh_p )
 
    call this%AUXDYNVAR3D_manager%Get3D( auxdynvars3d_dpres_id, dpres )
    call this%AUXDYNVAR3D_manager%Get3D( auxdynvars3d_dphyddx_id, dphyddx )
    call this%AUXDYNVAR3D_manager%Get3D( auxdynvars3d_dphyddy_id, dphyddy )
 
    if (this%hevi_flag) then 
      do n=1, mesh3d%LOCAL_MESH_NUM
        lcmesh3d => mesh3d%lcmesh_list(n)
        
        call this%tint(n)%StoreVar0( ddens%local(n)%val,  dens_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
        call this%tint(n)%StoreVar0( therm%local(n)%val, therm_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
        call this%tint(n)%StoreVar0(  momz%local(n)%val,  momz_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
        call this%tint(n)%StoreVar0(  momx%local(n)%val,  momx_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
        call this%tint(n)%StoreVar0(  momy%local(n)%val,  momy_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )        
      end do
    end if
 
    do n=1, mesh3d%LOCAL_MESH_NUM
      rkvar_list(1,n)%var2D => ddens%local(n)%val
      rkvar_list(2,n)%var2D => therm%local(n)%val
      rkvar_list(3,n)%var2D => momz%local(n)%val
      rkvar_list(4,n)%var2D => momx%local(n)%val
      rkvar_list(5,n)%var2D => momy%local(n)%val
      rkvar_ids(:) = (/ dens_vid, therm_vid, momz_vid, momx_vid, momy_vid /)
    end do
 
    do_wait = (.not. this%hide_mpi_comm_flag)
    call prof_rapend( 'ATM_DYN_update_pre', 2)
 
    do rkstage=1, this%tint(1)%nstage
    
      !- Calculate the tendency with the implicit part      
      if (this%hevi_flag) then        
        do n=1, mesh3d%LOCAL_MESH_NUM
          lcmesh3d => mesh3d%lcmesh_list(n)
 
          call prof_rapstart( 'ATM_DYN_cal_vi', 2)
          implicit_fac = this%tint(n)%Get_implicit_diagfac(rkstage)
          tintbuf_ind = this%tint(n)%tend_buf_indmap(rkstage)
          dt = this%tint(n)%Get_deltime()
          call this%cal_vi( &
            this%tint(n)%tend_buf2D_im(:,:,dens_vid,tintbuf_ind),                           & ! (out)
            this%tint(n)%tend_buf2D_im(:,:,momx_vid ,tintbuf_ind),                          & ! (out)
            this%tint(n)%tend_buf2D_im(:,:,momy_vid ,tintbuf_ind),                          & ! (out)
            this%tint(n)%tend_buf2D_im(:,:,momz_vid ,tintbuf_ind),                          & ! (out)
            this%tint(n)%tend_buf2D_im(:,:,therm_vid,tintbuf_ind),                          & ! (out)
            ddens%local(n)%val, momx%local(n)%val, momy%local(n)%val, momz%local(n)%val,    & ! (in)
            therm%local(n)%val,                                                             & ! (in)
            dens_hyd%local(n)%val, pres_hyd%local(n)%val,                                   & ! (in)
            this%tint(n)%var0_2D(:,:,dens_vid), this%tint(n)%var0_2D(:,:,momx_vid),         & ! (in)
            this%tint(n)%var0_2D(:,:,momy_vid ), this%tint(n)%var0_2D(:,:,momz_vid),        & ! (in)
            this%tint(n)%var0_2D(:,:,therm_vid ),                                           & ! (in)
            rtot%local(n)%val, cvtot%local(n)%val, cptot%local(n)%val,                      & ! (in)
            element_operation, dz, lift,                                                    & ! (in)
            implicit_fac, dt,                                                               & ! (in)
            lcmesh3d, lcmesh3d%refElem3D, lcmesh3d%lcmesh2D, lcmesh3d%lcmesh2D%refElem2D    ) ! (in)
          
          call prof_rapend( 'ATM_DYN_cal_vi', 2)  
          
          call prof_rapstart( 'ATM_DYN_store_impl', 2)      
          call this%tint(n)%StoreImplicit( rkstage, ddens%local(n)%val,  dens_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
          call this%tint(n)%StoreImplicit( rkstage, therm%local(n)%val, therm_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
          call this%tint(n)%StoreImplicit( rkstage,  momz%local(n)%val,  momz_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
          call this%tint(n)%StoreImplicit( rkstage,  momx%local(n)%val,  momx_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
          call this%tint(n)%StoreImplicit( rkstage,  momy%local(n)%val,  momy_vid, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )
          call prof_rapend( 'ATM_DYN_store_impl', 2) 
        end do
      
      end if
 
      !- Exchange halo data
      call prof_rapstart( 'ATM_DYN_exchange_prgv', 2)
      call prog_vars%MeshFieldComm_Exchange( do_wait )
      call prof_rapend( 'ATM_DYN_exchange_prgv', 2)
 
 
      !- Calculate pressure perturbation
 
      call prof_rapstart( 'ATM_DYN_cal_pres', 2)
      call atm_dyn_dgm_nonhydro3d_common_calc_pressure( &
        pres, dpres,                                       & ! (inout) 
        ddens, momx, momy, momz, therm,                    & ! (in)
        pres_hyd, dens_hyd, therm_hyd, rtot, cvtot, cptot, & ! (in)
        mesh3d, this%ENTOT_CONSERVE_SCHEME_FLAG )            ! (in)
      call prof_rapend( 'ATM_DYN_cal_pres', 2)
 
      !- Exchange halo data
      if ( ( .not. this%hide_mpi_comm_flag ) .or. this%ENTOT_CONSERVE_SCHEME_FLAG ) then
        call prof_rapstart( 'ATM_DYN_exchange_prgv', 2)
        call this%AUXDYNVAR3D_manager%MeshFieldComm_Exchange( do_wait )
        call prof_rapend( 'ATM_DYN_exchange_prgv', 2)
      end if
 
      if ( .not. this%hide_mpi_comm_flag ) then
        do n=1, mesh3d%LOCAL_MESH_NUM
          lcmesh3d => mesh3d%lcmesh_list(n)
 
          !- Apply boundary conditions
          call prof_rapstart( 'ATM_DYN_applyBC_prgv', 2)
          call this%boundary_cond%ApplyBC_PROGVARS_lc( n,                                                         & ! (in)
            ddens%local(n)%val, momx%local(n)%val, momy%local(n)%val, momz%local(n)%val, therm%local(n)%val,      & ! (inout)
            dens_hyd%local(n)%val, pres_hyd%local(n)%val,                                                         & ! (in)
            lcmesh3d%Gsqrt, lcmesh3d%GsqrtH, lcmesh3d%GIJ(:,:,1,1), lcmesh3d%GIJ(:,:,1,2), lcmesh3d%GIJ(:,:,2,2), & ! (in)
            lcmesh3d%GI3(:,:,1), lcmesh3d%GI3(:,:,2),                                                             & ! (in)
            lcmesh3d%normal_fn(:,:,1), lcmesh3d%normal_fn(:,:,2), lcmesh3d%normal_fn(:,:,3),                      & ! (in)
            lcmesh3d%vmapM, lcmesh3d%vmapP, lcmesh3d%vmapB,                                                       & ! (in)
            lcmesh3d, lcmesh3d%refElem3D, lcmesh3d%lcmesh2D, lcmesh3d%lcmesh2D%refElem2D                          ) ! (in)
          call prof_rapend( 'ATM_DYN_applyBC_prgv', 2)
        end do
      end if
 
      !- Calculate the tendency with the explicit part
      do n=1, mesh3d%LOCAL_MESH_NUM
        lcmesh3d => mesh3d%lcmesh_list(n)
 
        call prof_rapstart( 'ATM_DYN_update_caltend_ex', 2)
        tintbuf_ind = this%tint(n)%tend_buf_indmap(rkstage)
        call this%cal_tend_ex( &
          this%tint(n)%tend_buf2D_ex(:,:,dens_vid,tintbuf_ind),                             & ! (out)
          this%tint(n)%tend_buf2D_ex(:,:,momx_vid ,tintbuf_ind),                            & ! (out)
          this%tint(n)%tend_buf2D_ex(:,:,momy_vid ,tintbuf_ind),                            & ! (out)
          this%tint(n)%tend_buf2D_ex(:,:,momz_vid ,tintbuf_ind),                            & ! (out)
          this%tint(n)%tend_buf2D_ex(:,:,therm_vid,tintbuf_ind),                            & ! (out)
          ddens%local(n)%val, momx%local(n)%val, momy%local(n)%val, momz%local(n)%val,      & ! (in)
          therm%local(n)%val, dpres%local(n)%val,                                           & ! (in)
          dens_hyd%local(n)%val, pres_hyd%local(n)%val, pres_hyd_ref%local(n)%val,          & ! (in)
          therm_hyd%local(n)%val,                                                           & ! (in)
          coriolis%local(n)%val, rtot%local(n)%val, cvtot%local(n)%val, cptot%local(n)%val, & ! (in)
          dphyddx%local(n)%val, dphyddy%local(n)%val,                                       & ! (in)
          element_operation, dx, dy, dz, sx, sy, sz, lift,                                  & ! (in)
          lcmesh3d, lcmesh3d%refElem3D, lcmesh3d%lcmesh2D, lcmesh3d%lcmesh2D%refElem2D      ) ! (in)
        call prof_rapend( 'ATM_DYN_update_caltend_ex', 2)
 
        !- Sponge layer
        if (this%SPONGELAYER_FLAG) then
          call prof_rapstart('ATM_DYN_caltend_sponge', 2)
          call this%sponge_layer%AddTend( &
            this%tint(n)%tend_buf2D_ex(:,:,momx_vid ,tintbuf_ind),   & ! (inout)
            this%tint(n)%tend_buf2D_ex(:,:,momy_vid ,tintbuf_ind),   & ! (inout)
            this%tint(n)%tend_buf2D_ex(:,:,momz_vid ,tintbuf_ind),   & ! (inout)
            momx%local(n)%val, momy%local(n)%val, momz%local(n)%val, & ! (in)
            lcmesh3d, lcmesh3d%refElem3D                             ) ! (in)
          call prof_rapend('ATM_DYN_caltend_sponge', 2)
        end if
      end do
      
      call prof_rapstart( 'ATM_DYN_update_add_tp', 2)
      do n=1, mesh3d%LOCAL_MESH_NUM
        lcmesh3d => mesh3d%lcmesh_list(n)
        
        tintbuf_ind = this%tint(n)%tend_buf_indmap(rkstage)
        call add_phy_tend( &
          this, this%tint(n)%tend_buf2D_ex(:,:,:,tintbuf_ind),              & ! (inout)
          dens_tp%local(n)%val, momx_tp%local(n)%val, momy_tp%local(n)%val, & ! (in)
          momz_tp%local(n)%val, rhot_tp%local(n)%val, rhoh_p %local(n)%val, & ! (in)
          pres%local(n)%val, rtot%local(n)%val, cptot%local(n)%val,         & ! (in)
          n, lcmesh3d, lcmesh3d%refElem3D                                   ) ! (in)
      end do
      call prof_rapend( 'ATM_DYN_update_add_tp', 2)
 
 
      if ( this%hide_mpi_comm_flag ) then
 
        call prof_rapstart( 'ATM_DYN_exchange_prgv_wait', 2)
        call prog_vars%MeshFieldComm_Get()
        if ( this%ENTOT_CONSERVE_SCHEME_FLAG ) &
          call this%AUXDYNVAR3D_manager%MeshFieldComm_Get()
        call prof_rapend( 'ATM_DYN_exchange_prgv_wait', 2)
 
        do n=1, mesh3d%LOCAL_MESH_NUM
          lcmesh3d => mesh3d%lcmesh_list(n)
          tintbuf_ind = this%tint(n)%tend_buf_indmap(rkstage)
 
          !- Apply boundary conditions
          call prof_rapstart( 'ATM_DYN_applyBC_prgv', 2)
          call this%boundary_cond%ApplyBC_PROGVARS_lc( n,                                                         & ! (in)
            ddens%local(n)%val, momx%local(n)%val, momy%local(n)%val, momz%local(n)%val, therm%local(n)%val,      & ! (inout)
            dens_hyd%local(n)%val, pres_hyd%local(n)%val,                                                         & ! (in)
            lcmesh3d%Gsqrt, lcmesh3d%GsqrtH, lcmesh3d%GIJ(:,:,1,1), lcmesh3d%GIJ(:,:,1,2), lcmesh3d%GIJ(:,:,2,2), & ! (in)
            lcmesh3d%GI3(:,:,1), lcmesh3d%GI3(:,:,2),                                                             & ! (in)
            lcmesh3d%normal_fn(:,:,1), lcmesh3d%normal_fn(:,:,2), lcmesh3d%normal_fn(:,:,3),                      & ! (in)
            lcmesh3d%vmapM, lcmesh3d%vmapP, lcmesh3d%vmapB,                                                       & ! (in)
            lcmesh3d, lcmesh3d%refElem3D, lcmesh3d%lcmesh2D, lcmesh3d%lcmesh2D%refElem2D                          ) ! (in)
          call prof_rapend( 'ATM_DYN_applyBC_prgv', 2)
 
          call prof_rapstart( 'ATM_DYN_ebnd_flux', 2)
          call atm_dyn_dgm_nonhydro3d_rhot_heve_add_bnd_contrib_generalvc( & 
            this%tint(n)%tend_buf2D_ex(:,:,:,tintbuf_ind),                                    & ! (inout)          
            ddens%local(n)%val, momx%local(n)%val, momy%local(n)%val, momz%local(n)%val,      & ! (in)
            therm%local(n)%val, dpres%local(n)%val,                                           & ! (in)
            dens_hyd%local(n)%val, pres_hyd%local(n)%val, therm_hyd%local(n)%val,             & ! (in)
            rtot%local(n)%val, cvtot%local(n)%val, cptot%local(n)%val, &
            lcmesh3d%Gsqrt, lcmesh3d%GI3(:,:,1), lcmesh3d%GI3(:,:,2), lcmesh3d%normal_fn(:,:,1),lcmesh3d%normal_fn(:,:,2),lcmesh3d%normal_fn(:,:,3), &
            lcmesh3d%VMapM, lcmesh3d%VMapP, lcmesh3d, lcmesh3d%refElem3D, lcmesh3d%lcmesh2D, lcmesh3d%lcmesh2D%refElem2D, &
            element_operation )
          call prof_rapend( 'ATM_DYN_ebnd_flux', 2)
        end do
      end if
      
      do n=1, mesh3d%LOCAL_MESH_NUM
        lcmesh3d => mesh3d%lcmesh_list(n)
 
        if ( qa > 0 .and. this%EQS_TYPEID /= eqs_typeid_none ) then
          call prof_rapstart( 'ATM_DYN_tavg_mflx', 2)
          if (this%tint(1)%imex_flag) then
            tavg_coef_mflxz(:) = this%tint(n)%coef_b_im(:)
          else
            tavg_coef_mflxz(:) = this%tint(n)%coef_b_ex(:)
          end if
          call atm_dyn_dgm_trcadvect3d_save_massflux( &
            mflx_x_tavg%local(n)%val, mflx_y_tavg%local(n)%val, mflx_z_tavg%local(n)%val,   & ! (inout)
            alph_dens_m_tavg%local(n)%face_val, alph_dens_p_tavg%local(n)%face_val,         & ! (inout)
            ddens%local(n)%val, momx%local(n)%val, momy%local(n)%val, momz%local(n)%val,    & ! (in)
            dpres%local(n)%val, dens_hyd%local(n)%val, pres_hyd%local(n)%val,               & ! (in)
            rtot%local(n)%val, cvtot%local(n)%val, cptot%local(n)%val,                      & ! (in)
            lcmesh3d, lcmesh3d%refElem3D,                                                   & ! (in)
            rkstage, this%tint(n)%coef_b_ex(rkstage), tavg_coef_mflxz(rkstage),             & ! (in)
            this%hevi_flag                                                                  ) ! (in)
          call prof_rapend( 'ATM_DYN_tavg_mflx', 2)
        end if
 
        call prof_rapstart( 'ATM_DYN_update_advance', 2)      
        call this%tint(n)%Advance_varlist( rkstage, rkvar_list(:,n), rkvar_ids, 1, lcmesh3d%refElem%Np, lcmesh3d%NeS, lcmesh3d%NeE )  
        call prof_rapend( 'ATM_DYN_update_advance', 2)        
      end do
    
    end do ! end for RK loop
 
    call prof_rapstart( 'ATM_DYN_update_post', 2)
    if ( qa > 0 ) then
      do n=1, mesh3d%LOCAL_MESH_NUM
        lcmesh3d => mesh3d%lcmesh_list(n)
 
        !$omp parallel do
        do ke=lcmesh3d%NeS, lcmesh3d%NeE
          dens0_trc%local(n)%val(:,ke) = this%tint(n)%var0_2D(:,ke,dens_vid)
          dens_trc %local(n)%val(:,ke) = ddens%local(n)%val(:,ke)
        end do        
     end do
    end if
    call prof_rapend( 'ATM_DYN_update_post', 2)      
 
    if ( this%MODALFILTER_FLAG ) then
      do n=1, mesh3d%LOCAL_MESH_NUM
        lcmesh3d => mesh3d%lcmesh_list(n)
 
        call prof_rapstart( 'ATM_DYN_update_modalfilter', 2)        
        call atm_dyn_dgm_modalfilter_apply(  & 
          ddens%local(n)%val, momx%local(n)%val, momy%local(n)%val, momz%local(n)%val, therm%local(n)%val, & ! (inout)
          lcmesh3d, lcmesh3d%refElem3D, element_operation,           & ! (in)
          do_weight_gsqrt = .true.                                   ) ! (in)        
        call prof_rapend( 'ATM_DYN_update_modalfilter', 2)
      end do
    end if
 
    call prof_rapstart( 'ATM_DYN_update_post', 2)
    call atm_dyn_dgm_nonhydro3d_common_calc_pressure( &
      pres, dpres,                                    & ! (inout) 
      ddens, momx, momy, momz, therm,                 & ! (in)
      pres_hyd, dens_hyd, therm_hyd,                  & ! (in)
      rtot, cvtot, cptot,                             & ! (in)
      mesh3d, this%ENTOT_CONSERVE_SCHEME_FLAG )         ! (in)
    call prof_rapend( 'ATM_DYN_update_post', 2)
 
    return
  end subroutine atmdyndgmdriver_nonhydro3d_update
 
!> Finalize a object to provide a driver of atmospheric dynamical core
!OCL SERIAL
  subroutine atmdyndgmdriver_nonhydro3d_final( this )
    implicit none
 
    class(atmdyndgmdriver_nonhydro3d), intent(inout) :: this
    !-----------------------------------------------------------------------------
 
    call this%dynsolver_final()
    call this%boundary_cond%Final()
    
    if ( this%SPONGELAYER_FLAG ) call this%sponge_layer%Final()
 
    if ( this%MODALFILTER_FLAG ) then
      call this%modal_filter_3d%Final()
      if ( this%hevi_flag ) call this%modal_filter_v1D%Final()
    end if
    
    call this%AUXDYNVAR3D_manager%Final()
    call atmdyndgmdriver_base3d_final( this )   
 
    return
  end subroutine atmdyndgmdriver_nonhydro3d_final
 
  !> Calculate the pressure using the prognostic variables with the non-hydrostatic 3D atmospheric dynamical core
!OCL SERIAL
  subroutine atmdyndgmdriver_nonhydro3d_calc_pressure( this, &
    PRES, PROG_VARS, AUX_VARS                                )
 
    implicit none
 
    class(atmdyndgmdriver_nonhydro3d), intent(in) :: this
    class(meshfield3d), intent(inout) :: pres
    class(modelvarmanager), intent(inout) :: prog_vars
    class(modelvarmanager), intent(inout) :: aux_vars
 
    class(meshbase3d), pointer :: mesh3d
    class(meshfield3d), pointer :: ddens, momx, momy, momz, therm
    class(meshfield3d), pointer :: pres_hyd, dens_hyd, therm_hyd, rtot, cvtot, cptot
    
    type(meshfield3d) :: dpres
    !-----------------------------------------------------------------------------
 
    call prog_vars%Get3D(dens_vid , ddens)
    call prog_vars%Get3D(therm_vid, therm)
    call prog_vars%Get3D(momz_vid , momz )
    call prog_vars%Get3D(momx_vid , momx )
    call prog_vars%Get3D(momy_vid , momy )
 
    call aux_vars%Get3D( preshyd_vid, pres_hyd )
    call aux_vars%Get3D( denshyd_vid, dens_hyd )
    call aux_vars%Get3D( thermhyd_vid, therm_hyd )
    call aux_vars%Get3D( rtot_vid, rtot )
    call aux_vars%Get3D( cvtot_vid, cvtot )
    call aux_vars%Get3D( cptot_vid, cptot )
 
    mesh3d => ddens%mesh
    call dpres%Init( "DPRES", "Pa", mesh3d )
 
    call atm_dyn_dgm_nonhydro3d_common_calc_pressure( &
      pres, dpres,                                       & ! (inout) 
      ddens, momx, momy, momz, therm,                    & ! (in)
      pres_hyd, dens_hyd, therm_hyd, rtot, cvtot, cptot, & ! (in)
      mesh3d, this%ENTOT_CONSERVE_SCHEME_FLAG )            ! (in)
 
    call dpres%Final()
 
    return
  end subroutine atmdyndgmdriver_nonhydro3d_calc_pressure
  
  !> Update the hydrostatic part of thermodynamic prognostic variable (THERM_hyd)
!OCL SERIAL
  subroutine atmdyndgmdriver_nonhydro3d_update_thermhyd( this, &
    AUX_VARS                                                   )    
    use scale_atm_dyn_dgm_nonhydro3d_common, only: &
      atm_dyn_dgm_nonhydro3d_common_calc_therm_phyd
    implicit none
    class(atmdyndgmdriver_nonhydro3d), intent(in) :: this
    class(modelvarmanager), intent(inout) :: aux_vars
    
    class(meshfield3d), pointer :: pres_hyd, dens_hyd, therm_hyd
    class(meshbase3d), pointer :: mesh3d
    !---------------------------
 
    call aux_vars%Get3D( preshyd_vid, pres_hyd )
    call aux_vars%Get3D( denshyd_vid, dens_hyd )
    call aux_vars%Get3D( thermhyd_vid, therm_hyd )
 
    mesh3d => dens_hyd%mesh
 
    call atm_dyn_dgm_nonhydro3d_common_calc_therm_phyd( &
      therm_hyd,                                      & ! (inout) 
      pres_hyd, dens_hyd,                             & ! (in)
      mesh3d, this%ENTOT_CONSERVE_SCHEME_FLAG )         ! (in)
 
    return
  end subroutine atmdyndgmdriver_nonhydro3d_update_thermhyd
 
  !> Calculate the horizontal gradient of the hydrostatic pressure
!OCL SERIAL
  subroutine atmdyndgmdriver_nonhydro3d_update_phyd_hgrad( this, &
    PRES_hyd, PRES_hyd_ref,                    & ! (in)
    mesh3d, element_operation                  ) ! (in)
    use scale_atm_dyn_dgm_nonhydro3d_common, only: &
      atm_dyn_dgm_nonhydro3d_common_calc_phyd_hgrad_lc
    implicit none
    class(atmdyndgmdriver_nonhydro3d), intent(inout) :: this
    class(meshfield3d), intent(in) :: pres_hyd
    class(meshfield3d), intent(in) :: pres_hyd_ref
    class(meshbase3d), intent(in), target :: mesh3d
    class(elementoperationbase3d), intent(in) :: element_operation
    
    integer :: n
    class(localmesh3d), pointer :: lcmesh3d
    !---------------------------
 
    do n=1, mesh3d%LOCAL_MESH_NUM
      lcmesh3d => mesh3d%lcmesh_list(n)
      !$acc update host( PRES_hyd%local(n)%val, PRES_hyd_ref%local(n)%val )
      
      call atm_dyn_dgm_nonhydro3d_common_calc_phyd_hgrad_lc( &
        this%AUX_DYNVARS3D(auxdynvars3d_dphyddx_id)%local(n)%val, & ! (out)
        this%AUX_DYNVARS3D(auxdynvars3d_dphyddy_id)%local(n)%val, & ! (out)
        pres_hyd%local(n)%val, pres_hyd_ref%local(n)%val,         & ! (in)
        element_operation, lcmesh3d, lcmesh3d%refElem3D           ) ! (in)
 
      !$acc update device( this%AUX_DYNVARS3D(AUXDYNVARS3D_DPhydDx_ID)%local(n)%val, &
      !$acc                this%AUX_DYNVARS3D(AUXDYNVARS3D_DPhydDy_ID)%local(n)%val  )
    end do
 
    return
  end subroutine atmdyndgmdriver_nonhydro3d_update_phyd_hgrad
 
!----- private --------------------------------------
 
!OCL SERIAL
  subroutine add_phy_tend( this, & ! (in)
    dyn_tends,                                           & ! (inout)
    dens_tp, momx_tp, momy_tp, momz_tp, rhot_tp, rhoh_p, & !(in)
    pres, rtot, cptot,                                   & ! (in)
    domid, lcmesh, elem3d                                ) ! (in)
 
    implicit none
 
    class(atmdyndgmdriver_nonhydro3d), intent(inout) :: this
    class(localmesh3d), intent(in) :: lcmesh
    class(elementbase3d), intent(in) :: elem3d
    real(rp), intent(inout) :: dyn_tends(elem3d%np,lcmesh%nea,prgvar_num)
    real(rp), intent(in) :: dens_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: momx_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: momy_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: momz_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: rhot_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: rhoh_p (elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: pres(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: rtot(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: cptot(elem3d%np,lcmesh%nea)
    integer, intent(in) :: domid
 
    integer :: ke, p
    real(rp) :: exner(elem3d%np)
    real(rp) :: exner_
    real(rp) :: rp0
    !---------------------------------------------------------------------------------
 
    rp0   = 1.0_rp / pres00
 
    !$omp parallel private( EXNER, ke )
    !$acc parallel loop gang present( dyn_tends, DENS_tp, MOMX_tp, MOMY_tp, MOMZ_tp, lcmesh,elem3D)
    !$omp do
    do ke=lcmesh%NeS, lcmesh%NeE
      !$acc loop vector
      do p=1, elem3d%Np
        dyn_tends(p,ke,dens_vid) = dyn_tends(p,ke,dens_vid) + dens_tp(p,ke)
        dyn_tends(p,ke,momz_vid) = dyn_tends(p,ke,momz_vid) + momz_tp(p,ke)
        dyn_tends(p,ke,momx_vid) = dyn_tends(p,ke,momx_vid) + momx_tp(p,ke)
        dyn_tends(p,ke,momy_vid) = dyn_tends(p,ke,momy_vid) + momy_tp(p,ke)
      end do
    end do
    !$omp end do
 
    if ( this%ENTOT_CONSERVE_SCHEME_FLAG ) then
      !$omp do
      do ke=lcmesh%NeS, lcmesh%NeE
        exner(:) = ( pres(:,ke) * rp0 )**( rtot(:,ke) / cptot(:,ke) )
 
        dyn_tends(:,ke,therm_vid) = dyn_tends(:,ke,therm_vid) &
                                        + rhoh_p(:,ke)                             &
                                        + ( cptot(:,ke) * exner(:) ) * rhot_tp(:,ke)
      end do
      !$omp end do
    else
      !$omp do
      !$acc parallel loop gang present( dyn_tends, RHOT_tp, RHOH_p, PRES, Rtot, CPtot, lcmesh,elem3D)
      do ke=lcmesh%NeS, lcmesh%NeE
#ifdef _OPENACC
        !$acc loop vector
        do p=1, elem3d%Np
          exner_ = ( pres(p,ke) * rp0 )**( rtot(p,ke) / cptot(p,ke) )
 
          dyn_tends(p,ke,therm_vid) = dyn_tends(p,ke,therm_vid) &
                                        + rhot_tp(p,ke)                           &
                                        + rhoh_p(p,ke) / ( cptot(p,ke) * exner_ )
        end do
#else        
        exner(:) = ( pres(:,ke) * rp0 )**( rtot(:,ke) / cptot(:,ke) )
 
        dyn_tends(:,ke,therm_vid) = dyn_tends(:,ke,therm_vid) &
                                       + rhot_tp(:,ke)                             &
                                       + rhoh_p(:,ke) / ( cptot(:,ke) * exner(:) )
#endif
      end do
      !$omp end do
    end if
    !$omp end parallel
    return
  end subroutine add_phy_tend
 
!OCL SERIAL
  subroutine add_phy_tend_new( this, & ! (in)
    dyn_tends,                                           & ! (inout)
    dens_tp, momx_tp, momy_tp, momz_tp, rhot_tp, rhoh_p, & !(in)
    pres, rtot, cptot,                                   & ! (in)
    domid, lcmesh, elem3d                                ) ! (in)
 
    implicit none
 
    class(atmdyndgmdriver_nonhydro3d), intent(inout) :: this
    class(localmesh3d), intent(in) :: lcmesh
    class(elementbase3d), intent(in) :: elem3d
    real(rp), intent(inout) :: dyn_tends(elem3d%np,lcmesh%nea,prgvar_num)
    real(rp), intent(in) :: dens_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: momx_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: momy_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: momz_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: rhot_tp(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: rhoh_p (elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: pres(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: rtot(elem3d%np,lcmesh%nea)
    real(rp), intent(in) :: cptot(elem3d%np,lcmesh%nea)
    integer, intent(in) :: domid
 
    integer :: ke
    real(rp) :: exner(elem3d%np)
    real(rp) :: rp0
    !---------------------------------------------------------------------------------
 
    rp0   = 1.0_rp / pres00
 
    !$omp parallel private( EXNER, ke )
    
    !$omp do
    do ke=lcmesh%NeS, lcmesh%NeE
      dyn_tends(:,ke,dens_vid) = dyn_tends(:,ke,dens_vid) + dens_tp(:,ke)
      dyn_tends(:,ke,momz_vid) = dyn_tends(:,ke,momz_vid) + momz_tp(:,ke)
      dyn_tends(:,ke,momx_vid) = dyn_tends(:,ke,momx_vid) + momx_tp(:,ke)
      dyn_tends(:,ke,momy_vid) = dyn_tends(:,ke,momy_vid) + momy_tp(:,ke)
    end do
    !$omp end do
 
    if ( this%ENTOT_CONSERVE_SCHEME_FLAG ) then
      !$omp do
      do ke=lcmesh%NeS, lcmesh%NeE
        exner(:) = ( pres(:,ke) * rp0 )**( rtot(:,ke) / cptot(:,ke) )
 
        dyn_tends(:,ke,therm_vid) = dyn_tends(:,ke,therm_vid) &
                                        + rhoh_p(:,ke)                             &
                                        + ( cptot(:,ke) * exner(:) ) * rhot_tp(:,ke)
      end do
      !$omp end do
    else
      !$omp do
      do ke=lcmesh%NeS, lcmesh%NeE
        exner(:) = ( pres(:,ke) * rp0 )**( rtot(:,ke) / cptot(:,ke) )
 
        dyn_tends(:,ke,therm_vid) = dyn_tends(:,ke,therm_vid) &
                                       + rhot_tp(:,ke)                             &
                                       + rhoh_p(:,ke) / ( cptot(:,ke) * exner(:) )
      end do
      !$omp end do
    end if
    !$omp end parallel
    return
  end subroutine add_phy_tend_new
 
  !-- Setup modal filter
!OCL SERIAL
  subroutine setup_modalfilter( this, refElem3D, element_operation )
    use scale_element_line, only: lineelement
    implicit none
 
    class(atmdyndgmdriver_nonhydro3d), target, intent(inout) :: this
    class(hexahedralelement), target, intent(in) :: refelem3d
    class(elementoperationbase3d), intent(inout) :: element_operation
 
    real(rp) :: mf_etac_h  = 2.0_rp/3.0_rp
    real(rp) :: mf_alpha_h = 36.0_rp
    integer  :: mf_order_h = 16
    real(rp) :: mf_etac_v  = 2.0_rp/3.0_rp
    real(rp) :: mf_alpha_v = 36.0_rp
    integer  :: mf_order_v = 16
 
    namelist /param_atmos_dyn_modalfilter/ &
      mf_etac_h, mf_alpha_h, mf_order_h,   &
      mf_etac_v, mf_alpha_v, mf_order_v
    
    integer :: ierr
 
    type(lineelement) :: elemv1d
    !---------------------------------------------------------------
 
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_atmos_dyn_modalfilter,iostat=ierr)
    if( ierr < 0 ) then !--- missing
      log_info("ATMOS_DYN_setup_modalfilter",*) 'Not found namelist. Default used.'
    elseif( ierr > 0 ) then !--- fatal error
      log_error("ATMOS_DYN_setup_modalfilter",*) 'Invalid names in namelist PARAM_ATMOS_DYN_MODALFILTER. Check!'
      call prc_abort
    endif
 
    log_nml(param_atmos_dyn_modalfilter)
 
    call this%modal_filter_3d%Init( &
      refelem3d,                           & ! (in)
      mf_etac_h, mf_alpha_h, mf_order_h,   & ! (in)
      mf_etac_v, mf_alpha_v, mf_order_v    ) ! (in)
 
    call element_operation%Setup_ModalFilter( &
      mf_etac_h, mf_alpha_h, mf_order_h,   & ! (in)
      mf_etac_v, mf_alpha_v, mf_order_v    ) ! (in)
 
    return
  end subroutine setup_modalfilter
 
end module scale_atm_dyn_dgm_driver_nonhydro3d