mod_atmos_phy_tb.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!> module Atmosphere / Physics / sub-grid scale turbulence process
!!
!! @par Description
!!          Module for sub-grid scale turbulence process
!!
!! @author Yuta Kawai, Team SCALE
!!
!<
!-------------------------------------------------------------------------------
#include "scaleFElib.h"
module mod_atmos_phy_tb
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !  
  use scale_precision
  use scale_prc
  use scale_io
  use scale_prof
  use scale_const, only: &
    undef8 => const_undef8
  use scale_tracer, only: qa
 
  use scale_mesh_base, only: meshbase
  use scale_mesh_base2d, only: meshbase2d
  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_meshfield_base, only: meshfieldbase
  use scale_localmeshfield_base, only: &
    localmeshfieldbase, localmeshfieldbaselist
 
  use scale_model_mesh_manager, only: modelmeshbase
  use scale_model_var_manager, only: modelvarmanager
  use scale_model_component_proc, only:  modelcomponentproc
 
  use scale_atm_dyn_dgm_bnd, only: atmdynbnd
  
  use scale_atm_phy_tb_dgm_driver, only: &
    atmphytbdgmdriver
  use mod_atmos_phy_tb_vars, only: atmosphytbvars
 
  use scale_element_modalfilter, only: modalfilter
  use scale_meshfield_filter_operation_3d, only: &
    meshfieldfilteroperation3d  
    
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public type & procedure
  !
 
  !> Derived type to manage a component of sub-grid scale turbulent process
  !!
  type, extends(modelcomponentproc), public :: atmosphytb
    integer :: tb_typeid                  !< Type ID of SGS turbulent scheme
    type(atmphytbdgmdriver) :: tb_driver  !< Object to represent a driver for SGS turbulent schemes
 
    type(atmosphytbvars) :: vars          !< Object to manage variables with SGS turbulent model
    type(atmdynbnd), pointer :: dyn_bnd   !< Pointer to object for treating boundary conditions with atmospheric dynamics  
 
    logical :: gfilter_flag                            !< Flag to specify whether quasi-global filter is applied for SGS eddy viscosity and diffusivity
    type(meshfieldfilteroperation3d) :: gfilter_phy_tb !< Quasi-global filter for SGS eddy viscosity and diffusivity
 
    logical :: modalfilter_flag          !< Flag to specify whether modal filter is applied for SGS eddy viscosity and diffusivity
    type(modalfilter) :: modalfilter_3d  !< Modal filter for SGS eddy viscosity and diffusivity
  contains
    procedure, public :: setup => atmosphytb_setup 
    procedure, public :: calc_tendency => atmosphytb_calc_tendency
    procedure, public :: update => atmosphytb_update
    procedure, public :: finalize => atmosphytb_finalize
    procedure, public :: setdynbc => atmosphytb_setdynbc
  end type atmosphytb
 
  !-----------------------------------------------------------------------------
  !++ Public parameters & variables
  !-----------------------------------------------------------------------------
 
  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  !-----------------------------------------------------------------------------
    
