diff --git a/borland_source/CRHMmain.cpp b/borland_source/CRHMmain.cpp index 717cee40e..b8655791a 100644 --- a/borland_source/CRHMmain.cpp +++ b/borland_source/CRHMmain.cpp @@ -1,10 +1,10 @@ -// 04/12/21 change float to long for use_rho parameter in NewModules.h -// in SWEslope module 03/15/21 +// 04/06/22 update description for parameters, variables and units in +// various modules in 03/21/22 //--------------------------------------------------------------------------- #include #pragma hdrstop -#define CurrentVersion "04/12/21" +#define CurrentVersion "04/06/22" #include #include "CRHMmain.h" diff --git a/borland_source/NewModules.cpp b/borland_source/NewModules.cpp index f9a8b0a5e..655d8226c 100644 --- a/borland_source/NewModules.cpp +++ b/borland_source/NewModules.cpp @@ -1,4 +1,4 @@ -// 03/15/21 +// 04/06/22 //--------------------------------------------------------------------------- #include @@ -56,59 +56,59 @@ void MoveModulesToGlobal(String DLLName){ DLLModules.AddModule(new Classebsm("ebsm", "01/18/16", CRHM::BASIC)); - DLLModules.AddModule(new ClassLongVt("longVt", "02/10/16", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassLongVt("longVt", "04/04/22", CRHM::ADVANCE)); DLLModules.AddModule(new ClassSlope_Qsi("Slope_Qsi", "07/14/11", CRHM::ADVANCE)); DLLModules.AddModule(new Classalbedo("albedo", "08/11/11", CRHM::BASIC)); - DLLModules.AddModule(new Classnetall("netall", "03/22/16", CRHM::BASIC)); - DLLModules.AddModule(new Classevap("evap", "09/26/13", CRHM::BASIC)); + DLLModules.AddModule(new Classnetall("netall", "04/04/22", CRHM::BASIC)); + DLLModules.AddModule(new Classevap("evap", "03/18/22", CRHM::BASIC)); DLLModules.AddModule(new ClassevapD("evapD", "11/04/09", CRHM::ADVANCE)); - DLLModules.AddModule(new Classevap_Resist("evap_Resist", "06/09/20", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassevapD_Resist("evapD_Resist", "06/09/20", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassShutWall("ShuttleWallace", "10/05/06", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassShutWallD("ShuttleWallaceD", "10/05/06", CRHM::ADVANCE)); - - DLLModules.AddModule(new Classcrack("crack", "03/31/20", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassPrairieInfil("PrairieInfiltration", "03/31/20", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassAyers("Ayers", "01/11/17", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassGreencrack("Greencrack", "03/31/20", CRHM::BASIC)); - DLLModules.AddModule(new ClassGreenAmpt("GreenAmpt", "03/29/10", CRHM::ADVANCE)); - DLLModules.AddModule(new Classfrozen("frozen", "08/03/17", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassfrozenAyers("frozenAyers", "03/30/20", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassSoil("Soil", "02/01/21", CRHM::BASIC)); - DLLModules.AddModule(new ClassevapX("evapX", "06/09/20", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassSoilX("SoilX", "11/28/17", CRHM::ADVANCE)); // nlay >= 2 check added - DLLModules.AddModule(new ClassSoilDS("SoilDetention", "11/28/17", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassSoilPrairie("SoilPrairie", "10/22/18", CRHM::PROTO)); // prototype wetlands + DLLModules.AddModule(new Classevap_Resist("evap_Resist", "04/04/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassevapD_Resist("evapD_Resist", "04/04/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassShutWall("ShuttleWallace", "04/04/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassShutWallD("ShuttleWallaceD", "04/04/22", CRHM::ADVANCE)); + + DLLModules.AddModule(new Classcrack("crack", "04/04/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassPrairieInfil("PrairieInfiltration", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassAyers("Ayers", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassGreencrack("Greencrack", "04/04/22", CRHM::BASIC)); + DLLModules.AddModule(new ClassGreenAmpt("GreenAmpt", "04/04/22", CRHM::ADVANCE)); + DLLModules.AddModule(new Classfrozen("frozen", "04/04/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassfrozenAyers("frozenAyers", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassSoil("Soil", "04/05/22", CRHM::BASIC)); + DLLModules.AddModule(new ClassevapX("evapX", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassSoilX("SoilX", "04/05/22", CRHM::ADVANCE)); // nlay >= 2 check added + DLLModules.AddModule(new ClassSoilDS("SoilDetention", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassSoilPrairie("SoilPrairie", "04/05/22", CRHM::PROTO)); // prototype wetlands DLLModules.AddModule(new Classglacier_061718("glacier_061718", "06/10/16", CRHM::PROTO)); - DLLModules.AddModule(new Classglacier("glacier", "07/02/20", CRHM::ADVANCE)); + DLLModules.AddModule(new Classglacier("glacier", "04/05/22", CRHM::ADVANCE)); DLLModules.AddModule(new ClassSWEslope_061718("SWESlope_061718", "06/02/16", CRHM::PROTO)); - DLLModules.AddModule(new ClassSWEslope("SWESlope", "11/01/17", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassSWEslope("SWESlope", "04/05/22", CRHM::ADVANCE)); DLLModules.AddModule(new ClassICEflow("ICEflow", "12/31/18", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassNetroute("Netroute", "06/20/18", CRHM::BASIC)); - DLLModules.AddModule(new ClassNetroute_D("Netroute_D", "06/20/18", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassNetroute_M("Netroute_M", "06/20/18", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassNetroute_M_D("Netroute_M_D", "10/26/18", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassREWroute("REW_route", "06/19/18", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassNetroute("Netroute", "04/05/22", CRHM::BASIC)); + DLLModules.AddModule(new ClassNetroute_D("Netroute_D", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassNetroute_M("Netroute_M", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassNetroute_M_D("Netroute_M_D", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassREWroute("REW_route", "04/05/22", CRHM::ADVANCE)); DLLModules.AddModule(new ClassREWroute_stream("REW_route_stream", "07/09/18", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassREWroute2("REW_route2", "06/19/18", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassREWroute2("REW_route2", "04/05/22", CRHM::ADVANCE)); DLLModules.AddModule(new ClassSnobalCRHM("SnobalCRHM", "11/21/16", CRHM::ADVANCE)); DLLModules.AddModule(new ClasspbsmSnobal("pbsmSnobal", "01/05/17", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassCRHMCanopy("Canopy", "06/14/17", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassCRHMCanopyClearing("CanopyClearing", "04/05/19", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassCRHMCanopyClearingGap("CanopyClearingGap", "04/05/19", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassNeedle("NeedleLeaf", "07/19/11", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassCRHMCanopy("Canopy", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassCRHMCanopyClearing("CanopyClearing", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassCRHMCanopyClearingGap("CanopyClearingGap", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassNeedle("NeedleLeaf", "04/05/22", CRHM::ADVANCE)); DLLModules.AddModule(new Classwalmsley_wind("walmsley_wind", "07/30/08", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassXG("XG", "10/03/17", CRHM::ADVANCE)); + DLLModules.AddModule(new ClassXG("XG", "04/05/22", CRHM::ADVANCE)); DLLModules.AddModule(new ClassXGAyers("XGAyers", "05/19/17", CRHM::PROTO)); DLLModules.AddModule(new ClassSetSoil("SetSoil", "10/21/09", CRHM::ADVANCE)); - DLLModules.AddModule(new ClassVolumetric("Volumetric", "03/15/21", CRHM::ADVANCE)); - DLLModules.AddModule(new Classtsurface("tsurface", "01/15/19", CRHM::PROTO)); + DLLModules.AddModule(new ClassVolumetric("Volumetric", "04/05/22", CRHM::ADVANCE)); + DLLModules.AddModule(new Classtsurface("tsurface", "04/05/22", CRHM::PROTO)); DLLModules.AddModule(new Classalbedoparam("albedo_param", "11/22/05", CRHM::SUPPORT)); DLLModules.AddModule(new Classalbedoobs("albedo_obs", "11/22/05", CRHM::SUPPORT)); @@ -127,11 +127,11 @@ void MoveModulesToGlobal(String DLLName){ DLLModules.AddModule(new ClassSimpleRichard("SimpleSnow", "03/24/06", CRHM::CUSTOM)); DLLModules.AddModule(new ClassKevin("Kevin", "08/11/11", CRHM::OBSOL)); DLLModules.AddModule(new ClassTs("Tsnow", "01/15/13", CRHM::CUSTOM)); - DLLModules.AddModule(new ClassK_Estimate("K_Estimate", "01/16/18", CRHM::ADVANCE)); // fixed 'put' descriptions + DLLModules.AddModule(new ClassK_Estimate("K_Estimate", "04/06/22", CRHM::ADVANCE)); // fixed 'put' descriptions DLLModules.AddModule(new ClassSnobalX("Snobal", "02/03/16", CRHM::OBSOL)); - DLLModules.AddModule(new Classinterception("interception", "11/03/06", CRHM::OBSOL)); - DLLModules.AddModule(new Classlake("lake_evap", "07/04/12", CRHM::ADVANCE)); + DLLModules.AddModule(new Classinterception("interception", "04/05/22", CRHM::OBSOL)); + DLLModules.AddModule(new Classlake("lake_evap", "04/05/22", CRHM::ADVANCE)); if(!RELEASE){ DLLModules.AddModule(new ClassHMSA("HMSA", "01/16/13", CRHM::PROTO)); @@ -2159,17 +2159,17 @@ void Classnetall::decl(void) { Description = "'Models net all-wave radiation (Rn, RnD and RnD_POS) from sunshine hours, temperature and humidity using Brunt.'"; - declvar("net", NHRU, "all-wave net", "(MJ/m^2*int)", &net); + declvar("net", NHRU, "net all-wave radiation over time step", "(MJ/m^2*int)", &net); - decldiag("Rn", NHRU, "all-wave net", "(mm/m^2*int)", &Rn); + decldiag("Rn", NHRU, "net all-wave radiation over time step", "(mm/m^2*int)", &Rn); - declvar("netD", NHRU, "all-wave net", "(MJ/m^2*d)", &netD); + declvar("netD", NHRU, "net all-wave radiation per day", "(MJ/m^2*d)", &netD); - declvar("RnD", NHRU, "all-wave net", "(mm/m^2*d)", &RnD); + declvar("RnD", NHRU, "net all-wave radiation per day", "(mm/m^2*d)", &RnD); - decldiag("RnD_POS", NHRU, "Sum of Positive all-wave net", "(mm/m^2*d)", &RnD_POS); + decldiag("RnD_POS", NHRU, "Sum of positive net all-wave radiation per day", "(mm/m^2*d)", &RnD_POS); - declstatdiag("cum_net", NHRU, "cumulative all-wave net", "(MJ/m^2)", &cum_net); + declstatdiag("cum_net", NHRU, "cumulative net all-wave radiation", "(MJ/m^2)", &cum_net); declgetvar("*", "hru_t", "(°C)", &hru_t); @@ -2729,13 +2729,13 @@ void ClassNeedle::decl(void) { decldiag("k", NHRU, "extinction coefficient", "()", &k); - decldiag("Tauc", NHRU, "short-wave transmissivity", "(W/m^2)", &Tauc); + decldiag("Tauc", NHRU, "short-wave transmissivity", "()", &Tauc); decllocal("Pa", NHRU, "Average surface pressure", "(kPa)", &Pa); declvar("ra", NHRU, "", "(s/m)", &ra); - declvar("Qnsn_Var", NHRU, "net all-wave at snow surface", "(W/m^2*int)", &Qnsn_Var); + declvar("Qnsn_Var", NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn_Var); declparam("hru_elev", NHRU, "[637]", "0.0", "100000.0", "altitude", "(m)", &hru_elev); @@ -3275,7 +3275,7 @@ void Classevap::run(void) { evap[hh] = (delta(hru_t[hh])*Q*Global::Freq + (RHOa*Cp/ (lambda(hru_t[hh])*1e3)*(estar(hru_t[hh]) - hru_ea[hh])/(ra/86400)))/ - (delta(hru_t[hh]) + gamma(Pa[hh], hru_t[hh])*(1.0 + rs[hh]/ra))/ + (delta(hru_t[hh]) + gamma(Pa[hh], hru_t[hh])*(1.0 + rs[hh]/(ra/86400)))/ //18Mar2022 correction: add /86400 to ra term, as rs is in d/m and ra is in s/m Global::Freq; } else @@ -3824,19 +3824,19 @@ void Classcrack::decl(void) { Description = "'Handles frozen soil infiltration using Granger et al. 1984; Gray et al., 1986.'"; - declvar("snowinfil", NHRU, "infiltration", "(mm/d)", &snowinfil); + declvar("snowinfil", NHRU, "daily snowmelt infiltration", "(mm/d)", &snowinfil); - declstatdiag("cumsnowinfil", NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("meltrunoff", NHRU, "melt runoff", "(mm/d)", &meltrunoff); + declvar("meltrunoff", NHRU, "daily melt runoff", "(mm/d)", &meltrunoff); declstatdiag("cummeltrunoff", NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); - declvar("infil", NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", NHRU,"interval rainfall infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", NHRU, "cumulative rainfall infiltration", "(mm)", &cuminfil); - declvar("runoff", NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); @@ -3854,7 +3854,7 @@ void Classcrack::decl(void) { declparam("hru_area", NHRU, "[1]", "1e-6", "1e+09", "hru area", "(km^2)", &hru_area); declparam("fallstat", NHRU, "[50.0]", "-1.0","100.0", - "fall status 0.0 - unlimited/ 100.0 - restricted/ other - limited", "(%)", &fallstat); + "fall soil saturation status 0.0 - unlimited/ 100.0 - restricted/ other - limited", "(%)", &fallstat); decldiagparam("Major", NHRU, "[5]", "1", "100", "threshold for major melt", "(mm/d)", &Major); @@ -4332,21 +4332,21 @@ void ClassGreencrack::decl(void) { Description = "'Handles summer using Green Ampt and frozen soil infiltration using Granger et al. 1984; Gray et al., 1986.'"; - declvar("infil", NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", NHRU,"interval rainfall infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", NHRU, "cumulative rainfall infiltration", "(mm)", &cuminfil); - declvar("snowinfil", NHRU, "infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", NHRU, "daily snowmelt infiltration", "(mm/d)", &snowinfil); - declstatdiag("cumsnowinfil", NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("runoff", NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - declvar("meltrunoff", NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", NHRU, "daily snowmelt runoff", "(mm/d)", &meltrunoff); - declstatdiag("cummeltrunoff", NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); + declstatdiag("cummeltrunoff", NHRU, "cumulative snowmelt runoff", "(mm)", &cummeltrunoff); declvar("crackstat", NHRU, "infiltration status", "()", &crackstat); @@ -4357,21 +4357,21 @@ void ClassGreencrack::decl(void) { decllocal("RainOnSnowA", NHRU, "accumulated rain on snow", "(mm)", &RainOnSnowA); - decllocal("k", NHRU, "(mm/h)", "()", &k); + decllocal("k", NHRU, "saturated hydraulic conductivity", "(mm/h)", &k); - decllocal("F0", NHRU, "last HRU cumulative infiltration", "(mm)", &F0); + decllocal("F0", NHRU, "cumulative infiltation at the beginning of the time interval", "(mm)", &F0); - decllocal("f0", NHRU, "", "(mm/h)", &f0); + decllocal("f0", NHRU, "infiltration rate at the beginning of the time interval", "(mm/h)", &f0); - decllocal("F1", NHRU, "HRU cumulative infiltration", "(mm)", &F1); + decllocal("F1", NHRU, "cumulative infiltration at the end of the time interval", "(mm)", &F1); - decllocal("f1", NHRU, "", "(mm/h)", &f1); + decllocal("f1", NHRU, "infiltration rate at the end of the time interval", "(mm/h)", &f1); - decllocal("dthbot", NHRU, "", "()", &dthbot); + decllocal("dthbot", NHRU, "fraction value of soil water deficit", "()", &dthbot); - decllocal("psidthbot", NHRU, "", "(mm)", &psidthbot); + decllocal("psidthbot", NHRU, "capillary suction at the fraction value of soil water deficit", "(mm)", &psidthbot); - decllocal("timer", NHRU, "", "(d)", &timer); + decllocal("timer", NHRU, "indicator for limited infiltration case during Major melt infiltration", "(d)", &timer); declparam("basin_area", BASIN, "3", "1e-6", "1e+09", "total basin area", "(km^2)", &basin_area); @@ -4885,27 +4885,27 @@ void Classfrozen::decl(void) { Description = "'Frozen soil infiltration Zhao and Gray (1999).'"; - declvar("infil", NHRU, "Potential rain infiltration", "(mm/int)", &infil); + declvar("infil", NHRU, "interval rain infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", NHRU, "cumulative potential rain infiltration", "(mm)", &cuminfil); + declstatdiag("cuminfil", NHRU, "cumulative rain infiltration", "(mm)", &cuminfil); - declvar("snowinfil", NHRU, "melt infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", NHRU, "interval snowmelt infiltration", "(mm/int)", &snowinfil); - declstatvar("cumsnowinfil", NHRU, "cumulative melt infiltration", "(mm)", &cumsnowinfil); // for looping + declstatvar("cumsnowinfil", NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); // for looping - declvar("meltrunoff", NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", NHRU, "interval snowmelt runoff", "(mm/int)", &meltrunoff); - declstatdiag("cummeltrunoff", NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); + declstatdiag("cummeltrunoff", NHRU, "cumulative snowmelt runoff", "(mm)", &cummeltrunoff); - declvar("runoff", NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - decllocal("t0_Var", NHRU, "t0 value used by module", "(h)", &t0_Var); + decllocal("t0_Var", NHRU, "value of infiltration opportunity time", "(h)", &t0_Var); - decllocal("t0_Acc", NHRU, "opportunity time", "(h)", &t0_Acc); // to reset every loop + decllocal("t0_Acc", NHRU, "infiltration opportunity time accumulator", "(h)", &t0_Acc); // to reset every loop - decllocal("INF", NHRU, "parametric calculation", "(mm)", &INF); + decllocal("INF", NHRU, "infiltration into a frozen soil calculated from parametric relationship", "(mm)", &INF); decllocal("Julian_window", ONE, "currently in Julian window handling frozen infiltration.", "()", &Julian_window); @@ -5216,7 +5216,7 @@ void ClassNetroute::decl(void) { decldiag("outflow_diverted", NHRU, "HRU outflow diverted to another HRU", "(mm*km^2/int)", &outflow_diverted); - declstatdiag("cumoutflow_diverted", NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2/int)", &cumoutflow_diverted); + declstatdiag("cumoutflow_diverted", NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2)", &cumoutflow_diverted); declstatdiag("cum_to_Sd", NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm)", &cum_to_Sd); @@ -5232,25 +5232,25 @@ void ClassNetroute::decl(void) { decldiag("gwoutflow_diverted", NHRU, "HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwoutflow_diverted); - declstatdiag("gwcumoutflow_diverted", NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwcumoutflow_diverted); + declstatdiag("gwcumoutflow_diverted", NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2)", &gwcumoutflow_diverted); - declvar("ssrinflow", NHRU, "inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); + declvar("ssrinflow", NHRU, "subsurface inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); - declstatdiag("ssrcuminflow", NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); + declstatdiag("ssrcuminflow", NHRU, "cumulative subsurface inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); - declvar("ssroutflow", NHRU, "HRU outflow", "(mm*km^2/int)", &ssroutflow); + declvar("ssroutflow", NHRU, "HRU subsurface outflow", "(mm*km^2/int)", &ssroutflow); - declstatdiag("ssrcumoutflow", NHRU, "cumulative HRU outflow", "(mm*km^2)", &ssrcumoutflow); + declstatdiag("ssrcumoutflow", NHRU, "cumulative HRU subsurface outflow", "(mm*km^2)", &ssrcumoutflow); declstatdiag("HRU_cumbasinflow", NHRU, "cumulative HRU to basinflow", "(mm*km^2)", &HRU_cumbasinflow); - declvar("runinflow", NHRU, "inflow from other HRUs", "(mm*km^2/int)", &runinflow); + declvar("runinflow", NHRU, "overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2/int)", &runinflow); - declstatdiag("runcuminflow", NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &runcuminflow); + declstatdiag("runcuminflow", NHRU, "cumulative overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2)", &runcuminflow); - declvar("runoutflow", NHRU, "HRU outflow", "(mm*km^2/int)", &runoutflow); + declvar("runoutflow", NHRU, "HRU overland outflow", "(mm*km^2/int)", &runoutflow); - declstatdiag("runcumoutflow", NHRU, "cumulative HRU outflow", "(mm*km^2)", &runcumoutflow); + declstatdiag("runcumoutflow", NHRU, "cumulative HRU overland outflow", "(mm*km^2)", &runcumoutflow); declstatdiag("cum_preferential_flow_to_gw", NHRU, "cumulative other HRU's runoff to gw of this HRU via preferential flow path", "(mm)", &cum_preferential_flow_to_gw); @@ -5269,11 +5269,11 @@ void ClassNetroute::decl(void) { declstatdiag("cumbasingw", BASIN, "cumulative basin groundwater outflow", "(m^3)", &cumbasingw); - decllocal("soil_ssr_Buf", NHRU, "buffer subsurface runoff", "(mm/d)", &soil_ssr_Buf); + decllocal("soil_ssr_Buf", NHRU, "buffer subsurface runoff from soil, i.e. soil_ssr_Buf is from soil_ssr", "(mm/int)", &soil_ssr_Buf); - decllocal("soil_runoff_Buf", NHRU, "buffer rain runoff", "(mm/d)", &soil_runoff_Buf); + decllocal("soil_runoff_Buf", NHRU, "buffer overland runoff from soil, i.e. soil_runoff_Buf is from soil_runoff", "(mm/int)", &soil_runoff_Buf); - decllocal("soil_gw_Buf", NHRU, "buffer soil_gw(gw_flow) runoff", "(mm/d)", &soil_gw_Buf); + decllocal("soil_gw_Buf", NHRU, "buffer soil_gw(gw_flow) from soil, i.e. soil_gw_Buf is from gw_flow = soil_gw", "(mm/int)", &soil_gw_Buf); declparam("basin_area", BASIN, "3", "1e-6", "1e09", "Total basin area", "(km^2)", &basin_area); @@ -5695,7 +5695,7 @@ void Classinterception::decl(void) { declvar("SI_Lo", NHRU, "Canopy load", "(kg/m^2)", &SI_Lo); - declvar("net_snow", NHRU, "Canopy unload ", "(kg/m^2)", &net_snow); + declvar("net_snow", NHRU, "Canopy unload ", "(kg/m^2*int)", &net_snow); decldiag("Cum_net_snow", NHRU, "Cumulative Canopy unload ", "(kg/m^2)", &Cum_net_snow); @@ -5864,36 +5864,36 @@ void ClassGreenAmpt::decl(void) { Description = "'Summer Green Ampt model.'"; - declvar("infil", NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", NHRU,"Potential amount of rain water infiltrating the soil on each HRU", "(mm/int)", &infil); - declstatdiag("cuminfil", NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", NHRU, "cumulative potential rain water infiltration on each HRU", "(mm)", &cuminfil); declvar("runoff", NHRU, "rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - declvar("snowinfil", NHRU, "infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", NHRU, "interval snowmelt infiltration", "(mm/int)", &snowinfil); - declstatdiag("cumsnowinfil", NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("meltrunoff", NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", NHRU, "interval snowmelt runoff", "(mm/int)", &meltrunoff); - declstatvar("cummeltrunoff", NHRU, "cumulative melt runoff", "(mm/int)", &cummeltrunoff); + declstatvar("cummeltrunoff", NHRU, "cumulative snowmelt runoff", "(mm)", &cummeltrunoff); - decllocal("k", NHRU, "(mm/h)", "()", &k); + decllocal("k", NHRU, "saturated hydraulic conductivity", "(mm/h)", &k); - declstatdiag("F0", NHRU, "last HRU cumulative infiltration", "(mm)", &F0); + declstatdiag("F0", NHRU, "cumulative infiltation at the beginning of the time interval", "(mm)", &F0); - decllocal("f0", NHRU, "", "(mm/h)", &f0); + decllocal("f0", NHRU, "infiltration rate at the beginning of the time interval", "(mm/h)", &f0); - declstatdiag("F1", NHRU, "HRU cumulative infiltration", "(mm)", &F1); + declstatdiag("F1", NHRU, "cumulative infiltration at the end of the time interval", "(mm)", &F1); - decllocal("f1", NHRU, "", "(mm/h)", &f1); + decllocal("f1", NHRU, "infiltration rate at the end of the time interval", "(mm/h)", &f1); - decllocal("dthbot", NHRU, "", "()", &dthbot); + decllocal("dthbot", NHRU, "fraction value of soil water deficit", "()", &dthbot); - decllocal("psidthbot", NHRU, "", "(mm)", &psidthbot); + decllocal("psidthbot", NHRU, "capillary suction at the fraction value of soil water deficit", "(mm)", &psidthbot); declparam("basin_area", BASIN, "3", "1e-6", "1e+09", "total basin area", "(km^2)", &basin_area); @@ -9601,7 +9601,7 @@ void ClassNetroute_M::decl(void) { decldiag("outflow_diverted", NHRU, "HRU outflow diverted to another HRU", "(mm*km^2/int)", &outflow_diverted); - declstatdiag("cumoutflow_diverted", NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm*km^2/int)", &cumoutflow_diverted); + declstatdiag("cumoutflow_diverted", NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm*km^2)", &cumoutflow_diverted); declstatdiag("cum_to_Sd", NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm)", &cum_to_Sd); @@ -9617,25 +9617,25 @@ void ClassNetroute_M::decl(void) { decldiag("gwoutflow_diverted", NHRU, "HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwoutflow_diverted); - declstatdiag("gwcumoutflow_diverted", NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwcumoutflow_diverted); + declstatdiag("gwcumoutflow_diverted", NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2)", &gwcumoutflow_diverted); - declvar("ssrinflow", NHRU, "inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); + declvar("ssrinflow", NHRU, "subsurface inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); - declstatdiag("ssrcuminflow", NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); + declstatdiag("ssrcuminflow", NHRU, "cumulative subsurface inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); - declvar("ssroutflow", NHRU, "HRU outflow", "(mm*km^2/int)", &ssroutflow); + declvar("ssroutflow", NHRU, "HRU subsurface outflow", "(mm*km^2/int)", &ssroutflow); - declstatdiag("ssrcumoutflow", NHRU, "cumulative HRU outflow", "(mm*km^2)", &ssrcumoutflow); + declstatdiag("ssrcumoutflow", NHRU, "cumulative HRU subsurface outflow", "(mm*km^2)", &ssrcumoutflow); declstatdiag("HRU_cumbasinflow", NHRU, "cumulative HRU to basinflow", "(mm*km^2)", &HRU_cumbasinflow); - declvar("runinflow", NHRU, "inflow from other HRUs", "(mm*km^2/int)", &runinflow); + declvar("runinflow", NHRU, "overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2/int)", &runinflow); - declstatdiag("runcuminflow", NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &runcuminflow); + declstatdiag("runcuminflow", NHRU, "cumulative overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2)", &runcuminflow); - declvar("runoutflow", NHRU, "HRU outflow", "(mm*km^2/int)", &runoutflow); + declvar("runoutflow", NHRU, "HRU overland outflow", "(mm*km^2/int)", &runoutflow); - declstatdiag("runcumoutflow", NHRU, "cumulative HRU outflow", "(mm*km^2)", &runcumoutflow); + declstatdiag("runcumoutflow", NHRU, "cumulative HRU overland outflow", "(mm*km^2)", &runcumoutflow); declstatdiag("cum_preferential_flow_to_gw", NHRU, "cumulative other HRU's runoff to gw of this HRU via preferential flow path", "(mm)", &cum_preferential_flow_to_gw); @@ -9654,13 +9654,13 @@ void ClassNetroute_M::decl(void) { declstatdiag("cumbasingw", BASIN, "cumulative basin groundwater outflow", "(m^3)", &cumbasingw); - decllocal("soil_ssr_Buf", NHRU, "buffer subsurface runoff", "(mm/d)", &soil_ssr_Buf); + decllocal("soil_ssr_Buf", NHRU, "buffer subsurface runoff from soil, i.e. soil_ssr_Buf is from soil_ssr", "(mm/int)", &soil_ssr_Buf); - decllocal("soil_runoff_Buf", NHRU, "buffer rain runoff", "(mm/d)", &soil_runoff_Buf); + decllocal("soil_runoff_Buf", NHRU, "buffer overland runoff from soil, i.e. soil_runoff_Buf is from soil_runoff", "(mm/int)", &soil_runoff_Buf); - decllocal("soil_gw_Buf", NHRU, "buffer rain runoff", "(mm/d)", &soil_gw_Buf); + decllocal("soil_gw_Buf", NHRU, "buffer soil_gw(gw_flow) from soil, i.e. soil_gw_Buf is from gw_flow = soil_gw", "(mm/int)", &soil_gw_Buf); - decllocal("Ktravel", NHRU, "travel time", "(d)", &Ktravel); + decllocal("Ktravel", NHRU, "travel time from Muskingum method", "(d)", &Ktravel); declparam("basin_area", BASIN, "3", "1e-6", "1e09", "Total basin area", "(km^2)", &basin_area); @@ -10136,13 +10136,13 @@ void ClassREWroute2::decl(void) { gwCnt = declgrpvar("WS_ALL_gwflow", "basingw", "query variable = 'basingw'", "(m^3/int)", &gwrew, &gw_All); - declvar("WS_gwinflow", NHRU, "inflow from each RB", "(m^3/int)", &gwinflow); + declvar("WS_gwinflow", NHRU, "gwinflow from each RB", "(m^3/int)", &gwinflow); - declstatdiag("cum_WSgwinflow", NHRU, "cumulative inflow from each RB", "(m^3)", &cumgwinflow); + declstatdiag("cum_WSgwinflow", NHRU, "cumulative gwinflow from each RB", "(m^3)", &cumgwinflow); - declvar("WS_gwoutflow", NHRU, "outflow of each RB", "(m^3/int)", &gwoutflow); + declvar("WS_gwoutflow", NHRU, "gwoutflow of each RB", "(m^3/int)", &gwoutflow); - declstatdiag("cum_WSgwoutflow", NHRU, "cumulative outflow of each RB", "(m^3)", &cumgwoutflow); + declstatdiag("cum_WSgwoutflow", NHRU, "cumulative gwoutflow of each RB", "(m^3)", &cumgwoutflow); declvar("WS_gwflow", BASIN, "watershed ground water outflow", "(m^3/int)", &gwflow); @@ -10153,15 +10153,15 @@ void ClassREWroute2::decl(void) { declparam("WS_whereto", NHRU, "[0]", "0", "1000", "0 - watershed outflow, or RB input", "()", &WS_whereto); - declparam("WS_order", NHRU, "1,2,3,4,5!", "1","1000", "RB routing process order", "()", &WS_order); + declparam("WS_order", NHRU, "1,2,3,4,5!", "1","1000", "RB outflow routing process order", "()", &WS_order); declparam("WS_gwwhereto", NHRU, "[0]", "0", "1000", "0 - watershed outflow, or RB input", "()", &WS_gwwhereto); - declparam("WS_gworder", NHRU, "1,2,3,4,5!", "1","1000", "RB routing process order", "()", &WS_gworder); + declparam("WS_gworder", NHRU, "1,2,3,4,5!", "1","1000", "RB gwoutflow routing process order", "()", &WS_gworder); - declparam("WS_Lag", NHRU, "[0.0]", "0.0","1.0E4.0", "lag delay", "(h)", &WS_Lag); + declparam("WS_Lag", NHRU, "[0.0]", "0.0","1.0E4.0", "inflow lag delay", "(h)", &WS_Lag); - declparam("WS_gwLag", NHRU, "[0.0]", "0.0","1.0E4.0", "lag delay", "(h)", &WS_gwLag); + declparam("WS_gwLag", NHRU, "[0.0]", "0.0","1.0E4.0", "gwinflow lag delay", "(h)", &WS_gwLag); variation_set = VARIATION_2 + VARIATION_3; @@ -10199,13 +10199,13 @@ void ClassREWroute2::decl(void) { variation_set = VARIATION_0 + VARIATION_2; - decldiag("WS_Ktravel_var", NHRU, "inflow storage constant", "(d)", &WS_Ktravel_var); + decldiag("WS_Ktravel_var", NHRU, "inflow storage constant (Muskingum method)", "(d)", &WS_Ktravel_var); - decldiag("WS_gwKtravel_var", NHRU, "gw storage constant", "(d)", &WS_gwKtravel_var); + decldiag("WS_gwKtravel_var", NHRU, "gwinflow storage constant (Muskingum method)", "(d)", &WS_gwKtravel_var); declparam("WS_route_n", NHRU, "[0.025]", "0.016","0.2", "Manning roughness coefficient", "()", &WS_route_n); - declparam("WS_route_R", NHRU, "[0.5]", "0.01","1.0E4", "hydraulic radius", "()", &WS_route_R); + declparam("WS_route_R", NHRU, "[0.5]", "0.01","1.0E4", "hydraulic radius", "(m)", &WS_route_R); declparam("WS_route_S0", NHRU, "[1e-3]", "1e-6","1.0", "longitudinal channel slope", "()", &WS_route_S0); @@ -10220,9 +10220,9 @@ void ClassREWroute2::decl(void) { variation_set = VARIATION_1 + VARIATION_3; - declparam("WS_Kstorage", NHRU, "[0.0]", "0.0","200.0", "Clark storage constant", "(d)", &WS_Kstorage); + declparam("WS_Kstorage", NHRU, "[0.0]", "0.0","200.0", "inflow storage constant for RB (Clark method)", "(d)", &WS_Kstorage); - declparam("WS_gwKstorage", NHRU, "[0.0]", "0.0","200.0", "Clark storage constant", "(d)", &WS_gwKstorage); + declparam("WS_gwKstorage", NHRU, "[0.0]", "0.0","200.0", "gwinflow storage constant for RB (Clark method)", "(d)", &WS_gwKstorage); variation_set = VARIATION_ORG; @@ -10581,9 +10581,9 @@ ClassLongVt* ClassLongVt::klone(string name) const{ declvar("tau", NHRU, "Atmospheric transmissivity = S/Sextra", "()", &tau); - declvar("Qli_Var", NHRU, "calculated incoming long", "(W/m^2)", &Qli_Var); + declvar("Qli_Var", NHRU, "calculated incoming long-wave in open environment", "(W/m^2)", &Qli_Var); - declvar("QliVt_Var", NHRU, "calculated incoming long in open environment", "(W/m^2)", &QliVt_Var); + declvar("QliVt_Var", NHRU, "calculated incoming long-wave in rugged environment", "(W/m^2)", &QliVt_Var); @@ -11293,11 +11293,11 @@ void ClassNetroute_D::decl(void) { decldiag("outflow_diverted", NHRU, "HRU outflow diverted to another HRU", "(mm*km^2/int)", &outflow_diverted); - declstatdiag("cumoutflow_diverted", NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2/int)", &cumoutflow_diverted); + declstatdiag("cumoutflow_diverted", NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2)", &cumoutflow_diverted); decldiag("gwoutflow_diverted", NHRU, "HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwoutflow_diverted); - declstatdiag("gwcumoutflow_diverted", NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwcumoutflow_diverted); + declstatdiag("gwcumoutflow_diverted", NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2)", &gwcumoutflow_diverted); declstatdiag("cum_to_Sd", NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm)", &cum_to_Sd); @@ -11311,13 +11311,13 @@ void ClassNetroute_D::decl(void) { declstatdiag("gwcumoutflow", NHRU, "cumulative HRU gw outflow", "(mm*km^2)", &gwcumoutflow); - declvar("ssrinflow", NHRU, "inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); + declvar("ssrinflow", NHRU, "subsurface inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); - declstatdiag("ssrcuminflow", NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); + declstatdiag("ssrcuminflow", NHRU, "cumulative subsurface inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); - declvar("ssroutflow", NHRU, "HRU outflow", "(mm*km^2/int)", &ssroutflow); + declvar("ssroutflow", NHRU, "HRU subsurface outflow", "(mm*km^2/int)", &ssroutflow); - declstatdiag("ssrcumoutflow", NHRU, "cumulative HRU outflow", "(mm*km^2)", &ssrcumoutflow); + declstatdiag("ssrcumoutflow", NHRU, "cumulative HRU subsurface outflow", "(mm*km^2)", &ssrcumoutflow); declstatdiag("HRU_cumbasinflow", NHRU, "cumulative HRU to basinflow", "(mm*km^2)", &HRU_cumbasinflow); @@ -11326,13 +11326,13 @@ void ClassNetroute_D::decl(void) { declparam("preferential_flow", NHRU, "[0]", "0", "1","0 - no preferential and remain as runoff routing to other HRU, 1 - preferential flow and route runoff to other HRU's gw.", "()", &preferential_flow); - declvar("runinflow", NHRU, "inflow from other HRUs", "(mm*km^2/int)", &runinflow); + declvar("runinflow", NHRU, "overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2/int)", &runinflow); - declstatdiag("runcuminflow", NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &runcuminflow); + declstatdiag("runcuminflow", NHRU, "cumulative overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2)", &runcuminflow); - declvar("runoutflow", NHRU, "HRU outflow", "(mm*km^2/int)", &runoutflow); + declvar("runoutflow", NHRU, "HRU overland outflow", "(mm*km^2/int)", &runoutflow); - declstatdiag("runcumoutflow", NHRU, "cumulative HRU outflow", "(mm*km^2)", &runcumoutflow); + declstatdiag("runcumoutflow", NHRU, "cumulative HRU overland outflow", "(mm*km^2)", &runcumoutflow); declstatdiag("cumscaling_boost", NHRU, "cumulative amout inflow boosted", "(mm*km^2)", &cumscaling_boost); @@ -11348,11 +11348,11 @@ void ClassNetroute_D::decl(void) { declstatdiag("cumbasingw", BASIN, "cumulative basin groundwater outflow", "(m^3)", &cumbasingw); - decllocal("soil_ssr_Buf", NHRU, "buffer subsurface runoff", "(mm/d)", &soil_ssr_Buf); + decllocal("soil_ssr_Buf", NHRU, "buffer subsurface runoff from soil, i.e. soil_ssr_Buf is from soil_ssr", "(mm/int)", &soil_ssr_Buf); - decllocal("soil_runoff_Buf", NHRU, "buffer rain runoff", "(mm/d)", &soil_runoff_Buf); + decllocal("soil_runoff_Buf", NHRU, "buffer overland runoff from soil, i.e. soil_runoff_Buf is from soil_runoff", "(mm/int)", &soil_runoff_Buf); - decllocal("soil_gw_Buf", NHRU, "buffer rain runoff", "(mm/d)", &soil_gw_Buf); + decllocal("soil_gw_Buf", NHRU, "buffer soil_gw(gw_flow) from soil, i.e. soil_gw_Buf is from gw_flow = soil_gw", "(mm/int)", &soil_gw_Buf); decllocal("distrib_sum", NHRU, "HRU distribution sum", "()", &distrib_sum); @@ -11841,7 +11841,7 @@ void ClassNetroute_M_D::decl(void) { decldiag("outflow_diverted", NHRU, "HRU outflow diverted to another HRU", "(mm*km^2/int)", &outflow_diverted); - declstatdiag("cumoutflow_diverted", NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2/int)", &cumoutflow_diverted); + declstatdiag("cumoutflow_diverted", NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2)", &cumoutflow_diverted); declstatdiag("cum_to_Sd", NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm)", &cum_to_Sd); @@ -11857,15 +11857,15 @@ void ClassNetroute_M_D::decl(void) { decldiag("gwoutflow_diverted", NHRU, "HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwoutflow_diverted); - declstatdiag("gwcumoutflow_diverted", NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwcumoutflow_diverted); + declstatdiag("gwcumoutflow_diverted", NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2)", &gwcumoutflow_diverted); - declvar("ssrinflow", NHRU, "inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); + declvar("ssrinflow", NHRU, "subsurface inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); - declstatdiag("ssrcuminflow", NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); + declstatdiag("ssrcuminflow", NHRU, "cumulative subsurface inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); - declvar("ssroutflow", NHRU, "HRU outflow", "(mm*km^2/int)", &ssroutflow); + declvar("ssroutflow", NHRU, "HRU subsurface outflow", "(mm*km^2/int)", &ssroutflow); - declstatdiag("ssrcumoutflow", NHRU, "cumulative HRU outflow", "(mm*km^2)", &ssrcumoutflow); + declstatdiag("ssrcumoutflow", NHRU, "cumulative HRU subsurface outflow", "(mm*km^2)", &ssrcumoutflow); declstatdiag("HRU_cumbasinflow", NHRU, "cumulative HRU to basinflow", "(mm*km^2)", &HRU_cumbasinflow); @@ -11873,13 +11873,13 @@ void ClassNetroute_M_D::decl(void) { declparam("preferential_flow", NHRU, "[0]", "0", "1","0 - no preferential and remain as runoff routing to other HRU, 1 - preferential flow and route runoff to other HRU's gw.", "()", &preferential_flow); - declvar("runinflow", NHRU, "inflow from other HRUs", "(mm*km^2/int)", &runinflow); + declvar("runinflow", NHRU, "overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2/int)", &runinflow); - declstatdiag("runcuminflow", NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &runcuminflow); + declstatdiag("runcuminflow", NHRU, "cumulative overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2)", &runcuminflow); - declvar("runoutflow", NHRU, "HRU outflow", "(mm*km^2/int)", &runoutflow); + declvar("runoutflow", NHRU, "HRU overland outflow", "(mm*km^2/int)", &runoutflow); - declstatdiag("runcumoutflow", NHRU, "cumulative HRU outflow", "(mm*km^2)", &runcumoutflow); + declstatdiag("runcumoutflow", NHRU, "cumulative HRU overland outflow", "(mm*km^2)", &runcumoutflow); declstatdiag("cumscaling_boost", NHRU, "cumulative amout inflow boosted", "(mm*km^2)", &cumscaling_boost); @@ -11895,13 +11895,13 @@ void ClassNetroute_M_D::decl(void) { declstatdiag("cumbasingw", BASIN, "cumulative basin groundwater outflow", "(m^3)", &cumbasingw); - decllocal("soil_ssr_Buf", NHRU, "buffer subsurface runoff", "(mm/d)", &soil_ssr_Buf); + decllocal("soil_ssr_Buf", NHRU, "buffer subsurface runoff from soil, i.e. soil_ssr_Buf is from soil_ssr", "(mm/int)", &soil_ssr_Buf); - decllocal("soil_runoff_Buf", NHRU, "buffer rain runoff", "(mm/d)", &soil_runoff_Buf); + decllocal("soil_runoff_Buf", NHRU, "buffer overland runoff from soil, i.e. soil_runoff_Buf is from soil_runoff", "(mm/int)", &soil_runoff_Buf); - decllocal("soil_gw_Buf", NHRU, "buffer rain runoff", "(mm/d)", &soil_gw_Buf); + decllocal("soil_gw_Buf", NHRU, "buffer soil_gw(gw_flow) from soil, i.e. soil_gw_Buf is from gw_flow = soil_gw", "(mm/int)", &soil_gw_Buf); - decllocal("Ktravel", NHRU, "travel time", "(d)", &Ktravel); + decllocal("Ktravel", NHRU, "travel time from Muskingum method", "(d)", &Ktravel); decllocal("distrib_sum", NHRU, "HRU distribution sum", "()", &distrib_sum); @@ -12546,11 +12546,11 @@ void ClassVolumetric::decl(void) { Description = "'Converts soil moisture to volumetric equivalent and determines fall status.'"; - declvar("Volumetric", NHRU, "volumetric soil moisture", "()", &Volumetric); + declvar("Volumetric", NHRU, "fractional volumetric soil moisture", "()", &Volumetric); - declvar("Volumetric_rechr", NHRU, "volumetric soil moisture in soil recharge zone", "()", &Volumetric_rechr); // 04/14/2020: adding option for updating Si or fallstat based on Volumetric moisture content in recharge layer + declvar("Volumetric_rechr", NHRU, "fractional volumetric soil moisture in soil recharge zone", "()", &Volumetric_rechr); // 04/14/2020: adding option for updating Si or fallstat based on Volumetric moisture content in recharge layer - declvar("fallstat_V", NHRU, "fallstat_V copy of parameter fallstat", "()", &fallstat_V); + declvar("fallstat_V", NHRU, "fallstat_V copy of parameter fallstat", "(%)", &fallstat_V); declvar("Si_V", NHRU, "Si_V copy of parameter Si", "()", &Si_V); @@ -12571,6 +12571,8 @@ void ClassVolumetric::decl(void) { declparam("Si_correction", NHRU, "[0.0]", "0.0", "1.0", "Si correction number", "()", &Si_correction); + declparam("fallstat_correction", NHRU, "[1.0]", "0.0", "10.0", "fallstat correction factor", "()", &fallstat_correction); // 08/11/2021 + declparam("set_fallstat", NHRU, "[305]", "0","366", "set fallstat on this Julian date", "()", &set_fallstat); declparam("Volumetric_option", NHRU, "[1]", "0","1", "option of setting Si or fallstat: 0 - based on Volumetric moisture content in entire soil column, 1 - based on Volumetric moisture content in soil recharge layer", "()", &Volumetric_option); // 04/14/2020: @@ -12630,11 +12632,14 @@ void ClassVolumetric::run(void) { } if(fallstat[hh]){ - if(SetSoilproperties[soil_type[hh]][3] > 0.0) + if(SetSoilproperties[soil_type[hh]][3] > 0.0) { // 08/11/2021 if(Volumetric_option[hh]) // 04/14/2020 fallstat[hh] = Volumetric_rechr[hh]/SetSoilproperties[soil_type[hh]][3]*100000.0; // ie 100*1000 else fallstat[hh] = Volumetric[hh]/SetSoilproperties[soil_type[hh]][3]*100000.0; // ie 100*1000 + if(fallstat_correction[hh] >= 0.0) + fallstat[hh] = fallstat[hh]*fallstat_correction[hh]; // 08/11/2021 + } // 08/11/2021 else fallstat [hh] = 1.0; @@ -12937,17 +12942,17 @@ void ClassPrairieInfil::decl(void) { Description = "'Handles frozen soil infiltration using Granger et al. 1984; Gray et al., 1986 and Ayers, 1959 for unfrozen soil.'"; - declvar("snowinfil", NHRU, "infiltration", "(mm/d)", &snowinfil); + declvar("snowinfil", NHRU, "daily snowmelt infiltration", "(mm/d)", &snowinfil); - declstatdiag("cumsnowinfil", NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("meltrunoff", NHRU, "melt runoff", "(mm/d)", &meltrunoff); + declvar("meltrunoff", NHRU, "daily melt runoff", "(mm/d)", &meltrunoff); declstatdiag("cummeltrunoff", NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); - declvar("infil", NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", NHRU,"interval rainfall infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", NHRU, "cumulative rainfall infiltration", "(mm)", &cuminfil); declvar("runoff", NHRU, "rainfall runoff", "(mm/int)", &runoff); @@ -12967,7 +12972,7 @@ void ClassPrairieInfil::decl(void) { declparam("hru_area", NHRU, "[1]", "1e-6", "1e+09", "hru area", "(km^2)", &hru_area); declparam("fallstat", NHRU, "[50.0]", "-1.0","100.0", - "fall status 0.0 - unlimited/ 100.0 - restricted/ other - limited", "(%)", &fallstat); + "fall soil saturation status 0.0 - unlimited/ 100.0 - restricted/ other - limited", "(%)", &fallstat); declparam("Major", NHRU, "[5]", "1", "100", "threshold for major melt", "(mm/d)", &Major); @@ -12976,10 +12981,10 @@ void ClassPrairieInfil::decl(void) { decldiagparam("infDays", NHRU, "[6]", "0", "20", " maximum number of days of snowmelt infiltration to frozen soil ", "(d)", &infDays); declparam("texture", NHRU, "[1]", "1","4", - "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "(%)", &texture); + "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "()", &texture); declparam("groundcover", NHRU, "[1]", "1","6", - "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "(%)", &groundcover); + "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "()", &groundcover); declgetvar("*", "hru_tmax", "(°C)", &hru_tmax); declgetvar("*", "snowmeltD", "(mm/d)", &snowmelt); @@ -13250,7 +13255,7 @@ void ClassCRHMCanopy::decl(void) { declobs("Qnsn", NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn); - declvar("Qnsn_Var", NHRU, "net all-wave at snow surface", "(W/m^2*int)", &Qnsn_Var); + declvar("Qnsn_Var", NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn_Var); declobs("Qsisn", NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn); @@ -13262,11 +13267,11 @@ void ClassCRHMCanopy::decl(void) { decldiag("k", NHRU, "extinction coefficient", "()", &k); - decldiag("Tauc", NHRU, "short-wave transmissivity", "(W/m^2)", &Tauc); + decldiag("Tauc", NHRU, "short-wave transmissivity", "()", &Tauc); decllocal("Pa", NHRU, "Average surface pressure", "(kPa)", &Pa); - declvar("ra", NHRU, "", "(s/m)", &ra); + declvar("ra", NHRU, "resistance", "(s/m)", &ra); declvar("drip_cpy", NHRU, "canopy drip", "(mm/int)", &drip_Cpy); @@ -13274,11 +13279,11 @@ void ClassCRHMCanopy::decl(void) { declvar("net_rain", NHRU, " direct_rain + drip", "(mm/int)", &net_rain); - declstatdiag("cum_net_rain", NHRU, " direct_rain + drip", "(mm)", &cum_net_rain); + declstatdiag("cum_net_rain", NHRU, " cumulative direct_rain + drip", "(mm)", &cum_net_rain); declvar("Subl_Cpy", NHRU, "canopy snow sublimation", "(mm/int)", &Subl_Cpy); - declstatdiag("cum_Subl_Cpy", NHRU, "canopy snow sublimation", "(mm)", &cum_Subl_Cpy); + declstatdiag("cum_Subl_Cpy", NHRU, "cumulative canopy snow sublimation", "(mm)", &cum_Subl_Cpy); decldiag("Pevap", NHRU, "used when ground is snow covered to calculate canopy evaporation (Priestley-Taylor)", "(mm)", &Pevap); @@ -13286,11 +13291,11 @@ void ClassCRHMCanopy::decl(void) { declstatvar("Snow_load", NHRU, "canopy snow load (timetep start)", "(mm)", &Snow_load); - declvar("direct_snow", NHRU, "snow 'direct' Thru", "(mm/int)", &direct_snow); + declvar("direct_snow", NHRU, "snow 'direct' through canopy", "(mm/int)", &direct_snow); - declvar("SUnload", NHRU, "unloaded canopy snow", "(mm)", &SUnload); + declvar("SUnload", NHRU, "unloaded canopy snow", "(mm/int)", &SUnload); - declvar("SUnload_H2O", NHRU, "unloaded canopy snow as water", "(mm)", &SUnload_H2O); + declvar("SUnload_H2O", NHRU, "unloaded canopy snow as water", "(mm/int)", &SUnload_H2O); declstatdiag("cum_SUnload_H2O", NHRU, "Cumulative unloaded canopy snow as water", "(mm)", &cum_SUnload_H2O); @@ -13298,7 +13303,7 @@ void ClassCRHMCanopy::decl(void) { declvar("net_snow", NHRU, "hru_snow minus interception", "(mm/int)", &net_snow); - declstatdiag("cum_net_snow", NHRU, "Cumulative Canopy unload ", "(mm)", &cum_net_snow); + declstatdiag("cum_net_snow", NHRU, "Cumulative hru_snow minus interception", "(mm)", &cum_net_snow); declvar("net_p", NHRU, "total precipitation after interception", "(mm/int)", &net_p); @@ -13308,11 +13313,11 @@ void ClassCRHMCanopy::decl(void) { declvar("intcp_evap", NHRU, "HRU Evaporation from interception", "(mm/int)", &intcp_evap); - declstatdiag("cum_intcp_evap", NHRU, "HRU Evaporation from interception", "(mm)", &cum_intcp_evap); + declstatdiag("cum_intcp_evap", NHRU, "Cumulative HRU Evaporation from interception", "(mm)", &cum_intcp_evap); - declvar("Qsisn_Var", NHRU, "incident short-wave at surface", "(W/m^2*int)", &Qsisn_Var); + declvar("Qsisn_Var", NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn_Var); - declvar("Qlisn_Var", NHRU, "incident long-wave at surface", "(W/m^2*int)", &Qlisn_Var); + declvar("Qlisn_Var", NHRU, "incident long-wave at surface", "(W/m^2)", &Qlisn_Var); // parameters: @@ -13344,9 +13349,9 @@ void ClassCRHMCanopy::decl(void) { declparam("unload_t_water", NHRU, "[4.0]", "-10.0", "20.0", "if ice-bulb temp >= t: canopy snow is unloaded as water", "(°C)", &unload_t_water); - decldiagparam("Alpha_c", NHRU, "[0.1]", "0.05", "0.2", "canopy albedo", "()", &Alpha_c); + decldiagparam("Alpha_c", NHRU, "[0.1]", "0.05", "0.2", "canopy albedo, used for longwave-radiation enhancement estimation", "()", &Alpha_c); - decldiagparam("B_canopy", NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); + decldiagparam("B_canopy", NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter for longwave-radiation. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); } void ClassCRHMCanopy::init(void) { @@ -13552,7 +13557,7 @@ void ClassCRHMCanopy::run(void) { C1 = 1.0/(D*SvDens*Nu); Alpha = 5.0; - Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); + Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius; // 18Mar2022: remove Gamma Distribution Correction term, *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); // sublimation rate of single 'ideal' ice sphere: @@ -13588,8 +13593,8 @@ void ClassCRHMCanopy::run(void) { float IceBulbT = hru_t[hh] - (Vi* Hs/1e6/ci); float Six_Hour_Divisor = Global::Freq/4.0; // used to unload over 6 hours - const float c = 0.678/(24*7*24/Global::Freq); // weekly dimensionless unloading coefficient -> to CRHM time interval - + const float U = -1*log(0.678)/(24*7*Global::Freq/24); // weekly dimensionless unloading coefficient -> to CRHM time interval + // 21Mar2022 correction: invert the term 24/Global::Freq, use unloading rate coefficient U = -log(c)/t for snow unloading determined by inverse function of c = e^(-Ut) = 0.678 based on Eq. 14 in Hedstrom and Pomeroy (1998) // determine whether canopy snow is unloaded: if(IceBulbT >= unload_t_water[hh]){ @@ -13604,7 +13609,7 @@ void ClassCRHMCanopy::run(void) { cum_SUnload[hh] += SUnload[hh]; } else if(IceBulbT < unload_t[hh]){ // has to be at least one interval. Trip on half step - SUnload[hh] = Snow_load[hh]*c; // the dimensionless unloading coefficient already /interval + SUnload[hh] = Snow_load[hh]*U; // the dimensionless unloading coefficient already /interval, 21Mar2022 correction: use unloading rate coefficient U if(SUnload[hh] > Snow_load[hh]){ SUnload[hh] = Snow_load[hh]; Snow_load[hh] = 0.0; @@ -14275,21 +14280,21 @@ void ClassAyers::decl(void) { Description = "'Uses Ayers, 1959 for unfrozen soil. Snow is assumed to melt immediately on contact with the ground.'"; - declvar("infil", NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", NHRU,"interval rainfall infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", NHRU, "cumulative rainfall infiltration", "(mm)", &cuminfil); - declvar("runoff", NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - declvar("snowinfil", NHRU, "infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", NHRU, "interval snowmelt infiltration", "(mm/int)", &snowinfil); - declstatdiag("cumsnowinfil", NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("meltrunoff", NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", NHRU, "interval snowmelt runoff", "(mm/int)", &meltrunoff); - declstatdiag("cummeltrunoff", NHRU, "melt runoff", "(mm)", &cummeltrunoff); + declstatdiag("cummeltrunoff", NHRU, "cumulative snowmelt runoff", "(mm)", &cummeltrunoff); decllocal("melt_int", NHRU, "interval melt from snowmelD", "(mm/int)", &melt_int); @@ -14298,10 +14303,10 @@ void ClassAyers::decl(void) { declparam("hru_area", NHRU, "[1]", "1e-6", "1e+09", "hru area", "(km^2)", &hru_area); declparam("texture", NHRU, "[1]", "1","4", - "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "(%)", &texture); + "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "()", &texture); declparam("groundcover", NHRU, "[1]", "1","6", - "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "(%)", &groundcover); + "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "()", &groundcover); declgetvar("*", "net_rain", "(mm/int)", &net_rain); @@ -14530,29 +14535,29 @@ void ClassfrozenAyers::decl(void) { Description = "'Frozen soil infiltration Zhao and Gray (1999) and Ayers, (1959) for unfrozen soil.'"; - declvar("infil", NHRU, "Potential rain infiltration", "(mm/int)", &infil); + declvar("infil", NHRU, "interval rain infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", NHRU, "cumulative potential rain infiltration", "(mm)", &cuminfil); + declstatdiag("cuminfil", NHRU, "cumulative rain infiltration", "(mm)", &cuminfil); - declvar("snowinfil", NHRU, "melt infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", NHRU, "interval snowmelt infiltration", "(mm/int)", &snowinfil); - declstatvar("cumsnowinfil", NHRU, "cumulative melt infiltration", "(mm)", &cumsnowinfil); // for looping + declstatvar("cumsnowinfil", NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); // for looping - declvar("cumsnowinfil_0", NHRU, "cumulative melt infiltration at beginning of frozen cycle", "(mm)", &cumsnowinfil_0); // for looping + declvar("cumsnowinfil_0", NHRU, "cumulative snowmelt infiltration at beginning of frozen cycle", "(mm)", &cumsnowinfil_0); // for looping - declvar("meltrunoff", NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", NHRU, "interval snowmelt runoff", "(mm/int)", &meltrunoff); - declstatdiag("cummeltrunoff", NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); + declstatdiag("cummeltrunoff", NHRU, "cumulative snowmelt runoff", "(mm)", &cummeltrunoff); - declvar("runoff", NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - decllocal("t0_Var", NHRU, "t0 value used by module", "(h)", &t0_Var); + decllocal("t0_Var", NHRU, "value of infiltration opportunity time", "(h)", &t0_Var); - decllocal("t0_Acc", NHRU, "opportunity time", "(h)", &t0_Acc); // to reset every loop + decllocal("t0_Acc", NHRU, "infiltration opportunity time accumulator", "(h)", &t0_Acc); // to reset every loop - decllocal("INF", NHRU, "parametric calculation", "(mm)", &INF); + decllocal("INF", NHRU, "infiltration into a frozen soil calculated from parametric relationship", "(mm)", &INF); decllocal("Julian_window", ONE, "currently in Julian window handling frozen infiltration.", "()", &Julian_window); @@ -14587,10 +14592,10 @@ void ClassfrozenAyers::decl(void) { "(mm)", &soil_moist_max); declparam("texture", NHRU, "[1]", "1","4", - "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "(%)", &texture); + "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "()", &texture); declparam("groundcover", NHRU, "[1]", "1","6", - "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "(%)", &groundcover); + "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "()", &groundcover); decldiagparam("t0_Julian", ONE, "[30]", "0","366", "value > 0 - inhibit frozen algorithm till after this Julian date, 0 - enable frozen algorithm immediately when melt criteria is met", "()", &t0_Julian); @@ -15521,29 +15526,29 @@ void ClassSoil::decl(void) { declvar("infil_act_D", NHRU, "Daily actual amount of water infiltrating the soil on each HRU.", "(mm/d)", &infil_act_D); - declstatdiag("cum_gw_flow", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_gw_flow); + declstatdiag("cum_gw_flow", NHRU, "cumulative groundwater flow from HRU groundwater reservoirs.", "(mm)", &cum_gw_flow); - declvar("soil_ssr", NHRU, "Portion of soil moisture and recharge excess from a HRU that enters subsurface reservoirs.", "(mm/int)", &soil_ssr); + declvar("soil_ssr", NHRU, "subsurface runoff from soil layers and depressional storage.", "(mm/int)", &soil_ssr); - declvar("rechr_ssr", NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/int)", &rechr_ssr); + declvar("rechr_ssr", NHRU, "subsurface runoff from soil recharge layer.", "(mm/int)", &rechr_ssr); - declstatdiag("cum_soil_ssr", NHRU, "Accumulation of soil moisture from a HRU to ssr.", "(mm)", &cum_soil_ssr); + declstatdiag("cum_soil_ssr", NHRU, "cumulative subsurface runoff from layers and depressional storage.", "(mm)", &cum_soil_ssr); - declstatdiag("cum_rechr_ssr", NHRU, "Accumulation of Portion of excess from a HRU to ssr.", "(mm)", &cum_rechr_ssr); + declstatdiag("cum_rechr_ssr", NHRU, "cumulative subsurface runoff from soil recharge layer.", "(mm)", &cum_rechr_ssr); - declvar("soil_ssr_D", NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/d)", &soil_ssr_D); + declvar("soil_ssr_D", NHRU, "daily accumulation of soil_ssr.", "(mm/d)", &soil_ssr_D); declvar("soil_runoff", NHRU, "Portion of excess soil water from a HRU to runoff.", "(mm/int)", &soil_runoff); declstatdiag("cum_soil_runoff", NHRU, "Accumulation of Portion of excess soil water from a HRU to runoff.", "(mm)", &cum_soil_runoff); - declvar("soil_runoff_D", NHRU, "Portion of excess soil water from a HRU that enters groundwater reservoirs.", "(mm/d)", &soil_runoff_D); + declvar("soil_runoff_D", NHRU, "daily accumulation of soil_runoff.", "(mm/d)", &soil_runoff_D); - declstatdiag("cum_runoff_to_Sd", NHRU, "Cumulative portion of runoff to depression storage.", "(mm/int)", &cum_runoff_to_Sd); + declstatdiag("cum_runoff_to_Sd", NHRU, "Cumulative portion of runoff to depression storage.", "(mm)", &cum_runoff_to_Sd); declstatdiag("cum_soil_gw", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_soil_gw); - declstatdiag("cum_Sd_gw", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_Sd_gw); + declstatdiag("cum_Sd_gw", NHRU, "cumulative excess from Sd that enters groundwater reservoirs.", "(mm)", &cum_Sd_gw); decllocal("snowinfil_buf", NHRU, "buffer snow infiltration.", "(mm/d)", &snowinfil_buf); @@ -15552,7 +15557,7 @@ void ClassSoil::decl(void) { decllocal("meltrunoff_buf", NHRU, "buffer melt runoff.", "(mm/d)", &meltrunoff_buf); - decllocal("hru_evap_buf", NHRU, "buffer evaporation.", "(mm/d)", &hru_evap_buf); + decllocal("hru_evap_buf", NHRU, "buffer evaporation.", "(mm/int)", &hru_evap_buf); decllocal("soil_moist_Init", NHRU, "initial soil moisture.", "(mm)", &soil_moist_Init); @@ -15593,13 +15598,13 @@ void ClassSoil::decl(void) { declparam("gw_K", NHRU, "[0.0]", "0.", "100.0", "daily ground water drainage from gw reservoir.", "(mm/d)", &gw_K); - declparam("rechr_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge.", "(mm/d)", &rechr_ssr_K); + declparam("rechr_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge layer (soil_rechr).", "(mm/d)", &rechr_ssr_K); - declparam("lower_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from soil column.", "(mm/d)", &lower_ssr_K); + declparam("lower_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from lower soil layer (soil_moist - soil_rechr).", "(mm/d)", &lower_ssr_K); - declparam("Sd_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily depression storage ssr drainage factor.", "(mm/d)", &Sd_ssr_K); + declparam("Sd_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage factor from depression storage.", "(mm/d)", &Sd_ssr_K); - declparam("Sd_gw_K", NHRU, "[0.0]", "0.", "100.0", "daily depression storage gw drainage.", "(mm/d)", &Sd_gw_K); + declparam("Sd_gw_K", NHRU, "[0.0]", "0.", "100.0", "daily drainage factor to groundwater reservoir from depression storage.", "(mm/d)", &Sd_gw_K); declparam("soil_withdrawal", NDEFN, "[3]", "1", "4", "Select water withdrawal function for soil type: 1 = sand, 2 = loam, 3 = clay, 4 = organic. soil_withdrawal[1] - rechr layer, soil_withdrawal[2] - lower layer", "()", @@ -16479,7 +16484,7 @@ void Classevap_Resist::decl(void) { decldiagparam("F_Qg", NHRU, "[0.1]", "0.0", "1.0", "fraction to ground flux, Qg = F_Qg*Rn", "()", &F_Qg); - declparam("rcs", NHRU, "[25]", "25.0", "5000.0", "stomatal resistance", "(s/m)", &rcs); + declparam("rcs", NHRU, "[25]", "25.0", "5000.0", "minimum stomatal resistance", "(s/m)", &rcs); declparam("Htmax", NHRU, "[0.1]", "0.1", "100.0", "maximum vegetation height (Penman-Monteith)", "(m)", &Htmax); @@ -16781,7 +16786,7 @@ void ClassevapD_Resist::decl(void) { decldiagparam("F_Qg", NHRU, "[0.1]", "0.0", "1.0", "fraction to ground flux, Qg = F_Qg*Rn", "()", &F_Qg); - declparam("rcs", NHRU, "[25]", "25.0", "5000.0", "stomatal resistance (Penman-Monteith/Dalton bulk transfer)", "(s/m)", &rcs); + declparam("rcs", NHRU, "[25]", "25.0", "5000.0", "minimum stomatal resistance (Penman-Monteith/Dalton bulk transfer)", "(s/m)", &rcs); declparam("Htmax", NHRU, "[0.1]", "0.1", "100.0", "maximum vegetation height (Penman-Monteith)", "(m)", &Htmax); @@ -16994,25 +16999,25 @@ ClassShutWall* ClassShutWall::klone(string name) const{ declstatdiag("hru_cum_actet", NHRU, "cumulative actual evapotranspiration over HRU", "(mm)", &hru_cum_actet); - declvar("hru_evap", NHRU, "evaporation, interval calculation from daily", "(mm/int)", &evap); + declvar("hru_evap", NHRU, "interval evaporation", "(mm/int)", &evap); declvar("hru_evapD", NHRU, "daily evaporation", "(mm)", &evapD); - declstatdiag("hru_cum_evap", NHRU, "cumulative interval evaporation from daily", "(mm)", &cum_evap); + declstatdiag("hru_cum_evap", NHRU, "cumulative interval evaporation", "(mm)", &cum_evap); decldiag("Cc", NHRU, "canopy weighting coefficient", "()", &Cc); decldiag("Cs", NHRU, "substrate weighting coefficient", "()", &Cs); - decldiag("Ra", NHRU, "", "()", &Ra); + decldiag("Ra", NHRU, "aerodynamic resistance 'component'", "(mb/K*s/m)", &Ra); - decldiag("Rc", NHRU, "", "()", &Rc); + decldiag("Rc", NHRU, "canopy stomatal resistance 'component'", "(mb/K*s/m)", &Rc); - decldiag("Rs", NHRU, "", "()", &Rs); + decldiag("Rs", NHRU, "soil surface resistance 'component'", "(mb/K*s/m)", &Rs); - decldiag("ETc", NHRU, "", "(mm/d)", &ETc); + decldiag("ETc", NHRU, " daily evaporation from canopy", "(mm/d)", &ETc); - decldiag("ETs", NHRU, "", "(mm/d)", &ETs); + decldiag("ETs", NHRU, "daily evaporation from soil surface", "(mm/d)", &ETs); decldiag("raa", NHRU, "aerodynamic resistance from canopy to reference height", "(s/m)", &raa); @@ -17202,15 +17207,15 @@ ClassShutWallD* ClassShutWallD::klone(string name) const{ declvar("Cs", NHRU, "substrate weighting coefficient", "()", &Cs); - decldiag("Ra", NHRU, "", "()", &Ra); + decldiag("Ra", NHRU, "aerodynamic resistance 'component'", "(mb/K*s/m)", &Ra); - decldiag("Rc", NHRU, "", "()", &Rc); + decldiag("Rc", NHRU, "canopy stomatal resistance 'component'", "(mb/K*s/m)", &Rc); - decldiag("Rs", NHRU, "", "()", &Rs); + decldiag("Rs", NHRU, "soil surface resistance 'component'", "(mb/K*s/m)", &Rs); - decldiag("ETc", NHRU, "", "(mm/d)", &ETc); + decldiag("ETc", NHRU, " daily evaporation from canopy", "(mm/d)", &ETc); - decldiag("ETs", NHRU, "", "(mm/d)", &ETs); + decldiag("ETs", NHRU, "daily evaporation from soil surface", "(mm/d)", &ETs); decldiag("raa", NHRU, "aerodynamic resistance from canopy to reference height", "(s/m)", &raa); @@ -17498,15 +17503,15 @@ void Classlake::decl(void) { declvar("hru_t_Mmean", NHRU, "HRU temperature", "(°C)", &hru_t_Mmean); - declvar("hru_rh_Mmean", NHRU, "HRU rh", "()", &hru_rh_Mmean); + declvar("hru_rh_Mmean", NHRU, "HRU rh", "(%)", &hru_rh_Mmean); declvar("hru_u_Mmean", NHRU, "HRU wind speed", "(m/s)", &hru_u_Mmean); - decllocal("hru_t_acc", NHRU, "HRU t accumulated", "(°C)", &hru_t_acc); + decllocal("hru_t_acc", NHRU, "HRU t accumulated", "(°C*N)", &hru_t_acc); - decllocal("hru_rh_acc", NHRU, "HRU rh accumulated", "()", &hru_rh_acc); + decllocal("hru_rh_acc", NHRU, "HRU rh accumulated", "(%*N)", &hru_rh_acc); - decllocal("hru_u_acc", NHRU, "HRU u accumulated", "(m)", &hru_u_acc); + decllocal("hru_u_acc", NHRU, "HRU u accumulated", "(m/s*N)", &hru_u_acc); decllocal("start_open_day", NHRU, "TDate format start of open water", "()", &start_open_day); @@ -17710,11 +17715,11 @@ void ClassK_Estimate::decl(void) { declputparam("*", "gw_K", "(mm/d)", &gw_K); declvar("rechr_ssr_K_V", NHRU, "ssr drainage factor from recharge", "(mm/d)", &rechr_ssr_K_V); - declvar("lower_ssr_K_V", NHRU, "ssr drainage factor from soil column", "(mm/d)", &lower_ssr_K_V); + declvar("lower_ssr_K_V", NHRU, "ssr drainage factor from lower soil layer", "(mm/d)", &lower_ssr_K_V); declvar("Sd_ssr_K_V", NHRU, "depression storage ssr drainage factor", "(mm/d)", &Sd_ssr_K_V); declvar("Sd_gw_K_V", NHRU, "depression storage gw drainage factor", "(mm/d)", &Sd_gw_K_V); declvar("soil_gw_K_V", NHRU, "The maximum amount of the soil water excess for an HRU that is routed directly to the associated groundwater reservoir each day", "(mm/d)", &soil_gw_K_V); - declvar("gw_K_V", NHRU, "ground water drainage factor from gw reservoir each day", "(m/s)", &gw_K_V); + declvar("gw_K_V", NHRU, "ground water drainage factor from gw reservoir each day", "(mm/d)", &gw_K_V); declparam("Inhibit_K_set", NHRU, "[0]", "0", "63", "Inhibit setting of rechr_ssr_K/lower_ssr_K/Sd_ssr_K/Sd_gw_K/soil_gw_K/gw_K parameters using 1/2/4/8/16/32", "()", &Inhibit_K_set); @@ -17928,7 +17933,7 @@ void ClassevapX::decl(void) { declparam("Zwind", NHRU, "[10]", "0.01", "100.0", "wind measurement height (used by Penman-Monteith).", "(m)", &Zwind); - declparam("rcs", NHRU, "[25]", "25.0", "5000.0", "stomatal resistance (used by Penman-Monteith).", "(s/m)", &rcs); + declparam("rcs", NHRU, "[25]", "25.0", "5000.0", "minimum stomatal resistance (used by Penman-Monteith).", "(s/m)", &rcs); declparam("Htmax", NHRU, "[0.1]", "0.1", "100.0", "maximum vegetation height (used by Penman-Monteith).", "(m)", &Htmax); @@ -18403,25 +18408,25 @@ void ClassSoilPrairie::decl(void) { declvar("infil_act_D", NHRU, "Daily actual amount of water infiltrating the soil on each HRU.", "(mm/d)", &infil_act_D); - declstatdiag("cum_gw_flow", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_gw_flow); + declstatdiag("cum_gw_flow", NHRU, "cumulative groundwater flow from HRU groundwater reservoirs.", "(mm)", &cum_gw_flow); - declvar("soil_ssr", NHRU, "Portion of soil moisture and recharge excess from a HRU that enters subsurface reservoirs.", "(mm/int)", &soil_ssr); + declvar("soil_ssr", NHRU, "subsurface runoff from soil layers and depressional storage.", "(mm/int)", &soil_ssr); - declvar("rechr_ssr", NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/int)", &rechr_ssr); + declvar("rechr_ssr", NHRU, "subsurface runoff from soil recharge layer.", "(mm/int)", &rechr_ssr); - declstatdiag("cum_soil_ssr", NHRU, "Accumulation of soil moisture from a HRU to ssr.", "(mm)", &cum_soil_ssr); + declstatdiag("cum_soil_ssr", NHRU, "cumulative subsurface runoff from layers and depressional storage.", "(mm)", &cum_soil_ssr); - declstatdiag("cum_rechr_ssr", NHRU, "Accumulation of Portion of excess from a HRU to ssr.", "(mm)", &cum_rechr_ssr); + declstatdiag("cum_rechr_ssr", NHRU, "cumulative subsurface runoff from soil recharge layer.", "(mm)", &cum_rechr_ssr); - declvar("soil_ssr_D", NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/d)", &soil_ssr_D); + declvar("soil_ssr_D", NHRU, "daily accumulation of soil_ssr.", "(mm/d)", &soil_ssr_D); declvar("soil_runoff", NHRU, "Portion of excess soil water from a HRU to runoff.", "(mm/int)", &soil_runoff); declstatdiag("cum_soil_runoff", NHRU, "Accumulation of Portion of excess soil water from a HRU to runoff.", "(mm)", &cum_soil_runoff); - declvar("soil_runoff_D", NHRU, "Portion of excess soil water from a HRU that enters groundwater reservoirs.", "(mm/d)", &soil_runoff_D); + declvar("soil_runoff_D", NHRU, "daily accumulation of soil_runoff.", "(mm/d)", &soil_runoff_D); - decldiag("cum_runoff_to_Sd", NHRU, "Cumulative portion of runoff to depression storage.", "(mm/int)", &cum_runoff_to_Sd); + decldiag("cum_runoff_to_Sd", NHRU, "Cumulative portion of runoff to depression storage.", "(mm)", &cum_runoff_to_Sd); decldiag("cum_soil_gw", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_soil_gw); @@ -18440,7 +18445,7 @@ void ClassSoilPrairie::decl(void) { decllocal("meltrunoff_buf", NHRU, "buffer melt runoff.", "(mm/d)", &meltrunoff_buf); - decllocal("hru_evap_buf", NHRU, "buffer evaporation.", "(mm/d)", &hru_evap_buf); + decllocal("hru_evap_buf", NHRU, "buffer evaporation.", "(mm/int)", &hru_evap_buf); decllocal("hru_evap_PT_buf", NHRU, "Priestley-Taylor buffer evaporation", "(mm/d)", &hru_evap_PT_buf); @@ -18483,13 +18488,13 @@ void ClassSoilPrairie::decl(void) { declparam("gw_K", NHRU, "[0.0]", "0.", "100.0", "daily ground water drainage from gw reservoir.", "(mm/d)", &gw_K); - declparam("rechr_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge.", "(mm/d)", &rechr_ssr_K); + declparam("rechr_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge layer (soil_rechr).", "(mm/d)", &rechr_ssr_K); - declparam("lower_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from soil column.", "(mm/d)", &lower_ssr_K); + declparam("lower_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from lower soil layer (soil_moist - soil_rechr).", "(mm/d)", &lower_ssr_K); - declparam("Sd_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily depression storage ssr drainage factor.", "(mm/d)", &Sd_ssr_K); + declparam("Sd_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage factor from depression storage.", "(mm/d)", &Sd_ssr_K); - declparam("Sd_gw_K", NHRU, "[0.0]", "0.", "100.0", "daily depression storage gw drainage.", "(mm/d)", &Sd_gw_K); + declparam("Sd_gw_K", NHRU, "[0.0]", "0.", "100.0", "daily drainage factor to groundwater reservoir from depression storage.", "(mm/d)", &Sd_gw_K); declparam("Sd_water_frac_max", NHRU, "[0.24]", "0.0", "1.0", "Maximum fraction of the HRU area that can be water.", "()", &Sd_water_frac_max); @@ -19744,13 +19749,13 @@ void ClassREWroute::decl(void) { gwCnt = declgrpvar("WS_ALL_gwflow", "basingw", "query variable = 'basingw'", "(m^3/int)", &gwrew, &gw_All); - declvar("WS_gwinflow", NHRU, "inflow from each RB", "(m^3/int)", &gwinflow); + declvar("WS_gwinflow", NHRU, "gwinflow from each RB", "(m^3/int)", &gwinflow); - declstatdiag("cum_WSgwinflow", NHRU, "cumulative inflow from each RB", "(m^3)", &cumgwinflow); + declstatdiag("cum_WSgwinflow", NHRU, "cumulative gwinflow from each RB", "(m^3)", &cumgwinflow); - declvar("WS_gwoutflow", NHRU, "outflow of each RB", "(m^3/int)", &gwoutflow); + declvar("WS_gwoutflow", NHRU, "gwoutflow of each RB", "(m^3/int)", &gwoutflow); - declstatdiag("cum_WSgwoutflow", NHRU, "cumulative outflow of each RB", "(m^3)", &cumgwoutflow); + declstatdiag("cum_WSgwoutflow", NHRU, "cumulative gwoutflow of each RB", "(m^3)", &cumgwoutflow); declvar("WS_gwflow", BASIN, "watershed ground water outflow", "(m^3/int)", &gwflow); @@ -19759,29 +19764,29 @@ void ClassREWroute::decl(void) { declstatdiag("cum_WSgwflow", BASIN, "cumulative watershed ground water outflow", "(m^3)", &cumgwflow); - declparam("WS_Lag", NHRU, "[0.0]", "0.0","1.0E4.0", "lag delay", "(h)", &WS_Lag); + declparam("WS_Lag", NHRU, "[0.0]", "0.0","1.0E4.0", "inflow lag delay", "(h)", &WS_Lag); - declparam("WS_gwLag", NHRU, "[0.0]", "0.0","1.0E4.0", "lag delay", "(h)", &WS_gwLag); + declparam("WS_gwLag", NHRU, "[0.0]", "0.0","1.0E4.0", "gwinflow lag delay", "(h)", &WS_gwLag); declparam("WS_whereto", NHRU, "[0]", "0", "1000", "0 - watershed outflow, or RB input", "()", &WS_whereto); - declparam("WS_order", NHRU, "1,2,3,4,5!", "1","1000", "RB routing process order", "()", &WS_order); + declparam("WS_order", NHRU, "1,2,3,4,5!", "1","1000", "RB outflow routing process order", "()", &WS_order); - declparam("WS_gwwhereto", NHRU, "[0]", "0", "1000", "0 - watershed outflow, or RB input", "()", &WS_gwwhereto); + declparam("WS_gwwhereto", NHRU, "[0]", "0", "1000", "0 - watershed gwoutflow, or RB input", "()", &WS_gwwhereto); - declparam("WS_gworder", NHRU, "1,2,3,4,5!", "1","1000", "RB routing process order", "()", &WS_gworder); + declparam("WS_gworder", NHRU, "1,2,3,4,5!", "1","1000", "RB gwoutflow routing process order", "()", &WS_gworder); variation_set = VARIATION_0; - decldiag("WS_Ktravel_var", NHRU, "inflow storage constant", "(d)", &WS_Ktravel_var); + decldiag("WS_Ktravel_var", NHRU, "inflow storage constant (Muskingum method)", "(d)", &WS_Ktravel_var); - decldiag("WS_gwKtravel_var", NHRU, "gw storage constant", "(d)", &WS_gwKtravel_var); + decldiag("WS_gwKtravel_var", NHRU, "gwinflow storage constant (Muskingum method)", "(d)", &WS_gwKtravel_var); declparam("WS_route_n", NHRU, "[0.025]", "0.016","0.2", "Manning roughness coefficient", "()", &WS_route_n); - declparam("WS_route_R", NHRU, "[0.5]", "0.01","1.0E4", "hydraulic radius", "()", &WS_route_R); + declparam("WS_route_R", NHRU, "[0.5]", "0.01","1.0E4", "hydraulic radius", "(m)", &WS_route_R); declparam("WS_route_S0", NHRU, "[1e-3]", "1e-6","1.0", "longitudinal channel slope", "()", &WS_route_S0); @@ -19796,9 +19801,9 @@ void ClassREWroute::decl(void) { variation_set = VARIATION_1; - declparam("WS_Kstorage", NHRU, "[0.0]", "0.0","200.0", "Clark storage constant", "(d)", &WS_Kstorage); + declparam("WS_Kstorage", NHRU, "[0.0]", "0.0","200.0", "inflow storage constant for RB (Clark method)", "(d)", &WS_Kstorage); - declparam("WS_gwKstorage", NHRU, "[0.0]", "0.0","200.0", "Clark storage constant", "(d)", &WS_gwKstorage); + declparam("WS_gwKstorage", NHRU, "[0.0]", "0.0","200.0", "gwinflow storage constant for RB (Clark method)", "(d)", &WS_gwKstorage); variation_set = VARIATION_ORG; @@ -20030,17 +20035,17 @@ void ClassXG::decl(void) { declvar("pt", NDEFN, "thawing ratios", "()", &pt, &pt_lay, Global::nlay); - declstatvar("ttc", NDEFN, "thawing thermal conductivity", "(W/(m*K)", &ttc, &ttc_lay, Global::nlay); + declstatvar("ttc", NDEFN, "thawing thermal conductivity", "(W/(m*K))", &ttc, &ttc_lay, Global::nlay); - declstatvar("ftc", NDEFN, "freezing thermal conductivity", "(W/(m*K)", &ftc, &ftc_lay, Global::nlay); + declstatvar("ftc", NDEFN, "freezing thermal conductivity", "(W/(m*K))", &ftc, &ftc_lay, Global::nlay); declstatvar("ttc_contents", NDEFN, "thawing 0/1 thaw/freeze", "()", &ttc_contents, &ttc_contents_lay, Global::nlay); declstatvar("ftc_contents", NDEFN, "freezing 0/1 freeze/thaw", "()", &ftc_contents, &ftc_contents_lay, Global::nlay); - declvar("tc_composite", NDEFN, "freeze/thaw composite ftc/ttc value", "(W/(m*K)", &tc_composite, &tc_composite_lay, Global::nlay); + declvar("tc_composite", NDEFN, "freeze/thaw composite ftc/ttc value", "(W/(m*K))", &tc_composite, &tc_composite_lay, Global::nlay); - declvar("tc_composite2", NDEFN, "freeze/thaw composite2 ftc/ttc value", "(W/(m*K)", &tc_composite2, &tc_composite2_lay, Global::nlay); + declvar("tc_composite2", NDEFN, "freeze/thaw composite2 ftc/ttc value", "(W/(m*K))", &tc_composite2, &tc_composite2_lay, Global::nlay); declvar("layer_h2o", NDEFN, "water content", "(kg/m^3)", &layer_h2o, &h2o_lay, Global::nlay); @@ -20087,13 +20092,13 @@ void ClassXG::decl(void) { declparam("theta_min", NHRU, "[0.001]", "0.0001", "0.1", "minimum value of theta to prevent divide by zero errors)", "(m^3/m^3)", &theta_min); - declparam("soil_solid_km", NDEFN, "[2.5]", "0.03", "4", "dry soil thermal conductivity", "(W/(m*K)", &soil_solid_km, &soil_solid_km_lay, Global::nlay); + declparam("soil_solid_km", NDEFN, "[2.5]", "0.03", "4", "dry soil thermal conductivity", "(W/(m*K))", &soil_solid_km, &soil_solid_km_lay, Global::nlay); - declparam("soil_solid_km_ki", NDEFN, "[2.5]", "0.03", "4", "saturated frozen soil thermal conductivity", "(W/(m*K)", &soil_solid_km_ki, &soil_solid_km_ki_lay, Global::nlay); + declparam("soil_solid_km_ki", NDEFN, "[2.5]", "0.03", "4", "saturated frozen soil thermal conductivity", "(W/(m*K))", &soil_solid_km_ki, &soil_solid_km_ki_lay, Global::nlay); - declparam("soil_solid_km_kw", NDEFN, "[2.5]", "0.03", "4", "saturated unfrozen soil thermal conductivity.", "(W/(m*K)", &soil_solid_km_kw, &soil_solid_km_kw_lay, Global::nlay); + declparam("soil_solid_km_kw", NDEFN, "[2.5]", "0.03", "4", "saturated unfrozen soil thermal conductivity.", "(W/(m*K))", &soil_solid_km_kw, &soil_solid_km_kw_lay, Global::nlay); - declparam("SWE_k", NHRU, "[0.35]", "0.1", "1.0", "thermal conductivity of blowing snow.", "(W/(m*K)", &SWE_k); + declparam("SWE_k", NHRU, "[0.35]", "0.1", "1.0", "thermal conductivity of snow.", "(W/(m*K))", &SWE_k); declparam("Zdf_init", NHRU, "[0]", "0.0", "3", "initial depth of freezing front. Maximum value limited by freezing algorithm.", "(m)", &Zdf_init); @@ -21052,25 +21057,25 @@ void ClassSoilX::decl(void) { declvar("infil_act_D", NHRU, "Daily actual amount of water infiltrating the soil on each HRU.", "(mm/d)", &infil_act_D); - declstatdiag("cum_gw_flow", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_gw_flow); + declstatdiag("cum_gw_flow", NHRU, "cumulative groundwater flow from HRU groundwater reservoirs.", "(mm)", &cum_gw_flow); - declvar("soil_ssr", NHRU, "Portion of soil moisture and recharge excess from a HRU that enters subsurface reservoirs.", "(mm/int)", &soil_ssr); + declvar("soil_ssr", NHRU, "subsurface runoff from soil layers and depressional storage.", "(mm/int)", &soil_ssr); - declvar("rechr_ssr", NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/int)", &rechr_ssr); + declvar("rechr_ssr", NHRU, "subsurface runoff from soil recharge layer.", "(mm/int)", &rechr_ssr); - declstatdiag("cum_soil_ssr", NHRU, "Accumulation of soil moisture from a HRU to ssr.", "(mm)", &cum_soil_ssr); + declstatdiag("cum_soil_ssr", NHRU, "cumulative subsurface runoff from layers and depressional storage.", "(mm)", &cum_soil_ssr); - declstatdiag("cum_rechr_ssr", NHRU, "Accumulation of Portion of excess from a HRU to ssr.", "(mm)", &cum_rechr_ssr); + declstatdiag("cum_rechr_ssr", NHRU, "cumulative subsurface runoff from soil recharge layer.", "(mm)", &cum_rechr_ssr); - declvar("soil_ssr_D", NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/d)", &soil_ssr_D); + declvar("soil_ssr_D", NHRU, "daily accumulation of soil_ssr.", "(mm/d)", &soil_ssr_D); declvar("soil_runoff", NHRU, "Portion of excess soil water from a HRU to runoff.", "(mm/int)", &soil_runoff); declstatdiag("cum_soil_runoff", NHRU, "Accumulation of Portion of excess soil water from a HRU to runoff.", "(mm)", &cum_soil_runoff); - declvar("soil_runoff_D", NHRU, "Portion of excess soil water from a HRU that enters groundwater reservoirs.", "(mm/d)", &soil_runoff_D); + declvar("soil_runoff_D", NHRU, "daily accumulation of soil_runoff.", "(mm/d)", &soil_runoff_D); - declstatdiag("cum_runoff_to_Sd", NHRU, "Cumulative portion of runoff to depression storage.", "(mm/int)", &cum_runoff_to_Sd); + declstatdiag("cum_runoff_to_Sd", NHRU, "Cumulative portion of runoff to depression storage.", "(mm)", &cum_runoff_to_Sd); declstatdiag("cum_soil_gw", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_soil_gw); @@ -21081,7 +21086,7 @@ void ClassSoilX::decl(void) { decllocal("meltrunoff_buf", NHRU, "buffer melt runoff.", "(mm/d)", &meltrunoff_buf); - decllocal("hru_evap_buf", NHRU, "buffer evaporation.", "(mm/d)", &hru_evap_buf); + decllocal("hru_evap_buf", NHRU, "buffer evaporation.", "(mm/int)", &hru_evap_buf); decllocal("soil_moist_Init", NHRU, "initial soil moisture.", "(mm)", &soil_moist_Init); @@ -21124,11 +21129,11 @@ void ClassSoilX::decl(void) { declparam("rechr_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge. Modified by thaw_upper.", "(mm/d)", &rechr_ssr_K); - declparam("lower_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from soil column. Modified by thaw_lower.", "(mm/d)", &lower_ssr_K); + declparam("lower_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from lower soil layer (soil_moist - soil_rechr). Modified by thaw_lower.", "(mm/d)", &lower_ssr_K); - declparam("Sd_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily depression storage ssr drainage factor. Modified by thaw_all.", "(mm/d)", &Sd_ssr_K); + declparam("Sd_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage factor from depression storage. Modified by thaw_all.", "(mm/d)", &Sd_ssr_K); - declparam("Sd_gw_K", NHRU, "[0.0]", "0.", "100.0", "daily depression storage gw drainage.", "(mm/d)", &Sd_gw_K); + declparam("Sd_gw_K", NHRU, "[0.0]", "0.", "100.0", "daily drainage factor to groundwater reservoir from depression storage.", "(mm/d)", &Sd_gw_K); declparam("soil_withdrawal", NDEFN, "[3]", "1", "4", "Select water withdrawal function for soil type: 1 = sand, 2 = loam, 3 = clay, 4 = organic. soil_withdrawal[1] - rechr layer, soil_withdrawal[2] - lower layer", "()", @@ -22261,25 +22266,25 @@ void ClassSoilDS::decl(void) { declvar("infil_act_D", NHRU, "Daily actual amount of water infiltrating the soil on each HRU.", "(mm/d)", &infil_act_D); - declstatdiag("cum_gw_flow", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_gw_flow); + declstatdiag("cum_gw_flow", NHRU, "cumulative groundwater flow from HRU groundwater reservoirs.", "(mm)", &cum_gw_flow); - declvar("soil_ssr", NHRU, "Portion of soil moisture and recharge excess from a HRU that enters subsurface reservoirs.", "(mm/int)", &soil_ssr); + declvar("soil_ssr", NHRU, "subsurface runoff from soil layers and depressional storage.", "(mm/int)", &soil_ssr); - declvar("rechr_ssr", NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/int)", &rechr_ssr); + declvar("rechr_ssr", NHRU, "subsurface runoff from soil recharge layer.", "(mm/int)", &rechr_ssr); - declstatdiag("cum_soil_ssr", NHRU, "Accumulation of soil moisture from a HRU to ssr.", "(mm)", &cum_soil_ssr); + declstatdiag("cum_soil_ssr", NHRU, "cumulative subsurface runoff from layers and depressional storage.", "(mm)", &cum_soil_ssr); - declstatdiag("cum_rechr_ssr", NHRU, "Accumulation of Portion of excess from a HRU to ssr.", "(mm)", &cum_rechr_ssr); + declstatdiag("cum_rechr_ssr", NHRU, "cumulative subsurface runoff from soil recharge layer.", "(mm)", &cum_rechr_ssr); - declvar("soil_ssr_D", NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/d)", &soil_ssr_D); + declvar("soil_ssr_D", NHRU, "daily accumulation of soil_ssr.", "(mm/d)", &soil_ssr_D); declvar("soil_runoff", NHRU, "Portion of excess soil water from a HRU to runoff.", "(mm/int)", &soil_runoff); declstatdiag("cum_soil_runoff", NHRU, "Accumulation of Portion of excess soil water from a HRU to runoff.", "(mm)", &cum_soil_runoff); - declvar("soil_runoff_D", NHRU, "Portion of excess soil water from a HRU that enters groundwater reservoirs.", "(mm/d)", &soil_runoff_D); + declvar("soil_runoff_D", NHRU, "daily accumulation of soil_runoff.", "(mm/d)", &soil_runoff_D); - declstatdiag("cum_runoff_to_Sd", NHRU, "Cumulative portion of runoff to depression storage.", "(mm/int)", &cum_runoff_to_Sd); + declstatdiag("cum_runoff_to_Sd", NHRU, "Cumulative portion of runoff to depression storage.", "(mm)", &cum_runoff_to_Sd); declstatdiag("cum_soil_gw", NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_soil_gw); @@ -22290,7 +22295,7 @@ void ClassSoilDS::decl(void) { decllocal("meltrunoff_buf", NHRU, "buffer melt runoff.", "(mm/d)", &meltrunoff_buf); - decllocal("hru_evap_buf", NHRU, "buffer evaporation.", "(mm/d)", &hru_evap_buf); + decllocal("hru_evap_buf", NHRU, "buffer evaporation.", "(mm/int)", &hru_evap_buf); decllocal("soil_moist_Init", NHRU, "initial soil moisture.", "(mm)", &soil_moist_Init); @@ -22331,13 +22336,13 @@ void ClassSoilDS::decl(void) { declparam("gw_K", NHRU, "[0.0]", "0.", "100.0", "daily ground water drainage from gw reservoir.", "(mm/d)", &gw_K); - declparam("rechr_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge.", "(mm/d)", &rechr_ssr_K); + declparam("rechr_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge layer (soil_rechr).", "(mm/d)", &rechr_ssr_K); - declparam("lower_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from soil column.", "(mm/d)", &lower_ssr_K); + declparam("lower_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from lower soil layer (soil_moist - soil_rechr).", "(mm/d)", &lower_ssr_K); - declparam("Sd_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily depression storage ssr drainage factor.", "(mm/d)", &Sd_ssr_K); + declparam("Sd_ssr_K", NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage factor from depression storage.", "(mm/d)", &Sd_ssr_K); - declparam("Sd_gw_K", NHRU, "[0.0]", "0.", "100.0", "daily depression storage gw drainage.", "(mm/d)", &Sd_gw_K); + declparam("Sd_gw_K", NHRU, "[0.0]", "0.", "100.0", "daily drainage factor to groundwater reservoir from depression storage.", "(mm/d)", &Sd_gw_K); declparam("soil_withdrawal", NDEFN, "[3]", "1", "4", "Select water withdrawal function for soil type: 1 = sand, 2 = loam, 3 = clay, 4 = organic. soil_withdrawal[1] - rechr layer, soil_withdrawal[2] - lower layer", "()", @@ -23360,7 +23365,7 @@ void Classtsurface::decl(void) { declvar("hru_tsf_D", NHRU, "mean daily surface/skin temperature", "(°C)", &hru_tsf_D); - decldiag("hru_tsf_acc", NHRU, "mean daily surface/skin temperature", "(°C)", &hru_tsf_acc); + decldiag("hru_tsf_acc", NHRU, "temperature accumulator used to calculate the daily mean hru_tsfD", "(°C)", &hru_tsf_acc); declgetvar("*", "SWE", "(m)", &SWE); @@ -23371,7 +23376,7 @@ void Classtsurface::decl(void) { decllocal("hru_T_s_D", NHRU, "mean daily surface/skin temperature", "(°C)", &hru_T_s_D); - decllocal("hru_T_s_acc", NHRU, "sum interval air temperature from previous day", "(°C)", &hru_T_s_acc); + decllocal("hru_T_s_acc", NHRU, "temperature accumulator used to calculate the previous daily mean snowpack temperature hru_T_s_D", "(°C)", &hru_T_s_acc); declgetvar("*", "z_s", "(m)", &z_s); @@ -23386,7 +23391,7 @@ void Classtsurface::decl(void) { decllocal("hru_t_D", NHRU, "mean daily snowpack temperature from previous day", "(°C)", &hru_t_D); - decllocal("hru_t_acc", NHRU, "sum interval air temperature from previous day", "(°C)", &hru_t_acc); + decllocal("hru_t_acc", NHRU, "temperature accumulator used to calculate the previous daily air temperature hru_t_D", "(°C)", &hru_t_acc); declgetvar("*", "hru_tmin", "(°C)", &tmin); @@ -23425,7 +23430,7 @@ void Classtsurface::decl(void) { variation_set = VARIATION_2 + VARIATION_3 + VARIATION_4 + VARIATION_5; - declvar("SWE_tc", NHRU, "SWE thermal conductivity", "(W/(m*K)", &SWE_tc); + declvar("SWE_tc", NHRU, "SWE thermal conductivity", "(W/(m*K))", &SWE_tc); declvar("SWE_density", NHRU, "SWE density", "( kg/m^3)", &SWE_density); @@ -24685,15 +24690,15 @@ void ClassCRHMCanopyClearing::decl(void) { declobs("Qnsn", NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn); - declvar("Qnsn_Var", NHRU, "net all-wave at snow surface", "(W/m^2*int)", &Qnsn_Var); + declvar("Qnsn_Var", NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn_Var); declobs("Qsisn", NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn); - declvar("Qsisn_Var", NHRU, "incident short-wave at surface", "(W/m^2*int)", &Qsisn_Var); + declvar("Qsisn_Var", NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn_Var); declobs("Qlisn", NHRU, "incident long-wave at surface", "(W/m^2)", &Qlisn); - declvar("Qlisn_Var", NHRU, "incident short-wave at surface", "(W/m^2*int)", &Qlisn_Var); + declvar("Qlisn_Var", NHRU, "incident short-wave at surface", "(W/m^2)", &Qlisn_Var); declobs("Qlosn", NHRU, "reflected long-wave at surface", "(W/m^2)", &Qlosn); @@ -24701,11 +24706,11 @@ void ClassCRHMCanopyClearing::decl(void) { decldiag("k", NHRU, "extinction coefficient", "()", &k); - decldiag("Tauc", NHRU, "short-wave transmissivity", "(W/m^2)", &Tauc); + decldiag("Tauc", NHRU, "short-wave transmissivity", "()", &Tauc); decllocal("Pa", NHRU, "Average surface pressure", "(kPa)", &Pa); - declvar("ra", NHRU, "", "(s/m)", &ra); + declvar("ra", NHRU, "resistance", "(s/m)", &ra); declvar("drip_cpy", NHRU, "canopy drip", "(mm/int)", &drip_Cpy); @@ -24713,11 +24718,11 @@ void ClassCRHMCanopyClearing::decl(void) { declvar("net_rain", NHRU, " direct_rain + drip", "(mm/int)", &net_rain); - declstatdiag("cum_net_rain", NHRU, " direct_rain + drip", "(mm)", &cum_net_rain); + declstatdiag("cum_net_rain", NHRU, " cumulative direct_rain + drip", "(mm)", &cum_net_rain); declvar("Subl_Cpy", NHRU, "canopy snow sublimation", "(mm/int)", &Subl_Cpy); - declstatdiag("cum_Subl_Cpy", NHRU, "canopy snow sublimation", "(mm)", &cum_Subl_Cpy); + declstatdiag("cum_Subl_Cpy", NHRU, "cumulative canopy snow sublimation", "(mm)", &cum_Subl_Cpy); decldiag("Pevap", NHRU, "used when ground is snow covered to calculate canopy evaporation (Priestley-Taylor)", "(mm)", &Pevap); @@ -24725,7 +24730,7 @@ void ClassCRHMCanopyClearing::decl(void) { declstatvar("Snow_load", NHRU, "canopy snow load (timetep start)", "(mm)", &Snow_load); - declvar("direct_snow", NHRU, "snow 'direct' Thru", "(mm/int)", &direct_snow); + declvar("direct_snow", NHRU, "snow 'direct' through canopy", "(mm/int)", &direct_snow); declvar("SUnload", NHRU, "unloaded canopy snow", "(mm)", &SUnload); @@ -24737,7 +24742,7 @@ void ClassCRHMCanopyClearing::decl(void) { declvar("net_snow", NHRU, "hru_snow minus interception", "(mm/int)", &net_snow); - declstatdiag("cum_net_snow", NHRU, "Cumulative Canopy unload ", "(mm)", &cum_net_snow); + declstatdiag("cum_net_snow", NHRU, "Cumulative hru_snow minus interception", "(mm)", &cum_net_snow); declvar("net_p", NHRU, "total precipitation after interception", "(mm/int)", &net_p); @@ -24747,7 +24752,7 @@ void ClassCRHMCanopyClearing::decl(void) { declvar("intcp_evap", NHRU, "HRU Evaporation from interception", "(mm/int)", &intcp_evap); - declstatdiag("cum_intcp_evap", NHRU, "HRU Evaporation from interception", "(mm)", &cum_intcp_evap); + declstatdiag("cum_intcp_evap", NHRU, "Cumulative HRU Evaporation from interception", "(mm)", &cum_intcp_evap); // parameters: @@ -24781,9 +24786,9 @@ void ClassCRHMCanopyClearing::decl(void) { declparam("CanopyClearing", NHRU, "[0]", "0", "1", "canopy - 0/clearing - 1", "()", &CanopyClearing); - decldiagparam("Alpha_c", NHRU, "[0.1]", "0.05", "0.2", "canopy albedo", "()", &Alpha_c); + decldiagparam("Alpha_c", NHRU, "[0.1]", "0.05", "0.2", "canopy albedo, used for longwave-radiation enhancement estimation", "()", &Alpha_c); - decldiagparam("B_canopy", NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); + decldiagparam("B_canopy", NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter for longwave-radiation. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); } void ClassCRHMCanopyClearing::init(void) { @@ -25005,7 +25010,7 @@ void ClassCRHMCanopyClearing::run(void) { C1 = 1.0/(D*SvDens*Nu); Alpha = 5.0; - Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); + Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius; // 18Mar2022: remove Gamma Distribution Correction term, *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); // sublimation rate of single 'ideal' ice sphere: @@ -25041,8 +25046,8 @@ void ClassCRHMCanopyClearing::run(void) { float IceBulbT = hru_t[hh] - (Vi* Hs/1e6/ci); float Six_Hour_Divisor = Global::Freq/4.0; // used to unload over 6 hours - const float c = 0.678/(24*7*24/Global::Freq); // weekly dimensionless unloading coefficient -> to CRHM time interval - + const float U = -1*log(0.678)/(24*7*Global::Freq/24); // weekly dimensionless unloading coefficient -> to CRHM time interval + // 21Mar2022 correction: invert the term 24/Global::Freq, use unloading rate coefficient U = -log(c)/t for snow unloading determined by inverse function of c = e^(-Ut) = 0.678 based on Eq. 14 in Hedstrom and Pomeroy (1998) // determine whether canopy snow is unloaded: if(IceBulbT >= unload_t_water[hh]){ @@ -25057,7 +25062,7 @@ void ClassCRHMCanopyClearing::run(void) { cum_SUnload[hh] += SUnload[hh]; } else if(IceBulbT < unload_t[hh]){ // has to be at least one interval. Trip on half step - SUnload[hh] = Snow_load[hh]*c; // the dimensionless unloading coefficient already /interval + SUnload[hh] = Snow_load[hh]*U; // the dimensionless unloading coefficient already /interval, 21Mar2022 correction: use unloading rate coefficient U if(SUnload[hh] > Snow_load[hh]){ SUnload[hh] = Snow_load[hh]; Snow_load[hh] = 0.0; @@ -25272,15 +25277,15 @@ void ClassCRHMCanopyClearingGap::decl(void) { declobs("Qnsn", NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn); - declvar("Qnsn_Var", NHRU, "net all-wave at snow surface", "(W/m^2*int)", &Qnsn_Var); + declvar("Qnsn_Var", NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn_Var); declobs("Qsisn", NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn); - declvar("Qsisn_Var", NHRU, "incident short-wave at surface", "(W/m^2*int)", &Qsisn_Var); + declvar("Qsisn_Var", NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn_Var); declobs("Qlisn", NHRU, "incident long-wave at surface", "(W/m^2)", &Qlisn); - declvar("Qlisn_Var", NHRU, "incident long-wave at surface", "(W/m^2*int)", &Qlisn_Var); + declvar("Qlisn_Var", NHRU, "incident long-wave at surface", "(W/m^2)", &Qlisn_Var); declobs("Qlosn", NHRU, "reflected long-wave at surface", "(W/m^2)", &Qlosn); @@ -25288,11 +25293,11 @@ void ClassCRHMCanopyClearingGap::decl(void) { decldiag("k", NHRU, "extinction coefficient", "()", &k); - decldiag("Tauc", NHRU, "short-wave transmissivity", "(W/m^2)", &Tauc); + decldiag("Tauc", NHRU, "short-wave transmissivity", "()", &Tauc); decllocal("Pa", NHRU, "Average surface pressure", "(kPa)", &Pa); - declvar("ra", NHRU, "", "(s/m)", &ra); + declvar("ra", NHRU, "resistance", "(s/m)", &ra); declvar("drip_cpy", NHRU, "canopy drip", "(mm/int)", &drip_Cpy); @@ -25300,11 +25305,11 @@ void ClassCRHMCanopyClearingGap::decl(void) { declvar("net_rain", NHRU, " direct_rain + drip", "(mm/int)", &net_rain); - declstatdiag("cum_net_rain", NHRU, " direct_rain + drip", "(mm)", &cum_net_rain); + declstatdiag("cum_net_rain", NHRU, " cumulative direct_rain + drip", "(mm)", &cum_net_rain); declvar("Subl_Cpy", NHRU, "canopy snow sublimation", "(mm/int)", &Subl_Cpy); - declstatdiag("cum_Subl_Cpy", NHRU, "canopy snow sublimation", "(mm)", &cum_Subl_Cpy); + declstatdiag("cum_Subl_Cpy", NHRU, "cumulative canopy snow sublimation", "(mm)", &cum_Subl_Cpy); decldiag("Pevap", NHRU, "used when ground is snow covered to calculate canopy evaporation (Priestley-Taylor)", "(mm)", &Pevap); @@ -25312,7 +25317,7 @@ void ClassCRHMCanopyClearingGap::decl(void) { declstatvar("Snow_load", NHRU, "canopy snow load (timetep start)", "(mm)", &Snow_load); - declvar("direct_snow", NHRU, "snow 'direct' Thru", "(mm/int)", &direct_snow); + declvar("direct_snow", NHRU, "snow 'direct' through canopy", "(mm/int)", &direct_snow); declvar("SUnload", NHRU, "unloaded canopy snow", "(mm)", &SUnload); @@ -25324,7 +25329,7 @@ void ClassCRHMCanopyClearingGap::decl(void) { declvar("net_snow", NHRU, "hru_snow minus interception", "(mm/int)", &net_snow); - declstatdiag("cum_net_snow", NHRU, "Cumulative Canopy unload ", "(mm)", &cum_net_snow); + declstatdiag("cum_net_snow", NHRU, "Cumulative hru_snow minus interception", "(mm)", &cum_net_snow); declvar("net_p", NHRU, "total precipitation after interception", "(mm/int)", &net_p); @@ -25334,7 +25339,7 @@ void ClassCRHMCanopyClearingGap::decl(void) { declvar("intcp_evap", NHRU, "HRU Evaporation from interception", "(mm/int)", &intcp_evap); - declstatdiag("cum_intcp_evap", NHRU, "HRU Evaporation from interception", "(mm)", &cum_intcp_evap); + declstatdiag("cum_intcp_evap", NHRU, "Cumulative HRU Evaporation from interception", "(mm)", &cum_intcp_evap); // parameters: @@ -25372,9 +25377,9 @@ void ClassCRHMCanopyClearingGap::decl(void) { declparam("CanopyClearing", NHRU, "[0]", "0", "2", "canopy - 0/clearing - 1/gap - 2", "()", &CanopyClearing); - decldiagparam("Alpha_c", NHRU, "[0.1]", "0.05", "0.2", "canopy albedo", "()", &Alpha_c); + decldiagparam("Alpha_c", NHRU, "[0.1]", "0.05", "0.2", "canopy albedo, used for longwave-radiation enhancement estimation", "()", &Alpha_c); - decldiagparam("B_canopy", NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); + decldiagparam("B_canopy", NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter for longwave-radiation. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); } void ClassCRHMCanopyClearingGap::init(void) { @@ -25663,7 +25668,7 @@ void ClassCRHMCanopyClearingGap::run(void){ C1 = 1.0/(D*SvDens*Nu); Alpha = 5.0; - Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); + Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius; // 18Mar2022: remove Gamma Distribution Correction term, *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); // sublimation rate of single 'ideal' ice sphere: @@ -25699,8 +25704,8 @@ void ClassCRHMCanopyClearingGap::run(void){ float IceBulbT = hru_t[hh] - (Vi* Hs/1e6/ci); float Six_Hour_Divisor = Global::Freq/4.0; // used to unload over 6 hours - const float c = 0.678/(24*7*24/Global::Freq); // weekly dimensionless unloading coefficient -> to CRHM time interval - + const float U = -1*log(0.678)/(24*7*Global::Freq/24); // weekly dimensionless unloading coefficient -> to CRHM time interval + // 21Mar2022 correction: invert the term 24/Global::Freq, use unloading rate coefficient U = -log(c)/t for snow unloading determined by inverse function of c = e^(-Ut) = 0.678 based on Eq. 14 in Hedstrom and Pomeroy (1998) // determine whether canopy snow is unloaded: if(IceBulbT >= unload_t_water[hh]){ @@ -25715,7 +25720,7 @@ void ClassCRHMCanopyClearingGap::run(void){ cum_SUnload[hh] += SUnload[hh]; } else if(IceBulbT < unload_t[hh]){ // has to be at least one interval. Trip on half step - SUnload[hh] = Snow_load[hh]*c; // the dimensionless unloading coefficient already /interval + SUnload[hh] = Snow_load[hh]*U; // the dimensionless unloading coefficient already /interval, 21Mar2022 correction: use unloading rate coefficient U if(SUnload[hh] > Snow_load[hh]){ SUnload[hh] = Snow_load[hh]; Snow_load[hh] = 0.0; @@ -27019,11 +27024,11 @@ void Classglacier::decl(void){ declstatdiag("cumicemelt", NHRU, "cumulative ice melt", "(mm)", &cumicemelt); - declstatvar("firn_dens", NDEFN, "densities of snow densification layers", "(kg/m^3)", &firn_dens, &firn_dens_array, Global::nlay); + declstatvar("firn_dens", NDEFN, "densities of firn layers", "(kg/m^3)", &firn_dens, &firn_dens_array, Global::nlay); - declstatvar("firn_h", NDEFN, "depths of snow densification layers", "(m)", &firn_h, &firn_h_array, Global::nlay); + declstatvar("firn_h", NDEFN, "depths of firn layers", "(m)", &firn_h, &firn_h_array, Global::nlay); - declstatvar("firn_yr", NDEFN, "layer[1] - years to 'critical density] and layer[2, ...] age of firn", "(yr)", &firn_yr, &firn_yr_array, Global::nlay); + declstatvar("firn_yr", NDEFN, "layer[1] - years to 'critical density' and layer[2, ...] age of firn", "(yr)", &firn_yr, &firn_yr_array, Global::nlay); decldiagparam("firn_dens_init", NDEFN, "[220.0]", "0.0", "1000.0", "initial densities of firn densification layers", "(kg/m^3)", &firn_dens_init, &firn_dens_array_init, Global::nlay); @@ -27083,11 +27088,11 @@ void Classglacier::decl(void){ declstatdiag("cumfirn_2ice", NHRU, "cumulative firn added to ice", "(mm)", &cumfirn_2ice); - declvar("Gnet_rainD", NHRU, "daily net rain", "(mm/d)", &Gnet_rainD); + declvar("Gnet_rainD", NHRU, "daily net rain calculated from net_rain", "(mm/d)", &Gnet_rainD); declvar("net_rain_org", NHRU, "value of 'net_rain' before addition of SWE, firn and ice melt", "(mm/int)", &net_rain_org); - declvar("cumnet_rain_org", NHRU, "value of 'net_rain' before addition of SWE, firn and ice melt", "(mm)", &cumnet_rain_org); + declvar("cumnet_rain_org", NHRU, "cumulative value of 'net_rain' before addition of SWE, firn and ice melt", "(mm)", &cumnet_rain_org); ObsCnt_Albedo = declreadobs("glacier_Albedo_obs", NHRU, "available Albedo observations", "()", &glacier_Albedo_obs, HRU_OBS_misc, true); // HRU_OBS_p_ppt HRU_OBS_misc HRU_OBS_Q HRU_OBS_u HRU_OBS_t_rh_ea @@ -27177,7 +27182,7 @@ void Classglacier::decl(void){ decldiagparam("tfactor", NHRU, "[0.0]", "0.0","10.0", "degree day melt factor", "(mm/d*°C)", &tfactor); - decldiagparam("nfactor", NHRU, "[0.0]", "0.0","10.0", "net radiation factor (typical value 3.0(mm*m^2/MJ))", "(mm*m^2/MJ)", &nfactor); + decldiagparam("nfactor", NHRU, "[0.0]", "0.0","10.0", "net radiation factor (typical value 3.0(mm*m^2/MJ*d))", "(mm*m^2/MJ*d)", &nfactor); decldiagparam("Use_QnD", NHRU, "[0]", "0","1", "1 - Use QnD if available", "()", &Use_QnD); @@ -27949,7 +27954,7 @@ void ClassSWEslope::decl(void) { declparam("hru_area", NHRU, "[1]", "1e-6", "1e+09", "hru area", "(km^2)", &hru_area); - declparam("distrib_SWEslope", NDEFN, "[0.0]", "0.0", "1.0E6.0", "distribute this HRU iceflow to these HRUs. Source HRU can include itself in the re-distribution", "()", &distrib_SWEslope, &distrib_hru, nhru); + declparam("distrib_SWEslope", NDEFN, "[0.0]", "0.0", "1.0E6.0", "distribute SWE from this HRU to these HRUs. Source HRU can include itself in the re-distribution", "()", &distrib_SWEslope, &distrib_hru, nhru); declputvar("*", "SWE", "(mm)", &SWE); diff --git a/borland_source/NewModules.h b/borland_source/NewModules.h index 0ac3fb96f..f0d87ee52 100644 --- a/borland_source/NewModules.h +++ b/borland_source/NewModules.h @@ -1,4 +1,4 @@ -// 04/12/21 with changes to 07/02/20 +// 08/11/21 with changes to 04/12/21 //--------------------------------------------------------------------------- #ifndef OurModulesH @@ -2657,6 +2657,7 @@ ClassVolumetric(string Name, String Version = "undefined", CRHM::LMODULE Lvl = C // declared parameters const float *soil_Depth; const float *Si_correction; +const float *fallstat_correction; // 08/11/2021 const float *soil_moist_max; const float *soil_rechr_max; const long *soil_type; diff --git a/borland_source/Notes.txt b/borland_source/Notes.txt index 8b1378917..1b45c33ad 100644 --- a/borland_source/Notes.txt +++ b/borland_source/Notes.txt @@ -1 +1,613 @@ - +Main changes are as follows. + +1) The loop ahead features used by frozen, frozenAyers and lakeevap modules was fixed. +2) frozen and frozenAyers opportunity time was modified. + a) The calculation of opportunity time now initiates for a group when any HRU has snowmeltD greater than 2.0mm. + b) The end of the period used to calculate the opportunity is when the average of the SWE of a group is less than 2mm. + c) When Reset_t0 is GT 0, the value of t0 is ignored and the opportunity time is calculated for the group. +3) The monthly table for the parameter Meyer_B is offset for the Southern Hemisphere by six months. + +CRHM 01/19/12 + +1) Start and end of lake evaporation was not being handled properly in the module "lake_evap. + +CRHM 01/20/12 + +1) Addition of ice bulb temperature to module "obs" to determine snow/rain. + +CRHM 01/31/12 + +1) In order to make the variables that accumulate work properly when doing the "run-up looping" or "running ahead", it was necessary to make them all state variables. Unfortunately, saving and restoring these values will cause CRHM to execute slower. + +2) Logic was added so that only the groups requiring to run ahead to calculate future values do so. Other groups hold their values until it is time for the entire project to proceed. This reduces the number of state variables to be saved and restored. + +CRHM 02/08/12 (replaced CRHM.exe, new_modules.cpp and this file). + +1) Fixed bug in module obs when using daily time step with variation #1. + +CRHM 02/15/12 + +Added the following to module Snowbal. + +1) Parameter "T_g_or_G_flux" to select if the ground flux is calculated from ground temperatures or an actual flux is used defined by one of the following parameters. + +2) Observation "F_g" and if not available from "hru_F_g" below. + +3) Parameter "hru_F_g" + +N.B. Even when using the flux option, T_g is still used by the routine evap_cond(void) -- calculates evaporation/condensation at a point in the lower layer. + +CRHM 02/16/12 + +1) Corrected errors in newmodules.cpp. + +CRHM 02/22/12 + +1) When observation averages (or other function) were being displayed with no project loaded or an observation not used by a CRHM module the "HRU_OBS_Tables" were not being initialised correctly. + +CRHM 02/25/12 + +1) Corrected display of observation functions and display of variables with AddObsFunct feature. + +2) Corrected module basin. String parameters "Loop_to->Count" and "RapidAdvance_to" were not being handled correctly when not being used. + +CRHM 02/28/12 + +1) Fixed Snobal ground flux error when layer_count[hh] == 2. + +2) Modified modules frozen and frozenAyers. Parameter t0 was being ignored when t0 > 0.0 and Reset_t0 == 0. The opportunity time was always being calculated. + Values of of parameters t0 and Reset_t0 are never changed. t0_Var is set to the opportunity time used for infiltration calculations. + +CRHM 03/01/12 + +1) Changes to modules frozen and frozenAyers. When the opportunity time is calculated all infiltration is inhibited. It was not being reset to its proper value after the calculation of the opportunity time. + +CRHM 03/08/12 + +1) Removed parameter "Reset_t0" and replaced it with "t0_Julian" which now only determines the earliest start of the fronzen infiltration when calculating opportunity time or using parameter values. +2) To select the calculation of opportunity time, only t0 for HRU 1 has to be set to zero. + +CRHM 03/21/12 + +1) Changes to modules frozen and frozenAyers not correct. Need more work. +2) Maximums for parameters Sdmax and Sdinit in module Soil increased to 5000mm from 1000mm. + +CRHM 03/27/12 + +1) Added method of inhibiting culvert code in module soil variation #1 for HRUs with no culvert. When the value of parameter number_culverts is <= zero for an HRU, the culvert code is not executed. +2) Code was added to frozen and frozenAyers using a variable Julian_end equal to t0_Julian + 183 days. Work in progress. + +CRHM 04/01/12 + +1) Fixed problem in module obs using variation #1. Was not handling any of the daily temperatures correctly. +2) Generated all distribution files. + +CRHM 04/18/12 + +1) Added global warming feature allowing temperature and precipitation to me modified using parameters ClimChng_t and ClimChng_p. +2) Added parameter ClimChng_flag which determines if RH or ea (ea <= es) is kept constant with temperature change. +3) Added parameter ppt_ht_adj to adjust p and ppt with change in elevation. +4) Added variable t_obs which holds the value of the observation t before lapse rate and climate warming change is applied. +5) At present CRHM uses the RH observation and ignores the ea observation. + +CRHM 04/23/12 + +1) Added more reporting to log screen of modules Soil, Netroute and Netroute_M to assist in checking mass balance. +2) In Muskingum code added period to some constants. i.e. "2" was changed to "2.0" to ensure term was always handled as floating point. + +CRHM 04/25/12 + +1) Simplified climate warming/lapse rate code handling of t, rh and ea observations. Fixed errors and simplifies its operation. +2) Put Winstral albedo module back to its original with a few minor changes to make its output similar to "albedo_Richard" and "albedo_Baker". + +CRHM 04/27/12 + +1) CRHM will run using rh or ea. If both are present will use rh and ignore ea. When CRHM executes it generates the other using the adjusted temperature (lapse rate and climate change) and the parameter ElevChng_flag (maintain rh or ea with temperatue change). + +2) Precipitation log messages improved. + +CRHM 04/30/12 + +1) Lapse rate/climate warming error corrected. Worked correctly for simple projects but not for group projects. + +CRHM 05/03/12 + +1) Corrected error when modules are loaded before the driving observation file. +2) The parameter "ElevChng_flag" was not handling holding ea constant. + +CRHM 05/22/12 + +1) Modified Netroute, Netroute_M, Netroute_D and Netroute_M_D making it possible to to distribute HRU grounwater to gw reservoir(basingw), HRU surface water(basinflow), HRU recharge(soil_rechr) and depressional storage(Sd). + +CRHM 05/23/12 + +1) Module "lake_evap" was not calculating lake evaporation. Variable "lake_evap_month" was a state variable and was always being reset to zero after calculating the monthly evaporation. + +2) Projects using obs#1 would not build because of an obs/obs#1 conflict. + +CRHM 05/24/12 + +1) Added to the netroute family of modules the capabilty of redirecting gw. + +CRHM 06/14/12 + +1) Added ground water reservoir to module soil. State variable called "gw" with associated parameters gw_max, gw_init and gw_K. + +2) Variable "soil_gw" now feeds the ground water reservoir "gw" in module "soil" and is not used externally. + +3) A new variable "gw_flow" is the drainage from the ground water reservoir to the next module normally "Netroute" etc.. + +4) Input to "Netroute" etc. becomes "gw_flow" instead of "soil_gw". + +CRHM 06/29/12 + +1) Corrected error in modules Netroute_D, Netroute_M and Netroute_M_D caused by incorrect input to gw Clark delay. Error showed when gw was moved between HRUs (-hru). + +CRHM 06/28/12 Temporary release for Sebastian. Not fully tested or documented. + +1) Re-wrote the "lake_evap" module to simplify the handling of months for calculation of monthly means.. + +2) Modified Soil so that if "Sdmax" and "soil_moist_max" are both zero evaporation is not limited (i.e. lake evaporation") making "hru_evap" and "hru_actet" identical. + +3) Corrected run ahead logic in CRHM. + +CRHM 06/29/12 + +1) Changed parameter maximums. + +2) Added elevation term to lake evaporation equation. + +CRHM 07/04/12 + +1) Round off error with TDateTime variables fixed in module lake_evaporation. + +CRHM 11/15/12 + +1) Added a new variable to the module soil called "redirected_residual" to handle "outflow" redirected from an HRU to another HRU by Netroute/_D/_M/_M_D parameters "whereto" or "distrib_Route". + This change was made to correct a problem with the module soil#1 culvert variation. It also delays the re-directed runoff by one timestep and the runoff Clark input delay of Netroute/_D/_M/_M_D. + +2) The "order" parameter did not work properly in modules Netroute/_M when the values were non sequential. + +CRHM 11/16/12 + +1) Error fixed in module "soil" occurring whwn culvert code not used. + +CRHM 11/28/12 + +1) Addition of new module K_Estimate to calculate lateral flow rates in soil layers and groundwater layer using Darcy’s law for unsaturated flow. + +2) Added to the "soil" module a variable "infil_act" giving the actual infiltration permitted by "soil". Infiltration modules generate the potential infiltration rate "infil". + The Log screen expanded to assist in applying a mass balance. + +CRHM 12/21/12 + +1) Sparse files can now have lines in the observation file with a date and no data columns. These lines will be ignored. However, if there are any missing columns in a sparse file these will be set to -999999 to indicate missing data. + +CRHM 02/05/13 - faulty version + +1) Error fixed in modules "frozen" and "frozenAyers" causing the "snowmeltD" to not always be handled correctly when the parameter "t0[1]" was none zero. Error was introduced after the 07/04/2012 release. + +2) CRHM help files now distributed as PDF files. + +CRHM 02/27/13 + +1) Corrected error introduced 02/05/13 causing hru_rh and hru_ea not to be refreshed. + +CRHM 03/05/13 + +1) Fixed error in the snow unloading code in the canopy, canopyclearing and canopyclearinggap modules. + +CRHM 03/22/13 + +1) Problem fixed in the module "Greencrack".The variable "snowinfil" and "meltrunoff" were wrong though their accummulated values were correct. +2) When the modules "crack", "PrairieInfiltration" and "Greencrack" were used with an initial state file, they were not being initialised properly. + +CRHM 03/26/13 + +1) Error found in Netroute_D and Netroute_M_D. Distribution to basin flow was incorrect. Also, a line commented for debugging had not been restored in Netroute_M_D. +2) Added information to log screen giving each HRU's contribution to the basin flow. + +CRHM 05/17/13 + +1) modules frozen and frozenAyers changed to give more choice. Parameter t0, when positive is used as the opportunity time, + if t0 == 0, the opportunity time is calculate from t0 = 0.65*SWEPk, + if t0 is negative, then CRHM computes forward to calculate the opportunity and then backs up and uses the t0 determined. +2) Muskingum routing error checking changed. Still needs further work. + +CRHM 06/27/13 + +1) Revisions to CRHM observation input completed. Reviewed operation of the parameter HRU_OBS and related parameters, precip_elev_adj, ElevChng_flag, ClimChng_flag, ClimChng_t and ClimChng_precip. + +CRHM 09/20/13 + +1) Miscellaneous items. + +2) Removal of Shape screen. + +3) Removal of all database components (.dbf). + +4) Update of parameter Screen file write/read routines. Identical to project file write/read excecpt all module/group parameters are written separately. In the project file parameters with the same name and values are collected together and written as Shared. + +5) Inserted missing lines in module evap_resist. + +CRHM 10/01/13 + +1) Error in module calcsun#2 and calcsun#3 - hru_SunAct not calculated correctly. + + +CRHM 12/10/13 + +1) Historically parameters common to more than one module were grouped under "basin". Currently, they are grouped under "shared". A few months ago I removed the shared parameters from the "*.par" files +and entered them under their full module/group names. Unfortunately there was legacy code relating to the old "basin" parameters which began duplicating "basin" module parameters - basin_area, hru_area, +hru_elev, hru_lat, hru_ASL and hru_GSL. To cut a long story short the listed parameters were no longer shared and defaulted to the Bad Lake values for any modules other than basin. + +CRHM 12/17/13 + +1) Correction made to daily sum in the Observation Functions. + +2) Correction to how Build screen handles current parameters when re-building an existing project. + +CRHM 01/16/14 + +1) Summary screen and water year display completed. + +2) Work progressing on glacier module. + +3) Beginning 2014 a table which translated legacy module names to current names was removed. + This should not be a problem if an earlier project has been saved from a recent copy of CRHM as its module names will have been updated when the project was saved. + However, if you wish to run a very old project you will have to manually edit all the occurences in the project file using the following conversion table. + + "AnnandaleX, calcsunX, calcsun_QsiD, Slope_QsiX, ebsmX, long, longVtX, route, smbal, Trees" + become respectively, + "Annandale, calcsun, calcsun, Slope_Qsi, ebsm, longVt, longVt, Netroute, Soil, Canopy" + +CRHM 02/05/14 + +1) Updated modules Canopy, CanopyClearing and CanopyClearingGap. + +2) Added a new module "XG" based upon "A Simple Thaw-Freeze Algorithm for a Multilayerd Soil using Stephan Equation, Changwei et al., 2013. + +CRHM 02/06/14 + +1) Added two new filters - cos and abs. + +2) The filter sine was renamed to sin. The original name can still be used. + +CRHM 02/11/14 + +1) Additions to module XG. + +CRHM 02/13/14 + +1) Correction in CanopyClearing and CanopyClearingGap in handling of clearing "Qlisn". Now set equal to Qli_. + +CRHM 02/21/14 + +1) Minor correction to module XG. + +2) Start og new prototype module Exec. + +CRHM 03/12/14 + +1) In module Soil, the expression "exp(-soil_runoff[hh]/Sdmax[hh])" was causing an overflow error. Code was added to limit the ratio (soil_runoff[hh]/Sdmax[hh]) to a maximum of 12.0. + +CRHM 11/18/14 + +1) Debug code left in error in Bld screen causing error in Build/Construct screen. + +CRHM 11/21/14 + +1) Problem when building a new project without declaring an observation file first. CRHM could not determine if precipitation was p or ppt. If the project was saved and reloaded it would run correctly. Fixed + +CRHM 12/02/14 + +1) Added a Delta observation function. Still being tested. + +2) Format for saving observations and observation functions now the same as used for variables. Still being tested. + +3) Added an inhibit parameter to module XG which inhibits changing kw/ki after the front has passed through the layers. + +CRHM 01/15/15 + +1) Fixed bugs in saving and retrieving DISPLAY OBSERVATIONS to project files. + +2) Completed module XG and edited the help file. + +CRHM 02/17/15 + +1) Call "declputparam" prevents the parameter from being shared between groups in a group project and forces the parameter to be shared between all modules in a simple project. + +2) Fixed system error in the build screen when editing a project. This occurred when a project was being edited. It never happened when creating a new project. + +CRHM 03/01/15 + +1) Corrected problems with saving "AddObsFunct"s to project. + +2) CRHM variables are not defined until CRHM is run. On the otherhand odservations are always defined after loading. Export screen was faulting when an Observation was followed by a variable before CRHM was run. + +CRHM 04/14/15 + +1) Plot line colours done differently to eliminate white(invisible lines). + +2) Created module "z_s_and_rho" to allow module "pbsmSnobal" to be used without "SnobalCRHM". Variables "z_s and "rho" generated from expressions from Pomeroy and Gray from book "Snowcover..." + +3) When the global number of layers, "nlay" is increased in size the last defined layer is duplicated. This is satisfactory for say, soil properties but not for example firn layers which must be subsequently edited. + +CRHM 05/13/15 + +1) When a group was extracted from a group project and loaded as a simple project, it would not execute without faulting until it was saved and reloaded again. Fixed. + +CRHM 09/22/15 + +1) CRHM was saving information to the Registry. Removed because it made CRHM suspicious to anti-virus software. + +2) Observation and Variable functions completed. They calculate the functions for the time period chosen. These are Daily/Water year/Calendar year/Monthly/Summarize all. + +3) The module "obs" feature "catchadjust" was corrected. "Nypher" remains unchanged. "Geonor" is now called "MacDonald-Alter" and should not be used as it is not correct and the fourth option "Smith-Alter" should be used instead. The last option is used for the Alter shielded gauges like the Geonor and Pluvial. + +4) The module "ebsm" was enhanced to allow the variable "Qe_ebsm" energy to be sublimated instead of being added to the melt. In the original version this energy was added to "Qmelt. A parameter Qe_subl_from_SWE" was added to select sublimation or melt (original version). A variable "Qe_subl" gives the energy involved. + +CRHM 09/28/15 + +1) "AutoExit" option not functioning. Fixed. N.B. that "AutoExit" is inhibited unless at least one of the "Log" output choices is selected from "Last/All/Debug_Screen/Summary". + +CRHM 10/01/15 + +1) Changes made to modules "glacier" and "glacier2" + + a) Firn to ice threshold changed from 800kg/m3 to 830 kg/m3. + b) When SWE is added to Firn, SWE density is used and not the parameter "rho0". + c) Firn values are never allowed to decrease during densification. + +CRHM 10/16/15 + +1) Added code to pad last day of observation file if it does not end at midnight. "0.0" is used. Warning is displayed on the screen as it could be an error. + +CRHM 10/19/15 + +1) Changes made to the Smith-Alter catch correction in module Obs. + +2) Whan variables are deleted from ListBox3 any functions of these variables are deleted from ListBox4. + +3) If a project file requests an Obs function of a variable, CRHM checks that the variable appears in ListBox3 to be calculated in the model run. + +CRHM 11/25/15 + +1) Modules - Netroute, ClassNetroute_D, Netrout_M and Netrout_M_D were accounting for "gwinflow" twice. + +2) In the modules above the units were incorrect for the gw flow to the HRU gw. + +3) In modules ClassNetroute_D, Netrout_M and Netrout_M_D the "order" parameter was added as drainage order can be different from the HRU sequence. + +CRHM 11/30/15 + +Following changes made "Soil", "SoilX", "SoilK" and "SoilDetention", to correct gw mass balance errors. + +1) groundwater to gw_flow: + gw_flow[hh] += gw[hh]/gw_max[hh]*gw_K[hh]/Global::Freq; becomes float spill = gw[hh]/gw_max[hh]*gw_K[hh]/Global::Freq; + gw[hh] -= gw_flow[hh]; becomes gw[hh] -= spill; + plus gw_flow[hh] += spill; + +2) groundwater recharge of Sd: + soil_gw[hh] += (Sd[hh]*Sd2gw_k); becomes soil_gw[hh] += (Sd2gw_k); + Sd[hh] -= (Sd[hh]*Sd2gw_k); becomes Sd[hh] -= (Sd2gw_k); + + +3) lateral flow of Sd: + soil_ssr[hh] += (Sd[hh]*Sd2ssr_k); becomes soil_ssr[hh] += (Sd2ssr_k); + Sd[hh] -= (Sd[hh]*Sd2ssr_k); becomes Sd[hh] -= (Sd2ssr_k); + +CRHM 03/09/16 + +1) Module obs does not require the filter ea(t, rh) in the observation file to create the vapour pressure. It is created within CRHM from the temperature and relative humidity. If the observations rh and ea are available , rh is always used and not ea. + +2) The parameter Use_Observations_As_Supplied in the module obs is now fully functional. When used CRHM does not modify the input observations in anyway. Both observations rh and ea must be given. However, the observation filters ea(t, rh) or rh(t, ea) may be used to supply the missing ea or rh. + +3) It is recommended that the module XG only be used with the parameter k_update = 0 as modifying soil conductivity as freezing/thawing fronts advance does not work very well. + +CRHM 03/21/16 + +1)The parameter Use_Observations_As_Supplied in the module obs has been removed. When it is used it requires that the project be reloaded after any change in the parameter value is made. It may be added again later when a method is found to transparently reload a project. +. +CRHM 01/06/17 + +1) Module Ayers was not calculating "meltrunoff" and "runoff". correctly. + +2) Module pbsmSnobal was not distributing the drift correctly when the parameter "distrib" was negative to partition the HRUs into two or more drift regimes. + +CRHM 01/13/17 + +1) In module "obs" the catchratio calculated by MacDonald-Alter and Smith-Alter cannot be greater than 1.0. + +2) Checks were added to all soil moisture modules to terminate if gw_init is greater than gw_max. + +3) CRHM source code was exceeding the compiler maximum size. Removed some Quinton modules. + +CRHM 02/08/17 + +1) In module "obs", add one more row to obs_elev parameter, and in total two rows are used to index the obs_elev, the first row indexes elevation of observed air temp, the second row indexes elevation of observed precipitation. + +CRHM 04/24/17 + +1) In modules "Netroute", "Netroute_M", "Netroute_D", "Netroute_M_D", add a parameter preferential_flow, this gives option for a HRU to route surface runoff to another HRU's groundwater reservoir when preferential_flow is set to 1. + +CRHM 04/28/17 + +1) In module SWEslope, corrected available amount of snow for transport by avalanche slide; + + Amount = SWE[hh]; becomes Amount = SWE[hh] - Hd[hh]; + +CRHM 05/02/17 + +1) In modules "soil", "SoilDS", "SoilX", "ClassSoilPrairie", add one more row to soil_withdrawal parameter, and in total two rows are used to index the soil_withdrawal, the first row indexes soil withdrawal function for recharge layer, the second row indexes soil withdrawal function for lower layer. + +CRHM 06/13/17 + +1) In modules "Canopy", "CanopyClearing", "CanopyClearingGap", modified algorithm determine canopy interception of snow as unloading snow at slower rate, unloading snow at faster rate, and dripping. + +2) In modules "Canopy", "CanopyClearing", "CanopyClearingGap", moved code of canopy interception of snow sublimation before code of canopy interception of snow unloading. + +CRHM 06/14/17 + +1) In module "Canopy", added variables Qlisn_Var and Qsisn_Var, this builds link to SnobalCRHM#1. + +CRHM 10/31/17 + +1) In module SWEslope, corrected index error in parameter Disable_SWEslope; + + for (long hhh = 0; chkStruct(hhh); ++hhh) { + if(Disable_SWEslope[hh]) + continue; + + becomes + + for (long hhh = 0; chkStruct(hhh); ++hhh) { + if(Disable_SWEslope[hhh]) + continue; + +CRHM 11/15/17 + +1) Finished correcting error in indexing observation elevations in ClassCRHM.cpp/h + +2) Fixed problem with the module glacier. Albedo momemtarily changed to the "bare soil" value when SWE became zero. + +3) New equation for thermal conductivity in pbsm, pbsm_M, sbsm, and IceBulb + +CRHM 11/28/17 + + Previous changes to handle duplication of the parameters "obs_elev" and "soil_withdrawl" were causing other errors. + +CRHM 01/16/18 + + Previous changes to handle duplication of the parameters "obs_elev" and "soil_withdrawl" were causing other errors. + + Fixed error in declputparam for Dts_organic_runoff_K and Dts_snow_runoff_K. + +CRHM 05/15/19 + + Fixed errors in ClassModule that handles duplication of the parameters "obs_elev" and "soil_withdrawl". + +CRHM 05/15/19_GSL_change on 12/19/19 + Fixed error in GSL conversion in calculating diffuse variable in global module. + +CRHM 03/24/20 + + Fixed error in Si update in Volumetric module. + +CRHM 03/31/20 + + Add 'infDays' parameter in crack, PrairieInfiltration and Greencrack modules to handle more snowinfil conditions that were previously limited to max. 6 days. + + Better description for soil_rechr, soil_moist variables and parameters. + + Modified frozenAyers module comment out if(cumsnowinfil -cumsnowinfil_0 > INF), as the if statement could cause problems for multi-years runs. + +CRHM 04/14/20 + + Add option for updating Si or fallstat based on Volumetric moisture content in recharge layer in Volumetric module. + +CRHM 05/21/20 + + Correcting f2, f3, and f4 formula in Jarvis resistance scheme that is in evap_Resist, evap_ResistD, and evapX modules. + +CRHM 06/09/20 + + Restoring f2 in Jarvis resistance scheme in evap_Resist, evap_ResistD, and evapX modules to correct formula in CRHM 04/14/20, as pressure in f2 needs be coverted from kPa to mb. + +CRHM 06/18/20 + + Adding debris-cover glacier melt and katabatic parameterization as glacier#5 in glacier module. + +CRHM 06/25/20 + + Adding update for variable "Albedo" in glacier module. + + if(GlacierMode[hh] == 1 && SWE[hh] <= 0.0) + Albedo[hh] = glacier_Albedo[hh]; + +CRHM 07/02/20 + + Adding lagT_used and lagSW_used variables for debris cover melt in glacier module. + +CRHM 02/01/21 + + Changing default value for parameter 'Wetlands_scaling_factor' from -1 to 1 in Soil module and adding more description for the parameter. + +CRHM 03/15/21 + + Adding conditional statements to restrict divided by zero error for 'Volumetric' and 'Volumetric_rechr' variables in Volumetric module. + +CRHM 04/12/21 + + Change float to long type for use_rho parameter in NewModules.h in SWEslope module. + +CRHM 08/11/21 + + Add fallstat_correction parameter in Volumetric module to allow correction for the estimated fallstat, with default value as 1. + + if(fallstat_correction[hh] >= 0.0) + fallstat[hh] = fallstat[hh]*fallstat_correction[hh]; + +CRHM 03/18/22 + + In Canopy, CanopyClearing, and CanopyClearingGap module, removing Gamma Distribution Correction term (1.0 + 3.0/Alpha + 2.0/sqr(Alpha)) + term in mean particle mass equation, correction as, + Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius; + + In evap module, /86400 to ra term for rs/ra in Penman-Monteith method, because rs is in d/m while ra is in s/m, correction as, + + evap[hh] = (delta(hru_t[hh])*Q*Global::Freq + (RHOa*Cp/ + (lambda(hru_t[hh])*1e3)*(estar(hru_t[hh]) - hru_ea[hh])/(ra/86400)))/ + (delta(hru_t[hh]) + gamma(Pa[hh], hru_t[hh])*(1.0 + rs[hh]/(ra/86400)))/ + Global::Freq; + +CRHM 03/21/22 + + In Canopy, CanopyClearing, and CanopyClearingGap module, invert the time step conversion term in weekly dimensionless unloading coefficient, + use unloading rate coefficient U = -log(c)/t for snow unloading determined by inverse function of c = e^(-Ut) = 0.678 based on Eq. 14 in Hedstrom and Pomeroy (1998) + correction as, + const float U = -1*log(0.678)/(24*7*Global::Freq/24); + + else if(IceBulbT < unload_t[hh]) // has to be at least one interval. Trip on half step + SUnload[hh] = Snow_load[hh]*U; // the dimensionless unloading coefficient already /interval, 21Mar2022 correction: use unloading rate coefficient U + +CRHM 04/06/22 + + Update description for parameters, variables and units in the modules below: + + longVt + netall + evap_Resist + evapD_Resist + ShuttleWallace + ShuttleWallaceD + crack + PrairieInfiltration + Ayers + Greencrack + GreenAmpt + frozen + frozenAyers + Soil + evapX + SoilX + SoilDetention + SoilPrairie + glacier + SWESlope + Netroute + Netroute_D + Netroute_M + Netroute_M_D + REW_route + REW_route2 + Canopy + CanopyClearing + CanopyClearingGap + NeedleLeaf + XG + Volumetric + tsurface + K_Estimate + interception + lake_evap \ No newline at end of file diff --git a/crhmcode/src/modules/ClassAyers.cpp b/crhmcode/src/modules/ClassAyers.cpp index 2e91b7f9e..f26593d7b 100644 --- a/crhmcode/src/modules/ClassAyers.cpp +++ b/crhmcode/src/modules/ClassAyers.cpp @@ -23,21 +23,21 @@ void ClassAyers::decl(void) { Description = "'Uses Ayers, 1959 for unfrozen soil. Snow is assumed to melt immediately on contact with the ground.'"; - declvar("infil", TDim::NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", TDim::NHRU,"interval rainfall infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", TDim::NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", TDim::NHRU, "cumulative rainfall infiltration", "(mm)", &cuminfil); - declvar("runoff", TDim::NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", TDim::NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", TDim::NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - declvar("snowinfil", TDim::NHRU, "infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", TDim::NHRU, "interval snowmelt infiltration", "(mm/int)", &snowinfil); - declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("meltrunoff", TDim::NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", TDim::NHRU, "interval snowmelt runoff", "(mm/int)", &meltrunoff); - declstatdiag("cummeltrunoff", TDim::NHRU, "melt runoff", "(mm)", &cummeltrunoff); + declstatdiag("cummeltrunoff", TDim::NHRU, "cumulative snowmelt runoff", "(mm)", &cummeltrunoff); decllocal("melt_int", TDim::NHRU, "interval melt from snowmelD", "(mm/int)", &melt_int); @@ -46,10 +46,10 @@ void ClassAyers::decl(void) { declparam("hru_area", TDim::NHRU, "[1]", "1e-6", "1e+09", "hru area", "(km^2)", &hru_area); declparam("texture", TDim::NHRU, "[1]", "1","4", - "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "(%)", &texture); + "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "()", &texture); declparam("groundcover", TDim::NHRU, "[1]", "1","6", - "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "(%)", &groundcover); + "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "()", &groundcover); declgetvar("*", "net_rain", "(mm/int)", &net_rain); diff --git a/crhmcode/src/modules/ClassCRHMCanopy.cpp b/crhmcode/src/modules/ClassCRHMCanopy.cpp index 3aa70fe79..360373764 100644 --- a/crhmcode/src/modules/ClassCRHMCanopy.cpp +++ b/crhmcode/src/modules/ClassCRHMCanopy.cpp @@ -85,7 +85,7 @@ void ClassCRHMCanopy::decl(void) { declobs("Qnsn", TDim::NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn); - declvar("Qnsn_Var", TDim::NHRU, "net all-wave at snow surface", "(W/m^2*int)", &Qnsn_Var); + declvar("Qnsn_Var", TDim::NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn_Var); declobs("Qsisn", TDim::NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn); @@ -97,11 +97,11 @@ void ClassCRHMCanopy::decl(void) { decldiag("k", TDim::NHRU, "extinction coefficient", "()", &k); - decldiag("Tauc", TDim::NHRU, "short-wave transmissivity", "(W/m^2)", &Tauc); + decldiag("Tauc", TDim::NHRU, "short-wave transmissivity", "()", &Tauc); decllocal("Pa", TDim::NHRU, "Average surface pressure", "(kPa)", &Pa); - declvar("ra", TDim::NHRU, "", "(s/m)", &ra); + declvar("ra", TDim::NHRU, "resistance", "(s/m)", &ra); declvar("drip_cpy", TDim::NHRU, "canopy drip", "(mm/int)", &drip_Cpy); @@ -109,11 +109,11 @@ void ClassCRHMCanopy::decl(void) { declvar("net_rain", TDim::NHRU, " direct_rain + drip", "(mm/int)", &net_rain); - declstatdiag("cum_net_rain", TDim::NHRU, " direct_rain + drip", "(mm)", &cum_net_rain); + declstatdiag("cum_net_rain", TDim::NHRU, "cumulative direct_rain + drip", "(mm)", &cum_net_rain); declvar("Subl_Cpy", TDim::NHRU, "canopy snow sublimation", "(mm/int)", &Subl_Cpy); - declstatdiag("cum_Subl_Cpy", TDim::NHRU, "canopy snow sublimation", "(mm)", &cum_Subl_Cpy); + declstatdiag("cum_Subl_Cpy", TDim::NHRU, "cumulative canopy snow sublimation", "(mm)", &cum_Subl_Cpy); decldiag("Pevap", TDim::NHRU, "used when ground is snow covered to calculate canopy evaporation (Priestley-Taylor)", "(mm)", &Pevap); @@ -121,11 +121,11 @@ void ClassCRHMCanopy::decl(void) { declstatvar("Snow_load", TDim::NHRU, "canopy snow load (timetep start)", "(mm)", &Snow_load); - declvar("direct_snow", TDim::NHRU, "snow 'direct' Thru", "(mm/int)", &direct_snow); + declvar("direct_snow", TDim::NHRU, "snow 'direct' through canopy", "(mm/int)", &direct_snow); - declvar("SUnload", TDim::NHRU, "unloaded canopy snow", "(mm)", &SUnload); + declvar("SUnload", TDim::NHRU, "unloaded canopy snow", "(mm/int)", &SUnload); - declvar("SUnload_H2O", TDim::NHRU, "unloaded canopy snow as water", "(mm)", &SUnload_H2O); + declvar("SUnload_H2O", TDim::NHRU, "unloaded canopy snow as water", "(mm/int)", &SUnload_H2O); declstatdiag("cum_SUnload_H2O", TDim::NHRU, "Cumulative unloaded canopy snow as water", "(mm)", &cum_SUnload_H2O); @@ -133,7 +133,7 @@ void ClassCRHMCanopy::decl(void) { declvar("net_snow", TDim::NHRU, "hru_snow minus interception", "(mm/int)", &net_snow); - declstatdiag("cum_net_snow", TDim::NHRU, "Cumulative Canopy unload ", "(mm)", &cum_net_snow); + declstatdiag("cum_net_snow", TDim::NHRU, "Cumulative hru_snow minus interception", "(mm)", &cum_net_snow); declvar("net_p", TDim::NHRU, "total precipitation after interception", "(mm/int)", &net_p); @@ -143,11 +143,11 @@ void ClassCRHMCanopy::decl(void) { declvar("intcp_evap", TDim::NHRU, "HRU Evaporation from interception", "(mm/int)", &intcp_evap); - declstatdiag("cum_intcp_evap", TDim::NHRU, "HRU Evaporation from interception", "(mm)", &cum_intcp_evap); + declstatdiag("cum_intcp_evap", TDim::NHRU, "Cumulative HRU Evaporation from interception", "(mm)", &cum_intcp_evap); - declvar("Qsisn_Var", TDim::NHRU, "incident short-wave at surface", "(W/m^2*int)", &Qsisn_Var); + declvar("Qsisn_Var", TDim::NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn_Var); - declvar("Qlisn_Var", TDim::NHRU, "incident long-wave at surface", "(W/m^2*int)", &Qlisn_Var); + declvar("Qlisn_Var", TDim::NHRU, "incident long-wave at surface", "(W/m^2)", &Qlisn_Var); // parameters: @@ -179,9 +179,9 @@ void ClassCRHMCanopy::decl(void) { declparam("unload_t_water", TDim::NHRU, "[4.0]", "-10.0", "20.0", "if ice-bulb temp >= t: canopy snow is unloaded as water", "(" + string(DEGREE_CELSIUS) + ")", &unload_t_water); - decldiagparam("Alpha_c", TDim::NHRU, "[0.1]", "0.05", "0.2", "canopy albedo", "()", &Alpha_c); + decldiagparam("Alpha_c", TDim::NHRU, "[0.1]", "0.05", "0.2", "canopy albedo, used for longwave-radiation enhancement estimation", "()", &Alpha_c); - decldiagparam("B_canopy", TDim::NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); + decldiagparam("B_canopy", TDim::NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter for longwave-radiation. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); } void ClassCRHMCanopy::init(void) { @@ -387,7 +387,10 @@ void ClassCRHMCanopy::run(void) { C1 = 1.0/(D*SvDens*Nu); Alpha = 5.0; - Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); + + // 18Mar2022: remove Gamma Distribution Correction term, *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); + Mpm = 4.0 / 3.0 * M_PI * PBSM_constants::DICE * Radius * Radius * Radius; + // sublimation rate of single 'ideal' ice sphere: @@ -422,8 +425,11 @@ void ClassCRHMCanopy::run(void) { double IceBulbT = hru_t[hh] - (Vi* Hs/1e6/ci); double Six_Hour_Divisor = Global::Freq/4.0; // used to unload over 6 hours + + // weekly dimensionless unloading coefficient -> to CRHM time interval + const double U = -1 * log(0.678) / (24 * 7 * Global::Freq / 24); + // 21Mar2022 correction: invert the term 24/Global::Freq, use unloading rate coefficient U = -log(c)/t for snow unloading determined by inverse function of c = e^(-Ut) = 0.678 based on Eq. 14 in Hedstrom and Pomeroy (1998) - const double c = 0.678/(24*7*24/Global::Freq); // weekly dimensionless unloading coefficient -> to CRHM time interval // determine whether canopy snow is unloaded: @@ -438,14 +444,19 @@ void ClassCRHMCanopy::run(void) { Snow_load[hh] -= SUnload[hh]; cum_SUnload[hh] += SUnload[hh]; } - else if(IceBulbT < unload_t[hh]){ // has to be at least one interval. Trip on half step - SUnload[hh] = Snow_load[hh]*c; // the dimensionless unloading coefficient already /interval - if(SUnload[hh] > Snow_load[hh]){ + else if(IceBulbT < unload_t[hh]) // has to be at least one interval. Trip on half step + { + SUnload[hh] = Snow_load[hh] * U; // the dimensionless unloading coefficient already /interval, 21Mar2022 correction: use unloading rate coefficient U + + if(SUnload[hh] > Snow_load[hh]) + { SUnload[hh] = Snow_load[hh]; Snow_load[hh] = 0.0; } else - Snow_load[hh] -= SUnload[hh]; + { + Snow_load[hh] -= SUnload[hh]; + } cum_SUnload[hh] += SUnload[hh]; } diff --git a/crhmcode/src/modules/ClassCRHMCanopyClearing.cpp b/crhmcode/src/modules/ClassCRHMCanopyClearing.cpp index 7a3b09e07..1647cd7c3 100644 --- a/crhmcode/src/modules/ClassCRHMCanopyClearing.cpp +++ b/crhmcode/src/modules/ClassCRHMCanopyClearing.cpp @@ -85,15 +85,15 @@ void ClassCRHMCanopyClearing::decl(void) { declobs("Qnsn", TDim::NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn); - declvar("Qnsn_Var", TDim::NHRU, "net all-wave at snow surface", "(W/m^2*int)", &Qnsn_Var); + declvar("Qnsn_Var", TDim::NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn_Var); declobs("Qsisn", TDim::NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn); - declvar("Qsisn_Var", TDim::NHRU, "incident short-wave at surface", "(W/m^2*int)", &Qsisn_Var); + declvar("Qsisn_Var", TDim::NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn_Var); declobs("Qlisn", TDim::NHRU, "incident long-wave at surface", "(W/m^2)", &Qlisn); - declvar("Qlisn_Var", TDim::NHRU, "incident short-wave at surface", "(W/m^2*int)", &Qlisn_Var); + declvar("Qlisn_Var", TDim::NHRU, "incident short-wave at surface", "(W/m^2)", &Qlisn_Var); declobs("Qlosn", TDim::NHRU, "reflected long-wave at surface", "(W/m^2)", &Qlosn); @@ -101,11 +101,11 @@ void ClassCRHMCanopyClearing::decl(void) { decldiag("k", TDim::NHRU, "extinction coefficient", "()", &k); - decldiag("Tauc", TDim::NHRU, "short-wave transmissivity", "(W/m^2)", &Tauc); + decldiag("Tauc", TDim::NHRU, "short-wave transmissivity", "()", &Tauc); decllocal("Pa", TDim::NHRU, "Average surface pressure", "(kPa)", &Pa); - declvar("ra", TDim::NHRU, "", "(s/m)", &ra); + declvar("ra", TDim::NHRU, "resistance", "(s/m)", &ra); declvar("drip_cpy", TDim::NHRU, "canopy drip", "(mm/int)", &drip_Cpy); @@ -113,11 +113,11 @@ void ClassCRHMCanopyClearing::decl(void) { declvar("net_rain", TDim::NHRU, " direct_rain + drip", "(mm/int)", &net_rain); - declstatdiag("cum_net_rain", TDim::NHRU, " direct_rain + drip", "(mm)", &cum_net_rain); + declstatdiag("cum_net_rain", TDim::NHRU, "cumulative direct_rain + drip", "(mm)", &cum_net_rain); declvar("Subl_Cpy", TDim::NHRU, "canopy snow sublimation", "(mm/int)", &Subl_Cpy); - declstatdiag("cum_Subl_Cpy", TDim::NHRU, "canopy snow sublimation", "(mm)", &cum_Subl_Cpy); + declstatdiag("cum_Subl_Cpy", TDim::NHRU, "cumulative canopy snow sublimation", "(mm)", &cum_Subl_Cpy); decldiag("Pevap", TDim::NHRU, "used when ground is snow covered to calculate canopy evaporation (Priestley-Taylor)", "(mm)", &Pevap); @@ -125,7 +125,7 @@ void ClassCRHMCanopyClearing::decl(void) { declstatvar("Snow_load", TDim::NHRU, "canopy snow load (timetep start)", "(mm)", &Snow_load); - declvar("direct_snow", TDim::NHRU, "snow 'direct' Thru", "(mm/int)", &direct_snow); + declvar("direct_snow", TDim::NHRU, "snow 'direct' through canopy", "(mm/int)", &direct_snow); declvar("SUnload", TDim::NHRU, "unloaded canopy snow", "(mm)", &SUnload); @@ -137,7 +137,7 @@ void ClassCRHMCanopyClearing::decl(void) { declvar("net_snow", TDim::NHRU, "hru_snow minus interception", "(mm/int)", &net_snow); - declstatdiag("cum_net_snow", TDim::NHRU, "Cumulative Canopy unload ", "(mm)", &cum_net_snow); + declstatdiag("cum_net_snow", TDim::NHRU, "Cumulative hru_snow minus interception", "(mm)", &cum_net_snow); declvar("net_p", TDim::NHRU, "total precipitation after interception", "(mm/int)", &net_p); @@ -147,7 +147,7 @@ void ClassCRHMCanopyClearing::decl(void) { declvar("intcp_evap", TDim::NHRU, "HRU Evaporation from interception", "(mm/int)", &intcp_evap); - declstatdiag("cum_intcp_evap", TDim::NHRU, "HRU Evaporation from interception", "(mm)", &cum_intcp_evap); + declstatdiag("cum_intcp_evap", TDim::NHRU, "Cumulative HRU Evaporation from interception", "(mm)", &cum_intcp_evap); // parameters: @@ -181,9 +181,9 @@ void ClassCRHMCanopyClearing::decl(void) { declparam("CanopyClearing", TDim::NHRU, "[0]", "0", "1", "canopy - 0/clearing - 1", "()", &CanopyClearing); - decldiagparam("Alpha_c", TDim::NHRU, "[0.1]", "0.05", "0.2", "canopy albedo", "()", &Alpha_c); + decldiagparam("Alpha_c", TDim::NHRU, "[0.1]", "0.05", "0.2", "canopy albedo, used for longwave-radiation enhancement estimation", "()", &Alpha_c); - decldiagparam("B_canopy", TDim::NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); + decldiagparam("B_canopy", TDim::NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter for longwave-radiation. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); } void ClassCRHMCanopyClearing::init(void) { @@ -405,7 +405,7 @@ void ClassCRHMCanopyClearing::run(void) { C1 = 1.0/(D*SvDens*Nu); Alpha = 5.0; - Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); + Mpm = 4.0 / 3.0 * M_PI * PBSM_constants::DICE * Radius * Radius * Radius; // 18Mar2022: remove Gamma Distribution Correction term, *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); // sublimation rate of single 'ideal' ice sphere: @@ -441,7 +441,8 @@ void ClassCRHMCanopyClearing::run(void) { double IceBulbT = hru_t[hh] - (Vi* Hs/1e6/ci); double Six_Hour_Divisor = Global::Freq/4.0; // used to unload over 6 hours - const double c = 0.678/(24*7*24/Global::Freq); // weekly dimensionless unloading coefficient -> to CRHM time interval + const float U = -1 * log(0.678) / (24 * 7 * Global::Freq / 24); // weekly dimensionless unloading coefficient -> to CRHM time interval + // 21Mar2022 correction: invert the term 24/Global::Freq, use unloading rate coefficient U = -log(c)/t for snow unloading determined by inverse function of c = e^(-Ut) = 0.678 based on Eq. 14 in Hedstrom and Pomeroy (1998) // determine whether canopy snow is unloaded: @@ -457,7 +458,7 @@ void ClassCRHMCanopyClearing::run(void) { cum_SUnload[hh] += SUnload[hh]; } else if(IceBulbT < unload_t[hh]){ // has to be at least one interval. Trip on half step - SUnload[hh] = Snow_load[hh]*c; // the dimensionless unloading coefficient already /interval + SUnload[hh] = Snow_load[hh] * U; // the dimensionless unloading coefficient already /interval, 21Mar2022 correction: use unloading rate coefficient U if(SUnload[hh] > Snow_load[hh]){ SUnload[hh] = Snow_load[hh]; Snow_load[hh] = 0.0; diff --git a/crhmcode/src/modules/ClassCRHMCanopyClearingGap.cpp b/crhmcode/src/modules/ClassCRHMCanopyClearingGap.cpp index 775e74eef..bcada1dc4 100644 --- a/crhmcode/src/modules/ClassCRHMCanopyClearingGap.cpp +++ b/crhmcode/src/modules/ClassCRHMCanopyClearingGap.cpp @@ -90,15 +90,15 @@ void ClassCRHMCanopyClearingGap::decl(void) { declobs("Qnsn", TDim::NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn); - declvar("Qnsn_Var", TDim::NHRU, "net all-wave at snow surface", "(W/m^2*int)", &Qnsn_Var); + declvar("Qnsn_Var", TDim::NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn_Var); declobs("Qsisn", TDim::NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn); - declvar("Qsisn_Var", TDim::NHRU, "incident short-wave at surface", "(W/m^2*int)", &Qsisn_Var); + declvar("Qsisn_Var", TDim::NHRU, "incident short-wave at surface", "(W/m^2)", &Qsisn_Var); declobs("Qlisn", TDim::NHRU, "incident long-wave at surface", "(W/m^2)", &Qlisn); - declvar("Qlisn_Var", TDim::NHRU, "incident long-wave at surface", "(W/m^2*int)", &Qlisn_Var); + declvar("Qlisn_Var", TDim::NHRU, "incident long-wave at surface", "(W/m^2)", &Qlisn_Var); declobs("Qlosn", TDim::NHRU, "reflected long-wave at surface", "(W/m^2)", &Qlosn); @@ -106,11 +106,11 @@ void ClassCRHMCanopyClearingGap::decl(void) { decldiag("k", TDim::NHRU, "extinction coefficient", "()", &k); - decldiag("Tauc", TDim::NHRU, "short-wave transmissivity", "(W/m^2)", &Tauc); + decldiag("Tauc", TDim::NHRU, "short-wave transmissivity", "", &Tauc); decllocal("Pa", TDim::NHRU, "Average surface pressure", "(kPa)", &Pa); - declvar("ra", TDim::NHRU, "", "(s/m)", &ra); + declvar("ra", TDim::NHRU, "resistance", "(s/m)", &ra); declvar("drip_cpy", TDim::NHRU, "canopy drip", "(mm/int)", &drip_Cpy); @@ -118,11 +118,11 @@ void ClassCRHMCanopyClearingGap::decl(void) { declvar("net_rain", TDim::NHRU, " direct_rain + drip", "(mm/int)", &net_rain); - declstatdiag("cum_net_rain", TDim::NHRU, " direct_rain + drip", "(mm)", &cum_net_rain); + declstatdiag("cum_net_rain", TDim::NHRU, "cumulative direct_rain + drip", "(mm)", &cum_net_rain); declvar("Subl_Cpy", TDim::NHRU, "canopy snow sublimation", "(mm/int)", &Subl_Cpy); - declstatdiag("cum_Subl_Cpy", TDim::NHRU, "canopy snow sublimation", "(mm)", &cum_Subl_Cpy); + declstatdiag("cum_Subl_Cpy", TDim::NHRU, "cumulative canopy snow sublimation", "(mm)", &cum_Subl_Cpy); decldiag("Pevap", TDim::NHRU, "used when ground is snow covered to calculate canopy evaporation (Priestley-Taylor)", "(mm)", &Pevap); @@ -130,7 +130,7 @@ void ClassCRHMCanopyClearingGap::decl(void) { declstatvar("Snow_load", TDim::NHRU, "canopy snow load (timetep start)", "(mm)", &Snow_load); - declvar("direct_snow", TDim::NHRU, "snow 'direct' Thru", "(mm/int)", &direct_snow); + declvar("direct_snow", TDim::NHRU, "snow 'direct' through canopy", "(mm/int)", &direct_snow); declvar("SUnload", TDim::NHRU, "unloaded canopy snow", "(mm)", &SUnload); @@ -142,7 +142,7 @@ void ClassCRHMCanopyClearingGap::decl(void) { declvar("net_snow", TDim::NHRU, "hru_snow minus interception", "(mm/int)", &net_snow); - declstatdiag("cum_net_snow", TDim::NHRU, "Cumulative Canopy unload ", "(mm)", &cum_net_snow); + declstatdiag("cum_net_snow", TDim::NHRU, "Cumulative hru_snow minus interception", "(mm)", &cum_net_snow); declvar("net_p", TDim::NHRU, "total precipitation after interception", "(mm/int)", &net_p); @@ -152,7 +152,7 @@ void ClassCRHMCanopyClearingGap::decl(void) { declvar("intcp_evap", TDim::NHRU, "HRU Evaporation from interception", "(mm/int)", &intcp_evap); - declstatdiag("cum_intcp_evap", TDim::NHRU, "HRU Evaporation from interception", "(mm)", &cum_intcp_evap); + declstatdiag("cum_intcp_evap", TDim::NHRU, "Cumulative HRU Evaporation from interception", "(mm)", &cum_intcp_evap); // parameters: @@ -190,9 +190,9 @@ void ClassCRHMCanopyClearingGap::decl(void) { declparam("CanopyClearing", TDim::NHRU, "[0]", "0", "2", "canopy - 0/clearing - 1/gap - 2", "()", &CanopyClearing); - decldiagparam("Alpha_c", TDim::NHRU, "[0.1]", "0.05", "0.2", "canopy albedo", "()", &Alpha_c); + decldiagparam("Alpha_c", TDim::NHRU, "[0.1]", "0.05", "0.2", "canopy albedo, used for longwave-radiation enhancement estimation", "()", &Alpha_c); - decldiagparam("B_canopy", TDim::NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); + decldiagparam("B_canopy", TDim::NHRU, "[0.038]", "0.0", "0.2", "canopy enhancement parameter for longwave-radiation. Suggestions are Colorado - 0.023 and Alberta - 0.038", "()", &B_canopy); } void ClassCRHMCanopyClearingGap::init(void) { @@ -482,8 +482,7 @@ void ClassCRHMCanopyClearingGap::run(void){ C1 = 1.0/(D*SvDens*Nu); Alpha = 5.0; - Mpm = 4.0/3.0 * M_PI * PBSM_constants::DICE * Radius*Radius*Radius *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); - + Mpm = 4.0 / 3.0 * M_PI * PBSM_constants::DICE * Radius * Radius * Radius; // 18Mar2022: remove Gamma Distribution Correction term, *(1.0 + 3.0/Alpha + 2.0/sqr(Alpha)); // sublimation rate of single 'ideal' ice sphere: double Vs = (2.0* M_PI* Radius*Sigma2 - SStar* J)/(Hs* J + C1)/Mpm; @@ -518,8 +517,8 @@ void ClassCRHMCanopyClearingGap::run(void){ double IceBulbT = hru_t[hh] - (Vi* Hs/1e6/ci); double Six_Hour_Divisor = Global::Freq/4.0; // used to unload over 6 hours - const double c = 0.678/(24*7*24/Global::Freq); // weekly dimensionless unloading coefficient -> to CRHM time interval - + const float U = -1 * log(0.678) / (24 * 7 * Global::Freq / 24); // weekly dimensionless unloading coefficient -> to CRHM time interval + // 21Mar2022 correction: invert the term 24/Global::Freq, use unloading rate coefficient U = -log(c)/t for snow unloading determined by inverse function of c = e^(-Ut) = 0.678 based on Eq. 14 in Hedstrom and Pomeroy (1998) // determine whether canopy snow is unloaded: if(IceBulbT >= unload_t_water[hh]){ @@ -534,7 +533,7 @@ void ClassCRHMCanopyClearingGap::run(void){ cum_SUnload[hh] += SUnload[hh]; } else if(IceBulbT < unload_t[hh]){ // has to be at least one interval. Trip on half step - SUnload[hh] = Snow_load[hh]*c; // the dimensionless unloading coefficient already /interval + SUnload[hh] = Snow_load[hh] * U; // the dimensionless unloading coefficient already /interval, 21Mar2022 correction: use unloading rate coefficient U if(SUnload[hh] > Snow_load[hh]){ SUnload[hh] = Snow_load[hh]; Snow_load[hh] = 0.0; diff --git a/crhmcode/src/modules/ClassGreenAmpt.cpp b/crhmcode/src/modules/ClassGreenAmpt.cpp index 892acbcf9..78a2cfefd 100644 --- a/crhmcode/src/modules/ClassGreenAmpt.cpp +++ b/crhmcode/src/modules/ClassGreenAmpt.cpp @@ -25,36 +25,36 @@ void ClassGreenAmpt::decl(void) { Description = "'Summer Green Ampt model.'"; - declvar("infil", TDim::NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", TDim::NHRU,"Potential amount of rain water infiltrating the soil on each HRU", "(mm/int)", &infil); - declstatdiag("cuminfil", TDim::NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", TDim::NHRU, "cumulative potential rain water infiltration on each HRU", "(mm)", &cuminfil); declvar("runoff", TDim::NHRU, "rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", TDim::NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - declvar("snowinfil", TDim::NHRU, "infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", TDim::NHRU, "interval snowmelt infiltration", "(mm/int)", &snowinfil); - declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("meltrunoff", TDim::NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", TDim::NHRU, "interval snowmelt runoff", "(mm/int)", &meltrunoff); - declstatvar("cummeltrunoff", TDim::NHRU, "cumulative melt runoff", "(mm/int)", &cummeltrunoff); + declstatvar("cummeltrunoff", TDim::NHRU, "cumulative snowmelt runoff", "(mm/int)", &cummeltrunoff); - decllocal("k", TDim::NHRU, "(mm/h)", "()", &k); + decllocal("k", TDim::NHRU, "saturated hydraulic conductivity", "(mm/h)", &k); - declstatdiag("F0", TDim::NHRU, "last HRU cumulative infiltration", "(mm)", &F0); + declstatdiag("F0", TDim::NHRU, "cumulative infiltation at the beginning of the time interval", "(mm)", &F0); - decllocal("f0", TDim::NHRU, "", "(mm/h)", &f0); + decllocal("f0", TDim::NHRU, "infiltration rate at the beginning of the time interval", "(mm/h)", &f0); - declstatdiag("F1", TDim::NHRU, "HRU cumulative infiltration", "(mm)", &F1); + declstatdiag("F1", TDim::NHRU, "cumulative infiltration at the end of the time interval", "(mm)", &F1); - decllocal("f1", TDim::NHRU, "", "(mm/h)", &f1); + decllocal("f1", TDim::NHRU, "infiltration rate at the end of the time interval", "(mm/h)", &f1); - decllocal("dthbot", TDim::NHRU, "", "()", &dthbot); + decllocal("dthbot", TDim::NHRU, "fraction value of soil water deficit", "()", &dthbot); - decllocal("psidthbot", TDim::NHRU, "", "(mm)", &psidthbot); + decllocal("psidthbot", TDim::NHRU, "capillary suction at the fraction value of soil water deficit", "(mm)", &psidthbot); declparam("basin_area", TDim::BASIN, "3", "1e-6", "1e+09", "total basin area", "(km^2)", &basin_area); diff --git a/crhmcode/src/modules/ClassGreencrack.cpp b/crhmcode/src/modules/ClassGreencrack.cpp index 4edf5c26b..87d8cd125 100644 --- a/crhmcode/src/modules/ClassGreencrack.cpp +++ b/crhmcode/src/modules/ClassGreencrack.cpp @@ -24,19 +24,19 @@ void ClassGreencrack::decl(void) { Description = "'Handles summer using Green Ampt and frozen soil infiltration using Granger et al. 1984; Gray et al., 1986.'"; - declvar("infil", TDim::NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", TDim::NHRU,"interval rainfall infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", TDim::NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", TDim::NHRU, "cumulative rainfall infiltration", "(mm)", &cuminfil); - declvar("snowinfil", TDim::NHRU, "infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", TDim::NHRU, "daily snowmelt infiltration", "(mm/d)", &snowinfil); - declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("runoff", TDim::NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", TDim::NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", TDim::NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - declvar("meltrunoff", TDim::NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", TDim::NHRU, "daily snowmelt runoff", "(mm/d)", &meltrunoff); declstatdiag("cummeltrunoff", TDim::NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); @@ -49,21 +49,21 @@ void ClassGreencrack::decl(void) { decllocal("RainOnSnowA", TDim::NHRU, "accumulated rain on snow", "(mm)", &RainOnSnowA); - decllocal("k", TDim::NHRU, "(mm/h)", "()", &k); + decllocal("k", TDim::NHRU, "saturated hydraulic conductivity", "(mm/h)", &k); - decllocal("F0", TDim::NHRU, "last HRU cumulative infiltration", "(mm)", &F0); + decllocal("F0", TDim::NHRU, "cumulative infiltation at the beginning of the time interval", "(mm)", &F0); - decllocal("f0", TDim::NHRU, "", "(mm/h)", &f0); + decllocal("f0", TDim::NHRU, "infiltration rate at the beginning of the time interval", "(mm/h)", &f0); - decllocal("F1", TDim::NHRU, "HRU cumulative infiltration", "(mm)", &F1); + decllocal("F1", TDim::NHRU, "cumulative infiltration at the end of the time interval", "(mm)", &F1); - decllocal("f1", TDim::NHRU, "", "(mm/h)", &f1); + decllocal("f1", TDim::NHRU, "infiltration rate at the end of the time interval", "(mm/h)", &f1); - decllocal("dthbot", TDim::NHRU, "", "()", &dthbot); + decllocal("dthbot", TDim::NHRU, "fraction value of soil water deficit", "()", &dthbot); - decllocal("psidthbot", TDim::NHRU, "", "(mm)", &psidthbot); + decllocal("psidthbot", TDim::NHRU, "capillary suction at the fraction value of soil water deficit", "(mm)", &psidthbot); - decllocal("timer", TDim::NHRU, "", "(d)", &timer); + decllocal("timer", TDim::NHRU, "indicator for limited infiltration case during Major melt infiltration", "(d)", &timer); declparam("basin_area", TDim::BASIN, "3", "1e-6", "1e+09", "total basin area", "(km^2)", &basin_area); diff --git a/crhmcode/src/modules/ClassK_Estimate.cpp b/crhmcode/src/modules/ClassK_Estimate.cpp index 455a44c46..cfdbd586d 100644 --- a/crhmcode/src/modules/ClassK_Estimate.cpp +++ b/crhmcode/src/modules/ClassK_Estimate.cpp @@ -41,11 +41,11 @@ void ClassK_Estimate::decl(void) { declputparam("*", "gw_K", "(mm/d)", &gw_K); declvar("rechr_ssr_K_V", TDim::NHRU, "ssr drainage factor from recharge", "(mm/d)", &rechr_ssr_K_V); - declvar("lower_ssr_K_V", TDim::NHRU, "ssr drainage factor from soil column", "(mm/d)", &lower_ssr_K_V); + declvar("lower_ssr_K_V", TDim::NHRU, "ssr drainage factor from lower soil layer", "(mm/d)", &lower_ssr_K_V); declvar("Sd_ssr_K_V", TDim::NHRU, "depression storage ssr drainage factor", "(mm/d)", &Sd_ssr_K_V); declvar("Sd_gw_K_V", TDim::NHRU, "depression storage gw drainage factor", "(mm/d)", &Sd_gw_K_V); declvar("soil_gw_K_V", TDim::NHRU, "The maximum amount of the soil water excess for an HRU that is routed directly to the associated groundwater reservoir each day", "(mm/d)", &soil_gw_K_V); - declvar("gw_K_V", TDim::NHRU, "ground water drainage factor from gw reservoir each day", "(m/s)", &gw_K_V); + declvar("gw_K_V", TDim::NHRU, "ground water drainage factor from gw reservoir each day", "(mm/d)", &gw_K_V); declparam("Inhibit_K_set", TDim::NHRU, "[0]", "0", "63", "Inhibit setting of rechr_ssr_K/lower_ssr_K/Sd_ssr_K/Sd_gw_K/soil_gw_K/gw_K parameters using 1/2/4/8/16/32", "()", &Inhibit_K_set); diff --git a/crhmcode/src/modules/ClassLongVt.cpp b/crhmcode/src/modules/ClassLongVt.cpp index 8df3229f4..564f75b4d 100644 --- a/crhmcode/src/modules/ClassLongVt.cpp +++ b/crhmcode/src/modules/ClassLongVt.cpp @@ -31,9 +31,9 @@ ClassLongVt* ClassLongVt::klone(string name) const{ declvar("tau", TDim::NHRU, "Atmospheric transmissivity = S/Sextra", "()", &tau); - declvar("Qli_Var", TDim::NHRU, "calculated incoming long", "(W/m^2)", &Qli_Var); + declvar("Qli_Var", TDim::NHRU, "calculated incoming long-wave in open environment", "(W/m^2)", &Qli_Var); - declvar("QliVt_Var", TDim::NHRU, "calculated incoming long in open environment", "(W/m^2)", &QliVt_Var); + declvar("QliVt_Var", TDim::NHRU, "calculated incoming long-wave in rugged environment", "(W/m^2)", &QliVt_Var); diff --git a/crhmcode/src/modules/ClassNeedle.cpp b/crhmcode/src/modules/ClassNeedle.cpp index 97b7a05c1..4f2fb62cd 100644 --- a/crhmcode/src/modules/ClassNeedle.cpp +++ b/crhmcode/src/modules/ClassNeedle.cpp @@ -72,13 +72,13 @@ void ClassNeedle::decl(void) { decldiag("k", TDim::NHRU, "extinction coefficient", "()", &k); - decldiag("Tauc", TDim::NHRU, "short-wave transmissivity", "(W/m^2)", &Tauc); + decldiag("Tauc", TDim::NHRU, "short-wave transmissivity", "()", &Tauc); decllocal("Pa", TDim::NHRU, "Average surface pressure", "(kPa)", &Pa); declvar("ra", TDim::NHRU, "", "(s/m)", &ra); - declvar("Qnsn_Var", TDim::NHRU, "net all-wave at snow surface", "(W/m^2*int)", &Qnsn_Var); + declvar("Qnsn_Var", TDim::NHRU, "net all-wave at snow surface", "(W/m^2)", &Qnsn_Var); declparam("hru_elev", TDim::NHRU, "[637]", "0.0", "100000.0", "altitude", "(m)", &hru_elev); diff --git a/crhmcode/src/modules/ClassNetroute.cpp b/crhmcode/src/modules/ClassNetroute.cpp index a997815a3..d2305e75c 100644 --- a/crhmcode/src/modules/ClassNetroute.cpp +++ b/crhmcode/src/modules/ClassNetroute.cpp @@ -42,7 +42,7 @@ void ClassNetroute::decl(void) { decldiag("outflow_diverted", TDim::NHRU, "HRU outflow diverted to another HRU", "(mm*km^2/int)", &outflow_diverted); - declstatdiag("cumoutflow_diverted", TDim::NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2/int)", &cumoutflow_diverted); + declstatdiag("cumoutflow_diverted", TDim::NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2)", &cumoutflow_diverted); declstatdiag("cum_to_Sd", TDim::NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm)", &cum_to_Sd); @@ -58,25 +58,25 @@ void ClassNetroute::decl(void) { decldiag("gwoutflow_diverted", TDim::NHRU, "HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwoutflow_diverted); - declstatdiag("gwcumoutflow_diverted", TDim::NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwcumoutflow_diverted); + declstatdiag("gwcumoutflow_diverted", TDim::NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2)", &gwcumoutflow_diverted); - declvar("ssrinflow", TDim::NHRU, "inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); + declvar("ssrinflow", TDim::NHRU, "subsurface inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); - declstatdiag("ssrcuminflow", TDim::NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); + declstatdiag("ssrcuminflow", TDim::NHRU, "cumulative subsurface inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); - declvar("ssroutflow", TDim::NHRU, "HRU outflow", "(mm*km^2/int)", &ssroutflow); + declvar("ssroutflow", TDim::NHRU, "HRU subsurface outflow", "(mm*km^2/int)", &ssroutflow); - declstatdiag("ssrcumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &ssrcumoutflow); + declstatdiag("ssrcumoutflow", TDim::NHRU, "cumulative HRU subsurface outflow", "(mm*km^2)", &ssrcumoutflow); declstatdiag("HRU_cumbasinflow", TDim::NHRU, "cumulative HRU to basinflow", "(mm*km^2)", &HRU_cumbasinflow); - declvar("runinflow", TDim::NHRU, "inflow from other HRUs", "(mm*km^2/int)", &runinflow); + declvar("runinflow", TDim::NHRU, "overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2/int)", &runinflow); - declstatdiag("runcuminflow", TDim::NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &runcuminflow); + declstatdiag("runcuminflow", TDim::NHRU, "cumulative overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2)", &runcuminflow); - declvar("runoutflow", TDim::NHRU, "HRU outflow", "(mm*km^2/int)", &runoutflow); + declvar("runoutflow", TDim::NHRU, "HRU overland outflow", "(mm*km^2/int)", &runoutflow); - declstatdiag("runcumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &runcumoutflow); + declstatdiag("runcumoutflow", TDim::NHRU, "cumulative HRU overland outflow", "(mm*km^2)", &runcumoutflow); declstatdiag("cum_preferential_flow_to_gw", TDim::NHRU, "cumulative other HRU's runoff to gw of this HRU via preferential flow path", "(mm)", &cum_preferential_flow_to_gw); @@ -95,9 +95,9 @@ void ClassNetroute::decl(void) { declstatdiag("cumbasingw", TDim::BASIN, "cumulative basin groundwater outflow", "(m^3)", &cumbasingw); - decllocal("soil_ssr_Buf", TDim::NHRU, "buffer subsurface runoff", "(mm/d)", &soil_ssr_Buf); + decllocal("soil_ssr_Buf", TDim::NHRU, "buffer subsurface runoff from soil, i.e. soil_ssr_Buf is from soil_ssr", "(mm/int)", &soil_ssr_Buf); - decllocal("soil_runoff_Buf", TDim::NHRU, "buffer rain runoff", "(mm/d)", &soil_runoff_Buf); + decllocal("soil_runoff_Buf", TDim::NHRU, "buffer overland runoff from soil, i.e. soil_runoff_Buf is from soil_runoff", "(mm/int)", &soil_runoff_Buf); decllocal("soil_gw_Buf", TDim::NHRU, "buffer soil_gw(gw_flow) runoff", "(mm/d)", &soil_gw_Buf); diff --git a/crhmcode/src/modules/ClassNetroute_D.cpp b/crhmcode/src/modules/ClassNetroute_D.cpp index be7340854..f283d57fc 100644 --- a/crhmcode/src/modules/ClassNetroute_D.cpp +++ b/crhmcode/src/modules/ClassNetroute_D.cpp @@ -41,11 +41,11 @@ void ClassNetroute_D::decl(void) { decldiag("outflow_diverted", TDim::NHRU, "HRU outflow diverted to another HRU", "(mm*km^2/int)", &outflow_diverted); - declstatdiag("cumoutflow_diverted", TDim::NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2/int)", &cumoutflow_diverted); + declstatdiag("cumoutflow_diverted", TDim::NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2)", &cumoutflow_diverted); decldiag("gwoutflow_diverted", TDim::NHRU, "HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwoutflow_diverted); - declstatdiag("gwcumoutflow_diverted", TDim::NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwcumoutflow_diverted); + declstatdiag("gwcumoutflow_diverted", TDim::NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2)", &gwcumoutflow_diverted); declstatdiag("cum_to_Sd", TDim::NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm)", &cum_to_Sd); @@ -59,13 +59,13 @@ void ClassNetroute_D::decl(void) { declstatdiag("gwcumoutflow", TDim::NHRU, "cumulative HRU gw outflow", "(mm*km^2)", &gwcumoutflow); - declvar("ssrinflow", TDim::NHRU, "inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); + declvar("ssrinflow", TDim::NHRU, "subsurface inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); - declstatdiag("ssrcuminflow", TDim::NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); + declstatdiag("ssrcuminflow", TDim::NHRU, "cumulative subsurface inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); - declvar("ssroutflow", TDim::NHRU, "HRU outflow", "(mm*km^2/int)", &ssroutflow); + declvar("ssroutflow", TDim::NHRU, "HRU subsurface outflow", "(mm*km^2/int)", &ssroutflow); - declstatdiag("ssrcumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &ssrcumoutflow); + declstatdiag("ssrcumoutflow", TDim::NHRU, "cumulative HRU subsurface outflow", "(mm*km^2)", &ssrcumoutflow); declstatdiag("HRU_cumbasinflow", TDim::NHRU, "cumulative HRU to basinflow", "(mm*km^2)", &HRU_cumbasinflow); @@ -74,13 +74,13 @@ void ClassNetroute_D::decl(void) { declparam("preferential_flow", TDim::NHRU, "[0]", "0", "1","0 - no preferential and remain as runoff routing to other HRU, 1 - preferential flow and route runoff to other HRU's gw.", "()", &preferential_flow); - declvar("runinflow", TDim::NHRU, "inflow from other HRUs", "(mm*km^2/int)", &runinflow); + declvar("runinflow", TDim::NHRU, "overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2/int)", &runinflow); - declstatdiag("runcuminflow", TDim::NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &runcuminflow); + declstatdiag("runcuminflow", TDim::NHRU, "cumulative overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2)", &runcuminflow); - declvar("runoutflow", TDim::NHRU, "HRU outflow", "(mm*km^2/int)", &runoutflow); + declvar("runoutflow", TDim::NHRU, "HRU overland outflow", "(mm*km^2/int)", &runoutflow); - declstatdiag("runcumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &runcumoutflow); + declstatdiag("runcumoutflow", TDim::NHRU, "cumulative HRU overland outflow", "(mm*km^2)", &runcumoutflow); declstatdiag("cumscaling_boost", TDim::NHRU, "cumulative amout inflow boosted", "(mm*km^2)", &cumscaling_boost); @@ -96,11 +96,11 @@ void ClassNetroute_D::decl(void) { declstatdiag("cumbasingw", TDim::BASIN, "cumulative basin groundwater outflow", "(m^3)", &cumbasingw); - decllocal("soil_ssr_Buf", TDim::NHRU, "buffer subsurface runoff", "(mm/d)", &soil_ssr_Buf); + decllocal("soil_ssr_Buf", TDim::NHRU, "buffer subsurface runoff from soil, i.e. soil_ssr_Buf is from soil_ssr", "(mm/int)", &soil_ssr_Buf); - decllocal("soil_runoff_Buf", TDim::NHRU, "buffer rain runoff", "(mm/d)", &soil_runoff_Buf); + decllocal("soil_runoff_Buf", TDim::NHRU, "buffer overland runoff from soil, i.e. soil_runoff_Buf is from soil_runoff", "(mm/int)", &soil_runoff_Buf); - decllocal("soil_gw_Buf", TDim::NHRU, "buffer rain runoff", "(mm/d)", &soil_gw_Buf); + decllocal("soil_gw_Buf", TDim::NHRU, "buffer soil_gw(gw_flow) from soil, i.e. soil_gw_Buf is from gw_flow = soil_gw", "(mm/int)", &soil_gw_Buf); decllocal("distrib_sum", TDim::NHRU, "HRU distribution sum", "()", &distrib_sum); diff --git a/crhmcode/src/modules/ClassNetroute_M.cpp b/crhmcode/src/modules/ClassNetroute_M.cpp index 9b51919e1..077c83f7c 100644 --- a/crhmcode/src/modules/ClassNetroute_M.cpp +++ b/crhmcode/src/modules/ClassNetroute_M.cpp @@ -40,9 +40,9 @@ void ClassNetroute_M::decl(void) { declstatdiag("cumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &cumoutflow); - decldiag("outflow_diverted", TDim::NHRU, "HRU outflow diverted to another HRU", "(mm*km^2/int)", &outflow_diverted); + decldiag("outflow_diverted", TDim::NHRU, "HRU outflow diverted to another HRU", "(mm*km^2)", &outflow_diverted); - declstatdiag("cumoutflow_diverted", TDim::NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm*km^2/int)", &cumoutflow_diverted); + declstatdiag("cumoutflow_diverted", TDim::NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm*km^2)", &cumoutflow_diverted); declstatdiag("cum_to_Sd", TDim::NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm)", &cum_to_Sd); @@ -58,25 +58,25 @@ void ClassNetroute_M::decl(void) { decldiag("gwoutflow_diverted", TDim::NHRU, "HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwoutflow_diverted); - declstatdiag("gwcumoutflow_diverted", TDim::NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwcumoutflow_diverted); + declstatdiag("gwcumoutflow_diverted", TDim::NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2)", &gwcumoutflow_diverted); - declvar("ssrinflow", TDim::NHRU, "inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); + declvar("ssrinflow", TDim::NHRU, "subsurface inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); - declstatdiag("ssrcuminflow", TDim::NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); + declstatdiag("ssrcuminflow", TDim::NHRU, "cumulative subsurface inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); - declvar("ssroutflow", TDim::NHRU, "HRU outflow", "(mm*km^2/int)", &ssroutflow); + declvar("ssroutflow", TDim::NHRU, "HRU subsurface outflow", "(mm*km^2/int)", &ssroutflow); - declstatdiag("ssrcumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &ssrcumoutflow); + declstatdiag("ssrcumoutflow", TDim::NHRU, "cumulative HRU subsurface outflow", "(mm*km^2)", &ssrcumoutflow); declstatdiag("HRU_cumbasinflow", TDim::NHRU, "cumulative HRU to basinflow", "(mm*km^2)", &HRU_cumbasinflow); - declvar("runinflow", TDim::NHRU, "inflow from other HRUs", "(mm*km^2/int)", &runinflow); + declvar("runinflow", TDim::NHRU, "overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2/int)", &runinflow); - declstatdiag("runcuminflow", TDim::NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &runcuminflow); + declstatdiag("runcuminflow", TDim::NHRU, "cumulative overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2)", &runcuminflow); - declvar("runoutflow", TDim::NHRU, "HRU outflow", "(mm*km^2/int)", &runoutflow); + declvar("runoutflow", TDim::NHRU, "HRU overland outflow", "(mm*km^2/int)", &runoutflow); - declstatdiag("runcumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &runcumoutflow); + declstatdiag("runcumoutflow", TDim::NHRU, "cumulative HRU overland outflow", "(mm*km^2)", &runcumoutflow); declstatdiag("cum_preferential_flow_to_gw", TDim::NHRU, "cumulative other HRU's runoff to gw of this HRU via preferential flow path", "(mm)", &cum_preferential_flow_to_gw); @@ -95,14 +95,13 @@ void ClassNetroute_M::decl(void) { declstatdiag("cumbasingw", TDim::BASIN, "cumulative basin groundwater outflow", "(m^3)", &cumbasingw); - decllocal("soil_ssr_Buf", TDim::NHRU, "buffer subsurface runoff", "(mm/d)", &soil_ssr_Buf); + decllocal("soil_ssr_Buf", TDim::NHRU, "buffer subsurface runoff from soil, i.e. soil_ssr_Buf is from soil_ssr", "(mm/int)", &soil_ssr_Buf); - decllocal("soil_runoff_Buf", TDim::NHRU, "buffer rain runoff", "(mm/d)", &soil_runoff_Buf); + decllocal("soil_runoff_Buf", TDim::NHRU, "buffer overland runoff from soil, i.e. soil_runoff_Buf is from soil_runoff", "(mm/int)", &soil_runoff_Buf); - decllocal("soil_gw_Buf", TDim::NHRU, "buffer rain runoff", "(mm/d)", &soil_gw_Buf); - - decllocal("Ktravel", TDim::NHRU, "travel time", "(d)", &Ktravel); + decllocal("soil_gw_Buf", TDim::NHRU, "buffer soil_gw(gw_flow) from soil, i.e. soil_gw_Buf is from gw_flow = soil_gw", "(mm/int)", &soil_gw_Buf); + decllocal("Ktravel", TDim::NHRU, "travel time from Muskingum method", "(d)", &Ktravel); declparam("basin_area", TDim::BASIN, "3", "1e-6", "1e09", "Total basin area", "(km^2)", &basin_area); diff --git a/crhmcode/src/modules/ClassNetroute_M_D.cpp b/crhmcode/src/modules/ClassNetroute_M_D.cpp index 61235bc94..366fb4aed 100644 --- a/crhmcode/src/modules/ClassNetroute_M_D.cpp +++ b/crhmcode/src/modules/ClassNetroute_M_D.cpp @@ -41,7 +41,7 @@ void ClassNetroute_M_D::decl(void) { decldiag("outflow_diverted", TDim::NHRU, "HRU outflow diverted to another HRU", "(mm*km^2/int)", &outflow_diverted); - declstatdiag("cumoutflow_diverted", TDim::NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2/int)", &cumoutflow_diverted); + declstatdiag("cumoutflow_diverted", TDim::NHRU, "cumulative HRU outflow diverted to another HRU", "(mm*km^2)", &cumoutflow_diverted); declstatdiag("cum_to_Sd", TDim::NHRU, "cumulative other HRU to depressional storage (Sd) of this HRU", "(mm)", &cum_to_Sd); @@ -57,15 +57,15 @@ void ClassNetroute_M_D::decl(void) { decldiag("gwoutflow_diverted", TDim::NHRU, "HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwoutflow_diverted); - declstatdiag("gwcumoutflow_diverted", TDim::NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2/int)", &gwcumoutflow_diverted); + declstatdiag("gwcumoutflow_diverted", TDim::NHRU, "cumulative HRU gw outflow diverted to another HRU", "(mm*km^2)", &gwcumoutflow_diverted); - declvar("ssrinflow", TDim::NHRU, "inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); + declvar("ssrinflow", TDim::NHRU, "subsurface inflow from other HRUs", "(mm*km^2/int)", &ssrinflow); - declstatdiag("ssrcuminflow", TDim::NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); + declstatdiag("ssrcuminflow", TDim::NHRU, "cumulative subsurface inflow from other HRUs", "(mm*km^2)", &ssrcuminflow); - declvar("ssroutflow", TDim::NHRU, "HRU outflow", "(mm*km^2/int)", &ssroutflow); + declvar("ssroutflow", TDim::NHRU, "HRU subsurface outflow", "(mm*km^2/int)", &ssroutflow); - declstatdiag("ssrcumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &ssrcumoutflow); + declstatdiag("ssrcumoutflow", TDim::NHRU, "cumulative HRU subsurface outflow", "(mm*km^2)", &ssrcumoutflow); declstatdiag("HRU_cumbasinflow", TDim::NHRU, "cumulative HRU to basinflow", "(mm*km^2)", &HRU_cumbasinflow); @@ -73,13 +73,13 @@ void ClassNetroute_M_D::decl(void) { declparam("preferential_flow", TDim::NHRU, "[0]", "0", "1","0 - no preferential and remain as runoff routing to other HRU, 1 - preferential flow and route runoff to other HRU's gw.", "()", &preferential_flow); - declvar("runinflow", TDim::NHRU, "inflow from other HRUs", "(mm*km^2/int)", &runinflow); + declvar("runinflow", TDim::NHRU, "overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2/int)", &runinflow); - declstatdiag("runcuminflow", TDim::NHRU, "cumulative inflow from other HRUs", "(mm*km^2)", &runcuminflow); + declstatdiag("runcuminflow", TDim::NHRU, "cumulative overland inflow (sum of meltrunoff and runoff) from other HRUs", "(mm*km^2)", &runcuminflow); - declvar("runoutflow", TDim::NHRU, "HRU outflow", "(mm*km^2/int)", &runoutflow); + declvar("runoutflow", TDim::NHRU, "HRU overland outflow", "(mm*km^2/int)", &runoutflow); - declstatdiag("runcumoutflow", TDim::NHRU, "cumulative HRU outflow", "(mm*km^2)", &runcumoutflow); + declstatdiag("runcumoutflow", TDim::NHRU, "cumulative HRU overland outflow", "(mm*km^2)", &runcumoutflow); declstatdiag("cumscaling_boost", TDim::NHRU, "cumulative amout inflow boosted", "(mm*km^2)", &cumscaling_boost); @@ -95,13 +95,13 @@ void ClassNetroute_M_D::decl(void) { declstatdiag("cumbasingw", TDim::BASIN, "cumulative basin groundwater outflow", "(m^3)", &cumbasingw); - decllocal("soil_ssr_Buf", TDim::NHRU, "buffer subsurface runoff", "(mm/d)", &soil_ssr_Buf); + decllocal("soil_ssr_Buf", TDim::NHRU, "buffer subsurface runoff from soil, i.e. soil_ssr_Buf is from soil_ssr", "(mm/int)", &soil_ssr_Buf); - decllocal("soil_runoff_Buf", TDim::NHRU, "buffer rain runoff", "(mm/d)", &soil_runoff_Buf); + decllocal("soil_runoff_Buf", TDim::NHRU, "buffer overland runoff from soil, i.e. soil_runoff_Buf is from soil_runoff", "(mm/int)", &soil_runoff_Buf); - decllocal("soil_gw_Buf", TDim::NHRU, "buffer rain runoff", "(mm/d)", &soil_gw_Buf); + decllocal("soil_gw_Buf", TDim::NHRU, "buffer soil_gw(gw_flow) from soil, i.e. soil_gw_Buf is from gw_flow = soil_gw", "(mm/int)", &soil_gw_Buf); - decllocal("Ktravel", TDim::NHRU, "travel time", "(d)", &Ktravel); + decllocal("Ktravel", TDim::NHRU, "travel time from Muskingum method", "(d)", &Ktravel); decllocal("distrib_sum", TDim::NHRU, "HRU distribution sum", "()", &distrib_sum); diff --git a/crhmcode/src/modules/ClassPrairieInfil.cpp b/crhmcode/src/modules/ClassPrairieInfil.cpp index e11e6c286..1b22d5440 100644 --- a/crhmcode/src/modules/ClassPrairieInfil.cpp +++ b/crhmcode/src/modules/ClassPrairieInfil.cpp @@ -23,17 +23,17 @@ void ClassPrairieInfil::decl(void) { Description = "'Handles frozen soil infiltration using Granger et al. 1984; Gray et al., 1986 and Ayers, 1959 for unfrozen soil.'"; - declvar("snowinfil", TDim::NHRU, "infiltration", "(mm/d)", &snowinfil); + declvar("snowinfil", TDim::NHRU, "daily snowmelt infiltration", "(mm/d)", &snowinfil); - declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("meltrunoff", TDim::NHRU, "melt runoff", "(mm/d)", &meltrunoff); + declvar("meltrunoff", TDim::NHRU, "daily melt runoff", "(mm/d)", &meltrunoff); declstatdiag("cummeltrunoff", TDim::NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); - declvar("infil", TDim::NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", TDim::NHRU,"interval rainfall infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", TDim::NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", TDim::NHRU, "cumulative rainfall infiltration", "(mm)", &cuminfil); declvar("runoff", TDim::NHRU, "rainfall runoff", "(mm/int)", &runoff); @@ -53,7 +53,7 @@ void ClassPrairieInfil::decl(void) { declparam("hru_area", TDim::NHRU, "[1]", "1e-6", "1e+09", "hru area", "(km^2)", &hru_area); declparam("fallstat", TDim::NHRU, "[50.0]", "-1.0","100.0", - "fall status 0.0 - unlimited/ 100.0 - restricted/ other - limited", "(%)", &fallstat); + "fall soil saturation status 0.0 - unlimited/ 100.0 - restricted/ other - limited", "(%)", &fallstat); declparam("Major", TDim::NHRU, "[5]", "1", "100", "threshold for major melt", "(mm/d)", &Major); @@ -62,10 +62,10 @@ void ClassPrairieInfil::decl(void) { decldiagparam("infDays", TDim::NHRU, "[6]", "0", "20", " maximum number of days of snowmelt infiltration to frozen soil ", "(d)", &infDays); declparam("texture", TDim::NHRU, "[1]", "1","4", - "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "(%)", &texture); + "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "()", &texture); declparam("groundcover", TDim::NHRU, "[1]", "1","6", - "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "(%)", &groundcover); + "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "()", &groundcover); declgetvar("*", "hru_tmax", "(" + string(DEGREE_CELSIUS) + ")", &hru_tmax); declgetvar("*", "snowmeltD", "(mm/d)", &snowmelt); diff --git a/crhmcode/src/modules/ClassREWroute.cpp b/crhmcode/src/modules/ClassREWroute.cpp index b80be76ef..cc6d4a774 100644 --- a/crhmcode/src/modules/ClassREWroute.cpp +++ b/crhmcode/src/modules/ClassREWroute.cpp @@ -47,13 +47,13 @@ void ClassREWroute::decl(void) { gwCnt = declgrpvar("WS_ALL_gwflow", "basingw", "query variable = 'basingw'", "(m^3/int)", &gwrew, &gw_All); - declvar("WS_gwinflow", TDim::NHRU, "inflow from each RB", "(m^3/int)", &gwinflow); + declvar("WS_gwinflow", TDim::NHRU, "gwinflow from each RB", "(m^3/int)", &gwinflow); - declstatdiag("cum_WSgwinflow", TDim::NHRU, "cumulative inflow from each RB", "(m^3)", &cumgwinflow); + declstatdiag("cum_WSgwinflow", TDim::NHRU, "cumulative gwinflow from each RB", "(m^3)", &cumgwinflow); - declvar("WS_gwoutflow", TDim::NHRU, "outflow of each RB", "(m^3/int)", &gwoutflow); + declvar("WS_gwoutflow", TDim::NHRU, "gwoutflow of each RB", "(m^3/int)", &gwoutflow); - declstatdiag("cum_WSgwoutflow", TDim::NHRU, "cumulative outflow of each RB", "(m^3)", &cumgwoutflow); + declstatdiag("cum_WSgwoutflow", TDim::NHRU, "cumulative gwoutflow of each RB", "(m^3)", &cumgwoutflow); declvar("WS_gwflow", TDim::BASIN, "watershed ground water outflow", "(m^3/int)", &gwflow); @@ -62,29 +62,29 @@ void ClassREWroute::decl(void) { declstatdiag("cum_WSgwflow", TDim::BASIN, "cumulative watershed ground water outflow", "(m^3)", &cumgwflow); - declparam("WS_Lag", TDim::NHRU, "[0.0]", "0.0","1.0E4.0", "lag delay", "(h)", &WS_Lag); + declparam("WS_Lag", TDim::NHRU, "[0.0]", "0.0","1.0E4.0", "inflow lag delay", "(h)", &WS_Lag); - declparam("WS_gwLag", TDim::NHRU, "[0.0]", "0.0","1.0E4.0", "lag delay", "(h)", &WS_gwLag); + declparam("WS_gwLag", TDim::NHRU, "[0.0]", "0.0","1.0E4.0", "gwinflow lag delay", "(h)", &WS_gwLag); declparam("WS_whereto", TDim::NHRU, "[0]", "0", "1000", "0 - watershed outflow, or RB input", "()", &WS_whereto); - declparam("WS_order", TDim::NHRU, "1,2,3,4,5!", "1","1000", "RB routing process order", "()", &WS_order); + declparam("WS_order", TDim::NHRU, "1,2,3,4,5!", "1","1000", "RB outflow routing process order", "()", &WS_order); - declparam("WS_gwwhereto", TDim::NHRU, "[0]", "0", "1000", "0 - watershed outflow, or RB input", "()", &WS_gwwhereto); + declparam("WS_gwwhereto", TDim::NHRU, "[0]", "0", "1000", "0 - watershed gwoutflow, or RB input", "()", &WS_gwwhereto); - declparam("WS_gworder", TDim::NHRU, "1,2,3,4,5!", "1","1000", "RB routing process order", "()", &WS_gworder); + declparam("WS_gworder", TDim::NHRU, "1,2,3,4,5!", "1","1000", "RB gwoutflow routing process order", "()", &WS_gworder); variation_set = VARIATION_0; - decldiag("WS_Ktravel_var", TDim::NHRU, "inflow storage constant", "(d)", &WS_Ktravel_var); + decldiag("WS_Ktravel_var", TDim::NHRU, "inflow storage constant (Muskingum method)", "(d)", &WS_Ktravel_var); - decldiag("WS_gwKtravel_var", TDim::NHRU, "gw storage constant", "(d)", &WS_gwKtravel_var); + decldiag("WS_gwKtravel_var", TDim::NHRU, "gwinflow storage constant (Muskingum method)", "(d)", &WS_gwKtravel_var); declparam("WS_route_n", TDim::NHRU, "[0.025]", "0.016","0.2", "Manning roughness coefficient", "()", &WS_route_n); - declparam("WS_route_R", TDim::NHRU, "[0.5]", "0.01","1.0E4", "hydraulic radius", "()", &WS_route_R); + declparam("WS_route_R", TDim::NHRU, "[0.5]", "0.01","1.0E4", "hydraulic radius", "(m)", &WS_route_R); declparam("WS_route_S0", TDim::NHRU, "[1e-3]", "1e-6","1.0", "longitudinal channel slope", "()", &WS_route_S0); @@ -99,9 +99,9 @@ void ClassREWroute::decl(void) { variation_set = VARIATION_1; - declparam("WS_Kstorage", TDim::NHRU, "[0.0]", "0.0","200.0", "Clark storage constant", "(d)", &WS_Kstorage); + declparam("WS_Kstorage", TDim::NHRU, "[0.0]", "0.0","200.0", "inflow storage constant for RB (Clark method)", "(d)", &WS_Kstorage); - declparam("WS_gwKstorage", TDim::NHRU, "[0.0]", "0.0","200.0", "Clark storage constant", "(d)", &WS_gwKstorage); + declparam("WS_gwKstorage", TDim::NHRU, "[0.0]", "0.0","200.0", "gwinflow storage constant for RB (Clark method)", "(d)", &WS_gwKstorage); variation_set = VARIATION_ORG; diff --git a/crhmcode/src/modules/ClassREWroute2.cpp b/crhmcode/src/modules/ClassREWroute2.cpp index 38061ca11..b1b4d3c1b 100644 --- a/crhmcode/src/modules/ClassREWroute2.cpp +++ b/crhmcode/src/modules/ClassREWroute2.cpp @@ -31,13 +31,13 @@ void ClassREWroute2::decl(void) { inflowCnt = declgrpvar("WS_ALL_inflow", "basinflow", "query variable = 'basinflow'", "(m^3/int)", &rew, &inflow_All); - declvar("WS_inflow", TDim::NHRU, "inflow from each RB", "(m^3/int)", &inflow); + declvar("WS_inflow", TDim::NHRU, "gwinflow from each RB", "(m^3/int)", &inflow); - declstatdiag("cum_WSinflow", TDim::NHRU, "cumulative inflow from each RB", "(m^3)", &cuminflow); + declstatdiag("cum_WSinflow", TDim::NHRU, "cumulative gwinflow from each RB", "(m^3)", &cuminflow); - declvar("WS_outflow", TDim::NHRU, "outflow of each RB", "(m^3/int)", &outflow); + declvar("WS_outflow", TDim::NHRU, "gwoutflow of each RB", "(m^3/int)", &outflow); - declstatdiag("cum_WSoutflow", TDim::NHRU, "cumulative outflow of each RB", "(m^3)", &cumoutflow); + declstatdiag("cum_WSoutflow", TDim::NHRU, "cumulative gwoutflow of each RB", "(m^3)", &cumoutflow); declvar("WS_flow", TDim::BASIN, "watershed surface and sub-surface outflow", "(m^3/int)", &flow); @@ -48,13 +48,13 @@ void ClassREWroute2::decl(void) { gwCnt = declgrpvar("WS_ALL_gwflow", "basingw", "query variable = 'basingw'", "(m^3/int)", &gwrew, &gw_All); - declvar("WS_gwinflow", TDim::NHRU, "inflow from each RB", "(m^3/int)", &gwinflow); + declvar("WS_gwinflow", TDim::NHRU, "gwinflow from each RB", "(m^3/int)", &gwinflow); - declstatdiag("cum_WSgwinflow", TDim::NHRU, "cumulative inflow from each RB", "(m^3)", &cumgwinflow); + declstatdiag("cum_WSgwinflow", TDim::NHRU, "cumulative gwinflow from each RB", "(m^3)", &cumgwinflow); - declvar("WS_gwoutflow", TDim::NHRU, "outflow of each RB", "(m^3/int)", &gwoutflow); + declvar("WS_gwoutflow", TDim::NHRU, "gwoutflow of each RB", "(m^3/int)", &gwoutflow); - declstatdiag("cum_WSgwoutflow", TDim::NHRU, "cumulative outflow of each RB", "(m^3)", &cumgwoutflow); + declstatdiag("cum_WSgwoutflow", TDim::NHRU, "cumulative gwoutflow of each RB", "(m^3)", &cumgwoutflow); declvar("WS_gwflow", TDim::BASIN, "watershed ground water outflow", "(m^3/int)", &gwflow); @@ -65,15 +65,15 @@ void ClassREWroute2::decl(void) { declparam("WS_whereto", TDim::NHRU, "[0]", "0", "1000", "0 - watershed outflow, or RB input", "()", &WS_whereto); - declparam("WS_order", TDim::NHRU, "1,2,3,4,5!", "1","1000", "RB routing process order", "()", &WS_order); + declparam("WS_order", TDim::NHRU, "1,2,3,4,5!", "1","1000", "RB outflow routing process order", "()", &WS_order); declparam("WS_gwwhereto", TDim::NHRU, "[0]", "0", "1000", "0 - watershed outflow, or RB input", "()", &WS_gwwhereto); - declparam("WS_gworder", TDim::NHRU, "1,2,3,4,5!", "1","1000", "RB routing process order", "()", &WS_gworder); + declparam("WS_gworder", TDim::NHRU, "1,2,3,4,5!", "1","1000", "RB gwoutflow routing process order", "()", &WS_gworder); - declparam("WS_Lag", TDim::NHRU, "[0.0]", "0.0","1.0E4.0", "lag delay", "(h)", &WS_Lag); + declparam("WS_Lag", TDim::NHRU, "[0.0]", "0.0","1.0E4.0", "inflow lag delay", "(h)", &WS_Lag); - declparam("WS_gwLag", TDim::NHRU, "[0.0]", "0.0","1.0E4.0", "lag delay", "(h)", &WS_gwLag); + declparam("WS_gwLag", TDim::NHRU, "[0.0]", "0.0","1.0E4.0", "gwinflow lag delay", "(h)", &WS_gwLag); variation_set = VARIATION_2 + VARIATION_3; @@ -111,13 +111,13 @@ void ClassREWroute2::decl(void) { variation_set = VARIATION_0 + VARIATION_2; - decldiag("WS_Ktravel_var", TDim::NHRU, "inflow storage constant", "(d)", &WS_Ktravel_var); + decldiag("WS_Ktravel_var", TDim::NHRU, "inflow storage constant (Muskingum method)", "(d)", &WS_Ktravel_var); - decldiag("WS_gwKtravel_var", TDim::NHRU, "gw storage constant", "(d)", &WS_gwKtravel_var); + decldiag("WS_gwKtravel_var", TDim::NHRU, "gwinflow storage constant (Muskingum method)", "(d)", &WS_gwKtravel_var); declparam("WS_route_n", TDim::NHRU, "[0.025]", "0.016","0.2", "Manning roughness coefficient", "()", &WS_route_n); - declparam("WS_route_R", TDim::NHRU, "[0.5]", "0.01","1.0E4", "hydraulic radius", "()", &WS_route_R); + declparam("WS_route_R", TDim::NHRU, "[0.5]", "0.01","1.0E4", "hydraulic radius", "(m)", &WS_route_R); declparam("WS_route_S0", TDim::NHRU, "[1e-3]", "1e-6","1.0", "longitudinal channel slope", "()", &WS_route_S0); @@ -132,9 +132,9 @@ void ClassREWroute2::decl(void) { variation_set = VARIATION_1 + VARIATION_3; - declparam("WS_Kstorage", TDim::NHRU, "[0.0]", "0.0","200.0", "Clark storage constant", "(d)", &WS_Kstorage); + declparam("WS_Kstorage", TDim::NHRU, "[0.0]", "0.0","200.0", "inflow Clark storage constant for RB (Clark method)", "(d)", &WS_Kstorage); - declparam("WS_gwKstorage", TDim::NHRU, "[0.0]", "0.0","200.0", "Clark storage constant", "(d)", &WS_gwKstorage); + declparam("WS_gwKstorage", TDim::NHRU, "[0.0]", "0.0","200.0", "gwinflow Clark storage constant for RB (Clark method)", "(d)", &WS_gwKstorage); variation_set = VARIATION_ORG; diff --git a/crhmcode/src/modules/ClassSWEslope.cpp b/crhmcode/src/modules/ClassSWEslope.cpp index a5af81632..2a55725f2 100644 --- a/crhmcode/src/modules/ClassSWEslope.cpp +++ b/crhmcode/src/modules/ClassSWEslope.cpp @@ -57,7 +57,7 @@ void ClassSWEslope::decl(void) { declparam("hru_area", TDim::NHRU, "[1]", "1e-6", "1e+09", "hru area", "(km^2)", &hru_area); - declparam("distrib_SWEslope", TDim::NDEFN, "[0.0]", "0.0", "1.0E6.0", "distribute this HRU iceflow to these HRUs. Source HRU can include itself in the re-distribution", "()", &distrib_SWEslope, &distrib_hru, nhru); + declparam("distrib_SWEslope", TDim::NDEFN, "[0.0]", "0.0", "1.0E6.0", "distribute SWE from this HRU to these HRUs. Source HRU can include itself in the re-distribution", "()", &distrib_SWEslope, &distrib_hru, nhru); declputvar("*", "SWE", "(mm)", &SWE); diff --git a/crhmcode/src/modules/ClassShutWall.cpp b/crhmcode/src/modules/ClassShutWall.cpp index 3808e6231..c4b3c0179 100644 --- a/crhmcode/src/modules/ClassShutWall.cpp +++ b/crhmcode/src/modules/ClassShutWall.cpp @@ -26,25 +26,25 @@ ClassShutWall* ClassShutWall::klone(string name) const{ declstatdiag("hru_cum_actet", TDim::NHRU, "cumulative actual evapotranspiration over HRU", "(mm)", &hru_cum_actet); - declvar("hru_evap", TDim::NHRU, "evaporation, interval calculation from daily", "(mm/int)", &evap); + declvar("hru_evap", TDim::NHRU, "interval evaporation", "(mm/int)", &evap); declvar("hru_evapD", TDim::NHRU, "daily evaporation", "(mm)", &evapD); - declstatdiag("hru_cum_evap", TDim::NHRU, "cumulative interval evaporation from daily", "(mm)", &cum_evap); + declstatdiag("hru_cum_evap", TDim::NHRU, "cumulative interval evaporation", "(mm)", &cum_evap); decldiag("Cc", TDim::NHRU, "canopy weighting coefficient", "()", &Cc); decldiag("Cs", TDim::NHRU, "substrate weighting coefficient", "()", &Cs); - decldiag("Ra", TDim::NHRU, "", "()", &Ra); + decldiag("Ra", TDim::NHRU, "aerodynamic resistance 'component'", "(mb/K*s/m)", &Ra); - decldiag("Rc", TDim::NHRU, "", "()", &Rc); + decldiag("Rc", TDim::NHRU, "canopy stomatal resistance 'component'", "(mb/K*s/m)", &Rc); - decldiag("Rs", TDim::NHRU, "", "()", &Rs); + decldiag("Rs", TDim::NHRU, "soil surface resistance 'component'", "(mb/K*s/m)", &Rs); - decldiag("ETc", TDim::NHRU, "", "(mm/d)", &ETc); + decldiag("ETc", TDim::NHRU, "daily evaporation from canopy", "(mm/d)", &ETc); - decldiag("ETs", TDim::NHRU, "", "(mm/d)", &ETs); + decldiag("ETs", TDim::NHRU, "daily evaporation from soil surface", "(mm/d)", &ETs); decldiag("raa", TDim::NHRU, "aerodynamic resistance from canopy to reference height", "(s/m)", &raa); diff --git a/crhmcode/src/modules/ClassShutWallD.cpp b/crhmcode/src/modules/ClassShutWallD.cpp index e1e718fa6..d00d307da 100644 --- a/crhmcode/src/modules/ClassShutWallD.cpp +++ b/crhmcode/src/modules/ClassShutWallD.cpp @@ -35,15 +35,15 @@ ClassShutWallD* ClassShutWallD::klone(string name) const{ declvar("Cs", TDim::NHRU, "substrate weighting coefficient", "()", &Cs); - decldiag("Ra", TDim::NHRU, "", "()", &Ra); + decldiag("Ra", TDim::NHRU, "aerodynamic resistance 'component", "(mb/K*s/m)", &Ra); - decldiag("Rc", TDim::NHRU, "", "()", &Rc); + decldiag("Rc", TDim::NHRU, "canopy stomatal resistance 'component'", "(mb/K*s/m)", &Rc); - decldiag("Rs", TDim::NHRU, "", "()", &Rs); + decldiag("Rs", TDim::NHRU, "soil surface resistance 'component'", "(mb/K*s/m)", &Rs); - decldiag("ETc", TDim::NHRU, "", "(mm/d)", &ETc); + decldiag("ETc", TDim::NHRU, "daily evaporation from canopy", "(mm/d)", &ETc); - decldiag("ETs", TDim::NHRU, "", "(mm/d)", &ETs); + decldiag("ETs", TDim::NHRU, "daily evaporation from soil surface", "(mm/d)", &ETs); decldiag("raa", TDim::NHRU, "aerodynamic resistance from canopy to reference height", "(s/m)", &raa); diff --git a/crhmcode/src/modules/ClassSoil.cpp b/crhmcode/src/modules/ClassSoil.cpp index 1654e49d1..d7e258701 100644 --- a/crhmcode/src/modules/ClassSoil.cpp +++ b/crhmcode/src/modules/ClassSoil.cpp @@ -162,29 +162,29 @@ void ClassSoil::decl(void) { declvar("infil_act_D", TDim::NHRU, "Daily actual amount of water infiltrating the soil on each HRU.", "(mm/d)", &infil_act_D); - declstatdiag("cum_gw_flow", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_gw_flow); + declstatdiag("cum_gw_flow", TDim::NHRU, "cumulative groundwater flow from HRU groundwater reservoirs.", "(mm)", &cum_gw_flow); - declvar("soil_ssr", TDim::NHRU, "Portion of soil moisture and recharge excess from a HRU that enters subsurface reservoirs.", "(mm/int)", &soil_ssr); + declvar("soil_ssr", TDim::NHRU, "subsurface runoff from soil layers and depressional storage.", "(mm/int)", &soil_ssr); - declvar("rechr_ssr", TDim::NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/int)", &rechr_ssr); + declvar("rechr_ssr", TDim::NHRU, "subsurface runoff from soil recharge layer.", "(mm/int)", &rechr_ssr); - declstatdiag("cum_soil_ssr", TDim::NHRU, "Accumulation of soil moisture from a HRU to ssr.", "(mm)", &cum_soil_ssr); + declstatdiag("cum_soil_ssr", TDim::NHRU, "cumulative subsurface runoff from layers and depressional storage.", "(mm)", &cum_soil_ssr); - declstatdiag("cum_rechr_ssr", TDim::NHRU, "Accumulation of Portion of excess from a HRU to ssr.", "(mm)", &cum_rechr_ssr); + declstatdiag("cum_rechr_ssr", TDim::NHRU, "cumulative subsurface runoff from soil recharge layer.", "(mm)", &cum_rechr_ssr); - declvar("soil_ssr_D", TDim::NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/d)", &soil_ssr_D); + declvar("soil_ssr_D", TDim::NHRU, "daily accumulation of soil_ssr.", "(mm/d)", &soil_ssr_D); declvar("soil_runoff", TDim::NHRU, "Portion of excess soil water from a HRU to runoff.", "(mm/int)", &soil_runoff); declstatdiag("cum_soil_runoff", TDim::NHRU, "Accumulation of Portion of excess soil water from a HRU to runoff.", "(mm)", &cum_soil_runoff); - declvar("soil_runoff_D", TDim::NHRU, "Portion of excess soil water from a HRU that enters groundwater reservoirs.", "(mm/d)", &soil_runoff_D); + declvar("soil_runoff_D", TDim::NHRU, "daily accumulation of soil_runoff.", "(mm/d)", &soil_runoff_D); - declstatdiag("cum_runoff_to_Sd", TDim::NHRU, "Cumulative portion of runoff to depression storage.", "(mm/int)", &cum_runoff_to_Sd); + declstatdiag("cum_runoff_to_Sd", TDim::NHRU, "Cumulative portion of runoff to depression storage.", "(mm)", &cum_runoff_to_Sd); declstatdiag("cum_soil_gw", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_soil_gw); - declstatdiag("cum_Sd_gw", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_Sd_gw); + declstatdiag("cum_Sd_gw", TDim::NHRU, "cumulative excess from Sd that enters groundwater reservoirs.", "(mm)", &cum_Sd_gw); decllocal("snowinfil_buf", TDim::NHRU, "buffer snow infiltration.", "(mm/d)", &snowinfil_buf); @@ -193,7 +193,7 @@ void ClassSoil::decl(void) { decllocal("meltrunoff_buf", TDim::NHRU, "buffer melt runoff.", "(mm/d)", &meltrunoff_buf); - decllocal("hru_evap_buf", TDim::NHRU, "buffer evaporation.", "(mm/d)", &hru_evap_buf); + decllocal("hru_evap_buf", TDim::NHRU, "buffer evaporation.", "(mm/int)", &hru_evap_buf); decllocal("soil_moist_Init", TDim::NHRU, "initial soil moisture.", "(mm)", &soil_moist_Init); @@ -234,13 +234,13 @@ void ClassSoil::decl(void) { declparam("gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ground water drainage from gw reservoir.", "(mm/d)", &gw_K); - declparam("rechr_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge.", "(mm/d)", &rechr_ssr_K); + declparam("rechr_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge layer (soil_rechr).", "(mm/d)", &rechr_ssr_K); - declparam("lower_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from soil column.", "(mm/d)", &lower_ssr_K); + declparam("lower_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from lower soil layer (soil_moist - soil_rechr).", "(mm/d)", &lower_ssr_K); - declparam("Sd_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily depression storage ssr drainage factor.", "(mm/d)", &Sd_ssr_K); + declparam("Sd_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage factor from depression storage.", "(mm/d)", &Sd_ssr_K); - declparam("Sd_gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily depression storage gw drainage.", "(mm/d)", &Sd_gw_K); + declparam("Sd_gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily drainage factor to groundwater reservoir from depression storage.", "(mm/d)", &Sd_gw_K); declparam("soil_withdrawal", TDim::NDEFN, "[3]", "1", "4", "Select water withdrawal function for soil type: 1 = sand, 2 = loam, 3 = clay, 4 = organic. soil_withdrawal[1] - rechr layer, soil_withdrawal[2] - lower layer", "()", diff --git a/crhmcode/src/modules/ClassSoilDS.cpp b/crhmcode/src/modules/ClassSoilDS.cpp index d763a73d8..d9044481c 100644 --- a/crhmcode/src/modules/ClassSoilDS.cpp +++ b/crhmcode/src/modules/ClassSoilDS.cpp @@ -97,25 +97,25 @@ void ClassSoilDS::decl(void) { declvar("infil_act_D", TDim::NHRU, "Daily actual amount of water infiltrating the soil on each HRU.", "(mm/d)", &infil_act_D); - declstatdiag("cum_gw_flow", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_gw_flow); + declstatdiag("cum_gw_flow", TDim::NHRU, "cumulative groundwater flow from HRU groundwater reservoirs.", "(mm)", &cum_gw_flow); - declvar("soil_ssr", TDim::NHRU, "Portion of soil moisture and recharge excess from a HRU that enters subsurface reservoirs.", "(mm/int)", &soil_ssr); + declvar("soil_ssr", TDim::NHRU, "subsurface runoff from soil layers and depressional storage.", "(mm/int)", &soil_ssr); - declvar("rechr_ssr", TDim::NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/int)", &rechr_ssr); + declvar("rechr_ssr", TDim::NHRU, "subsurface runoff from soil recharge layer.", "(mm/int)", &rechr_ssr); - declstatdiag("cum_soil_ssr", TDim::NHRU, "Accumulation of soil moisture from a HRU to ssr.", "(mm)", &cum_soil_ssr); + declstatdiag("cum_soil_ssr", TDim::NHRU, "cumulative subsurface runoff from layers and depressional storage.", "(mm)", &cum_soil_ssr); - declstatdiag("cum_rechr_ssr", TDim::NHRU, "Accumulation of Portion of excess from a HRU to ssr.", "(mm)", &cum_rechr_ssr); + declstatdiag("cum_rechr_ssr", TDim::NHRU, "cumulative subsurface runoff from soil recharge layer", "(mm)", &cum_rechr_ssr); - declvar("soil_ssr_D", TDim::NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/d)", &soil_ssr_D); + declvar("soil_ssr_D", TDim::NHRU, "daily accumulation of soil_ssr.", "(mm/d)", &soil_ssr_D); declvar("soil_runoff", TDim::NHRU, "Portion of excess soil water from a HRU to runoff.", "(mm/int)", &soil_runoff); declstatdiag("cum_soil_runoff", TDim::NHRU, "Accumulation of Portion of excess soil water from a HRU to runoff.", "(mm)", &cum_soil_runoff); - declvar("soil_runoff_D", TDim::NHRU, "Portion of excess soil water from a HRU that enters groundwater reservoirs.", "(mm/d)", &soil_runoff_D); + declvar("soil_runoff_D", TDim::NHRU, "daily accumulation of soil_runoff.", "(mm/d)", &soil_runoff_D); - declstatdiag("cum_runoff_to_Sd", TDim::NHRU, "Cumulative portion of runoff to depression storage.", "(mm/int)", &cum_runoff_to_Sd); + declstatdiag("cum_runoff_to_Sd", TDim::NHRU, "Cumulative portion of runoff to depression storage.", "(mm)", &cum_runoff_to_Sd); declstatdiag("cum_soil_gw", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_soil_gw); @@ -126,7 +126,7 @@ void ClassSoilDS::decl(void) { decllocal("meltrunoff_buf", TDim::NHRU, "buffer melt runoff.", "(mm/d)", &meltrunoff_buf); - decllocal("hru_evap_buf", TDim::NHRU, "buffer evaporation.", "(mm/d)", &hru_evap_buf); + decllocal("hru_evap_buf", TDim::NHRU, "buffer evaporation.", "(mm/int)", &hru_evap_buf); decllocal("soil_moist_Init", TDim::NHRU, "initial soil moisture.", "(mm)", &soil_moist_Init); @@ -167,13 +167,13 @@ void ClassSoilDS::decl(void) { declparam("gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ground water drainage from gw reservoir.", "(mm/d)", &gw_K); - declparam("rechr_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge.", "(mm/d)", &rechr_ssr_K); + declparam("rechr_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge layer (soil_rechr).", "(mm/d)", &rechr_ssr_K); - declparam("lower_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from soil column.", "(mm/d)", &lower_ssr_K); + declparam("lower_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from lower soil layer (soil_moist - soil_rechr).", "(mm/d)", &lower_ssr_K); - declparam("Sd_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily depression storage ssr drainage factor.", "(mm/d)", &Sd_ssr_K); + declparam("Sd_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage factor from depression storage.", "(mm/d)", &Sd_ssr_K); - declparam("Sd_gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily depression storage gw drainage.", "(mm/d)", &Sd_gw_K); + declparam("Sd_gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily drainage factor to groundwater reservoir from depression storage.", "(mm/d)", &Sd_gw_K); declparam("soil_withdrawal", TDim::NDEFN, "[3]", "1", "4", "Select water withdrawal function for soil type: 1 = sand, 2 = loam, 3 = clay, 4 = organic. soil_withdrawal[1] - rechr layer, soil_withdrawal[2] - lower layer", "()", diff --git a/crhmcode/src/modules/ClassSoilX.cpp b/crhmcode/src/modules/ClassSoilX.cpp index d2e601a61..6dc9415b2 100644 --- a/crhmcode/src/modules/ClassSoilX.cpp +++ b/crhmcode/src/modules/ClassSoilX.cpp @@ -103,25 +103,25 @@ void ClassSoilX::decl(void) { declvar("infil_act_D", TDim::NHRU, "Daily actual amount of water infiltrating the soil on each HRU.", "(mm/d)", &infil_act_D); - declstatdiag("cum_gw_flow", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_gw_flow); + declstatdiag("cum_gw_flow", TDim::NHRU, "cumulative groundwater flow from HRU groundwater reservoirs.", "(mm)", &cum_gw_flow); - declvar("soil_ssr", TDim::NHRU, "Portion of soil moisture and recharge excess from a HRU that enters subsurface reservoirs.", "(mm/int)", &soil_ssr); + declvar("soil_ssr", TDim::NHRU, "subsurface runoff from soil layers and depressional storage.", "(mm/int)", &soil_ssr); - declvar("rechr_ssr", TDim::NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/int)", &rechr_ssr); + declvar("rechr_ssr", TDim::NHRU, "subsurface runoff from soil recharge layer.", "(mm/int)", &rechr_ssr); - declstatdiag("cum_soil_ssr", TDim::NHRU, "Accumulation of soil moisture from a HRU to ssr.", "(mm)", &cum_soil_ssr); + declstatdiag("cum_soil_ssr", TDim::NHRU, "cumulative subsurface runoff from layers and depressional storage.", "(mm)", &cum_soil_ssr); - declstatdiag("cum_rechr_ssr", TDim::NHRU, "Accumulation of Portion of excess from a HRU to ssr.", "(mm)", &cum_rechr_ssr); + declstatdiag("cum_rechr_ssr", TDim::NHRU, "cumulative subsurface runoff from soil recharge layer.", "(mm)", &cum_rechr_ssr); - declvar("soil_ssr_D", TDim::NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/d)", &soil_ssr_D); + declvar("soil_ssr_D", TDim::NHRU, "daily accumulation of soil_ssr.", "(mm/d)", &soil_ssr_D); declvar("soil_runoff", TDim::NHRU, "Portion of excess soil water from a HRU to runoff.", "(mm/int)", &soil_runoff); declstatdiag("cum_soil_runoff", TDim::NHRU, "Accumulation of Portion of excess soil water from a HRU to runoff.", "(mm)", &cum_soil_runoff); - declvar("soil_runoff_D", TDim::NHRU, "Portion of excess soil water from a HRU that enters groundwater reservoirs.", "(mm/d)", &soil_runoff_D); + declvar("soil_runoff_D", TDim::NHRU, "daily accumulation of soil_runoff.", "(mm/d)", &soil_runoff_D); - declstatdiag("cum_runoff_to_Sd", TDim::NHRU, "Cumulative portion of runoff to depression storage.", "(mm/int)", &cum_runoff_to_Sd); + declstatdiag("cum_runoff_to_Sd", TDim::NHRU, "Cumulative portion of runoff to depression storage.", "(mm)", &cum_runoff_to_Sd); declstatdiag("cum_soil_gw", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_soil_gw); @@ -132,7 +132,7 @@ void ClassSoilX::decl(void) { decllocal("meltrunoff_buf", TDim::NHRU, "buffer melt runoff.", "(mm/d)", &meltrunoff_buf); - decllocal("hru_evap_buf", TDim::NHRU, "buffer evaporation.", "(mm/d)", &hru_evap_buf); + decllocal("hru_evap_buf", TDim::NHRU, "buffer evaporation.", "(mm/int)", &hru_evap_buf); decllocal("soil_moist_Init", TDim::NHRU, "initial soil moisture.", "(mm)", &soil_moist_Init); @@ -175,11 +175,11 @@ void ClassSoilX::decl(void) { declparam("rechr_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge. Modified by thaw_upper.", "(mm/d)", &rechr_ssr_K); - declparam("lower_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from soil column. Modified by thaw_lower.", "(mm/d)", &lower_ssr_K); + declparam("lower_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from lower soil layer (soil_moist - soil_rechr). Modified by thaw_lower.", "(mm/d)", &lower_ssr_K); - declparam("Sd_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily depression storage ssr drainage factor. Modified by thaw_all.", "(mm/d)", &Sd_ssr_K); + declparam("Sd_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage factor from depression storage. Modified by thaw_all.", "(mm/d)", &Sd_ssr_K); - declparam("Sd_gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily depression storage gw drainage.", "(mm/d)", &Sd_gw_K); + declparam("Sd_gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily drainage factor to groundwater reservoir from depression storage.", "(mm/d)", &Sd_gw_K); declparam("soil_withdrawal", TDim::NDEFN, "[3]", "1", "4", "Select water withdrawal function for soil type: 1 = sand, 2 = loam, 3 = clay, 4 = organic. soil_withdrawal[1] - rechr layer, soil_withdrawal[2] - lower layer", "()", diff --git a/crhmcode/src/modules/ClassVolumetric.cpp b/crhmcode/src/modules/ClassVolumetric.cpp index 5767314b2..e7c29de6b 100644 --- a/crhmcode/src/modules/ClassVolumetric.cpp +++ b/crhmcode/src/modules/ClassVolumetric.cpp @@ -23,11 +23,11 @@ void ClassVolumetric::decl(void) { Description = "'Converts soil moisture to volumetric equivalent and determines fall status.'"; - declvar("Volumetric", TDim::NHRU, "volumetric soil moisture", "()", &Volumetric); + declvar("Volumetric", TDim::NHRU, "fractional volumetric soil moisture", "()", &Volumetric); - declvar("Volumetric_rechr", TDim::NHRU, "volumetric soil moisture in soil recharge zone", "()", &Volumetric_rechr); // 04/14/2020: adding option for updating Si or fallstat based on Volumetric moisture content in recharge layer + declvar("Volumetric_rechr", TDim::NHRU, "fractional volumetric soil moisture in soil recharge zone", "()", &Volumetric_rechr); // 04/14/2020: adding option for updating Si or fallstat based on Volumetric moisture content in recharge layer - declvar("fallstat_V", TDim::NHRU, "fallstat_V copy of parameter fallstat", "()", &fallstat_V); + declvar("fallstat_V", TDim::NHRU, "fallstat_V copy of parameter fallstat", "(%)", &fallstat_V); declvar("Si_V", TDim::NHRU, "Si_V copy of parameter Si", "()", &Si_V); @@ -48,6 +48,8 @@ void ClassVolumetric::decl(void) { declparam("Si_correction", TDim::NHRU, "[0.0]", "0.0", "1.0", "Si correction number", "()", &Si_correction); + declparam("fallstat_correction", TDim::NHRU, "[1.0]", "0.0", "10.0", "fallstat correction factor", "()", &fallstat_correction); // 08/11/2021 + declparam("set_fallstat", TDim::NHRU, "[305]", "0", "366", "set fallstat on this Julian date", "()", &set_fallstat); declparam("Volumetric_option", TDim::NHRU, "[1]", "0", "1", "option of setting Si or fallstat: 0 - based on Volumetric moisture content in entire soil column, 1 - based on Volumetric moisture content in soil recharge layer", "()", &Volumetric_option); // 04/14/2020: @@ -121,6 +123,11 @@ void ClassVolumetric::run(void) { { fallstat[hh] = Volumetric[hh] / SetSoilproperties[soil_type[hh]][3] * 100000.0; // ie 100*1000 } + + if (fallstat_correction[hh] >= 0.0) // fallstat_correction added 08/11/2021 + { + fallstat[hh] = fallstat[hh] * fallstat_correction[hh]; + } } else { diff --git a/crhmcode/src/modules/ClassVolumetric.h b/crhmcode/src/modules/ClassVolumetric.h index 8657cb293..2b36098c5 100644 --- a/crhmcode/src/modules/ClassVolumetric.h +++ b/crhmcode/src/modules/ClassVolumetric.h @@ -10,6 +10,7 @@ ClassVolumetric(string Name, string Version = "undefined", LMODULE Lvl = LMODULE // declared parameters const double *soil_Depth{ NULL }; const double *Si_correction{ NULL }; +const double* fallstat_correction{ NULL }; const double *soil_moist_max{ NULL }; const double *soil_rechr_max{ NULL }; const long *soil_type{ NULL }; diff --git a/crhmcode/src/modules/ClassXG.cpp b/crhmcode/src/modules/ClassXG.cpp index 1cf933cf3..7e7ac2332 100644 --- a/crhmcode/src/modules/ClassXG.cpp +++ b/crhmcode/src/modules/ClassXG.cpp @@ -53,17 +53,17 @@ void ClassXG::decl(void) { declvar("pt", TDim::NDEFN, "thawing ratios", "()", &pt, &pt_lay, Global::nlay); - declstatvar("ttc", TDim::NDEFN, "thawing thermal conductivity", "(W/(m*K)", &ttc, &ttc_lay, Global::nlay); + declstatvar("ttc", TDim::NDEFN, "thawing thermal conductivity", "(W/(m*K))", &ttc, &ttc_lay, Global::nlay); - declstatvar("ftc", TDim::NDEFN, "freezing thermal conductivity", "(W/(m*K)", &ftc, &ftc_lay, Global::nlay); + declstatvar("ftc", TDim::NDEFN, "freezing thermal conductivity", "(W/(m*K))", &ftc, &ftc_lay, Global::nlay); declstatvar("ttc_contents", TDim::NDEFN, "thawing 0/1 thaw/freeze", "()", &ttc_contents, &ttc_contents_lay, Global::nlay); declstatvar("ftc_contents", TDim::NDEFN, "freezing 0/1 freeze/thaw", "()", &ftc_contents, &ftc_contents_lay, Global::nlay); - declvar("tc_composite", TDim::NDEFN, "freeze/thaw composite ftc/ttc value", "(W/(m*K)", &tc_composite, &tc_composite_lay, Global::nlay); + declvar("tc_composite", TDim::NDEFN, "freeze/thaw composite ftc/ttc value", "(W/(m*K))", &tc_composite, &tc_composite_lay, Global::nlay); - declvar("tc_composite2", TDim::NDEFN, "freeze/thaw composite2 ftc/ttc value", "(W/(m*K)", &tc_composite2, &tc_composite2_lay, Global::nlay); + declvar("tc_composite2", TDim::NDEFN, "freeze/thaw composite2 ftc/ttc value", "(W/(m*K))", &tc_composite2, &tc_composite2_lay, Global::nlay); declvar("layer_h2o", TDim::NDEFN, "water content", "(kg/m^3)", &layer_h2o, &h2o_lay, Global::nlay); @@ -110,13 +110,13 @@ void ClassXG::decl(void) { declparam("theta_min", TDim::NHRU, "[0.001]", "0.0001", "0.1", "minimum value of theta to prevent divide by zero errors)", "(m^3/m^3)", &theta_min); - declparam("soil_solid_km", TDim::NDEFN, "[2.5]", "0.03", "4", "dry soil thermal conductivity", "(W/(m*K)", &soil_solid_km, &soil_solid_km_lay, Global::nlay); + declparam("soil_solid_km", TDim::NDEFN, "[2.5]", "0.03", "4", "dry soil thermal conductivity", "(W/(m*K))", &soil_solid_km, &soil_solid_km_lay, Global::nlay); - declparam("soil_solid_km_ki", TDim::NDEFN, "[2.5]", "0.03", "4", "saturated frozen soil thermal conductivity", "(W/(m*K)", &soil_solid_km_ki, &soil_solid_km_ki_lay, Global::nlay); + declparam("soil_solid_km_ki", TDim::NDEFN, "[2.5]", "0.03", "4", "saturated frozen soil thermal conductivity", "(W/(m*K))", &soil_solid_km_ki, &soil_solid_km_ki_lay, Global::nlay); - declparam("soil_solid_km_kw", TDim::NDEFN, "[2.5]", "0.03", "4", "saturated unfrozen soil thermal conductivity.", "(W/(m*K)", &soil_solid_km_kw, &soil_solid_km_kw_lay, Global::nlay); + declparam("soil_solid_km_kw", TDim::NDEFN, "[2.5]", "0.03", "4", "saturated unfrozen soil thermal conductivity.", "(W/(m*K))", &soil_solid_km_kw, &soil_solid_km_kw_lay, Global::nlay); - declparam("SWE_k", TDim::NHRU, "[0.35]", "0.1", "1.0", "thermal conductivity of blowing snow.", "(W/(m*K)", &SWE_k); + declparam("SWE_k", TDim::NHRU, "[0.35]", "0.1", "1.0", "thermal conductivity of snow.", "(W/(m*K))", &SWE_k); declparam("Zdf_init", TDim::NHRU, "[0]", "0.0", "3", "initial depth of freezing front. Maximum value limited by freezing algorithm.", "(m)", &Zdf_init); diff --git a/crhmcode/src/modules/Classcrack.cpp b/crhmcode/src/modules/Classcrack.cpp index 7c17438b3..52ff636a7 100644 --- a/crhmcode/src/modules/Classcrack.cpp +++ b/crhmcode/src/modules/Classcrack.cpp @@ -23,19 +23,19 @@ void Classcrack::decl(void) { Description = "'Handles frozen soil infiltration using Granger et al. 1984; Gray et al., 1986.'"; - declvar("snowinfil", TDim::NHRU, "infiltration", "(mm/d)", &snowinfil); + declvar("snowinfil", TDim::NHRU, "daily snowmelt infiltration", "(mm/d)", &snowinfil); - declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative infiltration", "(mm)", &cumsnowinfil); + declstatdiag("cumsnowinfil", TDim::NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); - declvar("meltrunoff", TDim::NHRU, "melt runoff", "(mm/d)", &meltrunoff); + declvar("meltrunoff", TDim::NHRU, "daily melt runoff", "(mm/d)", &meltrunoff); declstatdiag("cummeltrunoff", TDim::NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); - declvar("infil", TDim::NHRU,"Potential amount of water infiltrating the soil on each HRU", "(mm/int)", &infil); + declvar("infil", TDim::NHRU,"interval rainfall infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", TDim::NHRU, "cumulative potential infiltration on each HRU", "(mm)", &cuminfil); + declstatdiag("cuminfil", TDim::NHRU, "cumulative rainfall infiltration", "(mm)", &cuminfil); - declvar("runoff", TDim::NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", TDim::NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", TDim::NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); @@ -53,7 +53,7 @@ void Classcrack::decl(void) { declparam("hru_area", TDim::NHRU, "[1]", "1e-6", "1e+09", "hru area", "(km^2)", &hru_area); declparam("fallstat", TDim::NHRU, "[50.0]", "-1.0","100.0", - "fall status 0.0 - unlimited/ 100.0 - restricted/ other - limited", "(%)", &fallstat); + "fall soil saturation status 0.0 - unlimited/ 100.0 - restricted/ other - limited", "(%)", &fallstat); decldiagparam("Major", TDim::NHRU, "[5]", "1", "100", "threshold for major melt", "(mm/d)", &Major); diff --git a/crhmcode/src/modules/Classevap.cpp b/crhmcode/src/modules/Classevap.cpp index eb0b33546..82dc0c117 100644 --- a/crhmcode/src/modules/Classevap.cpp +++ b/crhmcode/src/modules/Classevap.cpp @@ -164,7 +164,7 @@ void Classevap::run(void) { evap[hh] = (delta(hru_t[hh])*Q*Global::Freq + (RHOa*Cp/ (lambda(hru_t[hh])*1e3)*(Common::estar(hru_t[hh]) - hru_ea[hh])/(ra/86400)))/ - (delta(hru_t[hh]) + gamma(Pa[hh], hru_t[hh])*(1.0 + rs[hh]/ra))/ + (delta(hru_t[hh]) + gamma(Pa[hh], hru_t[hh]) * (1.0 + rs[hh] / (ra / 86400))) / //18Mar2022 correction: add /86400 to ra term, as rs is in d/m and ra is in s/m Global::Freq; } else diff --git a/crhmcode/src/modules/ClassevapD_Resist.cpp b/crhmcode/src/modules/ClassevapD_Resist.cpp index 612a7bfa7..8d6ddbbf4 100644 --- a/crhmcode/src/modules/ClassevapD_Resist.cpp +++ b/crhmcode/src/modules/ClassevapD_Resist.cpp @@ -53,7 +53,7 @@ void ClassevapD_Resist::decl(void) { decldiagparam("F_Qg", TDim::NHRU, "[0.1]", "0.0", "1.0", "fraction to ground flux, Qg = F_Qg*Rn", "()", &F_Qg); - declparam("rcs", TDim::NHRU, "[25]", "25.0", "5000.0", "stomatal resistance (Penman-Monteith/Dalton bulk transfer)", "(s/m)", &rcs); + declparam("rcs", TDim::NHRU, "[25]", "25.0", "5000.0", "minimum stomatal resistance (Penman-Monteith/Dalton bulk transfer)", "(s/m)", &rcs); declparam("Htmax", TDim::NHRU, "[0.1]", "0.1", "100.0", "maximum vegetation height (Penman-Monteith)", "(m)", &Htmax); diff --git a/crhmcode/src/modules/ClassevapX.cpp b/crhmcode/src/modules/ClassevapX.cpp index 248314f24..688a1d1e4 100644 --- a/crhmcode/src/modules/ClassevapX.cpp +++ b/crhmcode/src/modules/ClassevapX.cpp @@ -58,7 +58,7 @@ void ClassevapX::decl(void) { declparam("Zwind", TDim::NHRU, "[10]", "0.01", "100.0", "wind measurement height (used by Penman-Monteith).", "(m)", &Zwind); - declparam("rcs", TDim::NHRU, "[25]", "25.0", "5000.0", "stomatal resistance (used by Penman-Monteith).", "(s/m)", &rcs); + declparam("rcs", TDim::NHRU, "[25]", "25.0", "5000.0", "minimum stomatal resistance (used by Penman-Monteith).", "(s/m)", &rcs); declparam("Htmax", TDim::NHRU, "[0.1]", "0.1", "100.0", "maximum vegetation height (used by Penman-Monteith).", "(m)", &Htmax); diff --git a/crhmcode/src/modules/Classevap_Resist.cpp b/crhmcode/src/modules/Classevap_Resist.cpp index 572b0ae73..2546f4935 100644 --- a/crhmcode/src/modules/Classevap_Resist.cpp +++ b/crhmcode/src/modules/Classevap_Resist.cpp @@ -60,7 +60,7 @@ void Classevap_Resist::decl(void) { decldiagparam("F_Qg", TDim::NHRU, "[0.1]", "0.0", "1.0", "fraction to ground flux, Qg = F_Qg*Rn", "()", &F_Qg); - declparam("rcs", TDim::NHRU, "[25]", "25.0", "5000.0", "stomatal resistance", "(s/m)", &rcs); + declparam("rcs", TDim::NHRU, "[25]", "25.0", "5000.0", "minimum stomatal resistance", "(s/m)", &rcs); declparam("Htmax", TDim::NHRU, "[0.1]", "0.1", "100.0", "maximum vegetation height (Penman-Monteith)", "(m)", &Htmax); diff --git a/crhmcode/src/modules/Classfrozen.cpp b/crhmcode/src/modules/Classfrozen.cpp index 3c49ecd2a..cc0088564 100644 --- a/crhmcode/src/modules/Classfrozen.cpp +++ b/crhmcode/src/modules/Classfrozen.cpp @@ -24,27 +24,27 @@ void Classfrozen::decl(void) { Description = "'Frozen soil infiltration Zhao and Gray (1999).'"; - declvar("infil", TDim::NHRU, "Potential rain infiltration", "(mm/int)", &infil); + declvar("infil", TDim::NHRU, "interval rain infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", TDim::NHRU, "cumulative potential rain infiltration", "(mm)", &cuminfil); + declstatdiag("cuminfil", TDim::NHRU, "cumulative rain infiltration", "(mm)", &cuminfil); - declvar("snowinfil", TDim::NHRU, "melt infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", TDim::NHRU, "interval snowmelt infiltration", "(mm/int)", &snowinfil); declstatvar("cumsnowinfil", TDim::NHRU, "cumulative melt infiltration", "(mm)", &cumsnowinfil); // for looping - declvar("meltrunoff", TDim::NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", TDim::NHRU, "interval snowmelt runoff", "(mm/int)", &meltrunoff); declstatdiag("cummeltrunoff", TDim::NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); - declvar("runoff", TDim::NHRU, "rainfall runoff", "(mm/int)", &runoff); + declvar("runoff", TDim::NHRU, "interval rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", TDim::NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - decllocal("t0_Var", TDim::NHRU, "t0 value used by module", "(h)", &t0_Var); + decllocal("t0_Var", TDim::NHRU, "value of infiltration opportunity time", "(h)", &t0_Var); - decllocal("t0_Acc", TDim::NHRU, "opportunity time", "(h)", &t0_Acc); // to reset every loop + decllocal("t0_Acc", TDim::NHRU, "infiltration opportunity time accumulator", "(h)", &t0_Acc); // to reset every loop - decllocal("INF", TDim::NHRU, "parametric calculation", "(mm)", &INF); + decllocal("INF", TDim::NHRU, "infiltration into a frozen soil calculated from parametric relationship", "(mm)", &INF); decllocal("Julian_window", TDim::ONE, "currently in Julian window handling frozen infiltration.", "()", &Julian_window); diff --git a/crhmcode/src/modules/ClassfrozenAyers.cpp b/crhmcode/src/modules/ClassfrozenAyers.cpp index 11694af20..d1f4ab01e 100644 --- a/crhmcode/src/modules/ClassfrozenAyers.cpp +++ b/crhmcode/src/modules/ClassfrozenAyers.cpp @@ -23,29 +23,29 @@ void ClassfrozenAyers::decl(void) { Description = "'Frozen soil infiltration Zhao and Gray (1999) and Ayers, (1959) for unfrozen soil.'"; - declvar("infil", TDim::NHRU, "Potential rain infiltration", "(mm/int)", &infil); + declvar("infil", TDim::NHRU, "interval rain infiltration", "(mm/int)", &infil); - declstatdiag("cuminfil", TDim::NHRU, "cumulative potential rain infiltration", "(mm)", &cuminfil); + declstatdiag("cuminfil", TDim::NHRU, "cumulative rain infiltration", "(mm)", &cuminfil); - declvar("snowinfil", TDim::NHRU, "melt infiltration", "(mm/int)", &snowinfil); + declvar("snowinfil", TDim::NHRU, "interval snowmelt infiltration", "(mm/int)", &snowinfil); - declstatvar("cumsnowinfil", TDim::NHRU, "cumulative melt infiltration", "(mm)", &cumsnowinfil); // for looping + declstatvar("cumsnowinfil", TDim::NHRU, "cumulative snowmelt infiltration", "(mm)", &cumsnowinfil); // for looping - declvar("cumsnowinfil_0", TDim::NHRU, "cumulative melt infiltration at beginning of frozen cycle", "(mm)", &cumsnowinfil_0); // for looping + declvar("cumsnowinfil_0", TDim::NHRU, "cumulative snowmelt infiltration at beginning of frozen cycle", "(mm)", &cumsnowinfil_0); // for looping - declvar("meltrunoff", TDim::NHRU, "melt runoff", "(mm/int)", &meltrunoff); + declvar("meltrunoff", TDim::NHRU, "interval snowmelt runoff", "(mm/int)", &meltrunoff); - declstatdiag("cummeltrunoff", TDim::NHRU, "cumulative melt runoff", "(mm)", &cummeltrunoff); + declstatdiag("cummeltrunoff", TDim::NHRU, "cumulative snowmelt runoff", "(mm)", &cummeltrunoff); declvar("runoff", TDim::NHRU, "rainfall runoff", "(mm/int)", &runoff); declstatdiag("cumrunoff", TDim::NHRU, "cumulative rainfall runoff", "(mm)", &cumrunoff); - decllocal("t0_Var", TDim::NHRU, "t0 value used by module", "(h)", &t0_Var); + decllocal("t0_Var", TDim::NHRU, "value of infiltration opportunity time", "(h)", &t0_Var); - decllocal("t0_Acc", TDim::NHRU, "opportunity time", "(h)", &t0_Acc); // to reset every loop + decllocal("t0_Acc", TDim::NHRU, "infiltration opportunity time accumulator", "(h)", &t0_Acc); // to reset every loop - decllocal("INF", TDim::NHRU, "parametric calculation", "(mm)", &INF); + decllocal("INF", TDim::NHRU, "infiltration into a frozen soil calculated from parametric relationship", "(mm)", &INF); decllocal("Julian_window", TDim::ONE, "currently in Julian window handling frozen infiltration.", "()", &Julian_window); @@ -80,10 +80,10 @@ void ClassfrozenAyers::decl(void) { "(mm)", &soil_moist_max); declparam("texture", TDim::NHRU, "[1]", "1","4", - "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "(%)", &texture); + "texture: 1 - coarse/medium over coarse, 2 - medium over medium, 3 - medium/fine over fine, 4 - soil over shallow bedrock.", "()", &texture); declparam("groundcover", TDim::NHRU, "[1]", "1","6", - "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "(%)", &groundcover); + "groundcover: 1 - bare soil, 2 - row crop, 3 - poor pasture, 4 - small grains, 5 - good pasture, 6 - forested.", "()", &groundcover); decldiagparam("t0_Julian", TDim::ONE, "[30]", "0","366", "value > 0 - inhibit frozen algorithm till after this Julian date, 0 - enable frozen algorithm immediately when melt criteria is met", "()", &t0_Julian); diff --git a/crhmcode/src/modules/Classglacier.cpp b/crhmcode/src/modules/Classglacier.cpp index 828be1c83..cb864df73 100644 --- a/crhmcode/src/modules/Classglacier.cpp +++ b/crhmcode/src/modules/Classglacier.cpp @@ -48,11 +48,11 @@ void Classglacier::decl(void) { declstatdiag("cumicemelt", TDim::NHRU, "cumulative ice melt", "(mm)", &cumicemelt); - declstatvar("firn_dens", TDim::NDEFN, "densities of snow densification layers", "(kg/m^3)", &firn_dens, &firn_dens_array, Global::nlay); + declstatvar("firn_dens", TDim::NDEFN, "densities of firn layers", "(kg/m^3)", &firn_dens, &firn_dens_array, Global::nlay); - declstatvar("firn_h", TDim::NDEFN, "depths of snow densification layers", "(m)", &firn_h, &firn_h_array, Global::nlay); + declstatvar("firn_h", TDim::NDEFN, "depths of firn layers", "(m)", &firn_h, &firn_h_array, Global::nlay); - declstatvar("firn_yr", TDim::NDEFN, "layer[1] - years to 'critical density] and layer[2, ...] age of firn", "(yr)", &firn_yr, &firn_yr_array, Global::nlay); + declstatvar("firn_yr", TDim::NDEFN, "layer[1] - years to 'critical density' and layer[2, ...] age of firn", "(yr)", &firn_yr, &firn_yr_array, Global::nlay); decldiagparam("firn_dens_init", TDim::NDEFN, "[220.0]", "0.0", "1000.0", "initial densities of firn densification layers", "(kg/m^3)", &firn_dens_init, &firn_dens_array_init, Global::nlay); @@ -112,11 +112,11 @@ void Classglacier::decl(void) { declstatdiag("cumfirn_2ice", TDim::NHRU, "cumulative firn added to ice", "(mm)", &cumfirn_2ice); - declvar("Gnet_rainD", TDim::NHRU, "daily net rain", "(mm/d)", &Gnet_rainD); + declvar("Gnet_rainD", TDim::NHRU, "daily net rain calculated from net_rain", "(mm/d)", &Gnet_rainD); declvar("net_rain_org", TDim::NHRU, "value of 'net_rain' before addition of SWE, firn and ice melt", "(mm/int)", &net_rain_org); - declvar("cumnet_rain_org", TDim::NHRU, "value of 'net_rain' before addition of SWE, firn and ice melt", "(mm)", &cumnet_rain_org); + declvar("cumnet_rain_org", TDim::NHRU, "cumulative value of 'net_rain' before addition of SWE, firn and ice melt", "(mm)", &cumnet_rain_org); ObsCnt_Albedo = declreadobs("glacier_Albedo_obs", TDim::NHRU, "available Albedo observations", "()", &glacier_Albedo_obs, HRU_OBS_misc, true); // HRU_OBS_p_ppt HRU_OBS_misc HRU_OBS_Q HRU_OBS_u HRU_OBS_t_rh_ea @@ -206,7 +206,7 @@ void Classglacier::decl(void) { decldiagparam("tfactor", TDim::NHRU, "[0.0]", "0.0", "10.0", "degree day melt factor", "(mm/d*" + string(DEGREE_CELSIUS) + ")", &tfactor); - decldiagparam("nfactor", TDim::NHRU, "[0.0]", "0.0", "10.0", "net radiation factor (typical value 3.0(mm*m^2/MJ))", "(mm*m^2/MJ)", &nfactor); + decldiagparam("nfactor", TDim::NHRU, "[0.0]", "0.0", "10.0", "net radiation factor (typical value 3.0(mm*m^2/MJ*d))", "(mm*m^2/MJ)", &nfactor); decldiagparam("Use_QnD", TDim::NHRU, "[0]", "0", "1", "1 - Use QnD if available", "()", &Use_QnD); diff --git a/crhmcode/src/modules/Classinterception.cpp b/crhmcode/src/modules/Classinterception.cpp index 909d12e7f..67c081545 100644 --- a/crhmcode/src/modules/Classinterception.cpp +++ b/crhmcode/src/modules/Classinterception.cpp @@ -26,7 +26,7 @@ void Classinterception::decl(void) { declvar("SI_Lo", TDim::NHRU, "Canopy load", "(kg/m^2)", &SI_Lo); - declvar("net_snow", TDim::NHRU, "Canopy unload ", "(kg/m^2)", &net_snow); + declvar("net_snow", TDim::NHRU, "Canopy unload ", "(kg/m^2*int)", &net_snow); decldiag("Cum_net_snow", TDim::NHRU, "Cumulative Canopy unload ", "(kg/m^2)", &Cum_net_snow); diff --git a/crhmcode/src/modules/Classlake.cpp b/crhmcode/src/modules/Classlake.cpp index ac1ea4852..589adbbab 100644 --- a/crhmcode/src/modules/Classlake.cpp +++ b/crhmcode/src/modules/Classlake.cpp @@ -39,15 +39,15 @@ void Classlake::decl(void) { declvar("hru_t_Mmean", TDim::NHRU, "HRU temperature", "(" + string(DEGREE_CELSIUS) + ")", &hru_t_Mmean); - declvar("hru_rh_Mmean", TDim::NHRU, "HRU rh", "()", &hru_rh_Mmean); + declvar("hru_rh_Mmean", TDim::NHRU, "HRU rh", "(%)", &hru_rh_Mmean); declvar("hru_u_Mmean", TDim::NHRU, "HRU wind speed", "(m/s)", &hru_u_Mmean); - decllocal("hru_t_acc", TDim::NHRU, "HRU t accumulated", "(" + string(DEGREE_CELSIUS) + ")", &hru_t_acc); + decllocal("hru_t_acc", TDim::NHRU, "HRU t accumulated", "(" + string(DEGREE_CELSIUS) + "*N)", &hru_t_acc); - decllocal("hru_rh_acc", TDim::NHRU, "HRU rh accumulated", "()", &hru_rh_acc); + decllocal("hru_rh_acc", TDim::NHRU, "HRU rh accumulated", "(%*N)", &hru_rh_acc); - decllocal("hru_u_acc", TDim::NHRU, "HRU u accumulated", "(m)", &hru_u_acc); + decllocal("hru_u_acc", TDim::NHRU, "HRU u accumulated", "(m/s*N)", &hru_u_acc); decllocal("start_open_day", TDim::NHRU, "TDate format start of open water", "()", &start_open_day); diff --git a/crhmcode/src/modules/Classnetall.cpp b/crhmcode/src/modules/Classnetall.cpp index a709dd203..57a246a22 100644 --- a/crhmcode/src/modules/Classnetall.cpp +++ b/crhmcode/src/modules/Classnetall.cpp @@ -24,17 +24,17 @@ void Classnetall::decl(void) { Description = "'Models net all-wave radiation (Rn, RnD and RnD_POS) from sunshine hours, temperature and humidity using Brunt.'"; - declvar("net", TDim::NHRU, "all-wave net", "(MJ/m^2*int)", &net); + declvar("net", TDim::NHRU, "net all-wave radiation over time step", "(MJ/m^2*int)", &net); - decldiag("Rn", TDim::NHRU, "all-wave net", "(mm/m^2*int)", &Rn); + decldiag("Rn", TDim::NHRU, "net all-wave radiation over time step", "(mm/m^2*int)", &Rn); - declvar("netD", TDim::NHRU, "all-wave net", "(MJ/m^2*d)", &netD); + declvar("netD", TDim::NHRU, "net all-wave radiation per day", "(MJ/m^2*d)", &netD); - declvar("RnD", TDim::NHRU, "all-wave net", "(mm/m^2*d)", &RnD); + declvar("RnD", TDim::NHRU, "net all-wave radiation per day", "(mm/m^2*d)", &RnD); - decldiag("RnD_POS", TDim::NHRU, "Sum of Positive all-wave net", "(mm/m^2*d)", &RnD_POS); + decldiag("RnD_POS", TDim::NHRU, "Sum of positive net all-wave radiation per day", "(mm/m^2*d)", &RnD_POS); - declstatdiag("cum_net", TDim::NHRU, "cumulative all-wave net", "(MJ/m^2)", &cum_net); + declstatdiag("cum_net", TDim::NHRU, "cumulative net all-wave radiation", "(MJ/m^2)", &cum_net); declgetvar("*", "hru_t", "(" + string(DEGREE_CELSIUS) + ")", &hru_t); diff --git a/crhmcode/src/modules/Classtsurface.cpp b/crhmcode/src/modules/Classtsurface.cpp index 3c747ec7b..a6b18f0d2 100644 --- a/crhmcode/src/modules/Classtsurface.cpp +++ b/crhmcode/src/modules/Classtsurface.cpp @@ -30,11 +30,11 @@ void Classtsurface::decl(void) { 'use previous daily mean snowpack temperature with thermal conductivity and energy of snowpack (***Snobal*** case) to estimate surface temperature during snowcover period; use parameter n_factor to estimate surface temperature from the air temperature during snow free periods (Woo, 2012, p. 57).' \ 'use previous daily mean hru_t with thermal conductivity and energy of snowpack (***ebsm*** case) to estimate surface temperature during snowcover period; use parameter n_factor to estimate surface temperature from the air temperature during snow free periods (Woo, 2012, p. 57). '"; - declvar("hru_tsf", TDim::NHRU, "surface/skin temperature", "(" + string(DEGREE_CELSIUS) + ")", &hru_tsf); + declvar("hru_tsf", TDim::NHRU, "temperature accumulator used to calculate the daily mean hru_tsfD", "(" + string(DEGREE_CELSIUS) + ")", &hru_tsf); declvar("hru_tsf_D", TDim::NHRU, "mean daily surface/skin temperature", "(" + string(DEGREE_CELSIUS) + ")", &hru_tsf_D); - decldiag("hru_tsf_acc", TDim::NHRU, "mean daily surface/skin temperature", "(" + string(DEGREE_CELSIUS) + ")", &hru_tsf_acc); + decldiag("hru_tsf_acc", TDim::NHRU, "temperature accumulator used to calculate the daily mean hru_tsfD", "(" + string(DEGREE_CELSIUS) + ")", &hru_tsf_acc); declgetvar("*", "SWE", "(m)", &SWE); @@ -45,7 +45,7 @@ void Classtsurface::decl(void) { decllocal("hru_T_s_D", TDim::NHRU, "mean daily surface/skin temperature", "(" + string(DEGREE_CELSIUS) + ")", &hru_T_s_D); - decllocal("hru_T_s_acc", TDim::NHRU, "sum interval air temperature from previous day", "(" + string(DEGREE_CELSIUS) + ")", &hru_T_s_acc); + decllocal("hru_T_s_acc", TDim::NHRU, "temperature accumulator used to calculate the previous daily mean snowpack temperature hru_T_s_D", "(" + string(DEGREE_CELSIUS) + ")", &hru_T_s_acc); declgetvar("*", "z_s", "(m)", &z_s); @@ -60,7 +60,7 @@ void Classtsurface::decl(void) { decllocal("hru_t_D", TDim::NHRU, "mean daily snowpack temperature from previous day", "(" + string(DEGREE_CELSIUS) + ")", &hru_t_D); - decllocal("hru_t_acc", TDim::NHRU, "sum interval air temperature from previous day", "(" + string(DEGREE_CELSIUS) + ")", &hru_t_acc); + decllocal("hru_t_acc", TDim::NHRU, "temperature accumulator used to calculate the previous daily air temperature hru_t_D", "(" + string(DEGREE_CELSIUS) + ")", &hru_t_acc); declgetvar("*", "hru_tmin", "(" + string(DEGREE_CELSIUS) + ")", &tmin); @@ -99,7 +99,7 @@ void Classtsurface::decl(void) { variation_set = VARIATION_2 + VARIATION_3 + VARIATION_4 + VARIATION_5; - declvar("SWE_tc", TDim::NHRU, "SWE thermal conductivity", "(W/(m*K)", &SWE_tc); + declvar("SWE_tc", TDim::NHRU, "SWE thermal conductivity", "(W/(m*K))", &SWE_tc); declvar("SWE_density", TDim::NHRU, "SWE density", "( kg/m^3)", &SWE_density); diff --git a/crhmcode/src/modules/newmodules/NewModules.cpp b/crhmcode/src/modules/newmodules/NewModules.cpp index f707b0f10..44f22e0af 100644 --- a/crhmcode/src/modules/newmodules/NewModules.cpp +++ b/crhmcode/src/modules/newmodules/NewModules.cpp @@ -154,52 +154,52 @@ void MoveModulesToGlobal(string DLLName) DLLModules.AddModule(new Classsbsm("sbsm", "10/21/09", LMODULE::ADVANCE)); DLLModules.AddModule(new ClassAnnan("Annandale", "07/14/11", LMODULE::ADVANCE)); DLLModules.AddModule(new Classebsm("ebsm", "01/18/16", LMODULE::BASIC)); - DLLModules.AddModule(new ClassLongVt("longVt", "02/10/16", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassLongVt("longVt", "04/04/22", LMODULE::ADVANCE)); DLLModules.AddModule(new ClassSlope_Qsi("Slope_Qsi", "07/14/11", LMODULE::ADVANCE)); DLLModules.AddModule(new Classalbedo("albedo", "08/11/11", LMODULE::BASIC)); - DLLModules.AddModule(new Classnetall("netall", "03/22/16", LMODULE::BASIC)); - DLLModules.AddModule(new Classevap("evap", "09/26/13", LMODULE::BASIC)); + DLLModules.AddModule(new Classnetall("netall", "04/04/22", LMODULE::BASIC)); + DLLModules.AddModule(new Classevap("evap", "03/18/22", LMODULE::BASIC)); DLLModules.AddModule(new ClassevapD("evapD", "11/04/09", LMODULE::ADVANCE)); - DLLModules.AddModule(new Classevap_Resist("evap_Resist", "06/09/20", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassevapD_Resist("evapD_Resist", "06/09/20", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassShutWall("ShuttleWallace", "10/05/06", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassShutWallD("ShuttleWallaceD", "10/05/06", LMODULE::ADVANCE)); - DLLModules.AddModule(new Classcrack("crack", "03/31/20", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassPrairieInfil("PrairieInfiltration", "03/31/20", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassAyers("Ayers", "01/11/17", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassGreencrack("Greencrack", "03/31/20", LMODULE::BASIC)); - DLLModules.AddModule(new ClassGreenAmpt("GreenAmpt", "03/29/10", LMODULE::ADVANCE)); - DLLModules.AddModule(new Classfrozen("frozen", "08/03/17", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassfrozenAyers("frozenAyers", "03/30/20", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassSoil("Soil", "02/01/21", LMODULE::BASIC)); - DLLModules.AddModule(new ClassevapX("evapX", "06/09/20", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassSoilX("SoilX", "11/28/17", LMODULE::ADVANCE)); // nlay >= 2 check added - DLLModules.AddModule(new ClassSoilDS("SoilDetention", "11/28/17", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassSoilPrairie("SoilPrairie", "10/22/18", LMODULE::PROTO)); // prototype wetlands - DLLModules.AddModule(new Classglacier("glacier", "07/02/20", LMODULE::ADVANCE)); + DLLModules.AddModule(new Classevap_Resist("evap_Resist", "04/04/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassevapD_Resist("evapD_Resist", "04/04/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassShutWall("ShuttleWallace", "04/04/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassShutWallD("ShuttleWallaceD", "04/04/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new Classcrack("crack", "04/04/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassPrairieInfil("PrairieInfiltration", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassAyers("Ayers", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassGreencrack("Greencrack", "04/04/22", LMODULE::BASIC)); + DLLModules.AddModule(new ClassGreenAmpt("GreenAmpt", "04/04/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new Classfrozen("frozen", "04/04/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassfrozenAyers("frozenAyers", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassSoil("Soil", "04/05/22", LMODULE::BASIC)); + DLLModules.AddModule(new ClassevapX("evapX", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassSoilX("SoilX", "04/05/22", LMODULE::ADVANCE)); // nlay >= 2 check added + DLLModules.AddModule(new ClassSoilDS("SoilDetention", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassSoilPrairie("SoilPrairie", "04/05/22", LMODULE::PROTO)); // prototype wetlands + DLLModules.AddModule(new Classglacier("glacier", "04/05/22", LMODULE::ADVANCE)); DLLModules.AddModule(new Classglacier_debris("glacier_debris", "11/22/19", LMODULE::ADVANCE)); DLLModules.AddModule(new ClassGlacier_debris_cover("Glacier_debris_cover", "10/17/19", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassSWEslope("SWESlope", "11/01/17", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassSWEslope("SWESlope", "04/05/22", LMODULE::ADVANCE)); DLLModules.AddModule(new ClassICEflow("ICEflow", "12/31/18", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassNetroute("Netroute", "06/20/18", LMODULE::BASIC)); - DLLModules.AddModule(new ClassNetroute_D("Netroute_D", "06/20/18", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassNetroute_M("Netroute_M", "06/20/18", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassNetroute_M_D("Netroute_M_D", "10/26/18", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassREWroute("REW_route", "06/19/18", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassNetroute("Netroute", "04/05/22", LMODULE::BASIC)); + DLLModules.AddModule(new ClassNetroute_D("Netroute_D", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassNetroute_M("Netroute_M", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassNetroute_M_D("Netroute_M_D", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassREWroute("REW_route", "04/05/22", LMODULE::ADVANCE)); DLLModules.AddModule(new ClassREWroute_stream("REW_route_stream", "07/09/18", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassREWroute2("REW_route2", "06/19/18", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassREWroute2("REW_route2", "04/05/22", LMODULE::ADVANCE)); DLLModules.AddModule(new ClassSnobalCRHM("SnobalCRHM", "11/21/16", LMODULE::ADVANCE)); DLLModules.AddModule(new ClasspbsmSnobal("pbsmSnobal", "01/05/17", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassCRHMCanopy("Canopy", "06/14/17", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassCRHMCanopyClearing("CanopyClearing", "04/05/19", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassCRHMCanopyClearingGap("CanopyClearingGap", "04/05/19", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassNeedle("NeedleLeaf", "07/19/11", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassCRHMCanopy("Canopy", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassCRHMCanopyClearing("CanopyClearing", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassCRHMCanopyClearingGap("CanopyClearingGap", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassNeedle("NeedleLeaf", "04/05/22", LMODULE::ADVANCE)); DLLModules.AddModule(new Classwalmsley_wind("walmsley_wind", "07/30/08", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassXG("XG", "10/03/17", LMODULE::ADVANCE)); + DLLModules.AddModule(new ClassXG("XG", "04/05/22", LMODULE::ADVANCE)); DLLModules.AddModule(new ClassXGAyers("XGAyers", "05/19/17", LMODULE::PROTO)); DLLModules.AddModule(new ClassSetSoil("SetSoil", "10/21/09", LMODULE::ADVANCE)); - DLLModules.AddModule(new ClassVolumetric("Volumetric", "03/15/21", LMODULE::ADVANCE)); - DLLModules.AddModule(new Classtsurface("tsurface", "01/15/19", LMODULE::PROTO)); + DLLModules.AddModule(new ClassVolumetric("Volumetric", "04/05/22", LMODULE::ADVANCE)); + DLLModules.AddModule(new Classtsurface("tsurface", "04/05/22", LMODULE::PROTO)); DLLModules.AddModule(new Classalbedoparam("albedo_param", "11/22/05", LMODULE::SUPPORT)); DLLModules.AddModule(new Classalbedoobs("albedo_obs", "11/22/05", LMODULE::SUPPORT)); DLLModules.AddModule(new ClassalbedoRichard("albedo_Richard", "03/19/15", LMODULE::SUPPORT)); @@ -214,10 +214,10 @@ void MoveModulesToGlobal(string DLLName) DLLModules.AddModule(new ClassSimpleRichard("SimpleSnow", "03/24/06", LMODULE::CUSTOM)); DLLModules.AddModule(new ClassKevin("Kevin", "08/11/11", LMODULE::OBSOL)); DLLModules.AddModule(new ClassTs("Tsnow", "01/15/13", LMODULE::CUSTOM)); - DLLModules.AddModule(new ClassK_Estimate("K_Estimate", "01/16/18", LMODULE::ADVANCE)); // fixed 'put' descriptions + DLLModules.AddModule(new ClassK_Estimate("K_Estimate", "04/06/22", LMODULE::ADVANCE)); // fixed 'put' descriptions DLLModules.AddModule(new ClassSnobalX("Snobal", "02/03/16", LMODULE::OBSOL)); - DLLModules.AddModule(new Classinterception("interception", "11/03/06", LMODULE::OBSOL)); - DLLModules.AddModule(new Classlake("lake_evap", "07/04/12", LMODULE::ADVANCE)); + DLLModules.AddModule(new Classinterception("interception", "04/05/22", LMODULE::OBSOL)); + DLLModules.AddModule(new Classlake("lake_evap", "04/05/22", LMODULE::ADVANCE)); if(!RELEASE) { diff --git a/crhmcode/src/modules/waterquality/ClassSoilPrairie.cpp b/crhmcode/src/modules/waterquality/ClassSoilPrairie.cpp index 8bcf911aa..8eb587ebb 100644 --- a/crhmcode/src/modules/waterquality/ClassSoilPrairie.cpp +++ b/crhmcode/src/modules/waterquality/ClassSoilPrairie.cpp @@ -93,25 +93,25 @@ void ClassSoilPrairie::decl(void) { declvar("infil_act_D", TDim::NHRU, "Daily actual amount of water infiltrating the soil on each HRU.", "(mm/d)", &infil_act_D); - declstatdiag("cum_gw_flow", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_gw_flow); + declstatdiag("cum_gw_flow", TDim::NHRU, "cumulative groundwater flow from HRU groundwater reservoirs.", "(mm)", &cum_gw_flow); - declvar("soil_ssr", TDim::NHRU, "Portion of soil moisture and recharge excess from a HRU that enters subsurface reservoirs.", "(mm/int)", &soil_ssr); + declvar("soil_ssr", TDim::NHRU, "subsurface runoff from soil layers and depressional storage.", "(mm/int)", &soil_ssr); - declvar("rechr_ssr", TDim::NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/int)", &rechr_ssr); + declvar("rechr_ssr", TDim::NHRU, "subsurface runoff from soil recharge layer.", "(mm/int)", &rechr_ssr); - declstatdiag("cum_soil_ssr", TDim::NHRU, "Accumulation of soil moisture from a HRU to ssr.", "(mm)", &cum_soil_ssr); + declstatdiag("cum_soil_ssr", TDim::NHRU, "cumulative subsurface runoff from layers and depressional storage.", "(mm)", &cum_soil_ssr); - declstatdiag("cum_rechr_ssr", TDim::NHRU, "Accumulation of Portion of excess from a HRU to ssr.", "(mm)", &cum_rechr_ssr); + declstatdiag("cum_rechr_ssr", TDim::NHRU, "cumulative subsurface runoff from soil recharge layer.", "(mm)", &cum_rechr_ssr); - declvar("soil_ssr_D", TDim::NHRU, "Portion of excess soil water from a HRU that enters subsurface reservoirs.", "(mm/d)", &soil_ssr_D); + declvar("soil_ssr_D", TDim::NHRU, "daily accumulation of soil_ssr.", "(mm/d)", &soil_ssr_D); declvar("soil_runoff", TDim::NHRU, "Portion of excess soil water from a HRU to runoff.", "(mm/int)", &soil_runoff); declstatdiag("cum_soil_runoff", TDim::NHRU, "Accumulation of Portion of excess soil water from a HRU to runoff.", "(mm)", &cum_soil_runoff); - declvar("soil_runoff_D", TDim::NHRU, "Portion of excess soil water from a HRU that enters groundwater reservoirs.", "(mm/d)", &soil_runoff_D); + declvar("soil_runoff_D", TDim::NHRU, "daily accumulation of soil_runoff.", "(mm/d)", &soil_runoff_D); - decldiag("cum_runoff_to_Sd", TDim::NHRU, "Cumulative portion of runoff to depression storage.", "(mm/int)", &cum_runoff_to_Sd); + decldiag("cum_runoff_to_Sd", TDim::NHRU, "Cumulative portion of runoff to depression storage.", "(mm)", &cum_runoff_to_Sd); decldiag("cum_soil_gw", TDim::NHRU, "Accumulation of excess soil water from a HRU that enters groundwater reservoirs.", "(mm)", &cum_soil_gw); @@ -130,7 +130,7 @@ void ClassSoilPrairie::decl(void) { decllocal("meltrunoff_buf", TDim::NHRU, "buffer melt runoff.", "(mm/d)", &meltrunoff_buf); - decllocal("hru_evap_buf", TDim::NHRU, "buffer evaporation.", "(mm/d)", &hru_evap_buf); + decllocal("hru_evap_buf", TDim::NHRU, "buffer evaporation.", "(mm/int)", &hru_evap_buf); decllocal("hru_evap_PT_buf", TDim::NHRU, "Priestley-Taylor buffer evaporation", "(mm/d)", &hru_evap_PT_buf); @@ -173,13 +173,13 @@ void ClassSoilPrairie::decl(void) { declparam("gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ground water drainage from gw reservoir.", "(mm/d)", &gw_K); - declparam("rechr_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge.", "(mm/d)", &rechr_ssr_K); + declparam("rechr_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from recharge layer (soil_rechr).", "(mm/d)", &rechr_ssr_K); - declparam("lower_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from soil column.", "(mm/d)", &lower_ssr_K); + declparam("lower_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage from lower soil layer (soil_moist - soil_rechr).", "(mm/d)", &lower_ssr_K); - declparam("Sd_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily depression storage ssr drainage factor.", "(mm/d)", &Sd_ssr_K); + declparam("Sd_ssr_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily ssr drainage factor from depression storage.", "(mm/d)", &Sd_ssr_K); - declparam("Sd_gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily depression storage gw drainage.", "(mm/d)", &Sd_gw_K); + declparam("Sd_gw_K", TDim::NHRU, "[0.0]", "0.", "100.0", "daily drainage factor to groundwater reservoir from depression storage.", "(mm/d)", &Sd_gw_K); declparam("Sd_water_frac_max", TDim::NHRU, "[0.24]", "0.0", "1.0", "Maximum fraction of the HRU area that can be water.", "()", &Sd_water_frac_max);