Index: wflow-py/wflow/wflow_sbm.py =================================================================== diff -u -re14061eac25a80485dc43ebab91c0f5b07649a78 -rd08f85b38e8de675a44c32721dd27a8818635b50 --- wflow-py/wflow/wflow_sbm.py (.../wflow_sbm.py) (revision e14061eac25a80485dc43ebab91c0f5b07649a78) +++ wflow-py/wflow/wflow_sbm.py (.../wflow_sbm.py) (revision d08f85b38e8de675a44c32721dd27a8818635b50) @@ -118,7 +118,7 @@ sys.exit(0) -def actEvap_SBM(RootingDepth, WTable, UStoreDepth, FirstZoneDepth, PotTrans, smoothpar,ust=0): +def actEvap_SBM(RootingDepth, WTable, UStoreDepth, SatWaterDepth, PotTrans, smoothpar,ust=0): """ Actual evaporation function: Actual evaporation function: @@ -132,25 +132,25 @@ Input: - - RootingDepth,WTable, UStoreDepth,FirstZoneDepth, PotTrans, smoothpar + - RootingDepth,WTable, UStoreDepth,SatWaterDepth, PotTrans, smoothpar Output: - - ActEvap, FirstZoneDepth, UStoreDepth ActEvapUStore + - ActEvap, SatWaterDepth, UStoreDepth ActEvapUStore """ # Step 1 from saturated zone, use rootingDepth as a limiting factor #rootsinWater = WTable < RootingDepth - #ActEvapSat = ifthenelse(rootsinWater,min(PotTrans,FirstZoneDepth),0.0) + #ActEvapSat = ifthenelse(rootsinWater,min(PotTrans,SatWaterDepth),0.0) # new method: # use sCurve to determine if the roots are wet.At the moment this ise set # to be a 0-1 curve wetroots = sCurve(WTable, a=RootingDepth, c=smoothpar) #wetroots = ifthenelse(WTable <= RootingDepth, scalar(1.0), scalar(0.0)) - ActEvapSat = min(PotTrans * wetroots, FirstZoneDepth) + ActEvapSat = min(PotTrans * wetroots, SatWaterDepth) - FirstZoneDepth = FirstZoneDepth - ActEvapSat + SatWaterDepth = SatWaterDepth - ActEvapSat RestPotEvap = PotTrans - ActEvapSat # now try unsat store @@ -166,7 +166,7 @@ ActEvap = ActEvapSat + ActEvapUStore - return ActEvap, FirstZoneDepth, UStoreDepth, ActEvapUStore + return ActEvap, SatWaterDepth, UStoreDepth, ActEvapUStore def SnowPackHBV(Snow, SnowWater, Precipitation, Temperature, TTI, TT, TTM, Cfmax, WHC): @@ -310,14 +310,14 @@ :var self.SnowWater: Snow pack water [mm] :var self.TSoil: Top soil temperature [oC] :var self.UStoreDepth: Water in the Unsaturated Store [mm] - :var self.FirstZoneDepth: Water in the saturated store [mm] + :var self.SatWaterDepth: Water in the saturated store [mm] :var self.CanopyStorage: Amount of water on the Canopy [mm] :var self.ReservoirVolume: Volume of each reservoir [m^3] :var self.GlacierStore: Thickness of the Glacier in a gridcell [mm] """ states = ['SurfaceRunoff', 'WaterLevel', - 'FirstZoneDepth', 'Snow', + 'SatWaterDepth', 'Snow', 'TSoil', 'UStoreDepth', 'SnowWater', 'CanopyStorage'] @@ -399,12 +399,12 @@ :var M.tbl: M parameter in the SBM model. Governs the decay of Ksat with depth [-] :var thetaR.tbl: Residual water content [mm/mm] :var thetaS.tbl: Saturated water content (porosity) [mm/mm] - :var FirstZoneKsatVer.tbl: Saturated conductivity [mm/d] + :var KsatVer.tbl: Saturated conductivity [mm/d] :var PathFrac.tbl: Fraction of compacted area per grid cell [-] :var InfiltCapSoil.tbl: Soil infiltration capacity [m/d] :var InfiltCapPath.tbl: Infiltration capacity of the compacted areas [mm/d] - :var FirstZoneMinCapacity.tbl: Minimum wdepth of the soil [mm] - :var FirstZoneCapacity.tbl: Maximum depth of the soil [m] + :var SoilMinThickness.tbl: Minimum wdepth of the soil [mm] + :var SoilWaterCapacity.tbl: Maximum depth of the soil [m] :var RootingDepth.tbl: Depth of the roots [mm] :var MaxLeakage.tbl: Maximum leakage out of the soil profile [mm/d] :var CapScale.tbl: Scaling factor in the Capilary rise calculations (100) [mm/d] @@ -604,23 +604,24 @@ self.PathFrac = self.readtblDefault(self.Dir + "/" + self.intbl + "/PathFrac.tbl", self.LandUse, subcatch, self.Soil, 0.01) # thickness of the soil - self.FirstZoneThickness = self.readtblDefault(self.Dir + "/" + self.intbl + "/FirstZoneCapacity.tbl", + self.SoilThickness = self.readtblDefault(self.Dir + "/" + self.intbl + "/SoilThickness.tbl", self.LandUse, subcatch, self.Soil, 2000.0) self.thetaR = self.readtblDefault(self.Dir + "/" + self.intbl + "/thetaR.tbl", self.LandUse, subcatch, self.Soil, 0.01) self.thetaS = self.readtblDefault(self.Dir + "/" + self.intbl + "/thetaS.tbl", self.LandUse, subcatch, self.Soil, 0.6) # minimum thickness of soild - self.FirstZoneMinCapacity = self.readtblDefault(self.Dir + "/" + self.intbl + "/FirstZoneMinCapacity.tbl", + self.SoilMinThickness = self.readtblDefault(self.Dir + "/" + self.intbl + "/SoilMinThickness.tbl", self.LandUse, subcatch, self.Soil, 500.0) + # FirstZoneKsatVer = $2\inmaps\FirstZoneKsatVer.map - self.FirstZoneKsatVer = self.readtblDefault(self.Dir + "/" + self.intbl + "/FirstZoneKsatVer.tbl", self.LandUse, + self.KsatVer = self.readtblDefault(self.Dir + "/" + self.intbl + "/KsatVer.tbl", self.LandUse, subcatch, self.Soil, 3000.0) * self.timestepsecs / self.basetimestep self.MporeFrac = self.readtblDefault(self.Dir + "/" + self.intbl + "/MporeFrac.tbl", self.LandUse, subcatch, self.Soil, 0.0) - self.FirstZoneKsatHorFrac = self.readtblDefault(self.Dir + "/" + self.intbl + "/FirstZoneKsatHorFrac.tbl", self.LandUse, + self.KsatHorFrac = self.readtblDefault(self.Dir + "/" + self.intbl + "/KsatHorFrac.tbl", self.LandUse, subcatch, self.Soil, 1.0) @@ -716,13 +717,13 @@ WI = ln(accuflux(self.TopoLdd, 1) / self.Slope) # Topographical wetnesss. Scale WI by zone/subcatchment assuming these ara also geological units WIMax = areamaximum(WI, self.TopoId) * WIMaxScale - self.FirstZoneThickness = max(min(self.FirstZoneThickness, (WI / WIMax) * self.FirstZoneThickness), - self.FirstZoneMinCapacity) + self.SoilThickness = max(min(self.SoilThickness, (WI / WIMax) * self.SoilThickness), + self.SoilMinThickness) - self.FirstZoneCapacity = self.FirstZoneThickness * (self.thetaS - self.thetaR) + self.SoilWaterCapacity = self.SoilThickness * (self.thetaS - self.thetaR) # limit roots to top 99% of first zone - self.RootingDepth = min(self.FirstZoneThickness * 0.99, self.RootingDepth) + self.RootingDepth = min(self.SoilThickness * 0.99, self.RootingDepth) # subgrid runoff generation, determine CC (sharpness of S-Curve) for upper # en lower part and take average @@ -797,7 +798,7 @@ self.CumRad = self.ZeroMap self.CumLeakage = self.ZeroMap self.CumPrecPol = self.ZeroMap - self.FirstZoneFlux = self.ZeroMap + self.SatWaterFlux = self.ZeroMap self.SumCellWatBal = self.ZeroMap self.PathInfiltExceeded = self.ZeroMap self.SoilInfiltExceeded = self.ZeroMap @@ -866,10 +867,10 @@ 'self.PathFrac', 'self.thetaR', 'self.thetaS', - 'self.FirstZoneMinCapacity', - 'self.FirstZoneKsatVer', + 'self.SoilMinThickness', + 'self.KsatVer', 'self.M', - 'self.FirstZoneCapacity', + 'self.SoilWaterCapacity', 'self.et_RefToPot', 'self.Slope', 'self.CC', @@ -888,8 +889,8 @@ if self.reinit == 1: self.logger.info("Setting initial conditions to default") - self.FirstZoneDepth = self.FirstZoneCapacity * 0.85 - self.UStoreDepth = self.FirstZoneCapacity * 0.0 + self.SatWaterDepth = self.SoilWaterCapacity * 0.85 + self.UStoreDepth = self.SoilWaterCapacity * 0.0 self.WaterLevel = self.ZeroMap self.SurfaceRunoff = self.ZeroMap self.Snow = self.ZeroMap @@ -917,18 +918,18 @@ self.OldKinWaveVolume = self.KinWaveVolume self.QCatchmentMM = self.SurfaceRunoff * self.QMMConvUp - self.InitialStorage = self.FirstZoneDepth + self.UStoreDepth + self.CanopyStorage - self.CellStorage = self.FirstZoneDepth + self.UStoreDepth + self.InitialStorage = self.SatWaterDepth + self.UStoreDepth + self.CanopyStorage + self.CellStorage = self.SatWaterDepth + self.UStoreDepth # Determine actual water depth - self.zi = max(0.0, self.FirstZoneThickness - self.FirstZoneDepth / (self.thetaS - self.thetaR)) + self.zi = max(0.0, self.SoilThickness - self.SatWaterDepth / (self.thetaS - self.thetaR)) # TOPOG_SBM type soil stuff self.f = (self.thetaS - self.thetaR) / self.M # NOTE:: This line used to be in the initial section. As a result # NOTE:: This line rused to be in the initial section. As a result # simulations will now be different as it used to be before - # the rescaling of the FirstZoneThickness - self.GWScale = (self.DemMax - self.DrainageBase) / self.FirstZoneThickness / self.RunoffGeneratingGWPerc + # the rescaling of the SoilThickness + self.GWScale = (self.DemMax - self.DrainageBase) / self.SoilThickness / self.RunoffGeneratingGWPerc def dynamic(self): @@ -962,13 +963,13 @@ :var self.WaterLevel: Water level in the kinematic wave [m] (above the bottom) :var self.ActInfilt: Actual infiltration into the unsaturated zone [mm] :var self.CanopyStorage: actual canopystorage (only for subdaily timesteps) [mm] - :var self.FirstZoneDepth: Amount of water in the saturated store [mm] + :var self.SatWaterDepth: Amount of water in the saturated store [mm] :var self.UStoreDepth: Amount of water in the unsaturated store [mm] :var self.zi: depth of the water table in mm below the surface [mm] :var self.Snow: Snow depth [mm] :var self.SnowWater: water content of the snow [mm] :var self.TSoil: Top soil temperature [oC] - :var self.FirstZoneDepth: amount of available water in the saturated part of the soil [mm] + :var self.SatWaterDepth: amount of available water in the saturated part of the soil [mm] :var self.UStoreDepth: amount of available water in the unsaturated zone [mm] :var self.Transfer: downward flux from unsaturated to saturated zone [mm] :var self.CapFlux: capilary flux from saturated to unsaturated zone [mm] @@ -1019,7 +1020,7 @@ self.wf_multparameters() - self.OrgStorage = self.UStoreDepth + self.FirstZoneDepth + self.OrgStorage = self.UStoreDepth + self.SatWaterDepth self.OldCanopyStorage = self.CanopyStorage self.PotEvap = self.PotenEvap # @@ -1089,11 +1090,11 @@ # -------------------------------- # Code to be able to force zi from the outside # - self.FirstZoneDepth = (self.thetaS - self.thetaR) * (self.FirstZoneThickness - self.zi) + self.SatWaterDepth = (self.thetaS - self.thetaR) * (self.SoilThickness - self.zi) self.AvailableForInfiltration = self.ThroughFall + self.StemFlow + self.IRSupplymm - UStoreCapacity = self.FirstZoneCapacity - self.FirstZoneDepth - self.UStoreDepth + UStoreCapacity = self.SoilWaterCapacity - self.SatWaterDepth - self.UStoreDepth # Runoff from water bodies and river network self.RunoffOpenWater = min(1.0,self.RiverFrac + self.WaterFrac) * self.AvailableForInfiltration @@ -1108,10 +1109,10 @@ Frac_correction = ifthenelse((self.SubCellFrac + self.RiverFrac + self.WaterFrac) > 1.0, self.SubCellFrac + self.RiverFrac + self.WaterFrac - 1.0, 0.0) self.SubCellRunoff = (self.SubCellFrac - Frac_correction) * self.AvailableForInfiltration - self.SubCellGWRunoff = min(self.SubCellFrac * self.FirstZoneDepth, - max(0.0,self.SubCellFrac * self.Slope * self.FirstZoneKsatVer * \ - self.FirstZoneKsatHorFrac * exp(-self.f * self.zi))) - self.FirstZoneDepth = self.FirstZoneDepth - self.SubCellGWRunoff + self.SubCellGWRunoff = min(self.SubCellFrac * self.SatWaterDepth, + max(0.0,self.SubCellFrac * self.Slope * self.KsatVer * \ + self.KsatHorFrac * exp(-self.f * self.zi))) + self.SatWaterDepth = self.SatWaterDepth - self.SubCellGWRunoff self.AvailableForInfiltration = self.AvailableForInfiltration - self.SubCellRunoff else: self.AbsoluteGW = self.DemMax - (self.zi * self.GWScale) @@ -1152,14 +1153,14 @@ self.CumInfiltExcess = self.CumInfiltExcess + self.InfiltExcess # Limit rootingdepth (if set externally) - self.ActRootingDepth = min(self.FirstZoneThickness * 0.99, self.ActRootingDepth) + self.ActRootingDepth = min(self.SoilThickness * 0.99, self.ActRootingDepth) # Determine transpiration # Split between bare soil/open water and vegetation self.potsoilopenwaterevap = (1.0 - self.CanopyGapFraction) * self.PotTransSoil self.PotTrans = self.PotTransSoil - self.potsoilopenwaterevap - self.SaturationDeficit = self.FirstZoneCapacity - self.FirstZoneDepth + self.SaturationDeficit = self.SoilWaterCapacity - self.SatWaterDepth # Linear reduction of soil moisture evaporation based on deficit @@ -1170,7 +1171,7 @@ self.RestEvap = self.RestEvap - self.ActEvapOpenWater # Next the rest is used for soil evaporation - self.soilevap = self.RestEvap * max(0.0,min(1.0, self.SaturationDeficit / self.FirstZoneCapacity)) + self.soilevap = self.RestEvap * max(0.0,min(1.0, self.SaturationDeficit / self.SoilWaterCapacity)) self.soilevap = min(self.soilevap, self.UStoreDepth) self.UStoreDepth = self.UStoreDepth - self.soilevap @@ -1180,9 +1181,9 @@ - self.Transpiration, self.FirstZoneDepth, self.UStoreDepth, self.ActEvapUStore = actEvap_SBM(self.ActRootingDepth, + self.Transpiration, self.SatWaterDepth, self.UStoreDepth, self.ActEvapUStore = actEvap_SBM(self.ActRootingDepth, self.zi, self.UStoreDepth, - self.FirstZoneDepth, + self.SatWaterDepth, self.PotTrans, self.rootdistpar, ust=self.UST) @@ -1210,53 +1211,53 @@ # Optional Macrco-Pore transfer self.MporeTransfer = self.ActInfilt * self.MporeFrac - self.FirstZoneDepth = self.FirstZoneDepth + self.MporeTransfer + self.SatWaterDepth = self.SatWaterDepth + self.MporeTransfer self.UStoreDepth = self.UStoreDepth - self.MporeTransfer - self.SaturationDeficit = self.FirstZoneCapacity - self.FirstZoneDepth + self.SaturationDeficit = self.SoilWaterCapacity - self.SatWaterDepth - self.zi = max(0.0, self.FirstZoneThickness - self.FirstZoneDepth / ( + self.zi = max(0.0, self.SoilThickness - self.SatWaterDepth / ( self.thetaS - self.thetaR)) # Determine actual water depth - Ksat = self.FirstZoneKsatVer * exp(-self.f * self.zi) + Ksat = self.KsatVer * exp(-self.f * self.zi) - self.DeepKsat = self.FirstZoneKsatVer * exp(-self.f * self.FirstZoneThickness) + self.DeepKsat = self.KsatVer * exp(-self.f * self.SoilThickness) # now the actual transfer to the saturated store.. self.Transfer = min(self.UStoreDepth, ifthenelse(self.SaturationDeficit <= 0.00001, 0.0, Ksat * self.UStoreDepth / (self.SaturationDeficit + 1))) - MaxCapFlux = max(0.0, min(Ksat, self.ActEvapUStore, UStoreCapacity, self.FirstZoneDepth)) + MaxCapFlux = max(0.0, min(Ksat, self.ActEvapUStore, UStoreCapacity, self.SatWaterDepth)) # No capilary flux is roots are in water, max flux if very near to water, lower flux if distance is large CapFluxScale = ifthenelse(self.zi > self.ActRootingDepth, self.CapScale / (self.CapScale + self.zi - self.ActRootingDepth) *\ self.timestepsecs/self.basetimestep, 0.0) self.CapFlux = MaxCapFlux * CapFluxScale # Determine Ksat at base - self.DeepTransfer = min(self.FirstZoneDepth,self.DeepKsat) + self.DeepTransfer = min(self.SatWaterDepth,self.DeepKsat) #ActLeakage = 0.0 # Now add leakage. to deeper groundwater self.ActLeakage = cover(max(0.0,min(self.MaxLeakage,self.DeepTransfer)),0) self.Percolation = cover(max(0.0,min(self.MaxPercolation,self.DeepTransfer)),0) #self.ActLeakage = ifthenelse(self.Seepage > 0.0, -1.0 * self.Seepage, self.ActLeakage) - self.FirstZoneDepth = self.FirstZoneDepth + self.Transfer - self.CapFlux - self.ActLeakage - self.Percolation + self.SatWaterDepth = self.SatWaterDepth + self.Transfer - self.CapFlux - self.ActLeakage - self.Percolation self.UStoreDepth = self.UStoreDepth - self.Transfer + self.CapFlux # Determine % saturated taking into account subcell fraction - self.Sat = max(self.SubCellFrac, scalar(self.FirstZoneDepth >= (self.FirstZoneCapacity * 0.999))) + self.Sat = max(self.SubCellFrac, scalar(self.SatWaterDepth >= (self.SoilWaterCapacity * 0.999))) ########################################################################## # Horizontal (downstream) transport of water ############################# ########################################################################## - self.zi = max(0.0, self.FirstZoneThickness - self.FirstZoneDepth / ( + self.zi = max(0.0, self.SoilThickness - self.SatWaterDepth / ( self.thetaS - self.thetaR)) # Determine actual water depth # Re-Determine saturation deficit. NB, as noted by Vertessy and Elsenbeer 1997 # this deficit does NOT take into account the water in the unsaturated zone - self.SaturationDeficit = self.FirstZoneCapacity - self.FirstZoneDepth + self.SaturationDeficit = self.SoilWaterCapacity - self.SatWaterDepth #self.logger.debug("Waterdem set to Altitude....") self.WaterDem = self.Altitude - (self.zi * 0.001) @@ -1267,37 +1268,37 @@ #TODO: We should make a couple ot iterations here... if self.waterdem: - Lateral = self.FirstZoneKsatVer * self.FirstZoneKsatHorFrac * self.waterSlope * exp(-self.SaturationDeficit / self.M) - MaxHor = max(0.0, min(Lateral, self.FirstZoneDepth)) - self.FirstZoneFlux = accucapacityflux(self.waterLdd, self.FirstZoneDepth, MaxHor) - self.FirstZoneDepth = accucapacitystate(self.waterLdd, self.FirstZoneDepth, MaxHor) + Lateral = self.KsatVer * self.KsatHorFrac * self.waterSlope * exp(-self.SaturationDeficit / self.M) + MaxHor = max(0.0, min(Lateral, self.SatWaterDepth)) + self.SatWaterFlux = accucapacityflux(self.waterLdd, self.SatWaterDepth, MaxHor) + self.SatWaterDepth = accucapacitystate(self.waterLdd, self.SatWaterDepth, MaxHor) else: - Lateral = self.FirstZoneKsatVer * self.FirstZoneKsatHorFrac * self.waterSlope * exp(-self.SaturationDeficit / self.M) - MaxHor = max(0.0, min(Lateral, self.FirstZoneDepth)) + Lateral = self.KsatVer * self.KsatHorFrac * self.waterSlope * exp(-self.SaturationDeficit / self.M) + MaxHor = max(0.0, min(Lateral, self.SatWaterDepth)) #MaxHor = self.ZeroMap - self.FirstZoneFlux = accucapacityflux(self.TopoLdd, self.FirstZoneDepth, MaxHor) - self.FirstZoneDepth = accucapacitystate(self.TopoLdd, self.FirstZoneDepth, MaxHor) + self.SatWaterFlux = accucapacityflux(self.TopoLdd, self.SatWaterDepth, MaxHor) + self.SatWaterDepth = accucapacitystate(self.TopoLdd, self.SatWaterDepth, MaxHor) ########################################################################## # Determine returnflow from first zone ########################## ########################################################################## - self.ExfiltWaterFrac = sCurve(self.FirstZoneDepth, a=self.FirstZoneCapacity, c=5.0) - self.ExfiltWater = self.ExfiltWaterFrac * (self.FirstZoneDepth - self.FirstZoneCapacity) - #self.ExfiltWater=ifthenelse (self.FirstZoneDepth - self.FirstZoneCapacity > 0 , self.FirstZoneDepth - self.FirstZoneCapacity , 0.0) - self.FirstZoneDepth = self.FirstZoneDepth - self.ExfiltWater + self.ExfiltWaterFrac = sCurve(self.SatWaterDepth, a=self.SoilWaterCapacity, c=5.0) + self.ExfiltWater = self.ExfiltWaterFrac * (self.SatWaterDepth - self.SoilWaterCapacity) + #self.ExfiltWater=ifthenelse (self.SatWaterDepth - self.SoilWaterCapacity > 0 , self.SatWaterDepth - self.SoilWaterCapacity , 0.0) + self.SatWaterDepth = self.SatWaterDepth - self.ExfiltWater # Re-determine UStoreCapacity - self.zi = max(0.0, self.FirstZoneThickness - self.FirstZoneDepth / ( + self.zi = max(0.0, self.SoilThickness - self.SatWaterDepth / ( self.thetaS - self.thetaR)) # Determine actual water depth self.ExfiltFromUstore = ifthenelse(self.zi == 0.0,\ ifthenelse(self.UStoreDepth > 0.0,self.UStoreDepth,self.ZeroMap),self.ZeroMap) self.ExfiltWater = self.ExfiltWater + self.ExfiltFromUstore self.UStoreDepth = self.UStoreDepth - self.ExfiltFromUstore - UStoreCapacity = self.FirstZoneCapacity - self.FirstZoneDepth - self.UStoreDepth + UStoreCapacity = self.SoilWaterCapacity - self.SatWaterDepth - self.UStoreDepth - Ksat = self.FirstZoneKsatVer * exp(-self.f * self.zi) + Ksat = self.KsatVer * exp(-self.f * self.zi) # Estimate water that may reinfilt SurfaceWater = self.WaterLevel/1000.0 # SurfaceWater (mm) @@ -1472,13 +1473,13 @@ #self.BB = catchmenttotal(cover(1.0), self.TopoLdd) # Single cell based water budget. snow not included yet. - self.CellStorage = self.UStoreDepth + self.FirstZoneDepth + self.CellStorage = self.UStoreDepth + self.SatWaterDepth self.DeltaStorage = self.CellStorage - self.OrgStorage - OutFlow = self.FirstZoneFlux + OutFlow = self.SatWaterFlux if self.waterdem: - CellInFlow = upstream(self.waterLdd, scalar(self.FirstZoneFlux)) + CellInFlow = upstream(self.waterLdd, scalar(self.SatWaterFlux)) else: - CellInFlow = upstream(self.TopoLdd, scalar(self.FirstZoneFlux)) + CellInFlow = upstream(self.TopoLdd, scalar(self.SatWaterFlux)) self.CumOutFlow = self.CumOutFlow + OutFlow self.CumActInfilt = self.CumActInfilt + self.ActInfilt @@ -1498,7 +1499,7 @@ self.SoilWatbal = self.ActInfilt + self.reinfiltwater + CellInFlow - self.Transpiration - self.soilevap -\ self.ExfiltWater - self.SubCellGWRunoff - self.DeltaStorage -\ - self.FirstZoneFlux + self.SatWaterFlux self.InterceptionWatBal = self.PrecipitationPlusMelt - self.Interception -self.StemFlow - self.ThroughFall -\ (self.OldCanopyStorage - self.CanopyStorage)