def checkerboard(mapin, fcc):
"""
checkerboard create a checkerboard map with unique id's in a
fcc*fcc cells area. The resulting map can be used
to derive statistics for (later) upscaling of maps (using the fcc factor)
.. warning: use with unitcell to get most reliable results!
Input:
- map (used to determine coordinates)
- fcc (size of the areas in cells)
Output:
- checkerboard type map
"""
msker = pcr.defined(mapin)
ymin = pcr.mapminimum(pcr.ycoordinate(msker))
yc = (pcr.ycoordinate((msker)) - ymin) / pcr.celllength()
yc = pcr.rounddown(yc / fcc)
# yc = yc/fcc
xmin = pcr.mapminimum(pcr.xcoordinate((msker)))
xc = (pcr.xcoordinate((msker)) - xmin) / pcr.celllength()
xc = pcr.rounddown(xc / fcc)
# xc = xc/fcc
yc = yc * (pcr.mapmaximum(xc) + 1.0)
xy = pcr.ordinal(xc + yc)
return xy
def checkerboard(mapin, fcc):
"""
checkerboard create a checkerboard map with unique id's in a
fcc*fcc cells area. The resulting map can be used
to derive statistics for (later) upscaling of maps (using the fcc factor)
.. warning: use with unitcell to get most reliable results!
Input:
- map (used to determine coordinates)
- fcc (size of the areas in cells)
Output:
- checkerboard type map
"""
msker = pcr.defined(mapin)
ymin = pcr.mapminimum(pcr.ycoordinate(msker))
yc = (pcr.ycoordinate((msker)) - ymin) / pcr.celllength()
yc = pcr.rounddown(yc / fcc)
# yc = yc/fcc
xmin = pcr.mapminimum(pcr.xcoordinate((msker)))
xc = (pcr.xcoordinate((msker)) - xmin) / pcr.celllength()
xc = pcr.rounddown(xc / fcc)
# xc = xc/fcc
yc = yc * (pcr.mapmaximum(xc) + 1.0)
xy = pcr.ordinal(xc + yc)
return xy
def upscale_riverlength(ldd, order, factor):
"""
Upscales the riverlength using 'factor'
The resulting maps can be resampled (e.g. using resample.exe) by factor and should
include the accurate length as determined with the original higher
resolution maps. This function is **depricated**,
use are_riverlength instead as this version
is very slow for large maps
Input:
- ldd
- minimum streamorder to include
Output:
- distance per factor cells
"""
strorder = pcr.streamorder(ldd)
strorder = pcr.ifthen(strorder >= order, strorder)
dist = pcr.cover(
pcr.max(pcr.celllength(),
pcr.ifthen(pcr.boolean(strorder), pcr.downstreamdist(ldd))),
0,
)
totdist = pcr.max(
pcr.ifthen(
pcr.boolean(strorder),
pcr.windowtotal(pcr.ifthen(pcr.boolean(strorder), dist),
pcr.celllength() * factor),
),
dist,
)
return totdist
def getValAtPoint(in_map, xcor, ycor):
"""
returns the value in a map at the point given.
works but is rather slow.
Input:
- in_map - map to determine coordinates from
- xcor - x coordinate
- ycor - y coordinate
Output:
- value
"""
x = pcr.pcr2numpy(pcr.xcoordinate(pcr.defined(in_map)), np.nan)
y = pcr.pcr2numpy(pcr.ycoordinate(pcr.defined(in_map)), np.nan)
XX = pcr.pcr2numpy(pcr.celllength(), 0.0)
themap = pcr.pcr2numpy(in_map, np.nan)
tolerance = 0.5 # takes a single point
diffx = x - xcor
diffy = y - ycor
col_ = np.absolute(diffx) <= (XX[0, 0] * tolerance) # cellsize
row_ = np.absolute(diffy) <= (XX[0, 0] * tolerance) # cellsize
point = col_ * row_
pt = point.argmax()
return themap.ravel()[pt]
def getgridparams():
""" return grid parameters in a python friendly way
Output:
[ Xul, Yul, xsize, ysize, rows, cols]
- xul - x upper left centre
- yul - y upper left centre
- xsize - size of a cell in x direction
- ysize - size of a cell in y direction
- cols - number of columns
- rows - number of rows
- xlr - x lower right centre
- ylr - y lower right centre
"""
# This is the default, but add for safety...
pcr.setglobaloption("coorcentre")
# x and Y are the same for now
xy = pcr.pcr2numpy(pcr.celllength(), np.nan)[0, 0]
xu = pcr.pcr2numpy(pcr.xcoordinate(1), np.nan)[0, 0]
yu = pcr.pcr2numpy(pcr.ycoordinate(1), np.nan)[0, 0]
ylr = pcr.pcr2numpy(pcr.ycoordinate(1), np.nan)[getrows() - 1, getcols() - 1]
xlr = pcr.pcr2numpy(pcr.xcoordinate(1), np.nan)[getrows() - 1, getcols() - 1]
return [xu, yu, xy, xy, getrows(), getcols(), xlr, ylr]
def getgridparams():
""" return grid parameters in a python friendly way
Output:
[ Xul, Yul, xsize, ysize, rows, cols]
- xul - x upper left centre
- yul - y upper left centre
- xsize - size of a cell in x direction
- ysize - size of a cell in y direction
- cols - number of columns
- rows - number of rows
- xlr - x lower right centre
- ylr - y lower right centre
"""
# This is the default, but add for safety...
pcr.setglobaloption("coorcentre")
# x and Y are the same for now
xy = pcr.pcr2numpy(pcr.celllength(), np.nan)[0, 0]
xu = pcr.pcr2numpy(pcr.xcoordinate(1), np.nan)[0, 0]
yu = pcr.pcr2numpy(pcr.ycoordinate(1), np.nan)[0, 0]
ylr = pcr.pcr2numpy(pcr.ycoordinate(1), np.nan)[getrows() - 1, getcols() - 1]
xlr = pcr.pcr2numpy(pcr.xcoordinate(1), np.nan)[getrows() - 1, getcols() - 1]
return [xu, yu, xy, xy, getrows(), getcols(), xlr, ylr]
def getRowColPoint(in_map, xcor, ycor):
"""
returns the row and col in a map at the point given.
Works but is rather slow.
Input:
- in_map - map to determine coordinates from
- xcor - x coordinate
- ycor - y coordinate
Output:
- row, column
"""
x = pcr.pcr2numpy(pcr.xcoordinate(pcr.boolean(pcr.scalar(in_map) + 1.0)), np.nan)
y = pcr.pcr2numpy(pcr.ycoordinate(pcr.boolean(pcr.scalar(in_map) + 1.0)), np.nan)
XX = pcr.pcr2numpy(pcr.celllength(), 0.0)
tolerance = 0.5 # takes a single point
diffx = x - xcor
diffy = y - ycor
col_ = np.absolute(diffx) <= (XX[0, 0] * tolerance) # cellsize
row_ = np.absolute(diffy) <= (XX[0, 0] * tolerance) # cellsize
point = col_ * row_
return point.argmax(0).max(), point.argmax(1).max()
def getValAtPoint(in_map, xcor, ycor):
"""
returns the value in a map at the point given.
works but is rather slow.
Input:
- in_map - map to determine coordinates from
- xcor - x coordinate
- ycor - y coordinate
Output:
- value
"""
x = pcr.pcr2numpy(pcr.xcoordinate(pcr.defined(in_map)), np.nan)
y = pcr.pcr2numpy(pcr.ycoordinate(pcr.defined(in_map)), np.nan)
XX = pcr.pcr2numpy(pcr.celllength(), 0.0)
themap = pcr.pcr2numpy(in_map, np.nan)
tolerance = 0.5 # takes a single point
diffx = x - xcor
diffy = y - ycor
col_ = np.absolute(diffx) <= (XX[0, 0] * tolerance) # cellsize
row_ = np.absolute(diffy) <= (XX[0, 0] * tolerance) # cellsize
point = col_ * row_
pt = point.argmax()
return themap.ravel()[pt]
def getRowColPoint(in_map, xcor, ycor):
"""
returns the row and col in a map at the point given.
Works but is rather slow.
Input:
- in_map - map to determine coordinates from
- xcor - x coordinate
- ycor - y coordinate
Output:
- row, column
"""
x = pcr.pcr2numpy(pcr.xcoordinate(pcr.boolean(pcr.scalar(in_map) + 1.0)), np.nan)
y = pcr.pcr2numpy(pcr.ycoordinate(pcr.boolean(pcr.scalar(in_map) + 1.0)), np.nan)
XX = pcr.pcr2numpy(pcr.celllength(), 0.0)
tolerance = 0.5 # takes a single point
diffx = x - xcor
diffy = y - ycor
col_ = np.absolute(diffx) <= (XX[0, 0] * tolerance) # cellsize
row_ = np.absolute(diffy) <= (XX[0, 0] * tolerance) # cellsize
point = col_ * row_
return point.argmax(0).max(), point.argmax(1).max()
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 detRealCellLength(ZeroMap, sizeinmetres):
"""
Determine cellength. Always returns the length
in meters.
"""
if sizeinmetres:
reallength = pcr.celllength()
xl = pcr.celllength()
yl = pcr.celllength()
else:
aa = pcr.ycoordinate(pcr.boolean(pcr.cover(ZeroMap + 1, 1)))
yl, xl = lattometres(aa)
xl = xl * pcr.celllength()
yl = yl * pcr.celllength()
# Average length for surface area calculations.
reallength = (xl + yl) * 0.5
return xl, yl, reallength
def detRealCellLength(ZeroMap, sizeinmetres):
"""
Determine cellength. Always returns the length
in meters.
"""
if sizeinmetres:
reallength = pcr.celllength()
xl = pcr.celllength()
yl = pcr.celllength()
else:
aa = pcr.ycoordinate(pcr.boolean(pcr.cover(ZeroMap + 1, 1)))
yl, xl = lattometres(aa)
xl = xl * pcr.celllength()
yl = yl * pcr.celllength()
# Average length for surface area calculations.
reallength = (xl + yl) * 0.5
return xl, yl, reallength
def getcols():
"""
returns the number of columns in the current map
Input:
- -
Output:
- nr of columns in the current clonemap as a scalar
"""
a = pcr.pcr2numpy(pcr.celllength(), np.nan).shape[1]
return a
def getcols():
"""
returns the number of columns in the current map
Input:
- -
Output:
- nr of columns in the current clonemap as a scalar
"""
a = pcr.pcr2numpy(pcr.celllength(), np.nan).shape[1]
return a
def upscale_riverlength(ldd, order, factor):
"""
Upscales the riverlength using 'factor'
The resulting maps can be resampled (e.g. using resample.exe) by factor and should
include the accurate length as determined with the original higher
resolution maps. This function is **depricated**,
use are_riverlength instead as this version
is very slow for large maps
Input:
- ldd
- minimum streamorder to include
Output:
- distance per factor cells
"""
strorder = pcr.streamorder(ldd)
strorder = pcr.ifthen(strorder >= order, strorder)
dist = pcr.cover(
pcr.max(
pcr.celllength(), pcr.ifthen(pcr.boolean(strorder), pcr.downstreamdist(ldd))
),
0,
)
totdist = pcr.max(
pcr.ifthen(
pcr.boolean(strorder),
pcr.windowtotal(
pcr.ifthen(pcr.boolean(strorder), dist), pcr.celllength() * factor
),
),
dist,
)
return totdist
def riverlength(ldd, order):
"""
Determines the length of a river using the ldd.
only determined for order and higher.
Input:
- ldd, order (streamorder)
Returns:
- totallength,lengthpercell, streamorder
"""
strorder = pcr.streamorder(ldd)
strorder = pcr.ifthen(strorder >= pcr.ordinal(order), strorder)
dist = pcr.max(pcr.celllength(),
pcr.ifthen(pcr.boolean(strorder), pcr.downstreamdist(ldd)))
return pcr.catchmenttotal(pcr.cover(dist, 0), ldd), dist, strorder
def riverlength(ldd, order):
"""
Determines the length of a river using the ldd.
only determined for order and higher.
Input:
- ldd, order (streamorder)
Returns:
- totallength,lengthpercell, streamorder
"""
strorder = pcr.streamorder(ldd)
strorder = pcr.ifthen(strorder >= pcr.ordinal(order), strorder)
dist = pcr.max(
pcr.celllength(), pcr.ifthen(pcr.boolean(strorder), pcr.downstreamdist(ldd))
)
return pcr.catchmenttotal(pcr.cover(dist, 0), ldd), dist, strorder
def points_to_map(in_map, xcor, ycor, tolerance):
"""
Returns a map with non zero values at the points defined
in X, Y pairs. It's goal is to replace the pcraster col2map program.
tolerance should be 0.5 to select single points
Performance is not very good and scales linear with the number of points
Input:
- in_map - map to determine coordinates from
- xcor - x coordinate (array or single value)
- ycor - y coordinate (array or single value)
- tolerance - tolerance in cell units. 0.5 selects a single cell\
10 would select a 10x10 block of cells
Output:
- Map with values burned in. 1 for first point, 2 for second and so on
"""
point = in_map * 0.0
x = pcr.pcr2numpy(pcr.xcoordinate(pcr.defined(in_map)), np.nan)
y = pcr.pcr2numpy(pcr.ycoordinate(pcr.defined(in_map)), np.nan)
cell_length = float(pcr.celllength())
# simple check to use both floats and numpy arrays
try:
c = xcor.ndim
except:
xcor = np.array([xcor])
ycor = np.array([ycor])
# Loop over points and "burn in" map
for n in range(0, xcor.size):
if Verbose:
print(n)
diffx = x - xcor[n]
diffy = y - ycor[n]
col_ = np.absolute(diffx) <= (cell_length * tolerance) # cellsize
row_ = np.absolute(diffy) <= (cell_length * tolerance) # cellsize
point = point + pcr.numpy2pcr(pcr.Scalar,
((col_ * row_) * (n + 1)), np.nan)
return pcr.ordinal(point)
def points_to_map(in_map, xcor, ycor, tolerance):
"""
Returns a map with non zero values at the points defined
in X, Y pairs. It's goal is to replace the pcraster col2map program.
tolerance should be 0.5 to select single points
Performance is not very good and scales linear with the number of points
Input:
- in_map - map to determine coordinates from
- xcor - x coordinate (array or single value)
- ycor - y coordinate (array or single value)
- tolerance - tolerance in cell units. 0.5 selects a single cell\
10 would select a 10x10 block of cells
Output:
- Map with values burned in. 1 for first point, 2 for second and so on
"""
point = in_map * 0.0
x = pcr.pcr2numpy(pcr.xcoordinate(pcr.defined(in_map)), np.nan)
y = pcr.pcr2numpy(pcr.ycoordinate(pcr.defined(in_map)), np.nan)
cell_length = float(pcr.celllength())
# simple check to use both floats and numpy arrays
try:
c = xcor.ndim
except:
xcor = np.array([xcor])
ycor = np.array([ycor])
# Loop over points and "burn in" map
for n in range(0, xcor.size):
if Verbose:
print(n)
diffx = x - xcor[n]
diffy = y - ycor[n]
col_ = np.absolute(diffx) <= (cell_length * tolerance) # cellsize
row_ = np.absolute(diffy) <= (cell_length * tolerance) # cellsize
point = point + pcr.numpy2pcr(pcr.Scalar, ((col_ * row_) * (n + 1)), np.nan)
return pcr.ordinal(point)
def output_filename(filename, buffer_size):
head, tail = os.path.split(filename)
tmp = tail.split(".")
fname = "{0}_{1}.map".format(tmp[0], buffer_size * int(pcr.celllength()))
return fname
def main():
"""
:ivar masterdem: digital elevation model
:ivar dem: digital elevation model
:ivar river: optional river map
"""
# Default values
strRiver = 8
masterdem = "dem.map"
step1dir = "step1"
step2dir = "step2"
workdir = "."
inifile = "wflow_prepare.ini"
recreate = False
snapgaugestoriver = False
try:
opts, args = getopt.getopt(sys.argv[1:], "W:hI:f")
except getopt.error as msg:
usage(msg)
for o, a in opts:
if o == "-W":
workdir = a
if o == "-I":
inifile = a
if o == "-h":
usage()
if o == "-f":
recreate = True
pcr.setglobaloption("unitcell")
os.chdir(workdir)
config = OpenConf(workdir + "/" + inifile)
masterdem = configget(config, "files", "masterdem", "dem.map")
pcr.setclone(masterdem)
strRiver = int(configget(config, "settings", "riverorder", "4"))
try:
gauges_x = config.get("settings", "gauges_x")
gauges_y = config.get("settings", "gauges_y")
except:
print("gauges_x and gauges_y are required entries in the ini file")
sys.exit(1)
step1dir = configget(config, "directories", "step1dir", "step1")
step2dir = configget(config, "directories", "step2dir", "step2")
# upscalefactor = float(config.get("settings","upscalefactor"))
corevolume = float(configget(config, "settings", "corevolume", "1E35"))
catchmentprecipitation = float(
configget(config, "settings", "catchmentprecipitation", "1E35"))
corearea = float(configget(config, "settings", "corearea", "1E35"))
outflowdepth = float(
configget(config, "settings", "lddoutflowdepth", "1E35"))
initialscale = int(configget(config, "settings", "initialscale", "1"))
csize = float(configget(config, "settings", "cellsize", "1"))
snapgaugestoriver = bool(
int(configget(config, "settings", "snapgaugestoriver", "1")))
lddglobaloption = configget(config, "settings", "lddglobaloption",
"lddout")
pcr.setglobaloption(lddglobaloption)
lu_water = configget(config, "files", "lu_water", "")
lu_paved = configget(config, "files", "lu_paved", "")
# X/Y coordinates of the gauges the system
exec("X=tr.array(" + gauges_x + ")")
exec("Y=tr.array(" + gauges_y + ")")
tr.Verbose = 1
# make the directories to save results in
mkoutputdirs(step1dir, step2dir)
ldddem = readdem(initialscale, masterdem, step1dir)
dem = ldddem
try:
catchmask = config.get("files", "catchment_mask")
except:
print("No catchment mask...")
else:
print("clipping DEM with mask.....")
mask = pcr.readmap(catchmask)
ldddem = pcr.ifthen(pcr.boolean(mask), ldddem)
dem = pcr.ifthen(pcr.boolean(mask), dem)
# See if there is a shape file of the river to burn in
try:
rivshp = config.get("files", "river")
except:
print("no river file specified")
outletpointX = float(
configget(config, "settings", "outflowpointX", "0.0"))
outletpointY = float(
configget(config, "settings", "outflowpointY", "0.0"))
else:
print("river file specified.....")
try:
outletpointX = float(
configget(config, "settings", "outflowpointX", "0.0"))
outletpointY = float(
configget(config, "settings", "outflowpointY", "0.0"))
except:
print(
"Need to specify the river outletpoint (a point at the end of the river within the current map)"
)
exit(1)
outletpointmap = tr.points_to_map(dem, outletpointX, outletpointY, 0.5)
pcr.report(outletpointmap, step1dir + "/outletpoint.map")
rivshpattr = config.get("files", "riverattr")
pcr.report(dem * 0.0, step1dir + "/nilmap.map")
thestr = ("gdal_translate -of GTiff " + step1dir + "/nilmap.map " +
step1dir + "/riverburn.tif")
os.system(thestr)
os.system("gdal_rasterize -burn 1 -l " + rivshpattr + " " + rivshp +
" " + step1dir + "/riverburn.tif")
thestr = ("gdal_translate -of PCRaster " + step1dir +
"/riverburn.tif " + step1dir + "/riverburn.map")
os.system(thestr)
riverburn = pcr.readmap(step1dir + "/riverburn.map")
# Determine regional slope assuming that is the way the river should run
pcr.setglobaloption("unitcell")
demregional = pcr.windowaverage(dem, 100)
ldddem = pcr.ifthenelse(riverburn >= 1.0, demregional - 1000, dem)
pcr.setglobaloption("unittrue")
upscalefactor = int(csize / pcr.celllength())
print("Creating ldd...")
ldd = tr.lddcreate_save(
step1dir + "/ldd.map",
ldddem,
recreate,
outflowdepth=outflowdepth,
corevolume=corevolume,
catchmentprecipitation=catchmentprecipitation,
corearea=corearea,
)
print("Determining streamorder...")
stro = pcr.streamorder(ldd)
pcr.report(stro, step1dir + "/streamorder.map")
strdir = pcr.ifthen(stro >= strRiver, stro)
pcr.report(strdir, step1dir + "/streamorderrive.map")
pcr.report(pcr.boolean(pcr.ifthen(stro >= strRiver, stro)),
step1dir + "/rivers.map")
pcr.setglobaloption("unittrue")
# outlet (and other gauges if given)
# TODO: check is x/y set if not skip this
print("Outlet...")
outlmap = tr.points_to_map(dem, X, Y, 0.5)
if snapgaugestoriver:
print("Snapping gauges to nearest river cells...")
pcr.report(outlmap, step1dir + "/orggauges.map")
outlmap = tr.snaptomap(outlmap, strdir)
# noutletmap = tr.points_to_map(dem,XX,YY,0.5)
# pcr.report(noutletmap,'noutlet.map')
pcr.report(outlmap, step1dir + "/gauges.map")
# check if there is a pre-define catchment map
try:
catchmask = config.get("files", "catchment_mask")
except:
print("No catchment mask, finding outlet")
# Find catchment (overall)
outlet = tr.find_outlet(ldd)
sub = pcr.subcatch(ldd, outlet)
pcr.report(sub, step1dir + "/catchment_overall.map")
else:
print("reading and converting catchment mask.....")
os.system("resample -r " + str(initialscale) + " " + catchmask + " " +
step1dir + "/catchment_overall.map")
sub = pcr.readmap(step1dir + "/catchment_overall.map")
print("Scatch...")
sd = pcr.subcatch(ldd, pcr.ifthen(outlmap > 0, outlmap))
pcr.report(sd, step1dir + "/scatch.map")
pcr.setglobaloption("unitcell")
print("Upscalefactor: " + str(upscalefactor))
if upscalefactor > 1:
gc.collect()
print("upscale river length1 (checkerboard map)...")
ck = tr.checkerboard(dem, upscalefactor)
pcr.report(ck, step1dir + "/ck.map")
pcr.report(dem, step1dir + "/demck.map")
print("upscale river length2...")
fact = tr.area_riverlength_factor(ldd, ck, upscalefactor)
pcr.report(fact, step1dir + "/riverlength_fact.map")
# print("make dem statistics...")
dem_ = pcr.areaaverage(dem, ck)
pcr.report(dem_, step1dir + "/demavg.map")
print("Create DEM statistics...")
dem_ = pcr.areaminimum(dem, ck)
pcr.report(dem_, step1dir + "/demmin.map")
dem_ = pcr.areamaximum(dem, ck)
pcr.report(dem_, step1dir + "/demmax.map")
# calculate percentiles
order = pcr.areaorder(dem, ck)
n = pcr.areatotal(pcr.spatial(pcr.scalar(1.0)), ck)
#: calculate 25 percentile
perc = tr.area_percentile(dem, ck, n, order, 25.0)
pcr.report(perc, step1dir + "/dem25.map")
perc = tr.area_percentile(dem, ck, n, order, 10.0)
pcr.report(perc, step1dir + "/dem10.map")
perc = tr.area_percentile(dem, ck, n, order, 50.0)
pcr.report(perc, step1dir + "/dem50.map")
perc = tr.area_percentile(dem, ck, n, order, 33.0)
pcr.report(perc, step1dir + "/dem33.map")
perc = tr.area_percentile(dem, ck, n, order, 66.0)
pcr.report(perc, step1dir + "/dem66.map")
perc = tr.area_percentile(dem, ck, n, order, 75.0)
pcr.report(perc, step1dir + "/dem75.map")
perc = tr.area_percentile(dem, ck, n, order, 90.0)
pcr.report(perc, step1dir + "/dem90.map")
else:
print("No fancy scaling done. Going strait to step2....")
pcr.report(dem, step1dir + "/demavg.map")
Xul = float(config.get("settings", "Xul"))
Yul = float(config.get("settings", "Yul"))
Xlr = float(config.get("settings", "Xlr"))
Ylr = float(config.get("settings", "Ylr"))
gdalstr = ("gdal_translate -projwin " + str(Xul) + " " + str(Yul) +
" " + str(Xlr) + " " + str(Ylr) + " -of PCRaster ")
# gdalstr = "gdal_translate -a_ullr " + str(Xul) + " " + str(Yul) + " " +str(Xlr) + " " +str(Ylr) + " -of PCRaster "
print(gdalstr)
pcr.report(pcr.cover(1.0), step1dir + "/wflow_riverlength_fact.map")
# Now us gdat tp convert the maps
os.system(gdalstr + step1dir + "/wflow_riverlength_fact.map" + " " +
step2dir + "/wflow_riverlength_fact.map")
os.system(gdalstr + step1dir + "/demavg.map" + " " + step2dir +
"/wflow_dem.map")
os.system(gdalstr + step1dir + "/demavg.map" + " " + step2dir +
"/wflow_demmin.map")
os.system(gdalstr + step1dir + "/demavg.map" + " " + step2dir +
"/wflow_demmax.map")
os.system(gdalstr + step1dir + "/gauges.map" + " " + step2dir +
"/wflow_gauges.map")
os.system(gdalstr + step1dir + "/rivers.map" + " " + step2dir +
"/wflow_river.map")
os.system(gdalstr + step1dir + "/streamorder.map" + " " + step2dir +
"/wflow_streamorder.map")
os.system(gdalstr + step1dir + "/gauges.map" + " " + step2dir +
"/wflow_outlet.map")
os.system(gdalstr + step1dir + "/scatch.map" + " " + step2dir +
"/wflow_catchment.map")
os.system(gdalstr + step1dir + "/ldd.map" + " " + step2dir +
"/wflow_ldd.map")
os.system(gdalstr + step1dir + "/scatch.map" + " " + step2dir +
"/wflow_subcatch.map")
if lu_water:
os.system(gdalstr + lu_water + " " + step2dir + "/WaterFrac.map")
if lu_paved:
os.system(gdalstr + lu_paved + " " + step2dir + "/PathFrac.map")
try:
lumap = config.get("files", "landuse")
except:
print("no landuse map...creating uniform map")
# clone=pcr.readmap(step2dir + "/wflow_dem.map")
pcr.setclone(step2dir + "/wflow_dem.map")
pcr.report(pcr.nominal(1), step2dir + "/wflow_landuse.map")
else:
os.system("resample --clone " + step2dir + "/wflow_dem.map " +
lumap + " " + step2dir + "/wflow_landuse.map")
try:
soilmap = config.get("files", "soil")
except:
print("no soil map..., creating uniform map")
pcr.setclone(step2dir + "/wflow_dem.map")
pcr.report(pcr.nominal(1), step2dir + "/wflow_soil.map")
else:
os.system("resample --clone " + step2dir + "/wflow_dem.map " +
soilmap + " " + step2dir + "/wflow_soil.map")
##################################
# Step 2 starts here
##################################
pcr.setclone(step2dir + "/cutout.map")
strRiver = int(configget(config, "settings", "riverorder_step2", "4"))
corevolume = float(configget(config, "settings", "corevolume", "1E35"))
catchmentprecipitation = float(
configget(config, "settings", "catchmentprecipitation", "1E35"))
corearea = float(configget(config, "settings", "corearea", "1E35"))
outflowdepth = float(
configget(config, "settings", "lddoutflowdepth", "1E35"))
lddmethod = configget(config, "settings", "lddmethod", "dem")
lddglobaloption = configget(config, "settings", "lddglobaloption",
"lddout")
pcr.setglobaloption(lddglobaloption)
nrrow = round(abs(Yul - Ylr) / csize)
nrcol = round(abs(Xlr - Xul) / csize)
mapstr = ("mapattr -s -S -R " + str(nrrow) + " -C " + str(nrcol) + " -l " +
str(csize) + " -x " + str(Xul) + " -y " + str(Yul) +
" -P yb2t " + step2dir + "/cutout.map")
os.system(mapstr)
pcr.setclone(step2dir + "/cutout.map")
lu_water = configget(config, "files", "lu_water", "")
lu_paved = configget(config, "files", "lu_paved", "")
if lu_water:
os.system("resample --clone " + step2dir + "/cutout.map " + lu_water +
" " + step2dir + "/wflow_waterfrac.map")
if lu_paved:
os.system("resample --clone " + step2dir + "/cutout.map " + lu_paved +
" " + step2dir + "/PathFrac.map")
#
try:
lumap = config.get("files", "landuse")
except:
print("no landuse map...creating uniform map")
clone = pcr.readmap(step2dir + "/cutout.map")
pcr.report(pcr.nominal(clone), step2dir + "/wflow_landuse.map")
else:
os.system("resample --clone " + step2dir + "/cutout.map " + lumap +
" " + step2dir + "/wflow_landuse.map")
try:
soilmap = config.get("files", "soil")
except:
print("no soil map..., creating uniform map")
clone = pcr.readmap(step2dir + "/cutout.map")
pcr.report(pcr.nominal(clone), step2dir + "/wflow_soil.map")
else:
os.system("resample --clone " + step2dir + "/cutout.map " + soilmap +
" " + step2dir + "/wflow_soil.map")
resamplemaps(step1dir, step2dir)
dem = pcr.readmap(step2dir + "/wflow_dem.map")
demmin = pcr.readmap(step2dir + "/wflow_demmin.map")
demmax = pcr.readmap(step2dir + "/wflow_demmax.map")
catchcut = pcr.readmap(step2dir + "/catchment_cut.map")
# now apply the area of interest (catchcut) to the DEM
# dem=pcr.ifthen(catchcut >=1 , dem)
#
# See if there is a shape file of the river to burn in
try:
rivshp = config.get("files", "river")
except:
print("no river file specified")
riverburn = pcr.readmap(step2dir + "/wflow_riverburnin.map")
else:
print("river file speficied.....")
rivshpattr = config.get("files", "riverattr")
pcr.report(dem * 0.0, step2dir + "/nilmap.map")
thestr = ("gdal_translate -of GTiff " + step2dir + "/nilmap.map " +
step2dir + "/wflow_riverburnin.tif")
os.system(thestr)
os.system("gdal_rasterize -burn 1 -l " + rivshpattr + " " + rivshp +
" " + step2dir + "/wflow_riverburnin.tif")
thestr = ("gdal_translate -of PCRaster " + step2dir +
"/wflow_riverburnin.tif " + step2dir +
"/wflow_riverburnin.map")
os.system(thestr)
riverburn = pcr.readmap(step2dir + "/wflow_riverburnin.map")
# ldddem = pcr.ifthenelse(riverburn >= 1.0, dem -1000 , dem)
# Only burn within the original catchment
riverburn = pcr.ifthen(pcr.scalar(catchcut) >= 1, riverburn)
# Now setup a very high wall around the catchment that is scale
# based on the distance to the catchment so that it slopes away from the
# catchment
if lddmethod != "river":
print("Burning in highres-river ...")
disttocatch = pcr.spread(pcr.nominal(catchcut), 0.0, 1.0)
demmax = pcr.ifthenelse(
pcr.scalar(catchcut) >= 1.0,
demmax,
demmax + (pcr.celllength() * 100.0) / disttocatch,
)
pcr.setglobaloption("unitcell")
demregional = pcr.windowaverage(demmin, 100)
demburn = pcr.cover(
pcr.ifthen(pcr.boolean(riverburn), demregional - 100.0), demmax)
else:
print("using average dem..")
demburn = dem
ldd = tr.lddcreate_save(
step2dir + "/ldd.map",
demburn,
True,
outflowdepth=outflowdepth,
corevolume=corevolume,
catchmentprecipitation=catchmentprecipitation,
corearea=corearea,
)
# Find catchment (overall)
outlet = tr.find_outlet(ldd)
sub = pcr.subcatch(ldd, outlet)
pcr.report(sub, step2dir + "/wflow_catchment.map")
pcr.report(outlet, step2dir + "/wflow_outlet.map")
# make river map
strorder = pcr.streamorder(ldd)
pcr.report(strorder, step2dir + "/wflow_streamorder.map")
river = pcr.ifthen(pcr.boolean(strorder >= strRiver), strorder)
pcr.report(river, step2dir + "/wflow_river.map")
# make subcatchments
# os.system("col2map --clone " + step2dir + "/cutout.map gauges.col " + step2dir + "/wflow_gauges.map")
exec("X=tr.array(" + gauges_x + ")")
exec("Y=tr.array(" + gauges_y + ")")
pcr.setglobaloption("unittrue")
outlmap = tr.points_to_map(dem, X, Y, 0.5)
pcr.report(outlmap, step2dir + "/wflow_gauges_.map")
if snapgaugestoriver:
print("Snapping gauges to river")
pcr.report(outlmap, step2dir + "/wflow_orggauges.map")
outlmap = tr.snaptomap(outlmap, river)
outlmap = pcr.ifthen(outlmap > 0, outlmap)
pcr.report(outlmap, step2dir + "/wflow_gauges.map")
scatch = pcr.subcatch(ldd, outlmap)
pcr.report(scatch, step2dir + "/wflow_subcatch.map")
def dynamic(self):
""" dynamic part of the water use module
init water use before sub step routing
"""
settings = LisSettings.instance()
option = settings.options
binding = settings.binding
maskinfo = MaskInfo.instance()
if option['wateruse']:
# ************************************************************
# ***** READ WATER DEMAND DATA *****************************
# ************************************************************
if option['TransientWaterDemandChange']:
if option['readNetcdfStack']:
if option['useWaterDemandAveYear']:
# using average year in NetCDF file format
self.var.DomesticDemandMM = readnetcdf(
binding['DomesticDemandMaps'],
self.var.currentTimeStep(),
timestampflag='closest',
averageyearflag=True) * self.var.DtDay
self.var.IndustrialDemandMM = readnetcdf(
binding['IndustrialDemandMaps'],
self.var.currentTimeStep(),
timestampflag='closest',
averageyearflag=True) * self.var.DtDay
self.var.LivestockDemandMM = readnetcdf(
binding['LivestockDemandMaps'],
self.var.currentTimeStep(),
timestampflag='closest',
averageyearflag=True) * self.var.DtDay
self.var.EnergyDemandMM = readnetcdf(
binding['EnergyDemandMaps'],
self.var.currentTimeStep(),
timestampflag='closest',
averageyearflag=True) * self.var.DtDay
else:
# Read from stack of maps in NetCDF format. Get time step corresponding to model step.
# added management for sub-daily model time steps
self.var.DomesticDemandMM = readnetcdf(
binding['DomesticDemandMaps'],
self.var.currentTimeStep(),
timestampflag='closest') * self.var.DtDay
self.var.IndustrialDemandMM = readnetcdf(
binding['IndustrialDemandMaps'],
self.var.currentTimeStep(),
timestampflag='closest') * self.var.DtDay
self.var.LivestockDemandMM = readnetcdf(
binding['LivestockDemandMaps'],
self.var.currentTimeStep(),
timestampflag='closest') * self.var.DtDay
self.var.EnergyDemandMM = readnetcdf(
binding['EnergyDemandMaps'],
self.var.currentTimeStep(),
timestampflag='closest') * self.var.DtDay
else:
# Read from stack of maps in Pcraster format
self.var.DomesticDemandMM = readmapsparse(
binding['DomesticDemandMaps'],
self.var.currentTimeStep(),
self.var.DomesticDemandMM) * self.var.DtDay
self.var.IndustrialDemandMM = readmapsparse(
binding['IndustrialDemandMaps'],
self.var.currentTimeStep(),
self.var.IndustrialDemandMM) * self.var.DtDay
self.var.LivestockDemandMM = readmapsparse(
binding['LivestockDemandMaps'],
self.var.currentTimeStep(),
self.var.LivestockDemandMM) * self.var.DtDay
self.var.EnergyDemandMM = readmapsparse(
binding['EnergyDemandMaps'],
self.var.currentTimeStep(),
self.var.EnergyDemandMM) * self.var.DtDay
# ************************************************************
# ***** LIVESTOCK ********************************************
# ************************************************************
self.var.LivestockAbstractionMM = self.var.LivestockDemandMM
self.var.LivestockConsumptiveUseMM = self.var.LivestockAbstractionMM * self.var.LivestockConsumptiveUseFraction
# the amount that is not returned to the hydrological cycle
LivestockAbstractionFromGroundwaterM3 = np.where(
self.var.GroundwaterBodies > 0,
self.var.FractionGroundwaterUsed *
self.var.LivestockConsumptiveUseMM * self.var.MMtoM3,
maskinfo.in_zero())
LivestockAbstractionFromNonConventionalWaterM3 = self.var.FractionNonConventionalWaterUsed * self.var.LivestockConsumptiveUseMM * self.var.MMtoM3
LivestockAbstractionFromSurfaceWaterM3 = self.var.LivestockConsumptiveUseMM * self.var.MMtoM3 - LivestockAbstractionFromGroundwaterM3 - LivestockAbstractionFromNonConventionalWaterM3
self.var.TotalLivestockAbstractionM3 += LivestockAbstractionFromGroundwaterM3 + LivestockAbstractionFromSurfaceWaterM3 + LivestockAbstractionFromNonConventionalWaterM3
# ************************************************************
# ***** DOMESTIC *********************************************
# ************************************************************
self.var.DomesticAbstractionMM = self.var.DomesticDemandMM * self.var.DomesticWaterSavingConstant * self.var.DomesticLeakageConstant
# Domestic Water Abstraction (mm per day), already taking into account water saving in households and leakage of the supply network
# Domestic water abstraction is larger if there is leakage, but is smaller if there is water savings
self.var.LeakageMM = (
self.var.DomesticLeakageConstant - 1
) * self.var.DomesticDemandMM * self.var.DomesticWaterSavingConstant
# Leakage in mm per day
self.var.LeakageLossMM = self.var.LeakageMM * self.var.LeakageWaterLossFraction
# The leakage amount that is lost (evaporated)
self.var.LeakageSoilMM = self.var.LeakageMM - self.var.LeakageLossMM
self.var.DomesticConsumptiveUseMM = self.var.DomesticDemandMM * self.var.DomesticWaterSavingConstant * self.var.DomesticConsumptiveUseFraction + self.var.LeakageLossMM
# DomesticConsumptiveUseMM is the amount that disappears from the waterbalance
# Assumption here is that leakage is partially lost/evaporated (LeakageWaterLoss fraction)
DomAbstractionFromGroundwaterM3 = np.where(
self.var.GroundwaterBodies > 0,
self.var.FractionGroundwaterUsed *
self.var.DomesticConsumptiveUseMM * self.var.MMtoM3,
maskinfo.in_zero())
DomAbstractionFromNonConventionalWaterM3 = self.var.FractionNonConventionalWaterUsed * self.var.DomesticConsumptiveUseMM * self.var.MMtoM3
DomAbstractionFromSurfaceWaterM3 = self.var.DomesticConsumptiveUseMM * self.var.MMtoM3 - DomAbstractionFromGroundwaterM3 - DomAbstractionFromNonConventionalWaterM3
# ************************************************************
# ***** INDUSTRY *********************************************
# ************************************************************
self.var.IndustrialAbstractionMM = self.var.IndustrialDemandMM * (
1 - self.var.WaterReUseFraction)
self.var.IndustrialConsumptiveUseMM = self.var.IndustrialAbstractionMM * self.var.IndustryConsumptiveUseFraction
# IndustrialAbstractionMM = scalar(timeinputsparse(IndustrialAbstractionMaps)) * (1-WaterReUseFraction);
# Industrial Water Demand (mm per day)
# WaterReUseFraction: Fraction of water re-used in industry (e.g. 50% = 0.5 = half of the water is re-used, used twice (baseline=0, maximum=1)
# IndustrialConsumptiveUseMM is the amount that evaporates etc
# only 1 map so this one is loaded in initial!
IndustrialWaterAbstractionM3 = self.var.IndustrialConsumptiveUseMM * self.var.MMtoM3
IndustrialAbstractionFromGroundwaterM3 = np.where(
self.var.GroundwaterBodies > 0,
self.var.FractionGroundwaterUsed *
IndustrialWaterAbstractionM3, maskinfo.in_zero())
IndustrialAbstractionFromNonConventionalWaterM3 = self.var.FractionNonConventionalWaterUsed * IndustrialWaterAbstractionM3
IndustrialAbstractionFromSurfaceWaterM3 = IndustrialWaterAbstractionM3 - IndustrialAbstractionFromGroundwaterM3 - IndustrialAbstractionFromNonConventionalWaterM3
# ************************************************************
# ***** ENERGY ***********************************************
# ************************************************************
self.var.EnergyAbstractionMM = self.var.EnergyDemandMM
self.var.EnergyConsumptiveUseMM = self.var.EnergyAbstractionMM * self.var.EnergyConsumptiveUseFraction
# EnergyConsumptiveUseMM is the amount that evaporates etc
EnergyAbstractionFromSurfaceWaterM3 = self.var.EnergyConsumptiveUseMM * self.var.MMtoM3
# all taken from surface water
# ************************************************************
# ***** IRRIGATION *******************************************
# ************************************************************
# water demand from loop3 = irrigated zone
self.var.Ta[2] = np.maximum(
np.minimum(self.var.RWS[2] * self.var.TranspirMaxCorrected,
self.var.W1[2] - self.var.WWP1[2]),
maskinfo.in_zero())
IrrigationWaterDemandMM = (
self.var.TranspirMaxCorrected -
self.var.Ta[2]) * self.var.IrrigationMult
# a factor (IrrigationMult) add some water (to prevent salinisation)
# irrigationWaterNeed assumed to be equal to potential transpiration minus actual transpiration
# in mm here, assumed for the entire pixel, thus later to be corrected with IrrigationFraction
# IrrigationType (value between 0 and 1) is used here to distinguish between additional adding water until fieldcapacity (value set to 1) or not (value set to 0)
IrrigationWaterDemandMM = np.where(
self.var.FrostIndex > self.var.FrostIndexThreshold,
maskinfo.in_zero(), IrrigationWaterDemandMM)
# IrrigationWaterDemand is 0 when soil is frozen
IrrigationWaterAbstractionMM = np.where(
(self.var.IrrigationEfficiency * self.var.ConveyanceEfficiency)
> 0, IrrigationWaterDemandMM * self.var.IrrigationFraction /
(self.var.IrrigationEfficiency *
self.var.ConveyanceEfficiency), maskinfo.in_zero())
self.var.IrrigationWaterAbstractionM3 = np.maximum(
IrrigationWaterAbstractionMM * self.var.MMtoM3,
maskinfo.in_zero())
# irrigation efficiency max 1, ~0.90 drip irrigation, ~0.75 sprinkling
# conveyance efficiency, around 0.80 for average channel
# multiplied by actual irrigated area (fraction) and cellsize(MMtoM3) in M3 per pixel
IrrigationAbstractionFromGroundwaterM3 = np.where(
self.var.GroundwaterBodies > 0,
self.var.FractionGroundwaterUsed *
self.var.IrrigationWaterAbstractionM3, maskinfo.in_zero())
IrrigationAbstractionFromSurfaceWaterM3 = np.maximum(
self.var.IrrigationWaterAbstractionM3 -
IrrigationAbstractionFromGroundwaterM3, maskinfo.in_zero())
# ************************************************************
# ***** TOTAL ABSTRACTIONS (DEMANDED) ************************
# ************************************************************
self.var.TotalAbstractionFromGroundwaterM3 = IrrigationAbstractionFromGroundwaterM3 + DomAbstractionFromGroundwaterM3 + LivestockAbstractionFromGroundwaterM3 + IndustrialAbstractionFromGroundwaterM3
self.var.TotalAbstractionFromSurfaceWaterM3 = IrrigationAbstractionFromSurfaceWaterM3 + self.var.PaddyRiceWaterAbstractionFromSurfaceWaterM3 + DomAbstractionFromSurfaceWaterM3 + LivestockAbstractionFromSurfaceWaterM3 + IndustrialAbstractionFromSurfaceWaterM3 + EnergyAbstractionFromSurfaceWaterM3
PaddyRiceWaterAbstractionFromSurfaceWaterMM = self.var.PaddyRiceWaterAbstractionFromSurfaceWaterM3 * self.var.M3toMM
# taken from paddy rice routine
self.var.TotalDemandM3 = (
self.var.LivestockAbstractionMM +
self.var.DomesticAbstractionMM + IrrigationWaterAbstractionMM +
PaddyRiceWaterAbstractionFromSurfaceWaterMM +
self.var.IndustrialAbstractionMM +
self.var.EnergyAbstractionMM) * self.var.MMtoM3
self.var.TotalIrrigationAbstractionM3 += IrrigationAbstractionFromGroundwaterM3 + IrrigationAbstractionFromSurfaceWaterM3
self.var.TotalPaddyRiceIrrigationAbstractionM3 += self.var.PaddyRiceWaterAbstractionFromSurfaceWaterM3
# totals calculated for reporting, for comparing with national reported values and possible calibration
# ************************************************************
# ***** ABSTRACTION FROM GROUNDWATER *************************
# ************************************************************
self.var.LZ = self.var.LZ - self.var.TotalAbstractionFromGroundwaterM3 * self.var.M3toMM
self.var.IrriLossCUM = self.var.IrriLossCUM + self.var.TotalAbstractionFromGroundwaterM3
# Abstraction is taken from lower groundwater zone
# for mass balance calculation also summed up in IrrilossCUM (in M3)
# ***********************************************************************
# ***** ABSTRACTION SUPPLIED BY NONCONVENTIONAL SOURCES (DESALINATION) **
# ***********************************************************************
self.var.NonConventionalWaterM3 = DomAbstractionFromNonConventionalWaterM3 + LivestockAbstractionFromNonConventionalWaterM3 + IndustrialAbstractionFromNonConventionalWaterM3
# Non conventional water producted is not abstracted from surface water
# ************************************************************
# ***** ABSTRACTION FROM LAKES AND RESERVOIRS ****************
# ************************************************************
if option['simulateReservoirs']:
# PotentialAbstractionFromReservoirsM3 = np.minimum(0.02 * self.var.ReservoirStorageM3, 0.01*self.var.TotalReservoirStorageM3C) #original
PotentialAbstractionFromReservoirsM3 = np.minimum(
0.02 * self.var.ReservoirStorageM3,
0.01 * self.var.TotalReservoirStorageM3C) * self.var.DtDay
PotentialAbstractionFromReservoirsM3 = np.where(
np.isnan(PotentialAbstractionFromReservoirsM3), 0,
PotentialAbstractionFromReservoirsM3)
else:
PotentialAbstractionFromReservoirsM3 = maskinfo.in_zero()
if option['simulateLakes']:
# CM
# PotentialAbstractionFromLakesM3 = 0.10 * self.var.LakeStorageM3 #original
PotentialAbstractionFromLakesM3 = 0.10 * self.var.LakeStorageM3 * self.var.DtDay
PotentialAbstractionFromLakesM3 = np.where(
np.isnan(PotentialAbstractionFromLakesM3), 0,
PotentialAbstractionFromLakesM3)
else:
PotentialAbstractionFromLakesM3 = maskinfo.in_zero()
if option['simulateReservoirs'] or option['simulateLakes']:
PotentialAbstractionFromLakesAndReservoirsM3 = PotentialAbstractionFromLakesM3 + PotentialAbstractionFromReservoirsM3
# potential total m3 that can be extracted from all lakes and reservoirs in a pixel
else:
PotentialAbstractionFromLakesAndReservoirsM3 = maskinfo.in_zero(
)
AreatotalPotentialAbstractionFromLakesAndReservoirsM3 = np.take(
np.bincount(
self.var.WUseRegionC,
weights=PotentialAbstractionFromLakesAndReservoirsM3),
self.var.WUseRegionC)
# potential total m3 that can be extracted from all lakes and reservoirs in the water region
AreatotalWaterAbstractionFromAllSurfaceSourcesM3 = np.take(
np.bincount(
self.var.WUseRegionC,
weights=self.var.TotalAbstractionFromSurfaceWaterM3),
self.var.WUseRegionC)
# the total amount that needs to be extracted from surface water, lakes and reservoirs in the water region
# self.var.FractionAllSurfaceWaterUsed = np.maximum(1 - self.var.FractionGroundwaterUsed - self.var.FractionNonConventionalWaterUsed,maskinfo.in_zero())
# self.var.FractionSurfaceWaterUsed = np.maximum(1 - self.var.FractionGroundwaterUsed - self.var.FractionNonConventionalWaterUsed-self.var.FractionLakeReservoirWaterUsed,maskinfo.in_zero())
# AreatotalWaterToBeAbstractedfromLakesReservoirsM3 = np.where( (self.var.FractionSurfaceWaterUsed+self.var.FractionLakeReservoirWaterUsed)> 0, (self.var.FractionLakeReservoirWaterUsed / (self.var.FractionSurfaceWaterUsed+self.var.FractionLakeReservoirWaterUsed)) * AreatotalWaterAbstractionFromAllSurfaceSourcesM3,maskinfo.in_zero())
AreatotalWaterToBeAbstractedfromLakesReservoirsM3 = self.var.FractionLakeReservoirWaterUsed * AreatotalWaterAbstractionFromAllSurfaceSourcesM3
self.var.AreatotalWaterAbstractedfromLakesReservoirsM3 = np.minimum(
AreatotalWaterToBeAbstractedfromLakesReservoirsM3,
AreatotalPotentialAbstractionFromLakesAndReservoirsM3)
# total amount of m3 abstracted from all lakes and reservoirs in the water regions
FractionAbstractedByLakesReservoirs = np.where(
AreatotalWaterAbstractionFromAllSurfaceSourcesM3 > 0,
self.var.AreatotalWaterAbstractedfromLakesReservoirsM3 /
AreatotalWaterAbstractionFromAllSurfaceSourcesM3,
maskinfo.in_zero())
self.var.TotalAbstractionFromSurfaceWaterM3 = self.var.TotalAbstractionFromSurfaceWaterM3 * (
1 - FractionAbstractedByLakesReservoirs)
# the original surface water abstraction amount is corrected for what is now already abstracted by lakes and reservoirs
FractionLakesReservoirsEmptying = np.where(
AreatotalPotentialAbstractionFromLakesAndReservoirsM3 > 0,
self.var.AreatotalWaterAbstractedfromLakesReservoirsM3 /
AreatotalPotentialAbstractionFromLakesAndReservoirsM3,
maskinfo.in_zero())
self.var.LakeAbstractionM3 = PotentialAbstractionFromLakesM3 * FractionLakesReservoirsEmptying
if option['simulateLakes']:
self.var.LakeStorageM3 = self.var.LakeStorageM3 - self.var.LakeAbstractionM3
self.var.ReservoirAbstractionM3 = PotentialAbstractionFromReservoirsM3 * FractionLakesReservoirsEmptying
if option['simulateReservoirs']:
self.var.ReservoirStorageM3 = self.var.ReservoirStorageM3 - self.var.ReservoirAbstractionM3
# subtract abstracted water from lakes and reservoir storage
# ************************************************************
# ***** Abstraction from channels ****************************
# ***** average abstraction taken from entire waterregion ****
# ***** limited by available channel water and e-flow minimum*
# ************************************************************
AreaTotalDemandedAbstractionFromSurfaceWaterM3 = np.maximum(
np.take(
np.bincount(
self.var.WUseRegionC,
weights=self.var.TotalAbstractionFromSurfaceWaterM3),
self.var.WUseRegionC), 0)
PixelAvailableWaterFromChannelsM3 = np.maximum(
self.var.ChanM3Kin - self.var.EFlowThreshold * self.var.DtSec,
0) * (1 - self.var.WUsePercRemain)
# respecting e-flow
AreaTotalAvailableWaterFromChannelsM3 = np.maximum(
np.take(
np.bincount(self.var.WUseRegionC,
weights=PixelAvailableWaterFromChannelsM3),
self.var.WUseRegionC), 0)
AreaTotalDemandedWaterFromChannelsM3 = np.minimum(
AreaTotalAvailableWaterFromChannelsM3,
AreaTotalDemandedAbstractionFromSurfaceWaterM3)
self.var.FractionAbstractedFromChannels = np.where(
AreaTotalAvailableWaterFromChannelsM3 > 0,
np.minimum(
AreaTotalDemandedWaterFromChannelsM3 /
AreaTotalAvailableWaterFromChannelsM3, 1), 0)
# IS THE DEFINITION OF AreaTotalDemandedWaterFromChannelsM3 REDUNDANT WITH np.minimum(...) ABOVE?
# fraction that is abstracted from channels (should be 0-1)
self.var.WUseAddM3 = self.var.FractionAbstractedFromChannels * PixelAvailableWaterFromChannelsM3
# pixel abstracted water in m3
self.var.WUseAddM3Dt = self.var.WUseAddM3 * self.var.InvNoRoutSteps
# splitting water use per timestep into water use per sub time step
self.var.wateruseCum += self.var.WUseAddM3
# summing up for water balance calculation
# If report wateruse
if (option['repwateruseGauges']) or (option['repwateruseSites']):
self.var.WUseSumM3 = accuflux(
self.var.Ldd,
decompress(self.var.WUseAddM3) * self.var.InvDtSec)
# totalAdd = areatotal(decompress(WUseAddM3),self.var.WUseRegion);
self.var.totalAddM3 = np.take(
np.bincount(self.var.WUseRegionC, weights=self.var.WUseAddM3),
self.var.WUseRegionC)
self.var.WaterUseShortageM3 = self.var.TotalAbstractionFromSurfaceWaterM3 - self.var.WUseAddM3
# amount of M3 that cannot be extracted from any source, including the channels
self.var.PotentialSurfaceWaterAvailabilityForIrrigationM3 = np.maximum(
PixelAvailableWaterFromChannelsM3 -
self.var.TotalAbstractionFromSurfaceWaterM3 +
IrrigationAbstractionFromSurfaceWaterM3 +
self.var.PaddyRiceWaterAbstractionFromSurfaceWaterM3, 0.0)
# available water excluding the surface water irrigation needs
# ************************************************************
# ***** Water Allocation *************************************
# ***** average abstraction taken from entire waterregion ****
# ***** limited by available channel water and e-flow minimum*
# ************************************************************
# totalAbstr = areatotal(decompress(TotalAbstractionFromSurfaceWaterM3),self.var.WUseRegion)
self.var.AreaTotalAbstractionFromSurfaceWaterM3 = np.take(
np.bincount(
self.var.WUseRegionC,
weights=self.var.TotalAbstractionFromSurfaceWaterM3 -
self.var.WUseAddM3), self.var.WUseRegionC)
self.var.AreaTotalAbstractionFromGroundwaterM3 = np.take(
np.bincount(
self.var.WUseRegionC,
weights=self.var.TotalAbstractionFromGroundwaterM3),
self.var.WUseRegionC)
# demand
self.var.AreaTotalDemandM3 = np.take(
np.bincount(self.var.WUseRegionC,
weights=self.var.TotalDemandM3),
self.var.WUseRegionC)
# totalEne = areatotal(decompress(self.var.EnergyConsumptiveUseMM*self.var.MMtoM3),self.var.WUseRegion)
AreatotalIrriM3 = np.take(
np.bincount(
self.var.WUseRegionC,
weights=IrrigationAbstractionFromSurfaceWaterM3 +
self.var.PaddyRiceWaterAbstractionFromSurfaceWaterM3),
self.var.WUseRegionC)
# AreatotalDomM3 = np.take(np.bincount(self.var.WUseRegionC, weights=DomAbstractionFromSurfaceWaterM3),
# self.var.WUseRegionC)
# AreatotalLiveM3 = np.take(np.bincount(self.var.WUseRegionC, weights=LivestockAbstractionFromSurfaceWaterM3),
# self.var.WUseRegionC)
# AreatotalIndM3 = np.take(np.bincount(self.var.WUseRegionC, weights=IndustrialAbstractionFromSurfaceWaterM3),
# self.var.WUseRegionC)
# AreatotalEneM3 = np.take(np.bincount(self.var.WUseRegionC, weights=EnergyAbstractionFromSurfaceWaterM3),
# self.var.WUseRegionC)
# Allocation rule: Domestic -> Energy -> Livestock -> Industry -> Irrigation
self.var.AreatotalIrrigationShortageM3 = np.take(
np.bincount(self.var.WUseRegionC,
weights=self.var.WaterUseShortageM3),
self.var.WUseRegionC)
self.var.AreatotalIrrigationUseM3 = np.maximum(
AreatotalIrriM3 - self.var.AreatotalIrrigationShortageM3, 0.0)
with np.errstate(all='ignore'):
fractionIrrigationAvailability = np.where(
AreatotalIrriM3 > 0,
self.var.AreatotalIrrigationUseM3 / AreatotalIrriM3, 1.0)
self.var.IrrigationWaterAbstractionM3 = fractionIrrigationAvailability * IrrigationAbstractionFromSurfaceWaterM3 + IrrigationAbstractionFromGroundwaterM3
# real irrigation is percentage of avail/demand for waterregion * old surface + old groundwater abstraction
IrrigationWaterDemand = self.var.IrrigationWaterAbstractionM3 * self.var.M3toMM
IrrigationWaterDemand = np.where(
self.var.IrrigationFraction > 0,
IrrigationWaterDemand / self.var.IrrigationFraction, 0.0)
# for mass balance calculate the loss of irrigation water
# ---------------------------------------------------------
# updating soil in loop3=irrigation
# ---------------------------------------------------------
Wold = self.var.W1[2]
IrrigationDemandW1b = np.maximum(
IrrigationWaterDemand - (self.var.WFilla - self.var.W1a[2]), 0)
self.var.W1a[2] = np.where(
self.var.W1a[2] >= self.var.WFilla, self.var.W1a[2],
np.minimum(self.var.WFilla,
self.var.W1a[2] + IrrigationWaterDemand))
self.var.W1b[2] = np.where(
self.var.W1b[2] >= self.var.WFillb, self.var.W1b[2],
np.minimum(self.var.WFillb,
self.var.W1b[2] + IrrigationDemandW1b))
self.var.W1[2] = np.add(self.var.W1a[2], self.var.W1b[2])
# if irrigated soil is less than Pf3 then fill up to Pf3 (if there is water demand)
# if more than Pf3 the additional water is transpirated
# there is already no water demand if the soil is frozen
Wdiff = self.var.W1[2] - Wold
self.var.Ta[2] = self.var.Ta[2] + IrrigationWaterDemand - Wdiff
self.var.IrriLossCUM = self.var.IrriLossCUM - self.var.IrrigationWaterAbstractionM3 * self.var.IrrigationEfficiency * self.var.ConveyanceEfficiency - Wdiff * self.var.MMtoM3 * self.var.IrrigationFraction
# Added to TA but also
# for mass balance calculate the loss of irrigation water
# AdR: irrigation demand added to W1 and Ta; so assumption here that soil moisture stays the same
# we could also abstract more water equivalent to satisfy Ta and bring soil moisture to pF2 or so, for later consideration#
# self.var.Ta[2] = np.where(self.var.FrostIndex > self.var.FrostIndexThreshold, maskinfo.in_zero(), self.var.Ta[2])
# transpiration is 0 when soil is frozen
# ---------------------------------------------------------
# E-flow
# ---------------------------------------------------------
self.var.EFlowIndicator = np.where(
self.var.ChanQ <= self.var.EFlowThreshold,
maskinfo.in_zero() + 1.0, maskinfo.in_zero())
# if ChanQ is less than EflowThreshold, EFlowIndicator becomes 1
# ************************************************************
# ***** update state variables ***
# ************************************************************
# CM Update state variables for changes to W1a[2] and W1b[2]
self.var.Theta1a[2] = self.var.W1a[2] / self.var.SoilDepth1a[2]
self.var.Theta1b[2] = self.var.W1b[2] / self.var.SoilDepth1b[2]
# ************************************************************
# ***** smooth lower zone with correction ***
# ************************************************************
if option['groundwaterSmooth']:
LZPcr = decompress(self.var.LZ)
Range = self.var.LZSmoothRange * celllength()
LZTemp1 = ifthen(self.var.GroundwaterBodiesPcr == 1, LZPcr)
LZTemp2 = ifthen(self.var.GroundwaterBodiesPcr == 1,
windowtotal(LZTemp1, Range))
LZTemp3 = windowtotal(LZTemp1 * 0 + 1, Range)
LZSmooth = ifthenelse(LZTemp3 == 0, 0.0,
pcrDiv(LZTemp2, LZTemp3))
LZPcr = ifthenelse(self.var.GroundwaterBodiesPcr == 0, LZPcr,
0.9 * LZPcr + 0.1 * LZSmooth)
diffCorr = 0.1 * areaaverage(LZSmooth - LZTemp1,
self.var.groundwaterCatch)
# error of 0.1 LZSmooth operation (same factor of 0.1 as above)
LZPcr -= cover(diffCorr, 0)
# correction of LZ by the average error from smoothing operation
self.var.LZ = compressArray(LZPcr)
def initial(self):
""" initial part of the misc module
"""
settings = LisSettings.instance()
option = settings.options
binding = settings.binding
maskinfo = MaskInfo.instance()
maskattrs = MaskAttrs.instance()
if option['gridSizeUserDefined']:
# <lfoption name="gridSizeUserDefined" choice="1" default="0">
# If option gridsizeUserDefined is activated, users can specify grid size properties
# in separate maps. This is useful whenever this information cannot be derived from
# the location attributes of the base maps (e.g. lat/lon systems or non-equal-area
# projections)
# Limitation: always assumes square grid cells (not rectangles!). Size of grid cells
# may vary across map though
self.var.PixelLengthPcr = loadmap('PixelLengthUser', pcr=True)
self.var.PixelLength = compressArray(self.var.PixelLengthPcr)
# Length of pixel [m]
# Area of pixel [m2]
self.var.PixelAreaPcr = loadmap('PixelAreaUser', pcr=True)
self.var.PixelArea = compressArray(self.var.PixelAreaPcr)
else:
# Default behaviour: grid size is derived from location attributes of
# base maps. Requirements:
# - Maps are in some equal-area projection
# - Length units meters
# - All grid cells have the same size
# Length of pixel [m]
self.var.PixelLengthPcr = celllength()
self.var.PixelLength = maskattrs['cell']
# Area of pixel [m2]
self.var.PixelAreaPcr = self.var.PixelLength**2
self.var.PixelArea = np.empty(maskinfo.info.mapC)
self.var.PixelArea.fill(self.var.PixelLength**2)
# self.var.PixelArea = spatial(self.var.PixelArea)
# Convert to spatial expresion (otherwise this variable cannnot be
# used in areatotal function)
# -----------------------------------------------------------------
# Miscellaneous repeatedly used expressions (as suggested by GF)
self.var.InvPixelLength = 1.0 / self.var.PixelLength
# Inverse of pixel size [1/m]
self.var.DtSec = loadmap('DtSec')
self.var.DtDay = self.var.DtSec / 86400.
# Time step, expressed as fraction of day (used to convert
# rate variables that are expressed as a quantity per day to
# into an amount per time step)
self.var.InvDtSec = 1 / self.var.DtSec
# Inverse of time step [1/s]
self.var.InvDtDay = 1 / self.var.DtDay
# Inverse of time step [1/d]
self.var.DtSecChannel = loadmap('DtSecChannel')
# Sub time step used for kinematic wave channel routing [seconds]
# within the model,the smallest out of DtSecChannel and DtSec is used
self.var.MMtoM = 0.001
# Multiplier to convert wate depths in mm to meters
self.var.MtoMM = 1000
# Multiplier to convert wate depths in meters to mm
self.var.MMtoM3 = 0.001 * self.var.PixelArea
# self.var.MMtoM3=0.001*float(celllength())**2
# Multiplier to convert water depths in mm to cubic
# metres
self.var.M3toMM = 1 / self.var.MMtoM3
# Multiplier to convert from cubic metres to mm water slice
self.var.GwLoss = loadmap('GwLoss')
self.var.GwPerc = np.maximum(loadmap('GwPercValue'), self.var.GwLoss)
# new Gwloss PB 12.11.2009
# if GWloss > GwPercValue -> GwPerc = GwLoss
self.var.GwPercStep = self.var.GwPerc * self.var.DtDay
# Percolation from upper to lower groundwater zone, expressed as
# amount per time step
self.var.GwLossStep = self.var.GwLoss * self.var.DtDay
# change similar to GwPercStep
# ************************************************************
# ***** Some additional stuff
# ************************************************************
# date of the first possible model run
# computation of model steps is referred to CalendarStartDay
self.var.CalendarDayStart = calendar(binding['CalendarDayStart'],
binding['calendar_type'])
self.var.PrScaling = loadmap('PrScaling')
self.var.CalEvaporation = loadmap('CalEvaporation')
self.var.Precipitation = None
self.var.Tavg = None
self.var.ETRef = None
self.var.ESRef = None
self.var.EWRef = None
# setting meteo data to none - is this necessary?
self.var.DayCounter = 0.0
self.var.MonthETpot = maskinfo.in_zero()
self.var.MonthETact = maskinfo.in_zero()
self.var.MonthWDemand = maskinfo.in_zero()
self.var.MonthWUse = maskinfo.in_zero()
self.var.MonthWDemand = maskinfo.in_zero()
self.var.MonthDis = maskinfo.in_zero()
self.var.MonthInternalFlow = maskinfo.in_zero()
self.var.TotalInternalFlowM3 = maskinfo.in_zero()
self.var.PerMonthInternalFlowM3 = maskinfo.in_zero()
# total freshwater generated in the sub-area (m3), basically local P-ET-Storage
self.var.TotalExternalInflowM3 = maskinfo.in_zero()
self.var.PerMonthExternalInflowM3 = maskinfo.in_zero()
# Total channel inflow (m3) from inlet points
self.var.PerMonthWaterDemandM3 = maskinfo.in_zero()
self.var.PerMonthWaterUseM3 = maskinfo.in_zero()
self.var.FlagDemandBiggerUse = scalar(0.0)
self.var.TotWEI = scalar(0.0)
self.var.TotlWEI = scalar(0.0)
self.var.TotCount = scalar(0.0)
self.var.SumETpot = maskinfo.in_zero()
self.var.SumETpotact = maskinfo.in_zero()
# Read the latitude (radians) from the precipitation forcing NetCDF file
with xr.open_dataset(binding["PrecipitationMaps"] + ".nc") as nc:
if all([co in nc.dims for co in ("x", "y")]):
try:
# look for the projection variable
proj_var = [
v for v in nc.data_vars.keys()
if 'proj4_params' in nc[v].attrs.keys()
][0]
# proj4 string
proj4_params = nc[proj_var].attrs['proj4_params']
# projection object obtained from the PROJ4 string
except IndexError:
try:
proj4_params = binding['proj4_params']
except KeyError:
raise Exception(
"If using projected coordinates (x, y), a variable with the 'proj4_params' "
"attribute must be included in the precipitation file or in settings file!"
)
# projection object obtained from the PROJ4 string
projection = Proj(proj4_params)
_, lat_deg = projection(*coordinatesLand(
nc.x.values, nc.y.values),
inverse=True) # latitude (degrees)
else:
_, lat_deg = coordinatesLand(
nc.lon.values, nc.lat.values) # latitude (degrees)
self.var.lat_rad = np.radians(lat_deg) # latitude (radians)
def main():
"""
:ivar masterdem: digital elevation model
:ivar dem: digital elevation model
:ivar river: optional river map
"""
# Default values
strRiver = 8
masterdem = "dem.map"
step1dir = "step1"
step2dir = "step2"
workdir = "."
inifile = "wflow_prepare.ini"
recreate = False
snapgaugestoriver = False
try:
opts, args = getopt.getopt(sys.argv[1:], "W:hI:f",['version'])
except getopt.error as msg:
usage(msg)
for o, a in opts:
if o == "-W":
workdir = a
if o == "-I":
inifile = a
if o == "-h":
usage()
if o == "-f":
recreate = True
if o == "--version":
import wflow
print("wflow version: ", wflow.__version__)
sys.exit(0)
pcr.setglobaloption("unitcell")
os.chdir(workdir)
config = OpenConf(workdir + "/" + inifile)
masterdem = configget(config, "files", "masterdem", "dem.map")
pcr.setclone(masterdem)
strRiver = int(configget(config, "settings", "riverorder", "4"))
try:
gauges_x = config.get("settings", "gauges_x")
gauges_y = config.get("settings", "gauges_y")
except:
print("gauges_x and gauges_y are required entries in the ini file")
sys.exit(1)
step1dir = configget(config, "directories", "step1dir", "step1")
step2dir = configget(config, "directories", "step2dir", "step2")
# upscalefactor = float(config.get("settings","upscalefactor"))
corevolume = float(configget(config, "settings", "corevolume", "1E35"))
catchmentprecipitation = float(
configget(config, "settings", "catchmentprecipitation", "1E35")
)
corearea = float(configget(config, "settings", "corearea", "1E35"))
outflowdepth = float(configget(config, "settings", "lddoutflowdepth", "1E35"))
initialscale = int(configget(config, "settings", "initialscale", "1"))
csize = float(configget(config, "settings", "cellsize", "1"))
snapgaugestoriver = bool(
int(configget(config, "settings", "snapgaugestoriver", "1"))
)
lddglobaloption = configget(config, "settings", "lddglobaloption", "lddout")
pcr.setglobaloption(lddglobaloption)
lu_water = configget(config, "files", "lu_water", "")
lu_paved = configget(config, "files", "lu_paved", "")
# X/Y coordinates of the gauges the system
X = np.fromstring(gauges_x, sep=',')
Y = np.fromstring(gauges_y, sep=',')
tr.Verbose = 1
# make the directories to save results in
if not os.path.isdir(step1dir + "/"):
os.makedirs(step1dir)
if not os.path.isdir(step2dir):
os.makedirs(step2dir)
if initialscale > 1:
print("Initial scaling of DEM...")
os.system(
"resample -r "
+ str(initialscale)
+ " "
+ masterdem
+ " "
+ step1dir
+ "/dem_scaled.map"
)
print("Reading dem...")
dem = pcr.readmap(step1dir + "/dem_scaled.map")
ldddem = dem
else:
print ("Reading dem...")
dem = pcr.readmap(masterdem)
ldddem = dem
try:
catchmask = config.get("files", "catchment_mask")
except:
print("No catchment mask...")
else:
print("clipping DEM with mask.....")
mask = pcr.readmap(catchmask)
ldddem = pcr.ifthen(pcr.boolean(mask), ldddem)
dem = pcr.ifthen(pcr.boolean(mask), dem)
# See if there is a shape file of the river to burn in
try:
rivshp = config.get("files", "river")
except:
print("no river file specified")
outletpointX = float(configget(config, "settings", "outflowpointX", "0.0"))
outletpointY = float(configget(config, "settings", "outflowpointY", "0.0"))
else:
print("river file specified.....")
try:
outletpointX = float(configget(config, "settings", "outflowpointX", "0.0"))
outletpointY = float(configget(config, "settings", "outflowpointY", "0.0"))
except:
print(
"Need to specify the river outletpoint (a point at the end of the river within the current map)"
)
exit(1)
outletpointmap = tr.points_to_map(dem, outletpointX, outletpointY, 0.5)
pcr.report(outletpointmap, step1dir + "/outletpoint.map")
# rivshpattr = config.get("files","riverattr")
pcr.report(dem * 0.0, step1dir + "/nilmap.map")
thestr = (
"gdal_translate -of GTiff "
+ step1dir
+ "/nilmap.map "
+ step1dir
+ "/riverburn.tif"
)
os.system(thestr)
rivshpattr = os.path.splitext(os.path.basename(rivshp))[0]
os.system(
"gdal_rasterize -burn 1 -l "
+ rivshpattr
+ " "
+ rivshp
+ " "
+ step1dir
+ "/riverburn.tif"
)
thestr = (
"gdal_translate -of PCRaster "
+ step1dir
+ "/riverburn.tif "
+ step1dir
+ "/riverburn.map"
)
os.system(thestr)
riverburn = pcr.readmap(step1dir + "/riverburn.map")
# Determine regional slope assuming that is the way the river should run
# Determine regional slope assuming that is the way the river should run
# pcr.setglobaloption("unitcell")
# demregional=pcr.windowaverage(dem,100)
ldddem = pcr.ifthenelse(riverburn >= 1.0, dem - 1000, dem)
pcr.setglobaloption("unittrue")
upscalefactor = int(csize / pcr.celllength())
print("Creating ldd...")
ldd = tr.lddcreate_save(
step1dir + "/ldd.map",
ldddem,
recreate,
outflowdepth=outflowdepth,
corevolume=corevolume,
catchmentprecipitation=catchmentprecipitation,
corearea=corearea,
)
print("Determining streamorder...")
stro = pcr.streamorder(ldd)
pcr.report(stro, step1dir + "/streamorder.map")
strdir = pcr.ifthen(stro >= strRiver, stro)
pcr.report(strdir, step1dir + "/streamorderrive.map")
pcr.report(pcr.boolean(pcr.ifthen(stro >= strRiver, stro)), step1dir + "/rivers.map")
pcr.setglobaloption("unittrue")
# outlet (and other gauges if given)
# TODO: check is x/y set if not skip this
print("Outlet...")
outlmap = tr.points_to_map(dem, X, Y, 0.5)
if snapgaugestoriver:
print("Snapping gauges to nearest river cells...")
pcr.report(outlmap, step1dir + "/orggauges.map")
outlmap = tr.snaptomap(outlmap, strdir)
# noutletmap = tr.points_to_map(dem,XX,YY,0.5)
# pcr.report(noutletmap,'noutlet.map')
pcr.report(outlmap, step1dir + "/gauges.map")
# check if there is a pre-define catchment map
try:
catchmask = config.get("files", "catchment_mask")
except:
print("No catchment mask, finding outlet")
# Find catchment (overall)
outlet = tr.find_outlet(ldd)
sub = tr.subcatch(ldd, outlet)
pcr.report(sub, step1dir + "/catchment_overall.map")
else:
print("reading and converting catchment mask.....")
os.system(
"resample -r "
+ str(initialscale)
+ " "
+ catchmask
+ " "
+ step1dir
+ "/catchment_overall.map"
)
sub = pcr.readmap(step1dir + "/catchment_overall.map")
print("Scatch...")
sd = tr.subcatch(ldd, pcr.ifthen(outlmap > 0, outlmap))
pcr.report(sd, step1dir + "/scatch.map")
pcr.setglobaloption("unitcell")
print("Upscalefactor: " + str(upscalefactor))
if upscalefactor > 1:
gc.collect()
print("upscale river length1 (checkerboard map)...")
ck = tr.checkerboard(dem, upscalefactor)
pcr.report(ck, step1dir + "/ck.map")
pcr.report(dem, step1dir + "/demck.map")
print("upscale river length2...")
fact = tr.area_riverlength_factor(ldd, ck, upscalefactor)
pcr.report(fact, step1dir + "/riverlength_fact.map")
# print("make dem statistics...")
dem_ = pcr.areaaverage(dem, ck)
pcr.report(dem_, step1dir + "/demavg.map")
print("Create DEM statistics...")
dem_ = pcr.areaminimum(dem, ck)
pcr.report(dem_, step1dir + "/demmin.map")
dem_ = pcr.areamaximum(dem, ck)
pcr.report(dem_, step1dir + "/demmax.map")
# calculate percentiles
order = pcr.areaorder(dem, ck)
n = pcr.areatotal(pcr.spatial(pcr.scalar(1.0)), ck)
#: calculate 25 percentile
perc = tr.area_percentile(dem, ck, n, order, 25.0)
pcr.report(perc, step1dir + "/dem25.map")
perc = tr.area_percentile(dem, ck, n, order, 10.0)
pcr.report(perc, step1dir + "/dem10.map")
perc = tr.area_percentile(dem, ck, n, order, 50.0)
pcr.report(perc, step1dir + "/dem50.map")
perc = tr.area_percentile(dem, ck, n, order, 33.0)
pcr.report(perc, step1dir + "/dem33.map")
perc = tr.area_percentile(dem, ck, n, order, 66.0)
pcr.report(perc, step1dir + "/dem66.map")
perc = tr.area_percentile(dem, ck, n, order, 75.0)
pcr.report(perc, step1dir + "/dem75.map")
perc = tr.area_percentile(dem, ck, n, order, 90.0)
pcr.report(perc, step1dir + "/dem90.map")
else:
print("No fancy scaling done. Going strait to step2....")
pcr.report(dem, step1dir + "/demavg.map")
Xul = float(config.get("settings", "Xul"))
Yul = float(config.get("settings", "Yul"))
Xlr = float(config.get("settings", "Xlr"))
Ylr = float(config.get("settings", "Ylr"))
gdalstr = (
"gdal_translate -projwin "
+ str(Xul)
+ " "
+ str(Yul)
+ " "
+ str(Xlr)
+ " "
+ str(Ylr)
+ " -of PCRaster "
)
# gdalstr = "gdal_translate -a_ullr " + str(Xul) + " " + str(Yul) + " " +str(Xlr) + " " +str(Ylr) + " -of PCRaster "
print(gdalstr)
pcr.report(pcr.cover(1.0), step1dir + "/wflow_riverlength_fact.map")
# Now us gdat tp convert the maps
os.system(
gdalstr
+ step1dir
+ "/wflow_riverlength_fact.map"
+ " "
+ step2dir
+ "/wflow_riverlength_fact.map"
)
os.system(
gdalstr + step1dir + "/demavg.map" + " " + step2dir + "/wflow_dem.map"
)
os.system(
gdalstr + step1dir + "/demavg.map" + " " + step2dir + "/wflow_demmin.map"
)
os.system(
gdalstr + step1dir + "/demavg.map" + " " + step2dir + "/wflow_demmax.map"
)
os.system(
gdalstr + step1dir + "/gauges.map" + " " + step2dir + "/wflow_gauges.map"
)
os.system(
gdalstr + step1dir + "/rivers.map" + " " + step2dir + "/wflow_river.map"
)
os.system(
gdalstr
+ step1dir
+ "/streamorder.map"
+ " "
+ step2dir
+ "/wflow_streamorder.map"
)
os.system(
gdalstr + step1dir + "/gauges.map" + " " + step2dir + "/wflow_outlet.map"
)
os.system(
gdalstr + step1dir + "/scatch.map" + " " + step2dir + "/wflow_catchment.map"
)
os.system(gdalstr + step1dir + "/ldd.map" + " " + step2dir + "/wflow_ldd.map")
os.system(
gdalstr + step1dir + "/scatch.map" + " " + step2dir + "/wflow_subcatch.map"
)
if lu_water:
os.system(gdalstr + lu_water + " " + step2dir + "/WaterFrac.map")
if lu_paved:
os.system(gdalstr + lu_paved + " " + step2dir + "/PathFrac.map")
try:
lumap = config.get("files", "landuse")
except:
print("no landuse map...creating uniform map")
# clone=pcr.readmap(step2dir + "/wflow_dem.map")
pcr.setclone(step2dir + "/wflow_dem.map")
pcr.report(pcr.nominal(1), step2dir + "/wflow_landuse.map")
else:
os.system(
"resample --clone "
+ step2dir
+ "/wflow_dem.map "
+ lumap
+ " "
+ step2dir
+ "/wflow_landuse.map"
)
try:
soilmap = config.get("files", "soil")
except:
print("no soil map..., creating uniform map")
pcr.setclone(step2dir + "/wflow_dem.map")
pcr.report(pcr.nominal(1), step2dir + "/wflow_soil.map")
else:
os.system(
"resample --clone "
+ step2dir
+ "/wflow_dem.map "
+ soilmap
+ " "
+ step2dir
+ "/wflow_soil.map"
)
def calc_buffer_size(radius_metres): return radius_metres / int(pcr.celllength())
def main():
"""
"""
workdir = "."
inifile = "wflow_prepare.ini"
try:
opts, args = getopt.getopt(sys.argv[1:], "W:hI:f", ['version'])
except getopt.error as msg:
usage(msg)
for o, a in opts:
if o == "-W":
workdir = a
if o == "-I":
inifile = a
if o == "-h":
usage()
if o == "-f":
recreate = True
if o == "--version":
import wflow
print("wflow version: ", wflow.__version__)
sys.exit(0)
os.chdir(workdir)
config = OpenConf(workdir + "/" + inifile)
step1dir = configget(config, "directories", "step1dir", "step1")
step2dir = configget(config, "directories", "step2dir", "step2")
snapgaugestoriver = bool(
int(configget(config, "settings", "snapgaugestoriver", "1"))
)
# make the directories to save results in
if not os.path.isdir(step1dir + "/"):
os.makedirs(step1dir)
if not os.path.isdir(step2dir):
os.makedirs(step2dir)
##first make the clone map
try:
Xul = float(config.get("settings", "Xul"))
Yul = float(config.get("settings", "Yul"))
Xlr = float(config.get("settings", "Xlr"))
Ylr = float(config.get("settings", "Ylr"))
except:
print("Xul, Xul, Xlr and Ylr are required entries in the ini file")
sys.exit(1)
csize = float(configget(config, "settings", "cellsize", "1"))
try:
gauges_x = config.get("settings", "gauges_x")
gauges_y = config.get("settings", "gauges_y")
except:
print("gauges_x and gauges_y are required entries in the ini file")
sys.exit(1)
strRiver = int(configget(config, "settings", "riverorder_step2", "4"))
corevolume = float(configget(config, "settings", "corevolume", "1E35"))
catchmentprecipitation = float(
configget(config, "settings", "catchmentprecipitation", "1E35")
)
corearea = float(configget(config, "settings", "corearea", "1E35"))
outflowdepth = float(configget(config, "settings", "lddoutflowdepth", "1E35"))
lddmethod = configget(config, "settings", "lddmethod", "dem")
lddglobaloption = configget(config, "settings", "lddglobaloption", "lddout")
pcr.setglobaloption(lddglobaloption)
nrrow = round(abs(Yul - Ylr) / csize)
nrcol = round(abs(Xlr - Xul) / csize)
mapstr = (
"mapattr -s -S -R "
+ str(nrrow)
+ " -C "
+ str(nrcol)
+ " -l "
+ str(csize)
+ " -x "
+ str(Xul)
+ " -y "
+ str(Yul)
+ " -P yb2t "
+ step2dir
+ "/cutout.map"
)
os.system(mapstr)
pcr.setclone(step2dir + "/cutout.map")
lu_water = configget(config, "files", "lu_water", "")
lu_paved = configget(config, "files", "lu_paved", "")
if lu_water:
os.system(
"resample --clone "
+ step2dir
+ "/cutout.map "
+ lu_water
+ " "
+ step2dir
+ "/wflow_waterfrac.map"
)
if lu_paved:
os.system(
"resample --clone "
+ step2dir
+ "/cutout.map "
+ lu_paved
+ " "
+ step2dir
+ "/PathFrac.map"
)
#
try:
lumap = config.get("files", "landuse")
except:
print("no landuse map...creating uniform map")
clone = pcr.readmap(step2dir + "/cutout.map")
pcr.report(pcr.nominal(clone), step2dir + "/wflow_landuse.map")
else:
os.system(
"resample --clone "
+ step2dir
+ "/cutout.map "
+ lumap
+ " "
+ step2dir
+ "/wflow_landuse.map"
)
try:
soilmap = config.get("files", "soil")
except:
print("no soil map..., creating uniform map")
clone = pcr.readmap(step2dir + "/cutout.map")
pcr.report(pcr.nominal(clone), step2dir + "/wflow_soil.map")
else:
os.system(
"resample --clone "
+ step2dir
+ "/cutout.map "
+ soilmap
+ " "
+ step2dir
+ "/wflow_soil.map"
)
resamplemaps(step1dir, step2dir)
dem = pcr.readmap(step2dir + "/wflow_dem.map")
demmin = pcr.readmap(step2dir + "/wflow_demmin.map")
demmax = pcr.readmap(step2dir + "/wflow_demmax.map")
# catchcut = pcr.readmap(step2dir + "/catchment_cut.map")
catchcut = pcr.readmap(step2dir + "/cutout.map")
# now apply the area of interest (catchcut) to the DEM
# dem=pcr.ifthen(catchcut >=1 , dem)
#
# See if there is a shape file of the river to burn in
try:
rivshp = config.get("files", "river")
except:
print("no river file specified")
riverburn = pcr.readmap(step2dir + "/wflow_riverburnin.map")
else:
print("river file speficied.....")
# rivshpattr = config.get("files","riverattr")
pcr.report(dem * 0.0, step2dir + "/nilmap.map")
thestr = (
"gdal_translate -of GTiff "
+ step2dir
+ "/nilmap.map "
+ step2dir
+ "/wflow_riverburnin.tif"
)
os.system(thestr)
rivshpattr = os.path.splitext(os.path.basename(rivshp))[0]
os.system(
"gdal_rasterize -burn 1 -l "
+ rivshpattr
+ " "
+ rivshp
+ " "
+ step2dir
+ "/wflow_riverburnin.tif"
)
thestr = (
"gdal_translate -of PCRaster "
+ step2dir
+ "/wflow_riverburnin.tif "
+ step2dir
+ "/wflow_riverburnin.map"
)
os.system(thestr)
riverburn = pcr.readmap(step2dir + "/wflow_riverburnin.map")
# ldddem = pcr.ifthenelse(riverburn >= 1.0, dem -1000 , dem)
# Only burn within the original catchment
riverburn = pcr.ifthen(pcr.scalar(catchcut) >= 1, riverburn)
# Now setup a very high wall around the catchment that is scale
# based on the distance to the catchment so that it slopes away from the
# catchment
if lddmethod != "river":
print("Burning in highres-river ...")
disttocatch = pcr.spread(pcr.nominal(catchcut), 0.0, 1.0)
demmax = pcr.ifthenelse(
pcr.scalar(catchcut) >= 1.0,
demmax,
demmax + (pcr.celllength() * 100.0) / disttocatch,
)
pcr.setglobaloption("unitcell")
# demregional=pcr.windowaverage(demmin,100)
demburn = pcr.cover(pcr.ifthen(pcr.boolean(riverburn), demmin - 100.0), demmax)
else:
print("using average dem..")
demburn = dem
ldd = tr.lddcreate_save(
step2dir + "/wflow_ldd.map",
demburn,
True,
outflowdepth=outflowdepth,
corevolume=corevolume,
catchmentprecipitation=catchmentprecipitation,
corearea=corearea,
)
# Find catchment (overall)
outlet = tr.find_outlet(ldd)
sub = tr.subcatch(ldd, outlet)
pcr.report(sub, step2dir + "/wflow_catchment.map")
pcr.report(outlet, step2dir + "/wflow_outlet.map")
# make river map
strorder = pcr.streamorder(ldd)
pcr.report(strorder, step2dir + "/wflow_streamorder.map")
river = pcr.ifthen(pcr.boolean(strorder >= strRiver), strorder)
pcr.report(river, step2dir + "/wflow_river.map")
# make subcatchments
# os.system("col2map --clone " + step2dir + "/cutout.map gauges.col " + step2dir + "/wflow_gauges.map")
X = np.fromstring(gauges_x, sep=',')
Y = np.fromstring(gauges_y, sep=',')
pcr.setglobaloption("unittrue")
outlmap = tr.points_to_map(dem, X, Y, 0.5)
pcr.report(outlmap, step2dir + "/wflow_gauges_.map")
if snapgaugestoriver:
print("Snapping gauges to river")
pcr.report(outlmap, step2dir + "/wflow_orggauges.map")
outlmap = tr.snaptomap(outlmap, river)
outlmap = pcr.ifthen(outlmap > 0, outlmap)
pcr.report(outlmap, step2dir + "/wflow_gauges.map")
scatch = tr.subcatch(ldd, outlmap)
pcr.report(scatch, step2dir + "/wflow_subcatch.map")
