From 444d2e18b49425180c793348d6a72afd15497346 Mon Sep 17 00:00:00 2001 From: John Alex Date: Wed, 26 Aug 2026 15:54:55 -0400 Subject: [PATCH 1/2] refactor(biogeophys): Fix mismatched associate aliases for frac_sno_eff --- src/biogeophys/CanopyFluxesMod.F90 | 10 +++++----- src/biogeophys/SnowHydrologyMod.F90 | 14 +++++++------- src/biogeophys/SnowSnicarMod.F90 | 6 +++--- src/biogeophys/SoilHydrologyMod.F90 | 4 ++-- src/biogeophys/SoilTemperatureMod.F90 | 28 +++++++++++++-------------- 5 files changed, 31 insertions(+), 31 deletions(-) diff --git a/src/biogeophys/CanopyFluxesMod.F90 b/src/biogeophys/CanopyFluxesMod.F90 index 29374a7b70..74f62c4c80 100644 --- a/src/biogeophys/CanopyFluxesMod.F90 +++ b/src/biogeophys/CanopyFluxesMod.F90 @@ -563,7 +563,7 @@ subroutine CanopyFluxes(bounds, num_exposedvegp, filter_exposedvegp, frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of surface water fwet => waterdiagnosticbulk_inst%fwet_patch , & ! Input: [real(r8) (:) ] fraction of canopy that is wet (0 to 1) fdry => waterdiagnosticbulk_inst%fdry_patch , & ! Input: [real(r8) (:) ] fraction of foliage that is green and dry [-] - frac_sno => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) qg_snow => waterdiagnosticbulk_inst%qg_snow_col , & ! Input: [real(r8) (:) ] specific humidity at snow surface [kg/kg] qg_soil => waterdiagnosticbulk_inst%qg_soil_col , & ! Input: [real(r8) (:) ] specific humidity at soil surface [kg/kg] @@ -1298,8 +1298,8 @@ subroutine CanopyFluxes(bounds, num_exposedvegp, filter_exposedvegp, erre = efe(p) - efeold end if ! fractionate ground emitted longwave - lw_grnd=(frac_sno(c)*t_soisno(c,snl(c)+1)**4 & - +(1._r8-frac_sno(c)-frac_h2osfc(c))*t_soisno(c,1)**4 & + lw_grnd=(frac_sno_eff(c)*t_soisno(c,snl(c)+1)**4 & + +(1._r8-frac_sno_eff(c)-frac_h2osfc(c))*t_soisno(c,1)**4 & +frac_h2osfc(c)*t_h2osfc(c)**4) dt_veg(p) = ((1._r8-frac_rad_abs_by_stem(p))*(sabv(p) + air(p) & @@ -1468,8 +1468,8 @@ subroutine CanopyFluxes(bounds, num_exposedvegp, filter_exposedvegp, ! Energy balance check in canopy - lw_grnd=(frac_sno(c)*t_soisno(c,snl(c)+1)**4 & - +(1._r8-frac_sno(c)-frac_h2osfc(c))*t_soisno(c,1)**4 & + lw_grnd=(frac_sno_eff(c)*t_soisno(c,snl(c)+1)**4 & + +(1._r8-frac_sno_eff(c)-frac_h2osfc(c))*t_soisno(c,1)**4 & +frac_h2osfc(c)*t_h2osfc(c)**4) err(p) = (1.0_r8-frac_rad_abs_by_stem(p))*(sabv(p) + air(p) + bir(p)*tlbef(p)**3 & diff --git a/src/biogeophys/SnowHydrologyMod.F90 b/src/biogeophys/SnowHydrologyMod.F90 index 578769d9ea..2677277f28 100644 --- a/src/biogeophys/SnowHydrologyMod.F90 +++ b/src/biogeophys/SnowHydrologyMod.F90 @@ -1926,7 +1926,7 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & t_soisno => temperature_inst%t_soisno_col , & ! Input: [real(r8) (:,:) ] soil temperature (Kelvin) imelt => temperature_inst%imelt_col , & ! Input: [integer (:,:) ] flag for melting (=1), freezing (=2), Not=0 - frac_sno => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] snow covered fraction + frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] snow covered fraction frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) swe_old => waterdiagnosticbulk_inst%swe_old_col , & ! Input: [real(r8) (:,:) ] initial swe values int_snow => waterstatebulk_inst%int_snow_col , & ! Input: [real(r8) (:) ] integrated snowfall [mm] @@ -1959,12 +1959,12 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & wx = (h2osoi_ice(c,j) + h2osoi_liq(c,j)) void = 1._r8 - (h2osoi_ice(c,j)/denice + h2osoi_liq(c,j)/denh2o)& - /(frac_sno(c) * dz(c,j)) + /(frac_sno_eff(c) * dz(c,j)) ! Allow compaction only for non-saturated node and higher ice lens node. if (void > 0.001_r8 .and. h2osoi_ice(c,j) > .1_r8) then - bi = h2osoi_ice(c,j) / (frac_sno(c) * dz(c,j)) + bi = h2osoi_ice(c,j) / (frac_sno_eff(c) * dz(c,j)) fi = h2osoi_ice(c,j) / wx td = tfrz-t_soisno(c,j) dexpf = exp(-c4*td) @@ -1977,7 +1977,7 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & ! Liquid water term - if (h2osoi_liq(c,j) > 0.01_r8*dz(c,j)*frac_sno(c)) ddz1=ddz1*c5 + if (h2osoi_liq(c,j) > 0.01_r8*dz(c,j)*frac_sno_eff(c)) ddz1=ddz1*c5 select case (overburden_compaction_method) case (OverburdenCompactionMethodAnderson1976) @@ -2030,7 +2030,7 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & fsno_melt = 1._r8 - frac_h2osfc(c) end if - ddz3 = ddz3 - max(0._r8,(fsno_melt - frac_sno(c))/frac_sno(c)) + ddz3 = ddz3 - max(0._r8,(fsno_melt - frac_sno_eff(c))/frac_sno_eff(c)) endif ddz3 = -1._r8/dtime * ddz3 else @@ -2058,7 +2058,7 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & ! The change in dz due to compaction ! Limit compaction to be no greater than fully saturated layer thickness - dz(c,j) = max(dz(c,j) * (1._r8+pdzdtc*dtime),(h2osoi_ice(c,j)/denice+ h2osoi_liq(c,j)/denh2o)/frac_sno(c)) + dz(c,j) = max(dz(c,j) * (1._r8+pdzdtc*dtime),(h2osoi_ice(c,j)/denice+ h2osoi_liq(c,j)/denh2o)/frac_sno_eff(c)) else ! saturated node is immobile @@ -2573,7 +2573,7 @@ subroutine DivideSnowLayers(bounds, num_snowc, filter_snowc, & associate( & t_soisno => temperature_inst%t_soisno_col , & ! Output: [real(r8) (:,:) ] soil temperature (Kelvin) - frac_sno => b_waterdiagnostic_inst%frac_sno_eff_col , & ! Output: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_eff => b_waterdiagnostic_inst%frac_sno_eff_col , & ! Output: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snw_rds => b_waterdiagnostic_inst%snw_rds_col , & ! Output: [real(r8) (:,:) ] effective snow grain radius (col,lyr) [microns, m^-6] mss_bcphi => aerosol_inst%mss_bcphi_col , & ! Output: [real(r8) (:,:) ] hydrophilic BC mass in snow (col,lyr) [kg] diff --git a/src/biogeophys/SnowSnicarMod.F90 b/src/biogeophys/SnowSnicarMod.F90 index f6d41bd6a0..3f006b3198 100644 --- a/src/biogeophys/SnowSnicarMod.F90 +++ b/src/biogeophys/SnowSnicarMod.F90 @@ -612,7 +612,7 @@ subroutine SNICAR_RT (bounds, num_nourbanc, filter_nourbanc, & associate(& snl => col%snl , & ! Input: [integer (:)] negative number of snow layers (col) [nbr] - frac_sno => waterdiagnosticbulk_inst%frac_sno_eff_col & ! Input: [real(r8) (:)] fraction of ground covered by snow (0 to 1) + frac_sno_eff=> waterdiagnosticbulk_inst%frac_sno_eff_col & ! Input: [real(r8) (:)] fraction of ground covered by snow (0 to 1) ) ! initialize parameter and @@ -1551,7 +1551,7 @@ subroutine SnowAge_grain(bounds, & qflx_snow_grnd_col => waterfluxbulk_inst%qflx_snow_grnd_col , & ! Input: [real(r8) (:) ] snow on ground after interception (col) [kg m-2 s-1] qflx_snofrz_lyr => waterfluxbulk_inst%qflx_snofrz_lyr_col , & ! Input: [real(r8) (:,:) ] snow freezing rate (col,lyr) [kg m-2 s-1] - frac_sno => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) h2osno_no_layers => waterstatebulk_inst%h2osno_no_layers_col , & ! Input: [real(r8) (:) ] snow that is not resolved into layers (col) [mm H2O] h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid water content (col,lyr) [kg m-2] h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] ice content (col,lyr) [kg m-2] @@ -1576,7 +1576,7 @@ subroutine SnowAge_grain(bounds, & snl_btm = 0 snl_top = snl(c_idx) + 1 - cdz(snl_top:snl_btm)=frac_sno(c_idx)*dz(c_idx,snl_top:snl_btm) + cdz(snl_top:snl_btm)=frac_sno_eff(c_idx)*dz(c_idx,snl_top:snl_btm) ! loop over snow layers do i=snl_top,snl_btm,1 diff --git a/src/biogeophys/SoilHydrologyMod.F90 b/src/biogeophys/SoilHydrologyMod.F90 index 753ddc59fc..d48f2b2d89 100644 --- a/src/biogeophys/SoilHydrologyMod.F90 +++ b/src/biogeophys/SoilHydrologyMod.F90 @@ -330,7 +330,7 @@ subroutine SetQflxInputs(bounds, num_hydrologyc, filter_hydrologyc, & qflx_ev_h2osfc => waterfluxbulk_inst%qflx_ev_h2osfc_col , & ! Input: [real(r8) (:)] evaporation flux from h2osfc (W/m**2) [+ to atm] qflx_sat_excess_surf => waterfluxbulk_inst%qflx_sat_excess_surf_col , & ! Input: [real(r8) (:)] surface runoff due to saturated surface (mm H2O /s) - frac_sno => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) ) @@ -348,7 +348,7 @@ subroutine SetQflxInputs(bounds, num_hydrologyc, filter_hydrologyc, & ! if no snow layers, sublimation is removed from h2osoi_ice in drainage qflx_evap=qflx_liqevap_from_top_layer(c) else - fsno=frac_sno(c) + fsno=frac_sno_eff(c) qflx_evap=qflx_ev_soil(c) endif diff --git a/src/biogeophys/SoilTemperatureMod.F90 b/src/biogeophys/SoilTemperatureMod.F90 index 367da626e6..5a54d0cc68 100644 --- a/src/biogeophys/SoilTemperatureMod.F90 +++ b/src/biogeophys/SoilTemperatureMod.F90 @@ -675,7 +675,7 @@ subroutine SoilThermProp (bounds, num_urbanc, filter_urbanc, num_nolakec, filter t_soisno => temperature_inst%t_soisno_col , & ! Input: [real(r8) (:,:) ] soil temperature [K] - frac_sno => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fractional snow covered area + frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fractional snow covered area h2osfc => waterstatebulk_inst%h2osfc_col , & ! Input: [real(r8) (:) ] surface (mm H2O) h2osno_no_layers => waterstatebulk_inst%h2osno_no_layers_col , & ! Input: [real(r8) (:) ] snow not resolved into layers (mm H2O) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid water (kg/m2) @@ -739,7 +739,7 @@ subroutine SoilThermProp (bounds, num_urbanc, filter_urbanc, num_nolakec, filter ! Thermal conductivity of snow ! Only examine levels from snl(c)+1 -> 0 where snl(c) < 1 if (snl(c)+1 < 1 .AND. (j >= snl(c)+1) .AND. (j <= 0)) then - bw(c,j) = (h2osoi_ice(c,j)+h2osoi_liq(c,j))/(frac_sno(c)*dz(c,j)) + bw(c,j) = (h2osoi_ice(c,j)+h2osoi_liq(c,j))/(frac_sno_eff(c)*dz(c,j)) l = col%landunit(c) ! Select method over glacier land unit @@ -886,8 +886,8 @@ subroutine SoilThermProp (bounds, num_urbanc, filter_urbanc, num_nolakec, filter do fc = 1,num_nolakec c = filter_nolakec(fc) if (snl(c)+1 < 1 .and. j >= snl(c)+1) then - if (frac_sno(c) > 0._r8) then - cv(c,j) = max(thin_sfclayer,(cpliq*h2osoi_liq(c,j) + cpice*h2osoi_ice(c,j))/frac_sno(c)) + if (frac_sno_eff(c) > 0._r8) then + cv(c,j) = max(thin_sfclayer,(cpliq*h2osoi_liq(c,j) + cpice*h2osoi_ice(c,j))/frac_sno_eff(c)) else cv(c,j) = thin_sfclayer endif @@ -950,7 +950,7 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & snl => col%snl , & ! Input: [integer (:) ] number of snow layers dz => col%dz , & ! Input: [real(r8) (:,:) ] layer thickness (m) - frac_sno => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) h2osno_no_layers => waterstatebulk_inst%h2osno_no_layers_col , & ! Output: [real(r8) (:) ] snow that is not resolved into layers (mm H2O) h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] ice lens (kg/m2) (new) @@ -1002,7 +1002,7 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & xm(c) = hm(c)*dtime/hfus temp1 = h2osfc(c) + xm(c) - z_avg=frac_sno(c)*snow_depth(c) + z_avg=frac_sno_eff(c)*snow_depth(c) if (z_avg > 0._r8) then rho_avg=min(800._r8,h2osno_total(c)/z_avg) else @@ -1029,8 +1029,8 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & ! update snow depth - if (frac_sno(c) > 0 .and. snl(c) < 0) then - snow_depth(c)=h2osno_total(c)/(rho_avg*frac_sno(c)) + if (frac_sno_eff(c) > 0 .and. snl(c) < 0) then + snow_depth(c)=h2osno_total(c)/(rho_avg*frac_sno_eff(c)) else snow_depth(c)=h2osno_total(c)/denice endif @@ -1042,9 +1042,9 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & eflx_h2osfc_to_snow_col(c) = 0. else if (snl(c) == -1)then - c1=frac_sno(c)*(dtime/fact(c,0) - dhsdT(c)*dtime) + c1=frac_sno_eff(c)*(dtime/fact(c,0) - dhsdT(c)*dtime) else - c1=frac_sno(c)/fact(c,0)*dtime + c1=frac_sno_eff(c)/fact(c,0)*dtime end if if ( frac_h2osfc(c) /= 0.0_r8 )then c2=(-cpliq*xm(c) - frac_h2osfc(c)*dhsdT(c)*dtime) @@ -1087,7 +1087,7 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & !initialize for next time step t_soisno(c,0) = t_h2osfc(c) else if (snl(c) == -1) then - c1=frac_sno(c)*(dtime/fact(c,0) - dhsdT(c)*dtime) + c1=frac_sno_eff(c)*(dtime/fact(c,0) - dhsdT(c)*dtime) if ( frac_h2osfc(c) /= 0.0_r8 )then c2=frac_h2osfc(c)*(c_h2osfc(c) - dtime*dhsdT(c)) @@ -1099,7 +1099,7 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & t_h2osfc(c) = t_soisno(c,0) else - c1=frac_sno(c)/fact(c,0)*dtime + c1=frac_sno_eff(c)/fact(c,0)*dtime if ( frac_h2osfc(c) /= 0.0_r8 )then c2=frac_h2osfc(c)*(c_h2osfc(c) - dtime*dhsdT(c)) else @@ -1114,8 +1114,8 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & h2osfc(c) = 0._r8 ! update snow depth - if (frac_sno(c) > 0 .and. snl(c) < 0) then - snow_depth(c)=h2osno_total(c)/(rho_avg*frac_sno(c)) + if (frac_sno_eff(c) > 0 .and. snl(c) < 0) then + snow_depth(c)=h2osno_total(c)/(rho_avg*frac_sno_eff(c)) else snow_depth(c)=h2osno_total(c)/denice endif From 450531d65f5e62e4f4b5b837ba70858001f1cca7 Mon Sep 17 00:00:00 2001 From: John Alex Date: Wed, 26 Aug 2026 15:54:55 -0400 Subject: [PATCH 2/2] refactor(biogeophys): Rename frac_sno to frac_sno_albedo and frac_sno_eff to frac_sno_fluxes --- src/biogeochem/CNVegStructUpdateMod.F90 | 16 +- src/biogeochem/DustEmisLeung2023.F90 | 4 +- src/biogeochem/DustEmisZender2003.F90 | 4 +- src/biogeochem/SatellitePhenologyMod.F90 | 6 +- .../DustEmis_test/test_DustEmisLeung2023.pf | 4 +- .../DustEmis_test/test_DustEmisZender2003.pf | 4 +- src/biogeophys/BalanceCheckMod.F90 | 20 +-- src/biogeophys/BiogeophysPreFluxCalcsMod.F90 | 10 +- src/biogeophys/CanopyFluxesMod.F90 | 10 +- src/biogeophys/FrictionVelocityMod.F90 | 6 +- src/biogeophys/HydrologyNoDrainageMod.F90 | 8 +- src/biogeophys/LakeHydrologyMod.F90 | 22 +-- src/biogeophys/SnowCoverFractionBaseMod.F90 | 46 +++--- .../SnowCoverFractionNiuYang2007Mod.F90 | 32 ++-- ...nowCoverFractionSwensonLawrence2012Mod.F90 | 48 +++--- src/biogeophys/SnowHydrologyMod.F90 | 144 +++++++++--------- src/biogeophys/SnowSnicarMod.F90 | 6 +- src/biogeophys/SoilFluxesMod.F90 | 32 ++-- src/biogeophys/SoilHydrologyMod.F90 | 6 +- src/biogeophys/SoilTemperatureMod.F90 | 98 ++++++------ src/biogeophys/SurfaceAlbedoMod.F90 | 38 ++--- src/biogeophys/SurfaceHumidityMod.F90 | 14 +- src/biogeophys/SurfaceRadiationMod.F90 | 14 +- src/biogeophys/SurfaceResistanceMod.F90 | 6 +- src/biogeophys/SurfaceWaterMod.F90 | 30 ++-- src/biogeophys/UrbanAlbedoMod.F90 | 26 ++-- src/biogeophys/UrbanFluxesMod.F90 | 4 +- src/biogeophys/UrbanRadiationMod.F90 | 8 +- src/biogeophys/WaterDiagnosticBulkType.F90 | 42 ++--- src/main/clm_driver.F90 | 4 +- src/unit_test_shr/unittestDustEmisInputs.F90 | 2 +- src/utils/clmfates_interfaceMod.F90 | 4 +- 32 files changed, 359 insertions(+), 359 deletions(-) diff --git a/src/biogeochem/CNVegStructUpdateMod.F90 b/src/biogeochem/CNVegStructUpdateMod.F90 index 4b6a82194a..609c247f10 100644 --- a/src/biogeochem/CNVegStructUpdateMod.F90 +++ b/src/biogeochem/CNVegStructUpdateMod.F90 @@ -76,10 +76,10 @@ subroutine CNVegStructUpdate(bounds,num_soilp, filter_soilp, & real(r8) :: tsai_min ! PATCH derived minimum tsai real(r8) :: tsai_alpha ! monthly decay rate of tsai real(r8) :: dt ! radiation time step (sec) - real(r8) :: frac_sno_adjusted ! frac_sno adjusted per frac_sno_threshold + real(r8) :: frac_sno_albedo_adjusted ! frac_sno_albedo adjusted per frac_sno_albedo_threshold real(r8), parameter :: dtsmonth = 2592000._r8 ! number of seconds in a 30 day month (60x60x24x30) - real(r8), parameter :: frac_sno_threshold = 0.999_r8 ! frac_sno values greater than this are treated as 1 + real(r8), parameter :: frac_sno_albedo_threshold = 0.999_r8 ! frac_sno_albedo values greater than this are treated as 1 !----------------------------------------------------------------------- ! tsai formula from Zeng et. al. 2002, Journal of Climate, p1835 ! @@ -113,7 +113,7 @@ subroutine CNVegStructUpdate(bounds,num_soilp, filter_soilp, & nind => dgvs_inst%nind_patch , & ! Input: [real(r8) (:) ] number of individuals (#/m**2) fpcgrid => dgvs_inst%fpcgrid_patch , & ! Input: [real(r8) (:) ] fractional area of patch (pft area/nat veg area) - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) forc_hgt_u_patch => frictionvel_inst%forc_hgt_u_patch , & ! Input: [real(r8) (:) ] observational height of wind at patch-level [m] @@ -304,15 +304,15 @@ subroutine CNVegStructUpdate(bounds,num_soilp, filter_soilp, & !depth of snow required for complete burial of grasses endif - if (frac_sno(c) <= frac_sno_threshold) then - frac_sno_adjusted = frac_sno(c) + if (frac_sno_albedo(c) <= frac_sno_albedo_threshold) then + frac_sno_albedo_adjusted = frac_sno_albedo(c) else ! avoid tiny but non-zero elai and esai that can cause radiation and/or photosynthesis code to blow up - frac_sno_adjusted = 1._r8 + frac_sno_albedo_adjusted = 1._r8 end if - elai(p) = max(tlai(p)*(1.0_r8 - frac_sno_adjusted) + tlai(p)*fb*frac_sno_adjusted, 0.0_r8) - esai(p) = max(tsai(p)*(1.0_r8 - frac_sno_adjusted) + tsai(p)*fb*frac_sno_adjusted, 0.0_r8) + elai(p) = max(tlai(p)*(1.0_r8 - frac_sno_albedo_adjusted) + tlai(p)*fb*frac_sno_albedo_adjusted, 0.0_r8) + esai(p) = max(tsai(p)*(1.0_r8 - frac_sno_albedo_adjusted) + tsai(p)*fb*frac_sno_albedo_adjusted, 0.0_r8) ! Fraction of vegetation free of snow if ((elai(p) + esai(p)) > 0._r8) then diff --git a/src/biogeochem/DustEmisLeung2023.F90 b/src/biogeochem/DustEmisLeung2023.F90 index ed5068d4e7..779dfc8906 100644 --- a/src/biogeochem/DustEmisLeung2023.F90 +++ b/src/biogeochem/DustEmisLeung2023.F90 @@ -423,7 +423,7 @@ subroutine DustEmission (this, bounds, & tlai => canopystate_inst%tlai_patch , & ! Input: [real(r8) (:) ] one-sided leaf area index, no burying by snow tsai => canopystate_inst%tsai_patch , & ! Input: [real(r8) (:) ] one-sided stem area index, no burying by snow - frac_sno => waterdiagnosticbulk_inst%frac_sno_col, & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col, & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) h2osoi_vol => waterstatebulk_inst%h2osoi_vol_col , & ! Input: [real(r8) (:,:) ] volumetric soil water (0<=h2osoi_vol<=watsat) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid soil water (kg/m2) h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] frozen soil water (kg/m2) @@ -516,7 +516,7 @@ subroutine DustEmission (this, bounds, & else lnd_frc_mbl(p) = 0.0_r8 endif - lnd_frc_mbl(p) = lnd_frc_mbl(p) * (1.0_r8 - frac_sno(c)) + lnd_frc_mbl(p) = lnd_frc_mbl(p) * (1.0_r8 - frac_sno_albedo(c)) else lnd_frc_mbl(p) = 0.0_r8 end if diff --git a/src/biogeochem/DustEmisZender2003.F90 b/src/biogeochem/DustEmisZender2003.F90 index cee704ad47..cbb438915d 100644 --- a/src/biogeochem/DustEmisZender2003.F90 +++ b/src/biogeochem/DustEmisZender2003.F90 @@ -249,7 +249,7 @@ subroutine DustEmission (this, bounds, & tlai => canopystate_inst%tlai_patch , & ! Input: [real(r8) (:) ] one-sided leaf area index, no burying by snow tsai => canopystate_inst%tsai_patch , & ! Input: [real(r8) (:) ] one-sided stem area index, no burying by snow - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) h2osoi_vol => waterstatebulk_inst%h2osoi_vol_col , & ! Input: [real(r8) (:,:) ] volumetric soil water (0<=h2osoi_vol<=watsat) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid soil water (kg/m2) h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] frozen soil water (kg/m2) @@ -318,7 +318,7 @@ subroutine DustEmission (this, bounds, & else lnd_frc_mbl(p) = 0.0_r8 endif - lnd_frc_mbl(p) = lnd_frc_mbl(p) * (1.0_r8 - frac_sno(c)) + lnd_frc_mbl(p) = lnd_frc_mbl(p) * (1.0_r8 - frac_sno_albedo(c)) else lnd_frc_mbl(p) = 0.0_r8 end if diff --git a/src/biogeochem/SatellitePhenologyMod.F90 b/src/biogeochem/SatellitePhenologyMod.F90 index 3c6c9ba99b..6e69edd5fc 100644 --- a/src/biogeochem/SatellitePhenologyMod.F90 +++ b/src/biogeochem/SatellitePhenologyMod.F90 @@ -202,7 +202,7 @@ subroutine UpdateSatellitePhenologyCanopy(bounds, num_filter, filter, & end if associate( & - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) tlai_driver => canopystate_inst%tlai_input_patch , & ! Input: [real(r8) (:) ] SP driver data for one-sided leaf area index, no burying by snow tsai_driver => canopystate_inst%tsai_input_patch , & ! Input: [real(r8) (:) ] SP driver data for one-sided stem area index, no burying by snow @@ -245,8 +245,8 @@ subroutine UpdateSatellitePhenologyCanopy(bounds, num_filter, filter, & fb = 1._r8 - (max(min(snow_depth(c),max(0.05,htop(p)*0.8_r8)),0._r8)/(max(0.05,htop(p)*0.8_r8))) endif - elai(p) = max(tlai(p)*(1.0_r8 - frac_sno(c)) + tlai(p)*fb*frac_sno(c), 0.0_r8) - esai(p) = max(tsai(p)*(1.0_r8 - frac_sno(c)) + tsai(p)*fb*frac_sno(c), 0.0_r8) + elai(p) = max(tlai(p)*(1.0_r8 - frac_sno_albedo(c)) + tlai(p)*fb*frac_sno_albedo(c), 0.0_r8) + esai(p) = max(tsai(p)*(1.0_r8 - frac_sno_albedo(c)) + tsai(p)*fb*frac_sno_albedo(c), 0.0_r8) if (elai(p) < 0.05_r8) elai(p) = 0._r8 if (esai(p) < 0.05_r8) esai(p) = 0._r8 diff --git a/src/biogeochem/test/DustEmis_test/test_DustEmisLeung2023.pf b/src/biogeochem/test/DustEmis_test/test_DustEmisLeung2023.pf index 77e0cba4c0..37f0f31336 100644 --- a/src/biogeochem/test/DustEmis_test/test_DustEmisLeung2023.pf +++ b/src/biogeochem/test/DustEmis_test/test_DustEmisLeung2023.pf @@ -155,7 +155,7 @@ contains real(r8) :: flx_mss_vrt_dst_tot call this%input%create_atm2lnd() - this%input%water_inst%waterdiagnosticbulk_inst%frac_sno_col(:) = 1.0_r8 + this%input%water_inst%waterdiagnosticbulk_inst%frac_sno_albedo_col(:) = 1.0_r8 call this%input%create_fv( ) call this%dust_emis%DustEmission(bounds, this%input%num_nolakep, this%input%filter_nolakep, this%input%atm2lnd_inst, & this%input%soilstate_inst, this%input%canopystate_inst, this%input%water_inst%waterstatebulk_inst, & @@ -208,7 +208,7 @@ contains call this%input%create_atm2lnd() call this%input%create_fv( ) ! Dust should abort with an error on dust mobility when snow fraction greater than 1 - this%input%water_inst%waterdiagnosticbulk_inst%frac_sno_col(:) = 1.0_r8 + 1.e-15_r8 + this%input%water_inst%waterdiagnosticbulk_inst%frac_sno_albedo_col(:) = 1.0_r8 + 1.e-15_r8 call this%dust_emis%DustEmission(bounds, this%input%num_nolakep, this%input%filter_nolakep, this%input%atm2lnd_inst, & this%input%soilstate_inst, this%input%canopystate_inst, this%input%water_inst%waterstatebulk_inst, & this%input%water_inst%waterdiagnosticbulk_inst, this%input%frictionvel_inst) diff --git a/src/biogeochem/test/DustEmis_test/test_DustEmisZender2003.pf b/src/biogeochem/test/DustEmis_test/test_DustEmisZender2003.pf index 6c883d0dfe..49f1efd7af 100644 --- a/src/biogeochem/test/DustEmis_test/test_DustEmisZender2003.pf +++ b/src/biogeochem/test/DustEmis_test/test_DustEmisZender2003.pf @@ -154,7 +154,7 @@ contains real(r8) :: flx_mss_vrt_dst_tot call this%input%create_atm2lnd() - this%input%water_inst%waterdiagnosticbulk_inst%frac_sno_col(:) = 1.0_r8 + this%input%water_inst%waterdiagnosticbulk_inst%frac_sno_albedo_col(:) = 1.0_r8 call this%input%create_fv( ) call this%dust_emis%DustEmission(bounds, this%input%num_nolakep, this%input%filter_nolakep, this%input%atm2lnd_inst, & this%input%soilstate_inst, this%input%canopystate_inst, this%input%water_inst%waterstatebulk_inst, & @@ -207,7 +207,7 @@ contains call this%input%create_atm2lnd() call this%input%create_fv( ) ! Dust should abort with an error on dust mobility when snow fraction greater than 1 - this%input%water_inst%waterdiagnosticbulk_inst%frac_sno_col(:) = 1.0_r8 + 1.e-15_r8 + this%input%water_inst%waterdiagnosticbulk_inst%frac_sno_albedo_col(:) = 1.0_r8 + 1.e-15_r8 call this%dust_emis%DustEmission(bounds, this%input%num_nolakep, this%input%filter_nolakep, this%input%atm2lnd_inst, & this%input%soilstate_inst, this%input%canopystate_inst, this%input%water_inst%waterstatebulk_inst, & this%input%water_inst%waterdiagnosticbulk_inst, this%input%frictionvel_inst) diff --git a/src/biogeophys/BalanceCheckMod.F90 b/src/biogeophys/BalanceCheckMod.F90 index b79fcee46e..7afcda7027 100644 --- a/src/biogeophys/BalanceCheckMod.F90 +++ b/src/biogeophys/BalanceCheckMod.F90 @@ -514,8 +514,8 @@ subroutine BalanceCheck( bounds, & forc_snow_grc => wateratm2lnd_inst%forc_snow_not_downscaled_grc, & ! Input: [real(r8) (:) ] grid cell-level snow rate [mm/s] h2osno_old => waterbalance_inst%h2osno_old_col , & ! Input: [real(r8) (:) ] snow water (mm H2O) at previous time step - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] effective snow fraction - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] effective snow fraction + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) begwb_grc => waterbalance_inst%begwb_grc , & ! Input: [real(r8) (:) ] grid cell-level water mass begining of the time step endwb_grc => waterbalance_inst%endwb_grc , & ! Output: [real(r8) (:) ] grid cell-level water mass end of the time step @@ -771,9 +771,9 @@ subroutine BalanceCheck( bounds, & if (lun%itype(l) == istdlak) then snow_sources(c) = qflx_snow_grnd_col(c) & - + frac_sno_eff(c) * (qflx_liq_grnd_col(c) & + + frac_sno_fluxes(c) * (qflx_liq_grnd_col(c) & + qflx_soliddew_to_top_layer(c) + qflx_liqdew_to_top_layer(c) ) - snow_sinks(c) = frac_sno_eff(c) * (qflx_solidevap_from_top_layer(c) & + snow_sinks(c) = frac_sno_fluxes(c) * (qflx_solidevap_from_top_layer(c) & + qflx_liqevap_from_top_layer(c) ) + qflx_snwcp_ice(c) + qflx_snwcp_liq(c) & + qflx_snwcp_discarded_ice_col(c) + qflx_snwcp_discarded_liq_col(c) & + qflx_snow_drain(c) + qflx_sl_top_soil(c) @@ -783,10 +783,10 @@ subroutine BalanceCheck( bounds, & lun%itype(l) == istcrop .or. lun%itype(l) == istwet .or. & lun%itype(l) == istice) then snow_sources(c) = (qflx_snow_grnd_col(c) - qflx_snow_h2osfc(c) ) & - + frac_sno_eff(c) * (qflx_liq_grnd_col(c) & + + frac_sno_fluxes(c) * (qflx_liq_grnd_col(c) & + qflx_soliddew_to_top_layer(c) + qflx_liqdew_to_top_layer(c) ) & + qflx_h2osfc_to_ice(c) - snow_sinks(c) = frac_sno_eff(c) * (qflx_solidevap_from_top_layer(c) & + snow_sinks(c) = frac_sno_fluxes(c) * (qflx_solidevap_from_top_layer(c) & + qflx_liqevap_from_top_layer(c)) + qflx_snwcp_ice(c) + qflx_snwcp_liq(c) & + qflx_snwcp_discarded_ice_col(c) + qflx_snwcp_discarded_liq_col(c) & + qflx_snow_drain(c) + qflx_sl_top_soil(c) @@ -823,7 +823,7 @@ subroutine BalanceCheck( bounds, & write(iulog,*)'errh2osno = ',errh2osno(indexc) write(iulog,*)'snl = ',col%snl(indexc) write(iulog,*)'snow_depth = ',snow_depth(indexc) - write(iulog,*)'frac_sno_eff = ',frac_sno_eff(indexc) + write(iulog,*)'frac_sno_fluxes = ',frac_sno_fluxes(indexc) write(iulog,*)'h2osno = ',h2osno_total(indexc) write(iulog,*)'h2osno_old = ',h2osno_old(indexc) write(iulog,*)'snow_sources = ',snow_sources(indexc)*dtime @@ -908,7 +908,7 @@ subroutine EnergyBalanceCheck( bounds, & forc_solai => atm2lnd_inst%forc_solai_grc , & ! Input: [real(r8) (:,:) ] diffuse radiation (vis=forc_solsd, nir=forc_solld) forc_lwrad => atm2lnd_inst%forc_lwrad_downscaled_col , & ! Input: [real(r8) (:) ] downward infrared (longwave) radiation (W/m**2) - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) dhsdt_canopy => energyflux_inst%dhsdt_canopy_patch , & ! Input: [real(r8) (:) ] change in heat content of canopy (W/m**2) [+ to atm] eflx_lwrad_out => energyflux_inst%eflx_lwrad_out_patch , & ! Input: [real(r8) (:) ] emitted infrared (longwave) radiation (W/m**2) @@ -1077,8 +1077,8 @@ subroutine EnergyBalanceCheck( bounds, & if ( errseb_max_val > error_thresh ) then write(iulog,*)'CTSM is stopping because errseb > ', error_thresh, ' W/m2' write(iulog,*)'sabv = ' ,sabv(indexp) - write(iulog,*)'sabg = ' ,sabg(indexp), ((1._r8- frac_sno(indexc))*sabg_soil(indexp) + & - frac_sno(indexc)*sabg_snow(indexp)),sabg_chk(indexp) + write(iulog,*)'sabg = ' ,sabg(indexp), ((1._r8- frac_sno_albedo(indexc))*sabg_soil(indexp) + & + frac_sno_albedo(indexc)*sabg_snow(indexp)),sabg_chk(indexp) write(iulog,*)'forc_tot = ' ,forc_solad(indexg,1) + forc_solad(indexg,2) + & forc_solai(indexg,1) + forc_solai(indexg,2) diff --git a/src/biogeophys/BiogeophysPreFluxCalcsMod.F90 b/src/biogeophys/BiogeophysPreFluxCalcsMod.F90 index 574af6f782..903c32e830 100644 --- a/src/biogeophys/BiogeophysPreFluxCalcsMod.F90 +++ b/src/biogeophys/BiogeophysPreFluxCalcsMod.F90 @@ -270,8 +270,8 @@ subroutine CalcInitialTemperatureAndEnergyVars(bounds, & elai => canopystate_inst%elai_patch , & ! Input: [real(r8) (:) ] one-sided leaf area index with burying by snow esai => canopystate_inst%esai_patch , & ! Input: [real(r8) (:) ] one-sided stem area index with burying by snow forc_hgt_t_patch => frictionvel_inst%forc_hgt_t_patch , & ! Input: [real(r8) (:) ] observational height of temperature at patch level [m] - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] ice lens (kg/m2) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid water (kg/m2) @@ -332,8 +332,8 @@ subroutine CalcInitialTemperatureAndEnergyVars(bounds, & ! ground temperature is weighted average of exposed soil, snow, and h2osfc if (snl(c) < 0) then - t_grnd(c) = frac_sno_eff(c) * t_soisno(c,snl(c)+1) & - + (1.0_r8 - frac_sno_eff(c) - frac_h2osfc(c)) * t_soisno(c,1) & + t_grnd(c) = frac_sno_fluxes(c) * t_soisno(c,snl(c)+1) & + + (1.0_r8 - frac_sno_fluxes(c) - frac_h2osfc(c)) * t_soisno(c,1) & + frac_h2osfc(c) * t_h2osfc(c) else t_grnd(c) = (1 - frac_h2osfc(c)) * t_soisno(c,1) + frac_h2osfc(c) * t_h2osfc(c) @@ -345,7 +345,7 @@ subroutine CalcInitialTemperatureAndEnergyVars(bounds, & if (lun%itype(l)==istice) then emg(c) = 0.97_r8 else - emg(c) = (1._r8-frac_sno(c))*0.96_r8 + frac_sno(c)*0.97_r8 + emg(c) = (1._r8-frac_sno_albedo(c))*0.96_r8 + frac_sno_albedo(c)*0.97_r8 end if end if diff --git a/src/biogeophys/CanopyFluxesMod.F90 b/src/biogeophys/CanopyFluxesMod.F90 index 74f62c4c80..07dbb5d5e2 100644 --- a/src/biogeophys/CanopyFluxesMod.F90 +++ b/src/biogeophys/CanopyFluxesMod.F90 @@ -563,7 +563,7 @@ subroutine CanopyFluxes(bounds, num_exposedvegp, filter_exposedvegp, frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of surface water fwet => waterdiagnosticbulk_inst%fwet_patch , & ! Input: [real(r8) (:) ] fraction of canopy that is wet (0 to 1) fdry => waterdiagnosticbulk_inst%fdry_patch , & ! Input: [real(r8) (:) ] fraction of foliage that is green and dry [-] - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) qg_snow => waterdiagnosticbulk_inst%qg_snow_col , & ! Input: [real(r8) (:) ] specific humidity at snow surface [kg/kg] qg_soil => waterdiagnosticbulk_inst%qg_soil_col , & ! Input: [real(r8) (:) ] specific humidity at soil surface [kg/kg] @@ -1298,8 +1298,8 @@ subroutine CanopyFluxes(bounds, num_exposedvegp, filter_exposedvegp, erre = efe(p) - efeold end if ! fractionate ground emitted longwave - lw_grnd=(frac_sno_eff(c)*t_soisno(c,snl(c)+1)**4 & - +(1._r8-frac_sno_eff(c)-frac_h2osfc(c))*t_soisno(c,1)**4 & + lw_grnd=(frac_sno_fluxes(c)*t_soisno(c,snl(c)+1)**4 & + +(1._r8-frac_sno_fluxes(c)-frac_h2osfc(c))*t_soisno(c,1)**4 & +frac_h2osfc(c)*t_h2osfc(c)**4) dt_veg(p) = ((1._r8-frac_rad_abs_by_stem(p))*(sabv(p) + air(p) & @@ -1468,8 +1468,8 @@ subroutine CanopyFluxes(bounds, num_exposedvegp, filter_exposedvegp, ! Energy balance check in canopy - lw_grnd=(frac_sno_eff(c)*t_soisno(c,snl(c)+1)**4 & - +(1._r8-frac_sno_eff(c)-frac_h2osfc(c))*t_soisno(c,1)**4 & + lw_grnd=(frac_sno_fluxes(c)*t_soisno(c,snl(c)+1)**4 & + +(1._r8-frac_sno_fluxes(c)-frac_h2osfc(c))*t_soisno(c,1)**4 & +frac_h2osfc(c)*t_h2osfc(c)**4) err(p) = (1.0_r8-frac_rad_abs_by_stem(p))*(sabv(p) + air(p) + bir(p)*tlbef(p)**3 & diff --git a/src/biogeophys/FrictionVelocityMod.F90 b/src/biogeophys/FrictionVelocityMod.F90 index 2cced839fe..219f293046 100644 --- a/src/biogeophys/FrictionVelocityMod.F90 +++ b/src/biogeophys/FrictionVelocityMod.F90 @@ -587,7 +587,7 @@ subroutine SetRoughnessLengthsAndForcHeightsNonLake(this, bounds, & displa => canopystate_inst%displa_patch , & ! Input: [real(r8) (:) ] displacement height (m) frac_veg_nosno => canopystate_inst%frac_veg_nosno_patch , & ! Input: [integer (:) ] fraction of vegetation not covered by snow (0 OR 1) [-] - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snomelt_accum => waterdiagnosticbulk_inst%snomelt_accum_col , & ! Input: [real(r8) (:) ] accumulated col snow melt for z0m calculation (m H2O) urbpoi => lun%urbpoi , & ! Input: [logical (:) ] true => landunit is an urban point z_0_town => lun%z_0_town , & ! Input: [real(r8) (:) ] momentum roughness length of urban landunit (m) @@ -606,14 +606,14 @@ subroutine SetRoughnessLengthsAndForcHeightsNonLake(this, bounds, & select case (z0param_method) case ('ZengWang2007') - if (frac_sno(c) > 0._r8) then + if (frac_sno_albedo(c) > 0._r8) then z0mg(c) = this%zsno else z0mg(c) = this%zlnd end if case ('Meier2022') ! Bare ground and ice have a different value l = col%landunit(c) - if (frac_sno(c) > 0._r8) then ! Do snow first because ice could be snow-covered + if (frac_sno_albedo(c) > 0._r8) then ! Do snow first because ice could be snow-covered if(use_z0m_snowmelt) then if ( snomelt_accum(c) < 1.e-5_r8 )then z0mg(c) = exp(-b1_param * rpi * 0.5_r8 + b4_param) * 1.e-3_r8 diff --git a/src/biogeophys/HydrologyNoDrainageMod.F90 b/src/biogeophys/HydrologyNoDrainageMod.F90 index 8f294c652e..419f7981e0 100644 --- a/src/biogeophys/HydrologyNoDrainageMod.F90 +++ b/src/biogeophys/HydrologyNoDrainageMod.F90 @@ -237,7 +237,7 @@ subroutine HydrologyNoDrainage(bounds, & snow_depth => b_waterdiagnostic_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height of snow covered area (m) snowdp => b_waterdiagnostic_inst%snowdp_col , & ! Input: [real(r8) (:) ] area-averaged snow height (m) - frac_sno_eff => b_waterdiagnostic_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] eff. snow cover fraction (col) [frc] + frac_sno_fluxes => b_waterdiagnostic_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] eff. snow cover fraction (col) [frc] frac_h2osfc => b_waterdiagnostic_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) snw_rds => b_waterdiagnostic_inst%snw_rds_col , & ! Output: [real(r8) (:,:) ] effective snow grain radius (col,lyr) [microns, m^-6] snw_rds_top => b_waterdiagnostic_inst%snw_rds_top_col , & ! Output: [real(r8) (:) ] effective snow grain size, top layer(col) [microns] @@ -451,7 +451,7 @@ subroutine HydrologyNoDrainage(bounds, & ! Calculate column average snow depth do c = bounds%begc,bounds%endc - snowdp(c) = snow_depth(c) * frac_sno_eff(c) + snowdp(c) = snow_depth(c) * frac_sno_fluxes(c) end do ! Calculate snow internal temperature @@ -553,8 +553,8 @@ subroutine HydrologyNoDrainage(bounds, & ! t_grnd is weighted average of exposed soil and snow if (snl(c) < 0) then - t_grnd(c) = frac_sno_eff(c) * t_soisno(c,snl(c)+1) & - + (1.0_r8 - frac_sno_eff(c)- frac_h2osfc(c)) * t_soisno(c,1) & + t_grnd(c) = frac_sno_fluxes(c) * t_soisno(c,snl(c)+1) & + + (1.0_r8 - frac_sno_fluxes(c)- frac_h2osfc(c)) * t_soisno(c,1) & + frac_h2osfc(c) * t_h2osfc(c) else t_grnd(c) = (1.0_r8 - frac_h2osfc(c)) * t_soisno(c,1) + frac_h2osfc(c) * t_h2osfc(c) diff --git a/src/biogeophys/LakeHydrologyMod.F90 b/src/biogeophys/LakeHydrologyMod.F90 index c1e69cbb13..62d462cd3c 100644 --- a/src/biogeophys/LakeHydrologyMod.F90 +++ b/src/biogeophys/LakeHydrologyMod.F90 @@ -123,7 +123,7 @@ subroutine LakeHydrology(bounds, & real(r8) :: heatrem ! used in case above [J/m^2] real(r8) :: heatsum(bounds%begc:bounds%endc) ! used in case above [J/m^2] real(r8) :: qflx_dew_minus_sub_snow ! qflx_soliddew_to_top_layer - qflx_solidevap_from_top_layer [mm/s] - real(r8), parameter :: frac_sno_small = 1.e-6_r8 ! small value of frac_sno used when initiating a snow pack due to frost + real(r8), parameter :: frac_sno_albedo_small = 1.e-6_r8 ! small value of frac_sno_albedo used when initiating a snow pack due to frost real(r8), parameter :: snow_bd = 250._r8 ! assumed snow bulk density (for lakes w/out resolved snow layers) [kg/m^3] ! Should only be used for frost below. !----------------------------------------------------------------------- @@ -172,8 +172,8 @@ subroutine LakeHydrology(bounds, & snw_rds_top => b_waterdiagnostic_inst%snw_rds_top_col , & ! Output: [real(r8) (:) ] effective snow grain size, top layer [microns] h2osno_top => b_waterdiagnostic_inst%h2osno_top_col , & ! Output: [real(r8) (:) ] mass of snow in top layer [kg] sno_liq_top => b_waterdiagnostic_inst%sno_liq_top_col , & ! Output: [real(r8) (:) ] liquid water fraction in top snow layer [frc] - frac_sno => b_waterdiagnostic_inst%frac_sno_col , & ! Output: [real(r8) (:) ] - frac_sno_eff => b_waterdiagnostic_inst%frac_sno_eff_col , & ! Output: [real(r8) (:) ] needed for snicar code + frac_sno_albedo => b_waterdiagnostic_inst%frac_sno_albedo_col , & ! Output: [real(r8) (:) ] + frac_sno_fluxes => b_waterdiagnostic_inst%frac_sno_fluxes_col , & ! Output: [real(r8) (:) ] needed for snicar code frac_iceold => b_waterdiagnostic_inst%frac_iceold_col , & ! Output: [real(r8) (:,:) ] fraction of ice relative to the tot water snow_depth => b_waterdiagnostic_inst%snow_depth_col , & ! Output: [real(r8) (:) ] snow height (m) h2osno_no_layers => b_waterstate_inst%h2osno_no_layers_col , & ! Output: [real(r8) (:) ] snow that is not resolved into layers (kg/m2) @@ -336,17 +336,17 @@ subroutine LakeHydrology(bounds, & h2osno_no_layers(c) = max(h2osno_no_layers(c), 0._r8) if (qflx_dew_minus_sub_snow > 0._r8) then ! If we're accumulating snow from dew, then ensure that we have at least a - ! small, non-zero frac_sno. (It complicates the code too much to call + ! small, non-zero frac_sno_albedo. (It complicates the code too much to call ! UpdateSnowDepthAndFrac for this purpose - see ! .) - if (frac_sno(c) <= 0._r8) then - frac_sno(c) = frac_sno_small + if (frac_sno_albedo(c) <= 0._r8) then + frac_sno_albedo(c) = frac_sno_albedo_small end if else if (qflx_dew_minus_sub_snow < 0._r8) then ! If we're losing snow from sublimation, and this has caused the snow pack - ! to completely vanish, then ensure that frac_sno is reset to 0. + ! to completely vanish, then ensure that frac_sno_albedo is reset to 0. if (h2osno_no_layers(c) == 0._r8) then - frac_sno(c) = 0._r8 + frac_sno_albedo(c) = 0._r8 end if end if if (h2osno_temp > 0._r8) then @@ -364,14 +364,14 @@ subroutine LakeHydrology(bounds, & end if end do - ! Since frac_sno may have been updated above, recalculate frac_sno_eff accordingly + ! Since frac_sno_albedo may have been updated above, recalculate frac_sno_fluxes accordingly call scf_method%CalcFracSnoEff(bounds, num_lakec, filter_lakec, & ! Inputs lun_itype_col = col%lun_itype(begc:endc), & urbpoi = col%urbpoi(begc:endc), & - frac_sno = frac_sno(begc:endc), & + frac_sno_albedo = frac_sno_albedo(begc:endc), & ! Outputs - frac_sno_eff = frac_sno_eff(begc:endc)) + frac_sno_fluxes = frac_sno_fluxes(begc:endc)) ! patch averages must be done here -- BEFORE SNOW CALCULATIONS AS THEY USE IT. ! for output to history tape and other uses diff --git a/src/biogeophys/SnowCoverFractionBaseMod.F90 b/src/biogeophys/SnowCoverFractionBaseMod.F90 index 2167fa0307..6e3958e9d6 100644 --- a/src/biogeophys/SnowCoverFractionBaseMod.F90 +++ b/src/biogeophys/SnowCoverFractionBaseMod.F90 @@ -25,7 +25,7 @@ module SnowCoverFractionBaseMod ! Common subroutines, implemented here ! ------------------------------------------------------------------------ - ! Calculate frac_sno_eff given frac_sno + ! Calculate frac_sno_fluxes given frac_sno_albedo procedure :: CalcFracSnoEff ! ------------------------------------------------------------------------ @@ -46,7 +46,7 @@ module SnowCoverFractionBaseMod subroutine UpdateSnowDepthAndFrac_Interface(this, bounds, num_c, filter_c, & lun_itype_col, urbpoi, h2osno_total, snowmelt, int_snow, newsnow, bifall, & - snow_depth, frac_sno, frac_sno_eff) + snow_depth, frac_sno_albedo, frac_sno_fluxes) ! Update snow depth and snow fraction use decompMod, only : bounds_type use shr_kind_mod , only : r8 => shr_kind_r8 @@ -66,12 +66,12 @@ subroutine UpdateSnowDepthAndFrac_Interface(this, bounds, num_c, filter_c, & real(r8) , intent(in) :: bifall( bounds%begc: ) ! bulk density of newly fallen dry snow (kg/m3) real(r8) , intent(inout) :: snow_depth( bounds%begc: ) ! snow height (m) - real(r8) , intent(inout) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) - real(r8) , intent(inout) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) end subroutine UpdateSnowDepthAndFrac_Interface subroutine AddNewsnowToIntsnow_Interface(this, bounds, num_c, filter_c, & - newsnow, h2osno_total, frac_sno, & + newsnow, h2osno_total, frac_sno_albedo, & int_snow) ! Add new snow to integrated snow fall use decompMod, only : bounds_type @@ -85,16 +85,16 @@ subroutine AddNewsnowToIntsnow_Interface(this, bounds, num_c, filter_c, & real(r8) , intent(in) :: newsnow( bounds%begc: ) ! total new snow in the time step (mm H2O) real(r8) , intent(in) :: h2osno_total( bounds%begc: ) ! total snow water (mm H2O) - real(r8) , intent(in) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) real(r8) , intent(inout) :: int_snow( bounds%begc: ) ! integrated snowfall (mm H2O) end subroutine AddNewsnowToIntsnow_Interface - pure function FracSnowDuringMelt_Interface(this, c, h2osno_total, int_snow) result(frac_sno) + pure function FracSnowDuringMelt_Interface(this, c, h2osno_total, int_snow) result(frac_sno_albedo) ! Single-point function: return fractional snow cover during melt use shr_kind_mod , only : r8 => shr_kind_r8 import :: snow_cover_fraction_base_type - real(r8) :: frac_sno ! function result + real(r8) :: frac_sno_albedo ! function result class(snow_cover_fraction_base_type), intent(in) :: this integer , intent(in) :: c ! column we're operating on real(r8), intent(in) :: h2osno_total ! total snow water (mm H2O) @@ -108,11 +108,11 @@ end function FracSnowDuringMelt_Interface !----------------------------------------------------------------------- subroutine CalcFracSnoEff(this, bounds, num_c, filter_c, & - lun_itype_col, urbpoi, frac_sno, & - frac_sno_eff) + lun_itype_col, urbpoi, frac_sno_albedo, & + frac_sno_fluxes) ! ! !DESCRIPTION: - ! Calculate frac_sno_eff given frac_sno + ! Calculate frac_sno_fluxes given frac_sno_albedo ! ! !ARGUMENTS: class(snow_cover_fraction_base_type), intent(in) :: this @@ -122,38 +122,38 @@ subroutine CalcFracSnoEff(this, bounds, num_c, filter_c, & integer , intent(in) :: lun_itype_col( bounds%begc: ) ! landunit type for each column logical , intent(in) :: urbpoi( bounds%begc: ) ! true if the given column is urban - real(r8) , intent(in) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) - real(r8) , intent(inout) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) ! ! !LOCAL VARIABLES: integer :: fc, c - logical :: allow_fractional_frac_sno_eff ! if true, frac_sno_eff can be fractional; otherwise it needs to be 0/1 + logical :: allow_fractional_frac_sno_fluxes ! if true, frac_sno_fluxes can be fractional; otherwise it needs to be 0/1 character(len=*), parameter :: subname = 'CalcFracSnoEff' !----------------------------------------------------------------------- SHR_ASSERT_FL((ubound(lun_itype_col, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(urbpoi, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_albedo, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) do fc = 1, num_c c = filter_c(fc) if (urbpoi(c) .or. lun_itype_col(c) == istdlak .or. .not. use_subgrid_fluxes) then ! subgrid_fluxes parameterization not used for urban and lake columns - allow_fractional_frac_sno_eff = .false. + allow_fractional_frac_sno_fluxes = .false. else - allow_fractional_frac_sno_eff = .true. + allow_fractional_frac_sno_fluxes = .true. end if - if (allow_fractional_frac_sno_eff) then - frac_sno_eff(c) = frac_sno(c) + if (allow_fractional_frac_sno_fluxes) then + frac_sno_fluxes(c) = frac_sno_albedo(c) else - if (frac_sno(c) > 0._r8) then - frac_sno_eff(c) = 1._r8 + if (frac_sno_albedo(c) > 0._r8) then + frac_sno_fluxes(c) = 1._r8 else - frac_sno_eff(c) = 0._r8 + frac_sno_fluxes(c) = 0._r8 end if end if end do diff --git a/src/biogeophys/SnowCoverFractionNiuYang2007Mod.F90 b/src/biogeophys/SnowCoverFractionNiuYang2007Mod.F90 index 31ae31eb6b..0fdd84f201 100644 --- a/src/biogeophys/SnowCoverFractionNiuYang2007Mod.F90 +++ b/src/biogeophys/SnowCoverFractionNiuYang2007Mod.F90 @@ -50,7 +50,7 @@ module SnowCoverFractionNiuYang2007Mod !----------------------------------------------------------------------- subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & lun_itype_col, urbpoi, h2osno_total, snowmelt, int_snow, newsnow, bifall, & - snow_depth, frac_sno, frac_sno_eff) + snow_depth, frac_sno_albedo, frac_sno_fluxes) ! ! !DESCRIPTION: ! Update snow depth and snow fraction using the NiuYang2007 parameterization @@ -70,8 +70,8 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & real(r8) , intent(in) :: bifall( bounds%begc: ) ! bulk density of newly fallen dry snow (kg/m3) real(r8) , intent(inout) :: snow_depth( bounds%begc: ) ! snow height (m) - real(r8) , intent(inout) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) - real(r8) , intent(inout) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) ! ! !LOCAL VARIABLES: integer :: fc, c @@ -87,8 +87,8 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & SHR_ASSERT_FL((ubound(newsnow, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(bifall, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(snow_depth, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_albedo, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) associate( & begc => bounds%begc, & @@ -108,32 +108,32 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & snow_depth(c) = snow_depth(c) + newsnow(c) / bifall(c) if (snow_depth(c) > 0.0_r8) then - frac_sno(c) = tanh(snow_depth(c) / (2.5_r8 * this%zlnd * & + frac_sno_albedo(c) = tanh(snow_depth(c) / (2.5_r8 * this%zlnd * & (min(800._r8,(h2osno_total(c)+ newsnow(c))/snow_depth(c))/100._r8)**1._r8) ) else - frac_sno(c) = 0._r8 + frac_sno_albedo(c) = 0._r8 end if ! NOTE(wjs, 2019-08-03) I'm not sure what the intent is of the following block, and ! it feels to me like this should be looking at (h2osno_total+newsnow), both in the ! condition and in the min, but for now I'm keeping the pre-existing logic. if (h2osno_total(c) > 0.0_r8 .and. h2osno_total(c) < 1.0_r8) then - frac_sno(c) = min(frac_sno(c), h2osno_total(c)) + frac_sno_albedo(c) = min(frac_sno_albedo(c), h2osno_total(c)) end if end do call this%CalcFracSnoEff(bounds, num_c, filter_c, & lun_itype_col = lun_itype_col(begc:endc), & urbpoi = urbpoi(begc:endc), & - frac_sno = frac_sno(begc:endc), & - frac_sno_eff = frac_sno_eff(begc:endc)) + frac_sno_albedo = frac_sno_albedo(begc:endc), & + frac_sno_fluxes = frac_sno_fluxes(begc:endc)) end associate end subroutine UpdateSnowDepthAndFrac !----------------------------------------------------------------------- subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & - newsnow, h2osno_total, frac_sno, & + newsnow, h2osno_total, frac_sno_albedo, & int_snow) ! ! !DESCRIPTION: @@ -149,7 +149,7 @@ subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & real(r8) , intent(in) :: newsnow( bounds%begc: ) ! total new snow in the time step (mm H2O) real(r8) , intent(in) :: h2osno_total( bounds%begc: ) ! total snow water (mm H2O) - real(r8) , intent(in) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) real(r8) , intent(inout) :: int_snow( bounds%begc: ) ! integrated snowfall (mm H2O) ! ! !LOCAL VARIABLES: @@ -160,7 +160,7 @@ subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & SHR_ASSERT_FL((ubound(newsnow, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(h2osno_total, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_albedo, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(int_snow, 1) == bounds%endc), sourcefile, __LINE__) do fc = 1, num_c @@ -171,7 +171,7 @@ subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & end subroutine AddNewsnowToIntsnow !----------------------------------------------------------------------- - pure function FracSnowDuringMelt(this, c, h2osno_total, int_snow) result(frac_sno) + pure function FracSnowDuringMelt(this, c, h2osno_total, int_snow) result(frac_sno_albedo) ! ! !DESCRIPTION: ! Single-point function giving frac_snow during times when the snow pack is melting @@ -182,7 +182,7 @@ pure function FracSnowDuringMelt(this, c, h2osno_total, int_snow) result(frac_sn ! the NiuYang07 method. ! ! !ARGUMENTS: - real(r8) :: frac_sno ! function result + real(r8) :: frac_sno_albedo ! function result class(snow_cover_fraction_niu_yang_2007_type), intent(in) :: this integer , intent(in) :: c ! column we're operating on real(r8), intent(in) :: h2osno_total ! total snow water (mm H2O) @@ -193,7 +193,7 @@ pure function FracSnowDuringMelt(this, c, h2osno_total, int_snow) result(frac_sn character(len=*), parameter :: subname = 'FracSnowDuringMelt' !----------------------------------------------------------------------- - frac_sno = nan + frac_sno_albedo = nan end function FracSnowDuringMelt diff --git a/src/biogeophys/SnowCoverFractionSwensonLawrence2012Mod.F90 b/src/biogeophys/SnowCoverFractionSwensonLawrence2012Mod.F90 index f6a5ff41ee..5b0de42c3c 100644 --- a/src/biogeophys/SnowCoverFractionSwensonLawrence2012Mod.F90 +++ b/src/biogeophys/SnowCoverFractionSwensonLawrence2012Mod.F90 @@ -64,7 +64,7 @@ module SnowCoverFractionSwensonLawrence2012Mod !----------------------------------------------------------------------- subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & lun_itype_col, urbpoi, h2osno_total, snowmelt, int_snow, newsnow, bifall, & - snow_depth, frac_sno, frac_sno_eff) + snow_depth, frac_sno_albedo, frac_sno_fluxes) ! ! !DESCRIPTION: ! Update snow depth and snow fraction using the SwensonLawrence2012 parameterization @@ -84,8 +84,8 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & real(r8) , intent(in) :: bifall( bounds%begc: ) ! bulk density of newly fallen dry snow (kg/m3) real(r8) , intent(inout) :: snow_depth( bounds%begc: ) ! snow height (m) - real(r8) , intent(inout) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) - real(r8) , intent(inout) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) ! ! !LOCAL VARIABLES: integer :: fc, c @@ -102,8 +102,8 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & SHR_ASSERT_FL((ubound(newsnow, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(bifall, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(snow_depth, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_albedo, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) associate( & begc => bounds%begc, & @@ -111,7 +111,7 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & ) ! ------------------------------------------------------------------------ - ! Update frac_sno + ! Update frac_sno_albedo ! ------------------------------------------------------------------------ do fc = 1, num_c @@ -121,18 +121,18 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & ! fsca parameterization based on *changes* in swe if (h2osno_total(c) == 0._r8) then if (newsnow(c) > 0._r8) then - frac_sno(c) = tanh(this%accum_factor * newsnow(c)) + frac_sno_albedo(c) = tanh(this%accum_factor * newsnow(c)) else - ! NOTE(wjs, 2019-08-07) This resetting of frac_sno to 0 when h2osno_total is 0 + ! NOTE(wjs, 2019-08-07) This resetting of frac_sno_albedo to 0 when h2osno_total is 0 ! may already be done elsewhere; if it isn't, it possibly *should* be done ! elsewhere rather than here. - frac_sno(c) = 0._r8 + frac_sno_albedo(c) = 0._r8 end if else ! h2osno_total(c) > 0 if (snowmelt(c) > 0._r8) then ! first compute change from melt during previous time step - frac_sno(c) = this%FracSnowDuringMelt( & + frac_sno_albedo(c) = this%FracSnowDuringMelt( & c = c, & h2osno_total = h2osno_total(c), & int_snow = int_snow(c)) @@ -142,11 +142,11 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & ! Update fsca by new snow event, add to previous fsca ! The form in Swenson & Lawrence 2012 (eqn. 3) is: - ! 1._r8 - (1._r8 - tanh(this%accum_factor * newsnow(c))) * (1._r8 - frac_sno(c)) + ! 1._r8 - (1._r8 - tanh(this%accum_factor * newsnow(c))) * (1._r8 - frac_sno_albedo(c)) ! ! This form is algebraically equivalent, but simpler and less prone to ! roundoff errors (see https://github.com/ESCOMP/ctsm/issues/784) - frac_sno(c) = frac_sno(c) + tanh(this%accum_factor * newsnow(c)) * (1._r8 - frac_sno(c)) + frac_sno_albedo(c) = frac_sno_albedo(c) + tanh(this%accum_factor * newsnow(c)) * (1._r8 - frac_sno_albedo(c)) end if end if @@ -155,8 +155,8 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & call this%CalcFracSnoEff(bounds, num_c, filter_c, & lun_itype_col = lun_itype_col(begc:endc), & urbpoi = urbpoi(begc:endc), & - frac_sno = frac_sno(begc:endc), & - frac_sno_eff = frac_sno_eff(begc:endc)) + frac_sno_albedo = frac_sno_albedo(begc:endc), & + frac_sno_fluxes = frac_sno_fluxes(begc:endc)) ! ------------------------------------------------------------------------ ! Update snow_depth @@ -166,8 +166,8 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & c = filter_c(fc) if (h2osno_total(c) > 0.0_r8) then - if (frac_sno_eff(c) > 0._r8)then - snow_depth(c)=snow_depth(c) + newsnow(c)/(bifall(c) * frac_sno_eff(c)) + if (frac_sno_fluxes(c) > 0._r8)then + snow_depth(c)=snow_depth(c) + newsnow(c)/(bifall(c) * frac_sno_fluxes(c)) else snow_depth(c)=0._r8 end if @@ -175,7 +175,7 @@ subroutine UpdateSnowDepthAndFrac(this, bounds, num_c, filter_c, & else ! h2osno_total == 0 if (newsnow(c) > 0._r8) then z_avg = newsnow(c)/bifall(c) - snow_depth(c) = z_avg/frac_sno_eff(c) + snow_depth(c) = z_avg/frac_sno_fluxes(c) else snow_depth(c) = 0._r8 end if @@ -188,7 +188,7 @@ end subroutine UpdateSnowDepthAndFrac !----------------------------------------------------------------------- subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & - newsnow, h2osno_total, frac_sno, & + newsnow, h2osno_total, frac_sno_albedo, & int_snow) ! ! !DESCRIPTION: @@ -205,7 +205,7 @@ subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & real(r8) , intent(in) :: newsnow( bounds%begc: ) ! total new snow in the time step (mm H2O) real(r8) , intent(in) :: h2osno_total( bounds%begc: ) ! total snow water (mm H2O) - real(r8) , intent(in) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) real(r8) , intent(inout) :: int_snow( bounds%begc: ) ! integrated snowfall (mm H2O) ! ! !LOCAL VARIABLES: @@ -217,7 +217,7 @@ subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & SHR_ASSERT_FL((ubound(newsnow, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(h2osno_total, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_albedo, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(int_snow, 1) == bounds%endc), sourcefile, __LINE__) do fc = 1, num_c @@ -227,7 +227,7 @@ subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & ! reset int_snow after accumulation events: make int_snow consistent with new ! fsno, h2osno_total temp_intsnow= (h2osno_total(c) + newsnow(c)) & - / (0.5*(cos(rpi*(1._r8-max(frac_sno(c),1e-6_r8))**(1./this%n_melt(c)))+1._r8)) + / (0.5*(cos(rpi*(1._r8-max(frac_sno_albedo(c),1e-6_r8))**(1./this%n_melt(c)))+1._r8)) int_snow(c) = min(1.e8_r8,temp_intsnow) end if @@ -241,13 +241,13 @@ subroutine AddNewsnowToIntsnow(this, bounds, num_c, filter_c, & end subroutine AddNewsnowToIntsnow !----------------------------------------------------------------------- - pure function FracSnowDuringMelt(this, c, h2osno_total, int_snow) result(frac_sno) + pure function FracSnowDuringMelt(this, c, h2osno_total, int_snow) result(frac_sno_albedo) ! ! !DESCRIPTION: ! Single-point function giving frac_snow during times when the snow pack is melting ! ! !ARGUMENTS: - real(r8) :: frac_sno ! function result + real(r8) :: frac_sno_albedo ! function result class(snow_cover_fraction_swenson_lawrence_2012_type), intent(in) :: this integer , intent(in) :: c ! column we're operating on real(r8), intent(in) :: h2osno_total ! total snow water (mm H2O) @@ -263,7 +263,7 @@ pure function FracSnowDuringMelt(this, c, h2osno_total, int_snow) result(frac_sn int_snow_limited = min(int_snow, this%int_snow_max) smr = min(1._r8, h2osno_total/int_snow_limited) - frac_sno = 1. - (acos(min(1._r8,(2.*smr - 1._r8)))/rpi)**(this%n_melt(c)) + frac_sno_albedo = 1. - (acos(min(1._r8,(2.*smr - 1._r8)))/rpi)**(this%n_melt(c)) end function FracSnowDuringMelt diff --git a/src/biogeophys/SnowHydrologyMod.F90 b/src/biogeophys/SnowHydrologyMod.F90 index 2677277f28..979fbeea4b 100644 --- a/src/biogeophys/SnowHydrologyMod.F90 +++ b/src/biogeophys/SnowHydrologyMod.F90 @@ -396,8 +396,8 @@ subroutine UpdateQuantitiesForNewSnow(bounds, num_c, filter_c, & dz = col%dz(begc:endc,:), & int_snow = b_waterstate_inst%int_snow_col(begc:endc), & swe_old = b_waterdiagnostic_inst%swe_old_col(begc:endc,:), & - frac_sno = b_waterdiagnostic_inst%frac_sno_col(begc:endc), & - frac_sno_eff = b_waterdiagnostic_inst%frac_sno_eff_col(begc:endc), & + frac_sno_albedo = b_waterdiagnostic_inst%frac_sno_albedo_col(begc:endc), & + frac_sno_fluxes = b_waterdiagnostic_inst%frac_sno_fluxes_col(begc:endc), & snow_depth = b_waterdiagnostic_inst%snow_depth_col(begc:endc), & snomelt_accum = b_waterdiagnostic_inst%snomelt_accum_col(begc:endc)) @@ -423,7 +423,7 @@ subroutine BulkDiag_NewSnowDiagnostics(bounds, num_c, filter_c, & scf_method, & dtime, lun_itype_col, urbpoi, snl, bifall, h2osno_total, h2osoi_ice, h2osoi_liq, & qflx_snow_grnd, qflx_snow_drain, & - dz, int_snow, swe_old, frac_sno, frac_sno_eff, snow_depth, snomelt_accum) + dz, int_snow, swe_old, frac_sno_albedo, frac_sno_fluxes, snow_depth, snomelt_accum) ! ! !DESCRIPTION: ! Update various snow-related diagnostic quantities to account for new snow @@ -447,8 +447,8 @@ subroutine BulkDiag_NewSnowDiagnostics(bounds, num_c, filter_c, & real(r8) , intent(inout) :: dz( bounds%begc: , -nlevsno+1: ) ! layer depth (m) real(r8) , intent(inout) :: int_snow( bounds%begc: ) ! integrated snowfall (mm H2O) real(r8) , intent(inout) :: swe_old( bounds%begc:, -nlevsno+1: ) ! snow water before update (mm H2O) - real(r8) , intent(inout) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) - real(r8) , intent(inout) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) real(r8) , intent(inout) :: snow_depth( bounds%begc: ) ! snow height (m) real(r8) , intent(inout) :: snomelt_accum( bounds%begc: ) ! accumulated col snow melt for z0m calculation (m H2O) ! @@ -476,8 +476,8 @@ subroutine BulkDiag_NewSnowDiagnostics(bounds, num_c, filter_c, & SHR_ASSERT_FL((ubound(dz, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(int_snow, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(swe_old) == [bounds%endc, 0]), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_albedo, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(snow_depth, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(snomelt_accum, 1) == bounds%endc), sourcefile, __LINE__) @@ -526,8 +526,8 @@ subroutine BulkDiag_NewSnowDiagnostics(bounds, num_c, filter_c, & bifall = bifall(begc:endc), & ! Outputs snow_depth = snow_depth(begc:endc), & - frac_sno = frac_sno(begc:endc), & - frac_sno_eff = frac_sno_eff(begc:endc)) + frac_sno_albedo = frac_sno_albedo(begc:endc), & + frac_sno_fluxes = frac_sno_fluxes(begc:endc)) do fc = 1, num_c c = filter_c(fc) @@ -542,7 +542,7 @@ subroutine BulkDiag_NewSnowDiagnostics(bounds, num_c, filter_c, & ! Inputs newsnow = newsnow(begc:endc), & h2osno_total = h2osno_total(begc:endc), & - frac_sno = frac_sno(begc:endc), & + frac_sno_albedo = frac_sno_albedo(begc:endc), & ! Outputs int_snow = int_snow(begc:endc)) @@ -811,7 +811,7 @@ subroutine InitializeExplicitSnowPack(bounds, num_c, filter_c, & ! Inputs snl = col%snl(begc:endc), & lun_itype_col = col%lun_itype(begc:endc), & - frac_sno_eff = b_waterdiagnostic_inst%frac_sno_eff_col(begc:endc), & + frac_sno_fluxes = b_waterdiagnostic_inst%frac_sno_fluxes_col(begc:endc), & snow_depth = b_waterdiagnostic_inst%snow_depth_col(begc:endc), & qflx_snow_grnd = b_waterflux_inst%qflx_snow_grnd_col(begc:endc), & ! Outputs @@ -855,7 +855,7 @@ end subroutine InitializeExplicitSnowPack !----------------------------------------------------------------------- subroutine BuildFilter_SnowpackInitialized(bounds, num_c, filter_c, & - snl, lun_itype_col, frac_sno_eff, snow_depth, qflx_snow_grnd, & + snl, lun_itype_col, frac_sno_fluxes, snow_depth, qflx_snow_grnd, & snowpack_initialized_filterc) ! ! !DESCRIPTION: @@ -868,7 +868,7 @@ subroutine BuildFilter_SnowpackInitialized(bounds, num_c, filter_c, & integer , intent(in) :: snl( bounds%begc: ) ! negative number of snow layers integer , intent(in) :: lun_itype_col( bounds%begc: ) ! landunit type for each column - real(r8) , intent(in) :: frac_sno_eff( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_fluxes( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) real(r8) , intent(in) :: snow_depth( bounds%begc: ) ! snow height (m) real(r8) , intent(in) :: qflx_snow_grnd( bounds%begc: ) ! snow on ground after interception (mm H2O/s) type(filter_col_type) , intent(out) :: snowpack_initialized_filterc ! column filter: columns where an explicit snow pack is initialized @@ -882,7 +882,7 @@ subroutine BuildFilter_SnowpackInitialized(bounds, num_c, filter_c, & SHR_ASSERT_FL((ubound(snl, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(lun_itype_col, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(snow_depth, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_snow_grnd, 1) == bounds%endc), sourcefile, __LINE__) @@ -897,12 +897,12 @@ subroutine BuildFilter_SnowpackInitialized(bounds, num_c, filter_c, & ! maintain answers as before. snowpack_initialized(c) = ( & snl(c) == 0 .and. & - frac_sno_eff(c)*snow_depth(c) >= (dzmin(1) + lsadz) .and. & + frac_sno_fluxes(c)*snow_depth(c) >= (dzmin(1) + lsadz) .and. & qflx_snow_grnd(c) > 0.0_r8) else snowpack_initialized(c) = ( & snl(c) == 0 .and. & - frac_sno_eff(c)*snow_depth(c) >= dzmin(1)) + frac_sno_fluxes(c)*snow_depth(c) >= dzmin(1)) end if end do @@ -1065,7 +1065,7 @@ subroutine SnowWater(bounds, & name = water_inst%GetBulkOrTracerName(i), & dtime = dtime, & snl = col%snl(begc:endc), & - frac_sno_eff = b_waterdiagnostic_inst%frac_sno_eff_col(begc:endc), & + frac_sno_fluxes = b_waterdiagnostic_inst%frac_sno_fluxes_col(begc:endc), & qflx_soliddew_to_top_layer = w%waterflux_inst%qflx_soliddew_to_top_layer_col(begc:endc), & qflx_solidevap_from_top_layer = w%waterflux_inst%qflx_solidevap_from_top_layer_col(begc:endc), & qflx_liq_grnd = w%waterflux_inst%qflx_liq_grnd_col(begc:endc), & @@ -1082,7 +1082,7 @@ subroutine SnowWater(bounds, & dtime = dtime, & snl = col%snl(begc:endc), & dz = col%dz(begc:endc,:), & - frac_sno_eff = b_waterdiagnostic_inst%frac_sno_eff_col(begc:endc), & + frac_sno_fluxes = b_waterdiagnostic_inst%frac_sno_fluxes_col(begc:endc), & h2osoi_ice = b_waterstate_inst%h2osoi_ice_col(begc:endc,:), & h2osoi_liq = b_waterstate_inst%h2osoi_liq_col(begc:endc,:), & ! Outputs @@ -1136,14 +1136,14 @@ subroutine SnowWater(bounds, & num_snowc, filter_snowc, num_nosnowc, filter_nosnowc, & ! Inputs dtime = dtime, & - frac_sno_eff = b_waterdiagnostic_inst%frac_sno_eff_col(begc:endc), & + frac_sno_fluxes = b_waterdiagnostic_inst%frac_sno_fluxes_col(begc:endc), & qflx_soliddew_to_top_layer = b_waterflux_inst%qflx_soliddew_to_top_layer_col(begc:endc), & qflx_liqdew_to_top_layer = b_waterflux_inst%qflx_liqdew_to_top_layer_col(begc:endc), & qflx_liq_grnd = b_waterflux_inst%qflx_liq_grnd_col(begc:endc), & h2osno_no_layers = b_waterstate_inst%h2osno_no_layers_col(begc:endc), & ! Outputs int_snow = b_waterstate_inst%int_snow_col(begc:endc), & - frac_sno = b_waterdiagnostic_inst%frac_sno_col(begc:endc), & + frac_sno_albedo = b_waterdiagnostic_inst%frac_sno_albedo_col(begc:endc), & snow_depth = b_waterdiagnostic_inst%snow_depth_col(begc:endc)) do i = water_inst%bulk_and_tracers_beg, water_inst%bulk_and_tracers_end @@ -1151,7 +1151,7 @@ subroutine SnowWater(bounds, & call SumFlux_AddSnowPercolation(bounds, & num_snowc, filter_snowc, num_nosnowc, filter_nosnowc, & ! Inputs - frac_sno_eff = b_waterdiagnostic_inst%frac_sno_eff_col(begc:endc), & + frac_sno_fluxes = b_waterdiagnostic_inst%frac_sno_fluxes_col(begc:endc), & qflx_snow_percolation_bottom = w%waterflux_inst%qflx_snow_percolation_col(begc:endc, 0), & qflx_liq_grnd = w%waterflux_inst%qflx_liq_grnd_col(begc:endc), & qflx_snomelt = w%waterflux_inst%qflx_snomelt_col(begc:endc), & @@ -1166,7 +1166,7 @@ end subroutine SnowWater !----------------------------------------------------------------------- subroutine UpdateState_TopLayerFluxes(bounds, num_snowc, filter_snowc, & - name, dtime, snl, frac_sno_eff, & + name, dtime, snl, frac_sno_fluxes, & qflx_soliddew_to_top_layer, qflx_solidevap_from_top_layer, qflx_liq_grnd, & qflx_liqdew_to_top_layer, qflx_liqevap_from_top_layer, h2osoi_ice, h2osoi_liq) ! @@ -1182,7 +1182,7 @@ subroutine UpdateState_TopLayerFluxes(bounds, num_snowc, filter_snowc, & character(len=*) , intent(in) :: name ! Name of bulk or this tracer (for output in case there's an error) real(r8) , intent(in) :: dtime ! land model time step (sec) integer , intent(in) :: snl( bounds%begc: ) ! negative number of snow layers - real(r8) , intent(in) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) real(r8) , intent(in) :: qflx_liqdew_to_top_layer( bounds%begc: ) ! rate of liquid water deposited on top soil or snow layer (dew) (mm H2O /s) real(r8) , intent(in) :: qflx_solidevap_from_top_layer( bounds%begc: ) ! rate of ice evaporated from top soil or snow layer (sublimation) (mm H2O /s) real(r8) , intent(in) :: qflx_liq_grnd( bounds%begc: ) ! liquid on ground after interception (mm H2O/s) @@ -1202,7 +1202,7 @@ subroutine UpdateState_TopLayerFluxes(bounds, num_snowc, filter_snowc, & !----------------------------------------------------------------------- SHR_ASSERT_FL((ubound(snl, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_soliddew_to_top_layer, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_solidevap_from_top_layer, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_liq_grnd, 1) == bounds%endc), sourcefile, __LINE__) @@ -1222,11 +1222,11 @@ subroutine UpdateState_TopLayerFluxes(bounds, num_snowc, filter_snowc, & h2osoi_liq_top_orig(c) = h2osoi_liq(c,lev_top(c)) h2osoi_ice(c,lev_top(c)) = h2osoi_ice(c,lev_top(c)) & - + frac_sno_eff(c) * (qflx_soliddew_to_top_layer(c) & + + frac_sno_fluxes(c) * (qflx_soliddew_to_top_layer(c) & - qflx_solidevap_from_top_layer(c)) * dtime h2osoi_liq(c,lev_top(c)) = h2osoi_liq(c,lev_top(c)) + & - frac_sno_eff(c) * (qflx_liq_grnd(c) + qflx_liqdew_to_top_layer(c) & + frac_sno_fluxes(c) * (qflx_liq_grnd(c) + qflx_liqdew_to_top_layer(c) & - qflx_liqevap_from_top_layer(c)) * dtime end do @@ -1264,7 +1264,7 @@ subroutine UpdateState_TopLayerFluxes(bounds, num_snowc, filter_snowc, & write(iulog,*) "c, lev_top(c) = ", c, lev_top(c) write(iulog,*) "h2osoi_ice_top_orig = ", h2osoi_ice_top_orig(c) write(iulog,*) "h2osoi_ice = ", h2osoi_ice(c,lev_top(c)) - write(iulog,*) "frac_sno_eff = ", frac_sno_eff(c) + write(iulog,*) "frac_sno_fluxes = ", frac_sno_fluxes(c) write(iulog,*) "qflx_soliddew_to_top_layer*dtime = ", qflx_soliddew_to_top_layer(c)*dtime write(iulog,*) "qflx_solidevap_from_top_layer*dtime = ", qflx_solidevap_from_top_layer(c)*dtime call endrun(subgrid_index=c, subgrid_level=subgrid_level_column, & @@ -1277,7 +1277,7 @@ subroutine UpdateState_TopLayerFluxes(bounds, num_snowc, filter_snowc, & write(iulog,*) "c, lev_top(c) = ", c, lev_top(c) write(iulog,*) "h2osoi_liq_top_orig = ", h2osoi_liq_top_orig(c) write(iulog,*) "h2osoi_liq = ", h2osoi_liq(c,lev_top(c)) - write(iulog,*) "frac_sno_eff = ", frac_sno_eff(c) + write(iulog,*) "frac_sno_fluxes = ", frac_sno_fluxes(c) write(iulog,*) "qflx_liq_grnd*dtime = ", qflx_liq_grnd(c)*dtime write(iulog,*) "qflx_liqdew_to_top_layer*dtime = ", qflx_liqdew_to_top_layer(c)*dtime write(iulog,*) "qflx_liqevap_from_top_layer*dtime = ", qflx_liqevap_from_top_layer(c)*dtime @@ -1291,7 +1291,7 @@ end subroutine UpdateState_TopLayerFluxes !----------------------------------------------------------------------- subroutine BulkFlux_SnowPercolation(bounds, num_snowc, filter_snowc, & - dtime, snl, dz, frac_sno_eff, h2osoi_ice, h2osoi_liq, & + dtime, snl, dz, frac_sno_fluxes, h2osoi_ice, h2osoi_liq, & qflx_snow_percolation) ! ! !DESCRIPTION: @@ -1308,7 +1308,7 @@ subroutine BulkFlux_SnowPercolation(bounds, num_snowc, filter_snowc, & real(r8) , intent(in) :: dtime ! land model time step (sec) integer , intent(in) :: snl( bounds%begc: ) ! negative number of snow layers real(r8) , intent(in) :: dz( bounds%begc: , -nlevsno+1: ) ! layer depth (m) - real(r8) , intent(in) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) real(r8) , intent(in) :: h2osoi_ice( bounds%begc: , -nlevsno+1: ) ! ice lens (kg/m2) real(r8) , intent(in) :: h2osoi_liq( bounds%begc: , -nlevsno+1: ) ! liquid water (kg/m2) @@ -1326,7 +1326,7 @@ subroutine BulkFlux_SnowPercolation(bounds, num_snowc, filter_snowc, & SHR_ASSERT_FL((ubound(snl, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(dz, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(h2osoi_ice, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(h2osoi_liq, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_snow_percolation, 1) == bounds%endc), sourcefile, __LINE__) @@ -1337,10 +1337,10 @@ subroutine BulkFlux_SnowPercolation(bounds, num_snowc, filter_snowc, & do fc = 1, num_snowc c = filter_snowc(fc) if (j >= snl(c)+1) then - ! need to scale dz by frac_sno to convert to grid cell average depth - vol_ice(c,j) = min(1._r8, h2osoi_ice(c,j)/(dz(c,j)*frac_sno_eff(c)*denice)) + ! need to scale dz by frac_sno_albedo to convert to grid cell average depth + vol_ice(c,j) = min(1._r8, h2osoi_ice(c,j)/(dz(c,j)*frac_sno_fluxes(c)*denice)) eff_porosity(c,j) = 1._r8 - vol_ice(c,j) - vol_liq(c,j) = min(eff_porosity(c,j),h2osoi_liq(c,j)/(dz(c,j)*frac_sno_eff(c)*denh2o)) + vol_liq(c,j) = min(eff_porosity(c,j),h2osoi_liq(c,j)/(dz(c,j)*frac_sno_fluxes(c)*denh2o)) end if end do end do @@ -1364,15 +1364,15 @@ subroutine BulkFlux_SnowPercolation(bounds, num_snowc, filter_snowc, & if (eff_porosity(c,j) < params_inst%wimp .OR. eff_porosity(c,j+1) < params_inst%wimp) then qflx_snow_percolation(c,j) = 0._r8 else - ! dz must be scaled by frac_sno to obtain gridcell average value + ! dz must be scaled by frac_sno_albedo to obtain gridcell average value qflx_snow_percolation(c,j) = max(0._r8,(vol_liq(c,j) & - - params_inst%ssi*eff_porosity(c,j))*dz(c,j)*frac_sno_eff(c)) + - params_inst%ssi*eff_porosity(c,j))*dz(c,j)*frac_sno_fluxes(c)) qflx_snow_percolation(c,j) = min(qflx_snow_percolation(c,j),(1._r8-vol_ice(c,j+1) & - - vol_liq(c,j+1))*dz(c,j+1)*frac_sno_eff(c)) + - vol_liq(c,j+1))*dz(c,j+1)*frac_sno_fluxes(c)) end if else qflx_snow_percolation(c,j) = max(0._r8,(vol_liq(c,j) & - - params_inst%ssi*eff_porosity(c,j))*dz(c,j)*frac_sno_eff(c)) + - params_inst%ssi*eff_porosity(c,j))*dz(c,j)*frac_sno_fluxes(c)) end if qflx_snow_percolation(c,j) = (qflx_snow_percolation(c,j)*1000._r8)/dtime end if @@ -1752,8 +1752,8 @@ end subroutine PostPercolation_AdjustLayerThicknesses !----------------------------------------------------------------------- subroutine BulkDiag_SnowWaterAccumulatedSnow(bounds, & num_snowc, filter_snowc, num_nosnowc, filter_nosnowc, & - dtime, frac_sno_eff, qflx_soliddew_to_top_layer, qflx_liqdew_to_top_layer, & - qflx_liq_grnd, h2osno_no_layers, int_snow, frac_sno, snow_depth) + dtime, frac_sno_fluxes, qflx_soliddew_to_top_layer, qflx_liqdew_to_top_layer, & + qflx_liq_grnd, h2osno_no_layers, int_snow, frac_sno_albedo, snow_depth) ! ! !DESCRIPTION: ! Update int_snow, and reset accumulated snow when no snow present @@ -1766,14 +1766,14 @@ subroutine BulkDiag_SnowWaterAccumulatedSnow(bounds, & integer, intent(in) :: filter_nosnowc(:) real(r8) , intent(in) :: dtime ! land model time step (sec) - real(r8) , intent(in) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) real(r8) , intent(in) :: qflx_soliddew_to_top_layer( bounds%begc: ) ! rate of solid water deposited on top soil or snow layer (frost) (mm H2O /s) real(r8) , intent(in) :: qflx_liqdew_to_top_layer( bounds%begc: ) ! rate of liquid water deposited on top soil or snow layer (dew) (mm H2O /s) real(r8) , intent(in) :: qflx_liq_grnd( bounds%begc: ) ! liquid on ground after interception (mm H2O/s) real(r8) , intent(in) :: h2osno_no_layers( bounds%begc: ) ! snow that is not resolved into layers (kg/m2) real(r8) , intent(inout) :: int_snow( bounds%begc: ) ! integrated snowfall (mm H2O) - real(r8) , intent(inout) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) real(r8) , intent(inout) :: snow_depth( bounds%begc: ) ! snow height (m) ! ! !LOCAL VARIABLES: @@ -1782,19 +1782,19 @@ subroutine BulkDiag_SnowWaterAccumulatedSnow(bounds, & character(len=*), parameter :: subname = 'BulkDiag_SnowWaterAccumulatedSnow' !----------------------------------------------------------------------- - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_soliddew_to_top_layer, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_liqdew_to_top_layer, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_liq_grnd, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(h2osno_no_layers, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(int_snow, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_albedo, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(snow_depth, 1) == bounds%endc), sourcefile, __LINE__) do fc = 1, num_snowc c = filter_snowc(fc) - int_snow(c) = int_snow(c) + frac_sno_eff(c) & + int_snow(c) = int_snow(c) + frac_sno_fluxes(c) & * (qflx_soliddew_to_top_layer(c) + qflx_liqdew_to_top_layer(c) & + qflx_liq_grnd(c)) * dtime end do @@ -1805,7 +1805,7 @@ subroutine BulkDiag_SnowWaterAccumulatedSnow(bounds, & ! reset accumulated snow when no snow present if (h2osno_no_layers(c) <= 0._r8) then int_snow(c) = 0._r8 - frac_sno(c) = 0._r8 + frac_sno_albedo(c) = 0._r8 snow_depth(c) = 0._r8 end if end do @@ -1815,7 +1815,7 @@ end subroutine BulkDiag_SnowWaterAccumulatedSnow !----------------------------------------------------------------------- subroutine SumFlux_AddSnowPercolation(bounds, & num_snowc, filter_snowc, num_nosnowc, filter_nosnowc, & - frac_sno_eff, qflx_snow_percolation_bottom, qflx_liq_grnd, qflx_snomelt, & + frac_sno_fluxes, qflx_snow_percolation_bottom, qflx_liq_grnd, qflx_snomelt, & qflx_snow_drain, qflx_rain_plus_snomelt) ! ! !DESCRIPTION: @@ -1828,7 +1828,7 @@ subroutine SumFlux_AddSnowPercolation(bounds, & integer, intent(in) :: num_nosnowc integer, intent(in) :: filter_nosnowc(:) - real(r8) , intent(in) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(in) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) real(r8) , intent(in) :: qflx_snow_percolation_bottom( bounds%begc: ) ! liquid percolation out of the bottom of the snow pack (mm H2O /s) real(r8) , intent(in) :: qflx_liq_grnd( bounds%begc: ) ! liquid on ground after interception (mm H2O/s) real(r8) , intent(in) :: qflx_snomelt( bounds%begc: ) ! snow melt (mm H2O /s) @@ -1842,7 +1842,7 @@ subroutine SumFlux_AddSnowPercolation(bounds, & character(len=*), parameter :: subname = 'SumFlux_AddSnowPercolation' !----------------------------------------------------------------------- - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_snow_percolation_bottom, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_liq_grnd, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_snomelt, 1) == bounds%endc), sourcefile, __LINE__) @@ -1854,7 +1854,7 @@ subroutine SumFlux_AddSnowPercolation(bounds, & qflx_snow_drain(c) = qflx_snow_drain(c) + qflx_snow_percolation_bottom(c) qflx_rain_plus_snomelt(c) = qflx_snow_percolation_bottom(c) & - + (1.0_r8 - frac_sno_eff(c)) * qflx_liq_grnd(c) + + (1.0_r8 - frac_sno_fluxes(c)) * qflx_liq_grnd(c) end do do fc = 1, num_nosnowc @@ -1926,7 +1926,7 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & t_soisno => temperature_inst%t_soisno_col , & ! Input: [real(r8) (:,:) ] soil temperature (Kelvin) imelt => temperature_inst%imelt_col , & ! Input: [integer (:,:) ] flag for melting (=1), freezing (=2), Not=0 - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] snow covered fraction + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] snow covered fraction frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) swe_old => waterdiagnosticbulk_inst%swe_old_col , & ! Input: [real(r8) (:,:) ] initial swe values int_snow => waterstatebulk_inst%int_snow_col , & ! Input: [real(r8) (:) ] integrated snowfall [mm] @@ -1959,12 +1959,12 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & wx = (h2osoi_ice(c,j) + h2osoi_liq(c,j)) void = 1._r8 - (h2osoi_ice(c,j)/denice + h2osoi_liq(c,j)/denh2o)& - /(frac_sno_eff(c) * dz(c,j)) + /(frac_sno_fluxes(c) * dz(c,j)) ! Allow compaction only for non-saturated node and higher ice lens node. if (void > 0.001_r8 .and. h2osoi_ice(c,j) > .1_r8) then - bi = h2osoi_ice(c,j) / (frac_sno_eff(c) * dz(c,j)) + bi = h2osoi_ice(c,j) / (frac_sno_fluxes(c) * dz(c,j)) fi = h2osoi_ice(c,j) / wx td = tfrz-t_soisno(c,j) dexpf = exp(-c4*td) @@ -1977,7 +1977,7 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & ! Liquid water term - if (h2osoi_liq(c,j) > 0.01_r8*dz(c,j)*frac_sno_eff(c)) ddz1=ddz1*c5 + if (h2osoi_liq(c,j) > 0.01_r8*dz(c,j)*frac_sno_fluxes(c)) ddz1=ddz1*c5 select case (overburden_compaction_method) case (OverburdenCompactionMethodAnderson1976) @@ -2023,14 +2023,14 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & ! Ensure sum of snow and surface water fractions are <= 1 after update ! ! Note that there is a similar adjustment in subroutine - ! FracH2oSfc (related to frac_sno); these two should be kept in + ! FracH2oSfc (related to frac_sno_albedo); these two should be kept in ! sync (e.g., if a 3rd fraction is ever added in one place, it ! needs to be added in the other place, too). if ((fsno_melt + frac_h2osfc(c)) > 1._r8) then fsno_melt = 1._r8 - frac_h2osfc(c) end if - ddz3 = ddz3 - max(0._r8,(fsno_melt - frac_sno_eff(c))/frac_sno_eff(c)) + ddz3 = ddz3 - max(0._r8,(fsno_melt - frac_sno_fluxes(c))/frac_sno_fluxes(c)) endif ddz3 = -1._r8/dtime * ddz3 else @@ -2058,7 +2058,7 @@ subroutine SnowCompaction(bounds, num_snowc, filter_snowc, & ! The change in dz due to compaction ! Limit compaction to be no greater than fully saturated layer thickness - dz(c,j) = max(dz(c,j) * (1._r8+pdzdtc*dtime),(h2osoi_ice(c,j)/denice+ h2osoi_liq(c,j)/denh2o)/frac_sno_eff(c)) + dz(c,j) = max(dz(c,j) * (1._r8+pdzdtc*dtime),(h2osoi_ice(c,j)/denice+ h2osoi_liq(c,j)/denh2o)/frac_sno_fluxes(c)) else ! saturated node is immobile @@ -2138,8 +2138,8 @@ subroutine CombineSnowLayers(bounds, num_snowc, filter_snowc, & mss_dst3 => aerosol_inst%mss_dst3_col , & ! Output: [real(r8) (:,:) ] dust species 3 mass in snow (col,lyr) [kg] mss_dst4 => aerosol_inst%mss_dst4_col , & ! Output: [real(r8) (:,:) ] dust species 4 mass in snow (col,lyr) [kg] - frac_sno => b_waterdiagnostic_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) - frac_sno_eff => b_waterdiagnostic_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => b_waterdiagnostic_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => b_waterdiagnostic_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snow_depth => b_waterdiagnostic_inst%snow_depth_col , & ! Output: [real(r8) (:) ] snow height (m) int_snow => b_waterstate_inst%int_snow_col , & ! Output: [real(r8) (:) ] integrated snowfall [mm] snw_rds => b_waterdiagnostic_inst%snw_rds_col , & ! Output: [real(r8) (:,:) ] effective snow grain radius (col,lyr) [microns, m^-6] @@ -2330,8 +2330,8 @@ subroutine CombineSnowLayers(bounds, num_snowc, filter_snowc, & l = col%landunit(c) if (snow_depth(c) > 0._r8) then if ((ltype(l) == istdlak .and. snow_depth(c) < dzmin(1) + lsadz ) .or. & - ((ltype(l) /= istdlak) .and. ((frac_sno_eff(c)*snow_depth(c) < dzmin(1)) & - .or. (h2osno_total(c)/(frac_sno_eff(c)*snow_depth(c)) < 50._r8)))) then + ((ltype(l) /= istdlak) .and. ((frac_sno_fluxes(c)*snow_depth(c) < dzmin(1)) & + .or. (h2osno_total(c)/(frac_sno_fluxes(c)*snow_depth(c)) < 50._r8)))) then do wi = water_inst%bulk_and_tracers_beg, water_inst%bulk_and_tracers_end @@ -2370,8 +2370,8 @@ subroutine CombineSnowLayers(bounds, num_snowc, filter_snowc, & end if if (h2osno_total(c) <= 0._r8) then snow_depth(c) = 0._r8 - frac_sno(c) = 0._r8 - frac_sno_eff(c) = 0._r8 + frac_sno_albedo(c) = 0._r8 + frac_sno_fluxes(c) = 0._r8 int_snow(c) = 0._r8 endif end do @@ -2390,8 +2390,8 @@ subroutine CombineSnowLayers(bounds, num_snowc, filter_snowc, & mssi(c) = 1 do i = msn_old(c)+1,0 - if ((frac_sno_eff(c)*dz(c,i) < dzminloc(mssi(c))) .or. & - ((h2osoi_ice_bulk(c,i) + h2osoi_liq_bulk(c,i))/(frac_sno_eff(c)*dz(c,i)) < 50._r8)) then + if ((frac_sno_fluxes(c)*dz(c,i) < dzminloc(mssi(c))) .or. & + ((h2osoi_ice_bulk(c,i) + h2osoi_liq_bulk(c,i))/(frac_sno_fluxes(c)*dz(c,i)) < 50._r8)) then if (i == snl(c)+1) then ! If top node is removed, combine with bottom neighbor. neibor = i + 1 @@ -2573,7 +2573,7 @@ subroutine DivideSnowLayers(bounds, num_snowc, filter_snowc, & associate( & t_soisno => temperature_inst%t_soisno_col , & ! Output: [real(r8) (:,:) ] soil temperature (Kelvin) - frac_sno_eff => b_waterdiagnostic_inst%frac_sno_eff_col , & ! Output: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => b_waterdiagnostic_inst%frac_sno_fluxes_col , & ! Output: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snw_rds => b_waterdiagnostic_inst%snw_rds_col , & ! Output: [real(r8) (:,:) ] effective snow grain radius (col,lyr) [microns, m^-6] mss_bcphi => aerosol_inst%mss_bcphi_col , & ! Output: [real(r8) (:,:) ] hydrophilic BC mass in snow (col,lyr) [kg] @@ -2632,7 +2632,7 @@ subroutine DivideSnowLayers(bounds, num_snowc, filter_snowc, & if (is_lake) then dzsno(c,j) = dz(c,j+snl(c)) else - dzsno(c,j) = frac_sno(c)*dz(c,j+snl(c)) + dzsno(c,j) = frac_sno_albedo(c)*dz(c,j+snl(c)) end if do wi = water_inst%bulk_and_tracers_beg, water_inst%bulk_and_tracers_end @@ -2813,7 +2813,7 @@ subroutine DivideSnowLayers(bounds, num_snowc, filter_snowc, & if (is_lake) then dz(c,j) = dzsno(c,j-snl(c)) else - dz(c,j) = dzsno(c,j-snl(c))/frac_sno(c) + dz(c,j) = dzsno(c,j-snl(c))/frac_sno_albedo(c) end if do wi = water_inst%bulk_and_tracers_beg, water_inst%bulk_and_tracers_end @@ -3056,7 +3056,7 @@ subroutine InitSnowLayers (bounds, snow_depth) cycle end if - ! LvK 9-JUN-2015: in CanopyHydrologyMod , snow_depth is scaled with frac_sno + ! LvK 9-JUN-2015: in CanopyHydrologyMod , snow_depth is scaled with frac_sno_albedo ! Here we do not apply scaling to snow_depth, so inconsistent? TODO ! Special case: too little snow for snowpack existence @@ -3143,7 +3143,7 @@ subroutine SnowCapping(bounds, num_initc, filter_initc, num_snowc, filter_snowc, integer :: i ! index of water tracer or bulk real(r8) :: dtime ! land model time step (sec) real(r8) :: h2osno_total(bounds%begc:bounds%endc) ! total snow water (mm H2O) - real(r8) :: rho_orig_bottom(bounds%begc:bounds%endc) ! partial density of ice in bottom snow layer, before updates (not scaled with frac_sno) [kg/m3] + real(r8) :: rho_orig_bottom(bounds%begc:bounds%endc) ! partial density of ice in bottom snow layer, before updates (not scaled with frac_sno_albedo) [kg/m3] real(r8) :: frac_adjust(bounds%begc:bounds%endc) ! fraction of mass remaining after capping type(filter_col_type) :: snow_capping_filterc ! column filter: columns undergoing snow capping @@ -3309,7 +3309,7 @@ subroutine BulkFlux_SnowCappingFluxes(bounds, num_snowc, filter_snowc, & real(r8) , intent(in) :: h2osoi_liq_bottom( bounds%begc: ) ! liquid water in bottom snow layer (kg/m2) type(filter_col_type) , intent(out) :: snow_capping_filterc ! column filter: columns undergoing snow capping - real(r8) , intent(inout) :: rho_orig_bottom( bounds%begc: ) ! partial density of ice in bottom snow layer, before updates (not scaled with frac_sno) (kg/m3) + real(r8) , intent(inout) :: rho_orig_bottom( bounds%begc: ) ! partial density of ice in bottom snow layer, before updates (not scaled with frac_sno_albedo) (kg/m3) real(r8) , intent(inout) :: frac_adjust( bounds%begc: ) ! fraction of mass remaining after capping real(r8) , intent(inout) :: qflx_snwcp_ice( bounds%begc: ) ! excess solid h2o due to snow capping (outgoing) (mm H2O /s) real(r8) , intent(inout) :: qflx_snwcp_liq( bounds%begc: ) ! excess liquid h2o due to snow capping (outgoing) (mm H2O /s) @@ -3632,7 +3632,7 @@ subroutine SnowCappingUpdateDzAndAerosols(bounds, snow_capping_filterc, & type(bounds_type) , intent(in) :: bounds type(filter_col_type) , intent(in) :: snow_capping_filterc ! column filter: columns undergoing snow capping - real(r8) , intent(in) :: rho_orig_bottom( bounds%begc: ) ! partial density of ice in bottom snow layer, before updates (not scaled with frac_sno) (kg/m3) + real(r8) , intent(in) :: rho_orig_bottom( bounds%begc: ) ! partial density of ice in bottom snow layer, before updates (not scaled with frac_sno_albedo) (kg/m3) real(r8) , intent(in) :: h2osoi_ice_bottom( bounds%begc: ) ! ice lens in bottom snow layer (kg/m2) real(r8) , intent(in) :: frac_adjust( bounds%begc: ) ! fraction of mass remaining after capping real(r8) , intent(inout) :: dz_bottom( bounds%begc: ) ! layer depth of bottom snow layer (m) diff --git a/src/biogeophys/SnowSnicarMod.F90 b/src/biogeophys/SnowSnicarMod.F90 index 3f006b3198..605bee14bc 100644 --- a/src/biogeophys/SnowSnicarMod.F90 +++ b/src/biogeophys/SnowSnicarMod.F90 @@ -612,7 +612,7 @@ subroutine SNICAR_RT (bounds, num_nourbanc, filter_nourbanc, & associate(& snl => col%snl , & ! Input: [integer (:)] negative number of snow layers (col) [nbr] - frac_sno_eff=> waterdiagnosticbulk_inst%frac_sno_eff_col & ! Input: [real(r8) (:)] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes=> waterdiagnosticbulk_inst%frac_sno_fluxes_col & ! Input: [real(r8) (:)] fraction of ground covered by snow (0 to 1) ) ! initialize parameter and @@ -1551,7 +1551,7 @@ subroutine SnowAge_grain(bounds, & qflx_snow_grnd_col => waterfluxbulk_inst%qflx_snow_grnd_col , & ! Input: [real(r8) (:) ] snow on ground after interception (col) [kg m-2 s-1] qflx_snofrz_lyr => waterfluxbulk_inst%qflx_snofrz_lyr_col , & ! Input: [real(r8) (:,:) ] snow freezing rate (col,lyr) [kg m-2 s-1] - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) h2osno_no_layers => waterstatebulk_inst%h2osno_no_layers_col , & ! Input: [real(r8) (:) ] snow that is not resolved into layers (col) [mm H2O] h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid water content (col,lyr) [kg m-2] h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] ice content (col,lyr) [kg m-2] @@ -1576,7 +1576,7 @@ subroutine SnowAge_grain(bounds, & snl_btm = 0 snl_top = snl(c_idx) + 1 - cdz(snl_top:snl_btm)=frac_sno_eff(c_idx)*dz(c_idx,snl_top:snl_btm) + cdz(snl_top:snl_btm)=frac_sno_fluxes(c_idx)*dz(c_idx,snl_top:snl_btm) ! loop over snow layers do i=snl_top,snl_btm,1 diff --git a/src/biogeophys/SoilFluxesMod.F90 b/src/biogeophys/SoilFluxesMod.F90 index 44e6d0e1cd..ba092a015d 100644 --- a/src/biogeophys/SoilFluxesMod.F90 +++ b/src/biogeophys/SoilFluxesMod.F90 @@ -90,7 +90,7 @@ subroutine SoilFluxes (bounds, num_urbanl, filter_urbanl, & frac_veg_nosno => canopystate_inst%frac_veg_nosno_patch , & ! Input: [integer (:) ] fraction of veg not covered by snow (0/1 now) [-] - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] ice lens (kg/m2) (new) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid water (kg/m2) (new) @@ -173,8 +173,8 @@ subroutine SoilFluxes (bounds, num_urbanl, filter_urbanl, & ! flux corrections if (col%snl(c) < 0) then - t_grnd0(c) = frac_sno_eff(c) * tssbef(c,col%snl(c)+1) & - + (1 - frac_sno_eff(c) - frac_h2osfc(c)) * tssbef(c,1) & + t_grnd0(c) = frac_sno_fluxes(c) * tssbef(c,col%snl(c)+1) & + + (1 - frac_sno_fluxes(c) - frac_h2osfc(c)) * tssbef(c,1) & + frac_h2osfc(c) * t_h2osfc_bef(c) else t_grnd0(c) = (1 - frac_h2osfc(c)) * tssbef(c,1) + frac_h2osfc(c) * t_h2osfc_bef(c) @@ -278,21 +278,21 @@ subroutine SoilFluxes (bounds, num_urbanl, filter_urbanl, & p = filter_nolakep(fp) c = patch%column(p) j = col%snl(c)+1 - ! snow layers; assumes for j < 1 that frac_sno_eff > 0 + ! snow layers; assumes for j < 1 that frac_sno_fluxes > 0 if (j < 1) then ! Defining the limitation uniformly for all patches is more ! strict than absolutely necessary. This definition assumes ! each patch is spatially distinct and may remove all the snow ! on its patch, but may not remove snow from adjacent patches. - evaporation_limit = (h2osoi_ice(c,j)+h2osoi_liq(c,j))/(frac_sno_eff(c)*dtime) + evaporation_limit = (h2osoi_ice(c,j)+h2osoi_liq(c,j))/(frac_sno_fluxes(c)*dtime) if (qflx_ev_snow(p) > evaporation_limit) then evaporation_demand = qflx_ev_snow(p) qflx_ev_snow(p) = evaporation_limit - qflx_evap_soi(p) = qflx_evap_soi(p) - frac_sno_eff(c)*(evaporation_demand - evaporation_limit) - qflx_liqevap_from_top_layer(p) = max(h2osoi_liq(c,j)/(frac_sno_eff(c)*dtime), 0._r8) - qflx_solidevap_from_top_layer(p) = max(h2osoi_ice(c,j)/(frac_sno_eff(c)*dtime), 0._r8) + qflx_evap_soi(p) = qflx_evap_soi(p) - frac_sno_fluxes(c)*(evaporation_demand - evaporation_limit) + qflx_liqevap_from_top_layer(p) = max(h2osoi_liq(c,j)/(frac_sno_fluxes(c)*dtime), 0._r8) + qflx_solidevap_from_top_layer(p) = max(h2osoi_ice(c,j)/(frac_sno_fluxes(c)*dtime), 0._r8) ! conserve total energy flux - eflx_sh_grnd(p) = eflx_sh_grnd(p) + frac_sno_eff(c)*(evaporation_demand - evaporation_limit)*htvp(c) + eflx_sh_grnd(p) = eflx_sh_grnd(p) + frac_sno_fluxes(c)*(evaporation_demand - evaporation_limit)*htvp(c) endif endif @@ -341,11 +341,11 @@ subroutine SoilFluxes (bounds, num_urbanl, filter_urbanl, & ! Ground heat flux if (.not. lun%urbpoi(l)) then - lw_grnd=(frac_sno_eff(c)*tssbef(c,col%snl(c)+1)**4 & - +(1._r8-frac_sno_eff(c)-frac_h2osfc(c))*tssbef(c,1)**4 & + lw_grnd=(frac_sno_fluxes(c)*tssbef(c,col%snl(c)+1)**4 & + +(1._r8-frac_sno_fluxes(c)-frac_h2osfc(c))*tssbef(c,1)**4 & +frac_h2osfc(c)*t_h2osfc_bef(c)**4) - eflx_soil_grnd(p) = ((1._r8- frac_sno_eff(c))*sabg_soil(p) + frac_sno_eff(c)*sabg_snow(p)) + dlrad(p) & + eflx_soil_grnd(p) = ((1._r8- frac_sno_fluxes(c))*sabg_soil(p) + frac_sno_fluxes(c)*sabg_snow(p)) + dlrad(p) & + (1-frac_veg_nosno(p))*emg(c)*forc_lwrad(c) & - emg(c)*sb*lw_grnd - emg(c)*sb*t_grnd0(c)**3*(4._r8*tinc(c)) & - (eflx_sh_grnd(p)+qflx_evap_soi(p)*htvp(c)) @@ -421,7 +421,7 @@ subroutine SoilFluxes (bounds, num_urbanl, filter_urbanl, & .and. col%itype(c) /= icol_roof) then ! area weight heat absorbed by snow layers if (j >= col%snl(c)+1 .and. j < 1) errsoi_patch(p) = errsoi_patch(p) & - - frac_sno_eff(c)*(t_soisno(c,j)-tssbef(c,j))/fact(c,j) + - frac_sno_fluxes(c)*(t_soisno(c,j)-tssbef(c,j))/fact(c,j) if (j >= 1) errsoi_patch(p) = errsoi_patch(p) & - (t_soisno(c,j)-tssbef(c,j))/fact(c,j) end if @@ -438,7 +438,7 @@ subroutine SoilFluxes (bounds, num_urbanl, filter_urbanl, & .or. col%itype(c) == icol_roof) then ! area weight heat absorbed by snow layers if (j >= col%snl(c)+1 .and. j < 1) errsoi_patch(p) = errsoi_patch(p) & - - frac_sno_eff(c)*(t_soisno(c,j)-tssbef(c,j))/fact(c,j) + - frac_sno_fluxes(c)*(t_soisno(c,j)-tssbef(c,j))/fact(c,j) if (j >= 1) errsoi_patch(p) = errsoi_patch(p) & - (t_soisno(c,j)-tssbef(c,j))/fact(c,j) end if @@ -462,8 +462,8 @@ subroutine SoilFluxes (bounds, num_urbanl, filter_urbanl, & j = col%snl(c)+1 if (.not. lun%urbpoi(l)) then - lw_grnd=(frac_sno_eff(c)*tssbef(c,col%snl(c)+1)**4 & - +(1._r8-frac_sno_eff(c)-frac_h2osfc(c))*tssbef(c,1)**4 & + lw_grnd=(frac_sno_fluxes(c)*tssbef(c,col%snl(c)+1)**4 & + +(1._r8-frac_sno_fluxes(c)-frac_h2osfc(c))*tssbef(c,1)**4 & +frac_h2osfc(c)*t_h2osfc_bef(c)**4) eflx_lwrad_out(p) = ulrad(p) & diff --git a/src/biogeophys/SoilHydrologyMod.F90 b/src/biogeophys/SoilHydrologyMod.F90 index d48f2b2d89..ff5d6ba52d 100644 --- a/src/biogeophys/SoilHydrologyMod.F90 +++ b/src/biogeophys/SoilHydrologyMod.F90 @@ -311,7 +311,7 @@ subroutine SetQflxInputs(bounds, num_hydrologyc, filter_hydrologyc, & ! !LOCAL VARIABLES: integer :: fc, c real(r8) :: qflx_evap ! evaporation for this column - real(r8) :: fsno ! copy of frac_sno + real(r8) :: fsno ! copy of frac_sno_albedo character(len=*), parameter :: subname = 'SetQflxInputs' !----------------------------------------------------------------------- @@ -330,7 +330,7 @@ subroutine SetQflxInputs(bounds, num_hydrologyc, filter_hydrologyc, & qflx_ev_h2osfc => waterfluxbulk_inst%qflx_ev_h2osfc_col , & ! Input: [real(r8) (:)] evaporation flux from h2osfc (W/m**2) [+ to atm] qflx_sat_excess_surf => waterfluxbulk_inst%qflx_sat_excess_surf_col , & ! Input: [real(r8) (:)] surface runoff due to saturated surface (mm H2O /s) - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) ) @@ -348,7 +348,7 @@ subroutine SetQflxInputs(bounds, num_hydrologyc, filter_hydrologyc, & ! if no snow layers, sublimation is removed from h2osoi_ice in drainage qflx_evap=qflx_liqevap_from_top_layer(c) else - fsno=frac_sno_eff(c) + fsno=frac_sno_fluxes(c) qflx_evap=qflx_ev_soil(c) endif diff --git a/src/biogeophys/SoilTemperatureMod.F90 b/src/biogeophys/SoilTemperatureMod.F90 index 5a54d0cc68..3287ac1548 100644 --- a/src/biogeophys/SoilTemperatureMod.F90 +++ b/src/biogeophys/SoilTemperatureMod.F90 @@ -199,7 +199,7 @@ subroutine SoilTemperature(bounds, num_urbanl, filter_urbanl, num_urbanc, filter frac_veg_nosno => canopystate_inst%frac_veg_nosno_patch , & ! Input: [integer (:) ] fraction of vegetation not covered by snow (0 OR 1) [-] - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) h2osfc => waterstatebulk_inst%h2osfc_col , & ! Input: [real(r8) (:) ] surface water (mm) excess_ice => waterstatebulk_inst%excess_ice_col , & ! Input: [real(r8) (:,:) ] excess ice (kg/m2) (new) (1:nlevgrnd) @@ -550,12 +550,12 @@ subroutine SoilTemperature(bounds, num_urbanl, filter_urbanl, num_urbanc, filter ! this expression will (should) work whether there is snow or not if (snl(c) < 0) then if(frac_h2osfc(c) /= 0._r8) then - t_grnd(c) = frac_sno_eff(c) * t_soisno(c,snl(c)+1) & - + (1.0_r8 - frac_sno_eff(c) - frac_h2osfc(c)) * t_soisno(c,1) & + t_grnd(c) = frac_sno_fluxes(c) * t_soisno(c,snl(c)+1) & + + (1.0_r8 - frac_sno_fluxes(c) - frac_h2osfc(c)) * t_soisno(c,1) & + frac_h2osfc(c) * t_h2osfc(c) else - t_grnd(c) = frac_sno_eff(c) * t_soisno(c,snl(c)+1) & - + (1.0_r8 - frac_sno_eff(c)) * t_soisno(c,1) + t_grnd(c) = frac_sno_fluxes(c) * t_soisno(c,snl(c)+1) & + + (1.0_r8 - frac_sno_fluxes(c)) * t_soisno(c,1) end if else @@ -675,7 +675,7 @@ subroutine SoilThermProp (bounds, num_urbanc, filter_urbanc, num_nolakec, filter t_soisno => temperature_inst%t_soisno_col , & ! Input: [real(r8) (:,:) ] soil temperature [K] - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fractional snow covered area + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] fractional snow covered area h2osfc => waterstatebulk_inst%h2osfc_col , & ! Input: [real(r8) (:) ] surface (mm H2O) h2osno_no_layers => waterstatebulk_inst%h2osno_no_layers_col , & ! Input: [real(r8) (:) ] snow not resolved into layers (mm H2O) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid water (kg/m2) @@ -739,7 +739,7 @@ subroutine SoilThermProp (bounds, num_urbanc, filter_urbanc, num_nolakec, filter ! Thermal conductivity of snow ! Only examine levels from snl(c)+1 -> 0 where snl(c) < 1 if (snl(c)+1 < 1 .AND. (j >= snl(c)+1) .AND. (j <= 0)) then - bw(c,j) = (h2osoi_ice(c,j)+h2osoi_liq(c,j))/(frac_sno_eff(c)*dz(c,j)) + bw(c,j) = (h2osoi_ice(c,j)+h2osoi_liq(c,j))/(frac_sno_fluxes(c)*dz(c,j)) l = col%landunit(c) ! Select method over glacier land unit @@ -886,8 +886,8 @@ subroutine SoilThermProp (bounds, num_urbanc, filter_urbanc, num_nolakec, filter do fc = 1,num_nolakec c = filter_nolakec(fc) if (snl(c)+1 < 1 .and. j >= snl(c)+1) then - if (frac_sno_eff(c) > 0._r8) then - cv(c,j) = max(thin_sfclayer,(cpliq*h2osoi_liq(c,j) + cpice*h2osoi_ice(c,j))/frac_sno_eff(c)) + if (frac_sno_fluxes(c) > 0._r8) then + cv(c,j) = max(thin_sfclayer,(cpliq*h2osoi_liq(c,j) + cpice*h2osoi_ice(c,j))/frac_sno_fluxes(c)) else cv(c,j) = thin_sfclayer endif @@ -950,7 +950,7 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & snl => col%snl , & ! Input: [integer (:) ] number of snow layers dz => col%dz , & ! Input: [real(r8) (:,:) ] layer thickness (m) - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) h2osno_no_layers => waterstatebulk_inst%h2osno_no_layers_col , & ! Output: [real(r8) (:) ] snow that is not resolved into layers (mm H2O) h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] ice lens (kg/m2) (new) @@ -1002,7 +1002,7 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & xm(c) = hm(c)*dtime/hfus temp1 = h2osfc(c) + xm(c) - z_avg=frac_sno_eff(c)*snow_depth(c) + z_avg=frac_sno_fluxes(c)*snow_depth(c) if (z_avg > 0._r8) then rho_avg=min(800._r8,h2osno_total(c)/z_avg) else @@ -1029,8 +1029,8 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & ! update snow depth - if (frac_sno_eff(c) > 0 .and. snl(c) < 0) then - snow_depth(c)=h2osno_total(c)/(rho_avg*frac_sno_eff(c)) + if (frac_sno_fluxes(c) > 0 .and. snl(c) < 0) then + snow_depth(c)=h2osno_total(c)/(rho_avg*frac_sno_fluxes(c)) else snow_depth(c)=h2osno_total(c)/denice endif @@ -1042,9 +1042,9 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & eflx_h2osfc_to_snow_col(c) = 0. else if (snl(c) == -1)then - c1=frac_sno_eff(c)*(dtime/fact(c,0) - dhsdT(c)*dtime) + c1=frac_sno_fluxes(c)*(dtime/fact(c,0) - dhsdT(c)*dtime) else - c1=frac_sno_eff(c)/fact(c,0)*dtime + c1=frac_sno_fluxes(c)/fact(c,0)*dtime end if if ( frac_h2osfc(c) /= 0.0_r8 )then c2=(-cpliq*xm(c) - frac_h2osfc(c)*dhsdT(c)*dtime) @@ -1087,7 +1087,7 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & !initialize for next time step t_soisno(c,0) = t_h2osfc(c) else if (snl(c) == -1) then - c1=frac_sno_eff(c)*(dtime/fact(c,0) - dhsdT(c)*dtime) + c1=frac_sno_fluxes(c)*(dtime/fact(c,0) - dhsdT(c)*dtime) if ( frac_h2osfc(c) /= 0.0_r8 )then c2=frac_h2osfc(c)*(c_h2osfc(c) - dtime*dhsdT(c)) @@ -1099,7 +1099,7 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & t_h2osfc(c) = t_soisno(c,0) else - c1=frac_sno_eff(c)/fact(c,0)*dtime + c1=frac_sno_fluxes(c)/fact(c,0)*dtime if ( frac_h2osfc(c) /= 0.0_r8 )then c2=frac_h2osfc(c)*(c_h2osfc(c) - dtime*dhsdT(c)) else @@ -1114,8 +1114,8 @@ subroutine PhaseChangeH2osfc (bounds, num_nolakec, filter_nolakec, & h2osfc(c) = 0._r8 ! update snow depth - if (frac_sno_eff(c) > 0 .and. snl(c) < 0) then - snow_depth(c)=h2osno_total(c)/(rho_avg*frac_sno_eff(c)) + if (frac_sno_fluxes(c) > 0 .and. snl(c) < 0) then + snow_depth(c)=h2osno_total(c)/(rho_avg*frac_sno_fluxes(c)) else snow_depth(c)=h2osno_total(c)/denice endif @@ -1199,7 +1199,7 @@ subroutine Phasechange (bounds, num_nolakec, filter_nolakec, dhsdT, & sucsat => soilstate_inst%sucsat_col , & ! Input: [real(r8) (:,:) ] minimum soil suction (mm) watsat => soilstate_inst%watsat_col , & ! Input: [real(r8) (:,:) ] volumetric soil water at saturation (porosity) - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) exice_subs_col => waterdiagnosticbulk_inst%exice_subs_col , & ! Output: [real(r8) (:,:) ] per layer subsidence due to excess ice melt (mm/s) @@ -1372,18 +1372,18 @@ subroutine Phasechange (bounds, num_nolakec, filter_nolakec, dhsdT, & if(j > 0) then hm(c,j) = dhsdT(c)*tinc(c,j) - tinc(c,j)/fact(c,j) else - hm(c,j) = frac_sno_eff(c)*(dhsdT(c)*tinc(c,j) - tinc(c,j)/fact(c,j)) + hm(c,j) = frac_sno_fluxes(c)*(dhsdT(c)*tinc(c,j) - tinc(c,j)/fact(c,j)) endif if ( j==1 .and. frac_h2osfc(c) /= 0.0_r8 ) then hm(c,j) = hm(c,j) - frac_h2osfc(c)*(dhsdT(c)*tinc(c,j)) end if else if (j == 1) then - hm(c,j) = (1.0_r8 - frac_sno_eff(c) - frac_h2osfc(c)) & + hm(c,j) = (1.0_r8 - frac_sno_fluxes(c) - frac_h2osfc(c)) & *dhsdT(c)*tinc(c,j) - tinc(c,j)/fact(c,j) else ! non-interfacial snow/soil layers if(j < 1) then - hm(c,j) = - frac_sno_eff(c)*(tinc(c,j)/fact(c,j)) + hm(c,j) = - frac_sno_fluxes(c)*(tinc(c,j)/fact(c,j)) else hm(c,j) = - tinc(c,j)/fact(c,j) endif @@ -1468,7 +1468,7 @@ subroutine Phasechange (bounds, num_nolakec, filter_nolakec, dhsdT, & t_soisno(c,j) = t_soisno(c,j) + fact(c,j)*heatr & /(1._r8-(1.0_r8 - frac_h2osfc(c))*fact(c,j)*dhsdT(c)) else - t_soisno(c,j) = t_soisno(c,j) + (fact(c,j)/frac_sno_eff(c))*heatr & + t_soisno(c,j) = t_soisno(c,j) + (fact(c,j)/frac_sno_fluxes(c))*heatr & /(1._r8-fact(c,j)*dhsdT(c)) endif @@ -1476,12 +1476,12 @@ subroutine Phasechange (bounds, num_nolakec, filter_nolakec, dhsdT, & else if (j == 1) then t_soisno(c,j) = t_soisno(c,j) + fact(c,j)*heatr & - /(1._r8-(1.0_r8 - frac_sno_eff(c) - frac_h2osfc(c))*fact(c,j)*dhsdT(c)) + /(1._r8-(1.0_r8 - frac_sno_fluxes(c) - frac_h2osfc(c))*fact(c,j)*dhsdT(c)) else if(j > 0) then t_soisno(c,j) = t_soisno(c,j) + fact(c,j)*heatr else - if(frac_sno_eff(c) > 0._r8) t_soisno(c,j) = t_soisno(c,j) + (fact(c,j)/frac_sno_eff(c))*heatr + if(frac_sno_fluxes(c) > 0._r8) t_soisno(c,j) = t_soisno(c,j) + (fact(c,j)/frac_sno_fluxes(c))*heatr endif endif @@ -1614,7 +1614,7 @@ subroutine ComputeGroundHeatFluxAndDeriv(bounds, & frac_veg_nosno => canopystate_inst%frac_veg_nosno_patch , & ! Input: [integer (:) ] fraction of vegetation not covered by snow (0 OR 1) [-] - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) qflx_ev_snow => waterfluxbulk_inst%qflx_ev_snow_patch , & ! Input: [real(r8) (:) ] evaporation flux from snow (mm H2O/s) [+ to atm] qflx_ev_soil => waterfluxbulk_inst%qflx_ev_soil_patch , & ! Input: [real(r8) (:) ] evaporation flux from soil (mm H2O/s) [+ to atm] @@ -1685,8 +1685,8 @@ subroutine ComputeGroundHeatFluxAndDeriv(bounds, & eflx_gnet(p) = sabg(p) + dlrad(p) & + (1._r8-frac_veg_nosno(p))*emg(c)*forc_lwrad(c) - lwrad_emit(c) & - (eflx_sh_grnd(p)+qflx_evap_soi(p)*htvp(c)) - ! save sabg for balancecheck, in case frac_sno is set to zero later - sabg_chk(p) = frac_sno_eff(c) * sabg_snow(p) + (1._r8 - frac_sno_eff(c) ) * sabg_soil(p) + ! save sabg for balancecheck, in case frac_sno_albedo is set to zero later + sabg_chk(p) = frac_sno_fluxes(c) * sabg_snow(p) + (1._r8 - frac_sno_fluxes(c) ) * sabg_soil(p) eflx_gnet_snow = sabg_snow(p) + dlrad(p) & + (1._r8-frac_veg_nosno(p))*emg(c)*forc_lwrad(c) - lwrad_emit_snow(c) & @@ -1984,7 +1984,7 @@ subroutine SetRHSVec(bounds, num_nolakec, filter_nolakec, dtime, & t_soisno => temperature_inst%t_soisno_col , & ! Input: [real(r8) (:,:) ] soil temperature [K] t_h2osfc => temperature_inst%t_h2osfc_col , & ! Input: [real(r8) (:) ] surface water temperature frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) begc => bounds%begc , & ! Input: [integer ] beginning column index endc => bounds%endc & ! Input: [integer ] ending column index ) @@ -2035,7 +2035,7 @@ subroutine SetRHSVec(bounds, num_nolakec, filter_nolakec, dtime, & fn_h2osfc( begc:endc ), & c_h2osfc( begc:endc ), & frac_h2osfc ( begc:endc), & - frac_sno_eff( begc:endc), & + frac_sno_fluxes( begc:endc), & t_soisno ( begc:endc, -nlevsno+1: ), & rt_soil( begc:endc, 1: )) @@ -2216,7 +2216,7 @@ end subroutine SetRHSVec_StandingSurfaceWater !----------------------------------------------------------------------- subroutine SetRHSVec_Soil(bounds, num_nolakec, filter_nolakec, & hs_top_snow, hs_soil, hs_top, dhsdT, sabg_lyr_col, fact, fn, fn_h2osfc, c_h2osfc, & - frac_h2osfc, frac_sno_eff, t_soisno, rt) + frac_h2osfc, frac_sno_fluxes, t_soisno, rt) ! ! !DESCRIPTION: ! Sets up RHS vector corresponding to all soil layers @@ -2242,7 +2242,7 @@ subroutine SetRHSVec_Soil(bounds, num_nolakec, filter_nolakec, & real(r8), intent(in) :: fn_h2osfc (bounds%begc: ) ! heat diffusion through standing-water/soil interface [W/m2] real(r8), intent(in) :: c_h2osfc( bounds%begc: ) ! heat capacity of surface water [col] real(r8), intent(in) :: frac_h2osfc(bounds%begc: ) ! fractional area with surface water greater than zero - real(r8), intent(in) :: frac_sno_eff(bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8), intent(in) :: frac_sno_fluxes(bounds%begc: ) ! fraction of ground covered by snow (0 to 1) real(r8), intent(in) :: t_soisno(bounds%begc:, -nlevsno+1:) ! soil temperature [K] real(r8), intent(out) :: rt(bounds%begc: ,1: ) ! rhs vector entries !----------------------------------------------------------------------- @@ -2260,7 +2260,7 @@ subroutine SetRHSVec_Soil(bounds, num_nolakec, filter_nolakec, & SHR_ASSERT_ALL_FL((ubound(fn_h2osfc) == (/bounds%endc/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(c_h2osfc) == (/bounds%endc/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(frac_h2osfc) == (/bounds%endc/)), sourcefile, __LINE__) - SHR_ASSERT_ALL_FL((ubound(frac_sno_eff) == (/bounds%endc/)), sourcefile, __LINE__) + SHR_ASSERT_ALL_FL((ubound(frac_sno_fluxes) == (/bounds%endc/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(t_soisno) == (/bounds%endc, nlevmaxurbgrnd/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(rt) == (/bounds%endc, nlevmaxurbgrnd/)), sourcefile, __LINE__) @@ -2320,10 +2320,10 @@ subroutine SetRHSVec_Soil(bounds, num_nolakec, filter_nolakec, & else if (j == 1) then ! this is the snow/soil interface layer rt(c,j) = t_soisno(c,j) + fact(c,j) & - *((1._r8-frac_sno_eff(c))*(hs_soil(c) - dhsdT(c)*t_soisno(c,j)) & - + cnfac*(fn(c,j) - frac_sno_eff(c) * fn(c,j-1))) + *((1._r8-frac_sno_fluxes(c))*(hs_soil(c) - dhsdT(c)*t_soisno(c,j)) & + + cnfac*(fn(c,j) - frac_sno_fluxes(c) * fn(c,j-1))) - rt(c,j) = rt(c,j) + frac_sno_eff(c)*fact(c,j)*sabg_lyr_col(c,j) + rt(c,j) = rt(c,j) + frac_sno_fluxes(c)*fact(c,j)*sabg_lyr_col(c,j) else if (j <= nlevgrnd-1) then rt(c,j) = t_soisno(c,j) + cnfac*fact(c,j)*( fn(c,j) - fn(c,j-1) ) @@ -2418,7 +2418,7 @@ subroutine SetMatrix(bounds, num_nolakec, filter_nolakec, dtime, nband, & associate( & z => col%z , & ! Input: [real(r8) (:,:) ] layer thickness [m] frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) begc => bounds%begc , & ! Input: [integer ] beginning column index endc => bounds%endc & ! Input: [integer ] ending column index ) @@ -2429,7 +2429,7 @@ subroutine SetMatrix(bounds, num_nolakec, filter_nolakec, dtime, nband, & dhsdT( begc:endc ), & tk( begc:endc, -nlevsno+1: ), & fact( begc:endc, -nlevsno+1: ), & - frac_sno_eff(begc:endc), & + frac_sno_fluxes(begc:endc), & bmatrix_snow( begc:endc, 1:, -nlevsno: ), & bmatrix_snow_soil( begc:endc, 1:, -1: )) @@ -2440,7 +2440,7 @@ subroutine SetMatrix(bounds, num_nolakec, filter_nolakec, dtime, nband, & dz_h2osfc( begc:endc ), & fact( begc:endc, -nlevsno+1: ), & frac_h2osfc(begc:endc), & - frac_sno_eff(begc:endc), & + frac_sno_fluxes(begc:endc), & bmatrix_soil( begc:endc, 1:, 1: ), & bmatrix_soil_snow( begc:endc, 1:, 1: )) @@ -2589,7 +2589,7 @@ end subroutine AssembleMatrixFromSubmatrices !----------------------------------------------------------------------- subroutine SetMatrix_Snow(bounds, num_nolakec, filter_nolakec, nband, & - dhsdT, tk, fact, frac_sno_eff, bmatrix_snow, bmatrix_snow_soil) + dhsdT, tk, fact, frac_sno_fluxes, bmatrix_snow, bmatrix_snow_soil) ! ! !DESCRIPTION: ! Setup the matrix entries corresponding to internal snow layers @@ -2609,7 +2609,7 @@ subroutine SetMatrix_Snow(bounds, num_nolakec, filter_nolakec, nband, & real(r8), intent(in) :: dhsdT(bounds%begc: ) ! temperature derivative of "hs" [col] real(r8), intent(in) :: tk(bounds%begc: ,-nlevsno+1: ) ! thermal conductivity [W/(m K)] real(r8), intent(in) :: fact( bounds%begc: , -nlevsno+1: ) ! used in computing tridiagonal matrix [col, lev] - real(r8), intent(in) :: frac_sno_eff(bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8), intent(in) :: frac_sno_fluxes(bounds%begc: ) ! fraction of ground covered by snow (0 to 1) real(r8), intent(out) :: bmatrix_snow(bounds%begc: , 1:, -nlevsno: ) ! matrix enteries real(r8), intent(out) :: bmatrix_snow_soil(bounds%begc: , 1:,-1: ) ! matrix enteries ! @@ -2625,7 +2625,7 @@ subroutine SetMatrix_Snow(bounds, num_nolakec, filter_nolakec, nband, & SHR_ASSERT_ALL_FL((ubound(dhsdT) == (/bounds%endc/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(tk) == (/bounds%endc, nlevmaxurbgrnd/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(fact) == (/bounds%endc, nlevmaxurbgrnd/)), sourcefile, __LINE__) - SHR_ASSERT_ALL_FL((ubound(frac_sno_eff) == (/bounds%endc/)), sourcefile, __LINE__) + SHR_ASSERT_ALL_FL((ubound(frac_sno_fluxes) == (/bounds%endc/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(bmatrix_snow) == (/bounds%endc, nband, -1/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(bmatrix_snow_soil) == (/bounds%endc, nband, -1/)), sourcefile, __LINE__) @@ -2685,7 +2685,7 @@ end subroutine SetMatrix_Snow !----------------------------------------------------------------------- subroutine SetMatrix_Soil(bounds, num_nolakec, filter_nolakec, nband, & - dhsdT, tk, tk_h2osfc, dz_h2osfc, fact, frac_h2osfc, frac_sno_eff, bmatrix_soil, bmatrix_soil_snow) + dhsdT, tk, tk_h2osfc, dz_h2osfc, fact, frac_h2osfc, frac_sno_fluxes, bmatrix_soil, bmatrix_soil_snow) ! ! !DESCRIPTION: ! Setup the matrix entries corresponding to internal soil layers @@ -2709,7 +2709,7 @@ subroutine SetMatrix_Soil(bounds, num_nolakec, filter_nolakec, nband, & real(r8), intent(in) :: dz_h2osfc(bounds%begc: ) ! Thickness of standing water [m] real(r8), intent(in) :: fact( bounds%begc: , -nlevsno+1: ) ! used in computing tridiagonal matrix [col, lev] real(r8), intent(in) :: frac_h2osfc(bounds%begc: ) ! fractional area with surface water greater than zero - real(r8), intent(in) :: frac_sno_eff(bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8), intent(in) :: frac_sno_fluxes(bounds%begc: ) ! fraction of ground covered by snow (0 to 1) real(r8), intent(out) :: bmatrix_soil(bounds%begc: , 1:, 1: ) ! matrix enteries corresponding to internal soil layers real(r8), intent(out) :: bmatrix_soil_snow(bounds%begc: , 1: ,1: ) ! matrix enteries corresponding to soil-snow interaction ! @@ -2728,7 +2728,7 @@ subroutine SetMatrix_Soil(bounds, num_nolakec, filter_nolakec, nband, & SHR_ASSERT_ALL_FL((ubound(dz_h2osfc) == (/bounds%endc/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(fact) == (/bounds%endc, nlevmaxurbgrnd/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(frac_h2osfc) == (/bounds%endc/)), sourcefile, __LINE__) - SHR_ASSERT_ALL_FL((ubound(frac_sno_eff) == (/bounds%endc/)), sourcefile, __LINE__) + SHR_ASSERT_ALL_FL((ubound(frac_sno_fluxes) == (/bounds%endc/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(bmatrix_soil) == (/bounds%endc, nband, nlevmaxurbgrnd/)), sourcefile, __LINE__) SHR_ASSERT_ALL_FL((ubound(bmatrix_soil_snow) == (/bounds%endc, nband, 1/)), sourcefile, __LINE__) @@ -2812,9 +2812,9 @@ subroutine SetMatrix_Soil(bounds, num_nolakec, filter_nolakec, nband, & dzp = (z(c,j+1)-z(c,j)) bmatrix_soil(c,2,j) = - (1._r8-cnfac)*fact(c,j)*tk(c,j)/dzp bmatrix_soil(c,3,j) = 1._r8 + (1._r8-cnfac)*fact(c,j)*(tk(c,j)/dzp & - + frac_sno_eff(c) * tk(c,j-1)/dzm) & - - (1._r8 - frac_sno_eff(c))*fact(c,j)*dhsdT(c) - bmatrix_soil_snow(c,5,j) = - frac_sno_eff(c) * (1._r8-cnfac) * fact(c,j) & + + frac_sno_fluxes(c) * tk(c,j-1)/dzm) & + - (1._r8 - frac_sno_fluxes(c))*fact(c,j)*dhsdT(c) + bmatrix_soil_snow(c,5,j) = - frac_sno_fluxes(c) * (1._r8-cnfac) * fact(c,j) & * tk(c,j-1)/dzm else if (j <= nlevgrnd-1) then dzm = (z(c,j)-z(c,j-1)) diff --git a/src/biogeophys/SurfaceAlbedoMod.F90 b/src/biogeophys/SurfaceAlbedoMod.F90 index d8d71ae41d..04728dd0af 100644 --- a/src/biogeophys/SurfaceAlbedoMod.F90 +++ b/src/biogeophys/SurfaceAlbedoMod.F90 @@ -401,7 +401,7 @@ subroutine SurfaceAlbedo(bounds,nc, & elai => canopystate_inst%elai_patch , & ! Input: [real(r8) (:) ] one-sided leaf area index with burying by snow esai => canopystate_inst%esai_patch , & ! Input: [real(r8) (:) ] one-sided stem area index with burying by snow - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) fcansno => waterdiagnosticbulk_inst%fcansno_patch , & ! Input: [real(r8) (:) ] fraction of canopy that is snow-covered (0 to 1) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid water content (col,lyr) [kg/m2] h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] ice lens content (col,lyr) [kg/m2] @@ -812,28 +812,28 @@ subroutine SurfaceAlbedo(bounds,nc, & if (coszen_col(c) > 0._r8) then ! ground albedo was originally computed in SoilAlbedo, but is now computed here ! because the order of SoilAlbedo and SNICAR_RT was switched for SNICAR. - albgrd(c,ib) = albsod(c,ib)*(1._r8-frac_sno(c)) + albsnd(c,ib)*frac_sno(c) - albgri(c,ib) = albsoi(c,ib)*(1._r8-frac_sno(c)) + albsni(c,ib)*frac_sno(c) + albgrd(c,ib) = albsod(c,ib)*(1._r8-frac_sno_albedo(c)) + albsnd(c,ib)*frac_sno_albedo(c) + albgri(c,ib) = albsoi(c,ib)*(1._r8-frac_sno_albedo(c)) + albsni(c,ib)*frac_sno_albedo(c) ! albedos for radiative forcing calculations: if (use_snicar_frc) then ! BC forcing albedo - albgrd_bc(c,ib) = albsod(c,ib)*(1.-frac_sno(c)) + albsnd_bc(c,ib)*frac_sno(c) - albgri_bc(c,ib) = albsoi(c,ib)*(1.-frac_sno(c)) + albsni_bc(c,ib)*frac_sno(c) + albgrd_bc(c,ib) = albsod(c,ib)*(1.-frac_sno_albedo(c)) + albsnd_bc(c,ib)*frac_sno_albedo(c) + albgri_bc(c,ib) = albsoi(c,ib)*(1.-frac_sno_albedo(c)) + albsni_bc(c,ib)*frac_sno_albedo(c) if (do_sno_oc) then ! OC forcing albedo - albgrd_oc(c,ib) = albsod(c,ib)*(1.-frac_sno(c)) + albsnd_oc(c,ib)*frac_sno(c) - albgri_oc(c,ib) = albsoi(c,ib)*(1.-frac_sno(c)) + albsni_oc(c,ib)*frac_sno(c) + albgrd_oc(c,ib) = albsod(c,ib)*(1.-frac_sno_albedo(c)) + albsnd_oc(c,ib)*frac_sno_albedo(c) + albgri_oc(c,ib) = albsoi(c,ib)*(1.-frac_sno_albedo(c)) + albsni_oc(c,ib)*frac_sno_albedo(c) endif ! dust forcing albedo - albgrd_dst(c,ib) = albsod(c,ib)*(1.-frac_sno(c)) + albsnd_dst(c,ib)*frac_sno(c) - albgri_dst(c,ib) = albsoi(c,ib)*(1.-frac_sno(c)) + albsni_dst(c,ib)*frac_sno(c) + albgrd_dst(c,ib) = albsod(c,ib)*(1.-frac_sno_albedo(c)) + albsnd_dst(c,ib)*frac_sno_albedo(c) + albgri_dst(c,ib) = albsoi(c,ib)*(1.-frac_sno_albedo(c)) + albsni_dst(c,ib)*frac_sno_albedo(c) ! pure snow albedo for all-aerosol radiative forcing - albgrd_pur(c,ib) = albsod(c,ib)*(1.-frac_sno(c)) + albsnd_pur(c,ib)*frac_sno(c) - albgri_pur(c,ib) = albsoi(c,ib)*(1.-frac_sno(c)) + albsni_pur(c,ib)*frac_sno(c) + albgrd_pur(c,ib) = albsod(c,ib)*(1.-frac_sno_albedo(c)) + albsnd_pur(c,ib)*frac_sno_albedo(c) + albgri_pur(c,ib) = albsoi(c,ib)*(1.-frac_sno_albedo(c)) + albsni_pur(c,ib)*frac_sno_albedo(c) end if ! also in this loop (but optionally in a different loop for vectorized code) @@ -842,15 +842,15 @@ subroutine SurfaceAlbedo(bounds,nc, & do i = -nlevsno+1,1,1 if (.not. use_subgrid_fluxes .or. lun%itype(col%landunit(c)) == istdlak) then if (ib == 1) then - flx_absdv(c,i) = flx_absd_snw(c,i,ib)*frac_sno(c) + & - ((1.-frac_sno(c))*(1-albsod(c,ib))*(flx_absd_snw(c,i,ib)/(1.-albsnd(c,ib)))) - flx_absiv(c,i) = flx_absi_snw(c,i,ib)*frac_sno(c) + & - ((1.-frac_sno(c))*(1-albsoi(c,ib))*(flx_absi_snw(c,i,ib)/(1.-albsni(c,ib)))) + flx_absdv(c,i) = flx_absd_snw(c,i,ib)*frac_sno_albedo(c) + & + ((1.-frac_sno_albedo(c))*(1-albsod(c,ib))*(flx_absd_snw(c,i,ib)/(1.-albsnd(c,ib)))) + flx_absiv(c,i) = flx_absi_snw(c,i,ib)*frac_sno_albedo(c) + & + ((1.-frac_sno_albedo(c))*(1-albsoi(c,ib))*(flx_absi_snw(c,i,ib)/(1.-albsni(c,ib)))) elseif (ib == 2) then - flx_absdn(c,i) = flx_absd_snw(c,i,ib)*frac_sno(c) + & - ((1.-frac_sno(c))*(1-albsod(c,ib))*(flx_absd_snw(c,i,ib)/(1.-albsnd(c,ib)))) - flx_absin(c,i) = flx_absi_snw(c,i,ib)*frac_sno(c) + & - ((1.-frac_sno(c))*(1-albsoi(c,ib))*(flx_absi_snw(c,i,ib)/(1.-albsni(c,ib)))) + flx_absdn(c,i) = flx_absd_snw(c,i,ib)*frac_sno_albedo(c) + & + ((1.-frac_sno_albedo(c))*(1-albsod(c,ib))*(flx_absd_snw(c,i,ib)/(1.-albsnd(c,ib)))) + flx_absin(c,i) = flx_absi_snw(c,i,ib)*frac_sno_albedo(c) + & + ((1.-frac_sno_albedo(c))*(1-albsoi(c,ib))*(flx_absi_snw(c,i,ib)/(1.-albsni(c,ib)))) endif else if (ib == 1) then diff --git a/src/biogeophys/SurfaceHumidityMod.F90 b/src/biogeophys/SurfaceHumidityMod.F90 index 25018211a9..2c5d74f1e4 100644 --- a/src/biogeophys/SurfaceHumidityMod.F90 +++ b/src/biogeophys/SurfaceHumidityMod.F90 @@ -90,7 +90,7 @@ subroutine CalculateSurfaceHumidity(bounds, & frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col , & ! Input: [real(r8) (:) ] fraction of ground covered by surface water (0 to 1) - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col , & ! Input: [real(r8) (:) ] eff. fraction of ground covered by snow (0 to 1) h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:) ] ice lens (kg/m2) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:) ] liquid water (kg/m2) qg_snow => waterdiagnosticbulk_inst%qg_snow_col , & ! Output: [real(r8) (:) ] specific humidity at snow surface [kg/kg] @@ -136,8 +136,8 @@ subroutine CalculateSurfaceHumidity(bounds, & psit = max(smpmin(c), psit) ! modify qred to account for h2osfc hr = exp(psit/roverg/t_soisno(c,1)) - qred = (1._r8 - frac_sno_eff(c) - frac_h2osfc(c))*hr & - + frac_sno_eff(c) + frac_h2osfc(c) + qred = (1._r8 - frac_sno_fluxes(c) - frac_h2osfc(c))*hr & + + frac_sno_fluxes(c) + frac_h2osfc(c) soilalpha(c) = qred else if (col%itype(c) == icol_road_perv) then @@ -155,7 +155,7 @@ subroutine CalculateSurfaceHumidity(bounds, & hr_road_perv = hr_road_perv + rootr_road_perv(c,j) end do ! Allows for sublimation of snow or dew on snow - qred = (1.-frac_sno_eff(c))*hr_road_perv + frac_sno_eff(c) + qred = (1.-frac_sno_fluxes(c))*hr_road_perv + frac_sno_fluxes(c) ! Normalize root resistances to get layer contribution to total ET if (hr_road_perv > 0._r8) then @@ -194,8 +194,8 @@ subroutine CalculateSurfaceHumidity(bounds, & call QSat(t_soisno(c,snl(c)+1), forc_pbot(c), qsatg, & qsdT = qsatgdT_snow) qg_snow(c) = qsatg - dqgdT(c) = frac_sno_eff(c)*qsatgdT_snow + & - (1._r8 - frac_sno_eff(c) - frac_h2osfc(c))*hr*qsatgdT_soil + dqgdT(c) = frac_sno_fluxes(c)*qsatgdT_snow + & + (1._r8 - frac_sno_fluxes(c) - frac_h2osfc(c))*hr*qsatgdT_soil else ! To be consistent with hs_top values in SoilTemp, set qg_snow to qg_soil ! for snl = 0 case. This ensures hs_top_snow will equal hs_top_soil. @@ -212,7 +212,7 @@ subroutine CalculateSurfaceHumidity(bounds, & qg_h2osfc(c) = qg_soil(c) end if - qg(c) = frac_sno_eff(c)*qg_snow(c) + (1._r8 - frac_sno_eff(c) - frac_h2osfc(c))*qg_soil(c) & + qg(c) = frac_sno_fluxes(c)*qg_snow(c) + (1._r8 - frac_sno_fluxes(c) - frac_h2osfc(c))*qg_soil(c) & + frac_h2osfc(c) * qg_h2osfc(c) else diff --git a/src/biogeophys/SurfaceRadiationMod.F90 b/src/biogeophys/SurfaceRadiationMod.F90 index 5de3ba6e09..650791c54d 100644 --- a/src/biogeophys/SurfaceRadiationMod.F90 +++ b/src/biogeophys/SurfaceRadiationMod.F90 @@ -539,7 +539,7 @@ subroutine SurfaceRadiation(bounds, num_nourbanp, filter_nourbanp, & forc_solai => atm2lnd_inst%forc_solai_grc , & ! Input: [real(r8) (:,:) ] diffuse radiation (W/m**2) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) nrad => surfalb_inst%nrad_patch , & ! Input: [integer (:) ] number of canopy layers, above snow for radiative transfer coszen => surfalb_inst%coszen_col , & ! Input: [real(r8) (:) ] column cosine of solar zenith angle @@ -636,7 +636,7 @@ subroutine SurfaceRadiation(bounds, num_nourbanp, filter_nourbanp, & fsds_sno_nd => surfrad_inst%fsds_sno_nd_patch , & ! Output: [real(r8) (:) ] incident near-IR, direct radiation on snow (for history files) (patch) [W/m2] fsds_sno_vi => surfrad_inst%fsds_sno_vi_patch , & ! Output: [real(r8) (:) ] incident visible, diffuse radiation on snow (for history files) (patch) [W/m2] fsds_sno_ni => surfrad_inst%fsds_sno_ni_patch , & ! Output: [real(r8) (:) ] incident near-IR, diffuse radiation on snow (for history files) (patch) [W/m2] - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col & !Input: + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col & !Input: ) @@ -870,11 +870,11 @@ subroutine SurfaceRadiation(bounds, num_nourbanp, filter_nourbanp, & sfc_frc_aer(p) = sabg(p) - sabg_pur(p) ! forcings averaged only over snow: - if (frac_sno(c) > 0._r8) then - sfc_frc_bc_sno(p) = sfc_frc_bc(p)/frac_sno(c) - sfc_frc_oc_sno(p) = sfc_frc_oc(p)/frac_sno(c) - sfc_frc_dst_sno(p) = sfc_frc_dst(p)/frac_sno(c) - sfc_frc_aer_sno(p) = sfc_frc_aer(p)/frac_sno(c) + if (frac_sno_albedo(c) > 0._r8) then + sfc_frc_bc_sno(p) = sfc_frc_bc(p)/frac_sno_albedo(c) + sfc_frc_oc_sno(p) = sfc_frc_oc(p)/frac_sno_albedo(c) + sfc_frc_dst_sno(p) = sfc_frc_dst(p)/frac_sno_albedo(c) + sfc_frc_aer_sno(p) = sfc_frc_aer(p)/frac_sno_albedo(c) else sfc_frc_bc_sno(p) = spval sfc_frc_oc_sno(p) = spval diff --git a/src/biogeophys/SurfaceResistanceMod.F90 b/src/biogeophys/SurfaceResistanceMod.F90 index 9b04327252..d2d58b5ae1 100644 --- a/src/biogeophys/SurfaceResistanceMod.F90 +++ b/src/biogeophys/SurfaceResistanceMod.F90 @@ -277,7 +277,7 @@ subroutine calc_beta_leepielke1992(bounds, num_nolakec, filter_nolakec, & h2osoi_ice => waterstatebulk_inst%h2osoi_ice_col , & ! Input: [real(r8) (:,:)] ice lens (kg/m2) h2osoi_liq => waterstatebulk_inst%h2osoi_liq_col , & ! Input: [real(r8) (:,:)] liquid water (kg/m2) - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:)] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:)] fraction of ground covered by snow (0 to 1) frac_h2osfc => waterdiagnosticbulk_inst%frac_h2osfc_col & ! Input: [real(r8) (:)] fraction of ground covered by surface water (0 to 1) ) @@ -294,9 +294,9 @@ subroutine calc_beta_leepielke1992(bounds, num_nolakec, filter_nolakec, & fac_fc = min(1._r8, wx/watfc(c,1)) !eqn5.66 but divided by theta at field capacity fac_fc = max( fac_fc, 0.01_r8 ) ! modify soil beta by snow cover. soilbeta for snow surface is one - soilbeta(c) = (1._r8-frac_sno(c)-frac_h2osfc(c)) & + soilbeta(c) = (1._r8-frac_sno_albedo(c)-frac_h2osfc(c)) & *0.25_r8*(1._r8 - cos(SHR_CONST_PI*fac_fc))**2._r8 & - + frac_sno(c)+ frac_h2osfc(c) + + frac_sno_albedo(c)+ frac_h2osfc(c) else !when water content of ths top layer is more than that at F.C. soilbeta(c) = 1._r8 end if diff --git a/src/biogeophys/SurfaceWaterMod.F90 b/src/biogeophys/SurfaceWaterMod.F90 index 562c64cc18..e8e386232d 100644 --- a/src/biogeophys/SurfaceWaterMod.F90 +++ b/src/biogeophys/SurfaceWaterMod.F90 @@ -85,7 +85,7 @@ subroutine UpdateFracH2oSfc(bounds, num_soilc, filter_soilc, & ! - If h2osfc is too small, it is set to 0, with all of the water there being moved ! to the top soil layer ! - ! - frac_sno is potentially updated to ensure that frac_sno + frac_h2osfc <= 1 + ! - frac_sno_albedo is potentially updated to ensure that frac_sno_albedo + frac_h2osfc <= 1 ! ! Note that this just operates over soil points: special landunits have frac_h2osfc fixed at 0 ! @@ -131,8 +131,8 @@ subroutine UpdateFracH2oSfc(bounds, num_soilc, filter_soilc, & h2osno_total = h2osno_total(begc:endc), & h2osfc = b_waterstate_inst%h2osfc_col(begc:endc), & ! Outputs - frac_sno = b_waterdiagnostic_inst%frac_sno_col(begc:endc), & - frac_sno_eff = b_waterdiagnostic_inst%frac_sno_eff_col(begc:endc), & + frac_sno_albedo = b_waterdiagnostic_inst%frac_sno_albedo_col(begc:endc), & + frac_sno_fluxes = b_waterdiagnostic_inst%frac_sno_fluxes_col(begc:endc), & frac_h2osfc = b_waterdiagnostic_inst%frac_h2osfc_col(begc:endc), & frac_h2osfc_nosnow = b_waterdiagnostic_inst%frac_h2osfc_nosnow_col(begc:endc), & qflx_too_small_h2osfc_to_soil = b_waterflux_inst%qflx_too_small_h2osfc_to_soil_col(begc:endc)) @@ -180,7 +180,7 @@ end subroutine UpdateFracH2oSfc !----------------------------------------------------------------------- subroutine BulkDiag_FracH2oSfc(bounds, num_soilc, filter_soilc, & dtime, micro_sigma, h2osno_total, & - h2osfc, frac_sno, frac_sno_eff, frac_h2osfc, frac_h2osfc_nosnow, & + h2osfc, frac_sno_albedo, frac_sno_fluxes, frac_h2osfc, frac_h2osfc_nosnow, & qflx_too_small_h2osfc_to_soil) ! ! !DESCRIPTION: @@ -193,7 +193,7 @@ subroutine BulkDiag_FracH2oSfc(bounds, num_soilc, filter_soilc, & ! - If h2osfc is too small, a flux is calculated that should be applied immediately ! after this routine to move all remaining h2osfc to the top soil layer ! - ! - frac_sno is potentially updated to ensure that frac_sno + frac_h2osfc <= 1 + ! - frac_sno_albedo is potentially updated to ensure that frac_sno_albedo + frac_h2osfc <= 1 ! ! Note that this just operates over soil points: special landunits have frac_h2osfc fixed at 0 ! @@ -206,8 +206,8 @@ subroutine BulkDiag_FracH2oSfc(bounds, num_soilc, filter_soilc, & real(r8) , intent(in) :: micro_sigma( bounds%begc: ) ! microtopography pdf sigma (m) real(r8) , intent(in) :: h2osno_total( bounds%begc: ) ! total snow water (mm H2O) real(r8) , intent(in) :: h2osfc( bounds%begc: ) ! surface water (mm) - real(r8) , intent(inout) :: frac_sno( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) - real(r8) , intent(inout) :: frac_sno_eff( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_albedo( bounds%begc: ) ! fraction of ground covered by snow (0 to 1) + real(r8) , intent(inout) :: frac_sno_fluxes( bounds%begc: ) ! eff. fraction of ground covered by snow (0 to 1) real(r8) , intent(inout) :: frac_h2osfc( bounds%begc: ) ! col fractional area with surface water greater than zero real(r8) , intent(inout) :: frac_h2osfc_nosnow( bounds%begc: ) ! col fractional area with surface water greater than zero (if no snow present) real(r8) , intent(inout) :: qflx_too_small_h2osfc_to_soil( bounds%begc: ) ! h2osfc transferred to soil if h2osfc is below some threshold (mm H2O /s) @@ -222,8 +222,8 @@ subroutine BulkDiag_FracH2oSfc(bounds, num_soilc, filter_soilc, & SHR_ASSERT_FL((ubound(micro_sigma, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(h2osno_total, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(h2osfc, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno, 1) == bounds%endc), sourcefile, __LINE__) - SHR_ASSERT_FL((ubound(frac_sno_eff, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_albedo, 1) == bounds%endc), sourcefile, __LINE__) + SHR_ASSERT_FL((ubound(frac_sno_fluxes, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(frac_h2osfc, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(frac_h2osfc_nosnow, 1) == bounds%endc), sourcefile, __LINE__) SHR_ASSERT_FL((ubound(qflx_too_small_h2osfc_to_soil, 1) == bounds%endc), sourcefile, __LINE__) @@ -273,20 +273,20 @@ subroutine BulkDiag_FracH2oSfc(bounds, num_soilc, filter_soilc, & ! Note that there is a similar adjustment in subroutine SnowCompaction (related ! to fsno_melt); these two should be kept in sync (e.g., if a 3rd fraction is ! ever added in one place, it needs to be added in the other place, too). - if (frac_sno(c) > (1._r8 - frac_h2osfc(c)) .and. h2osno_total(c) > 0) then + if (frac_sno_albedo(c) > (1._r8 - frac_h2osfc(c)) .and. h2osno_total(c) > 0) then if (frac_h2osfc(c) > 0.01_r8) then - frac_h2osfc(c) = max(1.0_r8 - frac_sno(c),0.01_r8) - frac_sno(c) = 1.0_r8 - frac_h2osfc(c) + frac_h2osfc(c) = max(1.0_r8 - frac_sno_albedo(c),0.01_r8) + frac_sno_albedo(c) = 1.0_r8 - frac_h2osfc(c) else - frac_sno(c) = 1.0_r8 - frac_h2osfc(c) + frac_sno_albedo(c) = 1.0_r8 - frac_h2osfc(c) endif ! NOTE(wjs, 2019-07-16) The following line should possibly be in a - ! use_subgrid_fluxes conditional (if false, set frac_sno_eff to 1, as is done + ! use_subgrid_fluxes conditional (if false, set frac_sno_fluxes to 1, as is done ! in SnowHydrologyMod). However, if we're running with surface water enabled, ! then subgrid fluxes must also be enabled, so for now we're not bothering to ! explicitly check use_subgrid_fluxes here. - frac_sno_eff(c)=frac_sno(c) + frac_sno_fluxes(c)=frac_sno_albedo(c) endif diff --git a/src/biogeophys/UrbanAlbedoMod.F90 b/src/biogeophys/UrbanAlbedoMod.F90 index 3e84f73176..de1966f352 100644 --- a/src/biogeophys/UrbanAlbedoMod.F90 +++ b/src/biogeophys/UrbanAlbedoMod.F90 @@ -126,7 +126,7 @@ subroutine UrbanAlbedo (bounds, num_urbanl, filter_urbanl, & canyon_hwr => lun%canyon_hwr , & ! Input: [real(r8) (:) ] ratio of building height to street width wtroad_perv => lun%wtroad_perv , & ! Input: [real(r8) (:) ] weight of pervious road wrt total road - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) alb_roof_dir => urbanparams_inst%alb_roof_dir , & ! Output: [real(r8) (:,:) ] direct roof albedo alb_roof_dif => urbanparams_inst%alb_roof_dif , & ! Output: [real(r8) (:,:) ] diffuse roof albedo @@ -377,20 +377,20 @@ subroutine UrbanAlbedo (bounds, num_urbanl, filter_urbanl, & c = filter_urbanc_coszen_gt0(fc) l = col%landunit(c) if (ctype(c) == icol_roof) then - alb_roof_dir_s(l,ib) = alb_roof_dir(l,ib)*(1._r8-frac_sno(c)) & - + albsnd_roof(l,ib)*frac_sno(c) - alb_roof_dif_s(l,ib) = alb_roof_dif(l,ib)*(1._r8-frac_sno(c)) & - + albsni_roof(l,ib)*frac_sno(c) + alb_roof_dir_s(l,ib) = alb_roof_dir(l,ib)*(1._r8-frac_sno_albedo(c)) & + + albsnd_roof(l,ib)*frac_sno_albedo(c) + alb_roof_dif_s(l,ib) = alb_roof_dif(l,ib)*(1._r8-frac_sno_albedo(c)) & + + albsni_roof(l,ib)*frac_sno_albedo(c) else if (ctype(c) == icol_road_imperv) then - alb_improad_dir_s(l,ib) = alb_improad_dir(l,ib)*(1._r8-frac_sno(c)) & - + albsnd_improad(l,ib)*frac_sno(c) - alb_improad_dif_s(l,ib) = alb_improad_dif(l,ib)*(1._r8-frac_sno(c)) & - + albsni_improad(l,ib)*frac_sno(c) + alb_improad_dir_s(l,ib) = alb_improad_dir(l,ib)*(1._r8-frac_sno_albedo(c)) & + + albsnd_improad(l,ib)*frac_sno_albedo(c) + alb_improad_dif_s(l,ib) = alb_improad_dif(l,ib)*(1._r8-frac_sno_albedo(c)) & + + albsni_improad(l,ib)*frac_sno_albedo(c) else if (ctype(c) == icol_road_perv) then - alb_perroad_dir_s(l,ib) = alb_perroad_dir(l,ib)*(1._r8-frac_sno(c)) & - + albsnd_perroad(l,ib)*frac_sno(c) - alb_perroad_dif_s(l,ib) = alb_perroad_dif(l,ib)*(1._r8-frac_sno(c)) & - + albsni_perroad(l,ib)*frac_sno(c) + alb_perroad_dir_s(l,ib) = alb_perroad_dir(l,ib)*(1._r8-frac_sno_albedo(c)) & + + albsnd_perroad(l,ib)*frac_sno_albedo(c) + alb_perroad_dif_s(l,ib) = alb_perroad_dif(l,ib)*(1._r8-frac_sno_albedo(c)) & + + albsni_perroad(l,ib)*frac_sno_albedo(c) end if end do end do diff --git a/src/biogeophys/UrbanFluxesMod.F90 b/src/biogeophys/UrbanFluxesMod.F90 index a6de9bd35c..c71eadb7c0 100644 --- a/src/biogeophys/UrbanFluxesMod.F90 +++ b/src/biogeophys/UrbanFluxesMod.F90 @@ -279,7 +279,7 @@ subroutine UrbanFluxes (bounds, num_nourbanl, filter_nourbanl, swmp80_ref2m => humanindex_inst%swmp80_ref2m_patch , & ! Output: [real(r8) (:) ] 2 m Swamp Cooler temperature 80% effi (C) swmp80_ref2m_u => humanindex_inst%swmp80_ref2m_u_patch , & ! Output: [real(r8) (:) ] Urban 2 m Swamp Cooler temperature 80% effi (C) - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) snow_depth => waterdiagnosticbulk_inst%snow_depth_col , & ! Input: [real(r8) (:) ] snow height (m) dqgdT => waterdiagnosticbulk_inst%dqgdT_col , & ! Input: [real(r8) (:) ] temperature derivative of "qg" qg => waterdiagnosticbulk_inst%qg_col , & ! Input: [real(r8) (:) ] specific humidity at ground surface (kg/kg) @@ -773,7 +773,7 @@ subroutine UrbanFluxes (bounds, num_nourbanl, filter_nourbanl, else if (ctype(c) == icol_road_perv) then ! Evaporation assigned to soil term if dew or snow ! or if no liquid water available in soil column - if (dqh(l) > 0._r8 .or. frac_sno(c) > 0._r8 .or. soilalpha_u(c) <= 0._r8) then + if (dqh(l) > 0._r8 .or. frac_sno_albedo(c) > 0._r8 .or. soilalpha_u(c) <= 0._r8) then qflx_evap_soi(p) = -forc_rho(g)*wtuq_road_perv_unscl(l)*dqh(l) qflx_tran_veg(p) = 0._r8 ! Otherwise, evaporation assigned to transpiration term diff --git a/src/biogeophys/UrbanRadiationMod.F90 b/src/biogeophys/UrbanRadiationMod.F90 index ccb3f196b7..587fd646ea 100644 --- a/src/biogeophys/UrbanRadiationMod.F90 +++ b/src/biogeophys/UrbanRadiationMod.F90 @@ -122,7 +122,7 @@ subroutine UrbanRadiation (bounds , & forc_solar => atm2lnd_inst%forc_solar_not_downscaled_grc , & ! Input: [real(r8) (:) ] incident solar radiation (W/m**2) forc_lwrad => atm2lnd_inst%forc_lwrad_not_downscaled_grc , & ! Input: [real(r8) (:) ] downward infrared (longwave) radiation (W/m**2) - frac_sno => waterdiagnosticbulk_inst%frac_sno_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) + frac_sno_albedo => waterdiagnosticbulk_inst%frac_sno_albedo_col , & ! Input: [real(r8) (:) ] fraction of ground covered by snow (0 to 1) t_ref2m => temperature_inst%t_ref2m_patch , & ! Input: [real(r8) (:) ] 2 m height surface air temperature (K) t_grnd => temperature_inst%t_grnd_col , & ! Input: [real(r8) (:) ] ground temperature (K) @@ -197,13 +197,13 @@ subroutine UrbanRadiation (bounds , & do c = coli(l),colf(l) if (ctype(c) == icol_roof ) then t_roof(l) = t_grnd(c) - em_roof_s(l) = em_roof(l)*(1._r8-frac_sno(c)) + snoem*frac_sno(c) + em_roof_s(l) = em_roof(l)*(1._r8-frac_sno_albedo(c)) + snoem*frac_sno_albedo(c) else if (ctype(c) == icol_road_imperv) then t_improad(l) = t_grnd(c) - em_improad_s(l) = em_improad(l)*(1._r8-frac_sno(c)) + snoem*frac_sno(c) + em_improad_s(l) = em_improad(l)*(1._r8-frac_sno_albedo(c)) + snoem*frac_sno_albedo(c) else if (ctype(c) == icol_road_perv ) then t_perroad(l) = t_grnd(c) - em_perroad_s(l) = em_perroad(l)*(1._r8-frac_sno(c)) + snoem*frac_sno(c) + em_perroad_s(l) = em_perroad(l)*(1._r8-frac_sno_albedo(c)) + snoem*frac_sno_albedo(c) else if (ctype(c) == icol_sunwall ) then t_sunwall(l) = t_grnd(c) else if (ctype(c) == icol_shadewall ) then diff --git a/src/biogeophys/WaterDiagnosticBulkType.F90 b/src/biogeophys/WaterDiagnosticBulkType.F90 index 2daef42b77..ddbccbea15 100644 --- a/src/biogeophys/WaterDiagnosticBulkType.F90 +++ b/src/biogeophys/WaterDiagnosticBulkType.F90 @@ -68,8 +68,8 @@ module WaterDiagnosticBulkType real(r8), pointer :: dqgdT_col (:) ! col d(qg)/dT ! Fractions - real(r8), pointer :: frac_sno_col (:) ! col fraction of ground covered by snow (0 to 1) - real(r8), pointer :: frac_sno_eff_col (:) ! col fraction of ground covered by snow (0 to 1) (note: this can be 1 even if there is no snow, but should be ignored in the no-snow case) + real(r8), pointer :: frac_sno_albedo_col (:) ! col fraction of ground covered by snow (0 to 1) + real(r8), pointer :: frac_sno_fluxes_col (:) ! col fraction of ground covered by snow (0 to 1) (note: this can be 1 even if there is no snow, but should be ignored in the no-snow case) real(r8), pointer :: frac_iceold_col (:,:) ! col fraction of ice relative to the tot water (new) (-nlevsno+1:nlevgrnd) real(r8), pointer :: frac_h2osfc_col (:) ! col fractional area with surface water greater than zero real(r8), pointer :: frac_h2osfc_nosnow_col (:) ! col fractional area with surface water greater than zero (if no snow present) @@ -222,8 +222,8 @@ subroutine InitBulkAllocate(this, bounds) allocate(this%rh_af_patch (begp:endp)) ; this%rh_af_patch (:) = nan allocate(this%rh10_af_patch (begp:endp)) ; this%rh10_af_patch (:) = spval - allocate(this%frac_sno_col (begc:endc)) ; this%frac_sno_col (:) = nan - allocate(this%frac_sno_eff_col (begc:endc)) ; this%frac_sno_eff_col (:) = nan + allocate(this%frac_sno_albedo_col (begc:endc)) ; this%frac_sno_albedo_col (:) = nan + allocate(this%frac_sno_fluxes_col (begc:endc)) ; this%frac_sno_fluxes_col (:) = nan allocate(this%frac_iceold_col (begc:endc,-nlevsno+1:nlevgrnd)) ; this%frac_iceold_col (:,:) = nan allocate(this%frac_h2osfc_col (begc:endc)) ; this%frac_h2osfc_col (:) = nan allocate(this%frac_h2osfc_nosnow_col (begc:endc)) ; this%frac_h2osfc_nosnow_col (:) = nan @@ -393,29 +393,29 @@ subroutine InitBulkHistory(this, bounds) long_name=this%info%lname('fraction of ground covered by surface water (if no snow present)'), & ptr_col=this%frac_h2osfc_nosnow_col, default='inactive') - this%frac_sno_col(begc:endc) = spval + this%frac_sno_albedo_col(begc:endc) = spval call hist_addfld1d ( & fname=this%info%fname('FSNO'), & units='unitless', & avgflag='A', & long_name=this%info%lname('fraction of ground covered by snow'), & - ptr_col=this%frac_sno_col, c2l_scale_type='urbanf') + ptr_col=this%frac_sno_albedo_col, c2l_scale_type='urbanf') call hist_addfld1d ( & fname=this%info%fname('FSNO_ICE'), & units='unitless', & avgflag='A', & long_name=this%info%lname('fraction of ground covered by snow (ice landunits only)'), & - ptr_col=this%frac_sno_col, c2l_scale_type='urbanf', l2g_scale_type='ice', & + ptr_col=this%frac_sno_albedo_col, c2l_scale_type='urbanf', l2g_scale_type='ice', & default='inactive') - this%frac_sno_eff_col(begc:endc) = spval + this%frac_sno_fluxes_col(begc:endc) = spval call hist_addfld1d ( & fname=this%info%fname('FSNO_EFF'), & units='unitless', & avgflag='A', & long_name=this%info%lname('effective fraction of ground covered by snow'), & - ptr_col=this%frac_sno_eff_col, c2l_scale_type='urbanf')!, default='inactive') + ptr_col=this%frac_sno_fluxes_col, c2l_scale_type='urbanf')!, default='inactive') if (use_cn) then this%fwet_patch(begp:endp) = spval @@ -750,16 +750,16 @@ subroutine InitBulkCold(this, bounds, & l = col%landunit(c) if (lun%urbpoi(l)) then ! From Bonan 1996 (LSM technical note) - this%frac_sno_col(c) = min( this%snow_depth_col(c)/0.05_r8, 1._r8) + this%frac_sno_albedo_col(c) = min( this%snow_depth_col(c)/0.05_r8, 1._r8) else - this%frac_sno_col(c) = 0._r8 + this%frac_sno_albedo_col(c) = 0._r8 ! snow cover fraction as in Niu and Yang 2007 if(this%snow_depth_col(c) > 0.0) then snowbd = min(400._r8, h2osno_input_col(c)/this%snow_depth_col(c)) !bulk density of snow (kg/m3) fmelt = (snowbd/100.)**1. ! 100 is the assumed fresh snow density; 1 is a melting factor that could be ! reconsidered, optimal value of 1.5 in Niu et al., 2007 - this%frac_sno_col(c) = tanh( this%snow_depth_col(c) / (2.5 * params_inst%zlnd * fmelt) ) + this%frac_sno_albedo_col(c) = tanh( this%snow_depth_col(c) / (2.5 * params_inst%zlnd * fmelt) ) endif end if end do @@ -856,23 +856,23 @@ subroutine RestartBulk(this, bounds, ncid, flag, writing_finidat_interp_dest_fil endif call restartvar(ncid=ncid, flag=flag, & - varname=this%info%fname('frac_sno_eff'), & + varname=this%info%fname('frac_sno_fluxes:frac_sno_eff'), & xtype=ncd_double, & dim1name='column', & long_name=this%info%lname('fraction of ground covered by snow (0 to 1)'),& units='unitless', & - interpinic_flag='interp', readvar=readvar, data=this%frac_sno_eff_col) + interpinic_flag='interp', readvar=readvar, data=this%frac_sno_fluxes_col) if (flag == 'read' .and. .not. readvar) then - this%frac_sno_eff_col(bounds%begc:bounds%endc) = 0.0_r8 + this%frac_sno_fluxes_col(bounds%begc:bounds%endc) = 0.0_r8 end if call restartvar(ncid=ncid, flag=flag, & - varname=this%info%fname('frac_sno'), & + varname=this%info%fname('frac_sno_albedo:frac_sno'), & xtype=ncd_double, & dim1name='column', & long_name=this%info%lname('fraction of ground covered by snow (0 to 1)'),& units='unitless',& - interpinic_flag='interp', readvar=readvar, data=this%frac_sno_col) + interpinic_flag='interp', readvar=readvar, data=this%frac_sno_albedo_col) call this%RestartBackcompatIssue783( & bounds = bounds, & ncid = ncid, & @@ -1001,8 +1001,8 @@ subroutine RestartBackcompatIssue783(this, bounds, ncid, flag, & ! Apply backwards compatibility corrections to address issue ESCOMP/ctsm#783 ! ! BACKWARDS_COMPATIBILITY(wjs, 2019-10-15) Due to ESCOMP/ctsm#783, old restart files - ! can have frac_sno == 0 for lake points despite having a snow pack. This can cause - ! other problems, so fix that here. However, it is apparently possible for frac_sno to + ! can have frac_sno_albedo == 0 for lake points despite having a snow pack. This can cause + ! other problems, so fix that here. However, it is apparently possible for frac_sno_albedo to ! be 0 legitimately when h2osno_total > 0. So if we apply this correction always, then ! we sometimes introduce unintentional changes to newer restart files where we don't ! actually need to apply this correction. We avoid this by writing metadata to the @@ -1072,11 +1072,11 @@ subroutine RestartBackcompatIssue783(this, bounds, ncid, flag, & h2osno_total = h2osno_total(bounds%begc:bounds%endc)) do fc = 1, filter_lakec%num c = filter_lakec%indices(fc) - if (this%frac_sno_col(c) == 0._r8 .and. h2osno_total(c) > 0._r8) then + if (this%frac_sno_albedo_col(c) == 0._r8 .and. h2osno_total(c) > 0._r8) then ! Often the value should be between 0 and 1 rather than being 1, but 1 is at ! least better than 0 in this case, and it would be tricky or impossible to ! figure out the "correct" value. - this%frac_sno_col(c) = 1._r8 + this%frac_sno_albedo_col(c) = 1._r8 end if end do end if diff --git a/src/main/clm_driver.F90 b/src/main/clm_driver.F90 index 05fa6145ba..939b2d3fe0 100644 --- a/src/main/clm_driver.F90 +++ b/src/main/clm_driver.F90 @@ -612,7 +612,7 @@ subroutine clm_drv(doalb, nextsw_cday, declinp1, declin, rstwr, nlend, rdate, ro atm2lnd_inst, temperature_inst, & aerosol_inst, water_inst) - ! update surface water fraction (this may modify frac_sno) + ! update surface water fraction (this may modify frac_sno_albedo) call UpdateFracH2oSfc(bounds_clump, & filter(nc)%num_soilc, filter(nc)%soilc, & water_inst) @@ -1036,7 +1036,7 @@ subroutine clm_drv(doalb, nextsw_cday, declinp1, declin, rstwr, nlend, rdate, ro l = col%landunit(c) if (lun%urbpoi(l)) then ! Urban landunit use Bonan 1996 (LSM Technical Note) - water_inst%waterdiagnosticbulk_inst%frac_sno_col(c) = & + water_inst%waterdiagnosticbulk_inst%frac_sno_albedo_col(c) = & min( water_inst%waterdiagnosticbulk_inst%snow_depth_col(c)/0.05_r8, 1._r8) end if end do diff --git a/src/unit_test_shr/unittestDustEmisInputs.F90 b/src/unit_test_shr/unittestDustEmisInputs.F90 index 771eb410f7..08ad677ed4 100644 --- a/src/unit_test_shr/unittestDustEmisInputs.F90 +++ b/src/unit_test_shr/unittestDustEmisInputs.F90 @@ -257,7 +257,7 @@ subroutine print_values(this) do c = bounds%begc, bounds%endc print *, 'watsat = ', this%soilstate_inst%watsat_col(c,1) print *, 'h2osoi_vol = ', this%water_inst%waterstatebulk_inst%h2osoi_vol_col(c,1) - print *, 'frac_sno = ', this%water_inst%waterdiagnosticbulk_inst%frac_sno_col(c) + print *, 'frac_sno_albedo = ', this%water_inst%waterdiagnosticbulk_inst%frac_sno_albedo_col(c) print *, 'mss_frac_clay_vld = ', this%soilstate_inst%mss_frc_cly_vld_col(c) end do do p = bounds%begp, bounds%endp diff --git a/src/utils/clmfates_interfaceMod.F90 b/src/utils/clmfates_interfaceMod.F90 index dc33169a97..3f9a662c02 100644 --- a/src/utils/clmfates_interfaceMod.F90 +++ b/src/utils/clmfates_interfaceMod.F90 @@ -1603,7 +1603,7 @@ subroutine wrap_update_hlmfates_dyn(this, nc, bounds_clump, & displa => canopystate_inst%displa_patch, & dleaf_patch => canopystate_inst%dleaf_patch, & snow_depth => waterdiagnosticbulk_inst%snow_depth_col, & - frac_sno_eff => waterdiagnosticbulk_inst%frac_sno_eff_col, & + frac_sno_fluxes => waterdiagnosticbulk_inst%frac_sno_fluxes_col, & frac_veg_nosno_alb => canopystate_inst%frac_veg_nosno_alb_patch) @@ -1612,7 +1612,7 @@ subroutine wrap_update_hlmfates_dyn(this, nc, bounds_clump, & do s=1,this%fates(nc)%nsites c = this%f2hmap(nc)%fcolumn(s) this%fates(nc)%bc_in(s)%snow_depth_si = snow_depth(c) - this%fates(nc)%bc_in(s)%frac_sno_eff_si = frac_sno_eff(c) + this%fates(nc)%bc_in(s)%frac_sno_eff_si = frac_sno_fluxes(c) end do ! Only update the fates internal snow burial if this is not a restart