/*****************************************************************************
MassEnergyBalance()
*****************************************************************************/
void MassEnergyBalance(int y, int x, float SineSolarAltitude, float DX,
float DY, int Dt, int HeatFluxOption,
int CanopyRadAttOption, int MaxVegLayers,
PIXMET *LocalMet, ROADSTRUCT *LocalNetwork, CHANNEL *ChannelData,
PRECIPPIX *LocalPrecip, VEGTABLE *VType,
VEGCHEMPIX *LocalVeg, SOILTABLE *SType,
SOILPIX *LocalSoil, SNOWPIX *LocalSnow,
EVAPPIX *LocalEvap, PIXRAD *TotalRad, CHEMTABLE *ChemTable,
SOILCHEMTABLE *SCType, VEGCHEMTABLE *VCType, DATE CurDate, BASINWIDE * Basinwide, GWPIX *LocalGW,
GEOTABLE *GType, float Slope, MAPSIZE *Map, VEGCHEMPIX **VegChemMap,OPTIONSTRUCT *Options,
int NSoilLayers, SOILPIX ** SoilMap, GWPIX ** Groundwater,
int NpsCats, NPSPIX **NpsMap, NONPOINTSOURCE **NpsTable,
AGGREGATED *Total, int NChems, int HasGroundwater, TOPOPIX ** TopoMap, float **PopulationMap)
{
PIXRAD LocalRad; /* Radiation balance components (W/m^2) */
float SurfaceWater_m; /* Pixel average depth of water before infiltration is calculated (m) */
float Infiltration; /* Infiltration into the top soil layer (m) */
float LowerRa; /* Aerodynamic resistance for lower layer (s/m) */
float LowerWind; /* Wind for lower layer (m/s) */
float MaxInfiltration; /* Maximum infiltration into the top soil layer (m) */
float MaxRoadbedInfiltration; /* Maximum infiltration through the road bed soil layer (m) */
float MeltEnergy; /* Energy used to melt snow and change of cold content of snow pack */
float MoistureFlux; /* Amount of water transported from the pixel to the atmosphere (m/timestep) */
float NetRadiation; /* Net radiation for a layer (W/m2) */
float Reference; /* Reference height for sensible heat calculation (m) */
float RoadbedInfiltration; /* Infiltration through the road bed (m) */
float Roughness; /* Roughness length (m) */
float Rp; /* radiation flux in visible part of the spectrum (W/m^2) */
float UpperRa; /* Aerodynamic resistance for upper layer (s/m) */
float UpperWind; /* Wind for upper layer (m/s) */
float SnowLongIn; /* Incoming longwave radiation at snow surface (W/m2) */
float SnowNetShort; /* Net amount of short wave radiation at the snow surface (W/m2) */
float SnowRa; /* Aerodynamic resistance for snow */
float SnowWind; /* Wind 2 m above snow */
float Tsurf; /* Surface temperature used in LongwaveBalance() (C) */
int NVegLActual; /* Number of vegetation layers above snow */
int HasSnow;
float SurfaceSoilWaterFlux; /* Track the movement from soil to surfce or vice versa for use in Chemistry routing, MWW -sc */
float Thrufall = 0.0; /* Temporarily stores the amount of rainfall for use in atmospheric deposition of Chems, MWW -sc */
int CurMonth = CurDate.Month; /* current month*/
ApplyNonPointSources(x,y,NSoilLayers, SoilMap, Groundwater, ChemTable, NpsCats, NpsMap, NpsTable, Total,
NChems, HasGroundwater, Map, TopoMap, PopulationMap, VType, VegChemMap);
NVegLActual = VType->NVegLayers;
if (LocalSnow->HasSnow == TRUE && VType->UnderStory == TRUE)--NVegLActual;
/* initialize the total amount of evapotranspiration, and MeltEnergy */
LocalEvap->ETot = 0.0;
LocalEvap->ET_potential = 0.0;
MeltEnergy = 0.0;
MoistureFlux = 0.0;
/* calculate the radiation balance for the ground/snow surface and the
vegetation layers above that surface */
RadiationBalance(HeatFluxOption, CanopyRadAttOption, SineSolarAltitude,
LocalMet->Sin, LocalMet->SinBeam, LocalMet->SinDiffuse,
LocalMet->Lin, LocalMet->Tair, LocalVeg->Tcanopy,
LocalSoil->TSurf, SType->Albedo, VType, LocalSnow,
&LocalRad);
/* calculate the actual aerodynamic resistances and wind speeds */
UpperWind = VType->U[0] * LocalMet->Wind;
UpperRa = VType->Ra[0] / LocalMet->Wind;
if((isnan(UpperRa))) assert(FALSE); //JASONS EDIT: 061025 moved from 3 lines above, because otherwise, was checking isNAN before being set!
if (VType->OverStory == TRUE) {
LowerWind = VType->U[1] * LocalMet->Wind;
LowerRa = VType->Ra[1] / LocalMet->Wind;
}
else {
LowerWind = UpperWind;
LowerRa = UpperRa;
}
/* calculate the amount of interception storage, and the amount of
throughfall. Of course this only needs to be done if there is
vegetation present. */
#ifndef NO_SNOW
if (VType->OverStory == TRUE &&
(LocalPrecip->IntSnow[0] || LocalPrecip->SnowFall > 0.0)) {
SnowInterception(y, x, Dt, VType->Fract[0], VType->LAI[0],
VType->MaxInt[0], VType->MaxSnowInt, VType->MDRatio,
VType->SnowIntEff, UpperRa, LocalMet->AirDens,
LocalMet->Eact, LocalMet->Lv, &LocalRad, LocalMet->Press,
LocalMet->Tair, LocalMet->Vpd, UpperWind,
&(LocalPrecip->RainFall), &(LocalPrecip->SnowFall),
&(LocalPrecip->IntRain[0]), &(LocalPrecip->IntSnow[0]),
&(LocalPrecip->TempIntStorage),
&(LocalSnow->CanopyVaporMassFlux), &(LocalVeg->Tcanopy),
&MeltEnergy);
MoistureFlux -= LocalSnow->CanopyVaporMassFlux;
// Because we now have a new estimate of the canopy temperature we can recalculate the longwave balance
if (LocalSnow->HasSnow == TRUE)Tsurf = LocalSnow->TSurf;
else if (HeatFluxOption == TRUE)Tsurf = LocalSoil->TSurf;
else Tsurf = LocalMet->Tair;
LongwaveBalance(VType->OverStory, VType->Fract[0], LocalMet->Lin, LocalVeg->Tcanopy, Tsurf, &LocalRad);
}//if no snow, then calculate rain interception
else if (VType->NVegLayers > 0) {
LocalVeg->Tcanopy = LocalMet->Tair;
LocalSnow->CanopyVaporMassFlux = 0.0;
LocalPrecip->TempIntStorage = 0.0;
InterceptionStorage(VType->NVegLayers, NVegLActual, VType->MaxInt,VType->Fract, LocalPrecip->IntRain,&(LocalPrecip->RainFall));
}
Thrufall = LocalPrecip->RainFall;
/* if snow is present, simulate the snow pack dynamics */
if (LocalSnow->HasSnow || LocalPrecip->SnowFall > 0.0) {
if (VType->OverStory == TRUE) {
SnowLongIn = LocalRad.LongIn[1];
SnowNetShort = LocalRad.NetShort[1];
}
else {
SnowLongIn = LocalRad.LongIn[0];
SnowNetShort = LocalRad.NetShort[0];
}
SnowWind = VType->USnow * LocalMet->Wind;
SnowRa = VType->RaSnow / LocalMet->Wind;
LocalSnow->Outflow =
SnowMelt(y, x, Dt, 2. + Z0_SNOW, 0.f, Z0_SNOW, SnowRa, LocalMet->AirDens,
LocalMet->Eact, LocalMet->Lv, SnowNetShort, SnowLongIn,
LocalMet->Press, LocalPrecip->RainFall, LocalPrecip->SnowFall,
LocalMet->Tair, LocalMet->Vpd, SnowWind,
&(LocalSnow->PackWater), &(LocalSnow->SurfWater),
&(LocalSnow->Swq), &(LocalSnow->VaporMassFlux),
&(LocalSnow->TPack), &(LocalSnow->TSurf), &MeltEnergy,
&(LocalSnow->ShearStress), &(LocalSnow->IceA), &(LocalSnow->IceVelocity), Slope );
/* Rainfall was added to SurfWater of the snow pack and has to be set to zero */
LocalPrecip->RainFall = 0.0;
MoistureFlux -= LocalSnow->VaporMassFlux;
/* Because we now have a new estimate of the snow surface temperature we can recalculate the longwave balance */
Tsurf = LocalSnow->TSurf;
LongwaveBalance(VType->OverStory, VType->Fract[0], LocalMet->Lin,
LocalVeg->Tcanopy, Tsurf, &LocalRad);
}
else {
LocalSnow->Outflow = 0.0;
LocalSnow->VaporMassFlux = 0.0;
}
/* Determine whether a snow pack is still present, or whether everything
has melted */
if (LocalSnow->Swq > 0.0)LocalSnow->HasSnow = TRUE;
else LocalSnow->HasSnow = FALSE;
/*do the glacier add */
if (LocalSnow->Swq < 1.0 && VType->Index == GLACIER) {
printf("resetting glacier swe of %f to 5.0 meters\n", LocalSnow->Swq);
LocalSnow->Glacier += (5.0 - LocalSnow->Swq);
LocalSnow->Swq = 5.0;
LocalSnow->TPack = 0.0;
LocalSnow->TSurf = 0.0;
}
#endif //end if there is snow
#ifndef NO_ET
/* calculate the amount of evapotranspiration from each vegetation layer
above the ground/soil surface. Also calculate the total amount of
evapotranspiration from the vegetation */
// NetRadiation=0; //JASONS EDIT: BUGBUG: the following line uses this as a param, but it is not yet defined.
/* Calculate the potentail ET, this is not used for any other calcs but is a desired
output in some situations, VARID added as 100. MWW 052405 */
/* LocalEvap->ET_potential = ((LocalMet->Slope/(LocalMet->Slope + LocalMet->Gamma) * NetRadiation) +
(LocalMet->Gamma/(LocalMet->Slope + LocalMet->Gamma) *
(6.43*(1+0.536*LocalMet->Wind)*LocalMet->Vpd/1000)/LocalMet->Lv))/
(WATER_DENSITY * LocalMet->Lv);
LocalEvap->ET_potential *=Dt; // convert to meters per timestep
*/
//calculate evapotranspiration if overstory present
if (VType->OverStory == TRUE) {
Rp = VISFRACT * LocalRad.NetShort[0];
NetRadiation = LocalRad.NetShort[0] + LocalRad.LongIn[0] - 2 * VType->Fract[0] * LocalRad.LongOut[0];
EvapoTranspiration(0, Dt, LocalMet, NetRadiation, Rp, VType, SType,
MoistureFlux, LocalSoil, &(LocalPrecip->IntRain[0]), LocalEvap, LocalNetwork->Adjust, UpperRa, Total);
MoistureFlux += LocalEvap->EAct[0] + LocalEvap->EInt[0];
if (LocalSnow->HasSnow != TRUE) {//calc understory evapotranspiration if there is no snow
Rp = VISFRACT * LocalRad.NetShort[1];
NetRadiation = LocalRad.NetShort[1] + LocalRad.LongIn[1] - VType->Fract[1] * LocalRad.LongOut[1];
EvapoTranspiration(1, Dt, LocalMet, NetRadiation, Rp, VType, SType,
MoistureFlux, LocalSoil, &(LocalPrecip->IntRain[1]), LocalEvap, LocalNetwork->Adjust, LowerRa, Total);
MoistureFlux += LocalEvap->EAct[1] + LocalEvap->EInt[1];
}
else {//calc understory evapotranspiration if there is snow
LocalEvap->EAct[1] = 0.;
LocalEvap->EInt[1] = 0.;
}
}//end overstory == true
// calc evapotranspiration if there is understory but not overstory and no snow
else if (LocalSnow->HasSnow != TRUE && VType->UnderStory == TRUE) {
Rp = VISFRACT * LocalRad.NetShort[0];
NetRadiation = LocalRad.NetShort[0] + LocalRad.LongIn[0] - VType->Fract[0] * LocalRad.LongOut[0];
EvapoTranspiration(0, Dt, LocalMet, NetRadiation, Rp, VType, SType,MoistureFlux, LocalSoil, &(LocalPrecip->IntRain[0]),
LocalEvap, LocalNetwork->Adjust, LowerRa, Total);
MoistureFlux += LocalEvap->EAct[0] + LocalEvap->EInt[0];
}
// calc evapotranspiration if there is snow and understory
else if (VType->UnderStory == TRUE) {
LocalEvap->EAct[0] = 0.;
LocalEvap->EInt[0] = 0.;
}
// Calculate soil evaporation from the upper soil layer if no snow is present and there is no understory
if (LocalSnow->HasSnow != TRUE && VType->UnderStory != TRUE) {
if (VType->OverStory == TRUE){
printf("this should never happen.");
ASSERTTEST(NetRadiation = LocalRad.NetShort[1] + LocalRad.LongIn[1] - LocalRad.LongOut[1]);
}
else
ASSERTTEST(NetRadiation =LocalRad.NetShort[0] + LocalRad.LongIn[0] - LocalRad.LongOut[0]);
NEGTEST(LocalEvap->EvapSoil =
SoilEvaporation(Dt, LocalMet->Tair, LocalMet->Slope, LocalMet->Gamma,
LocalMet->Lv, LocalMet->AirDens, LocalMet->Vpd,
NetRadiation, LowerRa, MoistureFlux, SType->Porosity[0],
SType->Ks[0], SType->Press[0], SType->PoreDist[0],
VType->RootDepth_m[0], &(LocalSoil->Moist_m_m[0]),
LocalNetwork->Adjust[0], &(LocalEvap->ET_potential)));
}
else
LocalEvap->EvapSoil = 0.0;
ASSERTTEST(MoistureFlux += LocalEvap->EvapSoil);
if(LocalEvap->ETot <0){
printf("negative total evap: %g\n",LocalEvap->ETot);
LocalEvap->ETot=0;
}
#endif
/* add the water that was not intercepted to the upper soil layer */
#ifndef NO_SOIL
LocalSoil->SurfaceWater_m = 0.0;
NEGTEST(SurfaceWater_m = LocalPrecip->RainFall + LocalSoil->Runoff_m + LocalSnow->Outflow);
NEGTEST(MaxInfiltration = (1 - VType->ImpervFrac) * LocalNetwork->PercArea[0] * SType->MaxInfiltrationRate * Dt);
Infiltration = min(MaxInfiltration,(1 - VType->ImpervFrac) * LocalNetwork->PercArea[0] *SurfaceWater_m);
if (Infiltration > MaxInfiltration)assert(FALSE);
Total->Soil.Infiltration_m+=Infiltration;
NEGTEST(MaxRoadbedInfiltration = (1 - LocalNetwork->PercArea[0]) * LocalNetwork->MaxInfiltrationRate * Dt);
NEGTEST(RoadbedInfiltration = (1 - LocalNetwork->PercArea[0]) *SurfaceWater_m);
//temporary measure JSB 4-4-09 There is no roadbed - why is roadbedinterception >0?
RoadbedInfiltration=0;
if (RoadbedInfiltration > MaxRoadbedInfiltration) RoadbedInfiltration = MaxRoadbedInfiltration;
ASSERTTEST(LocalSoil->Runoff_m = SurfaceWater_m - Infiltration - RoadbedInfiltration);
if(LocalSoil->Runoff_m<0){
if(LocalSoil->Runoff_m < -0.0001){ //add this check, in case very small float multiplication rounding error may occur
printf("Warning: Negative runoff: %.5f m at X: %d Y: %d \n",LocalSoil->Runoff_m,y,x);
assert(FALSE);
}
LocalSoil->Runoff_m=0;
}
// if(LocalSoil->Runoff_m>1)assert(FALSE);
NEGTEST(LocalSoil->SurfaceWater_m = LocalSoil->Runoff_m);
/* Calculate unsaturated soil water movement, and adjust soil water
table depth */
UnsaturatedFlow(Dt, Infiltration, RoadbedInfiltration,SType->NLayers, LocalSoil->Depth, VType->RootDepth_m,
SType->Ks, SType->PoreDist, SType->Porosity, SType->FCap, LocalSoil->Perc, LocalNetwork->PercArea,
LocalNetwork->Adjust, LocalNetwork->CutBankZone,LocalNetwork->BankHeight, &(LocalSoil->TableDepth_m),
&(LocalSoil->Runoff_m), LocalSoil->Moist_m_m, LocalSoil->ChannelReturn,y,x);
NEGTEST(LocalSoil->Runoff_m);
//if(LocalSoil->Runoff_m>1)printf("Warning: surface runoff is %.3f m at X: %d Y: %d \n",LocalSoil->Runoff_m,y,x);
/* positive SurfaceSoilWaterFlux, means water has moved from the surface into the soil */
ASSERTTEST(SurfaceSoilWaterFlux = (LocalSoil->SurfaceWater_m - LocalSoil->Runoff_m));
if(ChemTable->NChems > 0) {
/* MWW Add new chems from veg to surface and soil, also Track the source of surface waters and route disolved chems appropriately */
SoilChemistry(y, x, Dt, DX, DY,LocalSoil, SType, LocalVeg, VType, GType, ChemTable, Thrufall,
SurfaceSoilWaterFlux, SCType, VCType, LocalMet, CurMonth,Basinwide, CurDate,Options);
}
if (HeatFluxOption == TRUE) {
if (LocalSnow->HasSnow == TRUE) {
Reference = 2. + Z0_SNOW;
Roughness = Z0_SNOW;
}
else {
Reference = 2. + Z0_GROUND;
Roughness = Z0_GROUND;
}
SensibleHeatFlux(y, x, Dt, LowerRa, Reference, 0.0f, Roughness,
LocalMet, LocalRad.PixelNetShort, LocalRad.PixelLongIn,
MoistureFlux, SType->NLayers, VType->RootDepth_m,
SType, MeltEnergy, LocalSoil);
Tsurf = LocalSoil->TSurf;
LongwaveBalance(VType->OverStory, VType->Fract[0], LocalMet->Lin,
LocalVeg->Tcanopy, Tsurf, &LocalRad);
}
else NoSensibleHeatFlux(Dt, LocalMet, MoistureFlux, LocalSoil);
#endif
/* ----------------------------------------------------------*/
/* Assign local met data to the Stream Channel variables for */
/* stream temperature calculations. Added 08/12/2004 MWW */
if (channel_grid_has_channel(ChannelData->stream_map, x, y)) {
/* assign Pixel met data to channel segment for the current time step */
if (LocalSnow->HasSnow)HasSnow = 1;
else HasSnow = 0;
channel_grid_metdata(ChannelData->stream_map, x, y,
LocalMet->Tair, LocalRad.PixelNetShort,
LocalRad.PixelLongIn, LowerWind,
LocalMet->Rh, LocalMet->Press, HasSnow);
}
/* -END-STREAM-TEMP-SECTION-----------------------------------*/
/* add the components of the radiation balance for the current pixel to
the total */
AggregateRadiation(MaxVegLayers, VType->NVegLayers, &LocalRad, TotalRad);
}
/*****************************************************************************
Function name: RadiationBalance()
Purpose : Calculate the radiation balance for the individual canopy
layers
Required :
int HeatFluxOption - TRUE if surface temperature is being calculated
float Rs - Incoming shortwave radiation (W/m2)
float Ld - Incoming longwave radiation (W/m2)
float Tair - Ambient air temperature (C)
float Tcanopy - Canopy temperature from the previous timestep (C)
float Tsoil - soil surface temperature from the previous timestep
(C)
int NAct - Number of vegetation layers above the snow
VEGTABLE VType - Information about number of veg layers
SNOWPIX LocalSnow - Information about snow conditions at current pixel
PIXRAD *LocalRad - Components of radiation balance for current pixel
Returns : void
Modifies :
PIXRAD *LocalRad - Components of radiation balance for current pixel
Comments :
This routine is implemented according to Wigmosta et al. (1994), with a
small change for the soil surface temperature if a sensible heat flux is
calculated, and the canopy surface temperature.
The following assumptions are made:
- No snow:
soil temperature is TSurf from last timestep if HeatFluxOption ==
TRUE, otherwise the soil temperature is the same as the air
temperature
- Snow:
soil temperature is the snow surface temperature
- Canopy temperature is equal to the air temperature is there is no snow
interception
- There are at most two vegetation layers
Reference:
Wigmosta, M. S., L. W. Vail, and D. P. Lettenmaier, A distributed
hydrology-vegetation model for complex terrain, Water Resour. Res.,
30(6), 1665-1679, 1994.
Reference:
Nijssen and Lettenmaier, A simplified approach for predicting shortwave
radiation transfer through boreal forest canopies, JGR, 1999.
*****************************************************************************/
void RadiationBalance(int HeatFluxOption, int CanopyRadAttOption,
float SineSolarAltitude, float Rs,
float Rsd, float Rsb, float Ld, float Tair,
float Tcanopy, float Tsoil, float SoilAlbedo,
VEGTABLE *VType, SNOWPIX *LocalSnow, PIXRAD *LocalRad)
{
float F; /* Fraction of pixel covered by top canopy
layer [0-1] */
float Albedo[2]; /* Albedo of each layer */
float Tau; /* Transmittance for overstory vegetation
layer */
float Taub, Taud; /* Transmittance for overstory vegetation layer for
direct and diffuse radiation, respectively */
float Tsurf; /* Surface temperature (C) */
F = VType->Fract[0];
/*following added 08/13/2001 by Pascal Storck */
if (CanopyRadAttOption == VARIABLE) {
F = VType->HemiFract[0];
}
/*end of add 08/13/2001 */
/* Determine Albedo */
if (VType->OverStory == TRUE) {
Albedo[0] = VType->Albedo[0];
if (LocalSnow->HasSnow == TRUE)
Albedo[1] = LocalSnow->Albedo;
else if (VType->UnderStory == TRUE)
Albedo[1] = VType->Albedo[1];
else
Albedo[1] = SoilAlbedo;
}
else if (LocalSnow->HasSnow == TRUE)
Albedo[0] = LocalSnow->Albedo;
else if (VType->UnderStory == TRUE)
Albedo[0] = VType->Albedo[0];
else
Albedo[0] = SoilAlbedo;
/* if the attenuation is fixed, calculate the canopy transmittance */
if (CanopyRadAttOption == FIXED) {
if (VType->OverStory == TRUE)
Tau = exp(-VType->Atten*VType->LAI[0]);
else
Tau = 0.;
}
/* calculate canopy transmittance coefficient for overstory vegetation
layer */
/* for the case where Bart Nijssen's simplified radiation scheme is used
then k*LAI is assumed to be the effective Leaf Area Index (L in Nijssen
and Lettenmaier, 2000) */
else if (CanopyRadAttOption == VARIABLE) {
if (VType->OverStory == TRUE) {
Taub =
exp(-VType->LAI[0] / VType->ClumpingFactor *
(VType->LeafAngleA / SineSolarAltitude + VType->LeafAngleB));
/*formulation is typically based on the cos of the solar zenith angle,
which is the sin of the solar altitude (SA = 90 - SZA) */
Taud = VType->Taud;
if (Rs > 0.0) {
Tau = Taub * Rsb / Rs + Taud * Rsd / Rs;
Tau = (float) pow((double) Tau, (double)(VType->Scat));
/* VType->Scat can be specified as a scattering paramter
or DHSVM will set it to 0.8 if not specified */
Tau = Tau / (1 - Albedo[0] * Albedo[1]);
}
else
Tau = 0.;
}
else
Tau = 0.;
}
ShortwaveBalance(VType->OverStory, F, Rs, Tau, Albedo, LocalRad);
if (LocalSnow->HasSnow == TRUE)
Tsurf = LocalSnow->TSurf;
else if (HeatFluxOption == TRUE)
Tsurf = Tsoil;
else
Tsurf = Tair;
LongwaveBalance(VType->OverStory, F, Ld, Tcanopy, Tsurf, LocalRad);
}
/*****************************************************************************
Function name: MassEnergyBalance()
Purpose : Calculate mass and energy balance
Required :
Returns : void
Modifies :
Comments :
Reference :
Epema, G.F. and H.T. Riezbos, 1983, Fall Velocity of waterdrops at different
heights as a factor influencing erosivity of simulated rain. Rainfall simulation,
Runoff and Soil Erosion. Catena suppl. 4, Braunschweig. Jan de Ploey (Ed), 1-17.
Laws, J.o., and D.A. Parsons, 1943, the relation of raindrop size to intensity.
Trans. Am. Geophys. Union, 24: 452-460.
Wicks, J.M. and J.C. Bathurst, 1996, SHESED: a physically based, distributed
erosion and sediment yield component for the SHE hydrological modeling system,
Journal of Hydrology, 175, 213-238.
*****************************************************************************/
void MassEnergyBalance(OPTIONSTRUCT *Options, int y, int x, float SineSolarAltitude,
float DX, float DY, int Dt, int HeatFluxOption,
int CanopyRadAttOption, int RoadRouteOption,
int InfiltOption, int MaxVegLayers, PIXMET *LocalMet,
ROADSTRUCT *LocalNetwork, PRECIPPIX *LocalPrecip,
VEGTABLE *VType, VEGPIX *LocalVeg, SOILTABLE *SType,
SOILPIX *LocalSoil, SNOWPIX *LocalSnow,
EVAPPIX *LocalEvap, PIXRAD *TotalRad,
CHANNEL *ChannelData, float **skyview)
{
PIXRAD LocalRad; /* Radiation balance components (W/m^2) */
float SurfaceWater; /* Pixel average depth of water before infiltration is calculated (m) */
float RoadWater; /* Average depth of water on the road surface
(normalized by grid cell area)
before infiltration is calculated (m) */
float ChannelWater; /* Precip that hits the channel */
float Infiltration; /* Infiltration into the top soil layer (m) */
float Infiltrability; /* Dynamic infiltration capacity (m/s)*/
float B; /* Capillary drive and soil saturation deficit used
in dynamic infiltration calculation*/
float LowerRa; /* Aerodynamic resistance for lower layer (s/m) */
float LowerWind; /* Wind for lower layer (m/s) */
float MaxInfiltration; /* Maximum infiltration into the top soil layer (m) */
float MaxRoadbedInfiltration; /* Maximum infiltration through the road bed soil layer (m) */
float MeltEnergy; /* Energy used to melt snow and change of cold content of snow pack */
float MoistureFlux; /* Amount of water transported from the pixel
to the atmosphere (m/timestep) */
float NetRadiation; /* Total Net long- and shortwave radiation for each veg layer (W/m2) */
float PercArea; /* Surface area of percolation corrected for
channel and road area, divided by the grid cell area (0-1) */
float Reference; /* Reference height for sensible heat calculation (m) */
float RoadbedInfiltration;/* Infiltration through the road bed (m) */
float Roughness; /* Roughness length (m) */
float Rp; /* radiation flux in visible part of the spectrum (W/m^2) */
float UpperRa; /* Aerodynamic resistance for upper layer (s/m) */
float UpperWind; /* Wind for upper layer (m/s) */
float SnowLongIn; /* Incoming longwave radiation at snow surface (W/m2) */
float SnowNetShort; /* Net amount of short wave radiation at the snow surface (W/m2) */
float SnowRa; /* Aerodynamic resistance for snow */
float SnowWind; /* Wind 2 m above snow */
float Tsurf; /* Surface temperature used in LongwaveBalance() (C) */
float RainfallIntensity; /* Rainfall intensity (mm/h) */
float MS_Rainfall; /* Momentum squared for rain throughfall((kg* m/s)^2 /(m^2 * s)) */
int MS_Index; /* Index for determining alpha and beta cooresponding to RainfallIntensity*/
int NVegLActual; /* Number of vegetation layers above snow */
float alpha[4]={2.69e-8,3.75e-8,6.12e-8,11.75e-8}; /* empirical coefficient
for rainfall momentum after Wicks and Bathurst (1996) */
float beta[4]={1.6896,1.5545,1.4242,1.2821}; /* empirical coefficient
for rainfall momentum after Wicks and Bathurst (1996) */
int i;
float CanopyHeight[18] = {0.5,1,1.5,2,3,4,5,6,7,8,9,10,11,12,
13,14,15,16}; /* Canopy height at which drip fall
velocity is prescribed after Epema and Riezebos (1983) (m)*/
float FallVelocity[18] = {2.96,4.12,5.12,5.82,6.84,7.54,8.05,8.36,
8.54,8.66,8.75,8.82,8.87,8.91,8.96,9.02,9.07,9.13};
/* Drip fall velocity corresponding to
CanopyHeight after Epema and Riezebos (1983) (m/s)*/
float LD_FallVelocity; /* Leaf drip fall velocity corresponding to the
canopy height in vegetation map (m/s) */
/* Calculate the number of vegetation layers above the snow */
NVegLActual = VType->NVegLayers;
if (LocalSnow->HasSnow == TRUE && VType->UnderStory == TRUE)
--NVegLActual;
/* initialize the total amount of evapotranspiration, and MeltEnergy */
LocalEvap->ETot = 0.0;
MeltEnergy = 0.0;
MoistureFlux = 0.0;
/* calculate the radiation balance for the ground/snow surface and the
vegetation layers above that surface */
/* related files: settings.h data.h Calendar.h DHSVMerror.h massenergy.h constants.h
*/
// RadiationBalance(Options, HeatFluxOption, CanopyRadAttOption, SineSolarAltitude,
// LocalMet->VICSin, LocalMet->Sin, LocalMet->SinBeam, LocalMet->SinDiffuse,
// LocalMet->Lin, LocalMet->Tair, LocalVeg->Tcanopy,
// LocalSoil->TSurf, SType->Albedo, VType, LocalSnow, &LocalRad);
CRadiationBalance * crb = new CRadiationBalance;
crb->init(Options, HeatFluxOption, CanopyRadAttOption, SineSolarAltitude,
LocalMet->VICSin, LocalMet->Sin, LocalMet->SinBeam, LocalMet->SinDiffuse,
LocalMet->Lin, LocalMet->Tair, LocalVeg->Tcanopy,
LocalSoil->TSurf, SType->Albedo, VType, LocalSnow, &LocalRad);
crb->execute();
delete crb;
/* calculate the actual aerodynamic resistances and wind speeds */
UpperWind = VType->U[0] * LocalMet->Wind;
UpperRa = VType->Ra[0] / LocalMet->Wind;
if (VType->OverStory == TRUE) {
LowerWind = VType->U[1] * LocalMet->Wind;
LowerRa = VType->Ra[1] / LocalMet->Wind;
}
else {
LowerWind = UpperWind;
LowerRa = UpperRa;
}
/* Leaf drip impact*/
/* Find corresponding fall velocity for overstory and understory heights
by weighting scheme */
/* related files: independent module
*/
// if (VType->OverStory){
// /* staring at 1 assumes the overstory height > 0.5 m */
// for (i = 1; i <= 17; i++ ) {
// if (VType->Height[0] < CanopyHeight[i]) {
// LD_FallVelocity = ((VType->Height[0] - CanopyHeight[i-1])
// *FallVelocity[i] +
// (CanopyHeight[i] - VType->Height[0])*FallVelocity[i-1]) /
// (CanopyHeight[i] - CanopyHeight[i-1]);
// }
// }
// if (VType->UnderStory) {
// /* ending at 16 assumes the understory height < 16 m */
// for (i = 0; i <= 16; i++) {
// if (VType->Height[1] < CanopyHeight[i]) {
// LD_FallVelocity = ((VType->Height[1] - CanopyHeight[i])*FallVelocity[i] +
// (CanopyHeight[i+1] - VType->Height[1])*FallVelocity[i-1]) /
// (CanopyHeight[i+1] - CanopyHeight[i]);
// }
// }
// }
// }
// else if (VType->UnderStory) {
// /* ending at 16 assumes the understory height < 16 m */
// for (i = 0; i <= 16; i++) {
// if (VType->Height[0] < CanopyHeight[i]) {
// LD_FallVelocity = ((VType->Height[0] - CanopyHeight[i])*FallVelocity[i] +
// (CanopyHeight[i+1] - VType->Height[0])*FallVelocity[i-1]) /
// (CanopyHeight[i+1] - CanopyHeight[i]);
// }
// }
// }
// else LD_FallVelocity = 0;
CLeafDripImpact * cLeafDripImpact = new CLeafDripImpact();
cLeafDripImpact->init(VType, CanopyHeight, FallVelocity);
cLeafDripImpact->execute();
cLeafDripImpact->query(&LD_FallVelocity);
delete cLeafDripImpact;
/* RainFall impact */
/* 3600 is conversion factor (number of seconds per hour) */
/* related files: independant
*/
// if (LocalPrecip->RainFall > 0.) {
// RainfallIntensity = LocalPrecip->RainFall * (1./MMTOM) * (3600./Dt);
//
// /* Momentum is later weighted with the overstory/understory fraction */
// if (RainfallIntensity < 10.)
// MS_Index = 0;
// else if (RainfallIntensity >= 10. && RainfallIntensity < 100.)
// MS_Index = floor((RainfallIntensity + 49)/50);
// else
// MS_Index = 3;
//
// /* Eq. 1, Wicks and Bathurst (1996) */
// MS_Rainfall = alpha[MS_Index] * pow(RainfallIntensity, beta[MS_Index]);
//
// /* Calculating mediam raindrop diameter after Laws and Parsons (1943) */
// LocalPrecip->Dm = 0.00124 * pow((double)RainfallIntensity, 0.182);
// }
// else {
// MS_Rainfall = 0;
// LocalPrecip->Dm = LEAF_DRIP_DIA;
// }
CRainfallImpact * cRainfallImpact = new CRainfallImpact();
cRainfallImpact->init(LocalPrecip->RainFall, Dt);
cRainfallImpact->execute();
cRainfallImpact->query(&MS_Rainfall, &(LocalPrecip->Dm));
delete cRainfallImpact;
/* calculate the amount of interception storage, and the amount of
throughfall. Of course this only needs to be done if there is
vegetation present. */
/* related files:
SnowInterception.c brent.h constants.h settings.h massenergy.h data.h
Calendar.h snow.h functions.h DHSVMChannel.h getinit.h channel.h channel_grid.h
RadiationBalance.c settings.h data.h Calendar.h DHSVMerror.h massenergy.h constants.h
InterceptionStorage.c settings.h data.h Calendar.h DHSVMerror.h massenergy.h constants.h
SnowMelt.c brent.h constants.h settings.h massenergy.h data.h Calendar.h
functions.h DHSVMChannel.h getinit.h channel.h channel_grid.h snow.h
*/
#ifndef NO_SNOW
if (VType->OverStory == TRUE &&
(LocalPrecip->IntSnow[0] || LocalPrecip->SnowFall > 0.0)) {
// SnowInterception(y, x, Dt, VType->Fract[0], VType->LAI[0],
// VType->MaxInt[0], VType->MaxSnowInt, VType->MDRatio,
// VType->SnowIntEff, UpperRa, LocalMet->AirDens,
// LocalMet->Eact, LocalMet->Lv, &LocalRad, LocalMet->Press,
// LocalMet->Tair, LocalMet->Vpd, UpperWind,
// &(LocalPrecip->RainFall), &(LocalPrecip->SnowFall),
// &(LocalPrecip->IntRain[0]), &(LocalPrecip->IntSnow[0]),
// &(LocalPrecip->TempIntStorage),
// &(LocalSnow->CanopyVaporMassFlux), &(LocalVeg->Tcanopy),
// &MeltEnergy, &(LocalPrecip->MomentSq), VType->Height,
// VType->UnderStory, MS_Rainfall, LD_FallVelocity);
CSnowInterception * cSnowInterception = new CSnowInterception();
cSnowInterception->init(y, x, Dt, VType->Fract[0], VType->LAI[0],
VType->MaxInt[0], VType->MaxSnowInt, VType->MDRatio,
VType->SnowIntEff, UpperRa, LocalMet->AirDens,
LocalMet->Eact, LocalMet->Lv, &LocalRad, LocalMet->Press,
LocalMet->Tair, LocalMet->Vpd, UpperWind,
&(LocalPrecip->RainFall), &(LocalPrecip->SnowFall),
&(LocalPrecip->IntRain[0]), &(LocalPrecip->IntSnow[0]),
&(LocalPrecip->TempIntStorage),
&(LocalSnow->CanopyVaporMassFlux), &(LocalVeg->Tcanopy),
&MeltEnergy, &(LocalPrecip->MomentSq), VType->Height,
VType->UnderStory, MS_Rainfall, LD_FallVelocity);
delete cSnowInterception;
MoistureFlux -= LocalSnow->CanopyVaporMassFlux;
/* Because we now have a new estimate of the canopy temperature we can
recalculate the longwave balance */
if (LocalSnow->HasSnow == TRUE)
Tsurf = LocalSnow->TSurf;
else if (HeatFluxOption == TRUE)
Tsurf = LocalSoil->TSurf;
else
Tsurf = LocalMet->Tair;
LongwaveBalance(Options, VType->OverStory, VType->Fract[0], LocalMet->Lin,
LocalVeg->Tcanopy, Tsurf, &LocalRad);
}
else if (VType->NVegLayers > 0) {
LocalVeg->Tcanopy = LocalMet->Tair;
LocalSnow->CanopyVaporMassFlux = 0.0;
LocalPrecip->TempIntStorage = 0.0;
// InterceptionStorage(VType->NVegLayers, NVegLActual, VType->MaxInt,
// VType->Fract, LocalPrecip->IntRain,
// &(LocalPrecip->RainFall), &(LocalPrecip->MomentSq),
// VType->Height, VType->UnderStory, Dt, MS_Rainfall,
// LD_FallVelocity);
CInterceptionStorage * cInterceptionStorage = new CInterceptionStorage();
cInterceptionStorage->init(VType->NVegLayers, NVegLActual, VType->MaxInt,
VType->Fract, LocalPrecip->IntRain,
&(LocalPrecip->RainFall), &(LocalPrecip->MomentSq),
VType->Height, VType->UnderStory, Dt, MS_Rainfall,
LD_FallVelocity);
cInterceptionStorage->execute();
delete cInterceptionStorage;
}
else {
/* If no vegetation, kinetic energy is all due to direct precipitation. */
if(LocalPrecip->RainFall > 0.0)
LocalPrecip->MomentSq = MS_Rainfall;
}
/* If snow on the ground, assume no overland flow erosion. */
if(LocalSnow->HasSnow)
LocalPrecip->MomentSq = 0.0;
/* if snow is present, simulate the snow pack dynamics */
if (LocalSnow->HasSnow || LocalPrecip->SnowFall > 0.0) {
if (VType->OverStory == TRUE) {
SnowLongIn = LocalRad.LongIn[1];
SnowNetShort = LocalRad.NetShort[1];
}
else {
SnowLongIn = LocalRad.LongIn[0];
SnowNetShort = LocalRad.NetShort[0];
}
SnowWind = VType->USnow * LocalMet->Wind;
SnowRa = VType->RaSnow / LocalMet->Wind;
// LocalSnow->Outflow =
// SnowMelt(y, x, Dt, 2. + Z0_SNOW, 0.f, Z0_SNOW, SnowRa, LocalMet->AirDens,
// LocalMet->Eact, LocalMet->Lv, SnowNetShort, SnowLongIn,
// LocalMet->Press, LocalPrecip->RainFall, LocalPrecip->SnowFall,
// LocalMet->Tair, LocalMet->Vpd, SnowWind,
// &(LocalSnow->PackWater), &(LocalSnow->SurfWater),
// &(LocalSnow->Swq), &(LocalSnow->VaporMassFlux),
// &(LocalSnow->TPack), &(LocalSnow->TSurf), &MeltEnergy);
CSnowMelt * cSnowMelt = new CSnowMelt();
cSnowMelt->init(y, x, Dt, 2. + Z0_SNOW, 0.f, Z0_SNOW, SnowRa, LocalMet->AirDens,
LocalMet->Eact, LocalMet->Lv, SnowNetShort, SnowLongIn,
LocalMet->Press, LocalPrecip->RainFall, LocalPrecip->SnowFall,
LocalMet->Tair, LocalMet->Vpd, SnowWind,
&(LocalSnow->PackWater), &(LocalSnow->SurfWater),
&(LocalSnow->Swq), &(LocalSnow->VaporMassFlux),
&(LocalSnow->TPack), &(LocalSnow->TSurf), &MeltEnergy, &(LocalSnow->Outflow));
cSnowMelt->execute();
delete cSnowMelt;
/* Rainfall was added to SurfWater of the snow pack and has to be set to zero */
LocalPrecip->RainFall = 0.0;
MoistureFlux -= LocalSnow->VaporMassFlux;
/* Because we now have a new estimate of the snow surface temperature we
can recalculate the longwave balance */
Tsurf = LocalSnow->TSurf;
LongwaveBalance(Options, VType->OverStory, VType->Fract[0], LocalMet->Lin,
LocalVeg->Tcanopy, Tsurf, &LocalRad);
}
else {
LocalSnow->Outflow = 0.0;
LocalSnow->VaporMassFlux = 0.0;
}
/* Determine whether a snow pack is still present, or whether everything
has melted */
if (LocalSnow->Swq > 0.0)
LocalSnow->HasSnow = TRUE;
else
LocalSnow->HasSnow = FALSE;
/*do the glacier add */
if (LocalSnow->Swq < 1.0 && VType->Index == GLACIER) {
printf("resetting glacier swe of %f to 5.0 meters\n", LocalSnow->Swq);
LocalSnow->Glacier += (5.0 - LocalSnow->Swq);
LocalSnow->Swq = 5.0;
LocalSnow->TPack = 0.0;
LocalSnow->TSurf = 0.0;
}
#endif
#ifndef NO_ET
/* calculate the amount of evapotranspiration from each vegetation layer
above the ground/soil surface. Also calculate the total amount of
evapotranspiration from the vegetation */
/* related files: EvapoTranspiration.c settings.h data.h Calendar.h DHSVMerror.h massenergy.h constants.h
SoilEvaporation.c settings.h DHSVMerror.h massenergy.h data.h Calendar.h constants.h
*/
if (VType->OverStory == TRUE) {
Rp = VISFRACT * LocalRad.NetShort[0];
NetRadiation =
LocalRad.NetShort[0] +
LocalRad.LongIn[0] - 2 * VType->Fract[0] * LocalRad.LongOut[0];
// EvapoTranspiration(0, Dt, LocalMet, NetRadiation, Rp, VType, SType,
// MoistureFlux, LocalSoil, &(LocalPrecip->IntRain[0]),
// LocalEvap, LocalNetwork->Adjust, UpperRa);
CEvapoTranspiration* cEvapoTranspiration = new CEvapoTranspiration();
cEvapoTranspiration->init(0, Dt, LocalMet, NetRadiation, Rp, VType, SType,
MoistureFlux, LocalSoil, &(LocalPrecip->IntRain[0]),
LocalEvap, LocalNetwork->Adjust, UpperRa);
cEvapoTranspiration->execute();
delete cEvapoTranspiration;
MoistureFlux += LocalEvap->EAct[0] + LocalEvap->EInt[0];
if (LocalSnow->HasSnow != TRUE && VType->UnderStory == TRUE) {
Rp = VISFRACT * LocalRad.NetShort[1];
NetRadiation =
LocalRad.NetShort[1] +
LocalRad.LongIn[1] - VType->Fract[1] * LocalRad.LongOut[1];
EvapoTranspiration(1, Dt, LocalMet, NetRadiation, Rp, VType, SType,
MoistureFlux, LocalSoil, &(LocalPrecip->IntRain[1]),
LocalEvap, LocalNetwork->Adjust, LowerRa);
MoistureFlux += LocalEvap->EAct[1] + LocalEvap->EInt[1];
}
else if (VType->UnderStory == TRUE) {
LocalEvap->EAct[1] = 0.;
LocalEvap->EInt[1] = 0.;
}
} /* end if(VType->OverStory == TRUE) */
else if (LocalSnow->HasSnow != TRUE && VType->UnderStory == TRUE) {
Rp = VISFRACT * LocalRad.NetShort[0];
NetRadiation =
LocalRad.NetShort[0] +
LocalRad.LongIn[0] - VType->Fract[0] * LocalRad.LongOut[0];
EvapoTranspiration(0, Dt, LocalMet, NetRadiation, Rp, VType, SType,
MoistureFlux, LocalSoil, &(LocalPrecip->IntRain[0]),
LocalEvap, LocalNetwork->Adjust, LowerRa);
MoistureFlux += LocalEvap->EAct[0] + LocalEvap->EInt[0];
}
else if (VType->UnderStory == TRUE) {
LocalEvap->EAct[0] = 0.;
LocalEvap->EInt[0] = 0.;
}
/* Calculate soil evaporation from the upper soil layer if no snow is
present and there is no understory */
if (LocalSnow->HasSnow != TRUE && VType->UnderStory != TRUE) {
if (VType->OverStory == TRUE)
NetRadiation =
LocalRad.NetShort[1] + LocalRad.LongIn[1] - LocalRad.LongOut[1];
else
NetRadiation =
LocalRad.NetShort[0] + LocalRad.LongIn[0] - LocalRad.LongOut[0];
// LocalEvap->EvapSoil =
// SoilEvaporation(Dt, LocalMet->Tair, LocalMet->Slope, LocalMet->Gamma,
// LocalMet->Lv, LocalMet->AirDens, LocalMet->Vpd,
// NetRadiation, LowerRa, MoistureFlux, SType->Porosity[0],
// SType->Ks[0], SType->Press[0], SType->PoreDist[0],
// VType->RootDepth[0], &(LocalSoil->Moist[0]),
// LocalNetwork->Adjust[0]);
{
CSoilEvaporation * cSoilEvaporation = new CSoilEvaporation();
cSoilEvaporation->init(Dt, LocalMet->Tair, LocalMet->Slope, LocalMet->Gamma,
LocalMet->Lv, LocalMet->AirDens, LocalMet->Vpd,
NetRadiation, LowerRa, MoistureFlux, SType->Porosity[0],
SType->Ks[0], SType->Press[0], SType->PoreDist[0],
VType->RootDepth[0], &(LocalSoil->Moist[0]),
LocalNetwork->Adjust[0], &(LocalEvap->EvapSoil));
cSoilEvaporation->execute();
delete cSoilEvaporation;
}
}
else
LocalEvap->EvapSoil = 0.0;
MoistureFlux += LocalEvap->EvapSoil;
LocalEvap->ETot += LocalEvap->EvapSoil;
#endif
/* add the water that was not intercepted to the upper soil layer */
#ifndef NO_SOIL
/* This has been modified so that PercArea for infiltration is calculated
locally to account for the fact that some cells have roads and streams.
I am not sure if the old PercArea (which does not account for the fact
that some cells have roads and streams) needs to remain the same.
Currently, the old PercArea is passed to UnsaturatedFlow */
MaxRoadbedInfiltration = 0.;
MaxInfiltration = 0.;
ChannelWater = 0.;
RoadWater = 0.;
SurfaceWater = 0.;
PercArea = 1.;
RoadbedInfiltration = 0.;
/* ChannelWater is precipitation falling on the channel */
/* (if there is no road, LocalNetwork->RoadArea = 0) */
if (channel_grid_has_channel(ChannelData->stream_map, x, y)){
PercArea = 1. - (LocalNetwork->Area + LocalNetwork->RoadArea)/(DX*DY);
ChannelWater = LocalNetwork->Area/(DX*DY) * LocalPrecip->RainFall;
}
/* If there is a road and no channel, the PercArea is
based on the road only */
else if (channel_grid_has_channel(ChannelData->road_map, x, y)){
PercArea = 1. - (LocalNetwork->RoadArea)/(DX*DY);
MaxRoadbedInfiltration = (1. - PercArea) *
LocalNetwork->MaxInfiltrationRate * Dt;
}
/* SurfaceWater is rain falling on the hillslope +
snowmelt on the hillslope (there is no snowmelt on the channel) +
existing IExcess */
/* related files: independant
*/
// SurfaceWater = (PercArea * LocalPrecip->RainFall) +
// ((1. - (LocalNetwork->RoadArea)/(DX*DY)) * LocalSnow->Outflow) +
// LocalSoil->IExcess;
CSurfaceWater * cSurfaceWater = new CSurfaceWater();
//float m_PercArea, float m_Rainfall, float m_RoadArea, float m_DX, float m_DY, float m_Outflow, float m_IExcess
cSurfaceWater->init(PercArea,LocalPrecip->RainFall,LocalNetwork->RoadArea, DX, DY, LocalSnow->Outflow, LocalSoil->IExcess );
cSurfaceWater->execute();
cSurfaceWater->query(&SurfaceWater);
delete cSurfaceWater;
/* RoadWater is rain falling on the road surface +
snowmelt on the road surface + existing Road IExcess
(Existing road IExcess = 0). WORK IN PROGRESS*/
/* related files: independant
*/
// RoadWater = (LocalNetwork->RoadArea/(DX*DY) *
// (LocalPrecip->RainFall + LocalSnow->Outflow)) +
// LocalNetwork->IExcess;
CRoadWater * cRoadWater = new CRoadWater();
cRoadWater->init(LocalNetwork->RoadArea, DX, DY, LocalPrecip->RainFall, LocalSnow->Outflow, LocalNetwork->IExcess);
cRoadWater->execute();
cRoadWater->query(&RoadWater);
delete cRoadWater;
/* Infiltration module
* related files or modules: SurfaceWater, RoadWater,UnsaturatedFlow.c
constants.h settings.h functions.h
data.h Calendar.h DHSVMChannel.h getinit.h channel.h
channel_grid.h soilmoisture.h
*/
if(InfiltOption == STATIC)
MaxInfiltration = (1. - VType->ImpervFrac) * PercArea * SType->MaxInfiltrationRate * Dt;
else { /* InfiltOption == DYNAMIC
Dynamic Infiltration Capacity after Parlange and Smith 1978,
as used in KINEROS and THALES */
Infiltration = 0.0;
if (SurfaceWater > 0.) {
/* Infiltration is a function of the amount of water infiltrated since
the storm started */
if (LocalPrecip->PrecipStart){
LocalSoil->MoistInit = LocalSoil->Moist[0];
LocalSoil->InfiltAcc = 0.0;
}
/* Check that the B parameter > 0 */
if ((LocalSoil->InfiltAcc > 0.) && (SType->Porosity[0] > LocalSoil->MoistInit)) {
B = (SType->Porosity[0] - LocalSoil->MoistInit) *
(SType->G_Infilt + SurfaceWater);
Infiltrability = SType->Ks[0] * exp((LocalSoil->InfiltAcc)/B) /
(exp((LocalSoil->InfiltAcc)/B) - 1.);
}
else
Infiltrability = SurfaceWater/Dt ;
MaxInfiltration = Infiltrability * PercArea *
(1. - VType->ImpervFrac) * Dt;
LocalPrecip->PrecipStart = FALSE;
}/* end if (SurfaceWater > 0.) */
else
LocalPrecip->PrecipStart = TRUE;
} /* end Dynamic MaxInfiltration calculation */
Infiltration = (1. - VType->ImpervFrac) * SurfaceWater;
if (Infiltration > MaxInfiltration)
Infiltration = MaxInfiltration;
RoadbedInfiltration = RoadWater;
if (RoadbedInfiltration > MaxRoadbedInfiltration)
RoadbedInfiltration = MaxRoadbedInfiltration;
if (RoadRouteOption == FALSE)
LocalSoil->IExcess = SurfaceWater - Infiltration +
RoadWater - RoadbedInfiltration;
else {
LocalSoil->IExcess = SurfaceWater - Infiltration;
LocalNetwork->IExcess = RoadWater - RoadbedInfiltration;
if (LocalNetwork->IExcess < 0.){
LocalNetwork->IExcess = 0.;
printf("MEB: NetIExcess(%f), reset to 0\n", LocalNetwork->IExcess);
}
}
if (LocalSoil->IExcess < 0.){
printf("MEB: SoilIExcess(%f), reset to 0\n", LocalSoil->IExcess);
LocalSoil->IExcess = 0.;
}
/*Add water that hits the channel network to the channel network */
/* related files: channel_grid.c channel_grid.h channel.h settings.h
data.h Calendar.h tableio.h errorhandler.h DHSVMChannel.h
getinit.h
*/
if (ChannelWater > 0.){
channel_grid_inc_inflow(ChannelData->stream_map, x, y, ChannelWater * DX * DY);
LocalSoil->ChannelInt += ChannelWater;
}
/* Calculate unsaturated soil water movement, and adjust soil water
table depth */
/* related files: UnsaturatedFlow.c constants.h settings.h functions.h
data.h Calendar.h DHSVMChannel.h getinit.h channel.h
channel_grid.h soilmoisture.h
*/
// LocalSoil->Depth, LocalNetwork->Area, VType->RootDepth,
// SType->Ks, SType->PoreDist, SType->Porosity, SType->FCap,
// LocalSoil->Perc, LocalNetwork->PercArea,
// LocalNetwork->Adjust, LocalNetwork->CutBankZone,
// LocalNetwork->BankHeight, &(LocalSoil->TableDepth),
// &(LocalSoil->IExcess), LocalSoil->Moist, RoadRouteOption,
// InfiltOption, &(LocalNetwork->IExcess));
CUnsaturatedFlow * cUnsaturatedFlow = new CUnsaturatedFlow();
cUnsaturatedFlow->init(Dt, DX, DY, Infiltration, RoadbedInfiltration,
LocalSoil->SatFlow, SType->NLayers,
LocalSoil->Depth, LocalNetwork->Area, VType->RootDepth,
SType->Ks, SType->PoreDist, SType->Porosity, SType->FCap,
LocalSoil->Perc, LocalNetwork->PercArea,
LocalNetwork->Adjust, LocalNetwork->CutBankZone,
LocalNetwork->BankHeight, &(LocalSoil->TableDepth),
&(LocalSoil->IExcess), LocalSoil->Moist, RoadRouteOption,
InfiltOption, &(LocalNetwork->IExcess));
cUnsaturatedFlow->execute();
delete cUnsaturatedFlow;
/* Infiltration is updated in UnsaturatedFlow and accumulated
below */
if ((InfiltOption == DYNAMIC) && (SurfaceWater > 0.))
LocalSoil->InfiltAcc += Infiltration;
if (HeatFluxOption == TRUE) {
if (LocalSnow->HasSnow == TRUE) {
Reference = 2. + Z0_SNOW;
Roughness = Z0_SNOW;
}
else {
Reference = 2. + Z0_GROUND;
Roughness = Z0_GROUND;
}
/* Calculate sensible heat flux
related file: SensibleHeatFlux.c settings.h data.h Calendar.h
DHSVMerror.h massenergy.h constants.h brent.h functions.h
DHSVMChannel.h getinit.h channel.h channel_grid.h
*/
// SensibleHeatFlux(y, x, Dt, LowerRa, Reference, 0.0f, Roughness,
// LocalMet, LocalRad.PixelNetShort, LocalRad.PixelLongIn,
// MoistureFlux, SType->NLayers, VType->RootDepth,
// SType, MeltEnergy, LocalSoil);
CSensibleHeatFlux *cSensibleHeatFlux = new CSensibleHeatFlux();
cSensibleHeatFlux->init(y, x, Dt, LowerRa, Reference, 0.0f, Roughness,
LocalMet, LocalRad.PixelNetShort, LocalRad.PixelLongIn,
MoistureFlux, SType->NLayers, VType->RootDepth,
SType, MeltEnergy, LocalSoil);
cSensibleHeatFlux->execute();
delete cSensibleHeatFlux;
Tsurf = LocalSoil->TSurf;
/* Calculate long wave balance
related files: RadiationBalance.c settings.h data.h Calendar.h
DHSVMerror.h massenergy.h constants.h
*/
LongwaveBalance(Options, VType->OverStory, VType->Fract[0], LocalMet->Lin,
LocalVeg->Tcanopy, Tsurf, &LocalRad);
}
else
/* Calculate No sensible heat flux
related files: SensibleHeatFlux.c settings.h data.h Calendar.h
DHSVMerror.h massenergy.h constants.h brent.h functions.h
DHSVMChannel.h getinit.h channel.h channel_grid.h
*/
// NoSensibleHeatFlux(Dt, LocalMet, MoistureFlux, LocalSoil);
{
CNoSensibleHeatFlux *cNoSensibleHeatFlux = new CNoSensibleHeatFlux();
cNoSensibleHeatFlux->init(Dt, LocalMet, MoistureFlux, LocalSoil);
cNoSensibleHeatFlux->execute();
delete cNoSensibleHeatFlux;
}
#endif
/* add the components of the radiation balance for the current pixel to
the total */
/* related files: AggregateRadiation.c settings.h data.h Calendar.h massenergy.h
*/
// AggregateRadiation(MaxVegLayers, VType->NVegLayers, &LocalRad, TotalRad);
CAggregateRadiation *cAggregateRadiation = new CAggregateRadiation();
cAggregateRadiation->init(MaxVegLayers, VType->NVegLayers, &LocalRad, TotalRad);
cAggregateRadiation->execute();
delete cAggregateRadiation;
/* For RBM model, save the energy fluxes for outputs */
/* related files: channel_grid.c channel_grid.h channel.h settings.h
data.h Calendar.h tableio.h errorhandler.h DHSVMChannel.h
getinit.h
*/
if (Options->StreamTemp) {
if (channel_grid_has_channel(ChannelData->stream_map, x, y))
channel_grid_inc_other(ChannelData->stream_map, x, y, &LocalRad, LocalMet, skyview[y][x]);
}
}