scale_atm_dyn_dgm_modalfilter Module Reference

module FElib / Fluid dyn solver / Atmosphere / Common / Modal filter More...

Functions/Subroutines
subroutine, public	atm_dyn_dgm_modalfilter_apply (ddens_, momx_, momy_, momz_, drhot_, lmesh, elem, elem_operation, do_weight_gsqrt)
subroutine, public	atm_dyn_dgm_tracer_modalfilter_apply (qtrc_, dens_hyd_, ddens0_, ddens_, lmesh, elem, elem_operation)
	Apply a modal filtering to tracer variables.

Detailed Description

module FElib / Fluid dyn solver / Atmosphere / Common / Modal filter

Description

Modal filter for Atmospheric dynamical process. The modal filter suppresses the numerical instability due to the aliasing errors.

Author

Yuta Kawai, Team SCALE

Function/Subroutine Documentation

atm_dyn_dgm_modalfilter_apply()

subroutine, public scale_atm_dyn_dgm_modalfilter::atm_dyn_dgm_modalfilter_apply	(	real(rp), dimension(elem%np,lmesh%nea), intent(inout)	ddens_,
		real(rp), dimension(elem%np,lmesh%nea), intent(inout)	momx_,
		real(rp), dimension(elem%np,lmesh%nea), intent(inout)	momy_,
		real(rp), dimension(elem%np,lmesh%nea), intent(inout)	momz_,
		real(rp), dimension(elem%np,lmesh%nea), intent(inout)	drhot_,
		class(localmeshbase), intent(in)	lmesh,
		class(elementbase), intent(in)	elem,
		class(elementoperationbase3d), intent(in)	elem_operation,
		logical, intent(in), optional	do_weight_gsqrt )

Definition at line 49 of file scale_atm_dyn_dgm_modalfilter.F90.

 
    implicit none
 
    class(LocalMeshBase), intent(in) :: lmesh
    class(ElementBase), intent(in) :: elem    
    real(RP), intent(inout)  :: DDENS_(elem%Np,lmesh%NeA)
    real(RP), intent(inout)  :: MOMX_(elem%Np,lmesh%NeA)
    real(RP), intent(inout)  :: MOMY_(elem%Np,lmesh%NeA)
    real(RP), intent(inout)  :: MOMZ_(elem%Np,lmesh%NeA)
    real(RP), intent(inout)  :: DRHOT_(elem%Np,lmesh%NeA)
    class(ElementOperationBase3D), intent(in) :: elem_operation
    logical, intent(in), optional :: do_weight_Gsqrt
    
    integer :: ke
    real(RP) :: tmp(elem%Np,5)
    real(RP) :: work(elem%Np)
    real(RP) :: tmp_out(elem%Np,5)
 
    integer :: kk
    logical :: do_weight_Gsqrt_
    real(RP) :: RGsqrt(elem%Np)
    !------------------------------------
 
    if ( present( do_weight_gsqrt ) ) then
      do_weight_gsqrt_ = do_weight_gsqrt
    else
      do_weight_gsqrt_ = .false.
    end if
 
    if ( do_weight_gsqrt_ ) then
      !$omp parallel do private( tmp, tmp_out, work, kk, RGsqrt )
      do ke=lmesh%NeS, lmesh%NeE
        do kk=1, elem%Np
          tmp(kk,1) = lmesh%Gsqrt(kk,ke) * ddens_(kk,ke)
          tmp(kk,2) = lmesh%Gsqrt(kk,ke) * momx_(kk,ke)
          tmp(kk,3) = lmesh%Gsqrt(kk,ke) * momy_(kk,ke)
          tmp(kk,4) = lmesh%Gsqrt(kk,ke) * momz_(kk,ke)
          tmp(kk,5) = lmesh%Gsqrt(kk,ke) * drhot_(kk,ke)
        end do
 
        call elem_operation%ModalFilter_var5( tmp, work, &
          tmp_out ) ! (out)
 
        rgsqrt(:) = 1.0_rp / lmesh%Gsqrt(:,ke)
        ddens_(:,ke) = tmp_out(:,1) * rgsqrt(:)
        momx_(:,ke) = tmp_out(:,2) * rgsqrt(:)
        momy_(:,ke) = tmp_out(:,3) * rgsqrt(:)
        momz_(:,ke) = tmp_out(:,4) * rgsqrt(:)
        drhot_(:,ke) = tmp_out(:,5) * rgsqrt(:)
      end do    
 
    else
 
      !$omp parallel do private( tmp, work, kk )
      do ke=lmesh%NeS, lmesh%NeE
 
        do kk=1, elem%Np
          tmp(kk,1) = ddens_(kk,ke)
          tmp(kk,2) = momx_(kk,ke)
          tmp(kk,3) = momy_(kk,ke)
          tmp(kk,4) = momz_(kk,ke)
          tmp(kk,5) = drhot_(kk,ke)
        end do
        
        call elem_operation%ModalFilter_var5( tmp, work, &
          tmp_out )
 
        ddens_(:,ke) = tmp(:,1)
        momx_(:,ke) = tmp(:,2)
        momy_(:,ke) = tmp(:,3)
        momz_(:,ke) = tmp(:,4)
        drhot_(:,ke) = tmp(:,5)
      end do
 
    end if
 
    return

References scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().

Referenced by mod_atmos_phy_preproc::physpreprocnone_init().

atm_dyn_dgm_tracer_modalfilter_apply()

subroutine, public scale_atm_dyn_dgm_modalfilter::atm_dyn_dgm_tracer_modalfilter_apply	(	real(rp), dimension(elem%np,lmesh%nea), intent(inout)	qtrc_,
		real(rp), dimension(elem%np,lmesh%nea), intent(in)	dens_hyd_,
		real(rp), dimension(elem%np,lmesh%nea), intent(in)	ddens0_,
		real(rp), dimension (elem%np,lmesh%nea), intent(in)	ddens_,
		class(localmeshbase), intent(in)	lmesh,
		class(elementbase), intent(in)	elem,
		class(elementoperationbase3d), intent(in)	elem_operation )

Apply a modal filtering to tracer variables.

Definition at line 235 of file scale_atm_dyn_dgm_modalfilter.F90.

 
    implicit none
 
    class(LocalMeshBase), intent(in) :: lmesh
    class(ElementBase), intent(in) :: elem    
    real(RP), intent(inout)  :: QTRC_(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DENS_hyd_(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DDENS0_(elem%Np,lmesh%NeA)
    real(RP), intent(in)  :: DDENS_ (elem%Np,lmesh%NeA)
    class(ElementOperationBase3D), intent(in) :: elem_operation
 
    integer :: ke
    real(RP) :: tmp(elem%Np)
    real(RP) :: work(elem%Np)
    real(RP) :: tmp_out(elem%Np)
    real(RP) :: weight(elem%Np)
 
    real(RP) :: qtrc_avg
    real(RP) :: GsqrtRHOQ_ref(elem%Np)
    integer :: kk
    !------------------------------------
 
    !$omp parallel do private( tmp, tmp_out, work, kk, weight, qtrc_avg, GsqrtRHOQ_ref )
    do ke=lmesh%NeS, lmesh%NeE
 
      !    ( dens_hyd + ddens0 ) * ( qtrc_av + dqtrc )
      ! = ( dens_hyd + ddens ) * qtrc_avg + dens_ * dqtrc
      ! 
      !  dens_hyd * qtrc_avg + qtrc_avg [ MF * ddens ] 
      ! + MF_q [ dqtrc ]
      qtrc_avg = 0.125_rp * sum(elem%IntWeight_lgl(:) * qtrc_(:,ke))
      gsqrtrhoq_ref(:) = lmesh%Gsqrt(:,ke) * qtrc_avg * ( &
        dens_hyd_(:,ke) + ddens_(:,ke) - ddens0_(:,ke) )
 
      do kk=1, elem%Np
        weight(kk) = lmesh%Gsqrt(kk,ke) &
                   * ( dens_hyd_(kk,ke) + ddens0_(kk,ke) ) 
!        tmp(kk) = weight(kk) * QTRC_(kk,ke)
        tmp(kk) = weight(kk) * qtrc_(kk,ke) &
                - gsqrtrhoq_ref(kk)
      end do
 
      ! del(RHO Q) = RHOQ - RHO_hyd Q_avg
      !            = (RHO_hyd + dRHO) (Q_avg + dQ) - RHO_hyd Q_avg
      !            = RHO_hyd dQ + dRHO Q_avg + dR
      ! RHOQ = RHO_hyd Q_avg + del(RHO Q)
      call elem_operation%ModalFilter_tracer( tmp, work, &
        tmp_out )
 
      qtrc_(:,ke) = ( gsqrtrhoq_ref(:) + tmp_out(:) ) / weight(:)
    end do    
 
    return

Referenced by mod_atmos_phy_preproc::physpreprocnone_init().