Index: wflow/__init__.py =================================================================== diff -u -rf5ca8a2a5dc117ed9946ddc178d2b1017bc27050 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/__init__.py (.../__init__.py) (revision f5ca8a2a5dc117ed9946ddc178d2b1017bc27050) +++ wflow/__init__.py (.../__init__.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -28,5 +28,6 @@ os.environ["PROJ_DIR"] = os.path.join(basedir, "proj-data") from ._version import get_versions -__version__ = get_versions()['version'] + +__version__ = get_versions()["version"] del get_versions Index: wflow/_version.py =================================================================== diff -u -rfbd077ecd824c16e9e207b542e5ee2f9f9ff92dd -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/_version.py (.../_version.py) (revision fbd077ecd824c16e9e207b542e5ee2f9f9ff92dd) +++ wflow/_version.py (.../_version.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -1,4 +1,3 @@ - # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build @@ -58,28 +57,32 @@ def register_vcs_handler(vcs, method): # decorator """Decorator to mark a method as the handler for a particular VCS.""" + def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f + return decorate -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): """Call the given command(s).""" assert isinstance(commands, list) p = None for c in commands: try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) + p = subprocess.Popen( + [c] + args, + cwd=cwd, + env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr else None), + ) break except EnvironmentError: e = sys.exc_info()[1] @@ -116,16 +119,22 @@ for i in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} + return { + "version": dirname[len(parentdir_prefix) :], + "full-revisionid": None, + "dirty": False, + "error": None, + "date": None, + } else: rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) + print( + "Tried directories %s but none started with prefix %s" + % (str(rootdirs), parentdir_prefix) + ) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @@ -181,7 +190,7 @@ # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + tags = set([r[len(TAG) :] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -190,27 +199,34 @@ # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) + tags = set([r for r in refs if re.search(r"\d", r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: print("likely tags: %s" % ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] + r = ref[len(tag_prefix) :] if verbose: print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} + return { + "version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": None, + "date": date, + } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} + return { + "version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": "no suitable tags", + "date": None, + } @register_vcs_handler("git", "pieces_from_vcs") @@ -225,19 +241,27 @@ if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) + out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) if rc != 0: if verbose: print("Directory %s not under git control" % root) raise NotThisMethod("'git rev-parse --git-dir' returned error") # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) + describe_out, rc = run_command( + GITS, + [ + "describe", + "--tags", + "--dirty", + "--always", + "--long", + "--match", + "%s*" % tag_prefix, + ], + cwd=root, + ) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -260,17 +284,16 @@ dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] + git_describe = git_describe[: git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) + pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out return pieces # tag @@ -279,10 +302,12 @@ if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) + pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( + full_tag, + tag_prefix, + ) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] + pieces["closest-tag"] = full_tag[len(tag_prefix) :] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) @@ -293,13 +318,13 @@ else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) + count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() + date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[ + 0 + ].strip() pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces @@ -330,8 +355,7 @@ rendered += ".dirty" else: # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) + rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered @@ -445,11 +469,13 @@ def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} + return { + "version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None, + } if not style or style == "default": style = "pep440" # the default @@ -469,9 +495,13 @@ else: raise ValueError("unknown style '%s'" % style) - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} + return { + "version": rendered, + "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], + "error": None, + "date": pieces.get("date"), + } def get_versions(): @@ -485,8 +515,7 @@ verbose = cfg.verbose try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) + return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose) except NotThisMethod: pass @@ -495,13 +524,16 @@ # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. - for i in cfg.versionfile_source.split('/'): + for i in cfg.versionfile_source.split("/"): root = os.path.dirname(root) except NameError: - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None} + return { + "version": "0+unknown", + "full-revisionid": None, + "dirty": None, + "error": "unable to find root of source tree", + "date": None, + } try: pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) @@ -515,6 +547,10 @@ except NotThisMethod: pass - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} + return { + "version": "0+unknown", + "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", + "date": None, + } Index: wflow/pcrglobwb/groundwater.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/pcrglobwb/groundwater.py (.../groundwater.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/pcrglobwb/groundwater.py (.../groundwater.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -1192,7 +1192,9 @@ self.netcdfObj.data2NetCDF( str(self.outNCDir) + "/" + str(var) + "_monthTot.nc", var, - pcr.pcr2numpy(self.__getattribute__(var + "MonthTot"), vos.MV), + pcr.pcr2numpy( + self.__getattribute__(var + "MonthTot"), vos.MV + ), timeStamp, currTimeStep.monthIdx - 1, ) @@ -1217,7 +1219,9 @@ self.netcdfObj.data2NetCDF( str(self.outNCDir) + "/" + str(var) + "_monthAvg.nc", var, - pcr.pcr2numpy(self.__getattribute__(var + "MonthAvg"), vos.MV), + pcr.pcr2numpy( + self.__getattribute__(var + "MonthAvg"), vos.MV + ), timeStamp, currTimeStep.monthIdx - 1, ) @@ -1253,7 +1257,9 @@ self.netcdfObj.data2NetCDF( str(self.outNCDir) + "/" + str(var) + "_annuaTot.nc", var, - pcr.pcr2numpy(self.__getattribute__(var + "AnnuaTot"), vos.MV), + pcr.pcr2numpy( + self.__getattribute__(var + "AnnuaTot"), vos.MV + ), timeStamp, currTimeStep.annuaIdx - 1, ) @@ -1277,7 +1283,9 @@ self.netcdfObj.data2NetCDF( str(self.outNCDir) + "/" + str(var) + "_annuaAvg.nc", var, - pcr.pcr2numpy(self.__getattribute__(var + "AnnuaAvg"), vos.MV), + pcr.pcr2numpy( + self.__getattribute__(var + "AnnuaAvg"), vos.MV + ), timeStamp, currTimeStep.annuaIdx - 1, ) Index: wflow/pcrglobwb/landSurface.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/pcrglobwb/landSurface.py (.../landSurface.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/pcrglobwb/landSurface.py (.../landSurface.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -978,7 +978,8 @@ window_size = 1.25 * pcr.clone().cellSize() window_size = pcr.min( window_size, - pcr.min(pcr.clone().nrRows(), pcr.clone().nrCols()) * pcr.clone().cellSize(), + pcr.min(pcr.clone().nrRows(), pcr.clone().nrCols()) + * pcr.clone().cellSize(), ) try: self.irrigationEfficiency = pcr.cover( Index: wflow/pcrglobwb/routing.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/pcrglobwb/routing.py (.../routing.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/pcrglobwb/routing.py (.../routing.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -2448,7 +2448,9 @@ self.netcdfObj.data2NetCDF( str(self.outNCDir) + "/" + str(var) + "_monthTot.nc", var, - pcr.pcr2numpy(self.__getattribute__(var + "MonthTot"), vos.MV), + pcr.pcr2numpy( + self.__getattribute__(var + "MonthTot"), vos.MV + ), timeStamp, currTimeStep.monthIdx - 1, ) @@ -2473,7 +2475,9 @@ self.netcdfObj.data2NetCDF( str(self.outNCDir) + "/" + str(var) + "_monthAvg.nc", var, - pcr.pcr2numpy(self.__getattribute__(var + "MonthAvg"), vos.MV), + pcr.pcr2numpy( + self.__getattribute__(var + "MonthAvg"), vos.MV + ), timeStamp, currTimeStep.monthIdx - 1, ) @@ -2509,7 +2513,9 @@ self.netcdfObj.data2NetCDF( str(self.outNCDir) + "/" + str(var) + "_annuaTot.nc", var, - pcr.pcr2numpy(self.__getattribute__(var + "AnnuaTot"), vos.MV), + pcr.pcr2numpy( + self.__getattribute__(var + "AnnuaTot"), vos.MV + ), timeStamp, currTimeStep.annuaIdx - 1, ) @@ -2533,7 +2539,9 @@ self.netcdfObj.data2NetCDF( str(self.outNCDir) + "/" + str(var) + "_annuaAvg.nc", var, - pcr.pcr2numpy(self.__getattribute__(var + "AnnuaAvg"), vos.MV), + pcr.pcr2numpy( + self.__getattribute__(var + "AnnuaAvg"), vos.MV + ), timeStamp, currTimeStep.annuaIdx - 1, ) Index: wflow/pcrut.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/pcrut.py (.../pcrut.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/pcrut.py (.../pcrut.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -41,7 +41,11 @@ + (m3 * pcr.cos(4.0 * radlat)) + (m4 * pcr.cos(6.0 * radlat)) ) - longlen = (p1 * pcr.cos(radlat)) + (p2 * pcr.cos(3.0 * radlat)) + (p3 * pcr.cos(5.0 * radlat)) + longlen = ( + (p1 * pcr.cos(radlat)) + + (p2 * pcr.cos(3.0 * radlat)) + + (p3 * pcr.cos(5.0 * radlat)) + ) return latlen, longlen Index: wflow/reservoir_Sa.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/reservoir_Sa.py (.../reservoir_Sa.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/reservoir_Sa.py (.../reservoir_Sa.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -914,7 +914,9 @@ self.FrDur[k] = pcr.min( self.FrDur[k] - + pcr.ifthenelse(self.TempSurf > 0, self.ratFT[k] * self.TempSurf, self.TempSurf) + + pcr.ifthenelse( + self.TempSurf > 0, self.ratFT[k] * self.TempSurf, self.TempSurf + ) * self.dayDeg[k], 0, ) Index: wflow/reservoir_Sf.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/reservoir_Sf.py (.../reservoir_Sf.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/reservoir_Sf.py (.../reservoir_Sf.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -71,7 +71,9 @@ """ if self.FR_L: - self.Qu = pcr.areatotal(self.Qu_[k] * self.percentArea, pcr.nominal(self.TopoId)) + self.Qu = pcr.areatotal( + self.Qu_[k] * self.percentArea, pcr.nominal(self.TopoId) + ) else: self.Qu = self.Qu_[k] @@ -140,8 +142,12 @@ """ if self.FR_L: - self.Qu = pcr.areatotal(self.Qu_[k] * self.percentArea, pcr.nominal(self.TopoId)) - self.Qa = pcr.areatotal(self.Qa_[k] * self.percentArea, pcr.nominal(self.TopoId)) + self.Qu = pcr.areatotal( + self.Qu_[k] * self.percentArea, pcr.nominal(self.TopoId) + ) + self.Qa = pcr.areatotal( + self.Qa_[k] * self.percentArea, pcr.nominal(self.TopoId) + ) else: self.Qu = self.Qu_[k] self.Qa = self.Qa_[k] @@ -203,7 +209,9 @@ """ if self.FR_L: - self.Qa = pcr.areatotal(self.Qa_[k] * self.percentArea, pcr.nominal(self.TopoId)) + self.Qa = pcr.areatotal( + self.Qa_[k] * self.percentArea, pcr.nominal(self.TopoId) + ) else: self.Qa = self.Qa_[k] @@ -262,7 +270,9 @@ """ if self.FR_L: - self.Qa = pcr.areatotal(self.Qa_[k] * self.percentArea, pcr.nominal(self.TopoId)) + self.Qa = pcr.areatotal( + self.Qa_[k] * self.percentArea, pcr.nominal(self.TopoId) + ) else: self.Qa = self.Qa_[k] @@ -271,7 +281,9 @@ if self.convQa[k]: self.QfainLag = self.convQa[k][-1] self.Qfa = self.Sfa[k] * self.Kfa[k] - self.Percfa = pcr.ifthenelse(self.Ft_[k] == 1, self.Sfa[k] * self.perc[k] * 200, 0) + self.Percfa = pcr.ifthenelse( + self.Ft_[k] == 1, self.Sfa[k] * self.perc[k] * 200, 0 + ) self.Sfa[k] = self.Sfa[k] + self.QfainLag - self.Qfa - self.Percfa self.convQa[k].insert( @@ -289,7 +301,9 @@ else: self.Qfa = self.Sfa[k] * self.Kfa[k] - self.Percfa = pcr.ifthenelse(self.Ft_[k] == 1, self.Sfa[k] * self.perc[k] * 200, 0) + self.Percfa = pcr.ifthenelse( + self.Ft_[k] == 1, self.Sfa[k] * self.perc[k] * 200, 0 + ) self.Sfa[k] = self.Sfa[k] + self.Qfain - self.Qfa - self.Percfa self.wbSfa_[k] = ( Index: wflow/reservoir_Si.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/reservoir_Si.py (.../reservoir_Si.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/reservoir_Si.py (.../reservoir_Si.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -73,7 +73,9 @@ self.PotEvaporation = pcr.areatotal( self.PotEvaporation * self.percentArea, pcr.nominal(self.TopoId) ) - self.Si[k] = pcr.areatotal(self.Si[k] * self.percentArea, pcr.nominal(self.TopoId)) + self.Si[k] = pcr.areatotal( + self.Si[k] * self.percentArea, pcr.nominal(self.TopoId) + ) def interception_overflow_Ep(self, k): @@ -117,4 +119,6 @@ self.PotEvaporation = pcr.areatotal( self.PotEvaporation * self.percentArea, pcr.nominal(self.TopoId) ) - self.Si[k] = pcr.areatotal(self.Si[k] * self.percentArea, pcr.nominal(self.TopoId)) + self.Si[k] = pcr.areatotal( + self.Si[k] * self.percentArea, pcr.nominal(self.TopoId) + ) Index: wflow/reservoir_Su.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/reservoir_Su.py (.../reservoir_Su.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/reservoir_Su.py (.../reservoir_Su.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -211,13 +211,19 @@ self.Su_diff = pcr.ifthenelse(self.Su[k] < 0, self.Su[k], 0) self.Qu = ( self.Qu1 - + (self.Qu1 / pcr.ifthenelse(self.Qu1 + self.Perc1 > 0, self.Qu1 + self.Perc1, 1)) + + ( + self.Qu1 + / pcr.ifthenelse(self.Qu1 + self.Perc1 > 0, self.Qu1 + self.Perc1, 1) + ) * self.Su_diff ) self.Perc = pcr.ifthenelse( self.Perc1 > 0, self.Perc1 - + (self.Perc1 / pcr.ifthenelse(self.Qu1 + self.Perc1 > 0, self.Qu1 + self.Perc1, 1)) + + ( + self.Perc1 + / pcr.ifthenelse(self.Qu1 + self.Perc1 > 0, self.Qu1 + self.Perc1, 1) + ) * self.Su_diff, self.Perc1, ) Index: wflow/reservoir_Sw.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/reservoir_Sw.py (.../reservoir_Sw.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/reservoir_Sw.py (.../reservoir_Sw.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -110,7 +110,9 @@ self.Fm2 = pcr.max(self.Fm[k] * self.Precipitation, self.Fm[k]) self.Ew1 = pcr.max(pcr.min(self.PotEvaporation, self.Sw[k]), 0) - self.Qw1 = pcr.max(pcr.min(self.Fm2 * (self.Temperature - self.Tm[k]), self.Sw[k]), 0) + self.Qw1 = pcr.max( + pcr.min(self.Fm2 * (self.Temperature - self.Tm[k]), self.Sw[k]), 0 + ) self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew1 - self.Qw1 @@ -152,7 +154,9 @@ self.Fm2 = pcr.max(self.Fm[k] * self.Precipitation, self.Fm[k]) self.Ew1 = pcr.max(pcr.min(self.PotEvaporation, self.Sw[k]), 0) - self.Qw1 = pcr.max(pcr.min(self.Fm2 * (self.Temperature - self.Tm[k]), self.Sw[k]), 0) + self.Qw1 = pcr.max( + pcr.min(self.Fm2 * (self.Temperature - self.Tm[k]), self.Sw[k]), 0 + ) self.Sw[k] = self.Sw_t[k] + self.PrecipitationSnow - self.Ew1 - self.Qw1 Index: wflow/stats.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/stats.py (.../stats.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/stats.py (.../stats.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -486,7 +486,9 @@ Bvalues[i] != NoData and not np.isnan(Avalues[i]) ): if Avalues[i] != Bvalues[i]: - curr_sign = (Avalues[i] - Bvalues[i]) / math.fabs(Avalues[i] - Bvalues[i]) + curr_sign = (Avalues[i] - Bvalues[i]) / math.fabs( + Avalues[i] - Bvalues[i] + ) else: curr_sign = sign if curr_sign != sign: Index: wflow/wf_DynamicFramework.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wf_DynamicFramework.py (.../wf_DynamicFramework.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wf_DynamicFramework.py (.../wf_DynamicFramework.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -596,7 +596,9 @@ self._update_time_from_DT() - self.TheClone = pcr.scalar(pcr.xcoordinate((pcr.spatial(pcr.boolean(1.0))))) * 0.0 + self.TheClone = ( + pcr.scalar(pcr.xcoordinate((pcr.spatial(pcr.boolean(1.0))))) * 0.0 + ) def _update_time_from_DT(self): """ @@ -927,7 +929,9 @@ cmask = self._userModel().TopoId cmask = pcr.ifthen(cmask > 0, cmask) - totalzeromap = pcr.pcr2numpy(pcr.maptotal(pcr.scalar(pcr.defined(cmask))), 0) + totalzeromap = pcr.pcr2numpy( + pcr.maptotal(pcr.scalar(pcr.defined(cmask))), 0 + ) resttotal = pcr.pcr2numpy(pcr.maptotal(pcr.scalar(pcr.defined(rest))), 0) if resttotal[0, 0] < totalzeromap[0, 0]: @@ -986,7 +990,9 @@ rest = pcr.cover(pcr.readmap(mapname), default) else: if os.path.isfile(pathtotbl): - rest = pcr.lookupscalar(pathtotbl, landuse, subcatch, soil, pcr.cover(0.0) + n) + rest = pcr.lookupscalar( + pathtotbl, landuse, subcatch, soil, pcr.cover(0.0) + n + ) self.logger.info("Creating map from table: " + pathtotbl) else: self.logger.warning( @@ -1000,7 +1006,9 @@ cmask = self._userModel().TopoId cmask = pcr.ifthen(cmask > 0, cmask) - totalzeromap = pcr.pcr2numpy(pcr.maptotal(pcr.scalar(pcr.defined(cmask))), 0) + totalzeromap = pcr.pcr2numpy( + pcr.maptotal(pcr.scalar(pcr.defined(cmask))), 0 + ) resttotal = pcr.pcr2numpy(pcr.maptotal(pcr.scalar(pcr.defined(rest))), 0) if resttotal[0, 0] < totalzeromap[0, 0]: @@ -2003,7 +2011,13 @@ nr = nr + 1 else: if nr > 0: - self.logger.info("state variable " + str(var) + " contains " + str(nr) + " state files (stack)") + self.logger.info( + "state variable " + + str(var) + + " contains " + + str(nr) + + " state files (stack)" + ) stop = 1 if nr == 0: @@ -2998,7 +3012,9 @@ if hasattr(self._userModel(), "_inDynamic"): if self._userModel()._inDynamic() or self._inUpdateWeight(): - newName = pcraster.framework.generateNameT(name, self._userModel().currentTimeStep()) + newName = pcraster.framework.generateNameT( + name, self._userModel().currentTimeStep() + ) if newName == "": # For files from suspend newName = name Index: wflow/wf_netcdfio.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wf_netcdfio.py (.../wf_netcdfio.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wf_netcdfio.py (.../wf_netcdfio.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -257,12 +257,8 @@ cellsize = pcr.clone().cellSize() yupper = pcr.clone().north() xupper = pcr.clone().west() - x = pcr.pcr2numpy( - pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[0, :] - y = pcr.pcr2numpy( - pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[:, 0] + x = pcr.pcr2numpy(pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[0, :] + y = pcr.pcr2numpy(pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[:, 0] # Shift one timestep as we output at the end # starttime = starttime + dt.timedelta(seconds=timestepsecs) @@ -443,12 +439,8 @@ cellsize = pcr.clone().cellSize() yupper = pcr.clone().north() xupper = pcr.clone().west() - x = pcr.pcr2numpy( - pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[0, :] - y = pcr.pcr2numpy( - pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[:, 0] + x = pcr.pcr2numpy(pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[0, :] + y = pcr.pcr2numpy(pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[:, 0] # Shift one timestep as we output at the end # starttime = starttime + dt.timedelta(seconds=timestepsecs) @@ -602,7 +594,9 @@ maxmb = 40 self.maxlentime = len(self.dataset.variables["time"]) - self.maxsteps = np.minimum(maxmb * len(a) / floatspermb + 1, self.maxlentime - 1) + self.maxsteps = np.minimum( + maxmb * len(a) / floatspermb + 1, self.maxlentime - 1 + ) self.fstep = 0 self.lstep = self.fstep + self.maxsteps self.offset = 0 @@ -643,12 +637,8 @@ else: self.flip = True - x = pcr.pcr2numpy( - pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[0, :] - y = pcr.pcr2numpy( - pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[:, 0] + x = pcr.pcr2numpy(pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[0, :] + y = pcr.pcr2numpy(pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[:, 0] # Get average cell size acc = ( @@ -865,12 +855,8 @@ else: self.flip = True - x = pcr.pcr2numpy( - pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[0, :] - y = pcr.pcr2numpy( - pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[:, 0] + x = pcr.pcr2numpy(pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[0, :] + y = pcr.pcr2numpy(pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[:, 0] # Get average cell size acc = ( @@ -1000,12 +986,8 @@ except: self.y = self.dataset.variables["lat"][:] - x = pcr.pcr2numpy( - pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[0, :] - y = pcr.pcr2numpy( - pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan - )[:, 0] + x = pcr.pcr2numpy(pcr.xcoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[0, :] + y = pcr.pcr2numpy(pcr.ycoordinate(pcr.boolean(pcr.cover(1.0))), np.nan)[:, 0] (self.latidx,) = np.logical_and(self.x >= x.min(), self.x < x.max()).nonzero() (self.lonidx,) = np.logical_and(self.y >= x.min(), self.y < y.max()).nonzero() Index: wflow/wflow_cqf.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_cqf.py (.../wflow_cqf.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_cqf.py (.../wflow_cqf.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -154,7 +154,9 @@ RestPotEvap = PotTrans - ActEvapSat # now try unsat store - AvailCap = pcr.min(1.0, pcr.max(0.0, (WTable - RootingDepth) / (RootingDepth + 1.0))) + AvailCap = pcr.min( + 1.0, pcr.max(0.0, (WTable - RootingDepth) / (RootingDepth + 1.0)) + ) # AvailCap = pcr.max(0.0,pcr.ifthenelse(WTable < RootingDepth, WTable/RootingDepth, RootingDepth/WTable)) MaxExtr = AvailCap * UStoreDepth @@ -702,7 +704,8 @@ W = ( (alf * (alf + 2.0) ** (0.6666666667)) ** (0.375) * Qscale ** (0.375) - * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) ** (-0.1875) + * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) + ** (-0.1875) * self.N ** (0.375) ) RiverWidth = W @@ -728,7 +731,8 @@ self.DemMax = pcr.readmap(self.Dir + "/staticmaps/wflow_demmax") self.DrainageBase = pcr.readmap(self.Dir + "/staticmaps/wflow_demmin") self.CC = pcr.min( - 100.0, -log(1.0 / 0.1 - 1) / pcr.min(-0.1, self.DrainageBase - self.Altitude) + 100.0, + -log(1.0 / 0.1 - 1) / pcr.min(-0.1, self.DrainageBase - self.Altitude), ) # if pcr.maptotal(self.RunoffGeneratingThickness <= 0.0): @@ -814,7 +818,9 @@ self.Aspect = pcr.ifthenelse(self.Aspect <= 0.0, pcr.scalar(0.001), self.Aspect) # On Flat areas the Aspect function fails, fill in with average... self.Aspect = pcr.ifthenelse( - pcr.defined(self.Aspect), self.Aspect, pcr.areaaverage(self.Aspect, self.TopoId) + pcr.defined(self.Aspect), + self.Aspect, + pcr.areaaverage(self.Aspect, self.TopoId), ) # Set DCL to riverlength if that is longer that the basic length calculated from grid @@ -835,7 +841,9 @@ # Add rivers to the WaterFrac, but check with waterfrac map self.RiverFrac = pcr.min( 1.0, - pcr.ifthenelse(self.River, (RiverWidth * self.DCL) / (self.xl * self.yl), 0), + pcr.ifthenelse( + self.River, (RiverWidth * self.DCL) / (self.xl * self.yl), 0 + ), ) self.WaterFrac = self.WaterFrac - pcr.ifthenelse( (self.RiverFrac + self.WaterFrac) > 1.0, @@ -862,8 +870,12 @@ pcr.report(self.WHC, self.Dir + "/" + self.runId + "/outsum/WHC.map") pcr.report(self.Cmax, self.Dir + "/" + self.runId + "/outsum/Cmax.map") - pcr.report(self.csize, self.Dir + "/" + self.runId + "/outsum/CatchmentSize.map") - pcr.report(self.upsize, self.Dir + "/" + self.runId + "/outsum/UpstreamSize.map") + pcr.report( + self.csize, self.Dir + "/" + self.runId + "/outsum/CatchmentSize.map" + ) + pcr.report( + self.upsize, self.Dir + "/" + self.runId + "/outsum/UpstreamSize.map" + ) pcr.report(self.EoverR, self.Dir + "/" + self.runId + "/outsum/EoverR.map") pcr.report( self.RootingDepth, self.Dir + "/" + self.runId + "/outsum/RootingDepth.map" @@ -901,7 +913,9 @@ pcr.report(WI, self.Dir + "/" + self.runId + "/outsum/WI.map") pcr.report(self.CC, self.Dir + "/" + self.runId + "/outsum/CC.map") pcr.report(self.N, self.Dir + "/" + self.runId + "/outsum/N.map") - pcr.report(self.RiverFrac, self.Dir + "/" + self.runId + "/outsum/RiverFrac.map") + pcr.report( + self.RiverFrac, self.Dir + "/" + self.runId + "/outsum/RiverFrac.map" + ) pcr.report(self.xl, self.Dir + "/" + self.runId + "/outsum/xl.map") pcr.report(self.yl, self.Dir + "/" + self.runId + "/outsum/yl.map") @@ -1066,7 +1080,12 @@ Zoh = 0.25 * Zom d = 0.66 * self.VegetationHeigth - Ra = 4.72 * pcr.ln((z - d) / Zom) * pcr.ln((z - d) / Zoh) / (1 + 0.54 * self.WindSpeed) + Ra = ( + 4.72 + * pcr.ln((z - d) / Zom) + * pcr.ln((z - d) / Zoh) + / (1 + 0.54 * self.WindSpeed) + ) # Now the actual formula, this is for Interception, rs is zero VPD = Esat - Eact @@ -1092,7 +1111,10 @@ # CQ Specific function! ForRs = pcr.exp(0.867 * pcr.ln(InVPD) - 0.000831 * InWave + 2.81) - Rs = pcr.max(0.5, pcr.min(1000, pcr.ifthenelse(pcr.scalar(self.LandUse) > 1.0, ForRs, PasRs))) + Rs = pcr.max( + 0.5, + pcr.min(1000, pcr.ifthenelse(pcr.scalar(self.LandUse) > 1.0, ForRs, PasRs)), + ) # No transpiration at nigth, this is of no use to the trees. Rs = pcr.ifthenelse(InWave < 10.0, 500, Rs) @@ -1253,7 +1275,9 @@ self.FirstZoneThickness - self.FirstZoneDepth / (self.thetaS - self.thetaR), ) # Determine actual water depth Ksat = self.FirstZoneKsatVer * pcr.exp(-self.f * self.zi) - self.DeepKsat = self.FirstZoneKsatVer * pcr.exp(-self.f * self.FirstZoneThickness) + self.DeepKsat = self.FirstZoneKsatVer * pcr.exp( + -self.f * self.FirstZoneThickness + ) # Determine saturation deficit. NB, as noted by Vertessy and Elsenbeer 1997 # this deficit does NOT take into account the water in the unsaturated zone @@ -1275,7 +1299,8 @@ # Limit to MaxLeakage/day. Leakage percentage gets bigger if the # storm is bigger (macropores start kicking in... ActLeakage = pcr.max( - 0, pcr.min(self.MaxLeakage, self.Transfer * pcr.exp(0.01 * self.Transfer) / e) + 0, + pcr.min(self.MaxLeakage, self.Transfer * pcr.exp(0.01 * self.Transfer) / e), ) self.Transfer = self.Transfer - ActLeakage # Now add leakage. to deeper groundwater @@ -1303,7 +1328,9 @@ waterDem = self.Altitude - (self.zi * 0.001) waterLdd = pcr.lddcreate(waterDem, 1e35, 1e35, 1e35, 1e35) # waterLdd = pcr.lddcreate(waterDem,1,1,1,1) - waterSlope = pcr.max(0.00001, pcr.slope(waterDem) * pcr.celllength() / self.reallength) + waterSlope = pcr.max( + 0.00001, pcr.slope(waterDem) * pcr.celllength() / self.reallength + ) self.zi = pcr.max( 0.0, Index: wflow/wflow_floodmap.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_floodmap.py (.../wflow_floodmap.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_floodmap.py (.../wflow_floodmap.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -322,11 +322,15 @@ self.distfromriv > self.maxdist, 0.0, self.FloodDepth ) self.FloodDepth = pcr.ifthen(self.FloodDepth > 0.0, self.FloodDepth) - self.FloodExtent = pcr.ifthenelse(self.FloodDepth > 0.0, pcr.boolean(1), pcr.boolean(0)) + self.FloodExtent = pcr.ifthenelse( + self.FloodDepth > 0.0, pcr.boolean(1), pcr.boolean(0) + ) # Keep track of af depth and extent self.MaxDepth = pcr.max(self.MaxDepth, pcr.cover(self.FloodDepth, 0)) - self.MaxExt = pcr.max(pcr.scalar(self.MaxExt), pcr.scalar(pcr.cover(self.FloodExtent, 0))) + self.MaxExt = pcr.max( + pcr.scalar(self.MaxExt), pcr.scalar(pcr.cover(self.FloodExtent, 0)) + ) # reporting of maps is done by the framework (see ini file) Index: wflow/wflow_funcs.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_funcs.py (.../wflow_funcs.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_funcs.py (.../wflow_funcs.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -126,7 +126,7 @@ pt = 0.1 * p # Amount of P that falls on the canopy - Pfrac = pcr.max((1 - p - pt),0) * Precipitation + Pfrac = pcr.max((1 - p - pt), 0) * Precipitation # S cannot be larger than Cmax, no gravity drainage below that DD = pcr.ifthenelse(CanopyStorage > Cmax, CanopyStorage - Cmax, 0.0) Index: wflow/wflow_gr4.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_gr4.py (.../wflow_gr4.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_gr4.py (.../wflow_gr4.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -280,7 +280,9 @@ self.LandUse = pcr.cover(self.LandUse, pcr.nominal(pcr.ordinal(subcatch) > 0)) self.Soil = pcr.readmap(self.Dir + wflow_soil) #: Map with soil classes self.Soil = pcr.cover(self.Soil, pcr.nominal(pcr.ordinal(subcatch) > 0)) - self.OutputId = pcr.readmap(self.Dir + wflow_subcatch) # location of subcatchment + self.OutputId = pcr.readmap( + self.Dir + wflow_subcatch + ) # location of subcatchment # hourly time step self.dt = int(configget(self.config, "gr4", "dt", "1")) Index: wflow/wflow_hbv.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_hbv.py (.../wflow_hbv.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_hbv.py (.../wflow_hbv.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -510,7 +510,9 @@ os.path.join(self.Dir, wflow_subcatch), 0.0, fail=True ) # location of subcatchment - self.ZeroMap = 0.0 * pcr.scalar(pcr.defined(self.Altitude)) # map with only zero's + self.ZeroMap = 0.0 * pcr.scalar( + pcr.defined(self.Altitude) + ) # map with only zero's # 3: Input time series ################################################### self.P_mapstack = self.Dir + configget( @@ -621,10 +623,15 @@ + str(self.nrresComplex) + " complex reservoirs found." ) - self.ReserVoirDownstreamLocs = pcr.downstream(self.TopoLdd, self.ReserVoirLocs) + self.ReserVoirDownstreamLocs = pcr.downstream( + self.TopoLdd, self.ReserVoirLocs + ) self.TopoLddOrg = self.TopoLdd self.TopoLdd = pcr.lddrepair( - pcr.cover(pcr.ifthen(pcr.boolean(self.ReserVoirLocs), pcr.ldd(5)), self.TopoLdd) + pcr.cover( + pcr.ifthen(pcr.boolean(self.ReserVoirLocs), pcr.ldd(5)), + self.TopoLdd, + ) ) # HBV Soil params @@ -845,7 +852,8 @@ W = ( (alf * (alf + 2.0) ** (0.6666666667)) ** (0.375) * Qscale ** (0.375) - * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) ** (-0.1875) + * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) + ** (-0.1875) * self.N ** (0.375) ) # Use supplied riverwidth if possible, else calulate @@ -891,7 +899,9 @@ self.logger.info("Creating subcatchment-only drainage network (ldd)") ds = pcr.downstream(self.TopoLdd, self.TopoId) usid = pcr.ifthenelse(ds != self.TopoId, self.TopoId, 0) - self.TopoLdd = pcr.lddrepair(pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd)) + self.TopoLdd = pcr.lddrepair( + pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd) + ) # Used to seperate output per LandUse/management classes # OutZones = self.LandUse @@ -931,7 +941,9 @@ self.Aspect = pcr.ifthenelse(self.Aspect <= 0.0, pcr.scalar(0.001), self.Aspect) # On Flat areas the Aspect function fails, fill in with average... self.Aspect = pcr.ifthenelse( - pcr.defined(self.Aspect), self.Aspect, pcr.areaaverage(self.Aspect, self.TopoId) + pcr.defined(self.Aspect), + self.Aspect, + pcr.areaaverage(self.Aspect, self.TopoId), ) # Set DCL to riverlength if that is longer that the basic length calculated from grid @@ -1100,9 +1112,12 @@ RainFrac = pcr.ifthenelse( 1.0 * self.TTI == 0.0, - pcr.ifthenelse(self.Temperature <= self.TT, pcr.scalar(0.0), pcr.scalar(1.0)), + pcr.ifthenelse( + self.Temperature <= self.TT, pcr.scalar(0.0), pcr.scalar(1.0) + ), pcr.min( - (self.Temperature - (self.TT - self.TTI / 2.0)) / self.TTI, pcr.scalar(1.0) + (self.Temperature - (self.TT - self.TTI / 2.0)) / self.TTI, + pcr.scalar(1.0), ), ) RainFrac = pcr.max( @@ -1289,7 +1304,9 @@ self.RealQuickFlow = self.ZeroMap else: self.QuickFlow = self.KQuickFlow * self.UpperZoneStorage - self.RealQuickFlow = pcr.max(0, self.K0 * (self.UpperZoneStorage - self.SUZ)) + self.RealQuickFlow = pcr.max( + 0, self.K0 * (self.UpperZoneStorage - self.SUZ) + ) self.UpperZoneStorage = ( self.UpperZoneStorage - self.QuickFlow - self.RealQuickFlow ) Index: wflow/wflow_hbvl.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_hbvl.py (.../wflow_hbvl.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_hbvl.py (.../wflow_hbvl.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -349,7 +349,9 @@ os.path.join(self.Dir, wflow_subcatch), 0.0, fail=True ) # location of subcatchment - self.ZeroMap = 0.0 * pcr.scalar(pcr.defined(self.Altitude)) # map with only zero's + self.ZeroMap = 0.0 * pcr.scalar( + pcr.defined(self.Altitude) + ) # map with only zero's # 3: Input time series ################################################### self.P_mapstack = self.Dir + configget( @@ -647,9 +649,12 @@ RainFrac = pcr.ifthenelse( 1.0 * self.TTI == 0.0, - pcr.ifthenelse(self.Temperature <= self.TT, pcr.scalar(0.0), pcr.scalar(1.0)), + pcr.ifthenelse( + self.Temperature <= self.TT, pcr.scalar(0.0), pcr.scalar(1.0) + ), pcr.min( - (self.Temperature - (self.TT - self.TTI / 2.0)) / self.TTI, pcr.scalar(1.0) + (self.Temperature - (self.TT - self.TTI / 2.0)) / self.TTI, + pcr.scalar(1.0), ), ) RainFrac = pcr.max( Index: wflow/wflow_lib.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_lib.py (.../wflow_lib.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_lib.py (.../wflow_lib.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -133,11 +133,15 @@ inflow = pcr.ifthen(pcr.boolean(ReserVoirLocs), inflow) prec_av = pcr.cover( - pcr.ifthen(pcr.boolean(ReserVoirLocs), pcr.areaaverage(precip, ReservoirSimpleAreas)), + pcr.ifthen( + pcr.boolean(ReserVoirLocs), pcr.areaaverage(precip, ReservoirSimpleAreas) + ), pcr.scalar(0.0), ) pet_av = pcr.cover( - pcr.ifthen(pcr.boolean(ReserVoirLocs), pcr.areaaverage(pet, ReservoirSimpleAreas)), + pcr.ifthen( + pcr.boolean(ReserVoirLocs), pcr.areaaverage(pet, ReservoirSimpleAreas) + ), pcr.scalar(0.0), ) @@ -230,8 +234,12 @@ inflow = pcr.ifthen(pcr.boolean(ReserVoirLocs), inflow) - prec_av = pcr.ifthen(pcr.boolean(ReserVoirLocs), pcr.areaaverage(precip, ReservoirComplexAreas)) - pet_av = pcr.ifthen(pcr.boolean(ReserVoirLocs), pcr.areaaverage(pet, ReservoirComplexAreas)) + prec_av = pcr.ifthen( + pcr.boolean(ReserVoirLocs), pcr.areaaverage(precip, ReservoirComplexAreas) + ) + pet_av = pcr.ifthen( + pcr.boolean(ReserVoirLocs), pcr.areaaverage(pet, ReservoirComplexAreas) + ) np_reslocs = pcr.pcr2numpy(ReserVoirLocs, 0.0) np_linkedreslocs = pcr.pcr2numpy(LinkedReserVoirLocs, 0.0) @@ -274,7 +282,7 @@ np_outflow = pcr.pcr2numpy(outflow, np.nan) np_outflow_linked = np_reslocs * 0.0 - with np.errstate(invalid='ignore'): + with np.errstate(invalid="ignore"): if np_outflow[np_outflow < 0] is not None: np_outflow_linked[ np.in1d(np_reslocs, np_linkedreslocs[np_outflow < 0]).reshape( @@ -301,7 +309,7 @@ ) np_outflow_nz = np_outflow * 0.0 - with np.errstate(invalid='ignore'): + with np.errstate(invalid="ignore"): np_outflow_nz[np_outflow > 0] = np_outflow[np_outflow > 0] _outflow.append(np_outflow_nz) @@ -528,7 +536,9 @@ """ 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))) + dist = pcr.max( + pcr.celllength(), pcr.ifthen(pcr.boolean(strorder), pcr.downstreamdist(ldd)) + ) return pcr.catchmenttotal(pcr.cover(dist, 0), ldd), dist, strorder @@ -552,11 +562,18 @@ 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) + 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), + pcr.windowtotal( + pcr.ifthen(pcr.boolean(strorder), dist), pcr.celllength() * factor + ), ), dist, ) @@ -648,7 +665,9 @@ - outlet map (single point in the map) """ largest = pcr.mapmaximum(pcr.catchmenttotal(pcr.spatial(pcr.scalar(1.0)), ldd)) - outlet = pcr.ifthen(pcr.catchmenttotal(1.0, ldd) == largest, pcr.spatial(pcr.scalar(1.0))) + outlet = pcr.ifthen( + pcr.catchmenttotal(1.0, ldd) == largest, pcr.spatial(pcr.scalar(1.0)) + ) return outlet @@ -793,15 +812,20 @@ elif assign_existing: # unaccounted areas are added to largest nearest draining basin if up_area is None: - up_area = pcr.ifthen(pcr.boolean(pcr.cover(stream_ge, 0)), pcr.accuflux(ldd, 1)) + up_area = pcr.ifthen( + pcr.boolean(pcr.cover(stream_ge, 0)), pcr.accuflux(ldd, 1) + ) riverid = pcr.ifthen(pcr.boolean(pcr.cover(stream_ge, 0)), subcatch) friction = 1.0 / pcr.scalar( pcr.spreadzone(pcr.cover(pcr.ordinal(up_area), 0), 0, 0) ) # *(pcr.scalar(ldd)*0+1) delta = pcr.ifthen( pcr.scalar(ldd) >= 0, - pcr.ifthen(pcr.cover(subcatch, 0) == 0, pcr.spreadzone(pcr.cover(riverid, 0), 0, friction)), + pcr.ifthen( + pcr.cover(subcatch, 0) == 0, + pcr.spreadzone(pcr.cover(riverid, 0), 0, friction), + ), ) subcatch = pcr.ifthenelse(pcr.boolean(pcr.cover(subcatch, 0)), subcatch, delta) @@ -836,7 +860,13 @@ pts = pcr.ifthen((pcr.scalar(sttd) - pcr.scalar(stt)) > 0.0, sttd) dif = pcr.upstream( ldd, - pcr.cover(pcr.ifthen(large, pcr.uniqueid(pcr.boolean(pcr.ifthen(stt == pcr.ordinal(oorder), pts)))), 0), + pcr.cover( + pcr.ifthen( + large, + pcr.uniqueid(pcr.boolean(pcr.ifthen(stt == pcr.ordinal(oorder), pts))), + ), + 0, + ), ) dif = pcr.cover(pcr.scalar(outl), dif) # Add catchment outlet dif = pcr.ordinal(pcr.uniqueid(pcr.boolean(dif))) @@ -880,20 +910,31 @@ if fill: for order in range(oorder, maxorder): m_pts = pcr.ifthen((pcr.scalar(sttd) - pcr.scalar(order)) > 0.0, sttd) - m_dif = pcr.uniqueid(pcr.boolean(pcr.ifthen(stt == pcr.ordinal(order), m_pts))) + m_dif = pcr.uniqueid( + pcr.boolean(pcr.ifthen(stt == pcr.ordinal(order), m_pts)) + ) dif = pcr.uniqueid(pcr.boolean(pcr.cover(m_dif, dif))) for myorder in range(oorder - 1, stoporder, -1): sc = pcr.subcatchment(ldd, pcr.nominal(dif)) m_pts = pcr.ifthen((pcr.scalar(sttd) - pcr.scalar(stt)) > 0.0, sttd) - m_dif = pcr.uniqueid(pcr.boolean(pcr.ifthen(stt == pcr.ordinal(myorder - 1), m_pts))) - dif = pcr.uniqueid(pcr.boolean(pcr.cover(pcr.ifthen(pcr.scalar(sc) == 0, m_dif), dif))) + m_dif = pcr.uniqueid( + pcr.boolean(pcr.ifthen(stt == pcr.ordinal(myorder - 1), m_pts)) + ) + dif = pcr.uniqueid( + pcr.boolean(pcr.cover(pcr.ifthen(pcr.scalar(sc) == 0, m_dif), dif)) + ) if fillcomplete: sc = pcr.subcatchment(ldd, pcr.nominal(dif)) cs, m_dif, stt = subcatch_order_a(ldd, stoporder) dif = pcr.uniqueid( - pcr.boolean(pcr.cover(pcr.ifthen(pcr.scalar(sc) == 0, pcr.ordinal(m_dif)), pcr.ordinal(dif))) + pcr.boolean( + pcr.cover( + pcr.ifthen(pcr.scalar(sc) == 0, pcr.ordinal(m_dif)), + pcr.ordinal(dif), + ) + ) ) scsize = pcr.catchmenttotal(1, ldd) @@ -997,7 +1038,7 @@ # Loop over points and "burn in" map for n in range(0, xcor.size): if Verbose: - print (n) + print(n) diffx = x - xcor[n] diffy = y - ycor[n] col_ = np.absolute(diffx) <= (cell_length * tolerance) # cellsize @@ -1030,7 +1071,9 @@ pcr.ifthenelse( draindir == 8, yl, - pcr.ifthenelse(draindir == 4, xl, pcr.ifthenelse(draindir == 6, xl, slantlength)), + pcr.ifthenelse( + draindir == 4, xl, pcr.ifthenelse(draindir == 6, xl, slantlength) + ), ), ) @@ -1060,7 +1103,9 @@ pcr.ifthenelse( draindir == 8, xl, - pcr.ifthenelse(draindir == 4, yl, pcr.ifthenelse(draindir == 6, yl, slantwidth)), + pcr.ifthenelse( + draindir == 4, yl, pcr.ifthenelse(draindir == 6, yl, slantwidth) + ), ), ) return drainwidth @@ -1076,7 +1121,9 @@ result = pcr.ordinal(pcr.cover(-1)) for l, u, c in zip(lower, upper, classes): - result = pcr.cover(pcr.ifthen(inmap >= l, pcr.ifthen(inmap < u, pcr.ordinal(c))), result) + result = pcr.cover( + pcr.ifthen(inmap >= l, pcr.ifthen(inmap < u, pcr.ordinal(c))), result + ) return pcr.ifthen(result >= 0, result) @@ -1103,7 +1150,9 @@ according to D8 directions """ if rivers is None: - stream = pcr.ifthenelse(pcr.accuflux(ldd, 1) >= accuThreshold, pcr.boolean(1), pcr.boolean(0)) + stream = pcr.ifthenelse( + pcr.accuflux(ldd, 1) >= accuThreshold, pcr.boolean(1), pcr.boolean(0) + ) else: stream = pcr.boolean(pcr.cover(rivers, 0)) @@ -1112,7 +1161,9 @@ up_elevation = pcr.scalar(pcr.subcatchment(ldd, height_river)) else: drainage_surf = pcr.ifthen(rivers, pcr.accuflux(ldd, 1)) - weight = 1.0 / pcr.scalar(pcr.spreadzone(pcr.cover(pcr.ordinal(drainage_surf), 0), 0, 0)) + weight = 1.0 / pcr.scalar( + pcr.spreadzone(pcr.cover(pcr.ordinal(drainage_surf), 0), 0, 0) + ) up_elevation = pcr.ifthenelse( basin, pcr.scalar(pcr.subcatchment(ldd, height_river)), Index: wflow/wflow_lintul.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_lintul.py (.../wflow_lintul.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_lintul.py (.../wflow_lintul.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -817,7 +817,9 @@ # Hence in LINTUL3, some processes are still controlled directly by TSUM and some are controlled by its derived variable DVS # – a somewhat confusing situation that offers scope for future improvement. # After anthesis DVS proceeds at a different rate (DVS_gen) than before (DVS_veg). Throughout crop development DVS is calculated as the DVS_veg + DVS_gen. - DVS_veg = self.TSUM / self.TSUMAN * pcr.ifthenelse(CropHarvNow, pcr.scalar(0.0), 1.0) + DVS_veg = ( + self.TSUM / self.TSUMAN * pcr.ifthenelse(CropHarvNow, pcr.scalar(0.0), 1.0) + ) DVS_gen = (1.0 + (self.TSUM - self.TSUMAN) / self.TSUMMT) * pcr.ifthenelse( CropHarvNow, pcr.scalar(0.0), 1.0 ) @@ -881,7 +883,9 @@ DLV = (DLVS + DLVNS) * pcr.scalar(Not_Finished) RWLVG = pcr.ifthenelse(EMERG, GTOTAL * FLV - DLV, pcr.scalar(0.0)) self.WLVG = ( - self.WLVG + pcr.ifthenelse(CropStartNow, self.WLVGI, pcr.scalar(0.0)) + RWLVG + self.WLVG + + pcr.ifthenelse(CropStartNow, self.WLVGI, pcr.scalar(0.0)) + + RWLVG ) * (1.0 - pcr.scalar(CropHarvNow)) self.WLVD = (self.WLVD + DLV) * (1.0 - pcr.scalar(CropHarvNow)) @@ -917,7 +921,9 @@ # Total daily decrease in LAI due to leaf death (aging, mutual shading, N shortage): DLAI = (DLAIS + DLAINS) * pcr.scalar(Not_Finished) # The initial LAI (LAII, transplanted rice) is added to GLAI at crop establishment, not in below state equation as done by Shibu et al. (2010). - self.LAI = (self.LAI + GLAI - DLAI) * pcr.ifthenelse(CropHarvNow, pcr.scalar(0.0), 1.0) + self.LAI = (self.LAI + GLAI - DLAI) * pcr.ifthenelse( + CropHarvNow, pcr.scalar(0.0), 1.0 + ) # Daily death rate of roots: if self.DVS >= self.DVSDR, a fraction self.DRRT of the roots is dying every day: DRRT = pcr.ifthenelse(Roots_Dying, self.WRT * self.RDRRT, pcr.scalar(0.0)) Index: wflow/wflow_routing.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_routing.py (.../wflow_routing.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_routing.py (.../wflow_routing.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -141,7 +141,9 @@ self.Qbankfull = pow(self.bankFull / self.AlphaCh * self.Bw, 1.0 / self.Beta) self.Qchannel = pcr.min(self.SurfaceRunoff, self.Qbankfull) self.floodcells = pcr.boolean( - pcr.ifthenelse(self.WaterLevelCH > self.bankFull, pcr.boolean(1), pcr.boolean(0)) + pcr.ifthenelse( + self.WaterLevelCH > self.bankFull, pcr.boolean(1), pcr.boolean(0) + ) ) self.Qfloodplain = pcr.max(0.0, self.SurfaceRunoff - self.Qbankfull) @@ -424,7 +426,10 @@ ) self.TopoLddOrg = self.TopoLdd self.TopoLdd = pcr.lddrepair( - pcr.cover(pcr.ifthen(pcr.boolean(self.ReserVoirSimpleLocs), pcr.ldd(5)), self.TopoLdd) + pcr.cover( + pcr.ifthen(pcr.boolean(self.ReserVoirSimpleLocs), pcr.ldd(5)), + self.TopoLdd, + ) ) else: self.nrresSimple = 0 @@ -478,7 +483,8 @@ W = ( (alf * (alf + 2.0) ** (0.6666666667)) ** (0.375) * Qscale ** (0.375) - * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) ** (-0.1875) + * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) + ** (-0.1875) * self.N ** (0.375) ) # Use supplied riverwidth if possible, else calulate @@ -521,7 +527,9 @@ self.logger.info("Creating subcatchment-only drainage network (ldd)") ds = pcr.downstream(self.TopoLdd, self.TopoId) usid = pcr.ifthenelse(ds != self.TopoId, self.TopoId, 0) - self.TopoLdd = pcr.lddrepair(pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd)) + self.TopoLdd = pcr.lddrepair( + pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd) + ) self.QMMConv = self.timestepsecs / ( self.reallength * self.reallength * 0.001 @@ -537,7 +545,9 @@ # On Flat areas the Aspect function fails, fill in with average... self.Aspect = pcr.ifthenelse( - pcr.defined(self.Aspect), self.Aspect, pcr.areaaverage(self.Aspect, self.TopoId) + pcr.defined(self.Aspect), + self.Aspect, + pcr.areaaverage(self.Aspect, self.TopoId), ) # Set DCL to riverlength if that is longer that the basic length calculated from grid @@ -883,7 +893,9 @@ ########################################################################## MaxExtract = self.InflowKinWaveCell + self.OldInwater self.SurfaceWaterSupply = pcr.ifthenelse( - self.Inflow < 0.0, pcr.min(MaxExtract, -1.0 * self.Inflow), self.ZeroMap + self.Inflow < 0.0, + pcr.min(MaxExtract, -1.0 * self.Inflow), + self.ZeroMap, ) # Fraction of demand that is not used but flows back into the river get fracttion and move to return locations self.DemandReturnFlow = pcr.cover( @@ -921,7 +933,9 @@ self.SurfaceRunoff * self.QMMConv ) # SurfaceRunoffMM (mm) from SurfaceRunoff (m3/s) - self.InflowKinWaveCell = pcr.upstream(self.TopoLdd, self.OldSurfaceRunoff) + self.InflowKinWaveCell = pcr.upstream( + self.TopoLdd, self.OldSurfaceRunoff + ) deltasup = float(pcr.mapmaximum(abs(oldsup - self.SurfaceWaterSupply))) if deltasup < self.breakoff or self.nrit >= self.maxitsupply: @@ -966,7 +980,9 @@ # first column (nr 1). Assumes that outputloc and columns match! if self.updating: - self.QM = pcr.timeinputscalar(self.updateFile, self.UpdateMap) * self.QMMConv + self.QM = ( + pcr.timeinputscalar(self.updateFile, self.UpdateMap) * self.QMMConv + ) # Now update the state. Just add to the Ustore # self.UStoreDepth = result Index: wflow/wflow_sbm.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_sbm.py (.../wflow_sbm.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_sbm.py (.../wflow_sbm.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -164,8 +164,12 @@ else: AvailCap = pcr.ifthenelse( layerIndex < zi_layer, - pcr.min(1.0, pcr.max(0.0, (RootingDepth - sumLayer) / UStoreLayerThickness)), - pcr.min(1.0, pcr.max(0.0, (RootingDepth - sumLayer) / (WTable + 1 - sumLayer))), + pcr.min( + 1.0, pcr.max(0.0, (RootingDepth - sumLayer) / UStoreLayerThickness) + ), + pcr.min( + 1.0, pcr.max(0.0, (RootingDepth - sumLayer) / (WTable + 1 - sumLayer)) + ), ) MaxExtr = AvailCap * UStoreDepth @@ -260,27 +264,53 @@ return soilevap -def soilevap_SBM_sat(PotTransSoil,zi,thetaS,thetaR,UStoreLayerThickness, UStoreLayerDepth): + +def soilevap_SBM_sat( + PotTransSoil, zi, thetaS, thetaR, UStoreLayerThickness, UStoreLayerDepth +): # Follows after soilevap_SBM_unsat and requires the PotTranSoil that remains after - # soilevap_SBM_unsat. + # soilevap_SBM_unsat. # soilevap_SBM_sat only takes place in the upper layer. - + # Only works when more than 1 layer is used, otherwise soilevap_sat equals 0. - # PotTranSoil is reduced when there is either no saturated water layer in the - # upper soil layer (reduced to zero), or when the saturated layer is only a + # PotTranSoil is reduced when there is either no saturated water layer in the + # upper soil layer (reduced to zero), or when the saturated layer is only a # fraction of the upper soil layer (reduced to that fraction). - - # In case water is ponding, zi is negative - Start with setting negative values + + # In case water is ponding, zi is negative - Start with setting negative values # to 0.0 to assure positive soilevap values zi = pcr.ifthenelse(zi < 0.0, 0.0, zi) - + # Calculate soilevap - soilevap_sat = pcr.ifthenelse(len(UStoreLayerThickness)==1, 0.0, PotTransSoil * pcr.min(1.0, pcr.ifthenelse(zi >= UStoreLayerThickness[0], 0.0, (UStoreLayerThickness[0] - zi)/UStoreLayerThickness[0]))) - + soilevap_sat = pcr.ifthenelse( + len(UStoreLayerThickness) == 1, + 0.0, + PotTransSoil + * pcr.min( + 1.0, + pcr.ifthenelse( + zi >= UStoreLayerThickness[0], + 0.0, + (UStoreLayerThickness[0] - zi) / UStoreLayerThickness[0], + ), + ), + ) + # Set soilevap to demand (soilevap_sat) or, if less than the demand, the depth # of the saturated water layer - soilevapsat = pcr.ifthenelse(len(UStoreLayerThickness)==1, 0.0, pcr.min(soilevap_sat, pcr.ifthenelse(zi >= UStoreLayerThickness[0], 0.0, (UStoreLayerThickness[0] - zi)*(thetaS-thetaR)))) - + soilevapsat = pcr.ifthenelse( + len(UStoreLayerThickness) == 1, + 0.0, + pcr.min( + soilevap_sat, + pcr.ifthenelse( + zi >= UStoreLayerThickness[0], + 0.0, + (UStoreLayerThickness[0] - zi) * (thetaS - thetaR), + ), + ), + ) + return soilevapsat @@ -1232,7 +1262,9 @@ pcr.cover(resarea_pnt, pcr.scalar(0.0)), ) self.filter_P_PET = pcr.ifthenelse( - pcr.boolean(pcr.cover(res_area, pcr.scalar(0.0))), res_area * 0.0, self.filter_P_PET + pcr.boolean(pcr.cover(res_area, pcr.scalar(0.0))), + res_area * 0.0, + self.filter_P_PET, ) else: self.nrresSimple = 0 @@ -1291,10 +1323,15 @@ + str(self.nrresComplex) + " complex reservoirs found." ) - self.ReserVoirDownstreamLocs = pcr.downstream(self.TopoLdd, self.ReserVoirLocs) + self.ReserVoirDownstreamLocs = pcr.downstream( + self.TopoLdd, self.ReserVoirLocs + ) self.TopoLddOrg = self.TopoLdd self.TopoLdd = pcr.lddrepair( - pcr.cover(pcr.ifthen(pcr.boolean(self.ReserVoirLocs), pcr.ldd(5)), self.TopoLdd) + pcr.cover( + pcr.ifthen(pcr.boolean(self.ReserVoirLocs), pcr.ldd(5)), + self.TopoLdd, + ) ) tt_filter = pcr.pcr2numpy(self.filter_P_PET, 1.0) @@ -1311,7 +1348,8 @@ W = ( (alf * (alf + 2.0) ** (0.6666666667)) ** (0.375) * Qscale ** (0.375) - * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) ** (-0.1875) + * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) + ** (-0.1875) * self.N ** (0.375) ) # Use supplied riverwidth if possible, else calulate @@ -1444,7 +1482,8 @@ self.DemMax = pcr.readmap(self.Dir + "/staticmaps/wflow_demmax") self.DrainageBase = pcr.readmap(self.Dir + "/staticmaps/wflow_demmin") self.CClow = pcr.min( - 100.0, -pcr.ln(1.0 / 0.1 - 1) / pcr.min(-0.1, self.DrainageBase - self.Altitude) + 100.0, + -pcr.ln(1.0 / 0.1 - 1) / pcr.min(-0.1, self.DrainageBase - self.Altitude), ) self.CCup = pcr.min( 100.0, -pcr.ln(1.0 / 0.1 - 1) / pcr.min(-0.1, self.Altitude - self.DemMax) @@ -1468,7 +1507,9 @@ # ldddist returns zero for cell at the gauges so add 1.0 tp result self.DistToUpdPt = pcr.cover( pcr.min( - pcr.ldddist(self.TopoLdd, pcr.boolean(pcr.cover(self.UpdateMap, 0)), 1) + pcr.ldddist( + self.TopoLdd, pcr.boolean(pcr.cover(self.UpdateMap, 0)), 1 + ) * self.reallength / pcr.celllength(), self.UpdMaxDist, @@ -1487,7 +1528,9 @@ self.logger.info("Creating subcatchment-only drainage network (ldd)") ds = pcr.downstream(self.TopoLdd, self.TopoId) usid = pcr.ifthenelse(ds != self.TopoId, self.TopoId, 0) - self.TopoLdd = pcr.lddrepair(pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd)) + self.TopoLdd = pcr.lddrepair( + pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd) + ) # Used to seperate output per LandUse/management classes OutZones = self.LandUse @@ -1545,7 +1588,9 @@ self.Aspect = pcr.ifthenelse(self.Aspect <= 0.0, pcr.scalar(0.001), self.Aspect) # On Flat areas the Aspect function fails, fill in with average... self.Aspect = pcr.ifthenelse( - pcr.defined(self.Aspect), self.Aspect, pcr.areaaverage(self.Aspect, self.TopoId) + pcr.defined(self.Aspect), + self.Aspect, + pcr.areaaverage(self.Aspect, self.TopoId), ) # Set DCL to riverlength if that is longer that the basic length calculated from grid drainlength = detdrainlength(self.TopoLdd, self.xl, self.yl) @@ -1769,7 +1814,10 @@ self.Ewet = (1 - pcr.exp(-self.Kext * self.LAI)) * self.PotenEvap self.EoverR = pcr.ifthenelse( self.Precipitation > 0.0, - pcr.min(0.25, pcr.cover(self.Ewet / pcr.max(0.0001, self.Precipitation), 0.0)), + pcr.min( + 0.25, + pcr.cover(self.Ewet / pcr.max(0.0001, self.Precipitation), 0.0), + ), 0.0, ) if hasattr(self, "MAXLAI") and hasattr(self, "CWf"): @@ -1851,7 +1899,9 @@ ) # Max conversion to 8mm/day self.Snow2Glacier = ( - pcr.min(self.Snow2Glacier, 8.0) * self.timestepsecs / self.basetimestep + pcr.min(self.Snow2Glacier, 8.0) + * self.timestepsecs + / self.basetimestep ) self.Snow = self.Snow - (self.Snow2Glacier * self.GlacierFrac) @@ -1920,7 +1970,8 @@ # Runoff from water bodies and river network self.RunoffOpenWater = ( - pcr.min(1.0, self.RiverFrac + self.WaterFrac) * self.AvailableForInfiltration + pcr.min(1.0, self.RiverFrac + self.WaterFrac) + * self.AvailableForInfiltration ) # self.RunoffOpenWater = self.ZeroMap self.AvailableForInfiltration = ( @@ -1981,7 +2032,9 @@ self.InfiltCapPath * soilInfRedu < PathInf ) - InfiltSoilPath = pcr.min(MaxInfiltPath + MaxInfiltSoil, pcr.max(0.0, UStoreCapacity)) + InfiltSoilPath = pcr.min( + MaxInfiltPath + MaxInfiltSoil, pcr.max(0.0, UStoreCapacity) + ) self.In = InfiltSoilPath self.ActInfilt = InfiltSoilPath # JS Ad this to be compatible with rest @@ -2044,7 +2097,9 @@ self.UStoreLayerThickness[n], ) # Depth for calculation of vertical fluxes (bottom layer or zi) - self.z = pcr.ifthenelse(self.ZiLayer == float(n), self.zi, self.SumThickness) + self.z = pcr.ifthenelse( + self.ZiLayer == float(n), self.zi, self.SumThickness + ) self.storage.append(self.L * (self.thetaS - self.thetaR)) # First layer is treated differently than layers below first layer @@ -2070,12 +2125,21 @@ pcr.min(self.soilevapunsat, self.UStoreLayerDepth[0]), ) else: - self.soilevapunsat = pcr.min(self.soilevapunsat, self.UStoreLayerDepth[n]) + self.soilevapunsat = pcr.min( + self.soilevapunsat, self.UStoreLayerDepth[n] + ) # The remaining 'RestEvap' can be used for evaporation from the saturated layer self.RestEvap = self.RestEvap - self.soilevapunsat - self.soilevapsat = soilevap_SBM_sat(self.RestEvap,self.zi,self.thetaS,self.thetaR,self.UStoreLayerThickness,self.UStoreLayerDepth) - + self.soilevapsat = soilevap_SBM_sat( + self.RestEvap, + self.zi, + self.thetaS, + self.thetaR, + self.UStoreLayerThickness, + self.UStoreLayerDepth, + ) + # Total soil evaporation from the first soil layer self.soilevap = self.soilevapunsat + self.soilevapsat @@ -2395,7 +2459,9 @@ self.DeepTransfer = pcr.min(self.SatWaterDepth, self.DeepKsat) # ActLeakage = 0.0 # Now add leakage. to deeper groundwater - self.ActLeakage = pcr.cover(pcr.max(0.0, pcr.min(self.MaxLeakage, self.DeepTransfer)), 0) + self.ActLeakage = pcr.cover( + pcr.max(0.0, pcr.min(self.MaxLeakage, self.DeepTransfer)), 0 + ) self.Percolation = pcr.cover( pcr.max(0.0, pcr.min(self.MaxPercolation, self.DeepTransfer)), 0 ) @@ -2458,7 +2524,10 @@ Lateral = ( self.KsatHorFrac * self.KsatVer - * (pcr.exp(-self.f * self.zi) - pcr.exp(-self.f * self.SoilThickness)) + * ( + pcr.exp(-self.f * self.zi) + - pcr.exp(-self.f * self.SoilThickness) + ) * (1 / self.f) / (self.SoilThickness - self.zi) * self.waterSlope @@ -2488,7 +2557,10 @@ Lateral = ( self.KsatHorFrac * self.KsatVer - * (pcr.exp(-self.f * self.zi) - pcr.exp(-self.f * self.SoilThickness)) + * ( + pcr.exp(-self.f * self.zi) + - pcr.exp(-self.f * self.SoilThickness) + ) * (1 / self.f) / (self.SoilThickness - self.zi + 1.0) * self.waterSlope @@ -2605,7 +2677,10 @@ ponding_add = self.ZeroMap if self.nrpaddyirri > 0: ponding_add = pcr.cover( - pcr.min(pcr.ifthen(self.h_p > 0, self.inund), self.h_p - self.PondingDepth), 0.0 + pcr.min( + pcr.ifthen(self.h_p > 0, self.inund), self.h_p - self.PondingDepth + ), + 0.0, ) self.PondingDepth = self.PondingDepth + ponding_add irr_depth = ( @@ -2651,7 +2726,9 @@ 0, pcr.min( SurfaceWater * self.RiverWidth / self.reallength * 0.7, - pcr.min(self.InfiltCapSoil * (1.0 - self.PathFrac), UStoreCapacity), + pcr.min( + self.InfiltCapSoil * (1.0 - self.PathFrac), UStoreCapacity + ), ), ), ) @@ -2789,7 +2866,9 @@ ########################################################################## MaxExtract = self.InflowKinWaveCell + self.OldInwater self.SurfaceWaterSupply = pcr.ifthenelse( - self.Inflow < 0.0, pcr.min(MaxExtract, -1.0 * self.Inflow), self.ZeroMap + self.Inflow < 0.0, + pcr.min(MaxExtract, -1.0 * self.Inflow), + self.ZeroMap, ) # Fraction of demand that is not used but flows back into the river get fracttion and move to return locations self.DemandReturnFlow = pcr.cover( @@ -2827,7 +2906,9 @@ self.SurfaceRunoff * self.QMMConv ) # SurfaceRunoffMM (mm) from SurfaceRunoff (m3/s) - self.InflowKinWaveCell = pcr.upstream(self.TopoLdd, self.OldSurfaceRunoff) + self.InflowKinWaveCell = pcr.upstream( + self.TopoLdd, self.OldSurfaceRunoff + ) deltasup = float(pcr.mapmaximum(abs(oldsup - self.SurfaceWaterSupply))) if deltasup < self.breakoff or self.nrit >= self.maxitsupply: @@ -2867,7 +2948,9 @@ ) sqmarea = pcr.areatotal( self.reallength * self.reallength, - pcr.nominal(pcr.ifthen(self.IrriDemandm3 > 0, self.IrrigationPaddyAreas)), + pcr.nominal( + pcr.ifthen(self.IrriDemandm3 > 0, self.IrrigationPaddyAreas) + ), ) self.IRSupplymm = pcr.cover( @@ -2889,7 +2972,9 @@ # first column (nr 1). Assumes that outputloc and columns match! if self.updating: - self.QM = pcr.timeinputscalar(self.updateFile, self.UpdateMap) * self.QMMConv + self.QM = ( + pcr.timeinputscalar(self.updateFile, self.UpdateMap) * self.QMMConv + ) # Now update the state. Just add to the Ustore # self.UStoreDepth = result @@ -3039,7 +3124,9 @@ self.CumInt = self.CumInt + self.Interception - self.SnowCover = pcr.ifthenelse(self.Snow > 0.0, self.ZeroMap + 1.0, self.ZeroMap) + self.SnowCover = pcr.ifthenelse( + self.Snow > 0.0, self.ZeroMap + 1.0, self.ZeroMap + ) self.CumLeakage = self.CumLeakage + self.ActLeakage self.CumInwaterMM = self.CumInwaterMM + self.InwaterMM self.CumExfiltWater = self.CumExfiltWater + self.ExfiltWater Index: wflow/wflow_sbm_old.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_sbm_old.py (.../wflow_sbm_old.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_sbm_old.py (.../wflow_sbm_old.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -892,7 +892,10 @@ ) self.TopoLddOrg = self.TopoLdd self.TopoLdd = pcr.lddrepair( - pcr.cover(pcr.ifthen(pcr.boolean(self.ReserVoirLocs), pcr.ldd(5)), self.TopoLdd) + pcr.cover( + pcr.ifthen(pcr.boolean(self.ReserVoirLocs), pcr.ldd(5)), + self.TopoLdd, + ) ) else: self.nrres = 0 @@ -1029,7 +1032,8 @@ W = ( (alf * (alf + 2.0) ** (0.6666666667)) ** (0.375) * Qscale ** (0.375) - * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) ** (-0.1875) + * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) + ** (-0.1875) * self.N ** (0.375) ) # Use supplied riverwidth if possible, else calulate @@ -1107,7 +1111,9 @@ self.logger.info("Creating subcatchment-only drainage network (ldd)") ds = pcr.downstream(self.TopoLdd, self.TopoId) usid = pcr.ifthenelse(ds != self.TopoId, self.TopoId, 0) - self.TopoLdd = pcr.lddrepair(pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd)) + self.TopoLdd = pcr.lddrepair( + pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd) + ) # Used to seperate output per LandUse/management classes OutZones = self.LandUse @@ -1165,7 +1171,9 @@ self.Aspect = pcr.ifthenelse(self.Aspect <= 0.0, pcr.scalar(0.001), self.Aspect) # On Flat areas the Aspect function fails, fill in with average... self.Aspect = pcr.ifthenelse( - pcr.defined(self.Aspect), self.Aspect, pcr.areaaverage(self.Aspect, self.TopoId) + pcr.defined(self.Aspect), + self.Aspect, + pcr.areaaverage(self.Aspect, self.TopoId), ) # Set DCL to riverlength if that is longer that the basic length calculated from grid drainlength = detdrainlength(self.TopoLdd, self.xl, self.yl) @@ -1378,7 +1386,10 @@ self.Ewet = (1 - pcr.exp(-self.Kext * self.LAI)) * self.PotenEvap self.EoverR = pcr.ifthenelse( self.Precipitation > 0.0, - pcr.min(0.25, pcr.cover(self.Ewet / pcr.max(0.0001, self.Precipitation), 0.0)), + pcr.min( + 0.25, + pcr.cover(self.Ewet / pcr.max(0.0001, self.Precipitation), 0.0), + ), 0.0, ) if hasattr(self, "MAXLAI") and hasattr(self, "CWf"): @@ -1449,7 +1460,9 @@ ) # Max conversion to 8mm/day self.Snow2Glacier = ( - pcr.min(self.Snow2Glacier, 8.0) * self.timestepsecs / self.basetimestep + pcr.min(self.Snow2Glacier, 8.0) + * self.timestepsecs + / self.basetimestep ) self.Snow = self.Snow - (self.Snow2Glacier * self.GlacierFrac) @@ -1512,7 +1525,8 @@ # Runoff from water bodies and river network self.RunoffOpenWater = ( - pcr.min(1.0, self.RiverFrac + self.WaterFrac) * self.AvailableForInfiltration + pcr.min(1.0, self.RiverFrac + self.WaterFrac) + * self.AvailableForInfiltration ) # self.RunoffOpenWater = self.ZeroMap self.AvailableForInfiltration = ( @@ -1699,7 +1713,9 @@ self.DeepTransfer = pcr.min(self.SatWaterDepth, self.DeepKsat) # ActLeakage = 0.0 # Now add leakage. to deeper groundwater - self.ActLeakage = pcr.cover(pcr.max(0.0, pcr.min(self.MaxLeakage, self.DeepTransfer)), 0) + self.ActLeakage = pcr.cover( + pcr.max(0.0, pcr.min(self.MaxLeakage, self.DeepTransfer)), 0 + ) self.Percolation = pcr.cover( pcr.max(0.0, pcr.min(self.MaxPercolation, self.DeepTransfer)), 0 ) @@ -1815,7 +1831,9 @@ 0, pcr.min( SurfaceWater * self.RiverWidth / self.reallength * 0.7, - pcr.min(self.InfiltCapSoil * (1.0 - self.PathFrac), UStoreCapacity), + pcr.min( + self.InfiltCapSoil * (1.0 - self.PathFrac), UStoreCapacity + ), ), ), ) @@ -1923,7 +1941,9 @@ ########################################################################## MaxExtract = self.InflowKinWaveCell + self.OldInwater self.SurfaceWaterSupply = pcr.ifthenelse( - self.Inflow < 0.0, pcr.min(MaxExtract, -1.0 * self.Inflow), self.ZeroMap + self.Inflow < 0.0, + pcr.min(MaxExtract, -1.0 * self.Inflow), + self.ZeroMap, ) # Fraction of demand that is not used but flows back into the river get fracttion and move to return locations self.DemandReturnFlow = pcr.cover( @@ -1961,7 +1981,9 @@ self.SurfaceRunoff * self.QMMConv ) # SurfaceRunoffMM (mm) from SurfaceRunoff (m3/s) - self.InflowKinWaveCell = pcr.upstream(self.TopoLdd, self.OldSurfaceRunoff) + self.InflowKinWaveCell = pcr.upstream( + self.TopoLdd, self.OldSurfaceRunoff + ) deltasup = float(pcr.mapmaximum(abs(oldsup - self.SurfaceWaterSupply))) if deltasup < self.breakoff or self.nrit >= self.maxitsupply: @@ -2006,7 +2028,9 @@ # first column (nr 1). Assumes that outputloc and columns match! if self.updating: - self.QM = pcr.timeinputscalar(self.updateFile, self.UpdateMap) * self.QMMConv + self.QM = ( + pcr.timeinputscalar(self.updateFile, self.UpdateMap) * self.QMMConv + ) # Now update the state. Just add to the Ustore # self.UStoreDepth = result @@ -2087,7 +2111,9 @@ self.CumInt = self.CumInt + self.Interception - self.SnowCover = pcr.ifthenelse(self.Snow > 0.0, self.ZeroMap + 1.0, self.ZeroMap) + self.SnowCover = pcr.ifthenelse( + self.Snow > 0.0, self.ZeroMap + 1.0, self.ZeroMap + ) self.CumLeakage = self.CumLeakage + self.ActLeakage self.CumInwaterMM = self.CumInwaterMM + self.InwaterMM self.CumExfiltWater = self.CumExfiltWater + self.ExfiltWater Index: wflow/wflow_snow.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_snow.py (.../wflow_snow.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_snow.py (.../wflow_snow.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -177,7 +177,9 @@ rest = pcr.cover(pcr.readmap(mapname), default) else: if os.path.isfile(pathtotbl): - rest = pcr.cover(pcr.lookupscalar(pathtotbl, landuse, subcatch, soil), default) + rest = pcr.cover( + pcr.lookupscalar(pathtotbl, landuse, subcatch, soil), default + ) self.logger.info("Creating map from table: " + pathtotbl) else: self.logger.warning( @@ -474,7 +476,9 @@ RainFrac = pcr.ifthenelse( 1.0 * self.TTI == 0.0, pcr.ifthenelse(Temperature <= self.TT, pcr.scalar(0.0), pcr.scalar(1.0)), - pcr.min((Temperature - (self.TT - self.TTI / 2.0)) / self.TTI, pcr.scalar(1.0)), + pcr.min( + (Temperature - (self.TT - self.TTI / 2.0)) / self.TTI, pcr.scalar(1.0) + ), ) RainFrac = pcr.max( RainFrac, pcr.scalar(0.0) Index: wflow/wflow_sphy.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_sphy.py (.../wflow_sphy.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_sphy.py (.../wflow_sphy.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -515,7 +515,9 @@ for i in pars: try: setattr( - self, i, pcr.readmap(self.inpath + config.get("GROUNDW_PARS", i)) + self, + i, + pcr.readmap(self.inpath + config.get("GROUNDW_PARS", i)), ) except: setattr( @@ -605,7 +607,9 @@ pars = ["DDFG", "DDFDG", "GlacF"] for i in pars: try: - setattr(self, i, pcr.readmap(self.inpath + config.get("GLACIER", i))) + setattr( + self, i, pcr.readmap(self.inpath + config.get("GLACIER", i)) + ) except: # setattr(self, i, config.getfloat('GLACIER',i)) setattr(self, i, float(configget(self.config, "GLACIER", i, i))) @@ -686,7 +690,9 @@ # -read lake maps and parameters if lake module is used if self.LakeFLAG == 1: # nominal map with lake IDs - self.LakeID = pcr.cover(pcr.readmap(self.inpath + config.get("LAKE", "LakeId")), 0) + self.LakeID = pcr.cover( + pcr.readmap(self.inpath + config.get("LAKE", "LakeId")), 0 + ) # lookup table with function for each lake (exp, 1-order poly, 2-order poly, 3-order poly) LakeFunc_Tab = self.inpath + config.get("LAKE", "LakeFunc") # lookup table with Qh-coeficients for each lake @@ -945,7 +951,8 @@ if self.LakeFLAG == 1: LakeStor_Tab = self.inpath + config.get("LAKE", "LakeStor") self.StorRES = ( - pcr.cover(pcr.lookupscalar(LakeStor_Tab, 1, self.LakeID), 0) * 10 ** 6 + pcr.cover(pcr.lookupscalar(LakeStor_Tab, 1, self.LakeID), 0) + * 10 ** 6 ) # convert to m3 # -Qfrac for lake cells should be zero, else 1 self.QFRAC = pcr.ifthenelse(self.LakeID != 0, pcr.scalar(0), 1) @@ -957,7 +964,9 @@ try: self.StorRES = self.StorRES + ResStor # -Qfrac for reservoir cells should be zero, else 1 - self.QFRAC = pcr.ifthenelse(self.ResID != 0, pcr.scalar(0), self.QFRAC) + self.QFRAC = pcr.ifthenelse( + self.ResID != 0, pcr.scalar(0), self.QFRAC + ) except: self.StorRES = ResStor # -Qfrac for reservoir cells should be zero, else 1 @@ -975,7 +984,8 @@ i + "stor", ( pcr.cover( - pcr.lookupscalar(LakeStor_Tab, column + 2, self.LakeID), 0 + pcr.lookupscalar(LakeStor_Tab, column + 2, self.LakeID), + 0, ) + pcr.cover( pcr.lookupscalar(ResStor_Tab, column + 3, self.ResID), 0 @@ -993,7 +1003,8 @@ self, i + "stor", pcr.cover( - pcr.lookupscalar(LakeStor_Tab, column + 2, self.LakeID), 0 + pcr.lookupscalar(LakeStor_Tab, column + 2, self.LakeID), + 0, ) * 10 ** 6, ) @@ -1007,7 +1018,10 @@ self, i + "stor", pcr.cover( - pcr.lookupscalar(ResStor_Tab, column + 3, self.ResID), 0 + pcr.lookupscalar( + ResStor_Tab, column + 3, self.ResID + ), + 0, ) * 10 ** 6, ) @@ -1743,7 +1757,10 @@ self.RootWater = self.RootWater - RootRunoff # -Actual evapotranspiration etreddry = pcr.max( - pcr.min((self.RootWater - self.RootDry) / (self.RootWilt - self.RootDry), 1), 0 + pcr.min( + (self.RootWater - self.RootDry) / (self.RootWilt - self.RootDry), 1 + ), + 0, ) ETact = self.ET.ETact( pcr, ETpot, self.RootWater, self.RootSat, etreddry, RainFrac @@ -1758,7 +1775,8 @@ self.RoutFLAG == 1 or self.ResFLAG == 1 or self.LakeFLAG == 1 ): self.ETaSubBasinTSS.sample( - pcr.catchmenttotal(ActETact, self.FlowDir) / pcr.catchmenttotal(1, self.FlowDir) + pcr.catchmenttotal(ActETact, self.FlowDir) + / pcr.catchmenttotal(1, self.FlowDir) ) # -Update rootwater content self.RootWater = pcr.max(self.RootWater - ETact, 0) @@ -1796,7 +1814,9 @@ self.SeePage = self.SeepOld # -Report seepage self.reporting.reporting(self, pcr, "TotSeepF", pcr.scalar(self.SeePage)) - self.SubWater = pcr.min(pcr.max(self.SubWater - self.SeePage, 0), self.SubSat) + self.SubWater = pcr.min( + pcr.max(self.SubWater - self.SeePage, 0), self.SubSat + ) if self.mm_rep_FLAG == 1 and ( self.RoutFLAG == 1 or self.ResFLAG == 1 or self.LakeFLAG == 1 ): @@ -1985,7 +2005,8 @@ # -report flux in mm if self.mm_rep_FLAG == 1: self.QTOTSubBasinTSS.sample( - ((Q * 3600 * 24) / pcr.catchmenttotal(pcr.cellarea(), self.FlowDir)) * 1000 + ((Q * 3600 * 24) / pcr.catchmenttotal(pcr.cellarea(), self.FlowDir)) + * 1000 ) # -report lake and reservoir waterbalance if self.LakeFLAG == 1 and config.getint("REPORTING", "Lake_wbal") == 1: @@ -2153,7 +2174,8 @@ self.reporting.reporting(self, pcr, "QallRAtot", Q) if self.mm_rep_FLAG == 1: self.QTOTSubBasinTSS.sample( - ((Q * 3600 * 24) / pcr.catchmenttotal(pcr.cellarea(), self.FlowDir)) * 1000 + ((Q * 3600 * 24) / pcr.catchmenttotal(pcr.cellarea(), self.FlowDir)) + * 1000 ) # -Snow routing if self.SnowRA_FLAG == 1 and self.SnowFLAG == 1: Index: wflow/wflow_topoflex.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_topoflex.py (.../wflow_topoflex.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_topoflex.py (.../wflow_topoflex.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -174,7 +174,9 @@ rest = pcr.cover(pcr.readmap(mapname), default) else: if os.path.isfile(pathtotbl): - rest = pcr.cover(pcr.lookupscalar(pathtotbl, landuse, subcatch, soil), default) + rest = pcr.cover( + pcr.lookupscalar(pathtotbl, landuse, subcatch, soil), default + ) self.logger.info("Creating map from table: " + pathtotbl) else: self.logger.warning( @@ -903,8 +905,12 @@ ) # list * scalar ---> list wordt zoveel x gekopieerd als scalar. # initialise list for lag function - self.convQu = [[0 * pcr.scalar(self.catchArea)] * self.Tf[i] for i in self.Classes] - self.convQa = [[0 * pcr.scalar(self.catchArea)] * self.Tfa[i] for i in self.Classes] + self.convQu = [ + [0 * pcr.scalar(self.catchArea)] * self.Tf[i] for i in self.Classes + ] + self.convQa = [ + [0 * pcr.scalar(self.catchArea)] * self.Tfa[i] for i in self.Classes + ] if self.scalarInput: self.gaugesMap = pcr.nominal( @@ -915,7 +921,9 @@ ) # location of subcatchment self.OutputIdRunoff = pcr.boolean( pcr.ifthenelse( - self.gaugesR == 1, 1 * pcr.scalar(self.TopoId), 0 * pcr.scalar(self.TopoId) + self.gaugesR == 1, + 1 * pcr.scalar(self.TopoId), + 0 * pcr.scalar(self.TopoId), ) ) # location of subcatchment @@ -953,7 +961,8 @@ W = ( (alf * (alf + 2.0) ** (0.6666666667)) ** (0.375) * Qscale ** (0.375) - * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) ** (-0.1875) + * (pcr.max(0.0001, pcr.windowaverage(self.Slope, pcr.celllength() * 4.0))) + ** (-0.1875) * self.N ** (0.375) ) # Use supplied riverwidth if possible, else calulate @@ -978,7 +987,9 @@ self.logger.info("Creating subcatchment-only drainage network (ldd)") ds = pcr.downstream(self.TopoLdd, self.TopoId) usid = pcr.ifthenelse(ds != self.TopoId, self.TopoId, 0) - self.TopoLdd = pcr.lddrepair(pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd)) + self.TopoLdd = pcr.lddrepair( + pcr.ifthenelse(pcr.boolean(usid), pcr.ldd(5), self.TopoLdd) + ) # Used to seperate output per LandUse/management classes # OutZones = self.LandUse @@ -1449,7 +1460,9 @@ sum(multiply(self.Sw_t, self.percent)) / 1000 * self.surfaceArea, pcr.nominal(self.TopoId), ) - self.SsWB = pcr.areatotal(self.Ss / 1000 * self.surfaceArea, pcr.nominal(self.TopoId)) + self.SsWB = pcr.areatotal( + self.Ss / 1000 * self.surfaceArea, pcr.nominal(self.TopoId) + ) self.Ss_WB = pcr.areatotal( self.Ss_t / 1000 * self.surfaceArea, pcr.nominal(self.TopoId) ) Index: wflow/wflow_w3ra.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_w3ra.py (.../wflow_w3ra.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_w3ra.py (.../wflow_w3ra.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -145,7 +145,9 @@ #: pcraster option to calculate with units or cells. Not really an issue #: in this model but always good to keep in mind. pcr.setglobaloption("unittrue") - pcr.setglobaloption("radians") # Needed as W3RA was originally written in matlab + pcr.setglobaloption( + "radians" + ) # Needed as W3RA was originally written in matlab # SET GLBOAL PARAMETER VALUES (however not used in original script) # Nhru=2 @@ -494,7 +496,8 @@ self.wf_readmap(self.WINDSPEED_mapstack, default=1.0), pcr.scalar(1.0) ) self.AIRPRESS = pcr.cover( - self.wf_readmap(self.AIRPRESS_mapstack, default=980.0), pcr.scalar(980.0) + self.wf_readmap(self.AIRPRESS_mapstack, default=980.0), + pcr.scalar(980.0), ) # print "Using climatology for wind, air pressure and albedo." elif self.UseETPdata == 0: @@ -523,16 +526,28 @@ # conversion daylength pcr.setglobaloption("radians") - m = pcr.scalar(1) - pcr.tan((self.latitude * pcr.scalar(math.pi) / pcr.scalar(180))) * pcr.tan( + m = pcr.scalar(1) - pcr.tan( + (self.latitude * pcr.scalar(math.pi) / pcr.scalar(180)) + ) * pcr.tan( ( (pcr.scalar(23.439) * pcr.scalar(math.pi) / pcr.scalar(180)) - * pcr.cos(pcr.scalar(2) * pcr.scalar(math.pi) * (doy + pcr.scalar(9)) / pcr.scalar(365.25)) + * pcr.cos( + pcr.scalar(2) + * pcr.scalar(math.pi) + * (doy + pcr.scalar(9)) + / pcr.scalar(365.25) + ) ) ) self.fday = pcr.min( pcr.max( pcr.scalar(0.02), - pcr.scalar(pcr.acos(pcr.scalar(1) - pcr.min(pcr.max(pcr.scalar(0), m), pcr.scalar(2)))) + pcr.scalar( + pcr.acos( + pcr.scalar(1) + - pcr.min(pcr.max(pcr.scalar(0), m), pcr.scalar(2)) + ) + ) / pcr.scalar(math.pi), ), pcr.scalar(1), @@ -552,7 +567,8 @@ Ta = self.TMIN + pcr.scalar(0.75) * (self.TMAX - self.TMIN) # T in degC T24 = self.TMIN + pcr.scalar(0.5) * (self.TMAX - self.TMIN) # T in degC pex = pcr.min( - pcr.scalar(17.27) * (self.TMIN) / (pcr.scalar(237.3) + self.TMIN), pcr.scalar(10) + pcr.scalar(17.27) * (self.TMIN) / (pcr.scalar(237.3) + self.TMIN), + pcr.scalar(10), ) # T in degC pe = pcr.min( pcr.scalar(610.8) * (pcr.exp(pex)), pcr.scalar(10000.0) @@ -596,14 +612,20 @@ # for i=1:par.Nhru fwater1 = pcr.min(0.005, (0.007 * self.Sr ** 0.75)) fwater2 = pcr.min(0.005, (0.007 * self.Sr ** 0.75)) - fsat1 = pcr.min(1.0, pcr.max(pcr.min(0.005, 0.007 * self.Sr ** 0.75), Sgfree / self.Sgref)) - fsat2 = pcr.min(1.0, pcr.max(pcr.min(0.005, 0.007 * self.Sr ** 0.75), Sgfree / self.Sgref)) + fsat1 = pcr.min( + 1.0, pcr.max(pcr.min(0.005, 0.007 * self.Sr ** 0.75), Sgfree / self.Sgref) + ) + fsat2 = pcr.min( + 1.0, pcr.max(pcr.min(0.005, 0.007 * self.Sr ** 0.75), Sgfree / self.Sgref) + ) Sghru1 = self.Sg Sghru2 = self.Sg # CALCULATION OF PET # Conversions and coefficients (3.1) - pesx = pcr.min((pcr.scalar(17.27) * Ta / (pcr.scalar(237.3) + Ta)), pcr.scalar(10)) + pesx = pcr.min( + (pcr.scalar(17.27) * Ta / (pcr.scalar(237.3) + Ta)), pcr.scalar(10) + ) pes = pcr.min( pcr.scalar((pcr.scalar(610.8)) * pcr.exp(pesx)), pcr.scalar(10000) ) # saturated vapour pressure @@ -650,7 +672,9 @@ self.RLn = self.RLin - RLout self.fGR1 = self.Gfrac_max1 * (1 - pcr.exp(-fsoil1 / self.fvegref_G1)) - self.fGR2 = self.Gfrac_max2 * (1 - pcr.exp(-fsoil2 / self.fvegref_G2)) # (3.5) + self.fGR2 = self.Gfrac_max2 * ( + 1 - pcr.exp(-fsoil2 / self.fvegref_G2) + ) # (3.5) self.Rneff1 = (RSn1 + self.RLn) * (1 - self.fGR1) self.Rneff2 = (RSn2 + self.RLn) * (1 - self.fGR2) @@ -703,14 +727,26 @@ Et2 = pcr.min(Utot2, Etmax2) # # Root water uptake distribution (2.3) - U01 = pcr.max(pcr.min((U0max1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.S01 - 1e-2), 0) - Us1 = pcr.max(pcr.min((Usmax1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.Ss1 - 1e-2), 0) - Ud1 = pcr.max(pcr.min((Udmax1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.Sd1 - 1e-2), 0) + U01 = pcr.max( + pcr.min((U0max1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.S01 - 1e-2), 0 + ) + Us1 = pcr.max( + pcr.min((Usmax1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.Ss1 - 1e-2), 0 + ) + Ud1 = pcr.max( + pcr.min((Udmax1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.Sd1 - 1e-2), 0 + ) Et1 = U01 + Us1 + Ud1 # to ensure mass balance - U02 = pcr.max(pcr.min((U0max2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.S02 - 1e-2), 0) - Us2 = pcr.max(pcr.min((Usmax2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.Ss2 - 1e-2), 0) - Ud2 = pcr.max(pcr.min((Udmax2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.Sd2 - 1e-2), 0) + U02 = pcr.max( + pcr.min((U0max2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.S02 - 1e-2), 0 + ) + Us2 = pcr.max( + pcr.min((Usmax2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.Ss2 - 1e-2), 0 + ) + Ud2 = pcr.max( + pcr.min((Udmax2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.Sd2 - 1e-2), 0 + ) Et2 = U02 + Us2 + Ud2 # Soil evaporation (4.5) @@ -720,8 +756,12 @@ w02 = self.S02 / self.S0FC2 # (2.1) fsoilE1 = self.FsoilEmax1 * pcr.min(1, w01 / self.w0limE1) fsoilE2 = self.FsoilEmax2 * pcr.min(1, w02 / self.w0limE2) - Es1 = pcr.max(0, pcr.min(((1 - fsat1) * fsoilE1 * (self.E01 - Et1)), self.S01 - 1e-2)) - Es2 = pcr.max(0, pcr.min(((1 - fsat2) * fsoilE2 * (self.E02 - Et2)), self.S02 - 1e-2)) + Es1 = pcr.max( + 0, pcr.min(((1 - fsat1) * fsoilE1 * (self.E01 - Et1)), self.S01 - 1e-2) + ) + Es2 = pcr.max( + 0, pcr.min(((1 - fsat2) * fsoilE2 * (self.E02 - Et2)), self.S02 - 1e-2) + ) # Groundwater evaporation (4.6) Eg1 = pcr.min((fsat1 - fwater1) * self.FsoilEmax1 * (self.E01 - Et1), Sghru1) Eg2 = pcr.min((fsat2 - fwater2) * self.FsoilEmax2 * (self.E02 - Et2), Sghru2) @@ -900,10 +940,12 @@ self.Sd1 = self.Sd1 - Dd1 self.Sd2 = self.Sd2 - Dd2 Y1 = pcr.min( - self.Fgw_conn1 * pcr.max(0, self.wdlimU1 * self.SdFC1 - self.Sd1), Sghru1 - Eg1 + self.Fgw_conn1 * pcr.max(0, self.wdlimU1 * self.SdFC1 - self.Sd1), + Sghru1 - Eg1, ) Y2 = pcr.min( - self.Fgw_conn2 * pcr.max(0, self.wdlimU2 * self.SdFC2 - self.Sd2), Sghru2 - Eg2 + self.Fgw_conn2 * pcr.max(0, self.wdlimU2 * self.SdFC2 - self.Sd2), + Sghru2 - Eg2, ) # Y = Fgw_conn.*max(0,wdlimU.*SdFC-Sd); #nog matlab script self.Sd1 = self.Sd1 + Y1 Index: wflow/wflow_w3ra_new.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_w3ra_new.py (.../wflow_w3ra_new.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_w3ra_new.py (.../wflow_w3ra_new.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -141,7 +141,9 @@ #: pcraster option to calculate with units or cells. Not really an issue #: in this model but always good to keep in mind. pcr.setglobaloption("unittrue") - pcr.setglobaloption("radians") # Needed as W3RA was originally written in matlab + pcr.setglobaloption( + "radians" + ) # Needed as W3RA was originally written in matlab # SET GLBOAL PARAMETER VALUES (however not used in original script) # Nhru=2 @@ -519,16 +521,28 @@ # conversion daylength pcr.setglobaloption("radians") - m = pcr.scalar(1) - math.tan((self.latitude * pcr.scalar(math.pi) / pcr.scalar(180))) * math.tan( + m = pcr.scalar(1) - math.tan( + (self.latitude * pcr.scalar(math.pi) / pcr.scalar(180)) + ) * math.tan( ( (pcr.scalar(23.439) * pcr.scalar(math.pi) / pcr.scalar(180)) - * cos(pcr.scalar(2) * pcr.scalar(math.pi) * (doy + pcr.scalar(9)) / pcr.scalar(365.25)) + * cos( + pcr.scalar(2) + * pcr.scalar(math.pi) + * (doy + pcr.scalar(9)) + / pcr.scalar(365.25) + ) ) ) self.fday = pcr.min( pcr.max( pcr.scalar(0.02), - pcr.scalar(pcr.acos(pcr.scalar(1) - pcr.min(pcr.max(pcr.scalar(0), m), pcr.scalar(2)))) + pcr.scalar( + pcr.acos( + pcr.scalar(1) + - pcr.min(pcr.max(pcr.scalar(0), m), pcr.scalar(2)) + ) + ) / pcr.scalar(math.pi), ), pcr.scalar(1), @@ -548,7 +562,8 @@ Ta = self.TMIN + pcr.scalar(0.75) * (self.TMAX - self.TMIN) # T in degC T24 = self.TMIN + pcr.scalar(0.5) * (self.TMAX - self.TMIN) # T in degC pex = pcr.min( - pcr.scalar(17.27) * (self.TMIN) / (pcr.scalar(237.3) + self.TMIN), pcr.scalar(10) + pcr.scalar(17.27) * (self.TMIN) / (pcr.scalar(237.3) + self.TMIN), + pcr.scalar(10), ) # T in degC pe = pcr.min( pcr.scalar(610.8) * (pcr.exp(pex)), pcr.scalar(10000.0) @@ -597,14 +612,20 @@ # for i=1:par.Nhru fwater1 = pcr.min(0.005, (0.007 * self.Sr ** 0.75)) fwater2 = pcr.min(0.005, (0.007 * self.Sr ** 0.75)) - fsat1 = pcr.min(1.0, pcr.max(pcr.min(0.005, 0.007 * self.Sr ** 0.75), Sgfree / self.Sgref)) - fsat2 = pcr.min(1.0, pcr.max(pcr.min(0.005, 0.007 * self.Sr ** 0.75), Sgfree / self.Sgref)) + fsat1 = pcr.min( + 1.0, pcr.max(pcr.min(0.005, 0.007 * self.Sr ** 0.75), Sgfree / self.Sgref) + ) + fsat2 = pcr.min( + 1.0, pcr.max(pcr.min(0.005, 0.007 * self.Sr ** 0.75), Sgfree / self.Sgref) + ) Sghru1 = self.Sg Sghru2 = self.Sg # CALCULATION OF PET # Conversions and coefficients (3.1) - pesx = pcr.min((pcr.scalar(17.27) * Ta / (pcr.scalar(237.3) + Ta)), pcr.scalar(10)) + pesx = pcr.min( + (pcr.scalar(17.27) * Ta / (pcr.scalar(237.3) + Ta)), pcr.scalar(10) + ) pes = pcr.min( pcr.scalar((pcr.scalar(610.8)) * pcr.exp(pesx)), pcr.scalar(10000) ) # saturated vapour pressure @@ -650,7 +671,9 @@ self.RLn = self.RLin - RLout self.fGR1 = self.Gfrac_max1 * (1 - pcr.exp(-fsoil1 / self.fvegref_G1)) - self.fGR2 = self.Gfrac_max2 * (1 - pcr.exp(-fsoil2 / self.fvegref_G2)) # (3.5) + self.fGR2 = self.Gfrac_max2 * ( + 1 - pcr.exp(-fsoil2 / self.fvegref_G2) + ) # (3.5) self.Rneff1 = (RSn1 + self.RLn) * (1 - self.fGR1) self.Rneff2 = (RSn2 + self.RLn) * (1 - self.fGR2) @@ -703,14 +726,26 @@ Et2 = pcr.min(Utot2, Etmax2) # # Root water uptake distribution (2.3) - U01 = pcr.max(pcr.min((U0max1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.S01 - 1e-2), 0) - Us1 = pcr.max(pcr.min((Usmax1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.Ss1 - 1e-2), 0) - Ud1 = pcr.max(pcr.min((Udmax1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.Sd1 - 1e-2), 0) + U01 = pcr.max( + pcr.min((U0max1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.S01 - 1e-2), 0 + ) + Us1 = pcr.max( + pcr.min((Usmax1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.Ss1 - 1e-2), 0 + ) + Ud1 = pcr.max( + pcr.min((Udmax1 / (U0max1 + Usmax1 + Udmax1)) * Et1, self.Sd1 - 1e-2), 0 + ) Et1 = U01 + Us1 + Ud1 # to ensure mass balance - U02 = pcr.max(pcr.min((U0max2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.S02 - 1e-2), 0) - Us2 = pcr.max(pcr.min((Usmax2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.Ss2 - 1e-2), 0) - Ud2 = pcr.max(pcr.min((Udmax2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.Sd2 - 1e-2), 0) + U02 = pcr.max( + pcr.min((U0max2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.S02 - 1e-2), 0 + ) + Us2 = pcr.max( + pcr.min((Usmax2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.Ss2 - 1e-2), 0 + ) + Ud2 = pcr.max( + pcr.min((Udmax2 / (U0max2 + Usmax2 + Udmax2)) * Et2, self.Sd2 - 1e-2), 0 + ) Et2 = U02 + Us2 + Ud2 # Soil evaporation (4.5) @@ -720,8 +755,12 @@ w02 = self.S02 / self.S0FC2 # (2.1) fsoilE1 = self.FsoilEmax1 * pcr.min(1, w01 / self.w0limE1) fsoilE2 = self.FsoilEmax2 * pcr.min(1, w02 / self.w0limE2) - Es1 = pcr.max(0, pcr.min(((1 - fsat1) * fsoilE1 * (self.E01 - Et1)), self.S01 - 1e-2)) - Es2 = pcr.max(0, pcr.min(((1 - fsat2) * fsoilE2 * (self.E02 - Et2)), self.S02 - 1e-2)) + Es1 = pcr.max( + 0, pcr.min(((1 - fsat1) * fsoilE1 * (self.E01 - Et1)), self.S01 - 1e-2) + ) + Es2 = pcr.max( + 0, pcr.min(((1 - fsat2) * fsoilE2 * (self.E02 - Et2)), self.S02 - 1e-2) + ) # Groundwater evaporation (4.6) Eg1 = pcr.min((fsat1 - fwater1) * self.FsoilEmax1 * (self.E01 - Et1), Sghru1) Eg2 = pcr.min((fsat2 - fwater2) * self.FsoilEmax2 * (self.E02 - Et2), Sghru2) @@ -896,10 +935,12 @@ self.Sd1 = self.Sd1 - Dd1 self.Sd2 = self.Sd2 - Dd2 Y1 = pcr.min( - self.Fgw_conn1 * pcr.max(0, self.wdlimU1 * self.SdFC1 - self.Sd1), Sghru1 - Eg1 + self.Fgw_conn1 * pcr.max(0, self.wdlimU1 * self.SdFC1 - self.Sd1), + Sghru1 - Eg1, ) Y2 = pcr.min( - self.Fgw_conn2 * pcr.max(0, self.wdlimU2 * self.SdFC2 - self.Sd2), Sghru2 - Eg2 + self.Fgw_conn2 * pcr.max(0, self.wdlimU2 * self.SdFC2 - self.Sd2), + Sghru2 - Eg2, ) # Y = Fgw_conn.*max(0,wdlimU.*SdFC-Sd); #nog matlab script self.Sd1 = self.Sd1 + Y1 Index: wflow/wflow_wave.py =================================================================== diff -u -rc427e9b948a7fbad40a1c828b68355cb277dc5e0 -ra9498adee6baab0a0abaa331041be8948510167b --- wflow/wflow_wave.py (.../wflow_wave.py) (revision c427e9b948a7fbad40a1c828b68355cb277dc5e0) +++ wflow/wflow_wave.py (.../wflow_wave.py) (revision a9498adee6baab0a0abaa331041be8948510167b) @@ -170,7 +170,9 @@ + (self.ChannelForm * self.WaterLevelDyn * 2.0) + self.ChannelBottomWidth ) / 2.0 - self.AChannel = pcr.min(self.WaterLevelDyn, self.ChannelDepth) * ChannelSurface + self.AChannel = ( + pcr.min(self.WaterLevelDyn, self.ChannelDepth) * ChannelSurface + ) self.AFloodplain = pcr.max( (self.WaterLevelDyn - self.ChannelDepth) * self.FloodplainWidth, 0.0 ) @@ -272,7 +274,9 @@ self.FloodPlainVol = self.AFloodplain * self.ChannelLength self.ChannelVol = self.AChannel * self.ChannelLength fxboun = pcr.ifthen(self.dynHBoundary > 0, pcr.scalar(levelBoun)) - self.WaterLevelDyn = pcr.cover(pcr.ifthen(fxboun > 0, fxboun), self.WaterLevelDyn) + self.WaterLevelDyn = pcr.cover( + pcr.ifthen(fxboun > 0, fxboun), self.WaterLevelDyn + ) def stateVariables(self): """ @@ -405,7 +409,9 @@ if wflow_dynriver == "not_set": self.DynRiver = pcr.boolean(self.River) else: - self.DynRiver = pcr.boolean(pcr.readmap(os.path.join(self.Dir, wflow_dynriver))) + self.DynRiver = pcr.boolean( + pcr.readmap(os.path.join(self.Dir, wflow_dynriver)) + ) self.ChannelDepth = pcrut.readmapSave( self.Dir + "/staticmaps/ChannelDepth.map", 8.0 @@ -423,7 +429,9 @@ self.ChannelRoughness = pcrut.readmapSave( self.Dir + "/staticmaps/ChannelRoughness.map", 0.03 ) - self.ChannelRoughness = self.ChannelRoughness * pcr.scalar(pcr.boolean(self.DynRiver)) + self.ChannelRoughness = self.ChannelRoughness * pcr.scalar( + pcr.boolean(self.DynRiver) + ) # COnvert to chezy # self.ChannelRoughness = 1.49/self.ChannelRoughness self.ChannelLength = self.DCL * pcr.scalar(pcr.boolean(self.DynRiver)) @@ -441,7 +449,9 @@ * pcr.scalar(pcr.boolean(self.DynRiver)), ) - self.Structures = pcr.boolean(self.ZeroMap * pcr.scalar(pcr.boolean(self.DynRiver))) + self.Structures = pcr.boolean( + self.ZeroMap * pcr.scalar(pcr.boolean(self.DynRiver)) + ) self.StructureA = self.ZeroMap * pcr.scalar(pcr.boolean(self.DynRiver)) self.StructureB = self.ZeroMap * pcr.scalar(pcr.boolean(self.DynRiver)) self.StructureCrestLevel = self.ZeroMap * pcr.scalar(pcr.boolean(self.DynRiver)) @@ -496,7 +506,9 @@ #: here which pick upt the variable save by a call to wf_suspend() if self.reinit == 1: self.logger.info("Setting initial conditions to default (zero!)") - self.WaterLevelDyn = (self.ZeroMap + 0.1) * pcr.scalar(pcr.boolean(self.River)) + self.WaterLevelDyn = (self.ZeroMap + 0.1) * pcr.scalar( + pcr.boolean(self.River) + ) self.SurfaceRunoffDyn = self.ZeroMap * pcr.scalar(pcr.boolean(self.River)) else: