mod_atmos_phy_preproc.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!> module Atmosphere / Physics / Preprocessing
!!
!! @par Description
!!          A module to provide preprocessing operations for variables before evaluating physics tendencies
!!
!! @author Yuta Kawai, Team SCALE
!!
!<
!-------------------------------------------------------------------------------
#include "scaleFElib.h"
module mod_atmos_phy_preproc
  !-----------------------------------------------------------------------------
  !
  !++ Used modules
  !
  use scale_precision
  use scale_io
  use scale_prc
  use scale_tracer, only: qa
 
  use scale_element_base, only: &
    elementbase2d, elementbase3d
  use scale_localmesh_2d, only: localmesh2d
  use scale_localmesh_3d, only: localmesh3d
  use scale_localmeshfield_base, only: &
    localmeshfieldbase, localmeshfieldbaselist
  use scale_mesh_base2d, only: meshbase2d
  use scale_mesh_base3d, only: meshbase3d
 
  use scale_meshfield_base, only: &
    meshfield2d, meshfield3d
 
  use scale_atm_dyn_dgm_nonhydro3d_common, only: &
    prgvar_num, auxvar_num, phytend_num1 => phytend_num,                                        &
    prgvar_ddens_id, prgvar_therm_id, prgvar_momz_id, prgvar_momx_id, prgvar_momy_id,           &
    auxvar_denshydro_id, auxvar_preshydro_id, auxvar_thermhydro_id, auxvar_preshydro_ref_id,    &
    auxvar_rtot_id, auxvar_cptot_id, auxvar_cvtot_id,                                           &
    auxvar_pres_id, auxvar_pt_id, auxvar_qdry_id,                                               &
    phytend_dens_id, phytend_momx_id, phytend_momy_id, phytend_momz_id, phytend_rhot_id,        &
    phytend_rhoh_id
 
  use scale_element_modalfilter, only: modalfilter
  use scale_meshfield_filter_operation_3d, only: meshfieldfilteroperation3d  
 
  use scale_element_operation_tensorprod3d, only: &
    elementoperationtensorprod3d, &
    elementoperationtensorprod3d_create
 
  !-----------------------------------------------------------------------------
  implicit none
  private
 
  !-----------------------------------------------------------------------------
  !
  !++ Public type & procedures
  !
 
  !> Base type for preprocessing operations for variables before evaluating physics tendencies
  type, abstract, public :: physpreprocbase
    class(meshbase3d), pointer :: mesh3d
  contains
    procedure(physpreprocmodalbase_operate), public, deferred :: operate
    procedure(physpreprocmodalbase_final), public, deferred :: final
  end type physpreprocbase
  abstract interface 
    subroutine physpreprocmodalbase_operate( this, &
      PRG_VARS, QTRC_VARS, AUX_VARS,    &
      PRG_VARS0, QTRC_VARS0, AUX_VARS0  )
      import physpreprocbase
      import meshfield3d
      import prgvar_num
      import auxvar_num
      import qa
      class(physpreprocbase), intent(inout) :: this
      type(meshfield3d), intent(inout) :: PRG_VARS(PRGVAR_NUM)
      type(meshfield3d), intent(inout) :: AUX_VARS(AUXVAR_NUM)
      type(meshfield3d), intent(inout) :: QTRC_VARS(0:QA)
      type(meshfield3d), intent(in) :: PRG_VARS0(PRGVAR_NUM)
      type(meshfield3d), intent(in) :: AUX_VARS0(AUXVAR_NUM)
      type(meshfield3d), intent(in) :: QTRC_VARS0(0:QA)
    end subroutine physpreprocmodalbase_operate
 
    subroutine physpreprocmodalbase_final( this )
      import physpreprocbase
      class(physpreprocbase), intent(inout) :: this
    end subroutine physpreprocmodalbase_final
  end interface
 
  !> Derived type to represent no preprocessing operation for variables before evaluating physics tendencies  
  type, extends(physpreprocbase), public :: physpreprocnone
  contains
    procedure :: init => physpreprocnone_init
    procedure :: final => physpreprocnone_final
    procedure :: operate => physpreprocnone_operate
  end type physpreprocnone
 
  !> Derived type to represent modal filtering operation for variables before evaluating physics tendencies
  type, extends(physpreprocbase), public :: physpreprocmodalfilter
    type(modalfilter) :: mfilter
    class(elementoperationtensorprod3d), allocatable :: elem_optr
  contains
    procedure :: init => physpreprocmodalfilter_init
    procedure :: final => physpreprocmodalfilter_final
    procedure :: operate => physpreprocmodalfilter_operate
  end type physpreprocmodalfilter
 
  !> Derived type to represent quasi-global filtering operation for variables before evaluating physics tendencies
  type, extends(physpreprocbase), public :: physpreprocglobalfilter
    type(meshfieldfilteroperation3d) :: gfilter_prgvar
    type(meshfieldfilteroperation3d) :: gfilter_trcvar
    type(meshfield3d), allocatable :: rhoq(:)
  contains
    procedure :: init => physpreprocglobalfilter_init
    procedure :: final => physpreprocglobalfilter_final
    procedure :: operate => physpreprocglobalfilter_operate
  end type physpreprocglobalfilter
 
  
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private procedures & variables
  !
