def zonalSumArea(nominalMap, areaClass):
"""Memory efficient method to sum up the surface area of the different
classes in the nominal map. Separate by the regions in areaClass
input:
nominalMap: nominal map, e.g. ecotope map
areaClass: regions to compute surface areas over
"""
#-create a pointMap of the output locations, one for each areaClass
outputPointMap = pcrr.pointPerClass(areaClass)
#-iniate output DataFrame
dfInit = pcrr.getCellValues(outputPointMap, mapList = [areaClass], columns = ['areaClass'])
#-loop over the classes in nominalMap and compute the summed area per areaClass
IDs = np.unique(pcr.pcr2numpy(nominalMap, -9999))[1:]
dfList = []
for ID in IDs[:]:
pcrID = pcr.nominal(ID)
pcr.setglobaloption('unittrue')
IDArea = pcr.ifthen(nominalMap == pcrID, pcr.cellarea())
sectionSum = pcr.areatotal(IDArea, areaClass)
df = pcrr.getCellValues(outputPointMap, [sectionSum], [ID])
# df columns = rowIdx, colIdx, ID
df = df.drop(['rowIdx', 'colIdx'], axis=1)
dfList.append(df)
dfOut = dfInit.join(dfList)
#return dfInit, df, dfOut, dfList
return dfOut
def calculateLateralFlowDarcy(self):
self.calculateThicknessOfSaturatedLayer()
self.lateralFlowCubicMetrePerDay = self.slopeToDownstreamNeighbourNotFlat * self.saturatedConductivityMetrePerDay \
* pcr.celllength() * self.saturatedLayerThickness
self.lateralFlowCubicMetrePerTimeStep = (
self.lateralFlowCubicMetrePerDay / 24.0) * self.timeStepDuration
self.lateralFlowDarcyFluxAmount = self.lateralFlowCubicMetrePerTimeStep / pcr.cellarea(
)
def calculateLateralFlow(self):
self.calculateLateralFlowDarcy()
# outgoing lateral flow may not be greater than soil moisture minus wilting point
self.calculateSoilMoistureMinusWiltingPointThick()
self.lateralFlowFluxAmount = pcr.min(
self.lateralFlowDarcyFluxAmount,
self.soilMoistureMinusWiltingPointThick)
self.lateralFlowFluxCubicMetresPerHour = self.amountToFlux(
self.lateralFlowFluxAmount) * pcr.cellarea()
def areastat(Var, Area):
"""
Calculate several statistics of *Var* for each unique id in *Area*
Input:
- Var
- Area
Output:
- Standard_Deviation,Average,Max,Min
"""
Avg = pcr.areaaverage(Var, Area)
Sq = (Var - Avg) ** 2
N = pcr.areatotal(pcr.spatial(pcr.cellarea()), Area) / pcr.cellarea()
Sd = (pcr.areatotal(Sq, Area) / N) ** 0.5
Max = pcr.areamaximum(Var, Area)
Min = pcr.areaminimum(Var, Area)
return Sd, Avg, Max, Min
def areastat(Var, Area):
"""
Calculate several statistics of *Var* for each unique id in *Area*
Input:
- Var
- Area
Output:
- Standard_Deviation,Average,Max,Min
"""
Avg = pcr.areaaverage(Var, Area)
Sq = (Var - Avg) ** 2
N = pcr.areatotal(pcr.spatial(pcr.cellarea()), Area) / pcr.cellarea()
Sd = (pcr.areatotal(Sq, Area) / N) ** 0.5
Max = pcr.areamaximum(Var, Area)
Min = pcr.areaminimum(Var, Area)
return Sd, Avg, Max, Min
def dem_lowering(self, msr, area_polluted):
"""Calculate the cost and standard deviation of lowering the DEM."""
if msr.settings.loc['msr_type', 1] in ['sidechannel', 'lowering']:
# Determine the total volumetric difference over the measure area
# Assume that polluted area is < 0.5 m deep, see doc and Middelkoop.
dh_tot = self.ref_dem - msr.dem
dh_polluted = pcr.ifthen(area_polluted, pcr.min(0.5, dh_tot))
# pcr.aguila(dh_polluted)
dV_tot = dh_tot * pcr.cellarea()
dV_polluted = dh_polluted * pcr.cellarea()
volume_tot = area_total_value(dV_tot, msr.area)
volume_polluted = area_total_value(dV_polluted, area_polluted)
else:
volume_tot = 0
volume_polluted = 0
# Return cost and standard deviation as a dataframe
cost_ew = self.cost_input.iloc[0:3, 0:2]
cost_init = volume_tot * cost_ew.drop('flpl_low_polluted')
cost_polluted = volume_polluted * cost_ew.loc['flpl_low_polluted', :]
cost_out = cost_init.copy()
cost_out = cost_out.append(cost_polluted)
return cost_out
def __init__(self, ldd, timeStepDuration, timeStepsToReport, setOfVariablesToReport):
# init for supsend and resume in filtering
self.RunoffCubicMetrePerHour = pcr.scalar(0)
self.RunoffCubicMeterPerHourMovingAverage = pcr.scalar(0)
self.actualAbstractionFlux = pcr.scalar(0)
self.variablesToReport = {}
self.variablesAsNumpyToReport = {}
# real init
self.ldd = ldd
self.timeStepDuration = pcr.scalar(timeStepDuration)
self.cellArea = pcr.cellarea()
self.cumulativeDischargeCubicMetres = pcr.scalar(0.0)
self.timeStepsToReport = timeStepsToReport
self.setOfVariablesToReport = setOfVariablesToReport
def __init__(self, ldd, demOfBedrockTopography, regolithThickness,
initialSoilMoistureFraction, soilPorosityFraction,
wiltingPointFraction, fieldCapacityFraction,
limitingPointFraction, saturatedConductivityMetrePerDay,
timeStepDuration, timeStepsToReport, setOfVariablesToReport):
######
# inits only for suspend and resume in filtering
######
self.actualAbstractionFlux = pcr.scalar(0)
self.actualAbstractionFluxAmount = pcr.scalar(0)
self.actualAdditionFlux = pcr.scalar(0)
self.actualAdditionFluxAmount = pcr.scalar(0)
self.fWaterPotential = pcr.scalar(0)
self.lateralFlowCubicMetrePerDay = pcr.scalar(0)
self.lateralFlowCubicMetrePerTimeStep = pcr.scalar(0)
self.lateralFlowDarcyFluxAmount = pcr.scalar(0)
self.lateralFlowFluxAmount = pcr.scalar(0)
self.lateralFlowFluxCubicMetresPerHour = pcr.scalar(0)
self.maximumAbstractionThick = pcr.scalar(0)
self.maximumAdditionThick = pcr.scalar(0)
self.saturatedLayerThick = pcr.scalar(0)
self.saturatedLayerThickness = pcr.scalar(0)
self.soilMoistureMinusWiltingPointThick = pcr.scalar(0)
self.upwardSeepageAmount = pcr.scalar(0)
self.upwardSeepageFlux = pcr.scalar(0)
self.totalUpwardSeepageInUpstreamAreaCubicMetrePerHour = pcr.scalar(0)
self.totalActualAbstractionInUpstreamAreaCubicMetrePerHour = pcr.scalar(
0)
self.totalSoilMoistureThickInUpstreamAreaCubicMetre = pcr.scalar(0)
self.totalSoilMoistureFractionInUpstreamAreaTimesCellArea = pcr.scalar(
0)
self.totalSaturatedThickInUpstreamAreaCubicMetre = pcr.scalar(0)
self.soilMoistureFraction = pcr.scalar(0)
self.variablesToReport = {}
self.variablesAsNumpyToReport = {}
self.wiltingPointThick = pcr.scalar(0)
####
# real inits
####
self.cellArea = pcr.cellarea()
self.setBedrock(ldd, demOfBedrockTopography)
# parameters depending on regolith thickness
self.convertFractionsToThickness(regolithThickness,
soilPorosityFraction,
wiltingPointFraction,
limitingPointFraction,
fieldCapacityFraction)
# main state variable, amount of water
self.initialSoilMoistureFraction = initialSoilMoistureFraction
self.initialSoilMoistureThick = self.initialSoilMoistureFraction * self.regolithThickness
self.soilMoistureThick = self.initialSoilMoistureThick
# values independent of regolith thickness
self.saturatedConductivityMetrePerDay = saturatedConductivityMetrePerDay
self.timeStepDuration = timeStepDuration
self.timeStepsToReport = timeStepsToReport
self.setOfVariablesToReport = setOfVariablesToReport
# DJ add check on fractions (e.g. wiltingpoint cannot be bigger than soil porosity)
# for budgets
self.actualAdditionCum = pcr.scalar(0)
self.actualAbstractionCum = pcr.scalar(0)
self.lateralFlowFluxAmountCum = pcr.scalar(0)
self.upwardSeepageCum = pcr.scalar(0)
def totalActualAbstractionInUpstreamArea(self):
self.totalActualAbstractionInUpstreamAreaCubicMetrePerHour = pcr.accuflux(
self.ldd, self.actualAbstractionFlux) * pcr.cellarea()
def checkBudgets(self, currentSampleNumber, currentTimeStep):
increaseInPrecipitationStore = 0.0 - self.d_exchangevariables.cumulativePrecipitation
pcr.report(
increaseInPrecipitationStore,
pcrfw.generateNameST('incP', currentSampleNumber, currentTimeStep))
increaseInInterceptionStore = self.d_interceptionuptomaxstore.budgetCheck(
currentSampleNumber, currentTimeStep)
pcr.report(
increaseInInterceptionStore,
pcrfw.generateNameST('incI', currentSampleNumber, currentTimeStep))
increaseInSurfaceStore = self.d_surfaceStore.budgetCheck(
currentSampleNumber, currentTimeStep)
pcr.report(
increaseInSurfaceStore,
pcrfw.generateNameST('incS', currentSampleNumber, currentTimeStep))
increaseInSurfaceStoreQM = pcr.catchmenttotal(
increaseInSurfaceStore, self.ldd) * pcr.cellarea()
pcr.report(
increaseInSurfaceStoreQM,
pcrfw.generateNameST('testb', currentSampleNumber,
currentTimeStep))
# let op: infiltration store is directly passed to subsurface store, thus is not a real store
increaseInInfiltrationStore = self.d_infiltrationgreenandampt.budgetCheck(
currentSampleNumber, currentTimeStep)
increaseInSubSurfaceWaterStore, lateralFlowInSubsurfaceStore, abstractionFromSubSurfaceWaterStore = \
self.d_subsurfaceWaterOneLayer.budgetCheck(currentSampleNumber, currentTimeStep)
increaseInSubSurfaceStoreQM = pcr.catchmenttotal(
increaseInSubSurfaceWaterStore, self.ldd) * pcr.cellarea()
increaseInRunoffStoreCubicMetresInUpstreamArea = self.d_runoffAccuthreshold.budgetCheck(
)
totalIncreaseInStoresCubicMetresInUpstreamArea = 0.0
stores = [
increaseInPrecipitationStore, increaseInInterceptionStore,
increaseInSurfaceStore, increaseInSubSurfaceWaterStore
]
for store in stores:
increaseInStoreCubicMetresInUpstreamArea = pcr.catchmenttotal(
store, self.ldd) * pcr.cellarea()
totalIncreaseInStoresCubicMetresInUpstreamArea = totalIncreaseInStoresCubicMetresInUpstreamArea + \
increaseInStoreCubicMetresInUpstreamArea
pcr.report(
totalIncreaseInStoresCubicMetresInUpstreamArea,
pcrfw.generateNameST('inSt', currentSampleNumber, currentTimeStep))
pcr.report(
increaseInRunoffStoreCubicMetresInUpstreamArea,
pcrfw.generateNameST('inRu', currentSampleNumber, currentTimeStep))
pcr.report(
pcr.catchmenttotal(self.d_exchangevariables.upwardSeepageFlux,
self.ldd) * pcr.cellarea(),
pcrfw.generateNameST('inSe', currentSampleNumber, currentTimeStep))
# total budget is total increase in stores plus the upward seepage flux for each ts that is passed to the next
# timestep and thus not taken into account in the current timestep budgets
budget = totalIncreaseInStoresCubicMetresInUpstreamArea + increaseInRunoffStoreCubicMetresInUpstreamArea + \
lateralFlowInSubsurfaceStore * pcr.cellarea() + pcr.catchmenttotal(abstractionFromSubSurfaceWaterStore, self.ldd) * pcr.cellarea() + \
pcr.catchmenttotal(self.d_exchangevariables.upwardSeepageFlux, self.ldd) * pcr.cellarea()
pcr.report(
budget,
pcrfw.generateNameST('B-tot', currentSampleNumber,
currentTimeStep))
budgetRel = budget / increaseInRunoffStoreCubicMetresInUpstreamArea
pcr.report(
budgetRel,
pcrfw.generateNameST('B-rel', currentSampleNumber,
currentTimeStep))
def dynamic(self):
self.counter += 1
print(
str(self.curdate.day) + '-' + str(self.curdate.month) + '-' +
str(self.curdate.year) + ' t = ' + str(self.counter))
#-Snow and rain fraction settings for non-glacier part of model cell
SnowFrac = pcr.ifthenelse(self.SnowStore > 0,
pcr.scalar(1 - self.GlacFrac), 0)
RainFrac = pcr.ifthenelse(self.SnowStore == 0,
pcr.scalar(1 - self.GlacFrac), 0)
#-Read the precipitation time-series
if self.precNetcdfFLAG == 1:
#-read forcing by netcdf input
Precip = self.netcdf2PCraster.netcdf2pcrDynamic(self, pcr, 'Prec')
else:
#-read forcing by map input
Precip = pcr.readmap(pcrm.generateNameT(self.Prec, self.counter))
PrecipTot = Precip
#-Report Precip
self.reporting.reporting(self, pcr, 'TotPrec', Precip)
self.reporting.reporting(self, pcr, 'TotPrecF',
Precip * (1 - self.GlacFrac))
#-Temperature and determine reference evapotranspiration
if self.tempNetcdfFLAG == 1:
#-read forcing by netcdf input
Temp = self.netcdf2PCraster.netcdf2pcrDynamic(self, pcr, 'Temp')
else:
#-read forcing by map input
Temp = pcr.readmap(pcrm.generateNameT(self.Tair, self.counter))
if self.ETREF_FLAG == 0:
if self.TminNetcdfFLAG == 1:
#-read forcing by netcdf input
TempMin = self.netcdf2PCraster.netcdf2pcrDynamic(
self, pcr, 'Tmin')
else:
#-read forcing by map input
TempMin = pcr.readmap(
pcrm.generateNameT(self.Tmin, self.counter))
if self.TmaxNetcdfFLAG == 1:
#-read forcing by netcdf input
TempMax = self.netcdf2PCraster.netcdf2pcrDynamic(
self, pcr, 'Tmax')
else:
#-read forcing by map input
TempMax = pcr.readmap(
pcrm.generateNameT(self.Tmax, self.counter))
ETref = self.Hargreaves.Hargreaves(
pcr, self.Hargreaves.extrarad(self, pcr), Temp, TempMax,
TempMin)
else:
ETref = pcr.readmap(pcrm.generateNameT(self.ETref, self.counter))
self.reporting.reporting(self, pcr, 'TotETref', ETref)
self.reporting.reporting(self, pcr, 'TotETrefF',
ETref * (1 - self.GlacFrac))
#-Interception and effective precipitation
if self.DynVegFLAG == 1:
#-read dynamic processes dynamic vegetation
Precip = self.dynamic_veg.dynamic(self, pcr, pcrm, np, Precip,
ETref)
elif self.KcStatFLAG == 0:
#-Try to read the KC map series
try:
self.Kc = pcr.readmap(
pcrm.generateNameT(self.Kcmaps, self.counter))
self.KcOld = self.Kc
except:
self.Kc = self.KcOld
#-report mm effective precipitation for sub-basin averages
if self.mm_rep_FLAG == 1 and self.Prec_mm_FLAG == 1 and (
self.RoutFLAG == 1 or self.ResFLAG == 1 or self.LakeFLAG == 1):
self.PrecSubBasinTSS.sample(
pcr.catchmenttotal(Precip *
(1 - self.GlacFrac), self.FlowDir) /
pcr.catchmenttotal(1, self.FlowDir))
#-Snow, rain, and glacier calculations for glacier fraction of cell
if self.GlacFLAG:
#-read dynamic processes glacier
Rain_GLAC, Snow_GLAC, ActSnowMelt_GLAC, SnowR_GLAC, GlacMelt, GlacPerc, self.GlacR = self.glacier.dynamic(
self, pcr, pd, Temp, Precip)
#-If glacier module is not used, then
else:
Rain_GLAC = 0
Snow_GLAC = 0
ActSnowMelt_GLAC = 0
self.TotalSnowStore_GLAC = 0
SnowR_GLAC = 0
self.GlacR = 0
GlacMelt = 0
GlacPerc = 0
# Calculate snow and rain for non-glacier part of cell
if self.SnowFLAG == 1:
#-read dynamic processes snow
Rain, self.SnowR, OldTotalSnowStore = self.snow.dynamic(
self, pcr, Temp, Precip, Snow_GLAC, ActSnowMelt_GLAC, SnowFrac,
RainFrac, SnowR_GLAC)
else:
Rain = Precip
self.SnowR = 0
OldTotalSnowStore = 0
self.TotalSnowStore = 0
#-Report Rain
self.reporting.reporting(self, pcr, 'TotRain', Rain)
self.reporting.reporting(self, pcr, 'TotRainF',
Rain * (1 - self.GlacFrac) +
Rain_GLAC) # for entire cell
#-Potential evapotranspiration
ETpot = self.ET.ETpot(ETref, self.Kc)
if self.ETOpenWaterFLAG == 1:
self.ETOpenWater = self.ET.ETpot(ETref, self.kcOpenWater)
#-Report ETpot
self.reporting.reporting(self, pcr, 'TotETpot', ETpot)
self.reporting.reporting(self, pcr, 'TotETpotF', ETpot * RainFrac)
#-Rootzone calculations
self.RootWater = self.RootWater + self.CapRise
#-Calculate rootzone runoff
tempvar = self.rootzone.RootRunoff(self, pcr, RainFrac, Rain)
#-Rootzone runoff
RootRunoff = tempvar[0]
#-Infiltration
Infil = tempvar[1]
#-Report infiltration
self.reporting.reporting(self, pcr, 'Infil', Infil)
#-Updated rootwater content
self.RootWater = pcr.ifthenelse(RainFrac > 0, self.RootWater + Infil,
self.RootWater)
#-Actual evapotranspiration
if self.PlantWaterStressFLAG == 1:
etreddry = self.ET.ks(self, pcr, ETpot)
else:
etreddry = pcr.max(
pcr.min((self.RootWater - self.RootDry) /
(self.RootWilt - self.RootDry), 1), 0)
self.reporting.reporting(self, pcr, 'PlantStress', 1 - etreddry)
ETact = self.ET.ETact(pcr, ETpot, self.RootWater, self.RootSat,
etreddry, RainFrac)
#-Report the actual evapotranspiration
self.reporting.reporting(
self, pcr, 'TotETact',
ETact * (1 - self.openWaterFrac) +
self.ETOpenWater * self.openWaterFrac)
#-Actual evapotranspiration, corrected for rain fraction
ActETact = ETact * RainFrac
#-Report the actual evapotranspiration, corrected for rain fraction
self.reporting.reporting(self, pcr, 'TotETactF', ActETact)
if self.mm_rep_FLAG == 1 and self.ETa_mm_FLAG == 1 and (
self.RoutFLAG == 1 or self.ResFLAG == 1 or self.LakeFLAG == 1):
self.ETaSubBasinTSS.sample(
pcr.catchmenttotal(ActETact, self.FlowDir) /
pcr.catchmenttotal(1, self.FlowDir))
#-Update rootwater content
self.RootWater = pcr.max(self.RootWater - ETact, 0)
#-Calculate drainage
temp_RootDrain = self.rootzone.RootDrainage(
pcr, self.RootWater, self.RootDrain, self.RootField, self.RootSat,
self.RootDrainVel, self.RootTT)
#-Calculate percolation
temp_rootperc = self.rootzone.RootPercolation(pcr, self.RootWater,
self.SubWater,
self.RootField,
self.RootTT, self.SubSat)
#-Total sum of water able to leave the soil
RootOut = temp_RootDrain + temp_rootperc
#-Calculate new values for drainage and percolation (to be used when RootOut > RootExcess)
newdrain, newperc = self.rootzone.CalcFrac(pcr, self.RootWater,
self.RootField,
temp_RootDrain,
temp_rootperc)
#-Determine whether the new values need to be used
rootexcess = pcr.max(self.RootWater - self.RootField, 0)
self.RootDrain = pcr.ifthenelse(RootOut > rootexcess, newdrain,
temp_RootDrain)
rootperc = pcr.ifthenelse(RootOut > rootexcess, newperc, temp_rootperc)
#-Update the RootWater content
# Roottemp = self.RootWater
self.RootWater = self.RootWater - (self.RootDrain + rootperc)
#-Report rootzone percolation, corrected for fraction
self.reporting.reporting(self, pcr, 'TotRootPF',
rootperc * (1 - self.GlacFrac))
#-Report rootwater content
self.reporting.reporting(self, pcr, 'StorRootW',
self.RootWater * (1 - self.openWaterFrac))
#-Sub soil calculations
self.SubWater = self.SubWater + rootperc
if self.GroundFLAG == 0:
if self.SeepStatFLAG == 0:
try:
self.SeePage = pcr.readmap(
pcrm.generateNameT(self.Seepmaps, self.counter))
self.SeepOld = self.SeePage
except:
self.SeePage = self.SeepOld
#-Report seepage
self.reporting.reporting(self, pcr, 'TotSeepF',
pcr.scalar(self.SeePage))
self.SubWater = pcr.min(pcr.max(self.SubWater - self.SeePage, 0),
self.SubSat)
if self.mm_rep_FLAG == 1 and self.Seep_mm_FLAG == 1 and (
self.RoutFLAG == 1 or self.ResFLAG == 1
or self.LakeFLAG == 1):
self.SeepSubBasinTSS.sample(
pcr.catchmenttotal(self.SeePage, self.FlowDir) /
pcr.catchmenttotal(1, self.FlowDir))
#-Capillary rise
self.CapRise = self.subzone.CapilRise(pcr, self.SubField,
self.SubWater, self.CapRiseMax,
self.RootWater, self.RootSat,
self.RootField)
#-Report capillary rise, corrected for fraction
self.reporting.reporting(self, pcr, 'TotCapRF',
self.CapRise * (1 - self.GlacFrac))
#-Update sub soil water content
self.SubWater = self.SubWater - self.CapRise
if self.GroundFLAG == 1: # sub percolation will be calculated instead of subdrainage
subperc = self.subzone.SubPercolation(pcr, self.SubWater,
self.SubField, self.SubTT,
self.Gw, self.GwSat)
ActSubPerc = subperc * (1 - self.GlacFrac)
#-Report the subzone percolation, corrected for the fraction
self.reporting.reporting(self, pcr, 'TotSubPF', ActSubPerc)
#-Update sub soil water content
self.SubWater = self.SubWater - subperc
else: # sub drainage will be calculated instead of sub percolation
self.SubDrain = self.subzone.SubDrainage(pcr, self.SubWater,
self.SubField,
self.SubSat,
self.SubDrainVel,
self.SubDrain, self.SubTT)
#-Report drainage from subzone
self.reporting.reporting(self, pcr, 'TotSubDF', self.SubDrain)
#-Update sub soil water content
self.SubWater = self.SubWater - self.SubDrain
#-Report rootwater content
self.reporting.reporting(self, pcr, 'StorSubW',
self.SubWater * (1 - self.openWaterFrac))
#-Changes in soil water storage
OldSoilWater = self.SoilWater
self.SoilWater = (self.RootWater + self.SubWater) * (1 - self.GlacFrac)
#-Rootzone runoff
self.RootRR = RootRunoff * RainFrac * (1 - self.openWaterFrac)
#-Report rootzone runoff, corrected for fraction
self.reporting.reporting(self, pcr, 'TotRootRF', self.RootRR)
#-Rootzone drainage
self.RootDR = self.RootDrain * (1 - self.GlacFrac) * (
1 - self.openWaterFrac)
#-Report rootzone drainage, corrected for fraction
self.reporting.reporting(self, pcr, 'TotRootDF', self.RootDR)
#-Rain runoff
self.RainR = self.RootRR + self.RootDR
#-Report rain runoff
self.reporting.reporting(self, pcr, 'TotRainRF', self.RainR)
#-Groundwater calculations
if self.GroundFLAG == 1:
#-read dynamic processes groundwater
self.groundwater.dynamic(self, pcr, ActSubPerc, GlacPerc)
else:
#-Use drainage from subsoil as baseflow
self.BaseR = self.SubDrain
#-Groundwater level as scaled between min and max measured gwl
SoilAct = self.RootWater + self.SubWater
SoilRel = (SoilAct - self.SoilMin) / (
self.SoilMax - self.SoilMin
) # scale between 0 (dry) and 1 (wet)
GWL = self.GWL_base - (SoilRel - 0.5) * self.GWL_base
#-Report groundwater
self.reporting.reporting(self, pcr, 'GWL', GWL)
#-Report Total runoff
TotR = self.BaseR + self.RainR + self.SnowR + self.GlacR
self.reporting.reporting(self, pcr, 'TotRF', TotR)
#-Routing for lake and/or reservoir modules
if self.LakeFLAG == 1 or self.ResFLAG == 1:
#-read dynamic processes advanced routing
Q = self.advanced_routing.dynamic(self, pcr, pcrm, config, TotR,
self.ETOpenWater, PrecipTot)
#-Normal routing module
elif self.RoutFLAG == 1:
self.routing.dynamic(self, pcr, TotR)
if self.GlacFLAG:
#-read dynamic reporting processes glacier
self.glacier.dynamic_reporting(self, pcr, pd, np)
#-Water balance
if self.GlacFLAG and self.GlacRetreat == 1:
GlacTable_MODid = self.GlacTable.loc[:, ['FRAC_GLAC', 'ICE_DEPTH']]
GlacTable_MODid['ICE_DEPTH'] = GlacTable_MODid[
'ICE_DEPTH'] * GlacTable_MODid['FRAC_GLAC']
GlacTable_MODid = GlacTable_MODid.groupby(
GlacTable_MODid.index).sum()
GlacTable_MODid.fillna(0., inplace=True)
#-Report pcraster map of glacier depth
iceDepth = pcr.numpy.zeros(self.ModelID_1d.shape)
iceDepth[self.GlacierKeys] = GlacTable_MODid['ICE_DEPTH']
iceDepth = iceDepth.reshape(self.ModelID.shape)
iceDepth = pcr.numpy2pcr(pcr.Scalar, iceDepth, self.MV)
iceDepth = pcr.ifthen(
self.clone, iceDepth) #-only use values where clone is True
iceDepth = iceDepth * 1000 # in mm
#-change in storage
dS = ((self.RootWater - self.oldRootWater) + (self.SubWater - self.oldSubWater)) * (1-self.GlacFrac) + (self.Gw - self.oldGw) + \
(self.TotalSnowStore-OldTotalSnowStore) + (iceDepth - self.oldIceDepth)
#-set old state variables for glacier
self.oldIceDepth = iceDepth
iceDepth = None
del iceDepth
GlacTable_MODid = None
del GlacTable_MODid
elif self.GroundFLAG:
#-change in storage
dS = ((self.RootWater - self.oldRootWater) + (self.SubWater - self.oldSubWater)) * (1-self.GlacFrac) + (self.Gw - self.oldGw) + \
(self.TotalSnowStore-OldTotalSnowStore)
# set old state variables for groundwater
self.oldGw = self.Gw
else:
#-change in storage
dS = ((self.RootWater - self.oldRootWater) +
(self.SubWater - self.oldSubWater)) * (1 - self.GlacFrac) + (
self.TotalSnowStore - OldTotalSnowStore)
#-water balance per time step
if self.GroundFLAG:
waterbalance = Precip - ActETact - self.BaseR - self.RainR - self.SnowR - self.GlacR - dS
else:
waterbalance = Precip - ActETact - self.BaseR - self.RainR - self.SnowR - dS - self.SeePage
self.reporting.reporting(self, pcr, 'wbal', waterbalance)
#-total water balance
self.waterbalanceTot = self.waterbalanceTot + waterbalance
#-report water balance and accumulated water balance
if self.wbal_TSS_FLAG and (self.RoutFLAG == 1 or self.ResFLAG == 1
or self.LakeFLAG == 1):
self.wbalTSS.sample(
pcr.catchmenttotal(waterbalance, self.FlowDir) /
pcr.catchmenttotal(1., self.FlowDir))
self.wbalTotTSS.sample(
pcr.catchmenttotal(self.waterbalanceTot, self.FlowDir) /
pcr.catchmenttotal(1., self.FlowDir))
# set old state variables
self.oldRootWater = self.RootWater
self.oldSubWater = self.SubWater
waterbalance = None
del waterbalance
dS = None
del dS
#-End of water balance calculations
#-Sediment yield
if self.SedFLAG == 1:
#-determine runoff in mm per day
if self.RoutFLAG == 1 or self.ResFLAG == 1 or self.LakeFLAG == 1:
Runoff = (Q * 3600 * 24) / pcr.cellarea() * 1000
else:
Runoff = TotR
#-MUSLE
if self.SedModel == 1:
#-read dynamic processes musle
self.musle.dynamic(self, pcr, Runoff)
#-sediment transport
if self.SedTransFLAG == 1:
#-read dynamic sediment transport processes musle
self.sediment_transport.dynamic_musle(self, pcr)
#-Modified Morgan-Morgan-Finney model
if self.SedModel == 2:
#-determine soil erosion in transport (G)
G = self.mmf.dynamic(self, pcr, Precip, Runoff)
#-sediment transport
if self.SedTransFLAG == 1:
#-read dynamic sediment transport processes mmf
self.sediment_transport.dynamic_mmf(
self, pcr, Runoff, np, G)
#-update current date
self.curdate = self.curdate + self.datetime.timedelta(days=1)
def __init__(self):
# Print model info
print('The Spatial Processes in HYdrology (SPHY) model is')
print(
'developed and owned by FutureWater, Wageningen, The Netherlands')
print('Version 3.0, released June 2019')
print(' ')
#-Missing value definition
self.MV = -9999
# Read the modules to be used
self.GlacFLAG = config.getint('MODULES', 'GlacFLAG')
self.SnowFLAG = config.getint('MODULES', 'SnowFLAG')
self.RoutFLAG = config.getint('MODULES', 'RoutFLAG')
self.ResFLAG = config.getint('MODULES', 'ResFLAG')
self.LakeFLAG = config.getint('MODULES', 'LakeFLAG')
self.DynVegFLAG = config.getint('MODULES', 'DynVegFLAG')
self.GroundFLAG = config.getint('MODULES', 'GroundFLAG')
self.SedFLAG = config.getint('MODULES', 'SedFLAG')
self.SedTransFLAG = config.getint('MODULES', 'SedTransFLAG')
# import the required modules
import datetime, calendar, ET, rootzone, subzone
import utilities.reporting as reporting
import utilities.timecalc as timecalc
import utilities.netcdf2PCraster as netcdf2PCraster
from math import pi
#-standard python modules
self.datetime = datetime
self.calendar = calendar
self.pi = pi
#-FW defined modules
self.reporting = reporting
self.timecalc = timecalc
self.netcdf2PCraster = netcdf2PCraster
self.ET = ET
self.rootzone = rootzone
self.subzone = subzone
del datetime, calendar, pi, reporting, timecalc, ET, rootzone, subzone
#-import additional modules if required
if self.GlacFLAG == 1:
self.SnowFLAG = 1
self.GroundFLAG = 1
#-read the input and output directories from the configuration file
self.inpath = config.get('DIRS', 'inputdir')
self.outpath = config.get('DIRS', 'outputdir')
#-set the timing criteria
sy = config.getint('TIMING', 'startyear')
sm = config.getint('TIMING', 'startmonth')
sd = config.getint('TIMING', 'startday')
ey = config.getint('TIMING', 'endyear')
em = config.getint('TIMING', 'endmonth')
ed = config.getint('TIMING', 'endday')
self.startdate = self.datetime.datetime(sy, sm, sd)
self.enddate = self.datetime.datetime(ey, em, ed)
self.dateAfterUpdate = self.startdate - self.datetime.timedelta(
days=1
) #-only required for glacier retreat (create dummy value here to introduce the variable)
#-set date input for reporting
self.startYear = sy
self.endYear = ey
self.spinUpYears = config.getint('TIMING', 'spinupyears')
self.simYears = self.endYear - self.startYear - self.spinUpYears + 1
#-set the 2000 julian date number
self.julian_date_2000 = 2451545
#-read name of reporting table
self.RepTab = config.get('REPORTING', 'RepTab')
#-set the option to calculate the fluxes in mm for the upstream area
self.mm_rep_FLAG = config.getint('REPORTING', 'mm_rep_FLAG')
#-set the option to calculate the fluxes per component in mm for the upstream area
pars = [
'Prec', 'ETa', 'GMelt', 'QSNOW', 'QROOTR', 'QROOTD', 'QRAIN',
'QGLAC', 'QBASE', 'QTOT', 'Seep'
]
for i in pars:
var = i + '_mm_FLAG'
setattr(self, var, config.getint('REPORTING', var))
#-set the option to calculate the timeseries of the water balance
self.wbal_TSS_FLAG = config.getint('REPORTING', 'wbal_TSS_FLAG')
#-setting clone map
self.clonefile = self.inpath + config.get('GENERAL', 'mask')
pcr.setclone(self.clonefile)
self.clone = pcr.ifthen(pcr.readmap(self.clonefile), pcr.boolean(1))
self.cellArea = pcr.cellvalue(pcr.cellarea(), 1)[0]
#-read general maps
self.DEM = pcr.readmap(self.inpath + config.get('GENERAL', 'dem'))
self.Slope = pcr.readmap(self.inpath + config.get('GENERAL', 'Slope'))
self.Locations = pcr.readmap(self.inpath +
config.get('GENERAL', 'locations'))
#-read soil calibration fractions
self.RootFieldFrac = config.getfloat('SOIL_CAL', 'RootFieldFrac')
self.RootSatFrac = config.getfloat('SOIL_CAL', 'RootSatFrac')
self.RootDryFrac = config.getfloat('SOIL_CAL', 'RootDryFrac')
self.RootWiltFrac = config.getfloat('SOIL_CAL', 'RootWiltFrac')
self.RootKsatFrac = config.getfloat('SOIL_CAL', 'RootKsatFrac')
#-read soil maps
#-check for PedotransferFLAG
self.PedotransferFLAG = config.getint('PEDOTRANSFER',
'PedotransferFLAG')
#-if pedotransfer functions are used read the sand, clay, organic matter and bulk density maps, otherwise read the soil hydraulic properties
if self.PedotransferFLAG == 1:
import utilities.pedotransfer
self.pedotransfer = utilities.pedotransfer
del utilities.pedotransfer
#-read init processes pedotransfer
self.pedotransfer.init(self, pcr, config, np)
else:
#self.Soil = pcr.readmap(self.inpath + config.get('SOIL','Soil'))
self.RootFieldMap = pcr.readmap(self.inpath + config.get(
'SOIL', 'RootFieldMap')) * self.RootFieldFrac
self.RootSatMap = pcr.readmap(self.inpath + config.get(
'SOIL', 'RootSatMap')) * self.RootSatFrac
self.RootDryMap = pcr.readmap(self.inpath + config.get(
'SOIL', 'RootDryMap')) * self.RootDryFrac
self.RootWiltMap = pcr.readmap(self.inpath + config.get(
'SOIL', 'RootWiltMap')) * self.RootWiltFrac
self.RootKsat = pcr.readmap(self.inpath + config.get(
'SOIL', 'RootKsat')) * self.RootKsatFrac
self.SubSatMap = pcr.readmap(self.inpath +
config.get('SOIL', 'SubSatMap'))
self.SubFieldMap = pcr.readmap(self.inpath +
config.get('SOIL', 'SubFieldMap'))
self.SubKsat = pcr.readmap(self.inpath +
config.get('SOIL', 'SubKsat'))
self.RootDrainVel = self.RootKsat * self.Slope
#-Read and set the soil parameters
pars = ['CapRiseMax', 'RootDepthFlat', 'SubDepthFlat']
for i in pars:
try:
setattr(self, i,
pcr.readmap(self.inpath + config.get('SOILPARS', i)))
except:
setattr(self, i, config.getfloat('SOILPARS', i))
# groundwater storage as third storage layer. This is used instead of a fixed bottomflux
if self.GroundFLAG == 1:
import modules.groundwater
self.groundwater = modules.groundwater
del modules.groundwater
#-read init processes groundwater
self.groundwater.init(self, pcr, config)
else:
# if groundwater module is not used, read seepage and gwl_base
self.SeepStatFLAG = config.getint('SOILPARS', 'SeepStatic')
if self.SeepStatFLAG == 0: # set the seepage map series
self.Seepmaps = self.inpath + config.get('SOILPARS', 'SeePage')
else: #-set a static map or value for seepage
try:
self.SeePage = pcr.readmap(
self.inpath + config.get('SOILPARS', 'SeePage'))
except:
self.SeePage = config.getfloat('SOILPARS', 'SeePage')
try:
self.GWL_base = pcr.readmap(self.inpath +
config.get('SOILPARS', 'GWL_base'))
except:
self.GWL_base = config.getfloat('SOILPARS', 'GWL_base')
self.SubDrainVel = self.SubKsat * self.Slope
#-calculate soil properties
self.RootField = self.RootFieldMap * self.RootDepthFlat
self.RootSat = self.RootSatMap * self.RootDepthFlat
self.RootDry = self.RootDryMap * self.RootDepthFlat
self.RootWilt = self.RootWiltMap * self.RootDepthFlat
self.SubSat = self.SubSatMap * self.SubDepthFlat
self.SubField = self.SubFieldMap * self.SubDepthFlat
self.RootTT = pcr.max((self.RootSat - self.RootField) / self.RootKsat,
0.0001)
self.SubTT = pcr.max((self.SubSat - self.SubField) / self.SubKsat,
0.0001)
# soil max and soil min for scaling of gwl if groundwater module is not used
if self.GroundFLAG == 0:
self.SoilMax = self.RootSat + self.SubSat
self.SoilMin = self.RootDry + self.SubField
#-read land use map
self.LandUse = pcr.readmap(self.inpath +
config.get('LANDUSE', 'LandUse'))
#-Use the dynamic vegetation module
if self.DynVegFLAG == 1:
#-import dynamic vegetation module
import modules.dynamic_veg
self.dynamic_veg = modules.dynamic_veg
del modules.dynamic_veg
#-read init processes dynamic vegetation
self.dynamic_veg.init(self, pcr, config)
#-read the crop coefficient table if the dynamic vegetation module is not used
else:
self.KcStatFLAG = config.getint('LANDUSE', 'KCstatic')
if self.KcStatFLAG == 1:
#-read land use map and kc table
self.kc_table = self.inpath + config.get('LANDUSE', 'CropFac')
self.Kc = pcr.lookupscalar(self.kc_table, self.LandUse)
else:
#-set the kc map series
self.Kcmaps = self.inpath + config.get('LANDUSE', 'KC')
#-read the p factor table if the plant water stress module is used
self.PlantWaterStressFLAG = config.getint('PWS', 'PWS_FLAG')
if self.PlantWaterStressFLAG == 1:
PFactor = self.inpath + config.get('PWS', 'PFactor')
self.PMap = pcr.lookupscalar(PFactor, self.LandUse)
#-read and set glacier maps and parameters if glacier module is used
if self.GlacFLAG:
#-import glacier module
import modules.glacier
self.glacier = modules.glacier
del modules.glacier
#-read init processes glacier module
self.glacier.init(self, pcr, config, pd, np, os)
#-read and set snow maps and parameters if snow modules are used
if self.SnowFLAG == 1:
#-import snow module
import modules.snow
self.snow = modules.snow
del modules.snow
#-read init processes glacier module
self.snow.init(self, pcr, config)
#-read and set climate forcing and the calculation of etref
#-read precipitation data
#-read flag for precipitation forcing by netcdf
self.precNetcdfFLAG = config.getint('CLIMATE', 'precNetcdfFLAG')
if self.precNetcdfFLAG == 1:
#-read configuration for forcing by netcdf
self.netcdf2PCraster.getConfigNetcdf(self, config, 'Prec',
'CLIMATE')
#-determine x,y-coordinates of netcdf file and model domain and indices of netcdf corresponding to model domain
self.netcdf2PCraster.netcdf2pcrInit(self, pcr, 'Prec')
else:
#-read precipitation forcing folder
self.Prec = self.inpath + config.get('CLIMATE', 'Prec')
#-read precipitation data
#-read flag for temperature forcing by netcdf
self.tempNetcdfFLAG = config.getint('CLIMATE', 'tempNetcdfFLAG')
if self.tempNetcdfFLAG == 1:
#-read configuration for forcing by netcdf
self.netcdf2PCraster.getConfigNetcdf(self, config, 'Temp',
'CLIMATE')
#-determine x,y-coordinates of netcdf file and model domain and indices of netcdf corresponding to model domain
self.netcdf2PCraster.netcdf2pcrInit(self, pcr, 'Temp')
else:
#-read temperature forcing folder
self.Tair = self.inpath + config.get('CLIMATE', 'Tair')
#-read flag for etref time series input
self.ETREF_FLAG = config.getint('ETREF', 'ETREF_FLAG')
#-determine the use of a given etref time-series or calculate etref using Hargreaves
if self.ETREF_FLAG == 1:
self.ETref = self.inpath + config.get('ETREF', 'ETref')
else:
self.Lat = pcr.readmap(self.inpath + config.get('ETREF', 'Lat'))
#-read flag for minimum temperature forcing by netcdf
self.TminNetcdfFLAG = config.getint('ETREF', 'TminNetcdfFLAG')
if self.TminNetcdfFLAG == 1:
#-read configuration for forcing by netcdf
self.netcdf2PCraster.getConfigNetcdf(self, config, 'Tmin',
'ETREF')
#-determine x,y-coordinates of netcdf file and model domain and indices of netcdf corresponding to model domain
self.netcdf2PCraster.netcdf2pcrInit(self, pcr, 'Tmin')
else:
self.Tmin = self.inpath + config.get('ETREF', 'Tmin')
#-read flag for maximum temperature forcing by netcdf
self.TmaxNetcdfFLAG = config.getint('ETREF', 'TmaxNetcdfFLAG')
if self.TmaxNetcdfFLAG == 1:
#-read configuration for forcing by netcdf
self.netcdf2PCraster.getConfigNetcdf(self, config, 'Tmax',
'ETREF')
#-determine x,y-coordinates of netcdf file and model domain and indices of netcdf corresponding to model domain
self.netcdf2PCraster.netcdf2pcrInit(self, pcr, 'Tmax')
else:
self.Tmax = self.inpath + config.get('ETREF', 'Tmax')
self.Gsc = config.getfloat('ETREF', 'Gsc')
import hargreaves
self.Hargreaves = hargreaves
del hargreaves
#-read and set routing maps and parameters
if self.RoutFLAG == 1:
import modules.routing
self.routing = modules.routing
del modules.routing
#-read init processes routing
self.routing.init(self, pcr, config)
#-read and set routing maps and parameters
if self.ResFLAG == 1 or self.LakeFLAG == 1:
#-import advanced routing module
import modules.advanced_routing
self.advanced_routing = modules.advanced_routing
del modules.advanced_routing
#-read init processes advanced routing
self.advanced_routing.init(self, pcr, config)
#-read lake maps and parameters if lake module is used
if self.LakeFLAG == 1:
#-import lakes module
import modules.lakes
self.lakes = modules.lakes
del modules.lakes
#-read init processes lakes
self.lakes.init(self, pcr, config)
#-read reservior maps and parameters if reservoir module is used
if self.ResFLAG == 1:
#-import reservoirs module
import modules.reservoirs
self.reservoirs = modules.reservoirs
del modules.reservoirs
#-read init processes reservoirs
self.reservoirs.init(self, pcr, config)
#-read flag for calculation of ET in reservoirs
self.ETOpenWaterFLAG = config.getint('OPENWATER', 'ETOpenWaterFLAG')
if self.ETOpenWaterFLAG == 1:
#-read kc value for open water
self.kcOpenWater = config.getfloat('OPENWATER', 'kcOpenWater')
#-read openwater fraction map
self.openWaterFrac = pcr.readmap(
self.inpath + config.get('OPENWATER', 'openWaterFrac'))
#-determine openwater map with values of each reservoir/lake in the extent of the openwater
self.openWater = pcr.ifthenelse(self.openWaterFrac > 0,
pcr.scalar(1), pcr.scalar(0))
self.openWaterNominal = pcr.clump(pcr.nominal(self.openWater))
self.openWaterNominal = pcr.nominal(
pcr.areamaximum(pcr.scalar(self.ResID), self.openWaterNominal))
else:
#-set all cells to 0 for openwater fraction map
self.openWaterFrac = self.DEM * 0
self.openWater = 0
self.ETOpenWater = 0
#-read maps and parameters for infiltration excess
self.InfilFLAG = config.getfloat('INFILTRATION', 'Infil_excess')
if self.InfilFLAG == 1:
self.K_eff = config.getfloat('INFILTRATION', 'K_eff')
try:
self.Alpha = config.getfloat('INFILTRATION', 'Alpha')
except:
self.Alpha = pcr.readmap(self.inpath +
config.get('INFILTRATION', 'Alpha'))
try:
self.Labda_Infil = config.getfloat('INFILTRATION',
'Labda_infil')
except:
self.Labda_Infil = pcr.readmap(
self.inpath + config.get('INFILTRATION', 'Labda_infil'))
try:
self.paved_table = self.inpath + config.get(
'INFILTRATION', 'PavedFrac')
self.pavedFrac = pcr.lookupscalar(self.paved_table,
self.LandUse)
except:
self.pavedFrac = 0
#-read maps and parameters for soil erosion
if self.SedFLAG == 1:
#-read soil erosion model selector (1 for MUSLE, 2 for MMF)
self.SedModel = config.getfloat('SEDIMENT', 'SedModel')
#-read rock fraction map
self.RockFrac = pcr.readmap(self.inpath +
config.get('SEDIMENT', 'RockFrac'))
#-read MUSLE input parameters
if self.SedModel == 1:
#-import musle module
import modules.musle
self.musle = modules.musle
del modules.musle
#-read init processes musle
self.musle.init(self, pcr, config)
#-read MMF input parameters
if self.SedModel == 2:
#-import mmf module
import modules.mmf
self.mmf = modules.mmf
del modules.mmf
#-read init processes mmf
self.mmf.init(self, pcr, config)
#-read input parameters for sediment transport
if self.SedTransFLAG == 1:
#-import sediment transport module
import modules.sediment_transport
self.sediment_transport = modules.sediment_transport
del modules.sediment_transport
#-read init processes sediment transport
self.sediment_transport.init(self, pcr, config, csv, np)
#-set the global option for radians
pcr.setglobaloption('radians')