mod_atmos_driver.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
#include "scalelib.h"
module mod_atmos_driver
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
  use scale_io
  use scale_prof
  use scale_atmos_grid_cartesc_index
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public procedure
  !
  public :: atmos_driver_tracer_setup
  public :: atmos_driver_setup
  public :: atmos_driver_finalize
  public :: atmos_driver_calc_tendency
  public :: atmos_driver_calc_tendency_from_sflux
  public :: atmos_driver_update
  public :: atmos_surface_get
  public :: atmos_surface_set
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  !-----------------------------------------------------------------------------
contains
  !-----------------------------------------------------------------------------
  subroutine atmos_driver_tracer_setup
    use mod_atmos_phy_mp_driver, only: &
       atmos_phy_mp_driver_tracer_setup, &
       atmos_phy_mp_user_qhyd2qtrc,      &
       atmos_phy_mp_driver_qhyd2qtrc_onlyqv
    use mod_atmos_phy_mp_vars, only: &
       qa_mp, &
       qs_mp, &
       qe_mp
    use mod_atmos_phy_ae_driver, only: &
       atmos_phy_ae_driver_tracer_setup
    use mod_atmos_phy_ch_driver, only: &
       atmos_phy_ch_driver_tracer_setup
    use mod_atmos_phy_tb_driver, only: &
       atmos_phy_tb_driver_tracer_setup
    use mod_atmos_phy_bl_driver, only: &
       atmos_phy_bl_driver_tracer_setup
    use scale_atmos_hydrometeor, only: &
       atmos_hydrometeor_regist, &
       atmos_hydrometeor_dry
    use mod_atmos_admin, only: &
       atmos_use_qv
    use mod_atmos_phy_lt_driver, only: &
       atmos_phy_lt_driver_tracer_setup
    implicit none
 
    !---------------------------------------------------------------------------
 
    log_newline
    log_info("ATMOS_driver_tracer_setup",*) 'Setup'
 
 
    call atmos_phy_mp_driver_tracer_setup
    call atmos_phy_ch_driver_tracer_setup
    call atmos_phy_ae_driver_tracer_setup
    call atmos_phy_tb_driver_tracer_setup
    call atmos_phy_bl_driver_tracer_setup
    call atmos_phy_lt_driver_tracer_setup
 
    if ( atmos_hydrometeor_dry .and. atmos_use_qv ) then
       log_info("ATMOS_driver_tracer_setup",*) 'Regist QV'
       call atmos_hydrometeor_regist( 0, 0,                                    & ! (in)
            (/'QV'/),                                                          & ! (in)
            (/'Ratio of Water Vapor mass to total mass (Specific humidity)'/), & ! (in)
            (/'kg/kg'/),                                                       & ! (in)
            qs_mp                                                              ) ! (out)
       qa_mp = 1
       qe_mp = qs_mp
       atmos_phy_mp_user_qhyd2qtrc => atmos_phy_mp_driver_qhyd2qtrc_onlyqv
 
    end if
 
    return
  end subroutine atmos_driver_tracer_setup
 
  !-----------------------------------------------------------------------------
  subroutine atmos_driver_setup( init )
    use scale_time, only: &
       time_nowdate
    use scale_atmos_solarins, only: &
       atmos_solarins_setup
    use scale_atmos_refstate, only: &
       atmos_refstate_setup
    use mod_atmos_bnd_driver, only: &
       atmos_boundary_driver_setup
    use mod_atmos_dyn_driver, only: &
       atmos_dyn_driver_setup
    use mod_atmos_phy_mp_driver, only: &
       atmos_phy_mp_driver_setup
    use mod_atmos_phy_mp_vars, only: &
       qa_mp, &
       qs_mp, &
       qe_mp
    use mod_atmos_phy_ch_driver, only: &
       atmos_phy_ch_driver_setup
    use mod_atmos_phy_ae_driver, only: &
       atmos_phy_ae_driver_setup
    use mod_atmos_phy_rd_driver, only: &
       atmos_phy_rd_driver_setup
    use mod_atmos_phy_sf_driver, only: &
       atmos_phy_sf_driver_setup
    use mod_atmos_phy_tb_driver, only: &
       atmos_phy_tb_driver_setup
    use mod_atmos_phy_bl_driver, only: &
       atmos_phy_bl_driver_setup
    use mod_atmos_phy_cp_driver, only: &
       atmos_phy_cp_driver_setup
    use mod_atmos_phy_lt_driver, only: &
       atmos_phy_lt_driver_setup
    use scale_atmos_grid_cartesc, only: &
       cz => atmos_grid_cartesc_cz, &
       fz => atmos_grid_cartesc_fz
    use scale_atmos_grid_cartesc_real, only: &
       base_lon => atmos_grid_cartesc_real_basepoint_lon, &
       base_lat => atmos_grid_cartesc_real_basepoint_lat, &
       real_cz  => atmos_grid_cartesc_real_cz, &
       real_fz  => atmos_grid_cartesc_real_fz, &
       real_phi => atmos_grid_cartesc_real_phi
    implicit none
    logical, intent(in), optional :: init
    logical :: not_init
    !---------------------------------------------------------------------------
 
    not_init = .true.
    if ( present(init) ) not_init = .not. init
 
    log_newline
    log_info("ATMOS_driver_setup",*) 'Setup'
 
    log_newline
    log_info("ATMOS_driver_setup",*) 'Setup each atmospheric components ...'
 
    !--- setup solar insolation
    call atmos_solarins_setup( base_lon, base_lat, time_nowdate(1) )
 
    call prof_rapstart('ATM_Refstate', 2)
    call atmos_refstate_setup( ka, ks, ke, ia, isb, ieb, ja, jsb, jeb, &
                               cz(:), fz(:), real_cz(:,:,:), real_fz(:,:,:), real_phi(:,:,:) )
    call prof_rapend  ('ATM_Refstate', 2)
 
    call prof_rapstart('ATM_Boundary', 2)
    if ( not_init ) call atmos_boundary_driver_setup
    call prof_rapend  ('ATM_Boundary', 2)
 
    ! setup each components
    if ( not_init ) call atmos_dyn_driver_setup
    if ( not_init ) call atmos_phy_lt_driver_setup
                    call atmos_phy_mp_driver_setup
    if ( not_init ) call atmos_phy_ae_driver_setup
    if ( not_init ) call atmos_phy_ch_driver_setup
    if ( not_init ) call atmos_phy_rd_driver_setup
    if ( not_init ) call atmos_phy_sf_driver_setup
    if ( not_init ) call atmos_phy_tb_driver_setup
                    call atmos_phy_bl_driver_setup
    if ( not_init ) call atmos_phy_cp_driver_setup
 
    log_newline
    log_info("ATMOS_driver_setup",*) 'Finish setup of each atmospheric components.'
 
    return
  end subroutine atmos_driver_setup
 
  !-----------------------------------------------------------------------------
  subroutine atmos_driver_calc_tendency( force )
    use mod_atmos_vars, only: &
       dens_tp, &
       momz_tp, &
       rhou_tp, &
       rhov_tp, &
       rhot_tp, &
       rhoh_p,  &
       rhoq_tp, &
       momx_tp, &
       momy_tp
    use mod_atmos_phy_mp_driver, only: &
       atmos_phy_mp_driver_calc_tendency
    use mod_atmos_phy_ch_driver, only: &
       atmos_phy_ch_driver_calc_tendency
    use mod_atmos_phy_ae_driver, only: &
       atmos_phy_ae_driver_calc_tendency
    use mod_atmos_phy_rd_driver, only: &
       atmos_phy_rd_driver_calc_tendency
    use mod_atmos_phy_sf_driver, only: &
       atmos_phy_sf_driver_calc_tendency
    use mod_atmos_phy_tb_driver, only: &
       atmos_phy_tb_driver_calc_tendency
    use mod_atmos_phy_cp_driver, only: &
       atmos_phy_cp_driver_calc_tendency
    use mod_atmos_phy_bl_driver, only: &
       atmos_phy_bl_driver_calc_tendency
    use mod_admin_time, only: &
       do_phy_mp => time_doatmos_phy_mp, &
       do_phy_ae => time_doatmos_phy_ae, &
       do_phy_ch => time_doatmos_phy_ch, &
       do_phy_rd => time_doatmos_phy_rd, &
       do_phy_sf => time_doatmos_phy_sf, &
       do_phy_tb => time_doatmos_phy_tb, &
       do_phy_bl => time_doatmos_phy_bl, &
       do_phy_cp => time_doatmos_phy_cp, &
       do_phy_lt => time_doatmos_phy_lt
    use mod_atmos_admin, only: &
       atmos_sw_phy_mp, &
       atmos_sw_phy_ae, &
       atmos_sw_phy_ch, &
       atmos_sw_phy_rd, &
       atmos_sw_phy_sf, &
       atmos_sw_phy_tb, &
       atmos_sw_phy_bl, &
       atmos_sw_phy_cp
    use mod_cpl_admin, only: &
       cpl_sw
    implicit none
    logical, intent(in) :: force
    !---------------------------------------------------------------------------
 
    !########## Get Surface Boundary from coupler ##########
    call atmos_surface_get
 
    !########## calculate tendency ##########
    ! reset tendencies
    !$omp parallel workshare
    !$acc kernels