contains
!--
  !> Initialize an object to represent no preprocessing operation before evaluating physics tendencies
!OCL SERIAL
  subroutine physpreprocnone_init( this, mesh3D )
    implicit none
    class(physpreprocnone), intent(inout) :: this
    class(meshbase3d), intent(in), target :: mesh3D
    !----------------------------------------------------
    this%mesh3D => mesh3d
    return
  end subroutine physpreprocnone_init
 
  !> Finalize an object to represent no preprocessing operation before evaluating physics tendencies
!OCL SERIAL
  subroutine physpreprocnone_final( this )
    implicit none
    class(physpreprocnone), intent(inout) :: this
    !----------------------------------------------------
    return
  end subroutine physpreprocnone_final  
 
  !> Perform no preprocessing operation before evaluating physics tendencies
  !! This subroutine simply copies the input variables to the output variables without any modification.
!OCL SERIAL
  subroutine physpreprocnone_operate( this, &
    PRG_VARS, QTRC_VARS, AUX_VARS,    &
    PRG_VARS0, QTRC_VARS0, AUX_VARS0  )
    use scale_tracer, only: qa
    implicit none
    class(physpreprocnone), intent(inout) :: this
    type(meshfield3d), intent(inout) :: PRG_VARS(PRGVAR_NUM)
    type(meshfield3d), intent(inout) :: AUX_VARS(AUXVAR_NUM)
    type(meshfield3d), intent(inout) :: QTRC_VARS(0:QA)
    type(meshfield3d), intent(in) :: PRG_VARS0(PRGVAR_NUM)
    type(meshfield3d), intent(in) :: AUX_VARS0(AUXVAR_NUM)
    type(meshfield3d), intent(in) :: QTRC_VARS0(0:QA)
 
    integer :: n
    integer :: iq, iqs
    !----------------------------------------------------
 
    do n=1, this%mesh3D%LOCAL_MESH_NUM
      call copy_data( &
        prg_vars(prgvar_ddens_id)%local(n)%val, prg_vars(prgvar_momx_id)%local(n)%val, prg_vars(prgvar_momy_id)%local(n)%val, prg_vars(prgvar_momz_id)%local(n)%val, prg_vars(prgvar_therm_id)%local(n)%val,      & ! (inout)
        aux_vars(auxvar_denshydro_id)%local(n)%val, aux_vars(auxvar_preshydro_id)%local(n)%val,                                                                                                                   & ! (inout)
        prg_vars0(prgvar_ddens_id)%local(n)%val, prg_vars0(prgvar_momx_id)%local(n)%val, prg_vars0(prgvar_momy_id)%local(n)%val, prg_vars0(prgvar_momz_id)%local(n)%val, prg_vars0(prgvar_therm_id)%local(n)%val, & ! (in)
        aux_vars0(auxvar_denshydro_id)%local(n)%val, aux_vars0(auxvar_preshydro_id)%local(n)%val,                                                                                                                 & ! (in)
        this%mesh3D%lcmesh_list(n), this%mesh3D%refElem3D ) ! (in)
    end do
 
    if ( qa == 0 ) then
      iqs = 0
    else
      iqs = 1
    end if
    do iq=iqs, qa
      do n=1, this%mesh3D%LOCAL_MESH_NUM
        call copy_data_qtrc( qtrc_vars(iq)%local(n)%val,                                                                   & ! (inout)
          qtrc_vars0(iq)%local(n)%val, aux_vars(auxvar_denshydro_id)%local(n)%val, prg_vars(prgvar_ddens_id)%local(n)%val, & ! (in)
          this%mesh3D%lcmesh_list(n), this%mesh3D%refElem3D ) ! (in)
      end do
    end do
    return
  end subroutine physpreprocnone_operate
 