contains
!> Setup a component of SGS turbulence process
!!
!! @param model_mesh Object to manage computational mesh of atmospheric model 
!! @param tm_parent_comp Object to mange a temporal scheme in a parent component
!!
!OCL SERIAL
  subroutine atmosphytb_setup( this, model_mesh, tm_parent_comp )
    use mod_atmos_mesh, only: atmosmesh
    use scale_time_manager, only: time_manager_component
    use scale_element_hexahedral, only: hexahedralelement
 
    implicit none
    class(atmosphytb), intent(inout) :: this
    class(modelmeshbase), target, intent(in) :: model_mesh
    class(time_manager_component), intent(inout) :: tm_parent_comp
 
    real(DP) :: TIME_DT                             = undef8  !< Timestep for sub-grid scale turbulent process
    character(len=H_SHORT) :: TIME_DT_UNIT          = 'SEC'   !< Unit of timestep
 
    character(len=H_MID) :: TB_TYPE = 'SMAGORINSKY'           !< Type of sub-grid scale turbulent scheme
 
    character(len=H_SHORT) :: PostGLFilter_Type = 'None'
    character(len=H_SHORT) :: PostGLFilter_ConvFilterShape = 'GAUSSIAN'
    integer :: PostGLFilter_Nnodeh1D_reconst = -1
    real(RP) :: PostGLFilter_GaussinWidthFac = 1.5_rp
    real(RP) :: PostModalFilter_ALPHA_h = 0.0_rp
    real(RP) :: PostModalFilter_EtaC_h  = 0.0_rp
    integer :: PostModalFilter_ORDER_h  = 16    
    real(RP) :: PostModalFilter_ALPHA_v = 0.0_rp
    integer :: PostModalFilter_ORDER_v = 16
 
    namelist /param_atmos_phy_tb/ &
      time_dt,          & 
      time_dt_unit,     &
      tb_type,          &
      postglfilter_type, &
      postglfilter_nnodeh1d_reconst, &
      postglfilter_gaussinwidthfac, &
      postmodalfilter_alpha_h, & 
      postmodalfilter_etac_h, &
      postmodalfilter_order_h, &
      postmodalfilter_alpha_v, &
      postmodalfilter_order_v      
 
    
    class(atmosmesh), pointer     :: atm_mesh
    class(meshbase), pointer      :: ptr_mesh
    real(DP) :: dtsec
 
    integer :: ierr
    class(elementbase3d), pointer :: elem3D
    type(hexahedralelement) :: elem3D_hex
    !--------------------------------------------------
 
    if (.not. this%IsActivated()) return
 
    log_newline
    log_info("ATMOS_PHY_TB_setup",*) 'Setup'
 
    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_atmos_phy_tb,iostat=ierr)
    if( ierr < 0 ) then !--- missing
      log_info("ATMOS_PHY_TB_setup",*) 'Not found namelist. Default used.'
    elseif( ierr > 0 ) then !--- fatal error
      log_error("ATMOS_PHY_TB_setup",*) 'Not appropriate names in namelist PARAM_ATMOS_PHY_TB. Check!'
      call prc_abort
    endif
    log_nml(param_atmos_phy_tb)
 
    !- get mesh --------------------------------------------------
 
    call model_mesh%GetModelMesh( ptr_mesh )
    select type(model_mesh)
    class is (atmosmesh)
      atm_mesh => model_mesh
    end select
 
    !--- Register this component in the time manager
    
    call tm_parent_comp%Regist_process( 'ATMOS_PHY_TB', time_dt, time_dt_unit, & ! (in)
      this%tm_process_id )                                                       ! (out)
 
    dtsec = tm_parent_comp%process_list(this%tm_process_id)%dtsec
 
    !- initialize the variables 
    call this%vars%Init( model_mesh )      
 
    !- Initialize a module for turbulence model
    call this%tb_driver%Init( tb_type, dtsec, atm_mesh )
 
    !--
    this%dyn_bnd => null()
 
 
    !--
    select case( trim(postglfilter_type) )
    case ('ConvolFilter', 'Reconstruction', 'Reconstruction2')
      this%gFilter_flag = .true.
    case ('None', 'ModalFilter')
      this%gFilter_flag = .false.
    case default
      log_info("ATMOS_PHY_TB_setup",*) 'Not appropriate names of PostGLFilter_Type in namelist PARAM_ATMOS_PHY_TB. Check!'
      call prc_abort
    end select
    
    !-
    if ( this%gFilter_flag ) then
      if ( postglfilter_nnodeh1d_reconst < 0 ) then
        elem3d=> atm_mesh%ptr_mesh%lcmesh_list(1)%refElem3D
        postglfilter_nnodeh1d_reconst = elem3d%Nnode_h1D
      end if
      call this%gFilter_phy_tb%Init( postglfilter_type, &
        postglfilter_convfiltershape, postglfilter_gaussinwidthfac, &
        postglfilter_nnodeh1d_reconst,                              &
        2, 0, 0, atm_mesh%ptr_mesh            )
    end if
    if ( postmodalfilter_alpha_h > 0.0_rp .or. postmodalfilter_alpha_v > 0.0_rp ) then
      this%modalFilter_flag = .true.
      elem3d=> atm_mesh%ptr_mesh%lcmesh_list(1)%refElem3D
      call elem3d_hex%Init( elem3d%PolyOrder_h, elem3d%PolyOrder_v, .false. )
      call this%modalfilter_3D%Init( elem3d_hex, postmodalfilter_etac_h, postmodalfilter_alpha_h, postmodalfilter_order_h, 0.0_rp, postmodalfilter_alpha_v, postmodalfilter_order_v )
      call elem3d_hex%Final()
    else
      this%modalFilter_flag = .false.
    end if
 
    return
  end subroutine atmosphytb_setup
 
!> Calculate tendencies associated with a turbulent model
!!
!!
!! @param model_mesh Object to manage computational mesh of atmospheric model 
!! @param prgvars_list Object to mange prognostic variables with atmospheric dynamical core
!! @param trcvars_list Object to mange auxiliary variables 
!! @param forcing_list Object to mange forcing terms
!! @param is_update Flag to specify whether the tendencies are updated in this call
!!
!OCL SERIAL
  subroutine atmosphytb_calc_tendency( &
    this, model_mesh, prgvars_list, trcvars_list, &
    auxvars_list, forcing_list, is_update         )
 
    use scale_tracer, only: &
      tracer_advc   
    use scale_atm_dyn_dgm_nonhydro3d_common, only: &
      prgvar_ddens_id
    use scale_atm_phy_tb_dgm_common, only: &
      nu_vid => atmos_phy_tb_diag_nu_id, kh_vid => atmos_phy_tb_diag_kh_id
 
    use mod_atmos_vars, only: &
      atmosvars_getlocalmeshprgvars,    &
      atmosvars_getlocalmeshprgvar,     &
      atmosvars_getlocalmeshqtrcvar,    &
      atmosvars_getlocalmeshphyauxvars, &
      atmosvars_getlocalmeshphytends
    use mod_atmos_phy_tb_vars, only:          &
      atmosphytbvars_getlocalmeshfields_tend
     
    implicit none
    
    class(atmosphytb), intent(inout) :: this
    class(modelmeshbase), intent(in) :: model_mesh
    class(modelvarmanager), intent(inout) :: prgvars_list
    class(modelvarmanager), intent(inout) :: trcvars_list    
    class(modelvarmanager), intent(inout) :: auxvars_list
    class(modelvarmanager), intent(inout) :: forcing_list
    logical, intent(in) :: is_update
 
    class(meshbase), pointer :: mesh
    class(meshbase3d), pointer :: mesh3D
    class(localmesh3d), pointer :: lcmesh
    integer :: n
    integer :: ke
    integer :: iq
 
    class(localmeshfieldbase), pointer :: DENS_tp, MOMX_tp, MOMY_tp, MOMZ_tp, RHOT_tp, RHOH_P
    type(localmeshfieldbaselist) :: RHOQ_tp(QA)
    class(localmeshfieldbase), pointer :: tb_MOMX_t, tb_MOMY_t, tb_MOMZ_t, tb_RHOT_t
    class(localmeshfieldbase), pointer :: tb_RHOQ_t
    type(localmeshfieldbaselist) :: tb_RHOQ_t_list(QA)
    !--------------------------------------------------
 
    if (.not. this%IsActivated()) return
 
    !LOG_INFO('AtmosDyn_tendency',*)
 
    log_progress(*) 'atmosphere / physics / turbulence'
 
    call model_mesh%GetModelMesh( mesh )
    select type(mesh)
    class is (meshbase3d)
      mesh3d => mesh
    end select
 
    if (is_update) then
      call this%tb_driver%Tendency( this%vars%tends_manager, &
        prgvars_list, trcvars_list, auxvars_list,                                  &
        this%vars%auxvars_manager, this%vars%diagvars_manager,                     &
        this%dyn_bnd,                                                              &
        model_mesh%DOptrMat(1), model_mesh%DOptrMat(2), model_mesh%DOptrMat(3),    &
        model_mesh%SOptrMat(1), model_mesh%SOptrMat(2), model_mesh%SOptrMat(3),    &
        model_mesh%LiftOptrMat, mesh3d,                                            &
        this%gFilter_flag, this%gFilter_phy_tb, this%vars%diagvars(nu_vid:kh_vid), &
        this%modalFilter_flag, this%modalfilter_3D )
    end if
      
    call prof_rapstart('ATM_PHY_TB_add_tend', 2)
    do n=1, mesh%LOCAL_MESH_NUM
      call atmosvars_getlocalmeshphytends( n,        &
        mesh, forcing_list,                          &
        dens_tp, momx_tp, momy_tp, momz_tp, rhot_tp, &
        rhoh_p, rhoq_tp  )
 
      call atmosphytbvars_getlocalmeshfields_tend( n,               &
        mesh, this%vars%tends_manager,                              &
        tb_momx_t, tb_momy_t, tb_momz_t, tb_rhot_t, tb_rhoq_t_list, &
        lcmesh                                                      )
 
      !$omp parallel private(ke, iq)
      !$omp do
      do ke=lcmesh%NeS, lcmesh%NeE
        momx_tp%val(:,ke) = momx_tp%val(:,ke) + tb_momx_t%val(:,ke)
        momy_tp%val(:,ke) = momy_tp%val(:,ke) + tb_momy_t%val(:,ke)
        momz_tp%val(:,ke) = momz_tp%val(:,ke) + tb_momz_t%val(:,ke)
        rhot_tp%val(:,ke) = rhot_tp%val(:,ke) + tb_rhot_t%val(:,ke)
      end do
      !$omp end do    
      do iq = 1, qa
        if ( .not. tracer_advc(iq) ) cycle
        !$omp do
        do ke = lcmesh%NeS, lcmesh%NeE
          rhoq_tp(iq)%ptr%val(:,ke) = rhoq_tp(iq)%ptr%val(:,ke)        &
                                    + tb_rhoq_t_list(iq)%ptr%val(:,ke)
        end do
        !$omp end do
      end do
      !$omp end parallel
    end do
    call prof_rapend('ATM_PHY_TB_add_tend', 2)
 
    return  
  end subroutine atmosphytb_calc_tendency
 
