scale_land_dyn_bucket Module Reference

module land / dynamics / bucket More...

Functions/Subroutines
subroutine, public	land_dyn_bucket_setup
	Setup. More...
subroutine, public	land_dyn_bucket (LKMAX, LKS, LKE, LIA, LIS, LIE, LJA, LJS, LJE, TEMP_t, WATER_t, ICE_t, WaterLimit, ThermalCond, HeatCapacity, WaterDiff, SFLX_GH, SFLX_water, SFLX_RHOE, exists_land, CDZ, dt, NOWDAYSEC, TEMP, WATER, ICE, RUNOFF, RUNOFF_ENGI)
	Physical processes for land submodel. More...

Detailed Description

module land / dynamics / bucket

Description

slab-type land model

Author

Team SCALE

NAMELIST

• PARAM_LAND_DYN_BUCKET

  name	type	default value	comment
  LAND_DYN_BUCKET_T_FRZ	real(RP)
  LAND_DYN_BUCKET_NUDGING	logical	.false.	Is nudging for land physics used?
  LAND_DYN_BUCKET_NUDGING_TAU	real(DP)	0.0_DP	time constant for nudging [sec]
  LAND_DYN_BUCKET_NUDGING_TAU_UNIT	character(len=H_SHORT)	"SEC"
  LAND_DYN_BUCKET_NUDGING_BASENAME	character(len=H_LONG)	''
  LAND_DYN_BUCKET_NUDGING_BASENAME_ADD_NUM	logical	.false.
  LAND_DYN_BUCKET_NUDGING_NUMBER_OF_FILES	integer	1
  LAND_DYN_BUCKET_NUDGING_ENABLE_PERIODIC_YEAR	logical	.false.
  LAND_DYN_BUCKET_NUDGING_ENABLE_PERIODIC_MONTH	logical	.false.
  LAND_DYN_BUCKET_NUDGING_ENABLE_PERIODIC_DAY	logical	.false.
  LAND_DYN_BUCKET_NUDGING_STEP_FIXED	integer	0
  LAND_DYN_BUCKET_NUDGING_OFFSET	real(RP)	0.0_RP
  LAND_DYN_BUCKET_NUDGING_DEFVAL	real(RP)		= UNDEF
  LAND_DYN_BUCKET_NUDGING_CHECK_COORDINATES	logical	.true.
  LAND_DYN_BUCKET_NUDGING_STEP_LIMIT	integer	0
  LAND_DYN_BUCKET_UPDATE_BOTTOM_TEMP	logical	.false.	Is LAND_TEMP updated in the lowest level?
  LAND_DYN_BUCKET_UPDATE_BOTTOM_WATER	logical	.false.	Is LAND_WATER updated in the lowest level?

  
  

History Output

No history output

Function/Subroutine Documentation

land_dyn_bucket_setup()

subroutine, public scale_land_dyn_bucket::land_dyn_bucket_setup

Setup.

