def readTopo(self, iniItems):
# maps of elevation attributes:
topoParams = ['tanslope', 'slopeLength', 'orographyBeta']
if iniItems.landSurfaceOptions['topographyNC'] == str(None):
for var in topoParams:
input = iniItems.landSurfaceOptions[str(var)]
vars(self)[var] = pcr.scalar(0.0)
vars(self)[var] = vos.readPCRmapClone(input, self.cloneMap,
self.tmpDir,
self.inputDir)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
else:
topoPropertiesNC = vos.getFullPath(\
iniItems.landSurfaceOptions[\
'topographyNC'],
self.inputDir)
for var in topoParams:
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(\
topoPropertiesNC,var, \
cloneMapFileName = self.cloneMap)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
self.tanslope = pcr.max(self.tanslope, 0.00001)
# maps of relative elevation above flood plains
dzRel = [
'dzRel0001', 'dzRel0005', 'dzRel0010', 'dzRel0020', 'dzRel0030',
'dzRel0040', 'dzRel0050', 'dzRel0060', 'dzRel0070', 'dzRel0080',
'dzRel0090', 'dzRel0100'
]
if iniItems.landSurfaceOptions['topographyNC'] == str(None):
for i in range(0, len(dzRel)):
var = dzRel[i]
input = iniItems.landSurfaceOptions[str(var)]
vars(self)[var] = vos.readPCRmapClone(input, self.cloneMap,
self.tmpDir,
self.inputDir)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
if i > 0:
vars(self)[var] = pcr.max(
vars(self)[var],
vars(self)[dzRel[i - 1]])
else:
for i in range(0, len(dzRel)):
var = dzRel[i]
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(\
topoPropertiesNC,var, \
cloneMapFileName = self.cloneMap)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
if i > 0:
vars(self)[var] = pcr.max(
vars(self)[var],
vars(self)[dzRel[i - 1]])
def readTopo(self, iniItems, optionDict):
# a dictionary/section of options that will be used
if optionDict == None: optionDict = iniItems._sections["landSurfaceOptions"]
# maps of elevation attributes:
topoParams = ['tanslope','slopeLength','orographyBeta']
if optionDict['topographyNC'] == str(None):
for var in topoParams:
input = configget(iniItems,"landSurfaceOptions",str(var),"None")
vars(self)[var] = vos.readPCRmapClone(input,self.cloneMap,
self.tmpDir,self.inputDir)
if var != "slopeLength": vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
else:
topoPropertiesNC = vos.getFullPath(\
optionDict['topographyNC'],
self.inputDir)
for var in topoParams:
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(\
topoPropertiesNC,var, \
cloneMapFileName = self.cloneMap)
if var != "slopeLength": vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
#~ self.tanslope = pcr.max(self.tanslope, 0.00001) # In principle, tanslope can be zero. Zero tanslope will provide zero TCL (no interflow)
# covering slopeLength with its maximum value
self.slopeLength = pcr.cover(self.slopeLength, pcr.mapmaximum(self.slopeLength))
# maps of relative elevation above flood plains
dzRel = ['dzRel0001','dzRel0005',
'dzRel0010','dzRel0020','dzRel0030','dzRel0040','dzRel0050',
'dzRel0060','dzRel0070','dzRel0080','dzRel0090','dzRel0100']
if optionDict['topographyNC'] == str(None):
for i in range(0, len(dzRel)):
var = dzRel[i]
input = optionDict[str(var)]
vars(self)[var] = vos.readPCRmapClone(input,self.cloneMap,
self.tmpDir,self.inputDir)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
if i > 0: vars(self)[var] = pcr.max(vars(self)[var], vars(self)[dzRel[i-1]])
else:
for i in range(0, len(dzRel)):
var = dzRel[i]
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(\
topoPropertiesNC,var, \
cloneMapFileName = self.cloneMap)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
if i > 0: vars(self)[var] = pcr.max(vars(self)[var], vars(self)[dzRel[i-1]])
def __init__(self, configuration, currTimeStep):
self._configuration = configuration
self._modelTime = currTimeStep
pcr.setclone(configuration.cloneMap)
# read the ldd map
self.lddMap = vos.netcdf2PCRobjCloneWithoutTime(configuration.modflowParameterOptions['channelNC'],'lddMap',\
configuration.cloneMap)
# ensure ldd map is correct, and actually of type "ldd"
self.lddMap = pcr.lddrepair(pcr.ldd(self.lddMap))
# defining the landmask map
if configuration.globalOptions['landmask'] != "None":
self.landmask = vos.readPCRmapClone(\
configuration.globalOptions['landmask'],
configuration.cloneMap,configuration.tmpDir,configuration.globalOptions['inputDir'])
else:
self.landmask = pcr.defined(self.lddMap)
# preparing the sub-model(s) - Currently, there is only one sub-model.
self.createSubmodels()
def __init__(self, iniItems, landmask):
object.__init__(self)
# cloneMap, temporary directory, absolute path for input directory, landmask
self.cloneMap = iniItems.cloneMap
self.tmpDir = iniItems.tmpDir
self.inputDir = iniItems.globalOptions['inputDir']
self.landmask = landmask
# configuration from the ini file
self.iniItems = iniItems
# topography properties: read several variables from the netcdf file
for var in ['dem_minimum','dem_maximum','dem_average','dem_standard_deviation',\
'slopeLength','orographyBeta','tanslope',\
'dzRel0000','dzRel0001','dzRel0005',\
'dzRel0010','dzRel0020','dzRel0030','dzRel0040','dzRel0050',\
'dzRel0060','dzRel0070','dzRel0080','dzRel0090','dzRel0100']:
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['topographyNC'], \
var, self.cloneMap)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
# channel properties: read several variables from the netcdf file
for var in [
'lddMap', 'cellAreaMap', 'gradient', 'bankfull_width',
'bankfull_depth', 'dem_floodplain', 'dem_riverbed'
]:
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['channelNC'], \
var, self.cloneMap)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
# minimum channel width
minimum_channel_width = 0.1
self.bankfull_width = pcr.max(minimum_channel_width,
self.bankfull_width)
#~ # cell fraction if channel water reaching the flood plan # NOT USED
#~ self.flood_plain_fraction = self.return_innundation_fraction(pcr.max(0.0, self.dem_floodplain - self.dem_minimum))
# coefficient of Manning
self.manningsN = vos.readPCRmapClone(self.iniItems.modflowParameterOptions['manningsN'],\
self.cloneMap,self.tmpDir,self.inputDir)
# minimum channel gradient
minGradient = 0.00005
self.gradient = pcr.max(minGradient,
pcr.cover(self.gradient, minGradient))
# correcting lddMap
self.lddMap = pcr.ifthen(pcr.scalar(self.lddMap) > 0.0, self.lddMap)
self.lddMap = pcr.lddrepair(pcr.ldd(self.lddMap))
# channelLength = approximation of channel length (unit: m) # This is approximated by cell diagonal.
cellSizeInArcMin = np.round(pcr.clone().cellSize() * 60.)
verticalSizeInMeter = cellSizeInArcMin * 1852.
self.channelLength = ((self.cellAreaMap/verticalSizeInMeter)**(2)+\
(verticalSizeInMeter)**(2))**(0.5)
# option for lakes and reservoir
self.onlyNaturalWaterBodies = False
if self.iniItems.modflowParameterOptions[
'onlyNaturalWaterBodies'] == "True":
self.onlyNaturalWaterBodies = True
# groundwater linear recession coefficient (day-1) ; the linear reservoir concept is still being used to represent fast response flow
# particularly from karstic aquifer in mountainous regions
self.recessionCoeff = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['groundwaterPropertiesNC'],\
'recessionCoeff', self.cloneMap)
self.recessionCoeff = pcr.cover(self.recessionCoeff, 0.00)
self.recessionCoeff = pcr.min(1.0000, self.recessionCoeff)
#
if 'minRecessionCoeff' in iniItems.modflowParameterOptions.keys():
minRecessionCoeff = float(
iniItems.modflowParameterOptions['minRecessionCoeff'])
else:
minRecessionCoeff = 1.0e-4 # This is the minimum value used in Van Beek et al. (2011).
self.recessionCoeff = pcr.max(minRecessionCoeff, self.recessionCoeff)
# aquifer saturated conductivity (m/day)
self.kSatAquifer = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['groundwaterPropertiesNC'],\
'kSatAquifer', self.cloneMap)
self.kSatAquifer = pcr.cover(self.kSatAquifer,
pcr.mapmaximum(self.kSatAquifer))
self.kSatAquifer = pcr.max(0.010, self.kSatAquifer)
self.kSatAquifer *= 0.001
# aquifer specific yield (dimensionless)
self.specificYield = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['groundwaterPropertiesNC'],\
'specificYield', self.cloneMap)
self.specificYield = pcr.cover(self.specificYield,
pcr.mapmaximum(self.specificYield))
self.specificYield = pcr.max(
0.010, self.specificYield
) # TODO: TO BE CHECKED: The resample process of specificYield
self.specificYield = pcr.min(1.000, self.specificYield)
# estimate of thickness (unit: m) of accesible groundwater
totalGroundwaterThickness = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['estimateOfTotalGroundwaterThicknessNC'],\
'thickness', self.cloneMap)
# extrapolation
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,\
pcr.windowaverage(totalGroundwaterThickness, 1.0))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,\
pcr.windowaverage(totalGroundwaterThickness, 1.5))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness, 0.0)
#
# set minimum thickness
minimumThickness = pcr.scalar(float(\
self.iniItems.modflowParameterOptions['minimumTotalGroundwaterThickness']))
totalGroundwaterThickness = pcr.max(minimumThickness,
totalGroundwaterThickness)
#
# set maximum thickness: 250 m.
maximumThickness = 250.
self.totalGroundwaterThickness = pcr.min(maximumThickness,
totalGroundwaterThickness)
# river bed resistance (unit: day)
self.bed_resistance = 1.0
# option to ignore capillary rise
self.ignoreCapRise = True
if self.iniItems.modflowParameterOptions['ignoreCapRise'] == "False":
self.ignoreCapRise = False
# initiate old style reporting # TODO: remove this!
self.initiate_old_style_groundwater_reporting(iniItems)
def __init__(self, iniItems,landmask,spinUp):
object.__init__(self)
self.cloneMap = iniItems.cloneMap
self.tmpDir = iniItems.tmpDir
self.inputDir = iniItems.globalOptions['inputDir']
self.landmask = landmask
# option to activate water balance check
self.debugWaterBalance = True
if iniItems.routingOptions['debugWaterBalance'] == "False":
self.debugWaterBalance = False
if iniItems.groundwaterOptions['groundwaterPropertiesNC'] == str(None):
# assign the recession coefficient parameter(s)
self.recessionCoeff = vos.readPCRmapClone(\
iniItems.groundwaterOptions['recessionCoeff'],
self.cloneMap,self.tmpDir,self.inputDir)
else:
groundwaterPropertiesNC = vos.getFullPath(\
iniItems.groundwaterOptions[\
'groundwaterPropertiesNC'],
self.inputDir)
self.recessionCoeff = vos.netcdf2PCRobjCloneWithoutTime(\
groundwaterPropertiesNC,'recessionCoeff',\
cloneMapFileName = self.cloneMap)
# groundwater recession coefficient (day-1_
self.recessionCoeff = pcr.cover(self.recessionCoeff,0.00)
self.recessionCoeff = pcr.min(1.0000,self.recessionCoeff)
#
if 'minRecessionCoeff' in iniItems.groundwaterOptions.keys():
minRecessionCoeff = float(iniItems.groundwaterOptions['minRecessionCoeff'])
else:
minRecessionCoeff = 1.0e-4 # This is the minimum value used in Van Beek et al. (2011).
self.recessionCoeff = pcr.max(minRecessionCoeff,self.recessionCoeff)
if iniItems.groundwaterOptions['groundwaterPropertiesNC'] == str(None):
# assign aquifer specific yield
self.specificYield = vos.readPCRmapClone(\
iniItems.groundwaterOptions['specificYield'],
self.cloneMap,self.tmpDir,self.inputDir)
else:
self.specificYield = vos.netcdf2PCRobjCloneWithoutTime(\
groundwaterPropertiesNC,'specificYield',\
cloneMapFileName = self.cloneMap)
self.specificYield = pcr.cover(self.specificYield,0.0)
self.specificYield = pcr.max(0.010,self.specificYield) # TODO: TO BE CHECKED: The resample process of specificYield
self.specificYield = pcr.min(1.000,self.specificYield)
if iniItems.groundwaterOptions['groundwaterPropertiesNC'] == str(None):
# assign aquifer saturated conductivity
self.kSatAquifer = vos.readPCRmapClone(\
iniItems.groundwaterOptions['kSatAquifer'],
self.cloneMap,self.tmpDir,self.inputDir)
else:
self.kSatAquifer = vos.netcdf2PCRobjCloneWithoutTime(\
groundwaterPropertiesNC,'kSatAquifer',\
cloneMapFileName = self.cloneMap)
self.kSatAquifer = pcr.cover(self.kSatAquifer,0.0)
self.kSatAquifer = pcr.max(0.010,self.kSatAquifer)
# limitAbstraction options
self.limitAbstraction = False
if iniItems.landSurfaceOptions['limitAbstraction'] == "True": self.limitAbstraction = True
# option for limitting fossil groundwater abstractions - This option is only defined for IWMI project
self.limitFossilGroundwaterAbstraction = False
if self.limitAbstraction == False and\
"extraOptionsforProjectWithIWMI" in iniItems.allSections and\
iniItems.extraOptionsforProjectWithIWMI['limitFossilGroundWaterAbstraction'] == "True":
logger.info('Fossil groundwater abstraction limit is used (IWMI project).')
self.limitFossilGroundwaterAbstraction = True
# estimate of thickness (unit: mm) of aceesible groundwater: shallow and deep
totalGroundwaterThickness = vos.readPCRmapClone(\
iniItems.extraOptionsforProjectWithIWMI['estimateOfTotalGroundwaterThickness'],
self.cloneMap,self.tmpDir,self.inputDir)
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 1.0))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 1.5))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 2.5))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 5.0))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 7.5))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.mapmaximum(totalGroundwaterThickness))
# set minimum thickness to 50 m:
totalGroundwaterThickness = pcr.max(50.0, totalGroundwaterThickness)
# estimate of capacity (unit: m) of renewable groundwater (shallow)
storGroundwaterCap = pcr.cover(
vos.readPCRmapClone(\
iniItems.extraOptionsforProjectWithIWMI['estimateOfRenewableGroundwaterCapacity'],
self.cloneMap,self.tmpDir,self.inputDir),\
0.0)
# fossil groundwater capacity (unit: m)
self.fossilWaterCap = pcr.max(0.0,\
totalGroundwaterThickness*self.specificYield - storGroundwaterCap)
# option for limitting regional groundwater abstractions - This option is only defined
self.limitRegionalAnnualGroundwaterAbstraction = False
if "extraOptionsforProjectWithIWMI" in iniItems.allSections and\
iniItems.extraOptionsforProjectWithIWMI['limitRegionalAnnualGroundwaterAbstraction'] == "True":
logger.info('Limit for regional groundwater abstraction is used (IWMI project).')
self.limitRegionalAnnualGroundwaterAbstraction = True
region_ids = vos.readPCRmapClone(\
iniItems.extraOptionsforProjectWithIWMI['regionIds'],
self.cloneMap,self.tmpDir,self.inputDir)
self.region_ids = pcr.nominal(region_ids)
self.region_ids = pcr.ifthen(self.landmask, self.region_ids)
self.regionalAnnualGroundwaterAbstractionLimit = vos.readPCRmapClone(\
iniItems.extraOptionsforProjectWithIWMI['pumpingCapacity'],
self.cloneMap,self.tmpDir,self.inputDir)
self.regionalAnnualGroundwaterAbstractionLimit = pcr.roundup(self.regionalAnnualGroundwaterAbstractionLimit*1000.)/1000.
self.regionalAnnualGroundwaterAbstractionLimit = pcr.cover(self.regionalAnnualGroundwaterAbstractionLimit, 0.0)
self.regionalAnnualGroundwaterAbstractionLimit *= 1000. * 1000. * 1000. # unit: m3/year
self.regionalAnnualGroundwaterAbstractionLimit = pcr.ifthen(self.landmask,\
self.regionalAnnualGroundwaterAbstractionLimit)
# zones at which water allocation (surface and groundwater allocation) is determined
self.usingAllocSegments = False
if iniItems.landSurfaceOptions['allocationSegmentsForGroundSurfaceWater'] != "None": self.usingAllocSegments = True
# incorporating groundwater distribution network:
if self.usingAllocSegments and self.limitAbstraction == False:
self.allocSegments = vos.readPCRmapClone(\
iniItems.landSurfaceOptions['allocationSegmentsForGroundSurfaceWater'],
self.cloneMap,self.tmpDir,self.inputDir,isLddMap=False,cover=None,isNomMap=True)
self.allocSegments = pcr.ifthen(self.landmask, self.allocSegments)
cellArea = vos.readPCRmapClone(\
iniItems.routingOptions['cellAreaMap'],
self.cloneMap,self.tmpDir,self.inputDir)
cellArea = pcr.ifthen(self.landmask, cellArea) # TODO: integrate this one with the one coming from the routing module
self.segmentArea = pcr.areatotal(pcr.cover(cellArea, 0.0), self.allocSegments)
self.segmentArea = pcr.ifthen(self.landmask, self.segmentArea)
self.report = True
try:
self.outDailyTotNC = iniItems.groundwaterOptions['outDailyTotNC'].split(",")
self.outMonthTotNC = iniItems.groundwaterOptions['outMonthTotNC'].split(",")
self.outMonthAvgNC = iniItems.groundwaterOptions['outMonthAvgNC'].split(",")
self.outMonthEndNC = iniItems.groundwaterOptions['outMonthEndNC'].split(",")
self.outAnnuaTotNC = iniItems.groundwaterOptions['outAnnuaTotNC'].split(",")
self.outAnnuaAvgNC = iniItems.groundwaterOptions['outAnnuaAvgNC'].split(",")
self.outAnnuaEndNC = iniItems.groundwaterOptions['outAnnuaEndNC'].split(",")
except:
self.report = False
if self.report == True:
self.outNCDir = iniItems.outNCDir
self.netcdfObj = PCR2netCDF(iniItems)
#
# daily output in netCDF files:
if self.outDailyTotNC[0] != "None":
for var in self.outDailyTotNC:
# creating the netCDF files:
self.netcdfObj.createNetCDF(str(self.outNCDir)+"/"+ \
str(var)+"_dailyTot.nc",\
var,"undefined")
# MONTHly output in netCDF files:
# - cummulative
if self.outMonthTotNC[0] != "None":
for var in self.outMonthTotNC:
# initiating monthlyVarTot (accumulator variable):
vars(self)[var+'MonthTot'] = None
# creating the netCDF files:
self.netcdfObj.createNetCDF(str(self.outNCDir)+"/"+ \
str(var)+"_monthTot.nc",\
var,"undefined")
# - average
if self.outMonthAvgNC[0] != "None":
for var in self.outMonthAvgNC:
# initiating monthlyTotAvg (accumulator variable)
vars(self)[var+'MonthTot'] = None
# initiating monthlyVarAvg:
vars(self)[var+'MonthAvg'] = None
# creating the netCDF files:
self.netcdfObj.createNetCDF(str(self.outNCDir)+"/"+ \
str(var)+"_monthAvg.nc",\
var,"undefined")
# - last day of the month
if self.outMonthEndNC[0] != "None":
for var in self.outMonthEndNC:
# creating the netCDF files:
self.netcdfObj.createNetCDF(str(self.outNCDir)+"/"+ \
str(var)+"_monthEnd.nc",\
var,"undefined")
# YEARly output in netCDF files:
# - cummulative
if self.outAnnuaTotNC[0] != "None":
for var in self.outAnnuaTotNC:
# initiating yearly accumulator variable:
vars(self)[var+'AnnuaTot'] = None
# creating the netCDF files:
self.netcdfObj.createNetCDF(str(self.outNCDir)+"/"+ \
str(var)+"_annuaTot.nc",\
var,"undefined")
# - average
if self.outAnnuaAvgNC[0] != "None":
for var in self.outAnnuaAvgNC:
# initiating annualyVarAvg:
vars(self)[var+'AnnuaAvg'] = None
# initiating annualyTotAvg (accumulator variable)
vars(self)[var+'AnnuaTot'] = None
# creating the netCDF files:
self.netcdfObj.createNetCDF(str(self.outNCDir)+"/"+ \
str(var)+"_annuaAvg.nc",\
var,"undefined")
# - last day of the year
if self.outAnnuaEndNC[0] != "None":
for var in self.outAnnuaEndNC:
# creating the netCDF files:
self.netcdfObj.createNetCDF(str(self.outNCDir)+"/"+ \
str(var)+"_annuaEnd.nc",\
var,"undefined")
#get initial conditions
self.getICs(iniItems,spinUp)
def main():
# global map of subdomain masks
global_clone_map = "/scratch/mo/nest/ulysses/data/edwin/clone_maps/version_2020-08-04/clone_all_maps/clone_ulysses_06min_global.map"
# number of subdomain masks
num_of_masks = 54
# list of subdomain mask files for land (all in nc files)
subdomain_land_nc = "/scratch/mo/nest/ulysses/data/subdomain_masks/subdomain_land_%s.nc"
# lisk of subdomain maks files for touring (all in nc files)
subdomain_river_nc = "/scratch/mo/nest/ulysses/data/subdomain_river_masks/subdomain_river_%s.nc"
# output folder (and tmp folder)
out_folder = "/scratch/mo/nest/ulysses/data/edwin/clone_maps/version_2020-08-04/pcraster_maps/"
clean_out_folder = True
if os.path.exists(out_folder):
if clean_out_folder:
shutil.rmtree(out_folder)
os.makedirs(out_folder)
else:
os.makedirs(out_folder)
os.chdir(out_folder)
os.system("pwd")
# make tmp folder
tmp_folder = os.path.join(out_folder, "tmp_clone_uly") + "/"
if os.path.exists(tmp_folder): shutil.rmtree(tmp_folder)
os.makedirs(tmp_folder)
# make initial landmask maps at the global extent
# - set to the global clone map
pcr.setclone(global_clone_map)
# - for land
landmask_land_all = pcr.ifthen(
pcr.scalar(global_clone_map) > 10, pcr.nominal(0))
# - for river
landmask_river_and_land_all = pcr.ifthen(
pcr.scalar(global_clone_map) > 10, pcr.nominal(0))
for nr in range(1, num_of_masks + 1, 1):
msg = "Processing the landmask %s" % (str(nr))
msg = "\n\n" + str(msg) + "\n\n"
print(msg)
# set to the global clone map
pcr.setclone(global_clone_map)
# read land nc file (and convert it to pcraster)
subdomain_land_nc_file = subdomain_land_nc % (str(nr))
mask_land_selected = vos.netcdf2PCRobjCloneWithoutTime(ncFile = subdomain_land_nc_file, \
varName = "mask",\
cloneMapFileName = global_clone_map,\
LatitudeLongitude = True,\
specificFillValue = "NaN",\
absolutePath = None)
mask_land_selected_boolean = pcr.ifthen(
pcr.scalar(mask_land_selected) > 0.0, pcr.boolean(1.0))
mask_land_selected_boolean = pcr.ifthen(mask_land_selected_boolean,
mask_land_selected_boolean)
# update global landmask for land
mask_land_selected_nominal = pcr.ifthen(mask_land_selected_boolean,
pcr.nominal(nr))
landmask_land_all = pcr.cover(landmask_land_all,
mask_land_selected_nominal)
# ~ pcr.aguila(landmask_land_all)
# read river nc file (and convert it to pcraster)
subdomain_river_nc_file = subdomain_river_nc % (str(nr))
mask_river_selected = vos.netcdf2PCRobjCloneWithoutTime(ncFile = subdomain_river_nc_file, \
varName = "mask",\
cloneMapFileName = global_clone_map,\
LatitudeLongitude = True,\
specificFillValue = "NaN",\
absolutePath = None)
mask_river_selected_boolean = pcr.ifthen(
pcr.scalar(mask_river_selected) > 0.0, pcr.boolean(1.0))
mask_river_selected_boolean = pcr.ifthen(mask_river_selected_boolean,
mask_river_selected_boolean)
# merge land and river landmask
mask_selected_boolean = pcr.cover(mask_land_selected_boolean,
mask_river_selected_boolean)
mask_selected_nominal = pcr.ifthen(mask_selected_boolean,
pcr.nominal(nr))
# ~ pcr.aguila(mask_selected_nominal)
filename_for_land_river_mask_at_global_extent = "global_landmask_river_and_land_mask_%s.map" % (
str(nr))
filename_for_land_river_mask_at_global_extent = os.path.join(
out_folder, filename_for_land_river_mask_at_global_extent)
pcr.report(mask_selected_nominal,
filename_for_land_river_mask_at_global_extent)
# update global landmask for land and river
landmask_river_and_land_all = pcr.cover(landmask_river_and_land_all,
mask_selected_nominal)
# ~ pcr.aguila(landmask_river_and_land_all)
# get the bounding box based on the landmask file
xmin, ymin, xmax, ymax = boundingBox(mask_selected_boolean)
# cellsize
cellsize = vos.getMapAttributes(global_clone_map, "cellsize")
num_rows = int(round(ymax - ymin) / cellsize)
num_cols = int(round(xmax - xmin) / cellsize)
# make the clone map using mapattr
clonemap_mask_file = "clonemap_mask_%s.map" % (str(nr))
# - example: mapattr -s -R 19 -C 68 -B -P yb2t -x 12 -y -14.02 -l 0.8 mask2.map
cmd = "mapattr -s -R %s -C %s -B -P yb2t -x %s -y %s -l %s %s" % (
str(num_rows), str(num_cols), str(xmin), str(ymax), str(cellsize),
clonemap_mask_file)
print(cmd)
os.system(cmd)
# set the landmask for land
pcr.setclone(clonemap_mask_file)
landmask_land = vos.netcdf2PCRobjCloneWithoutTime(ncFile = subdomain_land_nc_file, \
varName = "mask",\
cloneMapFileName = clonemap_mask_file,\
LatitudeLongitude = True,\
specificFillValue = "NaN",\
absolutePath = None)
landmask_land_boolean = pcr.ifthen(
pcr.scalar(landmask_land) > 0.0, pcr.boolean(1.0))
landmask_land_boolean = pcr.ifthen(landmask_land_boolean,
landmask_land_boolean)
# - save the landmask for land (used for PCR-GLOBWB reporting)
landmask_land_file = "landmask_land_mask_%s.map" % (str(nr))
pcr.report(landmask_land_boolean, landmask_land_file)
# set the landmask for river and land
landmask_river_and_land = vos.readPCRmapClone(v = filename_for_land_river_mask_at_global_extent, \
cloneMapFileName = clonemap_mask_file,
tmpDir = tmp_folder, \
absolutePath = None, isLddMap = False, cover = None, isNomMap = True)
landmask_river_and_land_boolean = pcr.ifthen(
pcr.scalar(landmask_river_and_land) > 0.0, pcr.boolean(1.0))
landmask_river_and_land_boolean = pcr.ifthen(
landmask_river_and_land_boolean, landmask_river_and_land_boolean)
landmask_river_and_land_file = "landmask_river_and_land_mask_%s.map" % (
str(nr))
pcr.report(landmask_river_and_land_boolean,
landmask_river_and_land_file)
# kill all aguila processes if exist
os.system('killall aguila')
# report a global nominal map for land
pcr.setclone(global_clone_map)
filename_for_nominal_land_mask_at_global_extent = "global_landmask_land_mask_all.map"
pcr.report(landmask_land_all,
filename_for_nominal_land_mask_at_global_extent)
pcr.aguila(landmask_land_all)
# report a global nominal map for river and and land
pcr.setclone(global_clone_map)
filename_for_nominal_land_river_mask_at_global_extent = "global_landmask_river_and_land_mask_all.map"
pcr.report(landmask_river_and_land_all,
filename_for_nominal_land_river_mask_at_global_extent)
pcr.aguila(landmask_river_and_land_all)
print("\n\n Done \n\n")
def readSoilMapOfFAO(self, iniItems, optionDict = None):
# a dictionary/section of options that will be used
if optionDict == None: optionDict = iniItems._sections["landSurfaceOptions"] #iniItems.landSurfaceOptions
# soil variable names given either in the ini or netCDF file:
soilParameters = ['airEntryValue1','airEntryValue2',
'poreSizeBeta1','poreSizeBeta2',
'resVolWC1','resVolWC2',
'satVolWC1','satVolWC2',
'KSat1','KSat2',
'percolationImp']
if optionDict['soilPropertiesNC'] == str(None):
for var in soilParameters:
input = optionDict[str(var)]
vars(self)[var] = \
vos.readPCRmapClone(input,self.cloneMap,\
self.tmpDir,self.inputDir)
vars(self)[var] = pcr.scalar(vars(self)[var])
if input == "percolationImp": vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
# extrapolation
# - TODO: Make a general extrapolation option as a function in the virtualOS.py
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 0.75))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
else:
soilPropertiesNC = vos.getFullPath(\
optionDict['soilPropertiesNC'],
self.inputDir)
for var in soilParameters:
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(\
soilPropertiesNC,var, \
cloneMapFileName = self.cloneMap)
if var == "percolationImp": vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
# extrapolation
# - TODO: Make a general extrapolation option as a function in the virtualOS.py
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 0.75))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var],
pcr.windowaverage(vars(self)[var], 1.00))
vars(self)[var] = pcr.cover(vars(self)[var], 0.01)
# make sure that resVolWC1 <= satVolWC1
self.resVolWC1 = pcr.min(self.resVolWC1, self.satVolWC1)
self.resVolWC2 = pcr.min(self.resVolWC2, self.satVolWC2)
if self.numberOfLayers == 2:
self.satVolMoistContUpp = self.satVolWC1 # saturated volumetric moisture content (m3.m-3)
self.satVolMoistContLow = self.satVolWC2
self.resVolMoistContUpp = self.resVolWC1 # residual volumetric moisture content (m3.m-3)
self.resVolMoistContLow = self.resVolWC2
self.airEntryValueUpp = self.airEntryValue1 # air entry value (m) according to soil water retention curve of Clapp & Hornberger (1978)
self.airEntryValueLow = self.airEntryValue2
self.poreSizeBetaUpp = self.poreSizeBeta1 # pore size distribution parameter according to Clapp & Hornberger (1978)
self.poreSizeBetaLow = self.poreSizeBeta2
self.kSatUpp = self.KSat1 # saturated hydraulic conductivity (m.day-1)
self.kSatLow = self.KSat2
if self.numberOfLayers == 3:
self.satVolMoistContUpp000005 = self.satVolWC1
self.satVolMoistContUpp005030 = self.satVolWC1
self.satVolMoistContLow030150 = self.satVolWC2
self.resVolMoistContUpp000005 = self.resVolWC1
self.resVolMoistContUpp005030 = self.resVolWC1
self.resVolMoistContLow030150 = self.resVolWC2
self.airEntryValueUpp000005 = self.airEntryValue1
self.airEntryValueUpp005030 = self.airEntryValue1
self.airEntryValueLow030150 = self.airEntryValue2
self.poreSizeBetaUpp000005 = self.poreSizeBeta1
self.poreSizeBetaUpp005030 = self.poreSizeBeta1
self.poreSizeBetaLow030150 = self.poreSizeBeta2
self.kSatUpp000005 = self.KSat1
self.kSatUpp005030 = self.KSat1
self.kSatLow030150 = self.KSat2
self.percolationImp = pcr.cover(self.percolationImp, 0.0) # fractional area where percolation to groundwater store is impeded (dimensionless)
# soil thickness and storage variable names
# as given either in the ini or netCDF file:
soilStorages = ['firstStorDepth', 'secondStorDepth',
'soilWaterStorageCap1','soilWaterStorageCap2']
if optionDict['soilPropertiesNC'] == str(None):
for var in soilStorages:
input = optionDict[str(var)]
temp = str(var)+'Inp'
vars(self)[temp] = vos.readPCRmapClone(input,\
self.cloneMap,
self.tmpDir,self.inputDir)
# extrapolation
# - TODO: Make a general extrapolation option as a function in the virtualOS.py
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 0.75))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp], 0.0)
else:
soilPropertiesNC = vos.getFullPath(\
optionDict['soilPropertiesNC'],
self.inputDir)
for var in soilStorages:
temp = str(var)+'Inp'
vars(self)[temp] = vos.netcdf2PCRobjCloneWithoutTime(\
soilPropertiesNC,var, \
cloneMapFileName = self.cloneMap)
# extrapolation
# - TODO: Make a general extrapolation option as a function in the virtualOS.py
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 0.75))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp],
pcr.windowaverage(vars(self)[temp], 1.05))
vars(self)[temp] = pcr.cover(vars(self)[temp], 0.0)
# layer thickness
if self.numberOfLayers == 2:
self.thickUpp = (0.30/0.30)*self.firstStorDepthInp
self.thickLow = (1.20/1.20)*self.secondStorDepthInp
if self.numberOfLayers == 3:
self.thickUpp000005 = (0.05/0.30)*self.firstStorDepthInp
self.thickUpp005030 = (0.25/0.30)*self.firstStorDepthInp
self.thickLow030150 = (1.20/1.20)*self.secondStorDepthInp
# soil storage
if self.numberOfLayers == 2:
#~ self.storCapUpp = (0.30/0.30)*self.soilWaterStorageCap1Inp
#~ self.storCapLow = (1.20/1.20)*self.soilWaterStorageCap2Inp # 22 Feb 2014: We can calculate this based on thickness and porosity.
self.storCapUpp = self.thickUpp * \
(self.satVolMoistContUpp - self.resVolMoistContUpp)
self.storCapLow = self.thickLow * \
(self.satVolMoistContLow - self.resVolMoistContLow)
self.rootZoneWaterStorageCap = self.storCapUpp + \
self.storCapLow # This is called as WMAX in the original pcrcalc script.
if self.numberOfLayers == 3:
self.storCapUpp000005 = self.thickUpp000005 * \
(self.satVolMoistContUpp000005 - self.resVolMoistContUpp000005)
self.storCapUpp005030 = self.thickUpp005030 * \
(self.satVolMoistContUpp005030 - self.resVolMoistContUpp005030)
self.storCapLow030150 = self.thickLow030150 * \
(self.satVolMoistContLow030150 - self.resVolMoistContLow030150)
self.rootZoneWaterStorageCap = self.storCapUpp000005 + \
self.storCapUpp005030 + \
self.storCapLow030150
def __init__(self, iniItems,landmask,spinUp):
object.__init__(self)
self.cloneMap = iniItems.cloneMap
self.tmpDir = iniItems.tmpDir
self.inputDir = iniItems.globalOptions['inputDir']
self.landmask = landmask
# option to activate water balance check
self.debugWaterBalance = True
if iniItems.routingOptions['debugWaterBalance'] == "False":
self.debugWaterBalance = False
if iniItems.groundwaterOptions['groundwaterPropertiesNC'] == str(None):
# assign the recession coefficient parameter(s)
self.recessionCoeff = vos.readPCRmapClone(\
iniItems.groundwaterOptions['recessionCoeff'],
self.cloneMap,self.tmpDir,self.inputDir)
else:
groundwaterPropertiesNC = vos.getFullPath(\
iniItems.groundwaterOptions[\
'groundwaterPropertiesNC'],
self.inputDir)
self.recessionCoeff = vos.netcdf2PCRobjCloneWithoutTime(\
groundwaterPropertiesNC,'recessionCoeff',\
cloneMapFileName = self.cloneMap)
# groundwater recession coefficient (day-1)
self.recessionCoeff = pcr.cover(self.recessionCoeff,0.00)
self.recessionCoeff = pcr.min(1.0000,self.recessionCoeff)
#
if 'minRecessionCoeff' in iniItems.groundwaterOptions.keys():
minRecessionCoeff = float(iniItems.groundwaterOptions['minRecessionCoeff'])
else:
minRecessionCoeff = 1.0e-4 # This is the minimum value used in Van Beek et al. (2011).
self.recessionCoeff = pcr.max(minRecessionCoeff,self.recessionCoeff)
if iniItems.groundwaterOptions['groundwaterPropertiesNC'] == str(None):
# assign aquifer specific yield
self.specificYield = vos.readPCRmapClone(\
iniItems.groundwaterOptions['specificYield'],
self.cloneMap,self.tmpDir,self.inputDir)
else:
self.specificYield = vos.netcdf2PCRobjCloneWithoutTime(\
groundwaterPropertiesNC,'specificYield',\
cloneMapFileName = self.cloneMap)
self.specificYield = pcr.cover(self.specificYield,0.0)
self.specificYield = pcr.max(0.010,self.specificYield) # TODO: TO BE CHECKED: The resample process of specificYield
self.specificYield = pcr.min(1.000,self.specificYield)
if iniItems.groundwaterOptions['groundwaterPropertiesNC'] == str(None):
# assign aquifer saturated conductivity
self.kSatAquifer = vos.readPCRmapClone(\
iniItems.groundwaterOptions['kSatAquifer'],
self.cloneMap,self.tmpDir,self.inputDir)
else:
self.kSatAquifer = vos.netcdf2PCRobjCloneWithoutTime(\
groundwaterPropertiesNC,'kSatAquifer',\
cloneMapFileName = self.cloneMap)
self.kSatAquifer = pcr.cover(self.kSatAquifer,0.0)
self.kSatAquifer = pcr.max(0.010,self.kSatAquifer)
# limitAbstraction options
self.limitAbstraction = False
if iniItems.landSurfaceOptions['limitAbstraction'] == "True": self.limitAbstraction = True
# option for limitting regional groundwater abstractions
if iniItems.groundwaterOptions['pumpingCapacityNC'] != "None":
logger.info('Limit for annual regional groundwater abstraction is used.')
self.limitRegionalAnnualGroundwaterAbstraction = True
self.pumpingCapacityNC = vos.getFullPath(\
iniItems.groundwaterOptions['pumpingCapacityNC'],self.inputDir,False)
else:
logger.warning('NO LIMIT for regional groundwater (annual) pumping. It may result too high groundwater abstraction.')
self.limitRegionalAnnualGroundwaterAbstraction = False
# option for limitting fossil groundwater abstractions:
self.limitFossilGroundwaterAbstraction = False
#
# estimate of fossil groundwater capacity:
if iniItems.groundwaterOptions['limitFossilGroundWaterAbstraction'] == "True":
logger.info('Fossil groundwater abstractions are allowed with LIMIT.')
self.limitFossilGroundwaterAbstraction = True
# estimate of thickness (unit: m) of accesible groundwater: shallow and deep
totalGroundwaterThickness = vos.readPCRmapClone(\
iniItems.groundwaterOptions['estimateOfTotalGroundwaterThickness'],
self.cloneMap,self.tmpDir,self.inputDir)
# extrapolation
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 1.0))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 1.5))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 2.5))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,
pcr.windowaverage(totalGroundwaterThickness, 5.0))
#
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness, 0.0)
#
# set minimum thickness
minimumThickness = pcr.scalar(float(\
iniItems.groundwaterOptions['minimumTotalGroundwaterThickness']))
totalGroundwaterThickness = pcr.max(minimumThickness, totalGroundwaterThickness)
#
# estimate of capacity (unit: m) of renewable groundwater (shallow)
storGroundwaterCap = pcr.cover(
vos.readPCRmapClone(\
iniItems.groundwaterOptions['estimateOfRenewableGroundwaterCapacity'],
self.cloneMap,self.tmpDir,self.inputDir), 0.0)
#
# fossil groundwater capacity (unit: m)
self.fossilWaterCap = pcr.ifthen(self.landmask,\
pcr.max(0.0,\
totalGroundwaterThickness*self.specificYield - storGroundwaterCap))
# zones at which groundwater allocations are determined
self.usingAllocSegments = False
if iniItems.landSurfaceOptions['allocationSegmentsForGroundSurfaceWater'] != "None": self.usingAllocSegments = True
# incorporating groundwater distribution network:
if self.usingAllocSegments:
self.allocSegments = vos.readPCRmapClone(\
iniItems.landSurfaceOptions['allocationSegmentsForGroundSurfaceWater'],
self.cloneMap,self.tmpDir,self.inputDir,isLddMap=False,cover=None,isNomMap=True)
self.allocSegments = pcr.ifthen(self.landmask, self.allocSegments)
cellArea = vos.readPCRmapClone(\
iniItems.routingOptions['cellAreaMap'],
self.cloneMap,self.tmpDir,self.inputDir)
cellArea = pcr.ifthen(self.landmask, cellArea) # TODO: integrate this one with the one coming from the routing module
self.segmentArea = pcr.areatotal(pcr.cover(cellArea, 0.0), self.allocSegments)
self.segmentArea = pcr.ifthen(self.landmask, self.segmentArea)
# get initial conditions
self.getICs(iniItems,spinUp)
# initiate old style reporting # TODO: remove this!
self.initiate_old_style_groundwater_reporting(iniItems)
def readSoilMapOfFAO(self, iniItems):
# soil variable names given either in the ini or netCDF file:
soilParameters = [
'airEntryValue1', 'airEntryValue2', 'poreSizeBeta1',
'poreSizeBeta2', 'resVolWC1', 'resVolWC2', 'satVolWC1',
'satVolWC2', 'KSat1', 'KSat2', 'percolationImp'
]
if iniItems.landSurfaceOptions['soilPropertiesNC'] == str(None):
for var in soilParameters:
input = iniItems.landSurfaceOptions[str(var)]
vars(self)[var] = \
vos.readPCRmapClone(input,self.cloneMap,\
self.tmpDir,self.inputDir)
vars(self)[var] = pcr.scalar(vars(self)[var])
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
else:
soilPropertiesNC = vos.getFullPath(\
iniItems.landSurfaceOptions[\
'soilPropertiesNC'],
self.inputDir)
for var in soilParameters:
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(\
soilPropertiesNC,var, \
cloneMapFileName = self.cloneMap)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
if self.numberOfLayers == 2:
self.satVolMoistContUpp = self.satVolWC1 # saturated volumetric moisture content (m3.m-3)
self.satVolMoistContLow = self.satVolWC2
self.resVolMoistContUpp = self.resVolWC1 # residual volumetric moisture content (m3.m-3)
self.resVolMoistContLow = self.resVolWC2
self.airEntryValueUpp = self.airEntryValue1 # air entry value (m) according to soil water retention curve of Clapp & Hornberger (1978)
self.airEntryValueLow = self.airEntryValue2
self.poreSizeBetaUpp = self.poreSizeBeta1 # pore size distribution parameter according to Clapp & Hornberger (1978)
self.poreSizeBetaLow = self.poreSizeBeta2
self.kSatUpp = self.KSat1 # saturated hydraulic conductivity (m.day-1)
self.kSatLow = self.KSat2
if self.numberOfLayers == 3:
self.satVolMoistContUpp000005 = self.satVolWC1
self.satVolMoistContUpp005030 = self.satVolWC1
self.satVolMoistContLow030150 = self.satVolWC2
self.resVolMoistContUpp000005 = self.resVolWC1
self.resVolMoistContUpp005030 = self.resVolWC1
self.resVolMoistContLow030150 = self.resVolWC2
self.airEntryValueUpp000005 = self.airEntryValue1
self.airEntryValueUpp005030 = self.airEntryValue1
self.airEntryValueLow030150 = self.airEntryValue2
self.poreSizeBetaUpp000005 = self.poreSizeBeta1
self.poreSizeBetaUpp005030 = self.poreSizeBeta1
self.poreSizeBetaLow030150 = self.poreSizeBeta2
self.kSatUpp000005 = self.KSat1
self.kSatUpp005030 = self.KSat1
self.kSatLow030150 = self.KSat2
self.percolationImp = self.percolationImp # fractional area where percolation to groundwater store is impeded (dimensionless)
# soil thickness and storage variable names
# as given either in the ini or netCDF file:
soilStorages = [
'firstStorDepth', 'secondStorDepth', 'soilWaterStorageCap1',
'soilWaterStorageCap2'
]
if iniItems.landSurfaceOptions['soilPropertiesNC'] == str(None):
for var in soilStorages:
input = iniItems.landSurfaceOptions[str(var)]
temp = str(var) + 'Inp'
vars(self)[temp] = vos.readPCRmapClone(input,\
self.cloneMap,
self.tmpDir,self.inputDir)
vars(self)[temp] = pcr.cover(vars(self)[temp], 0.0)
else:
soilPropertiesNC = vos.getFullPath(\
iniItems.landSurfaceOptions[\
'soilPropertiesNC'],
self.inputDir)
for var in soilStorages:
temp = str(var) + 'Inp'
vars(self)[temp] = vos.netcdf2PCRobjCloneWithoutTime(\
soilPropertiesNC,var, \
cloneMapFileName = self.cloneMap)
vars(self)[temp] = pcr.cover(vars(self)[temp], 0.0)
# layer thickness
if self.numberOfLayers == 2:
self.thickUpp = (0.30 / 0.30) * self.firstStorDepthInp
self.thickLow = (1.20 / 1.20) * self.secondStorDepthInp
if self.numberOfLayers == 3:
self.thickUpp000005 = (0.05 / 0.30) * self.firstStorDepthInp
self.thickUpp005030 = (0.25 / 0.30) * self.firstStorDepthInp
self.thickLow030150 = (1.20 / 1.20) * self.secondStorDepthInp
# soil storage
if self.numberOfLayers == 2:
#~ self.storCapUpp = (0.30/0.30)*self.soilWaterStorageCap1Inp
#~ self.storCapLow = (1.20/1.20)*self.soilWaterStorageCap2Inp # 22 Feb 2014: We can calculate this based on thickness and porosity.
self.storCapUpp = self.thickUpp * \
(self.satVolMoistContUpp - self.resVolMoistContUpp)
self.storCapLow = self.thickLow * \
(self.satVolMoistContLow - self.resVolMoistContLow)
self.rootZoneWaterStorageCap = self.storCapUpp + \
self.storCapLow
if self.numberOfLayers == 3:
self.storCapUpp000005 = self.thickUpp000005 * \
(self.satVolMoistContUpp000005 - self.resVolMoistContUpp000005)
self.storCapUpp005030 = self.thickUpp005030 * \
(self.satVolMoistContUpp005030 - self.resVolMoistContUpp005030)
self.storCapLow030150 = self.thickLow030150 * \
(self.satVolMoistContLow030150 - self.resVolMoistContLow030150)
self.rootZoneWaterStorageCap = self.storCapUpp000005 + \
self.storCapUpp005030 + \
self.storCapLow030150
# ignoring some variable names
variable_names.pop('lat','')
variable_names.pop('lon','')
variable_names.pop('latiudes','')
variable_names.pop('longitudes','')
variable_names.pop('latiude','')
variable_names.pop('longitude','')
variable_names.pop('time','')
# use the first variable
variable_name = str(variable_names[0])
msg = 'Converting '+variable_name+' from the file:'+input_netcdf_filename+' to '+output_pcraster_filename
print msg
# set date_yyyy_mm_dd
date_yyyy_mm_dd = None
if len(sys.argv) > 5: date_yyyy_mm_dd = sys.argv[5]
# read netcdf file
if date_yyyy_mm_dd == None:
map_value = vos.netcdf2PCRobjCloneWithoutTime(input_netcdf_filename,\
variable_name,\
clone_map_filename)
else:
map_value = vos.netcdf2PCRobjClone(input_netcdf_filename,\
variable_name,\
date_yyyy_mm_dd,\
clone_map_filename)
# save the map as pcraster map
pcr.report(map_value, output_pcraster_filename)
def __init__(self, iniItems, landmask):
object.__init__(self)
# cloneMap, temporary directory for the resample process, temporary directory for the modflow process, absolute path for input directory, landmask
self.cloneMap = iniItems.cloneMap
self.tmpDir = iniItems.tmpDir
self.tmp_modflow_dir = iniItems.tmp_modflow_dir
self.inputDir = iniItems.globalOptions['inputDir']
self.landmask = landmask
# configuration from the ini file
self.iniItems = iniItems
# topography properties: read several variables from the netcdf file
for var in ['dem_minimum','dem_maximum','dem_average','dem_standard_deviation',\
'slopeLength','orographyBeta','tanslope',\
'dzRel0000','dzRel0001','dzRel0005',\
'dzRel0010','dzRel0020','dzRel0030','dzRel0040','dzRel0050',\
'dzRel0060','dzRel0070','dzRel0080','dzRel0090','dzRel0100']:
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['topographyNC'], \
var, self.cloneMap)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
# channel properties: read several variables from the netcdf file
for var in ['lddMap','cellAreaMap','gradient','bankfull_width',
'bankfull_depth','dem_floodplain','dem_riverbed']:
vars(self)[var] = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['channelNC'], \
var, self.cloneMap)
vars(self)[var] = pcr.cover(vars(self)[var], 0.0)
# minimum channel width
minimum_channel_width = 0.5 # TODO: Define this one in the configuration file
self.bankfull_width = pcr.max(minimum_channel_width, self.bankfull_width)
#~ # cell fraction if channel water reaching the flood plan # NOT USED YET
#~ self.flood_plain_fraction = self.return_innundation_fraction(pcr.max(0.0, self.dem_floodplain - self.dem_minimum))
# coefficient of Manning
self.manningsN = vos.readPCRmapClone(self.iniItems.modflowParameterOptions['manningsN'],\
self.cloneMap,self.tmpDir,self.inputDir)
# minimum channel gradient
minGradient = 0.00005 # TODO: Define this one in the configuration file
self.gradient = pcr.max(minGradient, pcr.cover(self.gradient, minGradient))
# correcting lddMap
self.lddMap = pcr.ifthen(pcr.scalar(self.lddMap) > 0.0, self.lddMap)
self.lddMap = pcr.lddrepair(pcr.ldd(self.lddMap))
# channelLength = approximation of channel length (unit: m) # This is approximated by cell diagonal.
cellSizeInArcMin = np.round(pcr.clone().cellSize()*60.) # FIXME: This one will not work if you use the resolution: 0.5, 1.5, 2.5 arc-min
verticalSizeInMeter = cellSizeInArcMin*1852.
horizontalSizeInMeter = self.cellAreaMap/verticalSizeInMeter
self.channelLength = ((horizontalSizeInMeter)**(2)+\
(verticalSizeInMeter)**(2))**(0.5)
# option for lakes and reservoir
self.onlyNaturalWaterBodies = False
if self.iniItems.modflowParameterOptions['onlyNaturalWaterBodies'] == "True": self.onlyNaturalWaterBodies = True
# groundwater linear recession coefficient (day-1) ; the linear reservoir concept is still being used to represent fast response flow
# particularly from karstic aquifer in mountainous regions
self.recessionCoeff = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['groundwaterPropertiesNC'],\
'recessionCoeff', self.cloneMap)
self.recessionCoeff = pcr.cover(self.recessionCoeff,0.00)
self.recessionCoeff = pcr.min(1.0000,self.recessionCoeff)
#
if 'minRecessionCoeff' in iniItems.modflowParameterOptions.keys():
minRecessionCoeff = float(iniItems.modflowParameterOptions['minRecessionCoeff'])
else:
minRecessionCoeff = 1.0e-4 # This is the minimum value used in Van Beek et al. (2011).
self.recessionCoeff = pcr.max(minRecessionCoeff,self.recessionCoeff)
# aquifer saturated conductivity (m/day)
self.kSatAquifer = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['groundwaterPropertiesNC'],\
'kSatAquifer', self.cloneMap)
self.kSatAquifer = pcr.cover(self.kSatAquifer,pcr.mapmaximum(self.kSatAquifer))
self.kSatAquifer = pcr.max(0.001,self.kSatAquifer)
# TODO: Define the minimum value as part of the configuration file
# aquifer specific yield (dimensionless)
self.specificYield = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['groundwaterPropertiesNC'],\
'specificYield', self.cloneMap)
self.specificYield = pcr.cover(self.specificYield,pcr.mapmaximum(self.specificYield))
self.specificYield = pcr.max(0.010,self.specificYield) # TODO: TO BE CHECKED: The resample process of specificYield
self.specificYield = pcr.min(1.000,self.specificYield)
# TODO: Define the minimum value as part of the configuration file
# estimate of thickness (unit: m) of accesible groundwater
totalGroundwaterThickness = vos.netcdf2PCRobjCloneWithoutTime(self.iniItems.modflowParameterOptions['estimateOfTotalGroundwaterThicknessNC'],\
'thickness', self.cloneMap)
# extrapolation
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,\
pcr.windowaverage(totalGroundwaterThickness, 1.0))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness,\
pcr.windowaverage(totalGroundwaterThickness, 1.5))
totalGroundwaterThickness = pcr.cover(totalGroundwaterThickness, 0.0)
#
# set minimum thickness
minimumThickness = pcr.scalar(float(\
self.iniItems.modflowParameterOptions['minimumTotalGroundwaterThickness']))
totalGroundwaterThickness = pcr.max(minimumThickness, totalGroundwaterThickness)
#
# set maximum thickness: 250 m. # TODO: Define this one as part of the ini file
maximumThickness = 250.
self.totalGroundwaterThickness = pcr.min(maximumThickness, totalGroundwaterThickness)
# TODO: Define the maximum value as part of the configuration file
# surface water bed thickness (unit: m)
bed_thickness = 0.1 # TODO: Define this as part of the configuration file
# surface water bed resistance (unit: day)
bed_resistance = bed_thickness / (self.kSatAquifer)
minimum_bed_resistance = 1.0 # TODO: Define this as part of the configuration file
self.bed_resistance = pcr.max(minimum_bed_resistance,\
bed_resistance,)
# option to ignore capillary rise
self.ignoreCapRise = True
if self.iniItems.modflowParameterOptions['ignoreCapRise'] == "False": self.ignoreCapRise = False
# a variable to indicate if the modflow has been called or not
self.modflow_has_been_called = False
# list of the convergence criteria for HCLOSE (unit: m)
# - Deltares default's value is 0.001 m # check this value with Jarno
self.criteria_HCLOSE = [0.001, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
self.criteria_HCLOSE = sorted(self.criteria_HCLOSE)
# list of the convergence criteria for RCLOSE (unit: m3)
# - Deltares default's value for their 25 and 250 m resolution models is 10 m3 # check this value with Jarno
cell_area_assumption = verticalSizeInMeter * float(pcr.cellvalue(pcr.mapmaximum(horizontalSizeInMeter),1)[0])
self.criteria_RCLOSE = [10., 10.* cell_area_assumption/(250.*250.), 10.* cell_area_assumption/(25.*25.)]
self.criteria_RCLOSE = sorted(self.criteria_RCLOSE)
# initiate the index for HCLOSE and RCLOSE
self.iteration_HCLOSE = 0
self.iteration_RCLOSE = 0
# initiate old style reporting # TODO: remove this!
self.initiate_old_style_groundwater_reporting(iniItems)
def main():
# make output directory
try:
os.makedirs(output_directory)
except:
if cleanOutputDir == True:
os.system('rm -r ' + output_directory + "/*")
# change the current directory/path to output directory
os.chdir(output_directory)
# make temporary directory
tmp_directory = output_directory + "/tmp"
os.makedirs(tmp_directory)
vos.clean_tmp_dir(tmp_directory)
# format and initialize logger
logger_initialize = Logger(output_directory)
logger.info('Start processing for 5 arc-min resolution!')
# clone and landmask for 5 arc-min resolution
pcr.setclone(clone_map_05min_file)
landmask = pcr.defined(clone_map_05min_file)
# read thickness value (at 5 arc min resolution)
logger.info('Reading the thickness at 5 arc-min resolution!')
thickness = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(thickness_05min_netcdf['filename'], "average_corrected", clone_map_05min_file))
#
# update landmask
landmask = pcr.defined(thickness)
# read aquifer properties at 5 arc min resolution
logger.info(
'Reading saturated conductivity and specific yield at 5 arc-min resolution!'
)
saturated_conductivity = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(\
aquifer_properties_05min_netcdf['filename'],\
"kSatAquifer" , clone_map_05min_file))
specific_yield = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(\
aquifer_properties_05min_netcdf['filename'],\
"specificYield", clone_map_05min_file))
# saving 5 min parameters to a netcdf file
logger.info('Saving groundwater parameter parameters to a netcdf file: ' +
output_05min_filename)
#
output_05min_netcdf = outputNetCDF.OutputNetCDF(clone_map_05min_file)
#
variable_names = ["saturated_conductivity", "specific_yield", "thickness"]
units = ["m/day", "1", "m"]
variable_fields = [
pcr.pcr2numpy(saturated_conductivity, vos.MV),
pcr.pcr2numpy(specific_yield, vos.MV),
pcr.pcr2numpy(thickness, vos.MV),
]
pcr.report(saturated_conductivity, "saturated_conductivity_05min.map")
pcr.report(specific_yield, "specific_yield_05min.map")
pcr.report(thickness, "thickness_05min.map")
output_05min_netcdf.createNetCDF(output_05min_filename, variable_names,
units)
output_05min_netcdf.changeAtrribute(output_05min_filename,
netcdf_attributes)
output_05min_netcdf.data2NetCDF(output_05min_filename, variable_names,
variable_fields)
logger.info('Start processing for 30 arc-min resolution!')
# upscaling thickness to 30 arc min resolution
logger.info('Upscaling thickness from 5 arc-min resolution to 30 arc-min!')
thickness_05min_array = pcr.pcr2numpy(thickness, vos.MV)
thickness_30min_array = vos.regridToCoarse(thickness_05min_array, 30. / 5.,
"average")
#
# set clone for 30 arc min resolution
pcr.setclone(clone_map_30min_file)
#
landmask = pcr.defined(clone_map_30min_file)
thickness = pcr.ifthen(
landmask, pcr.numpy2pcr(pcr.Scalar, thickness_30min_array, vos.MV))
#
# update landmask
landmask = pcr.defined(thickness)
# read aquifer properties at 30 arc min resolution
logger.info(
'Reading saturated conductivity and specific yield at 30 arc-min resolution!'
)
saturated_conductivity = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(\
aquifer_properties_30min_netcdf['filename'],\
"kSatAquifer" , clone_map_30min_file))
specific_yield = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(\
aquifer_properties_30min_netcdf['filename'],\
"specificYield", clone_map_30min_file))
# saving 30 min parameters to a netcdf file
logger.info('Saving groundwater parameter parameters to a netcdf file: ' +
output_30min_filename)
#
output_30min_netcdf = outputNetCDF.OutputNetCDF(clone_map_30min_file)
#
variable_names = ["saturated_conductivity", "specific_yield", "thickness"]
units = ["m/day", "1", "m"]
variable_fields = [
pcr.pcr2numpy(saturated_conductivity, vos.MV),
pcr.pcr2numpy(specific_yield, vos.MV),
pcr.pcr2numpy(thickness, vos.MV),
]
pcr.report(saturated_conductivity, "saturated_conductivity_30min.map")
pcr.report(specific_yield, "specific_yield_30min.map")
pcr.report(thickness, "thickness_30min.map")
output_30min_netcdf.createNetCDF(output_30min_filename, variable_names,
units)
output_30min_netcdf.changeAtrribute(output_30min_filename,
netcdf_attributes)
output_30min_netcdf.data2NetCDF(output_30min_filename, variable_names,
variable_fields)
def __init__(self, clone_map_file,\
input_thickness_netcdf_file,\
input_thickness_var_name ,\
margat_aquifers,\
tmp_directory,
landmask = None,
arcdegree = True):
object.__init__(self)
# aquifer table from Margat and van der Gun
self.margat_aquifers = margat_aquifers
# clone map
self.clone_map_file = clone_map_file
self.clone_map_attr = vos.getMapAttributesALL(self.clone_map_file)
if arcdegree == True:
self.clone_map_attr['cellsize'] = round(self.clone_map_attr['cellsize'] * 360000.)/360000.
xmin = self.clone_map_attr['xUL']
xmax = xmin + self.clone_map_attr['cols'] * self.clone_map_attr['cellsize']
ymax = self.clone_map_attr['yUL']
ymin = ymax - self.clone_map_attr['rows'] * self.clone_map_attr['cellsize']
pcr.setclone(self.clone_map_file)
# temporary directory
self.tmp_directory = tmp_directory
# thickness approximation (unit: m, file in netcdf with variable name = average
self.approx_thick = vos.netcdf2PCRobjCloneWithoutTime(input_thickness_netcdf_file,\
input_thickness_var_name,\
self.clone_map_file)
# set minimum value to 0.1 mm
self.approx_thick = pcr.max(0.0001, self.approx_thick)
# rasterize the shape file
# -
# save current directory and move to temporary directory
current_dir = str(os.getcwd()+"/")
os.chdir(str(self.tmp_directory))
#
cmd_line = 'gdal_rasterize -a MARGAT ' # layer name = MARGAT
cmd_line += '-te '+str(xmin)+' '+str(ymin)+' '+str(xmax)+' '+str(ymax)+ ' '
cmd_line += '-tr '+str(self.clone_map_attr['cellsize'])+' '+str(self.clone_map_attr['cellsize'])+' '
cmd_line += str(margat_aquifers['shapefile'])+' '
cmd_line += 'tmp.tif'
print(cmd_line); os.system(cmd_line)
#
# make it nomial
cmd_line = 'pcrcalc tmp.map = "nominal(tmp.tif)"'
print(cmd_line); os.system(cmd_line)
#
# make sure that the clone map is correct
cmd_line = 'mapattr -c '+str(self.clone_map_file)+' tmp.map'
print(cmd_line); os.system(cmd_line)
#
# read the map
self.margat_aquifer_map = pcr.nominal(pcr.readmap("tmp.map"))
#
# clean temporary directory and return to the original directory
vos.clean_tmp_dir(self.tmp_directory)
os.chdir(current_dir)
# extend the extent of each aquifer
self.margat_aquifer_map = pcr.cover(self.margat_aquifer_map,
pcr.windowmajority(self.margat_aquifer_map, 1.25))
# assign aquifer thickness, unit: m (lookuptable operation)
self.margat_aquifer_thickness = pcr.lookupscalar(margat_aquifers['txt_table'], self.margat_aquifer_map)
self.margat_aquifer_thickness = pcr.ifthen(self.margat_aquifer_thickness > 0., \
self.margat_aquifer_thickness)
#~ pcr.report(self.margat_aquifer_thickness,"thick.map"); os.system("aguila thick.map")
# aquifer map
self.margat_aquifer_map = pcr.ifthen(self.margat_aquifer_thickness > 0., self.margat_aquifer_map)
# looping per aquifer: cirrecting or rescaling
aquifer_ids = np.unique(pcr.pcr2numpy(pcr.scalar(self.margat_aquifer_map), vos.MV))
aquifer_ids = aquifer_ids[aquifer_ids > 0]
aquifer_ids = aquifer_ids[aquifer_ids < 10000]
self.rescaled_thickness = None
for id in aquifer_ids:
rescaled_thickness = self.correction_per_aquifer(id)
try:
self.rescaled_thickness = pcr.cover(self.rescaled_thickness, rescaled_thickness)
except:
self.rescaled_thickness = rescaled_thickness
# integrating
ln_aquifer_thickness = self.mapFilling( pcr.ln(self.rescaled_thickness), pcr.ln(self.approx_thick) )
self.aquifer_thickness = pcr.exp(ln_aquifer_thickness)
#~ pcr.report(self.aquifer_thickness,"thick.map"); os.system("aguila thick.map")
# cropping only in the landmask region
if landmask == None: landmask = self.clone_map_file
self.landmask = pcr.defined(vos.readPCRmapClone(landmask,self.clone_map_file,self.tmp_directory))
#~ pcr.report(self.landmask,"test.map"); os.system("aguila test.map")
self.aquifer_thickness = pcr.ifthen(self.landmask, self.aquifer_thickness)
def __init__(self, clone_map_file, \
dem_average_netcdf, dem_floodplain_netcdf, ldd_netcdf, \
lookup_table_average_thickness, lookup_table_zscore, \
number_of_samples, include_percentile = True,\
threshold_sedimentary_basin = 50.0, elevation_F_min = 0.0, elevation_F_max = 50.0): # values defined in de Graaf et al. (2014)
DynamicModel.__init__(self)
MonteCarloModel.__init__(self)
msg = "\n"
msg += "\n"
msg += 'For each step, please refer to de Graaf et al. (2014).'
msg += "\n"
logger.info(msg)
# set clone
self.clone_map_file = clone_map_file
pcr.setclone(clone_map_file)
# an option to include_percentile or not
self.include_percentile = include_percentile
# number of samples
self.number_of_samples = pcr.scalar(number_of_samples)
logger.info(
"Step 1: Identify the cells belonging to the sedimentary basin region."
)
dem_average = vos.netcdf2PCRobjCloneWithoutTime(dem_average_netcdf['file_name'],\
dem_average_netcdf['variable_name'],\
clone_map_file)
dem_average = pcr.max(0.0, dem_average)
self.dem_average = pcr.cover(dem_average, 0.0)
dem_floodplain = vos.netcdf2PCRobjCloneWithoutTime(
dem_floodplain_netcdf['file_name'],
dem_floodplain_netcdf['variable_name'], clone_map_file)
dem_floodplain = pcr.max(0.0, dem_floodplain)
lddMap = vos.netcdf2PCRobjCloneWithoutTime(ldd_netcdf['file_name'],
ldd_netcdf['variable_name'],
clone_map_file)
self.lddMap = pcr.lddrepair(pcr.lddrepair(pcr.ldd(lddMap)))
self.landmask = pcr.defined(self.lddMap)
elevation_F = dem_average - dem_floodplain
sedimentary_basin_extent = pcr.ifthen(
elevation_F < pcr.scalar(threshold_sedimentary_basin),
pcr.boolean(1))
# include the continuity along the river network
sedimentary_basin_extent = pcr.windowmajority(
sedimentary_basin_extent,
3.00 * vos.getMapAttributes(clone_map_file, "cellsize"))
sedimentary_basin_extent = pcr.cover(sedimentary_basin_extent, \
pcr.path(self.lddMap, pcr.defined(sedimentary_basin_extent)))
# TODO: We should also include the extent of major aquifer basins and unconsolidated sediments in the GLiM map.
elevation_F = pcr.ifthen(sedimentary_basin_extent, elevation_F)
elevation_F = pcr.max(0.0, elevation_F)
elevation_F = pcr.min(50., elevation_F)
logger.info(
"Step 2: Calculate relative difference and associate z_score.")
relative_elevation_F = pcr.scalar(
1.0) - (elevation_F - elevation_F_min) / (elevation_F_max -
elevation_F_min)
z_score_relat_elev_F = pcr.lookupscalar(lookup_table_zscore,
relative_elevation_F)
self.F = z_score_relat_elev_F # zscore (varying over the map)
# maximum and minimum z_score
self.F = pcr.min(3.75, self.F)
self.F = pcr.max(-10.00, self.F)
logger.info(
"Step 3: Assign average and variation of aquifer thickness.")
self.lookup_table_average_thickness = lookup_table_average_thickness
self.lnCV = pcr.scalar(
0.1
) # According to Inge, this lnCV value corresponds to the table "lookup_table_average_thickness".
for year in range(start_year, end_year + 1, 1):
# cdo for every year
inp_file_name = input_directory + file_name_front + str(year) + ".nc"
out_file_name = output_directory + file_name_front + str(
year) + "_maximum.nc"
cmd = 'cdo timmax ' + inp_file_name + " " + out_file_name
print(cmd)
os.system(cmd)
# time stamp for netcdf reporting
timeStamp = datetime.datetime(year, 12, 31, 0)
# read value and report it at 5 arcmin resolution
print("Reading values at 5 arcmin resolution.")
value_at_05_min = vos.netcdf2PCRobjCloneWithoutTime(ncFile = out_file_name, varName = variable_name, \
cloneMapFileName = clone_map_05min_file)
value_at_05_min = pcr.cover(value_at_05_min, 0.0)
numpy_at_05_min = pcr.pcr2numpy(value_at_05_min, vos.MV)
report_netcdf_05min.data2NetCDF(output_file_05min, \
variable_name, \
numpy_at_05_min, \
timeStamp)
# upscale it to 30 arcmin resolution and report it
print("Upscale to 30 arcmin resolution.")
value_at_30_min = pcr.areatotal(value_at_05_min * cell_area_05min, cell_ids_30min) /\
pcr.areatotal( cell_area_05min, cell_ids_30min)
value_at_30_min = pcr.cover(value_at_30_min, 0.0)
numpy_at_30_min = vos.regridToCoarse(pcr.pcr2numpy(value_at_30_min, vos.MV), \
int(30./5.), "average", vos.MV)
report_netcdf_30min.data2NetCDF(output_file_30min, \