!--------------------------------------------
  !> Initialize an object to represent modal filtering operation before evaluating physics tendencies
!OCL SERIAL
  subroutine physpreprocmodalfilter_init( this,     &
    MF_ALPHA_h, MF_ORDER_h, MF_ALPHA_v, MF_ORDER_v, &
    mesh3D )
    implicit none
    class(physpreprocmodalfilter), intent(inout) :: this
    real(RP), intent(in) :: MF_ALPHA_h
    integer, intent(in) :: MF_ORDER_h
    real(RP), intent(in) :: MF_ALPHA_v
    integer, intent(in) :: MF_ORDER_v
    class(meshbase3d), intent(in), target :: mesh3D
    !----------------------------------------------------
 
    this%mesh3D => mesh3d
 
    call elementoperationtensorprod3d_create( mesh3d%refElem3D, &
        this%elem_optr )
    
    call this%elem_optr%Setup_ModalFilter( 0.0_rp, mf_alpha_h, mf_order_h, 0.0_rp, mf_alpha_v, mf_order_v )
    call this%elem_optr%Setup_ModalFilter_tracer( 0.0_rp, mf_alpha_h, mf_order_h, 0.0_rp, mf_alpha_v, mf_order_v )    
    return
  end subroutine physpreprocmodalfilter_init
 
  !> Finalize an object to represent modal filtering operation before evaluating physics tendencies
!OCL SERIAL
  subroutine physpreprocmodalfilter_final( this )
    use scale_element_hexahedral, only: hexahedralelement
    implicit none
    class(physpreprocmodalfilter), intent(inout) :: this
    !----------------------------------------------------
 
    call this%mfilter%Final()
    
    call this%elem_optr%Final()
    deallocate( this%elem_optr )
    return
  end subroutine physpreprocmodalfilter_final  
 
  !> Perform modal filtering operation before evaluating physics tendencies
!OCL SERIAL
  subroutine physpreprocmodalfilter_operate( this, &
    PRG_VARS, QTRC_VARS, AUX_VARS,    &
    PRG_VARS0, QTRC_VARS0, AUX_VARS0  )
    use scale_element_hexahedral, only: hexahedralelement
    use scale_tracer, only: qa
    implicit none
    class(physpreprocmodalfilter), intent(inout) :: this
    type(meshfield3d), intent(inout) :: PRG_VARS(PRGVAR_NUM)
    type(meshfield3d), intent(inout) :: AUX_VARS(AUXVAR_NUM)
    type(meshfield3d), intent(inout) :: QTRC_VARS(0:QA)
    type(meshfield3d), intent(in) :: PRG_VARS0(PRGVAR_NUM)
    type(meshfield3d), intent(in) :: AUX_VARS0(AUXVAR_NUM)
    type(meshfield3d), intent(in) :: QTRC_VARS0(0:QA)
 
    integer :: n
    integer :: iq, iqs
    !----------------------------------------------------
 
    do n=1, this%mesh3D%LOCAL_MESH_NUM
      call apply_modal_filter_core( &
        prg_vars(prgvar_ddens_id)%local(n)%val, prg_vars(prgvar_momx_id)%local(n)%val, prg_vars(prgvar_momy_id)%local(n)%val, prg_vars(prgvar_momz_id)%local(n)%val, prg_vars(prgvar_therm_id)%local(n)%val,      & ! (inout)
        aux_vars(auxvar_denshydro_id)%local(n)%val, aux_vars(auxvar_preshydro_id)%local(n)%val,                                                                                                                   & ! (inout)
        prg_vars0(prgvar_ddens_id)%local(n)%val, prg_vars0(prgvar_momx_id)%local(n)%val, prg_vars0(prgvar_momy_id)%local(n)%val, prg_vars0(prgvar_momz_id)%local(n)%val, prg_vars0(prgvar_therm_id)%local(n)%val, & ! (in)
        aux_vars0(auxvar_denshydro_id)%local(n)%val, aux_vars0(auxvar_preshydro_id)%local(n)%val,                                                                                                                 & ! (in)
        this%elem_optr, this%mesh3D%lcmesh_list(n), this%mesh3D%refElem3D ) ! (in)
    end do
 
    if ( qa == 0 ) then
      iqs = 0
    else
      iqs = 1
    end if
    do iq=iqs, qa
      do n=1, this%mesh3D%LOCAL_MESH_NUM
        call apply_modal_filter_qtrc_core( qtrc_vars(iq)%local(n)%val,                                                     & ! (inout)
          qtrc_vars0(iq)%local(n)%val, aux_vars(auxvar_denshydro_id)%local(n)%val, prg_vars(prgvar_ddens_id)%local(n)%val, & ! (in)
          this%elem_optr, this%mesh3D%lcmesh_list(n), this%mesh3D%refElem3D ) ! (in)
      end do
    end do
    return
  end subroutine physpreprocmodalfilter_operate
 
!-- 
  !> Initialize an object to represent quasi-global filtering operation before evaluating physics tendencies
!OCL SERIAL
  subroutine physpreprocglobalfilter_init( this, &
    GLFilterOptrType, GLFilterShape, GLFilterWidthFac,  &
    Nnode_h1D_reconst, &
    mesh3D )
    implicit none
    class(physpreprocglobalfilter), intent(inout) :: this
    character(len=*), intent(in) :: GLFilterOptrType
    character(len=*), intent(in) :: GLFilterShape
    real(RP), intent(in) :: GLFilterWidthFac
    integer, intent(in) :: Nnode_h1D_reconst
    class(meshbase3d), intent(in), target :: mesh3D
 
    integer :: iq
    character(len=H_SHORT) :: varname
    !----------------------------------------------------
    
    this%mesh3D => mesh3d
    
    call this%gFilter_prgvar%Init( glfilteroptrtype, glfiltershape, glfilterwidthfac, nnode_h1d_reconst, &
      prgvar_num, 0, 0, mesh3d )
    call this%gFilter_trcvar%Init( glfilteroptrtype, glfiltershape, glfilterwidthfac, nnode_h1d_reconst, &
      max(1,qa), 0, 0, mesh3d )
    
    allocate( this%RHOQ(0:qa) )
    do iq=0, qa
      write(varname,'(a,I2.2)') 'RHOQ', iq
      call this%RHOQ(iq)%Init( trim(varname), "kg/m3", mesh3d )
    end do
    return
  end subroutine physpreprocglobalfilter_init
 
  !> Finalize an object to represent quasi-global filtering operation before evaluating physics tendencies
!OCL SERIAL
  subroutine physpreprocglobalfilter_final( this )
    use scale_element_hexahedral, only: hexahedralelement
    implicit none
    class(physpreprocglobalfilter), intent(inout) :: this
 
    integer :: iq
    !----------------------------------------------------
    call this%gFilter_prgvar%Final()
    call this%gFilter_trcvar%Final()
 
    do iq=0, qa
      call this%RHOQ(iq)%Final()
    end do
    deallocate( this%RHOQ )
    return
  end subroutine physpreprocglobalfilter_final  
 
  !> Perform quasi-global filtering operation before evaluating physics tendencies
!OCL SERIAL
  subroutine physpreprocglobalfilter_operate( this, &
    PRG_VARS, QTRC_VARS, AUX_VARS,   &
    PRG_VARS0, QTRC_VARS0, AUX_VARS0 )
    use scale_element_hexahedral, only: hexahedralelement
    use scale_tracer, only: qa
    implicit none
    class(physpreprocglobalfilter), intent(inout) :: this
    type(meshfield3d), intent(inout) :: PRG_VARS(PRGVAR_NUM)
    type(meshfield3d), intent(inout) :: AUX_VARS(AUXVAR_NUM)
    type(meshfield3d), intent(inout) :: QTRC_VARS(0:QA)
    type(meshfield3d), intent(in) :: PRG_VARS0(PRGVAR_NUM)
    type(meshfield3d), intent(in) :: AUX_VARS0(AUXVAR_NUM)
    type(meshfield3d), intent(in) :: QTRC_VARS0(0:QA)
 
    integer :: n
    integer :: iq, iqs
    !----------------------------------------------------
 
    do n=1, this%mesh3D%LOCAL_MESH_NUM
      call copy_data( &
        prg_vars(prgvar_ddens_id)%local(n)%val, prg_vars(prgvar_momx_id)%local(n)%val, prg_vars(prgvar_momy_id)%local(n)%val, prg_vars(prgvar_momz_id)%local(n)%val, prg_vars(prgvar_therm_id)%local(n)%val,      & ! (inout)
        aux_vars(auxvar_denshydro_id)%local(n)%val, aux_vars(auxvar_preshydro_id)%local(n)%val,                                                                                                                   & ! (inout)
        prg_vars0(prgvar_ddens_id)%local(n)%val, prg_vars0(prgvar_momx_id)%local(n)%val, prg_vars0(prgvar_momy_id)%local(n)%val, prg_vars0(prgvar_momz_id)%local(n)%val, prg_vars0(prgvar_therm_id)%local(n)%val, & ! (in)
        aux_vars0(auxvar_denshydro_id)%local(n)%val, aux_vars0(auxvar_preshydro_id)%local(n)%val,                                                                                                                 & ! (in)
        this%mesh3D%lcmesh_list(n), this%mesh3D%refElem3D ) ! (in)
    end do
 
    call this%gFilter_prgvar%Apply( prg_vars, this%mesh3D )
 
    if ( qa == 0 ) then
      iqs = 0
    else
      iqs = 1
    end if
    do iq=iqs, qa
      do n=1, this%mesh3D%LOCAL_MESH_NUM
        call calc_data_rhoq( this%RHOQ(iq)%local(n)%val,                                                                    & ! (inout)
          qtrc_vars0(iq)%local(n)%val, aux_vars(auxvar_denshydro_id)%local(n)%val, prg_vars0(prgvar_ddens_id)%local(n)%val, & ! (in)
          this%mesh3D%lcmesh_list(n), this%mesh3D%refElem3D ) ! (in)
      end do
    end do
 
    call this%gFilter_trcvar%Apply( this%RHOQ(iqs:qa), this%mesh3D )
 
    do iq=iqs, qa
      do n=1, this%mesh3D%LOCAL_MESH_NUM
        call calc_data_rhoq2qtrc( qtrc_vars(iq)%local(n)%val,                                                             & ! (inout)
          this%RHOQ(iq)%local(n)%val, aux_vars(auxvar_denshydro_id)%local(n)%val, prg_vars(prgvar_ddens_id)%local(n)%val, & ! (in)
          this%mesh3D%lcmesh_list(n), this%mesh3D%refElem3D ) ! (in)
      end do
    end do
 
    return
  end subroutine physpreprocglobalfilter_operate
 
!-- private --------------------------------
!OCL SERIAL  
  subroutine copy_data( &
    DDENS, MOMX, MOMY, MOMZ, THERM, DENS_hyd, PRES_hyd, &
    DDENS0, MOMX0, MOMY0, MOMZ0, THERM0, DENS_hyd0, PRES_hyd0, &
    lmesh, elem )
    implicit none
    class(localmesh3d), intent(in) :: lmesh
    class(elementbase3d), intent(in) :: elem
    real(RP), intent(out) :: DDENS(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: MOMX(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: MOMY(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: MOMZ(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: THERM(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: DENS_hyd(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: 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) :: DENS_hyd0(elem%Np,lmesh%NeA)
    real(RP), intent(in) :: PRES_hyd0(elem%Np,lmesh%NeA)
 
    integer :: ke
    !--------------------------------------------------
 
    !$omp parallel do private(ke)
    do ke=lmesh%NeS, lmesh%NeE
      ddens(:,ke) = ddens0(:,ke)
      momx(:,ke) = momx0(:,ke)
      momy(:,ke) = momy0(:,ke)
      momz(:,ke) = momz0(:,ke)
      therm(:,ke) = therm0(:,ke)
 
      dens_hyd(:,ke) = dens_hyd0(:,ke)
      pres_hyd(:,ke) = pres_hyd0(:,ke)
    end do    
    return
  end subroutine copy_data
!OCL SERIAL  
  subroutine copy_data_qtrc( QTRC, &
    QTRC0, DENS_hyd, DDENS, &
    lmesh, elem             )
    implicit none
    class(localmesh3d), intent(in) :: lmesh
    class(elementbase3d), intent(in) :: elem
    real(RP), intent(inout)  :: QTRC(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: QTRC0(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DENS_hyd(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DDENS(elem%Np,lmesh%NeA)
 
    integer :: ke
    !--------------------------------------------------
 
    !$omp parallel do private(ke)
    do ke=lmesh%NeS, lmesh%NeE
      qtrc(:,ke) = qtrc0(:,ke)
    end do    
    return
  end subroutine copy_data_qtrc
 
!OCL SERIAL  
  subroutine calc_data_rhoq( RHOQ, &
    QTRC0, DENS_hyd, DDENS0, &
    lmesh, elem              )
    implicit none
    class(localmesh3d), intent(in) :: lmesh
    class(elementbase3d), intent(in) :: elem
    real(RP), intent(inout)  :: RHOQ(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: QTRC0(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DENS_hyd(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DDENS0(elem%Np,lmesh%NeA)
 
    integer :: ke
    !--------------------------------------------------
 
    !$omp parallel do private(ke)
    do ke=lmesh%NeS, lmesh%NeE
      rhoq(:,ke) = qtrc0(:,ke) * ( ddens0(:,ke) + dens_hyd(:,ke) )
    end do
    return
  end subroutine calc_data_rhoq
 
!OCL SERIAL  
  subroutine calc_data_rhoq2qtrc( QTRC, &
    RHOQ0, DENS_hyd, DDENS0, &
    lmesh, elem              )
    implicit none
    class(localmesh3d), intent(in) :: lmesh
    class(elementbase3d), intent(in) :: elem
    real(RP), intent(inout)  :: QTRC(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: RHOQ0(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DENS_hyd(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DDENS0(elem%Np,lmesh%NeA)
 
    integer :: ke
    !--------------------------------------------------
 
    !$omp parallel do private(ke)
    do ke=lmesh%NeS, lmesh%NeE
      qtrc(:,ke) = rhoq0(:,ke) / ( ddens0(:,ke) + dens_hyd(:,ke) )
    end do
    return
  end subroutine calc_data_rhoq2qtrc
 
!-
!OCL SERIAL  
  subroutine apply_modal_filter_core( &
    DDENS, MOMX, MOMY, MOMZ, THERM, DENS_hyd, PRES_hyd, &
    DDENS0, MOMX0, MOMY0, MOMZ0, THERM0, DENS_hyd0, PRES_hyd0, &
    elem_optr, lmesh, elem )
    use scale_atm_dyn_dgm_modalfilter, only: &
        atm_dyn_dgm_modalfilter_apply
    implicit none
    class(localmesh3d), intent(in) :: lmesh
    class(elementbase3d), intent(in) :: elem
    real(RP), intent(out) :: DDENS(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: MOMX(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: MOMY(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: MOMZ(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: THERM(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: DENS_hyd(elem%Np,lmesh%NeA)
    real(RP), intent(out) :: 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) :: DENS_hyd0(elem%Np,lmesh%NeA)
    real(RP), intent(in) :: PRES_hyd0(elem%Np,lmesh%NeA)
    class(elementoperationtensorprod3d), intent(in) :: elem_optr
 
    integer :: ke
    !--------------------------------------------------
 
    !$omp parallel do private(ke)
    do ke=lmesh%NeS, lmesh%NeE
      ddens(:,ke) = ddens0(:,ke)
      momx(:,ke) = momx0(:,ke)
      momy(:,ke) = momy0(:,ke)
      momz(:,ke) = momz0(:,ke)
      therm(:,ke) = therm0(:,ke)
 
      dens_hyd(:,ke) = dens_hyd0(:,ke)
      pres_hyd(:,ke) = pres_hyd0(:,ke)
    end do    
    call atm_dyn_dgm_modalfilter_apply( ddens, momx, momy, momz, therm, &
        lmesh, elem, elem_optr, .true. )
    return
  end subroutine apply_modal_filter_core
 
!OCL SERIAL  
  subroutine apply_modal_filter_qtrc_core( QTRC, &
    QTRC0, DENS_hyd, DDENS, &
    elem_optr, lmesh, elem  )
    use scale_atm_dyn_dgm_modalfilter, only: &
        atm_dyn_dgm_tracer_modalfilter_apply
    implicit none
    class(localmesh3d), intent(in) :: lmesh
    class(elementbase3d), intent(in) :: elem
    real(RP), intent(inout)  :: QTRC(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: QTRC0(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DENS_hyd(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DDENS(elem%Np,lmesh%NeA)
    class(elementoperationtensorprod3d), intent(in) :: elem_optr
 
    integer :: ke
    !--------------------------------------------------
 
    !$omp parallel do private(ke)
    do ke=lmesh%NeS, lmesh%NeE
      qtrc(:,ke) = qtrc0(:,ke)
    end do    
    call atm_dyn_dgm_tracer_modalfilter_apply( qtrc, & ! (inout)
      dens_hyd, ddens, ddens, lmesh, elem, elem_optr ) ! (in)
    return
  end subroutine apply_modal_filter_qtrc_core
end module mod_atmos_phy_preproc