def snow_rain(self, k):
"""
- snow melt based on degree day factor and minimum surface temperature
- meltfactor increases with temperature
-
- Code for ini-file: 6
"""
JarvisCoefficients.calcEpSnow(self, k)
#self.PotEvaporation = self.EpHour
self.PotEvaporation = cover(ifthenelse(self.EpHour > 0, self.EpHour, 0), 0)
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow
self.Fm2 = max(self.Fm[k] * self.Precipitation, self.Fm[k])
self.Ew1 = max(min(self.PotEvaporation, self.Sw[k]), 0)
self.Qw1 = max(min(self.Fm2 * (self.Temperature - self.Tm[k]), self.Sw[k]),
0)
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew1 - self.Qw1
self.Sw_diff = ifthenelse(self.Sw[k] < 0, self.Sw[k], 0)
self.Ew = self.Ew1 + (self.Ew1 / ifthenelse(
self.Ew1 + self.Qw1 > 0, self.Ew1 + self.Qw1, 1)) * self.Sw_diff
self.Qw = self.Qw1 + (self.Qw1 / ifthenelse(
self.Ew1 + self.Qw1 > 0, self.Ew1 + self.Qw1, 1)) * self.Sw_diff
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew - self.Qw
self.Sw[k] = ifthenelse(self.Sw[k] < 0, 0, self.Sw[k])
self.Sw_diff2 = ifthen(self.Sw[k] < 0, self.Sw[k])
self.wbSw_[k] = self.PrecipitationSnow - self.Ew - self.Qw - self.Sw[
k] + self.Sw_t[k]
self.Ew_[k] = self.Ew
self.Qw_[k] = self.Qw
def interception_overflow_Ep(self,k):
"""
- Effective rainfall is all that does not fit into the interception reservoir
- Outgoing fluxes are determined separately
- this version cannot be run with Su averaged (for the current code)
- Code for ini-file: 3
"""
JarvisCoefficients.calcEp(self,k)
self.Pe = max(self.Precipitation - (self.imax[k] - self.Si_t[k]),0)
self.Si[k] = self.Si_t[k] + (self.Precipitation - self.Pe)
self.Ei = min(self.EpHour, self.Si[k])
self.Si[k] = self.Si[k] - self.Ei
self.Ei_[k]=self.Ei
self.Pe_[k]=self.Pe
self.Ep_[k]=self.EpHour
self.wbSi_[k] = self.Precipitation - self.Ei - self.Pe - self.Si[k] + self.Si_t[k]
if self.URFR_L:
self.Ei = areatotal(self.Ei * self.percentArea, nominal(self.TopoId))
self.Pe = areatotal(self.Pe * self.percentArea, nominal(self.TopoId))
self.PotEvaporation = areatotal(self.PotEvaporation * self.percentArea, nominal(self.TopoId))
self.Si[k] = areatotal(self.Si[k] * self.percentArea, nominal(self.TopoId))
def interception_overflow_Ep(self,k):
"""
- Effective rainfall is all that does not fit into the interception reservoir
- Outgoing fluxes are determined separately
- this version cannot be run with Su averaged (for the current code)
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),0)
self.Pe = max(self.Precipitation - (self.imax[k] - self.Si_t[k]),0)
self.Si[k] = self.Si_t[k] + (self.Precipitation - self.Pe)
self.Ei = ifthenelse(self.Sw[k] == 0, min((self.PotEvaporation - (self.Ew_[k] / self.lamda * self.lamdaS)), self.Si[k]), 0) #ifstatement added on 3-11-2015 for snow module, '-self.Ew_[k]' added on 17-2-2016
self.Si[k] = self.Si[k] - self.Ei
self.wbSi_[k] = self.Precipitation - self.Ei - self.Pe - self.Si[k] + self.Si_t[k]
self.Pe = self.Pe + self.Qw_[k] #added on 3-11-2015 for snow module
self.Ei = self.Ei + (self.Ew_[k] / self.lamda * self.lamdaS) #lambda added on 17-2-2016
self.Ei_[k]=self.Ei
self.Pe_[k]=self.Pe
self.Ep_[k]=self.EpHour
if self.URFR_L:
self.Ei = areatotal(self.Ei * self.percentArea, nominal(self.TopoId))
self.Pe = areatotal(self.Pe * self.percentArea, nominal(self.TopoId))
self.PotEvaporation = areatotal(self.PotEvaporation * self.percentArea, nominal(self.TopoId))
self.Si[k] = areatotal(self.Si[k] * self.percentArea, nominal(self.TopoId))
def interception_overflow_Ep(self,k):
"""
- Effective rainfall is all that does not fit into the interception reservoir
- Outgoing fluxes are determined separately
- this version cannot be run with Su averaged (for the current code)
- Code for ini-file: 3
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),0)
self.Pe = max(self.Precipitation - (self.imax[k] - self.Si_t[k]),0)
self.Si[k] = self.Si_t[k] + (self.Precipitation - self.Pe)
self.Ei = ifthenelse(self.Sw[k] == 0, min((self.PotEvaporation - (self.Ew_[k] / self.lamda * self.lamdaS)), self.Si[k]), 0) #ifstatement added on 3-11-2015 for snow module, '-self.Ew_[k]' added on 17-2-2016
self.Si[k] = self.Si[k] - self.Ei
self.wbSi_[k] = self.Precipitation - self.Ei - self.Pe - self.Si[k] + self.Si_t[k]
self.Pe = self.Pe + self.Qw_[k] #added on 3-11-2015 for snow module
self.Ei = self.Ei + (self.Ew_[k] / self.lamda * self.lamdaS) #lambda added on 17-2-2016
self.Ei_[k]=self.Ei
self.Pe_[k]=self.Pe
self.Ep_[k]=self.EpHour
if self.URFR_L:
self.Ei = areatotal(self.Ei * self.percentArea, nominal(self.TopoId))
self.Pe = areatotal(self.Pe * self.percentArea, nominal(self.TopoId))
self.PotEvaporation = areatotal(self.PotEvaporation * self.percentArea, nominal(self.TopoId))
self.Si[k] = areatotal(self.Si[k] * self.percentArea, nominal(self.TopoId))
def snow_no_reservoir(self, k):
"""
This function is used when no snow zone reservoir is used and only
passes fluxes from the upper reservoirs to the lower
Qw = Psnow
Ew = 0.
Storage in snow zone = 0.
!!!still needs a final check!!!
k is the class indication
self contains all the variables of the model
"""
try:
JarvisCoefficients.calcEpSnow(self, k)
except:
JarvisCoefficients.calcEpSnowHour(self, k)
self.PotEvaporation = self.EpHour
self.PotEvaporation = cover(ifthenelse(self.EpHour > 0, self.EpHour, 0), 0)
self.Qw_[k] = max(self.PrecipitationSnow, 0)
self.Ew_[k] = 0.
self.Sw[k] = 0.
self.wbSw_[k] = self.Precipitation - self.Ew_[k] - self.Qw_[k] - self.Sw[
k] + self.Sw_t[k]
def agriZone_Jarvis(self,k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on Jarvis stress functions
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qa u is determined from overflow from Sa
- Code for ini-file: 1
"""
self.Qa = max(self.Pe - (self.samax[k] - self.Sa_t[k]),0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa)
self.SaN = self.Sa[k] / self.samax[k]
self.SuN = self.Su[k] / self.sumax[k]
JarvisCoefficients.calcEu(self,k,1) #calculation of Ea based on Jarvis stress functions
self.Ea1 = self.Eu
# if self.teller == 45:
# pdb.set_trace()
self.Fa1 = self.Fmin[k] + (self.Fmax[k] - self.Fmin[k]) * e ** (-self.decF[k] * self.SuN)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa) - self.Fa1 - self.Ea1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Fa = self.Fa1 + (self.Fa1/ifthenelse(self.Fa1 + self.Ea1 > 0 , self.Fa1 + self.Ea1 , 1)) * self.Sa_diff
self.Ea = self.Ea1 + (self.Ea1/ifthenelse(self.Fa1 + self.Ea1 > 0 , self.Fa1 + self.Ea1 , 1)) * self.Sa_diff
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa) - self.Ea - self.Fa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0 , self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.wbSa_[k] = self.Pe - self.Ea - self.Qa - self.Fa - self.Sa[k] + self.Sa_t[k]
self.Ea_[k] = self.Ea
self.Qa_[k] = self.Qa
self.Fa_[k] = self.Fa
def agriZone_Jarvis(self,k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on Jarvis stress functions
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qa u is determined from overflow from Sa
- Code for ini-file: 1
"""
self.Qa = max(self.Pe - (self.samax[k] - self.Sa_t[k]),0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa)
self.SaN = min(self.Sa[k] / self.samax2, 1)
self.SuN = self.Su[k] / self.sumax[k]
JarvisCoefficients.calcEu(self,k,1) #calculation of Ea based on Jarvis stress functions
self.Ea1 = self.Eu
self.Fa1 = self.Fmin[k] + (self.Fmax[k] - self.Fmin[k]) * e ** (-self.decF[k] * self.SuN)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa) - self.Fa1 - self.Ea1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Fa = self.Fa1 + (self.Fa1/ifthenelse(self.Fa1 + self.Ea1 > 0 , self.Fa1 + self.Ea1 , 1)) * self.Sa_diff
self.Ea = self.Ea1 + (self.Ea1/ifthenelse(self.Fa1 + self.Ea1 > 0 , self.Fa1 + self.Ea1 , 1)) * self.Sa_diff
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa) - self.Ea - self.Fa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0 , self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.wbSa_[k] = self.Pe - self.Ea - self.Qa - self.Fa - self.Sa[k] + self.Sa_t[k]
self.Ea_[k] = self.Ea
self.Qa_[k] = self.Qa
self.Fa_[k] = self.Fa
def snow(self,k):
"""
- snow melt based on degree day factor and
"""
JarvisCoefficients.calcEpSnow(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour > 0, self.EpHour, 0),0)
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow
self.Ew1 = max(min(self.PotEvaporation,self.Sw[k]),0)
self.Qw1 = max(self.Fm[k] * (self.Temperature - self.Tm[k]), 0)
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew1 - self.Qw1
self.Sw_diff = ifthenelse(self.Sw[k] < 0, self.Sw[k], 0)
self.Ew = self.Ew1 + (self.Ew1/ifthenelse(self.Ew1 + self.Qw1 > 0 , self.Ew1 + self.Qw1 , 1)) * self.Sw_diff
self.Qw = self.Qw1 + (self.Qw1/ifthenelse(self.Ew1 + self.Qw1 > 0 , self.Ew1 + self.Qw1 , 1)) * self.Sw_diff
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew - self.Qw
self.Sw[k] = ifthenelse(self.Sw[k] < 0, 0 , self.Sw[k])
self.Sw_diff2 = ifthen(self.Sw[k] < 0, self.Sw[k])
self.wbSw_[k] = self.PrecipitationSnow - self.Ew - self.Qw - self.Sw[k] + self.Sw_t[k]
self.Ew_[k] = self.Ew
self.Qw_[k] = self.Qw
def snow_rain_hourlyEp(self,k):
"""
- snow melt based on degree day factor and minimum surface temperature
- meltfactor increases with temperature
"""
JarvisCoefficients.calcEpSnowHour(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour > 0, self.EpHour, 0),0)
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow
self.Fm2 = max(self.Fm[k] * self.Precipitation, self.Fm[k])
self.Ew1 = max(min(self.PotEvaporation, self.Sw[k]),0)
self.Qw1 = max(min(self.Fm2 * (self.Temperature - self.Tm[k]), self.Sw[k]), 0)
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew1 - self.Qw1
self.Sw_diff = ifthenelse(self.Sw[k] < 0, self.Sw[k], 0)
self.Ew = self.Ew1 + (self.Ew1/ifthenelse(self.Ew1 + self.Qw1 > 0 , self.Ew1 + self.Qw1 , 1)) * self.Sw_diff
self.Qw = self.Qw1 + (self.Qw1/ifthenelse(self.Ew1 + self.Qw1 > 0 , self.Ew1 + self.Qw1 , 1)) * self.Sw_diff
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew - self.Qw
self.Sw[k] = ifthenelse(self.Sw[k] < 0, 0 , self.Sw[k])
self.Sw_diff2 = ifthen(self.Sw[k] < 0, self.Sw[k])
self.wbSw_[k] = self.PrecipitationSnow - self.Ew - self.Qw - self.Sw[k] + self.Sw_t[k]
self.Ew_[k] = self.Ew
self.Qw_[k] = self.Qw
def snow(self, k):
"""
- snow melt based on degree day factor and
"""
JarvisCoefficients.calcEpSnow(self, k)
self.PotEvaporation = cover(ifthenelse(self.EpHour > 0, self.EpHour, 0), 0)
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow
self.Ew1 = max(min(self.PotEvaporation, self.Sw[k]), 0)
self.Qw1 = max(self.Fm[k] * (self.Temperature - self.Tm[k]), 0)
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew1 - self.Qw1
self.Sw_diff = ifthenelse(self.Sw[k] < 0, self.Sw[k], 0)
self.Ew = self.Ew1 + (self.Ew1 / ifthenelse(
self.Ew1 + self.Qw1 > 0, self.Ew1 + self.Qw1, 1)) * self.Sw_diff
self.Qw = self.Qw1 + (self.Qw1 / ifthenelse(
self.Ew1 + self.Qw1 > 0, self.Ew1 + self.Qw1, 1)) * self.Sw_diff
self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew - self.Qw
self.Sw[k] = ifthenelse(self.Sw[k] < 0, 0, self.Sw[k])
self.Sw_diff2 = ifthen(self.Sw[k] < 0, self.Sw[k])
self.wbSw_[k] = self.PrecipitationSnow - self.Ew - self.Qw - self.Sw[
k] + self.Sw_t[k]
self.Ew_[k] = self.Ew
self.Qw_[k] = self.Qw
def unsatZone_forAgri_Jarvis_cropG(self, k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on Jarvis stress functions
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qu is determined with a beta function (same as in HBV?)
- inflow is infiltration from agriculture reservoir
"""
self.cropG_scal = pcr2numpy(self.cropG, NaN)
if any(self.cropG_scal == 1):
self.sumax2 = self.sumax[k]
else:
self.sumax2 = self.sumax[k] * self.redsu[k]
self.Su[k] = ifthenelse(self.Su_t[k] + self.Fa > self.sumax2, self.sumax2,
self.Su_t[k] + self.Fa)
self.Quadd = ifthenelse(self.Su_t[k] + self.Fa > self.sumax2,
self.Su_t[k] + self.Fa - self.sumax2, 0)
self.SuN = self.Su[k] / self.sumax2
self.SiN = self.Si[k] / self.imax[k]
JarvisCoefficients.calcEu(
self, k, 2) #calculation of Eu based on Jarvis stress functions
self.Eu1 = self.Eu
self.Qu1 = (self.Fa - self.Quadd) * (1 - (1 - self.SuN)**self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Fa -
self.Quadd) - self.Qu1 - self.Eu - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (
self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1 +
self.Eu1 + self.Perc1, 1)) * self.Su_diff
self.Qu = self.Qu1 + (
self.Qu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1 +
self.Eu1 + self.Perc1, 1)) * self.Su_diff
self.Perc = ifthenelse(
self.Perc1 > 0, self.Perc1 +
(self.Perc1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1
+ self.Eu1 + self.Perc1, 1)) * self.Su_diff,
self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Fa -
self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0, self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax2), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[
k] = self.Fa - self.Eu - self.Qu - self.Quadd - self.Perc + self.Cap - self.Su[
k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def interception_overflow_Ep(self, k):
"""
- Effective rainfall is all that does not fit into the interception reservoir
- Outgoing fluxes are determined separately
- this version cannot be run with Su averaged (for the current code)
- Code for ini-file: 3
"""
JarvisCoefficients.calcEp(self, k)
self.Pe = max(self.Precipitation - (self.imax[k] - self.Si_t[k]), 0)
self.Si[k] = self.Si_t[k] + (self.Precipitation - self.Pe)
self.Ei = min(self.EpHour, self.Si[k])
self.Si[k] = self.Si[k] - self.Ei
self.Ei_[k] = self.Ei
self.Pe_[k] = self.Pe
self.Ep_[k] = self.EpHour
self.wbSi_[
k] = self.Precipitation - self.Ei - self.Pe - self.Si[k] + self.Si_t[k]
if self.URFR_L:
self.Ei = areatotal(self.Ei * self.percentArea, nominal(self.TopoId))
self.Pe = areatotal(self.Pe * self.percentArea, nominal(self.TopoId))
self.PotEvaporation = areatotal(self.PotEvaporation * self.percentArea,
nominal(self.TopoId))
self.Si[k] = areatotal(self.Si[k] * self.percentArea,
nominal(self.TopoId))
def agriZone_Ep(self,k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on LP
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qa u is determined from overflow from Sa
- Code for ini-file: 2
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = self.EpHour
self.Qa = max(self.Pe - (self.samax[k] - self.Sa_t[k]),0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa)
self.SaN = self.Sa[k] / self.samax[k]
self.SuN = self.Su[k] / self.sumax[k]
self.Ea1 = max((self.PotEvaporation - self.Ei),0) * min(self.Sa[k] / (self.samax[k] * self.LP[k]),1)
self.Fa1 = self.Fmin[k] + (self.Fmax[k] - self.Fmin[k]) * e ** (-self.decF[k] * self.SuN)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa) - self.Fa1 - self.Ea1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Fa = self.Fa1 + (self.Fa1/ifthenelse(self.Fa1 + self.Ea1 > 0 , self.Fa1 + self.Ea1 , 1)) * self.Sa_diff
self.Ea = self.Ea1 + (self.Ea1/ifthenelse(self.Fa1 + self.Ea1 > 0 , self.Fa1 + self.Ea1 , 1)) * self.Sa_diff
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa) - self.Ea - self.Fa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0 , self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.wbSa_[k] = self.Pe - self.Ea - self.Qa - self.Fa - self.Sa[k] + self.Sa_t[k]
self.Ea_[k] = self.Ea
self.Qa_[k] = self.Qa
self.Fa_[k] = self.Fa
def unsatZone_forAgri_Ep(self, k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on beta/LP
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qu is determined with a beta function (same as in HBV?)
- inflow is infiltration from agriculture reservoir
- Code for ini-file: 17
"""
JarvisCoefficients.calcEp(self, k)
self.PotEvaporation = self.EpHour
self.Su[k] = ifthenelse(self.Su_t[k] + self.Fa > self.sumax[k],
self.sumax[k], self.Su_t[k] + self.Fa)
self.Quadd = ifthenelse(self.Su_t[k] + self.Fa > self.sumax[k],
self.Su_t[k] + self.Fa - self.sumax[k], 0)
self.SuN = self.Su[k] / self.sumax[k]
self.SiN = self.Si[k] / self.imax[k]
self.Eu1 = max((self.PotEvaporation - self.Ei - self.Ea), 0) * min(
self.Su[k] / (self.sumax[k] * self.LP[k]), 1)
self.Qu1 = (self.Fa - self.Quadd) * (1 - (1 - self.SuN)**self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Fa -
self.Quadd) - self.Qu1 - self.Eu - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (
self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1 +
self.Eu1 + self.Perc1, 1)) * self.Su_diff
self.Qu = self.Qu1 + (
self.Qu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1 +
self.Eu1 + self.Perc1, 1)) * self.Su_diff
self.Perc = ifthenelse(
self.Perc1 > 0, self.Perc1 +
(self.Perc1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1
+ self.Eu1 + self.Perc1, 1)) * self.Su_diff,
self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Fa -
self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0, self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax[k]), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[
k] = self.Fa - self.Eu - self.Qu - self.Quadd - self.Perc + self.Cap - self.Su[
k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def unsatZone_LP_beta_Ep(self, k):
"""
- Potential evaporation is calculated with formula in 'JarvisCoefficients', but without
using the Jarvis stress functions
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation linear until LP, from than with potential rate
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato
- Qu is determined with a beta function (same as in HBV?)
- Code for ini-file: 13
"""
JarvisCoefficients.calcEp(self, k)
self.PotEvaporation = self.EpHour
self.Su[k] = ifthenelse(self.Su_t[k] + self.Pe > self.sumax[k],
self.sumax[k], self.Su_t[k] + self.Pe)
self.Quadd = ifthenelse(self.Su_t[k] + self.Pe > self.sumax[k],
self.Su_t[k] + self.Pe - self.sumax[k], 0)
self.SuN = self.Su[k] / self.sumax[k]
self.SiN = self.Si[k] / self.imax[k]
self.Eu1 = max((self.PotEvaporation - self.Ei), 0) * min(
self.Su[k] / (self.sumax[k] * self.LP[k]), 1)
self.Qu1 = (self.Pe - self.Quadd) * (1 - (1 - self.SuN)**self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Pe -
self.Quadd) - self.Qu1 - self.Eu1 - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (
self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1 +
self.Eu1 + self.Perc1, 1)) * self.Su_diff
self.Qu = self.Qu1 + (
self.Qu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1 +
self.Eu1 + self.Perc1, 1)) * self.Su_diff
self.Perc = ifthenelse(
self.Perc1 > 0, self.Perc1 +
(self.Perc1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0, self.Qu1
+ self.Eu1 + self.Perc1, 1)) * self.Su_diff,
self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Pe -
self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0, self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax[k]), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[
k] = self.Pe - self.Eu - self.Qu - self.Quadd - self.Perc + self.Cap - self.Su[
k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def unsatZone_withAgri_Jarvis(self, k):
"""
- Potential evaporation is calculated with formula in 'JarvisCoefficients', but without
using the Jarvis stress functions
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation linear until LP, from than with potential rate
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato
- Qu is determined with a beta function (same as in HBV?)
- Code for ini-file: 15
"""
self.Sa[k] = ifthenelse(self.Sa_t[k] + self.Pe > self.samax[k],
self.samax[k], self.Sa_t[k] + self.Pe)
self.Qaadd = ifthenelse(self.Sa_t[k] + self.Pe > self.samax[k],
self.Sa_t[k] + self.Pe - self.samax[k], 0)
self.SaN = self.Sa[k] / self.samax[k]
JarvisCoefficients.calcEu(
self, k, 1) #calculation of Eu based on Jarvis stress functions
self.Ea = self.Eu
self.Qa1 = (self.Pe - self.Qaadd) * (1 - (1 - self.SaN)**self.beta[k])
self.Fa1 = self.famax[k] * (self.sumax[k] - self.Su[k]) / self.sumax[k]
self.Sa[k] = self.Sa_t[k] + (self.Pe -
self.Qaadd) - self.Qa1 - self.Ea - self.Fa1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Qa = self.Qa1 + (self.Qa1 / ifthenelse(
self.Qa1 + self.Fa1 > 0, self.Qa1 + self.Fa1, 1)) * self.Sa_diff
self.Fa = ifthenelse(
self.Fa1 > 0, self.Fa1 + (self.Fa1 / ifthenelse(
self.Qa1 + self.Fa1 > 0, self.Qa1 + self.Fa1, 1)) * self.Sa_diff,
self.Fa1)
self.Sa[k] = self.Sa_t[k] + (self.Pe -
self.Qaadd) - self.Ea - self.Qa - self.Fa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0, self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.Capa = min(self.cap[k] * (1 - self.Sa[k] / self.samax[k]), self.Su[k])
self.Sa[k] = self.Sa[k] + self.Capa
self.Su[k] = self.Su_t[k] + self.Fa - self.Capa
self.Perc = self.perc[k] * (self.Su[k] / self.sumax[k])
self.Su[k] = self.Su[k] - self.Perc
self.wbSa_[
k] = self.Pe - self.Ea - self.Qa - self.Qaadd - self.Fa + self.Capa - self.Sa[
k] + self.Sa_t[k]
self.wbSu_[k] = self.Fa - self.Perc - self.Capa - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Ea
self.Qu_[k] = self.Qa + self.Qaadd
self.Fa_[k] = self.Fa
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def unsatZone_LP_beta_Ep_cropG(self,k):
"""
- Potential evaporation is calculated with formula in 'JarvisCoefficients', but without
using the Jarvis stress functions
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation linear until LP, from than with potential rate
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato
- Qu is determined with a beta function (same as in HBV?)
- root zone storage for crop land is decreased in autumn and winter
- Code for ini-file: 20
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = self.EpHour
#
# pdb.set_trace()
self.cropG_scal = pcr2numpy(self.cropG,NaN)
if any(self.cropG_scal == 1):
self.sumax2 = self.sumax[k]
elif any(self.cropG_scal > 0):
# pdb.set_trace()
self.sumax2 = self.sumax[k] * (1 - numpy.max(self.cropG_scal[self.cropG_scal >= 0]) * (1-self.redsu[k]))
else:
self.sumax2 = self.sumax[k] * self.redsu[k]
self.Su[k] = ifthenelse(self.Su_t[k] + self.Pe > self.sumax2, self.sumax2, self.Su_t[k] + self.Pe)
self.Quadd = ifthenelse(self.Su_t[k] + self.Pe > self.sumax2, self.Su_t[k] + self.Pe - self.sumax2, 0)
self.SuN = self.Su[k] / self.sumax2
self.SiN = self.Si[k] / self.imax[k]
self.Eu1 = max((self.PotEvaporation - self.Ei),0) * min(self.Su[k] / (self.sumax2 * self.LP[k]),1)
self.Qu1 = (self.Pe - self.Quadd) * (1 - (1 - self.SuN) ** self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Pe - self.Quadd) - self.Qu1 - self.Eu1 - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 +self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Qu = self.Qu1 + (self.Qu1/ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Perc = ifthenelse (self.Perc1 > 0, self.Perc1 + (self.Perc1/ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff, self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Pe - self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0 , self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax2), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[k] = self.Pe - self.Eu - self.Qu - self.Quadd - self.Perc + self. Cap - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def agriZone_Ep_Sa_beta(self, k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on LP
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qa u is determined from overflow from Sa --> incorporation of beta function
- Fa is based on storage in Sa
- Code for ini-file: 6
"""
JarvisCoefficients.calcEp(self, k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),
0)
self.samax2 = self.samax[k] * scalar(self.catchArea)
self.Qaadd = max(self.Sa_t[k] + self.Pe - self.samax2, 0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd)
self.SaN = min(max(self.Sa[k] / self.samax2, 0), 1)
self.SuN = self.Su[k] / self.sumax[k]
self.Ea1 = max((self.PotEvaporation - self.Ei), 0) * min(
self.Sa[k] / (self.samax2 * self.LP[k]), 1)
self.Qa1 = (self.Pe - self.Qaadd) * (1 - (1 - self.SaN)**self.beta[k])
self.Fa1 = ifthenelse(
self.SaN > 0, self.Fmin[k] +
(self.Fmax[k] - self.Fmin[k]) * e**(-self.decF[k] * (1 - self.SaN)), 0)
self.Sa[k] = self.Sa_t[k] + (self.Pe -
self.Qaadd) - self.Qa1 - self.Fa1 - self.Ea1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Qa = self.Qa1 + (
self.Qa1 / ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0, self.Fa1 +
self.Ea1 + self.Qa1, 1)) * self.Sa_diff
self.Fa = self.Fa1 + (
self.Fa1 / ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0, self.Fa1 +
self.Ea1 + self.Qa1, 1)) * self.Sa_diff
self.Ea = self.Ea1 + (
self.Ea1 / ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0, self.Fa1 +
self.Ea1 + self.Qa1, 1)) * self.Sa_diff
self.Sa[k] = self.Sa_t[k] + (self.Pe -
self.Qaadd) - self.Ea - self.Fa - self.Qa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0, self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.wbSa_[
k] = self.Pe - self.Ea - self.Qa - self.Qaadd - self.Fa - self.Sa[
k] + self.Sa_t[k]
self.Ea_[k] = self.Ea
self.Qa_[k] = self.Qa + self.Qaadd
self.Fa_[k] = self.Fa
def unsatZone_LP_beta_Ep_cropG(self,k):
"""
- Potential evaporation is calculated with formula in 'JarvisCoefficients', but without
using the Jarvis stress functions
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation linear until LP, from than with potential rate
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato
- Qu is determined with a beta function (same as in HBV?)
- root zone storage for crop land is decreased in autumn and winter
- Code for ini-file: 20
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = self.EpHour
#
# pdb.set_trace()
self.cropG_scal = pcr2numpy(self.cropG,NaN)
if any(self.cropG_scal == 1):
self.sumax2 = self.sumax[k]
elif any(self.cropG_scal > 0):
# pdb.set_trace()
self.sumax2 = self.sumax[k] * (1 - numpy.max(self.cropG_scal[self.cropG_scal >= 0]) * (1-self.redsu[k]))
else:
self.sumax2 = self.sumax[k] * self.redsu[k]
self.Su[k] = ifthenelse(self.Su_t[k] + self.Pe > self.sumax2, self.sumax2, self.Su_t[k] + self.Pe)
self.Quadd = ifthenelse(self.Su_t[k] + self.Pe > self.sumax2, self.Su_t[k] + self.Pe - self.sumax2, 0)
self.SuN = self.Su[k] / self.sumax2
self.SiN = self.Si[k] / self.imax[k]
self.Eu1 = max((self.PotEvaporation - self.Ei),0) * min(self.Su[k] / (self.sumax2 * self.LP[k]),1)
self.Qu1 = (self.Pe - self.Quadd) * (1 - (1 - self.SuN) ** self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Pe - self.Quadd) - self.Qu1 - self.Eu1 - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 +self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Qu = self.Qu1 + (self.Qu1/ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Perc = ifthenelse (self.Perc1 > 0, self.Perc1 + (self.Perc1/ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff, self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Pe - self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0 , self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax2), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[k] = self.Pe - self.Eu - self.Qu - self.Quadd - self.Perc + self. Cap - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def unsatZone_LP_beta_Ep_percDvar(self,k):
"""
- Potential evaporation is calculated with formula in 'JarvisCoefficients', but without
using the Jarvis stress functions
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation linear until LP, from than with potential rate
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato
- Qu is determined with a beta function (same as in HBV?)
- Code for ini-file: 13
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),0)
self.Su[k] = ifthenelse(self.Su_t[k] + self.Pe > self.sumax[k], self.sumax[k], self.Su_t[k] + self.Pe)
self.Quadd = ifthenelse(self.Su_t[k] + self.Pe > self.sumax[k], self.Su_t[k] + self.Pe - self.sumax[k], 0)
self.SuN = self.Su[k] / self.sumax[k]
self.SiN = self.Si[k] / self.imax[k]
self.drought = ifthenelse(self.SuN < self.LP[k], self.TopoId, ifthenelse(pcrand(self.SuN < 0.8, self.drought), self.TopoId, boolean(scalar(self.TopoId) * 0)))
self.stijg = max(min(scalar(ifthenelse(self.drought == 1, self.stijg + self.Su_t[k] - self.Su_t2[k], 0)), self.sumax[k] * 100), 0)
self.Eu1 = max((self.PotEvaporation - self.Ei),0) * min(self.Su[k] / (self.sumax[k] * self.LP[k]),1)
self.Qu1 = (self.Pe - self.Quadd) * (1 - (1 - self.SuN) ** self.beta[k])
# self.percDeep = max(10 * (1 - self.Ss / 30) * self.perc[k], 0)
self.percDeep = 0.8 * self.stijg * self.perc[k]
self.Perc1 = self.perc[k] * self.SuN + self.percDeep
self.Su[k] = self.Su_t[k] + (self.Pe - self.Quadd) - self.Qu1 - self.Eu1 - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 +self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Qu = self.Qu1 + (self.Qu1/ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Perc = ifthenelse (self.Perc1 > 0, self.Perc1 + (self.Perc1/ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff, self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Pe - self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0 , self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax[k]), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[k] = self.Pe - self.Eu - self.Qu - self.Quadd - self.Perc + self. Cap - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
self.Epot_[k] = self.PotEvaporation
self.percDeep_[k] = self.percDeep
def unsatZone_LP_beta_Jarvis(self, k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on Jarvis stress functions
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qu is determined with a beta function (same as in HBV?)
- Code for ini-file: 12
"""
self.Su[k] = ifthenelse(self.Su_t[k] + self.Pe > self.sumax[k],
self.sumax[k], self.Su_t[k] + self.Pe)
self.Quadd = ifthenelse(self.Su_t[k] + self.Pe > self.sumax[k],
self.Su_t[k] + self.Pe - self.sumax[k], 0)
self.SuN = self.Su[k] / self.sumax[k]
self.SiN = self.Si[k] / self.imax[k]
JarvisCoefficients.calcEu(
self, k, 1) #calculation of Eu based on Jarvis stress functions
self.Qu1 = (self.Pe - self.Quadd) * (1 - (1 - self.SuN)**self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Pe -
self.Quadd) - self.Qu1 - self.Eu - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Qu = self.Qu1 + (self.Qu1 / ifthenelse(
self.Qu1 + self.Perc1 > 0, self.Qu1 + self.Perc1, 1)) * self.Su_diff
self.Perc = ifthenelse(
self.Perc1 > 0, self.Perc1 +
(self.Perc1 / ifthenelse(self.Qu1 + self.Perc1 > 0,
self.Qu1 + self.Perc1, 1)) * self.Su_diff,
self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Pe -
self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0, self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax[k]), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[
k] = self.Pe - self.Eu - self.Qu - self.Quadd - self.Perc + self.Cap - self.Su[
k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def unsatZone_forAgri_Ep_cropG(self,k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on beta/LP
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qu is determined with a beta function (same as in HBV?)
- inflow is infiltration from agriculture reservoir
- Code for ini-file: 19
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),0)
self.cropG_scal = pcr2numpy(self.cropG,NaN)
if any(self.cropG_scal == 1):
self.sumax2 = self.sumax[k]
else:
self.sumax2 = self.sumax[k] * self.redsu[k]
self.Su[k] = ifthenelse(self.Su_t[k] + self.Fa > self.sumax2, self.sumax2, self.Su_t[k] + self.Fa)
self.Quadd = ifthenelse(self.Su_t[k] + self.Fa > self.sumax2, self.Su_t[k] + self.Fa - self.sumax2, 0)
self.SuN = self.Su[k] / self.sumax2
self.SiN = self.Si[k] / self.imax[k]
self.Eu1 = max((self.PotEvaporation - self.Ei),0) * min(self.Su[k] / (self.sumax2 * self.LP[k]),1)
self.Qu1 = (self.Fa - self.Quadd) * (1 - (1 - self.SuN) ** self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Fa - self.Quadd) - self.Qu1 - self.Eu - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Qu = self.Qu1 + (self.Qu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Perc = ifthenelse (self.Perc1 > 0, self.Perc1 + (self.Perc1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff, self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Fa - self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0 , self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax2), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[k] = self.Fa - self.Eu - self.Qu - self.Quadd - self.Perc + self. Cap - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def unsatZone_LP_beta_Ep_Ei(self,k):
"""
- Potential evaporation is calculated with formula in 'JarvisCoefficients', but without
using the Jarvis stress functions
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation linear until LP, from than with potential rate
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato
- Qu is determined with a beta function (same as in HBV?)
- Code for ini-file: 13
"""
#pdb.set_trace()
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),0)
self.Su[k] = ifthenelse(self.Su_t[k] + self.Pe > self.sumax[k], self.sumax[k], self.Su_t[k] + self.Pe)
self.Quadd = ifthenelse(self.Su_t[k] + self.Pe > self.sumax[k], self.Su_t[k] + self.Pe - self.sumax[k], 0)
self.SuN = self.Su[k] / self.sumax[k]
self.SiN = self.Si[k] / self.imax[k]
self.Eu1 = ifthenelse(self.SiN == 1, 0, max((self.PotEvaporation),0) * min(self.Su[k] / (self.sumax[k] * self.LP[k]),1))
# self.Eu1 = max((self.PotEvaporation),0) * min(self.Su[k] / (self.sumax[k] * self.LP[k]),1)
self.Qu1 = (self.Pe - self.Quadd) * (1 - (1 - self.SuN) ** self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Pe - self.Quadd) - self.Qu1 - self.Eu1 - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 +self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Qu = self.Qu1 + (self.Qu1/ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Perc = ifthenelse (self.Perc1 > 0, self.Perc1 + (self.Perc1/ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff, self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Pe - self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0 , self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax[k]), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[k] = self.Pe - self.Eu - self.Qu - self.Quadd - self.Perc + self. Cap - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
# self.Su_diff_[k] = self.Su_diff
# self.Quadd_[k] = self.Quadd
self.Epot_[k] = self.PotEvaporation
def unsatZone_withAgri_Ep(self,k):
"""
- Potential evaporation is calculated with formula in 'JarvisCoefficients', but without
using the Jarvis stress functions
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation linear until LP, from than with potential rate
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato
- Qu is determined with a beta function (same as in HBV?)
- Code for ini-file: 14
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),0)
self.Sa[k] = ifthenelse(self.Sa_t[k] + self.Pe > self.samax[k], self.samax[k], self.Sa_t[k] + self.Pe)
self.Qaadd = ifthenelse(self.Sa_t[k] + self.Pe > self.samax[k], self.Sa_t[k] + self.Pe - self.samax[k], 0)
self.SaN = self.Sa[k] / self.samax[k]
self.Ea1 = max((self.PotEvaporation - self.Ei),0) * min(self.Sa[k] / (self.samax[k] * self.LP[k]),1)
self.Qa1 = (self.Pe - self.Qaadd) * (1 - (1 - self.SaN) ** self.beta[k])
self.Fa1 = self.famax[k] * (self.sumax[k] - self.Su[k]) / self.sumax[k]
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd) - self.Qa1 - self.Ea1 - self.Fa1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Ea = self.Ea1 + (self.Ea1 / ifthenelse(self.Qa1 + self.Ea1 +self.Fa1 > 0 , self.Qa1 + self.Ea1 + self.Fa1 , 1)) * self.Sa_diff
self.Qa = self.Qa1 + (self.Qa1/ifthenelse(self.Qa1 + self.Ea1 + self.Fa1 > 0 , self.Qa1 + self.Ea1 + self.Fa1 , 1)) * self.Sa_diff
self.Fa = ifthenelse (self.Fa1 > 0, self.Fa1 + (self.Fa1/ifthenelse(self.Qa1 + self.Ea1 + self.Fa1 > 0 , self.Qa1 + self.Ea1 + self.Fa1 , 1)) * self.Sa_diff, self.Fa1)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd) - self.Ea - self.Qa - self.Fa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0 , self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.Capa = min(self.cap[k] * (1 - self.Sa[k] / self.samax[k]), self.Su[k])
self.Sa[k] = self.Sa[k] + self.Capa
self.Su[k] = self.Su_t[k] + self.Fa - self.Capa
self.Perc = self.perc[k] * (self.Su[k] / self.sumax[k])
self.Su[k] = self.Su[k] - self.Perc
self.wbSa_[k] = self.Pe - self.Ea - self.Qa - self.Qaadd - self.Fa + self. Capa - self.Sa[k] + self.Sa_t[k]
self.wbSu_[k] = self.Fa - self.Perc - self. Capa - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Ea
self.Qu_[k] = self.Qa + self.Qaadd
self.Fa_[k] = self.Fa
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def agriZone_Ep_Sa_cropG(self, k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on LP
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qa u is determined from overflow from Sa
- Fa is based on storage in Sa
- Code for ini-file: 4
"""
JarvisCoefficients.calcEp(self, k)
self.PotEvaporation = self.EpHour
self.samax2 = self.samax[k] * self.cropG
self.Qaadd = max(self.Sa_t[k] - self.samax2, 0)
# if self.teller == 66:
# pdb.set_trace()
self.Qa = max(self.Pe - (self.samax2 - self.Sa_t[k]), 0) + self.Qaadd
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa)
self.SaN = self.Sa[k] / self.samax2
self.SuN = self.Su[k] / self.sumax[k]
self.Ea1 = max((self.PotEvaporation - self.Ei), 0) * min(
self.Sa[k] / (self.samax2 * self.LP[k]), 1)
self.Fa1 = ifthenelse(
self.SaN > 0, self.Fmin[k] +
(self.Fmax[k] - self.Fmin[k]) * e**(-self.decF[k] * (1 - self.SaN)), 0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa) - self.Fa1 - self.Ea1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Fa = self.Fa1 + (self.Fa1 / ifthenelse(
self.Fa1 + self.Ea1 > 0, self.Fa1 + self.Ea1, 1)) * self.Sa_diff
self.Ea = self.Ea1 + (self.Ea1 / ifthenelse(
self.Fa1 + self.Ea1 > 0, self.Fa1 + self.Ea1, 1)) * self.Sa_diff
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qa) - self.Ea - self.Fa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0, self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.wbSa_[
k] = self.Pe - self.Ea - self.Qa - self.Fa - self.Sa[k] + self.Sa_t[k]
self.Ea_[k] = self.Ea
self.Qa_[k] = self.Qa
self.Fa_[k] = self.Fa
def unsatZone_forAgri_Ep_percDvar(self,k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on beta/LP
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qu is determined with a beta function (same as in HBV?)
- inflow is infiltration from agriculture reservoir
- Code for ini-file: 17
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),0)
self.Su[k] = ifthenelse(self.Su_t[k] + self.Fa > self.sumax[k], self.sumax[k], self.Su_t[k] + self.Fa)
self.Quadd = ifthenelse(self.Su_t[k] + self.Fa > self.sumax[k], self.Su_t[k] + self.Fa - self.sumax[k], 0)
self.SuN = self.Su[k] / self.sumax[k]
self.SiN = self.Si[k] / self.imax[k]
self.drought = ifthenelse(self.SuN < self.LP[k], self.TopoId, ifthenelse(pcrand(self.SuN < 0.8, self.drought), self.TopoId, boolean(scalar(self.TopoId) * 0)))
self.stijg = max(min(scalar(ifthenelse(self.drought == 1, self.stijg + self.Su_t[k] - self.Su_t2[k], 0)), self.sumax[k] * 100), 0)
# self.stijg = max(self.Su_t[k] - self.Su_t2[k], 0)
self.Eu1 = ifthenelse(self.Ft_[k] == 1, max((self.PotEvaporation - self.Ei - self.Ea),0) * min(self.Su[k] / (self.sumax[k] * self.LP[k]),1), 0) # no transpiration in case of frozen soil. Added on 22 feb 2016
self.percDeep = 0.8 * self.stijg * self.perc[k]
self.Qu1 = (self.Fa - self.Quadd) * (1 - (1 - self.SuN) ** self.beta[k])
self.Perc1 = self.perc[k] * self.SuN + self.percDeep
self.Su[k] = self.Su_t[k] + (self.Fa - self.Quadd) - self.Qu1 - self.Eu - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Qu = self.Qu1 + (self.Qu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Perc = ifthenelse (self.Perc1 > 0, self.Perc1 + (self.Perc1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff, self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Fa - self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0 , self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax[k]), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[k] = self.Fa - self.Eu - self.Qu - self.Quadd - self.Perc + self. Cap - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def agriZone_Ep_Sa_beta_frostSamax_surfTemp(self,k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on LP
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qa u is determined from overflow from Sa --> incorporation of beta function
- Fa is based on storage in Sa
- Fa is decreased in case of frozen soil
- Code for ini-file: 13
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = self.EpHour
self.FrDur[k] = min(self.FrDur[k] + ifthenelse(self.TempSurf > 0, self.ratFT[k] * self.TempSurf, self.TempSurf) * self.dayDeg[k], 0)
self.Ft = min(max(self.FrDur[k] / (self.FrDur1[k] - self.FrDur0[k]) - self.FrDur0[k] / (self.FrDur1[k] - self.FrDur0[k]), self.samin[k]), 1)
self.samax2 = self.samax[k] * scalar(self.catchArea) * self.Ft
self.Qaadd = max(self.Sa_t[k] + self.Pe - self.samax2,0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd)
self.SaN = min(self.Sa[k] / self.samax2, 1)
self.SuN = self.Su[k] / self.sumax[k]
self.Ea1 = max((self.PotEvaporation - self.Ei),0) * min(self.Sa[k] / (self.samax2 * self.LP[k]),1)
self.Qa1 = (self.Pe - self.Qaadd) * (1 - (1 - self.SaN) ** self.beta[k])
self.Fa1 = ifthenelse(self.SaN > 0,self.Fmin[k] + (self.Fmax[k] - self.Fmin[k]) * e ** (-self.decF[k] * (1 - self.SaN)),0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd) - self.Qa1 - self.Fa1 - self.Ea1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Qa = self.Qa1 + (self.Qa1/ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0, self.Fa1 + self.Ea1 + self.Qa1, 1)) * self.Sa_diff
self.Fa = self.Fa1 + (self.Fa1/ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0, self.Fa1 + self.Ea1 + self.Qa1, 1)) * self.Sa_diff
self.Ea = self.Ea1 + (self.Ea1/ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0, self.Fa1 + self.Ea1 + self.Qa1, 1)) * self.Sa_diff
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd) - self.Ea - self.Fa - self.Qa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0 , self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.wbSa_[k] = self.Pe - self.Ea - self.Qa - self.Qaadd - self.Fa - self.Sa[k] + self.Sa_t[k]
self.Ea_[k] = self.Ea
self.Qa_[k] = self.Qa + self.Qaadd
self.Fa_[k] = self.Fa
self.Ft_[k] = self.Ft
def unsatZone_forAgri_Jarvis(self,k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on Jarvis stress functions
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qu is determined with a beta function (same as in HBV?)
- inflow is infiltration from agriculture reservoir
- Code for ini-file: 16
"""
self.Su[k] = ifthenelse(self.Su_t[k] + self.Fa > self.sumax[k], self.sumax[k], self.Su_t[k] + self.Fa)
self.Quadd = ifthenelse(self.Su_t[k] + self.Fa > self.sumax[k], self.Su_t[k] + self.Fa - self.sumax[k], 0)
self.SuN = self.Su[k] / self.sumax[k]
self.SiN = self.Si[k] / self.imax[k]
JarvisCoefficients.calcEu(self,k,2) #calculation of Eu based on Jarvis stress functions
self.Eu1 = self.Eu
self.Qu1 = (self.Fa - self.Quadd) * (1 - (1 - self.SuN) ** self.beta[k])
self.Perc1 = self.perc[k] * self.SuN
self.Su[k] = self.Su_t[k] + (self.Fa - self.Quadd) - self.Qu1 - self.Eu - self.Perc1
self.Su_diff = ifthenelse(self.Su[k] < 0, self.Su[k], 0)
self.Eu = self.Eu1 + (self.Eu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Qu = self.Qu1 + (self.Qu1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff
self.Perc = ifthenelse (self.Perc1 > 0, self.Perc1 + (self.Perc1 / ifthenelse(self.Qu1 + self.Eu1 + self.Perc1 > 0 , self.Qu1 + self.Eu1 + self.Perc1 , 1)) * self.Su_diff, self.Perc1)
self.Su[k] = self.Su_t[k] + (self.Fa - self.Quadd) - self.Eu - self.Qu - self.Perc
self.Su[k] = ifthenelse(self.Su[k] < 0, 0 , self.Su[k])
self.Su_diff2 = ifthen(self.Su[k] < 0, self.Su[k])
self.Cap = min(self.cap[k] * (1 - self.Su[k] / self.sumax[k]), self.Ss)
self.Su[k] = self.Su[k] + self.Cap
self.wbSu_[k] = self.Fa - self.Eu - self.Qu - self.Quadd - self.Perc + self. Cap - self.Su[k] + self.Su_t[k]
self.Eu_[k] = self.Eu
self.Qu_[k] = self.Qu + self.Quadd
self.Cap_[k] = self.Cap
self.Perc_[k] = self.Perc
def agriZone_Ep_Sa_cropG_beta(self,k):
"""
- Potential evaporation is decreased by energy used for interception evaporation
- Formula for evaporation based on LP
- Outgoing fluxes are determined based on (value in previous timestep + inflow)
and if this leads to negative storage, the outgoing fluxes are corrected to rato --> Eu is
no longer taken into account for this correction
- Qa u is determined from overflow from Sa --> incorporation of beta function
- Fa is based on storage in Sa
"""
JarvisCoefficients.calcEp(self,k)
self.PotEvaporation = cover(ifthenelse(self.EpHour >= 0, self.EpHour, 0),0)
self.samax2 = self.samax[k] * self.cropG
self.Qaadd = max(self.Sa_t[k] + self.Pe - self.samax2,0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd)
self.SaN = self.Sa[k] / self.samax2
self.SuN = self.Su[k] / self.sumax[k]
self.Ea1 = max((self.PotEvaporation - self.Ei),0) * min(self.Sa[k] / (self.samax2 * self.LP[k]),1)
self.Qa1 = (self.Pe - self.Qaadd) * (1 - (1 - self.SaN) ** self.beta[k])
self.Fa1 = ifthenelse(self.SaN > 0,self.Fmin[k] + (self.Fmax[k] - self.Fmin[k]) * e ** (-self.decF[k] * (1 - self.SaN)),0)
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd) - self.Qa1 - self.Fa1 - self.Ea1
self.Sa_diff = ifthenelse(self.Sa[k] < 0, self.Sa[k], 0)
self.Qa = self.Qa1 + (self.Qa1/ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0 , self.Fa1 + self.Ea1 + self.Qa1, 1)) * self.Sa_diff
self.Fa = self.Fa1 + (self.Fa1/ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0 , self.Fa1 + self.Ea1 + self.Qa1 , 1)) * self.Sa_diff
self.Ea = self.Ea1 + (self.Ea1/ifthenelse(self.Fa1 + self.Ea1 + self.Qa1 > 0 , self.Fa1 + self.Ea1 + self.Qa1 , 1)) * self.Sa_diff
self.Sa[k] = self.Sa_t[k] + (self.Pe - self.Qaadd) - self.Ea - self.Fa - self.Qa
self.Sa[k] = ifthenelse(self.Sa[k] < 0, 0 , self.Sa[k])
self.Sa_diff2 = ifthen(self.Sa[k] < 0, self.Sa[k])
self.wbSa_[k] = self.Pe - self.Ea - self.Qa - self.Qaadd - self.Fa - self.Sa[k] + self.Sa_t[k]
self.Ea_[k] = self.Ea
self.Qa_[k] = self.Qa + self.Qaadd
self.Fa_[k] = self.Fa
