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 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 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 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")