def checkmap(name, value, map, flagmap, find):
""" check maps if they fit to the mask map
"""
s = [name, value]
MMaskMap = 0
if flagmap:
amap = scalar(defined(MMaskMap))
try:
smap = scalar(defined(map))
except:
msg = "Map: " + name + " in " + value + " does not fit"
if name == "LZAvInflowMap":
msg += "\nTry to execute the initial run first"
raise LisfloodError(msg)
mvmap = maptotal(smap)
mv = pcraster.cellvalue(mvmap, 1, 1)[0]
s.append(mv)
less = maptotal(ifthenelse(defined(MMaskMap), amap - smap, scalar(0)))
s.append(pcraster.cellvalue(less, 1, 1)[0])
less = mapminimum(scalar(map))
s.append(pcraster.cellvalue(less, 1, 1)[0])
less = maptotal(scalar(map))
s.append(pcraster.cellvalue(less, 1, 1)[0] / mv) if mv > 0 else s.append('0')
less = mapmaximum(scalar(map))
s.append(pcraster.cellvalue(less, 1, 1)[0])
if find > 0:
if find == 2:
s.append('last_Map_used')
else:
s.append('')
else:
s.append(0)
s.append(0)
s.append(float(map))
s.append(float(map))
s.append(float(map))
if checkmap.called == 1: # FIXME omg
print ("%-25s%-40s%11s%11s%11s%11s%11s" % ("Name", "File/Value", "nonMV", "MV", "min", "mean", "max"))
print ("%-25s%-40s%11i%11i%11.2f%11.2f%11.2f" % (s[0], s[1][-39:], s[2], s[3], s[4], s[5], s[6]))
return
def initial(self):
""" initial part of the reservoir module
"""
# ************************************************************
# ***** RESERVOIRS
# ************************************************************
settings = LisSettings.instance()
option = settings.options
maskinfo = MaskInfo.instance()
if option['simulateReservoirs']:
# NoSubStepsRes=max(1,roundup(self.var.DtSec/loadmap('DtSecReservoirs')))
# Number of sub-steps based on value of DtSecReservoirs,
# or 1 if DtSec is smaller than DtSecReservoirs
# DtSubRes=self.var.DtSec/loadmap('NoSubStepsRes')
# Corresponding sub-timestep (seconds)
settings = LisSettings.instance()
binding = settings.binding
self.var.ReservoirSitesC = loadmap('ReservoirSites')
self.var.ReservoirSitesC[self.var.ReservoirSitesC < 1] = 0
self.var.ReservoirSitesC[self.var.IsChannel == 0] = 0
# Get rid of any reservoirs that are not part of the channel network
# mask reserovoirs sites when using sub-catchments mask
# ReservoirSitesC_masked = ifthen(self.var.MaskMap,self.var.ReservoirSitesC)
self.var.ReservoirSitesCC = np.compress(self.var.ReservoirSitesC > 0, self.var.ReservoirSitesC)
self.var.ReservoirIndex = np.nonzero(self.var.ReservoirSitesC)[0]
if self.var.ReservoirSitesC.size == 0:
print(LisfloodWarning('There are no lakes. Reservoirs simulation stops here'))
option['simulateReservoirs'] = False
option['repsimulateReservoirs'] = False
return
# break if no reservoirs
self.var.IsStructureKinematic = np.where(self.var.ReservoirSitesC > 0, np.bool8(1), self.var.IsStructureKinematic)
# Add reservoir locations to structures map (used to modify LddKinematic
# and to calculate LddStructuresKinematic)
ReservoirSitePcr = loadmap('ReservoirSites', pcr=True)
self.var.ReservoirSites = ReservoirSitePcr
ReservoirSitePcr = ifthen((defined(ReservoirSitePcr) & boolean(decompress(self.var.IsChannel))), ReservoirSitePcr)
# Get rid of any reservoirs that are not part of the channel network
# (following logic of 'old' code the inflow into these reservoirs is
# always zero, so either change this or leave them out!)
TotalReservoirStorageM3 = lookupscalar(str(binding['TabTotStorage']), ReservoirSitePcr)
self.var.TotalReservoirStorageM3C = compressArray(TotalReservoirStorageM3)
self.var.TotalReservoirStorageM3C = np.where(np.isnan(self.var.TotalReservoirStorageM3C), 0, self.var.TotalReservoirStorageM3C)
self.var.TotalReservoirStorageM3CC = np.compress(self.var.ReservoirSitesC > 0, self.var.TotalReservoirStorageM3C)
# Total storage of each reservoir [m3]
ConservativeStorageLimit = lookupscalar(str(binding['TabConservativeStorageLimit']), ReservoirSitePcr)
ConservativeStorageLimitC = compressArray(ConservativeStorageLimit)
self.var.ConservativeStorageLimitCC = np.compress(self.var.ReservoirSitesC > 0, ConservativeStorageLimitC)
# Conservative storage limit (fraction of total storage, [-])
NormalStorageLimit = lookupscalar(str(binding['TabNormalStorageLimit']), ReservoirSitePcr)
NormalStorageLimitC = compressArray(NormalStorageLimit)
self.var.NormalStorageLimitCC = np.compress(self.var.ReservoirSitesC > 0, NormalStorageLimitC)
# Normal storage limit (fraction of total storage, [-])
FloodStorageLimit = lookupscalar(str(binding['TabFloodStorageLimit']), ReservoirSitePcr)
FloodStorageLimitC = compressArray(FloodStorageLimit)
self.var.FloodStorageLimitCC = np.compress(self.var.ReservoirSitesC > 0, FloodStorageLimitC)
# Flood storage limit (fraction of total storage, [-])
NonDamagingReservoirOutflow = lookupscalar(str(binding['TabNonDamagingOutflowQ']), ReservoirSitePcr)
NonDamagingReservoirOutflowC = compressArray(NonDamagingReservoirOutflow)
self.var.NonDamagingReservoirOutflowCC = np.compress(self.var.ReservoirSitesC > 0, NonDamagingReservoirOutflowC)
# Non-damaging reservoir outflow [m3/s]
NormalReservoirOutflow = lookupscalar(str(binding['TabNormalOutflowQ']), ReservoirSitePcr)
NormalReservoirOutflowC = compressArray(NormalReservoirOutflow)
self.var.NormalReservoirOutflowCC = np.compress(self.var.ReservoirSitesC > 0, NormalReservoirOutflowC)
# Normal reservoir outflow [m3/s]
MinReservoirOutflow = lookupscalar(str(binding['TabMinOutflowQ']), ReservoirSitePcr)
MinReservoirOutflowC = compressArray(MinReservoirOutflow)
self.var.MinReservoirOutflowCC = np.compress(self.var.ReservoirSitesC > 0, MinReservoirOutflowC)
# minimum reservoir outflow [m3/s]
# Calibration
adjust_Normal_Flood = loadmap('adjust_Normal_Flood')
adjust_Normal_FloodC = makenumpy(adjust_Normal_Flood)
adjust_Normal_FloodCC = np.compress(self.var.ReservoirSitesC > 0, adjust_Normal_FloodC)
# adjusting the balance between normal and flood storage
# big value (= closer to flood) results in keeping the normal qoutflow longer constant
self.var.Normal_FloodStorageLimitCC = self.var.NormalStorageLimitCC + adjust_Normal_FloodCC * (self.var.FloodStorageLimitCC - self.var.NormalStorageLimitCC)
ReservoirRnormqMult = loadmap('ReservoirRnormqMult')
ReservoirRnormqMultC = makenumpy(ReservoirRnormqMult)
ReservoirRnormqMultCC = np.compress(self.var.ReservoirSitesC > 0, ReservoirRnormqMultC)
self.var.NormalReservoirOutflowCC = self.var.NormalReservoirOutflowCC * ReservoirRnormqMultCC
# calibration: all reservoirs normal outflow are multiplied with a factor
self.var.NormalReservoirOutflowCC = np.where(self.var.NormalReservoirOutflowCC > self.var.MinReservoirOutflowCC, self.var.NormalReservoirOutflowCC, self.var.MinReservoirOutflowCC+0.01)
self.var.NormalReservoirOutflowCC = np.where(self.var.NormalReservoirOutflowCC < self.var.NonDamagingReservoirOutflowCC, self.var.NormalReservoirOutflowCC, self.var.NonDamagingReservoirOutflowCC-0.01)
# Repeatedly used expressions in reservoirs routine
self.var.DeltaO = self.var.NormalReservoirOutflowCC - self.var.MinReservoirOutflowCC
self.var.DeltaLN = self.var.NormalStorageLimitCC - 2 * self.var.ConservativeStorageLimitCC
self.var.DeltaLF = self.var.FloodStorageLimitCC - self.var.NormalStorageLimitCC
self.var.DeltaNFL = self.var.FloodStorageLimitCC - self.var.Normal_FloodStorageLimitCC
ReservoirInitialFillValue = loadmap('ReservoirInitialFillValue')
if np.max(ReservoirInitialFillValue) == -9999:
ReservoirInitialFill = self.var.NormalStorageLimitCC,
else:
ReservoirInitialFill = np.compress(self.var.ReservoirSitesC > 0, ReservoirInitialFillValue)
self.var.ReservoirFillCC = ReservoirInitialFill
# Initial reservoir fill (fraction of total storage, [-])
# -9999: assume reservoirs are filled to normal storage limit
ReservoirStorageIniM3CC = ReservoirInitialFill * self.var.TotalReservoirStorageM3CC
# Initial reservoir storage [m3] from state or initvalue
self.var.ReservoirStorageM3CC = ReservoirStorageIniM3CC.copy()
# self.var.ReservoirFill = ReservoirInitialFill.copy()
# Initial fill of reservoirs (fraction of total storage, [-])
self.var.ReservoirStorageIniM3 = maskinfo.in_zero()
np.put(self.var.ReservoirStorageIniM3, self.var.ReservoirIndex, ReservoirStorageIniM3CC)
self.var.ReservoirStorageM3 = self.var.ReservoirStorageIniM3