!OCL XFILL
    dens_tp(:,:,:)   = 0.0_rp
    !$acc end kernels
    !$acc kernels
!OCL XFILL
    momz_tp(:,:,:)   = 0.0_rp
    !$acc end kernels
    !$acc kernels
!OCL XFILL
    rhou_tp(:,:,:)   = 0.0_rp
    !$acc end kernels
    !$acc kernels
!OCL XFILL
    rhov_tp(:,:,:)   = 0.0_rp
    !$acc end kernels
    !$acc kernels
!OCL XFILL
    rhot_tp(:,:,:)   = 0.0_rp
    !$acc end kernels
    !$acc kernels
!OCL XFILL
    rhoh_p(:,:,:)   = 0.0_rp
    !$acc end kernels
    !$acc kernels
!OCL XFILL
    rhoq_tp(:,:,:,:) = 0.0_rp
    !$acc end kernels
    !$acc kernels
!OCL XFILL
    momx_tp(:,:,:)   = 0.0_rp
    !$acc end kernels
    !$acc kernels
!OCL XFILL
    momy_tp(:,:,:)   = 0.0_rp
    !$acc end kernels
    !$omp end parallel workshare
 
    ! Microphysics
    if ( atmos_sw_phy_mp ) then
       call prof_rapstart('ATM_Microphysics', 1)
       call atmos_phy_mp_driver_calc_tendency( update_flag = do_phy_mp .or. force )
       call prof_rapend  ('ATM_Microphysics', 1)
    endif
    ! Aerosol
    if ( atmos_sw_phy_ae ) then
       call prof_rapstart('ATM_Aerosol', 1)
       call atmos_phy_ae_driver_calc_tendency( update_flag = do_phy_ae .or. force )
       call prof_rapend  ('ATM_Aerosol', 1)
    endif
    ! Chemistry
    if ( atmos_sw_phy_ch ) then
       call prof_rapstart('ATM_Chemistry', 1)
       call atmos_phy_ch_driver_calc_tendency( update_flag = do_phy_ch .or. force )
       call prof_rapend  ('ATM_Chemistry', 1)
    endif
    ! Radiation
    if ( atmos_sw_phy_rd ) then
       call prof_rapstart('ATM_Radiation', 1)
       call atmos_phy_rd_driver_calc_tendency( update_flag = do_phy_rd .or. force )
       call prof_rapend  ('ATM_Radiation', 1)
    endif
    ! Turbulence
    if ( atmos_sw_phy_tb ) then
       call prof_rapstart('ATM_Turbulence', 1)
       call atmos_phy_tb_driver_calc_tendency( update_flag = do_phy_tb .or. force )
       call prof_rapend  ('ATM_Turbulence', 1)
    endif
    ! Cumulus
    if ( atmos_sw_phy_cp ) then
       call prof_rapstart('ATM_Cumulus', 1)
       call atmos_phy_cp_driver_calc_tendency( update_flag = do_phy_cp .or. force )
       call prof_rapend  ('ATM_Cumulus', 1)
    endif
    if ( .not. cpl_sw ) then
       ! Surface Flux
       if ( atmos_sw_phy_sf ) then
          call prof_rapstart('ATM_SurfaceFlux', 1)
          call atmos_phy_sf_driver_calc_tendency( update_flag = do_phy_sf .or. force )
          call prof_rapend  ('ATM_SurfaceFlux', 1)
       endif
       ! Planetary Boundary layer
       if ( atmos_sw_phy_bl ) then
          call prof_rapstart('ATM_PBL', 1)
          call atmos_phy_bl_driver_calc_tendency( update_flag = do_phy_bl .or. force )
          call prof_rapend  ('ATM_PBL', 1)
       endif
    end if
 
    !########## Set Surface Boundary Condition ##########
    call atmos_surface_set( countup = .true. )
 
    return
  end subroutine atmos_driver_calc_tendency
 
  !-----------------------------------------------------------------------------
  subroutine atmos_driver_calc_tendency_from_sflux( force )
    use mod_atmos_phy_sf_driver, only: &
       atmos_phy_sf_driver_calc_tendency
    use mod_atmos_phy_bl_driver, only: &
       atmos_phy_bl_driver_calc_tendency
    use mod_cpl_admin, only: &
       cpl_sw
    use mod_atmos_admin, only: &
       atmos_sw_phy_sf, &
       atmos_sw_phy_bl
    use mod_admin_time, only: &
       do_phy_sf => time_doatmos_phy_sf, &
       do_phy_bl => time_doatmos_phy_bl
    implicit none
    logical, intent(in) :: force
    !---------------------------------------------------------------------------
 
    if ( cpl_sw ) then
 
       !########## Get Surface Boundary Condition ##########
       call atmos_surface_get
 
       ! Surface Flux
       if ( atmos_sw_phy_sf ) then
          call prof_rapstart('ATM_SurfaceFlux', 1)
          call atmos_phy_sf_driver_calc_tendency( update_flag = do_phy_sf .or. force )
          call prof_rapend  ('ATM_SurfaceFlux', 1)
       endif
 
       ! Planetary Boundary layer
       if ( atmos_sw_phy_bl ) then
          call prof_rapstart('ATM_PBL', 1)
          call atmos_phy_bl_driver_calc_tendency( update_flag = do_phy_bl .or. force )
          call prof_rapend  ('ATM_PBL', 1)
       endif
 
    end if
 
    return
  end subroutine atmos_driver_calc_tendency_from_sflux
 
  !-----------------------------------------------------------------------------
  subroutine atmos_driver_update
    use mod_atmos_admin, only: &
       atmos_sw_dyn,    &
       atmos_sw_phy_mp, &
       atmos_sw_phy_ae, &
       atmos_sw_phy_lt
    use mod_admin_time, only: &
       do_dyn    => time_doatmos_dyn,    &
       do_phy_mp => time_doatmos_phy_mp, &
       do_phy_ae => time_doatmos_phy_ae
    use scale_atmos_refstate, only: &
       atmos_refstate_update
    use mod_atmos_vars, only: &
       atmos_vars_calc_diagnostics,&
       atmos_vars_fillhalo,        &
       dens,                       &
       temp,                       &
       pres,                       &
       pott,                       &
       qv
    use mod_atmos_bnd_driver, only: &
       atmos_boundary_driver_update, &
       atmos_boundary_driver_send,   &
       atmos_boundary_update_flag
    use mod_atmos_dyn_driver, only: &
       atmos_dyn_driver
    use mod_atmos_phy_mp_driver, only: &
       atmos_phy_mp_driver_adjustment
    use mod_atmos_phy_ae_driver, only: &
       atmos_phy_ae_driver_adjustment
    use mod_atmos_phy_lt_driver, only: &
       atmos_phy_lt_driver_adjustment
    use scale_atmos_grid_cartesc, only: &
       cz   => atmos_grid_cartesc_cz,  &
       fz   => atmos_grid_cartesc_fz,  &
       fdz  => atmos_grid_cartesc_fdz, &
       rcdz => atmos_grid_cartesc_rcdz
    use scale_atmos_grid_cartesc_real, only: &
       real_cz  => atmos_grid_cartesc_real_cz, &
       real_fz  => atmos_grid_cartesc_real_fz, &
       real_phi => atmos_grid_cartesc_real_phi, &
       area     => atmos_grid_cartesc_real_area
    use scale_time, only: &
       time_nowdaysec, &
       time_dtsec
    implicit none
 
    !---------------------------------------------------------------------------
 
    !########## Dynamics ##########
    if ( atmos_sw_dyn ) then
       if ( atmos_boundary_update_flag ) then
          call prof_rapstart('ATM_Boundary', 2)
          call atmos_boundary_driver_update( time_nowdaysec - time_dtsec * 0.5_dp )
          call prof_rapend  ('ATM_Boundary', 2)
          call atmos_vars_fillhalo
       endif
       call prof_rapstart('ATM_Dynamics', 1)
       call atmos_dyn_driver( do_dyn )
       call prof_rapend  ('ATM_Dynamics', 1)
    endif
 
 
    !########## Calculate diagnostic variables ##########
    call atmos_vars_calc_diagnostics
 
 
    !########## Adjustment ##########
    ! Microphysics
    if ( atmos_sw_phy_mp ) then
       call prof_rapstart('ATM_Microphysics', 1)
       call atmos_phy_mp_driver_adjustment
       call prof_rapend  ('ATM_Microphysics', 1)
       call atmos_vars_fillhalo
       call atmos_vars_calc_diagnostics
    endif
    ! Aerosol
    if ( atmos_sw_phy_ae ) then
       call prof_rapstart('ATM_Aerosol', 1)
       call atmos_phy_ae_driver_adjustment
       call prof_rapend  ('ATM_Aerosol', 1)
       call atmos_vars_fillhalo
       call atmos_vars_calc_diagnostics
    endif
    ! Lightning
    if ( atmos_sw_phy_lt ) then
       call prof_rapstart('ATM_Lightning', 1)
       call atmos_phy_lt_driver_adjustment
       call prof_rapend  ('ATM_Lightning', 1)
       call atmos_vars_fillhalo
       ! calc_diagnostics is not necessary
    end if
 
 
    !########## Lateral/Top Boundary Condition ###########
    if ( atmos_boundary_update_flag ) then
       call prof_rapstart('ATM_Boundary', 2)
       call atmos_boundary_driver_update( time_nowdaysec )
       call prof_rapend  ('ATM_Boundary', 2)
       call atmos_vars_fillhalo
       call atmos_vars_calc_diagnostics
    endif
 
 
    !########## Send Lateral/Top Boundary Condition (Online nesting) ###########
    if ( atmos_boundary_update_flag ) then
       call prof_rapstart('ATM_Boundary', 2)
       call atmos_boundary_driver_send
       call prof_rapend  ('ATM_Boundary', 2)
    endif
 
 
    !########## Reference State ###########
    call prof_rapstart('ATM_Refstate', 2)
    call atmos_refstate_update( ka, ks, ke, ia, is, ie, isb, ieb, ja, js, je, jsb, jeb, &
                                dens(:,:,:), pott(:,:,:), temp(:,:,:), pres(:,:,:), qv(:,:,:), & ! [IN]
                                cz(:), fz(:), fdz(:), rcdz(:),                                 & ! [IN]
                                real_cz(:,:,:), real_fz(:,:,:), real_phi(:,:,:), area(:,:),    & ! [IN]
                                time_nowdaysec                                                 ) ! [IN]
    call prof_rapend  ('ATM_Refstate', 2)
 
    return
  end subroutine atmos_driver_update
 
  !-----------------------------------------------------------------------------
  subroutine atmos_driver_finalize( init )
    use scale_atmos_refstate, only: &
       atmos_refstate_finalize
    use mod_atmos_bnd_driver, only: &
       atmos_boundary_driver_finalize
    use mod_atmos_dyn_driver, only: &
       atmos_dyn_driver_finalize
    use mod_atmos_phy_lt_driver, only: &
       atmos_phy_lt_driver_finalize
    use mod_atmos_phy_mp_driver, only: &
       atmos_phy_mp_driver_finalize
    use mod_atmos_phy_ae_driver, only: &
       atmos_phy_ae_driver_finalize
    use mod_atmos_phy_ch_driver, only: &
       atmos_phy_ch_driver_finalize
    use mod_atmos_phy_rd_driver, only: &
       atmos_phy_rd_driver_finalize
    use mod_atmos_phy_tb_driver, only: &
       atmos_phy_tb_driver_finalize
    use mod_atmos_phy_bl_driver, only: &
       atmos_phy_bl_driver_finalize
    use mod_atmos_phy_cp_driver, only: &
       atmos_phy_cp_driver_finalize
    implicit none
    logical, intent(in), optional :: init
    logical :: not_init
    !---------------------------------------------------------------------------
 
    log_newline
    log_info("ATMOS_driver_finalize",*) 'Finalize'
 
    not_init = .true.
    if ( present(init) ) not_init = .not. init
 
    if ( not_init ) call atmos_dyn_driver_finalize
    if ( not_init ) call atmos_phy_lt_driver_finalize
                    call atmos_phy_mp_driver_finalize
    if ( not_init ) call atmos_phy_ae_driver_finalize
    if ( not_init ) call atmos_phy_ch_driver_finalize
    if ( not_init ) call atmos_phy_rd_driver_finalize
    !if ( not_init ) call ATMOS_PHY_SF_driver_finalize
    if ( not_init ) call atmos_phy_tb_driver_finalize
                    call atmos_phy_bl_driver_finalize
    if ( not_init )call atmos_phy_cp_driver_finalize
 
    if ( not_init ) call atmos_boundary_driver_finalize
 
    call atmos_refstate_finalize
 
    return
  end subroutine atmos_driver_finalize
 
  !-----------------------------------------------------------------------------
  subroutine atmos_surface_get
    use mod_atmos_phy_sf_vars, only: &
       sfc_temp   => atmos_phy_sf_sfc_temp,   &
       sfc_albedo => atmos_phy_sf_sfc_albedo, &
       sfc_z0m    => atmos_phy_sf_sfc_z0m,    &
       sfc_z0h    => atmos_phy_sf_sfc_z0h,    &
       sfc_z0e    => atmos_phy_sf_sfc_z0e,    &
       sflx_mw    => atmos_phy_sf_sflx_mw,    &
       sflx_mu    => atmos_phy_sf_sflx_mu,    &
       sflx_mv    => atmos_phy_sf_sflx_mv,    &
       sflx_sh    => atmos_phy_sf_sflx_sh,    &
       sflx_lh    => atmos_phy_sf_sflx_lh,    &
       sflx_shex  => atmos_phy_sf_sflx_shex,  &
       sflx_lhex  => atmos_phy_sf_sflx_lhex,  &
       sflx_qvex  => atmos_phy_sf_sflx_qvex,  &
       sflx_gh    => atmos_phy_sf_sflx_gh,    &
       sflx_qtrc  => atmos_phy_sf_sflx_qtrc,  &
       sflx_engi  => atmos_phy_sf_sflx_engi,  &
       u10        => atmos_phy_sf_u10,        &
       v10        => atmos_phy_sf_v10,        &
       t2         => atmos_phy_sf_t2,         &
       q2         => atmos_phy_sf_q2
    use mod_cpl_admin, only: &
       cpl_sw
    use mod_cpl_vars, only: &
       cpl_getsfc_atm
    implicit none
    !---------------------------------------------------------------------------
 
    call prof_rapstart('ATM_SfcExch', 2)
 
    if ( cpl_sw ) then
       call cpl_getsfc_atm( sfc_temp(:,:),     & ! [OUT]
                            sfc_albedo(:,:,:,:), & ! [OUT]
                            sfc_z0m(:,:),     & ! [OUT]
                            sfc_z0h(:,:),     & ! [OUT]
                            sfc_z0e(:,:),     & ! [OUT]
                            sflx_mw(:,:),     & ! [OUT]
                            sflx_mu(:,:),     & ! [OUT]
                            sflx_mv(:,:),     & ! [OUT]
                            sflx_sh(:,:),     & ! [OUT]
                            sflx_lh(:,:),     & ! [OUT]
                            sflx_shex(:,:),     & ! [OUT]
                            sflx_lhex(:,:),     & ! [OUT]
                            sflx_qvex(:,:),     & ! [OUT]
                            sflx_gh(:,:),     & ! [OUT]
                            sflx_qtrc(:,:,:),   & ! [OUT]
                            sflx_engi(:,:),     & ! [OUT]
                            u10(:,:),     & ! [OUT]
                            v10(:,:),     & ! [OUT]
                            t2(:,:),     & ! [OUT]
                            q2(:,:)      ) ! [OUT]
    endif
 
    call prof_rapend  ('ATM_SfcExch', 2)
 
    return
  end subroutine atmos_surface_get
 
  !-----------------------------------------------------------------------------
  subroutine atmos_surface_set( countup )
    use scale_atmos_grid_cartesc_real, only: &
       real_fz => atmos_grid_cartesc_real_fz
    use scale_atmos_bottom, only: &
       bottom_estimate => atmos_bottom_estimate
    use mod_atmos_vars, only: &
       dens, &
       qv,   &
       temp, &
       pres, &
       w,    &
       u,    &
       v,    &
       prec, &
       prec_engi
    use mod_atmos_phy_sf_vars, only: &
       sfc_temp  => atmos_phy_sf_sfc_temp
    use mod_atmos_phy_mp_vars, only: &
       sflx_rain_mp => atmos_phy_mp_sflx_rain, &
       sflx_snow_mp => atmos_phy_mp_sflx_snow, &
       sflx_engi_mp => atmos_phy_mp_sflx_engi
    use mod_atmos_phy_cp_vars, only: &
       sflx_rain_cp => atmos_phy_cp_sflx_rain, &
       sflx_snow_cp => atmos_phy_cp_sflx_snow, &
       sflx_engi_cp => atmos_phy_cp_sflx_engi
    use mod_atmos_phy_rd_vars, only: &
       sflx_rad_dn => atmos_phy_rd_sflx_down, &
       cossza      => atmos_phy_rd_cossza
    use mod_atmos_phy_bl_vars, only: &
       atm_pbl => atmos_phy_bl_zi
    use mod_cpl_admin, only: &
       cpl_sw
    use mod_cpl_vars, only: &
       cpl_putatm
    implicit none
 
    ! arguments
    logical, intent(in) :: countup
 
    ! works
    real(rp) :: sfc_dens(ia,ja)
    real(rp) :: sfc_pres(ia,ja)
 
    real(rp) :: temp1(ia,ja)
    real(rp) :: pres1(ia,ja)
    real(rp) :: w1   (ia,ja)
    real(rp) :: u1   (ia,ja)
    real(rp) :: v1   (ia,ja)
    real(rp) :: dens1(ia,ja)
    real(rp) :: qv1  (ia,ja)
 
    integer  :: i,j
    !---------------------------------------------------------------------------
 
    call prof_rapstart('ATM_SfcExch', 2)
 
    ! sum of rainfall from mp and cp
    !$omp parallel do private(i,j) OMP_SCHEDULE_
    !$acc kernels
    do j = js, je
    do i = is, ie
       prec(i,j) = sflx_rain_mp(i,j) + sflx_rain_cp(i,j) + sflx_snow_mp(i,j) + sflx_snow_cp(i,j)
       prec_engi(i,j) = sflx_engi_mp(i,j) + sflx_engi_cp(i,j)
    enddo
    enddo
    !$acc end kernels
 
    if ( cpl_sw ) then
 
       !$acc data create(SFC_DENS,SFC_PRES,TEMP1,PRES1,W1,U1,V1,DENS1,QV1)
 
       ! planetary boundary layer
       call bottom_estimate( ka, ks, ke, ia, is, ie, ja, js, je, &
                             dens(:,:,:), pres(:,:,:), qv(:,:,:), & ! [IN]
                             sfc_temp(:,:),                       & ! [IN]
                             real_fz(:,:,:),                      & ! [IN]
                             sfc_dens(:,:), sfc_pres(:,:)         ) ! [OUT]
 
       !$omp parallel do
       !$acc kernels
       do j = js, je
       do i = is, ie
          temp1(i,j) = temp(ks,i,j)
          pres1(i,j) = pres(ks,i,j)
          w1(i,j) = w(ks,i,j)
          u1(i,j) = u(ks,i,j)
          v1(i,j) = v(ks,i,j)
          dens1(i,j) = dens(ks,i,j)
          qv1(i,j) = qv(ks,i,j)
       end do
       end do
       !$acc end kernels
 
       call cpl_putatm( temp1(:,:),     & ! [IN]
                        pres1(:,:),     & ! [IN]
                        w1(:,:),     & ! [IN]
                        u1(:,:),     & ! [IN]
                        v1(:,:),     & ! [IN]
                        dens1(:,:),     & ! [IN]
                        qv1(:,:),     & ! [IN]
                        atm_pbl(:,:),     & ! [IN]
                        sfc_dens(:,:),     & ! [IN]
                        sfc_pres(:,:),     & ! [IN]
                        sflx_rad_dn(:,:,:,:), & ! [IN]
                        cossza(:,:),     & ! [IN]
                        prec(:,:),     & ! [IN]
                        prec_engi(:,:),     & ! [IN]
                        countup               ) ! [IN]
 
       !$acc end data
 
    endif
 
    call prof_rapend  ('ATM_SfcExch', 2)
 
    return
  end subroutine atmos_surface_set
 
  subroutine atmos_driver_boundary_update
 
  end subroutine atmos_driver_boundary_update
end module mod_atmos_driver