!> Update variables in a turbulent model
!!
!! @param model_mesh Object to manage computational mesh of atmospheric model 
!! @param prgvars_list Object to mange prognostic variables with atmospheric dynamical core
!! @param trcvars_list Object to mange auxiliary variables 
!! @param forcing_list Object to mange forcing terms
!! @param is_update Flag to speicfy whether the tendencies are updated in this call
!!
!OCL SERIAL
  subroutine atmosphytb_update( this, model_mesh, prgvars_list, trcvars_list, auxvars_list, forcing_list, is_update )
    implicit none
 
    class(atmosphytb), intent(inout) :: this
    class(modelmeshbase), intent(in) :: model_mesh
    class(modelvarmanager), intent(inout) :: prgvars_list
    class(modelvarmanager), intent(inout) :: trcvars_list    
    class(modelvarmanager), intent(inout) :: auxvars_list
    class(modelvarmanager), intent(inout) :: forcing_list
    logical, intent(in) :: is_update
    !--------------------------------------------------
 
    return
  end subroutine atmosphytb_update
 
!> Finalize a component of sub-grid scale turbulent process
!!
!OCL SERIAL
  subroutine atmosphytb_finalize( this )
    implicit none
    class(atmosphytb), intent(inout) :: this
 
    !--------------------------------------------------
    if (.not. this%IsActivated()) return
 
    call this%tb_driver%Final()
    call this%vars%Final()
 
    return
  end subroutine atmosphytb_finalize
 
!> Set boundary conditions to a turbulent model
!!
!! @param dyn_bnd Object to manage boundary conditions of dynamical core
!!
!OCL SERIAL
  subroutine atmosphytb_setdynbc( this, dyn_bnd )
    implicit none
    class(atmosphytb), intent(inout) :: this
    type(atmdynbnd), intent(in), target :: dyn_bnd
    !--------------------------------------------------
 
    this%dyn_bnd => dyn_bnd
 
    return
  end subroutine atmosphytb_setdynbc
  
!- private ------------------------------------------------
 
end module mod_atmos_phy_tb