Definition at line 72 of file scale_land_dyn_bucket.F90.

    use scale_prc, only: &
       prc_abort
    use scale_const, only: &
       undef => const_undef, &
       tem00 => const_tem00, &
       dwatr => const_dwatr, &
       dice  => const_dice,  &
       cl    => const_cl
    use scale_calendar, only: &
       calendar_unit2sec
    use scale_file_external_input, only: &
       file_external_input_regist
    use scale_atmos_hydrometeor, only: &
       cv_water, &
       cv_ice
    implicit none
 
    namelist / param_land_dyn_bucket / &
       land_dyn_bucket_t_frz,                         &
       land_dyn_bucket_nudging,                       &
       land_dyn_bucket_nudging_tau,                   &
       land_dyn_bucket_nudging_tau_unit,              &
       land_dyn_bucket_nudging_basename,              &
       land_dyn_bucket_nudging_basename_add_num,      &
       land_dyn_bucket_nudging_number_of_files,       &
       land_dyn_bucket_nudging_enable_periodic_year,  &
       land_dyn_bucket_nudging_enable_periodic_month, &
       land_dyn_bucket_nudging_enable_periodic_day,   &
       land_dyn_bucket_nudging_step_fixed,            &
       land_dyn_bucket_nudging_offset,                &
       land_dyn_bucket_nudging_defval,                &
       land_dyn_bucket_nudging_check_coordinates,     &
       land_dyn_bucket_nudging_step_limit,            &
       land_dyn_bucket_update_bottom_temp,            &
       land_dyn_bucket_update_bottom_water
 
    integer :: ierr
    !---------------------------------------------------------------------------
 
    log_newline
    log_info("LAND_DYN_BUCKET_setup",*) 'Setup'
 
    land_dyn_bucket_nudging_defval = undef
    land_dyn_bucket_t_frz          = tem00
 
    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_land_dyn_bucket,iostat=ierr)
    if( ierr < 0 ) then !--- missing
       log_info("LAND_DYN_BUCKET_setup",*) 'Not found namelist. Default used.'
    elseif( ierr > 0 ) then !--- fatal error
       log_error("LAND_DYN_BUCKET_setup",*) 'Not appropriate names in namelist PARAM_LAND_DYN_BUCKET. Check!'
       call prc_abort
    endif
    log_nml(param_land_dyn_bucket)
 
    if ( land_dyn_bucket_nudging ) then
       call calendar_unit2sec( land_dyn_bucket_nudging_tausec, land_dyn_bucket_nudging_tau, land_dyn_bucket_nudging_tau_unit )
 
       log_info("LAND_DYN_BUCKET_setup",*) 'Use nudging for LAND physics  : ON'
       log_info("LAND_DYN_BUCKET_setup",*) 'Relaxation time Tau [sec]     : ', land_dyn_bucket_nudging_tausec
 
       if ( land_dyn_bucket_nudging_tausec <= 0.0_rp ) then
          log_info("LAND_DYN_BUCKET_setup",*) 'Tau<=0 means that LST is completely replaced by the external data.'
          replace = .true.
       endif
 
       if ( land_dyn_bucket_nudging_basename == '' ) then
          log_error("LAND_DYN_BUCKET_setup",*) 'LAND_DYN_BUCKET_nudging_basename is necessary !!'
          call prc_abort
       end if
 
       call file_external_input_regist( land_dyn_bucket_nudging_basename,              & ! [IN]
                                        land_dyn_bucket_nudging_basename_add_num,      & ! [IN]
                                        land_dyn_bucket_nudging_number_of_files,       & ! [IN]
                                        'LAND_TEMP',                                   & ! [IN]
                                        'LXY',                                         & ! [IN]
                                        land_dyn_bucket_nudging_enable_periodic_year,  & ! [IN]
                                        land_dyn_bucket_nudging_enable_periodic_month, & ! [IN]
                                        land_dyn_bucket_nudging_enable_periodic_day,   & ! [IN]
                                        land_dyn_bucket_nudging_step_fixed,            & ! [IN]
                                        land_dyn_bucket_nudging_offset,                & ! [IN]
                                        land_dyn_bucket_nudging_defval,                & ! [IN]
                                        check_coordinates = land_dyn_bucket_nudging_check_coordinates, & ! [IN]
                                        step_limit        = land_dyn_bucket_nudging_step_limit,        & ! [IN]
                                        allow_missing     = (.not. replace)                            ) ! [IN]
 
       call file_external_input_regist( land_dyn_bucket_nudging_basename,              & ! [IN]
                                        land_dyn_bucket_nudging_basename_add_num,      & ! [IN]
                                        land_dyn_bucket_nudging_number_of_files,       & ! [IN]
                                        'LAND_WATER',                                  & ! [IN]
                                        'LXY',                                         & ! [IN]
                                        land_dyn_bucket_nudging_enable_periodic_year,  & ! [IN]
                                        land_dyn_bucket_nudging_enable_periodic_month, & ! [IN]
                                        land_dyn_bucket_nudging_enable_periodic_day,   & ! [IN]
                                        land_dyn_bucket_nudging_step_fixed,            & ! [IN]
                                        land_dyn_bucket_nudging_offset,                & ! [IN]
                                        land_dyn_bucket_nudging_defval,                & ! [IN]
                                        check_coordinates = land_dyn_bucket_nudging_check_coordinates, & ! [IN]
                                        step_limit        = land_dyn_bucket_nudging_step_limit,        & ! [IN]
                                        allow_missing     = (.not. replace)                            ) ! [IN]
 
       log_info("LAND_DYN_BUCKET_setup",*) 'Use nudging for Land physics: ON'
    else
       log_info("LAND_DYN_BUCKET_setup",*) 'Use nudging for Land physics: OFF'
    end if
 
    water_denscs = dwatr * cv_water
    ice_denscs   = dice  * cv_ice
 
    log_newline
    log_info("LAND_DYN_BUCKET_setup",*) 'Update soil temperature of bottom layer? : ', land_dyn_bucket_update_bottom_temp
    log_info("LAND_DYN_BUCKET_setup",*) 'Update soil moisture    of bottom layer? : ', land_dyn_bucket_update_bottom_water
 
    return

References scale_calendar::calendar_unit2sec(), scale_const::const_cl, scale_const::const_dice, scale_const::const_dwatr, scale_const::const_tem00, scale_const::const_undef, scale_atmos_hydrometeor::cv_ice, scale_atmos_hydrometeor::cv_water, scale_file_external_input::file_external_input_regist(), scale_io::io_fid_conf, and scale_prc::prc_abort().

Referenced by mod_land_driver::land_driver_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

land_dyn_bucket()

subroutine, public scale_land_dyn_bucket::land_dyn_bucket	(	integer, intent(in)	LKMAX,
		integer, intent(in)	LKS,
		integer, intent(in)	LKE,
		integer, intent(in)	LIA,
		integer, intent(in)	LIS,
		integer, intent(in)	LIE,
		integer, intent(in)	LJA,
		integer, intent(in)	LJS,
		integer, intent(in)	LJE,
		real(rp), dimension (lkmax,lia,lja), intent(in)	TEMP_t,
		real(rp), dimension (lkmax,lia,lja), intent(in)	WATER_t,
		real(rp), dimension (lkmax,lia,lja), intent(in)	ICE_t,
		real(rp), dimension (lia,lja), intent(in)	WaterLimit,
		real(rp), dimension (lia,lja), intent(in)	ThermalCond,
		real(rp), dimension(lia,lja), intent(in)	HeatCapacity,
		real(rp), dimension (lia,lja), intent(in)	WaterDiff,
		real(rp), dimension (lia,lja), intent(in)	SFLX_GH,
		real(rp), dimension (lia,lja), intent(in)	SFLX_water,
		real(rp), dimension (lia,lja), intent(in)	SFLX_RHOE,
		logical, dimension (lia,lja), intent(in)	exists_land,
		real(rp), dimension (lkmax), intent(in)	CDZ,
		real(dp), intent(in)	dt,
		real(dp), intent(in)	NOWDAYSEC,
		real(rp), dimension (lkmax,lia,lja), intent(inout)	TEMP,
		real(rp), dimension(lkmax,lia,lja), intent(inout)	WATER,
		real(rp), dimension (lkmax,lia,lja), intent(inout)	ICE,
		real(rp), dimension (lia,lja), intent(out)	RUNOFF,
		real(rp), dimension(lia,lja), intent(out)	RUNOFF_ENGI
	)

Physical processes for land submodel.

Definition at line 204 of file scale_land_dyn_bucket.F90.

    use scale_const, only: &
       undef => const_undef, &
       dwatr => const_dwatr, &
       dice  => const_dice,  &
       emelt => const_emelt
    use scale_prc, only: &
       prc_abort
    use scale_file_external_input, only: &
       file_external_input_update
    use scale_matrix, only: &
       matrix_solver_tridiagonal
    use scale_atmos_hydrometeor, only: &
       cv_water, &
       cv_ice,   &
       lhf
    implicit none
    integer, intent(in) :: LKMAX, LKS, LKE
    integer, intent(in) :: LIA, LIS, LIE
    integer, intent(in) :: LJA, LJS, LJE
 
    real(RP), intent(in) :: TEMP_t      (LKMAX,LIA,LJA)
    real(RP), intent(in) :: WATER_t     (LKMAX,LIA,LJA)
    real(RP), intent(in) :: ICE_t       (LKMAX,LIA,LJA)
    real(RP), intent(in) :: WaterLimit  (LIA,LJA)
    real(RP), intent(in) :: ThermalCond (LIA,LJA)
    real(RP), intent(in) :: HeatCapacity(LIA,LJA)
    real(RP), intent(in) :: WaterDiff   (LIA,LJA)
    real(RP), intent(in) :: SFLX_GH     (LIA,LJA) ! positive for downward
    real(RP), intent(in) :: SFLX_water  (LIA,LJA) ! positive for downward
    real(RP), intent(in) :: SFLX_RHOE   (LIA,LJA) ! positive for downward
    logical,  intent(in) :: exists_land (LIA,LJA)
    real(RP), intent(in) :: CDZ         (LKMAX)
    real(DP), intent(in) :: dt
    real(DP), intent(in) :: NOWDAYSEC
 
    real(RP), intent(inout) :: TEMP (LKMAX,LIA,LJA)
    real(RP), intent(inout) :: WATER(LKMAX,LIA,LJA)
    real(RP), intent(inout) :: ICE  (LKMAX,LIA,LJA)
 
    real(RP), intent(out) :: RUNOFF     (LIA,LJA)
    real(RP), intent(out) :: RUNOFF_ENGI(LIA,LJA) ! internal energy of the runoff water
 
    logical :: error
 
    real(RP) :: TEMP1 (LKMAX,LIA,LJA)
    real(RP) :: WATER1(LKMAX,LIA,LJA)
    real(RP) :: ICE1  (LKMAX,LIA,LJA)
 
    real(RP) :: kappa      (LKMAX)
 
    real(RP) :: U(LKMAX,LIA,LJA)
    real(RP) :: M(LKMAX,LIA,LJA)
    real(RP) :: L(LKMAX,LIA,LJA)
    real(RP) :: V(LKMAX,LIA,LJA)
 
    real(RP) :: NDG_TEMP (LKMAX,LIA,LJA)
    real(RP) :: NDG_WATER(LKMAX,LIA,LJA)
 
    real(RP) :: MASS_total(LKMAX)
    real(RP) :: MASS_water(LKMAX)
    real(RP) :: MASS_ice(LKMAX)
 
    real(RP) :: ENGI(LKMAX,LIA,LJA)
    real(RP) :: CS
    real(RP) :: CL
 
    real(RP) :: flux(LKS-1:LKE)
 
    real(RP) :: ro, rw, ri
    real(RP) :: sw
 
    integer :: k, i, j
    !---------------------------------------------------------------------------
 
    log_progress(*) 'land / dynamics / bucket'
 
    if ( land_dyn_bucket_nudging ) then
 
       call file_external_input_update( &
                          'LAND_TEMP', & ! (in)
                          nowdaysec,   & ! (in)
                          temp1,       & ! (out)
                          error        ) ! (out)
       if ( error ) then
          log_error("LAND_DYN_BUCKET",*) 'Requested data is not found!'
          call prc_abort
       end if
 
       call file_external_input_update( &
                         'LAND_WATER', & ! (in)
                         nowdaysec,    & ! (in)
                         water1,       & ! (out)
                         error         ) ! (out)
       if ( error ) then
          log_error("LAND_DYN_BUCKET",*) 'Requested data is not found!'
          call prc_abort
       end if
 
       if ( .not. replace ) then
          ! nudging is used
 
          !$omp parallel do
          do j = ljs,lje
          do i = lis,lie
          do k = lks,lke
             if ( temp1(k,i,j) == undef ) then
                ndg_temp(k,i,j) = 0.0_rp
             else
                ndg_temp(k,i,j) = ( temp1(k,i,j) - temp(k,i,j) ) / land_dyn_bucket_nudging_tausec * dt
             end if
          end do
          end do
          end do
 
          !$omp parallel do
          do j = ljs,lje
          do i = lis,lie
          do k = lks,lke
             if ( water1(k,i,j) == undef ) then
                ndg_water(k,i,j) = 0.0_rp
             else
                ndg_water(k,i,j) = ( water1(k,i,j) - ( water(k,i,j) + ice(k,i,j) ) ) / land_dyn_bucket_nudging_tausec * dt
             end if
          end do
          end do
          end do
 
       end if
 
       if ( .not. land_dyn_bucket_update_bottom_water ) then
          !$omp parallel do
          do j = ljs, lje
          do i = lis, lie
             ndg_water(lke,i,j) = 0.0_rp
          end do
          end do
       end if
 
       if ( .not. land_dyn_bucket_update_bottom_temp ) then
          !$omp parallel do
          do j = ljs, lje
          do i = lis, lie
             ndg_temp(lke,i,j) = 0.0_rp
          end do
          end do
       end if
 
    else
       ! nudging is NOT used
 
       !$omp parallel do
       do j = ljs,lje
       do i = lis,lie
       do k = lks,lke
          ndg_temp(k,i,j) = 0.0_rp
          ndg_water(k,i,j) = 0.0_rp
       end do
       end do
       end do
 
    end if
 
    if ( .not. replace ) then
 
       !$omp parallel do &
       !$omp private(MASS_total, MASS_water, MASS_ice, CS)
       do j = ljs, lje
       do i = lis, lie
          if ( exists_land(i,j) ) then
             do k = lks, lke
                mass_total(k) = dwatr * water(k,i,j) + dice * ice(k,i,j)
             end do
             mass_total(lks) = mass_total(lks) + dt * sflx_water(i,j) / cdz(lks)
 
             cs = ( 1.0_rp - waterlimit(i,j) ) * heatcapacity(i,j)
             do k = lks, lke
                engi(k,i,j) = ( cs + water_denscs * water(k,i,j) + ice_denscs * ice(k,i,j) ) * temp(k,i,j) - lhf * dice * ice(k,i,j)
             end do
             engi(lks,i,j) = engi(lks,i,j) + dt * ( sflx_gh(i,j) + sflx_rhoe(i,j) ) / cdz(lks)
 
             ! phase change
             do k = lks, lke
                mass_ice(k) = min( mass_total(k), max( 0.0_rp, &
                     ( engi(k,i,j) - ( cs + cv_water * mass_total(k) ) * land_dyn_bucket_t_frz ) &
                     / ( ( cv_ice - cv_water ) * land_dyn_bucket_t_frz - lhf ) &
                     ) )
                mass_water(k) = mass_total(k) - mass_ice(k)
                v(k,i,j) = mass_water(k) / dwatr
                ice1(k,i,j) = mass_ice(k) / dice
                temp1(k,i,j) = ( engi(k,i,j) + lhf * mass_ice(k) ) &
                     / ( cs + cv_water * mass_water(k) + cv_ice * mass_ice(k) )
             end do
          end if
       end do
       end do
 
 
       !$omp parallel do
       do j = ljs, lje
       do i = lis, lie
          if ( exists_land(i,j) ) then
             l(lks,i,j) = 0.0_rp
             u(lks,i,j) = -2.0_rp * waterdiff(i,j) / ( cdz(lks) * ( cdz(lks) + cdz(lks+1) ) ) * dt
             m(lks,i,j) = 1.0_rp - l(lks,i,j) - u(lks,i,j)
          end if
       end do
       end do
 
       if ( land_dyn_bucket_update_bottom_water ) then
          !$omp parallel do
          do j = ljs, lje
          do i = lis, lie
             if ( exists_land(i,j) ) then
                l(lke,i,j) = -2.0_rp * waterdiff(i,j) / ( cdz(lke) * ( cdz(lke) + cdz(lke-1) ) ) * dt
             end if
          end do
          end do
       else
          !$omp parallel do
          do j = ljs, lje
          do i = lis, lie
             if ( exists_land(i,j) ) then
                l(lke,i,j) = 0.0_rp
             end if
          end do
          end do
       end if
       !$omp parallel do
       do j = ljs, lje
       do i = lis, lie
          if ( exists_land(i,j) ) then
             u(lke,i,j) = 0.0_rp
             m(lke,i,j) = 1.0_rp - l(lke,i,j) - u(lke,i,j)
          end if
       end do
       end do
 
       !$omp parallel do
       do j = ljs, lje
       do i = lis, lie
       do k = lks+1, lke-1
          if ( exists_land(i,j) ) then
             l(k,i,j) = -2.0_rp * waterdiff(i,j) / ( cdz(k) * ( cdz(k) + cdz(k-1) ) ) * dt
             u(k,i,j) = -2.0_rp * waterdiff(i,j) / ( cdz(k) * ( cdz(k) + cdz(k+1) ) ) * dt
             m(k,i,j) = 1.0_rp - l(k,i,j) - u(k,i,j)
          end if
       end do
       end do
       end do
 
       call matrix_solver_tridiagonal( lkmax, 1, lkmax, &
                                       lia, lis, lie,   &
                                       lja, ljs, lje,   &
                                       u(:,:,:), m(:,:,:), l(:,:,:), & ! [IN]
                                       v(:,:,:),                     & ! [IN]
                                       water1(:,:,:),                & ! [OUT]
                                       mask = exists_land(:,:)       ) ! [IN]
 
       ! temperature
 
       flux(lks-1) = 0.0_rp
       flux(lke)   = 0.0_rp
 
       !$omp parallel do &
       !$omp private(kappa,CS,CL,sw) &
       !$omp firstprivate(flux)
       do j = ljs, lje
       do i = lis, lie
          if ( exists_land(i,j) ) then
 
             cs = ( 1.0_rp - waterlimit(i,j) ) * heatcapacity(i,j)
             do k = lks, lke
                kappa(k) = thermalcond(i,j) + 0.5_rp * water1(k,i,j)**(1.0_rp/3.0_rp)
             end do
 
             do k = lks, lke-1
                flux(k) = - 2.0_rp *  dwatr * waterdiff(i,j) * ( water1(k+1,i,j) - water1(k,i,j) ) / ( cdz(k+1) + cdz(k) )
                sw = 0.5_rp - sign( 0.5_rp, flux(k) )
                flux(k) = flux(k) * cv_water * ( temp1(k+1,i,j) * sw + temp1(k,i,j) * ( 1.0_rp - sw ) )
             end do
             if ( .not. land_dyn_bucket_update_bottom_temp ) then
                flux(lke) = flux(lke-1)
             end if
 
             do k = lks, lke
                v(k,i,j) = engi(k,i,j) + lhf * dice * ice1(k,i,j) &
                         - dt * ( flux(k) - flux(k-1) ) / cdz(k)
             end do
 
             cl = cs + water_denscs * water1(lks,i,j) + ice_denscs * ice1(lks,i,j)
             l(lks,i,j) = 0.0_rp
             u(lks,i,j) = - ( kappa(lks) + kappa(lks+1) ) / ( cdz(lks) * ( cdz(lks) + cdz(lks+1) ) ) * dt
             m(lks,i,j) = cl - l(lks,i,j) - u(lks,i,j)
 
             cl = cs + water_denscs * water1(lke,i,j) + ice_denscs * ice1(lke,i,j)
             if ( land_dyn_bucket_update_bottom_water ) then
 
                l(lke,i,j) = - ( kappa(lke) + kappa(lke-1) ) / ( cdz(lke) * ( cdz(lke) + cdz(lke-1) ) ) * dt
             else
                l(lke,i,j) = 0.0_rp
             end if
             u(lke,i,j) = 0.0_rp
             m(lke,i,j) = cl - l(lke,i,j) - u(lke,i,j)
 
             do k = lks+1, lke-1
                cl = cs + water_denscs * water1(k,i,j) + ice_denscs * ice1(k,i,j)
                l(k,i,j) = - ( kappa(k) + kappa(k-1) ) / ( cdz(k) * ( cdz(k) + cdz(k-1) ) ) * dt
                u(k,i,j) = - ( kappa(k) + kappa(k+1) ) / ( cdz(k) * ( cdz(k) + cdz(k+1) ) ) * dt
                m(k,i,j) = cl - l(k,i,j) - u(k,i,j)
             end do
 
          end if
       end do
       end do
 
       call matrix_solver_tridiagonal( lkmax, 1, lkmax, &
                                       lia, lis, lie,   &
                                       lja, ljs, lje,   &
                                       u(:,:,:), m(:,:,:), l(:,:,:), & ! [IN]
                                       v(:,:,:),                     & ! [IN]
                                       temp1(:,:,:),                 & ! [OUT]
                                       mask = exists_land(:,:)       ) ! [IN]
 
 
       !$omp parallel do
       do j = ljs, lje
       do i = lis, lie
          if ( exists_land(i,j) ) then
             do k = lks, lke
                temp1(k,i,j) = temp1(k,i,j) + ndg_temp(k,i,j)
             end do
          end if
       end do
       end do
 
 
       !$omp parallel do &
       !$omp private(ro,rw,ri)
       do j = ljs, lje
       do i = lis, lie
          if ( exists_land(i,j) ) then
             do k = lks, lke
                if ( temp1(k,i,j) >= land_dyn_bucket_t_frz ) then
                   water1(k,i,j) = water1(k,i,j) + ndg_water(k,i,j)
                else
                   ice1(k,i,j) = ice1(k,i,j) + ndg_water(k,i,j)
                end if
             end do
 
             ! runoff of soil moisture (vertical sum)
             runoff(i,j) = 0.0_rp
             runoff_engi(i,j) = 0.0_rp
             do k = lks, lke
                ro = max( water1(k,i,j) + ice1(k,i,j) - waterlimit(i,j), 0.0_rp )
                rw = min( ro, water1(k,i,j) )
                ri = ro - rw
                water1(k,i,j) = water1(k,i,j) - rw
                ice1(k,i,j) = ice1(k,i,j) - ri
                rw = rw * dwatr / dt
                ri = ri * dice / dt
                runoff(i,j) = runoff(i,j) + ( rw + ri ) * cdz(k)
                runoff_engi(i,j) = runoff_engi(i,j) &
                     + ( ( rw * cv_water + ri * cv_ice ) * temp1(k,i,j) - ri * lhf ) * cdz(k)
             end do
          end if
       end do
       end do
 
 
       if ( .not. land_dyn_bucket_update_bottom_water ) then
          !$omp parallel do
          do j = ljs, lje
          do i = lis, lie
             if ( exists_land(i,j) ) then
                water1(lke,i,j) = water(lke,i,j)
                ice1(lke,i,j) = ice(lke,i,j)
             end if
          end do
          end do
       endif
 
       if ( .not. land_dyn_bucket_update_bottom_temp ) then
          !$omp parallel do
          do j = ljs, lje
          do i = lis, lie
             if ( exists_land(i,j) ) then
                temp1(lke,i,j) = temp(lke,i,j)
             end if
          end do
          end do
       endif
 
    end if
 
 
    !$omp parallel do
    do j = ljs, lje
    do i = lis, lie
       if( exists_land(i,j) ) then
          do k = lks, lke
             temp(k,i,j) = temp1(k,i,j)
             water(k,i,j) = water1(k,i,j)
             ice(k,i,j) = ice1(k,i,j)
          end do
       end if
    end do
    end do
 
    return

References scale_const::const_dice, scale_const::const_dwatr, scale_const::const_emelt, scale_const::const_undef, scale_atmos_hydrometeor::cv_ice, scale_atmos_hydrometeor::cv_water, scale_atmos_hydrometeor::lhf, and scale_prc::prc_abort().

Referenced by mod_land_driver::land_driver_update().

Here is the call graph for this function:

Here is the caller graph for this function: