epsg=srs,
desc=args.description)
# Import DEM into location
demFilepath = os.path.join(context.projectDir, manifest['dem'])
#print demFilepath
result = grassLib.script.run_command('r.in.gdal',
flags="e",
input=demFilepath,
output='dem')
if result != 0:
sys.exit("Failed to import DEM into new GRASS dataset %s/%s, results:\n%s" % \
(grassDbase, args.location, result) )
# Set region to DEM
result = grassLib.script.run_command('g.region', rast='dem')
if result != 0:
sys.exit("Failed to set region to DEM")
# Update metadata
RHESSysMetadata.writeGRASSEntry(context, 'dem_rast', 'dem')
RHESSysMetadata.writeRHESSysEntry(context, 'grass_dbase', dbase)
RHESSysMetadata.writeRHESSysEntry(context, 'grass_location',
grassConfig.location)
RHESSysMetadata.writeRHESSysEntry(context, 'grass_mapset', grassConfig.mapset)
RHESSysMetadata.writeRHESSysEntry(context, 'rhessys_dir', paths.rhessysDir)
RHESSysMetadata.writeRHESSysEntry(context, 'model_description',
args.description)
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
if result != 0:
sys.exit("r.mask filed, returning %s" % (result,) )
result = grassLib.script.run_command('g.region', rast=demRast)
if result != 0:
sys.exit("g.region failed to set region to DEM, returning %s" % (result,))
if not args.defonly:
sys.stdout.write('Generating soil texture map from percent sand and clay maps...')
sys.stdout.flush()
# Import percent sand and percent clay raster maps into GRASS
percentSandRasterPath = os.path.join(context.projectDir, manifest['soil_raster_pctsand'])
result = grassLib.script.run_command('r.in.gdal', input=percentSandRasterPath, output='soil_pctsand', overwrite=args.overwrite)
if result != 0:
sys.exit("Failed to import soil_raster_pctsand into GRASS dataset %s/%s, results:\n%s" % \
(grassDbase, metadata['grass_location'], result) )
RHESSysMetadata.writeGRASSEntry(context, 'soil_pctsand_rast', 'soil_pctsand')
percentClayRasterPath = os.path.join(context.projectDir, manifest['soil_raster_pctclay'])
result = grassLib.script.run_command('r.in.gdal', input=percentClayRasterPath, output='soil_pctclay', overwrite=args.overwrite)
if result != 0:
sys.exit("Failed to import soil_raster_pctclay into GRASS dataset %s/%s, results:\n%s" % \
(grassDbase, metadata['grass_location'], result) )
RHESSysMetadata.writeGRASSEntry(context, 'soil_pctclay_rast', 'soil_pctclay')
# Generate soil texture map
schemePath = os.path.join(moduleEtc, 'USDA.dat')
if not os.access(schemePath, os.R_OK):
raise IOError(errno.EACCES, "Not allowed to read r.soils.texture scheme %s" % (schemePath,) )
soilTexture = os.path.join(modulePath, 'r.soils.texture')
result = grassLib.script.read_command(soilTexture, sand='soil_pctsand', clay='soil_pctclay',
scheme=schemePath, output=soil_rast, overwrite=args.overwrite)
(stdoutStr, stderrStr) = p.communicate()
result = p.returncode
if result != 0:
sys.stdout.write(stdoutStr)
sys.exit("\nv.in.ascii failed, returning %s" % (result,))
# Generate Thiessen polygons
p = grassLib.script.pipe_command('v.voronoi', input='basestation_points', output='basestation_areas',
overwrite=args.overwrite)
(stdoutStr, stderrStr) = p.communicate()
result = p.returncode
if result != 0:
sys.stdout.write(stdoutStr)
sys.exit("\nv.voronoi failed, returning %s" % (result,))
# Rasterize Thiessen polygons
p = grassLib.script.pipe_command('v.to.rast', input='basestation_areas', output='basestations',
use='cat', labelcolumn='name', overwrite=args.overwrite)
(stdoutStr, stderrStr) = p.communicate()
result = p.returncode
if result != 0:
sys.stdout.write(stdoutStr)
sys.exit("\nv.to.rast failed, returning %s" % (result,))
# Write metadata
RHESSysMetadata.writeRHESSysEntry( context, 'basestations_text', paths.relpath(basestationsDest) )
RHESSysMetadata.writeGRASSEntry( context, 'basestations_rast', 'basestations' )
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
sys.stdout.flush()
demCols = int(studyArea['dem_columns'])
result = grassLib.script.write_command('r.mapcalc',
stdin="%s=(row()-1) * %d + col()" % (PATCH_RAST, demCols) )
if result != 0:
sys.exit("r.mapcalc failed to create patch map, returning %s" % (result,))
if args.patchType == 'clump':
if args.clumpMap == 'wetness_index':
clumpMap = grassMetadata['wetness_index_rast']
else:
clumpMap = demRast
sys.stdout.write("Generating clumped patch map based on %s raster...\n" % (clumpMap) )
sys.stdout.flush()
result = grassLib.script.run_command('r.clump', input=clumpMap, output=PATCH_RAST, overwrite=args.overwrite)
if result != 0:
sys.exit("r.mapcalc failed to create patch map, returning %s" % (result,))
sys.stdout.write('done\n')
# Write metadata
RHESSysMetadata.writeGRASSEntry(context, 'patch_rast', PATCH_RAST)
if args.forceZone or not 'zone_rast' in grassMetadata:
# Only overwrite zone raster
RHESSysMetadata.writeGRASSEntry(context, 'zone_rast', PATCH_RAST)
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
# Convert raster to integer
sys.stdout.write(
"Converting %s raster to integer using multiplier %s...\n" %
(t, str(args.multiplier)))
sys.stdout.flush()
mapcalcCmd = "%s=int(%s * %s)" % (t, importName,
str(args.multiplier))
print(mapcalcCmd)
result = grassLib.script.write_command('r.mapcalc',
stdin=mapcalcCmd)
if result != 0:
sys.exit("Integer conversion failed for raster %s of GRASS dataset %s/%s, result:\n%s" % \
(t, grassDbase, metadata['grass_location'], result) )
result = grassLib.script.run_command('g.remove', rast=importName)
if result != 0:
sys.exit("Failed to delete temporary raster %s of GRASS dataset %s/%s, result:\n%s" % \
(importName, grassDbase, metadata['grass_location'], result) )
grassEntryKey = "%s_rast" % (t, )
RHESSysMetadata.writeGRASSEntry(context, grassEntryKey, t)
sys.stdout.write('done\n')
# Invalidate metadata as necessary
if t == RHESSysMetadata.RASTER_TYPE_LC:
RHESSysMetadata.deleteRHESSysEntry(context, 'stratum_defs')
RHESSysMetadata.deleteRHESSysEntry(context, 'landuse_defs')
elif t == RHESSysMetadata.RASTER_TYPE_SOIL:
RHESSysMetadata.deleteRHESSysEntry(context, 'soil_defs')
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
# Set up GRASS environment
grassConfig = GRASSConfig(context, grassDbase, location, mapset, newLocation=True, overwrite=args.overwrite)
grassLib = GRASSLib(grassConfig=grassConfig)
# Create the new location
grassLib.script.core.create_location(grassConfig.dbase, grassConfig.location, epsg=srs, desc=args.description)
# Import DEM into location
demFilepath = os.path.join(context.projectDir, manifest["dem"])
# print demFilepath
result = grassLib.script.run_command("r.in.gdal", flags="e", input=demFilepath, output="dem")
if result != 0:
sys.exit("Failed to import DEM into new GRASS dataset %s/%s, results:\n%s" % (grassDbase, args.location, result))
# Set region to DEM
result = grassLib.script.run_command("g.region", rast="dem")
if result != 0:
sys.exit("Failed to set region to DEM")
# Update metadata
RHESSysMetadata.writeGRASSEntry(context, "dem_rast", "dem")
RHESSysMetadata.writeRHESSysEntry(context, "grass_dbase", dbase)
RHESSysMetadata.writeRHESSysEntry(context, "grass_location", grassConfig.location)
RHESSysMetadata.writeRHESSysEntry(context, "grass_mapset", grassConfig.mapset)
RHESSysMetadata.writeRHESSysEntry(context, "rhessys_dir", paths.rhessysDir)
RHESSysMetadata.writeRHESSysEntry(context, "model_description", args.description)
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
sys.exit("r.mapcalc failed to create patch map, returning %s" %
(result, ))
if args.patchType == 'clump':
if args.clumpMap == 'wetness_index':
clumpMap = grassMetadata['wetness_index_rast']
else:
clumpMap = demRast
sys.stdout.write("Generating clumped patch map based on %s raster...\n" %
(clumpMap))
sys.stdout.flush()
result = grassLib.script.run_command('r.clump',
input=clumpMap,
output=PATCH_RAST,
overwrite=args.overwrite)
if result != 0:
sys.exit("r.mapcalc failed to create patch map, returning %s" %
(result, ))
sys.stdout.write('done\n')
# Write metadata
RHESSysMetadata.writeGRASSEntry(context, 'patch_rast', PATCH_RAST)
if args.forceZone or not 'zone_rast' in grassMetadata:
# Only overwrite zone raster
RHESSysMetadata.writeGRASSEntry(context, 'zone_rast', PATCH_RAST)
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
p = grassLib.script.pipe_command('v.voronoi',
input='basestation_points',
output='basestation_areas',
overwrite=args.overwrite)
(stdoutStr, stderrStr) = p.communicate()
result = p.returncode
if result != 0:
sys.stdout.write(stdoutStr)
sys.exit("\nv.voronoi failed, returning %s" % (result, ))
# Rasterize Thiessen polygons
p = grassLib.script.pipe_command('v.to.rast',
input='basestation_areas',
output='basestations',
use='cat',
labelcolumn='name',
overwrite=args.overwrite)
(stdoutStr, stderrStr) = p.communicate()
result = p.returncode
if result != 0:
sys.stdout.write(stdoutStr)
sys.exit("\nv.to.rast failed, returning %s" % (result, ))
# Write metadata
RHESSysMetadata.writeRHESSysEntry(context, 'basestations_text',
paths.relpath(basestationsDest))
RHESSysMetadata.writeGRASSEntry(context, 'basestations_rast', 'basestations')
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
def run(self, *args, **kwargs):
""" Create flow tables for multiple worldfiles
Arguments:
scenario_id -- int ID of the GI Notebook scenario whose GI instances are to be parameterized.
auth_token -- string Authorization token to use for authenticating to the GI Notebook.
host -- string Hostname of GI Notebook server. Default: None.
api_root -- string The root of the API URL to use. Default: None.
use_HTTPS -- boolean Use HTTPS for communication with the GI Notebook.
force -- boolean Force overwrite of existing scenario output. Default: False.
verbose -- boolean Produce verbose output. Default: False.
"""
scenario_id = kwargs.get('scenario_id')
if scenario_id is None:
raise RunException('Scenario ID was not specified.')
auth_token = kwargs.get('auth_token')
if auth_token is None:
raise RunException('Authorization token was not specified.')
host = kwargs.get('host', DEFAULT_HOSTNAME)
api_root = kwargs.get('api_path', DEFAULT_API_ROOT)
use_HTTPS = kwargs.get('use_HTTPS', False)
force = kwargs.get('force', False)
verbose = kwargs.get('verbose', False)
self.checkMetadata()
self.param_const, self.param_db = self._init_paramdb()
self.paths = RHESSysPaths(self.context.projectDir, self.metadata['rhessys_dir'])
gi_scenario_base = 'gi_scenario'
gi_scenario_data = "{0}.geojson".format(gi_scenario_base)
scenario_geojson_path = os.path.join(self.context.projectDir, gi_scenario_data)
gi_scenario_soils_base = "{0}_wsoils".format(gi_scenario_base)
gi_scenario_soils = "{0}.geojson".format(gi_scenario_soils_base)
scenario_soils_geojson_path = os.path.join(self.context.projectDir, gi_scenario_soils)
gi_scenario_landuse_base = "{0}_landuse".format(gi_scenario_base)
gi_scenario_landuse = "{0}.geojson".format(gi_scenario_landuse_base)
scenario_landuse_geojson_path = os.path.join(self.context.projectDir, gi_scenario_landuse)
gi_scenario_data_key = 'gi_scenario_data'
gi_scenario_soils_data_key = "{0}_soils".format(gi_scenario_data_key)
gi_scenario_landuse_data_key = "{0}_landuse".format(gi_scenario_data_key)
if gi_scenario_data_key in self.metadata:
if verbose:
self.outfp.write('Existing GI scenario found.\n')
if force:
if verbose:
self.outfp.write('Force option specified, overwriting existing GI scenario.\n')
if os.path.exists(scenario_geojson_path):
os.unlink(scenario_geojson_path)
if os.path.exists(scenario_soils_geojson_path):
os.unlink(scenario_soils_geojson_path)
if os.path.exists(scenario_landuse_geojson_path):
os.unlink(scenario_landuse_geojson_path)
else:
raise RunException('Exiting. Use force option to overwrite.')
if verbose:
output = None
else:
output = open('/dev/null')
try:
# Connect to GI Notebook and fetch GI instance information (in GeoJSON format)
# for this scenario ID.
if verbose:
self.outfp.write("\nDownloading GI scenario {0} from GI database...\n".format(scenario_id))
nb = GINotebook(hostname=host,
api_root=api_root,
use_https=use_HTTPS, auth_token=auth_token)
scenario = nb.get_scenario(scenario_id)
scenario_geojson = scenario.get_instances_as_geojson(indent=2, shorten=True)
(gi_scenario_data_wgs84, scenario_geojson_wgs84_path), (gi_scenario_data, scenario_geojson_path) = \
self._write_geojson_and_reproject(scenario_geojson, gi_scenario_base, verbose=verbose, output=output)
# Filter out instances that do not contain soils data
gi_scenario_soils_base = "{0}_wsoils".format(gi_scenario_base)
scenario_geojson_wsoils = scenario.get_instances_as_geojson(indent=2, shorten=True,
filter=lambda a: a.get('e_1_pedid') is not None)
(gi_scenario_soils_wgs84, scenario_soils_geojson_wgs84_path), (gi_scenario_soils, scenario_soils_geojson_path) = \
self._write_geojson_and_reproject(scenario_geojson_wsoils, gi_scenario_soils_base,
verbose=verbose, output=output)
# Import scenario GeoJSON into GRASS
self._import_vector_into_grass(scenario_geojson_path, gi_scenario_data_key,
force=force, verbose=verbose, output=output)
# Import scenario (instances with soils data) GeoJSON into GRASS
self._import_vector_into_grass(scenario_soils_geojson_path, gi_scenario_soils_data_key,
force=force, verbose=verbose, output=output)
# Generate raster layers from vector-based GI Scenario
# Raster for updating soil type
self._rasterize(gi_scenario_soils_data_key, gi_scenario_soils_data_key,
column='e_1_pedid', labelcolumn='e_1_pednm',
rast_title='GI soil types',
verbose=verbose,
force=force,
redir_fp=output)
# Raster for updating stratum type
gi_scenario_strata = "gi_scenario_strata"
self._rasterize(gi_scenario_data_key, gi_scenario_strata,
column='e_1_vegid', labelcolumn='e_1_vegnm',
rast_title='GI vegetation types',
verbose=verbose,
force=force,
redir_fp=output)
# Raster for updating land use
# Filter out instances that are not rain gardens (i.e. the only GI type for which we currently have a
# land use).
scenario_geojson_landuse = scenario.get_instances_as_geojson(indent=2, shorten=True,
filter=lambda a: a.get('type',
'') == 'Rain Garden')
(gi_scenario_landuse_wgs84, scenario_landuse_geojson_wgs84_path), \
(gi_scenario_landuse, scenario_landuse_geojson_path) = \
self._write_geojson_and_reproject(scenario_geojson_landuse, gi_scenario_landuse_base,
verbose=verbose, output=output)
# Import land use (i.e. instances that are rain gardens) GeoJSON into GRASS
self._import_vector_into_grass(scenario_landuse_geojson_path, gi_scenario_landuse_data_key,
force=force, verbose=verbose, output=output)
# Search for raster value for rain gardens in RHESSys parameter DB
rg_name = 'raingarden'
rg_found = self.param_db.search(self.param_const.SEARCH_TYPE_HIERARCHICAL, 'landuse', rg_name,
None, None, None, None, None, None, None, None)
if not rg_found:
raise RunException("Unable to find raingarden landuse class in parameter database")
rg_id = [c[1][2] for c in self.param_db.classes.iteritems()][0]
# Generate raster layer from vector-based GI Scenario
# Raster for updating landuse type
self._rasterize_single_value(gi_scenario_landuse_data_key, gi_scenario_landuse_data_key,
value=rg_id, label=rg_name,
rast_title='GI landuse types',
verbose=verbose,
force=force,
redir_fp=output)
# Write out updated landuse, stratum, and soil rasters and parameter definitions
# Backup landuse raster
self._backup_raster(self.grassMetadata['landuse_rast'])
# Update landuse raster
self._update_raster(self.grassMetadata['landuse_rast'], gi_scenario_landuse_data_key)
# Generate parameter definition file for landuse raster
self._generate_parameter_definitions_for_raster(self.grassMetadata['landuse_rast'], 'landuse',
verbose=verbose)
# Backup stratum raster
self._backup_raster(self.grassMetadata['stratum_rast'])
# Update stratum raster
self._update_raster(self.grassMetadata['stratum_rast'], gi_scenario_strata)
# Generate parameter definition file for stratum raster
self._generate_parameter_definitions_for_raster(self.grassMetadata['stratum_rast'], 'stratum',
verbose=verbose)
# Backup soils raster
self._backup_raster(self.grassMetadata['soil_rast'])
# Update soils raster
self._update_raster(self.grassMetadata['soil_rast'], gi_scenario_soils_data_key)
# Generate parameter definition file for soil raster
self._generate_parameter_definitions_for_raster(self.grassMetadata['soil_rast'], 'soil',
verbose=verbose)
# Write metadata
RHESSysMetadata.writeGRASSEntry(self.context, "{0}_rast".format(gi_scenario_landuse_data_key),
gi_scenario_landuse_data_key)
RHESSysMetadata.writeGRASSEntry(self.context, "{0}_rast".format(gi_scenario_soils_data_key),
gi_scenario_soils_data_key)
RHESSysMetadata.writeGRASSEntry(self.context, "{0}_rast".format(gi_scenario_strata), gi_scenario_strata)
RHESSysMetadata.writeGRASSEntry(self.context, "{0}_vect".format(gi_scenario_data_key), gi_scenario_data_key)
RHESSysMetadata.writeGRASSEntry(self.context, "{0}_vect".format(gi_scenario_soils_data_key),
gi_scenario_soils_data_key)
RHESSysMetadata.writeGRASSEntry(self.context, "{0}_vect".format(gi_scenario_landuse_data_key),
gi_scenario_landuse_data_key)
RHESSysMetadata.writeRHESSysEntry(self.context, gi_scenario_data_key, gi_scenario_data)
if verbose:
self.outfp.write('\n\nFinished parameterizing GI.\n')
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(self.context, RHESSysMetadata.getCommandLine())
finally:
if output:
output.close()
if not args.defonly:
sys.stdout.write(
'Generating soil texture map from percent sand and clay maps...')
sys.stdout.flush()
# Import percent sand and percent clay raster maps into GRASS
percentSandRasterPath = os.path.join(context.projectDir,
manifest['soil_raster_pctsand'])
result = grassLib.script.run_command('r.in.gdal',
input=percentSandRasterPath,
output='soil_pctsand',
overwrite=args.overwrite)
if result != 0:
sys.exit("Failed to import soil_raster_pctsand into GRASS dataset %s/%s, results:\n%s" % \
(grassDbase, metadata['grass_location'], result) )
RHESSysMetadata.writeGRASSEntry(context, 'soil_pctsand_rast',
'soil_pctsand')
percentClayRasterPath = os.path.join(context.projectDir,
manifest['soil_raster_pctclay'])
result = grassLib.script.run_command('r.in.gdal',
input=percentClayRasterPath,
output='soil_pctclay',
overwrite=args.overwrite)
if result != 0:
sys.exit("Failed to import soil_raster_pctclay into GRASS dataset %s/%s, results:\n%s" % \
(grassDbase, metadata['grass_location'], result) )
RHESSysMetadata.writeGRASSEntry(context, 'soil_pctclay_rast',
'soil_pctclay')
# Generate soil texture map
schemePath = os.path.join(moduleEtc, 'USDA.dat')
if result != 0:
sys.exit("Failed to resample imported raster %s of GRASS dataset %s/%s, result:\n%s" % \
(t, grassDbase, metadata['grass_location'], result) )
if args.integer:
# Convert raster to integer
sys.stdout.write("Converting %s raster to integer using multiplier %s...\n" % (t, str(args.multiplier)) )
sys.stdout.flush()
mapcalcCmd = "%s=int(%s * %s)" % (t, importName, str(args.multiplier) )
print(mapcalcCmd)
result = grassLib.script.write_command('r.mapcalc', stdin=mapcalcCmd)
if result != 0:
sys.exit("Integer conversion failed for raster %s of GRASS dataset %s/%s, result:\n%s" % \
(t, grassDbase, metadata['grass_location'], result) )
result = grassLib.script.run_command('g.remove', rast=importName)
if result != 0:
sys.exit("Failed to delete temporary raster %s of GRASS dataset %s/%s, result:\n%s" % \
(importName, grassDbase, metadata['grass_location'], result) )
grassEntryKey = "%s_rast" % (t,)
RHESSysMetadata.writeGRASSEntry(context, grassEntryKey, t)
sys.stdout.write('done\n')
# Invalidate metadata as necessary
if t == RHESSysMetadata.RASTER_TYPE_LC:
RHESSysMetadata.deleteRHESSysEntry(context, 'stratum_defs')
RHESSysMetadata.deleteRHESSysEntry(context, 'landuse_defs')
elif t == RHESSysMetadata.RASTER_TYPE_SOIL:
RHESSysMetadata.deleteRHESSysEntry(context, 'soil_defs')
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
# Make sure mask and region are properly set
result = grassLib.script.run_command('r.mask', flags='r')
if result != 0:
sys.exit("r.mask filed, returning %s" % (result,) )
result = grassLib.script.run_command('g.region', rast=demRast)
if result != 0:
sys.exit("g.region failed to set region to DEM, returning %s" % (result,))
# Reclassify custom soils map into one compatible with RHESSys soil types defined in ParamDB
soilReclassName = 'soil_reclass'
result = grassLib.script.read_command('r.reclass', input=soilRast, output=soilReclassName,
rules=soilsRulePath, overwrite=args.overwrite)
if None == result:
sys.exit("r.reclass failed to create soils map, returning %s" % (result,))
RHESSysMetadata.writeGRASSEntry(context, 'soil_rast', soilReclassName)
# Fetch relevant stratum default files from param DB
pipe = grassLib.script.pipe_command('r.stats', flags='licn', input=soilReclassName)
rasterVals = {}
for line in pipe.stdout:
(dn, cat, num) = line.strip().split()
if cat != 'NULL':
rasterVals[cat] = int(dn)
pipe.wait()
print("Writing soil definition files to %s" % (paths.RHESSYS_DEF) )
for key in rasterVals.keys():
print("soil '%s' has dn %d" % (key, rasterVals[key]) )
paramsFound = paramDB.search(paramConst.SEARCH_TYPE_CONSTRAINED, None, key, None, None, None, None, None, None, None, None,
limitToBaseClasses=True, defaultIdOverride=rasterVals[key])
assert(paramsFound)
result = grassLib.script.run_command('g.region', rast=demRast)
if result != 0:
sys.exit("g.region failed to set region to DEM, returning %s" % (result,))
# Generate drainage direction map
flags = None
if args.multiflowdirection:
flags = 'f'
result = grassLib.script.run_command('r.watershed',
elevation=flowDirDem, drainage='drain', accumulation='uaa',
overwrite=args.overwrite,
flags=flags)
if result != 0:
sys.exit("r.watershed failed creating drainage direction and uaa maps, returning %s" % (result,))
RHESSysMetadata.writeGRASSEntry(context, 'drain_rast', 'drain')
RHESSysMetadata.writeGRASSEntry(context, 'uaa_rast', 'uaa')
# Convert gage coordinates into dem_srs coordinates
(easting, northing) = transformCoordinates(studyArea['gage_lon_wgs84'],
studyArea['gage_lat_wgs84'],
t_srs=studyArea['dem_srs'])
RHESSysMetadata.writeRHESSysEntry(context, 'gage_easting_raw', easting)
RHESSysMetadata.writeRHESSysEntry(context, 'gage_northing_raw', northing)
point = "%f|%f\n" % (easting, northing)
result = grassLib.script.write_command('v.in.ascii', output='gage', stdin=point, overwrite=args.overwrite)
if result != 0:
sys.exit("v.in.ascii failed to create 'gage' vector, returning %s" % (result,))
if result != 0:
sys.exit("r.mask filed, returning %s" % (result, ))
result = grassLib.script.run_command('g.region', rast=demRast)
if result != 0:
sys.exit("g.region failed to set region to DEM, returning %s" % (result, ))
# Reclassify custom soils map into one compatible with RHESSys soil types defined in ParamDB
soilReclassName = 'soil_reclass'
result = grassLib.script.read_command('r.reclass',
input=soilRast,
output=soilReclassName,
rules=soilsRulePath,
overwrite=args.overwrite)
if None == result:
sys.exit("r.reclass failed to create soils map, returning %s" % (result, ))
RHESSysMetadata.writeGRASSEntry(context, 'soil_rast', soilReclassName)
# Fetch relevant stratum default files from param DB
pipe = grassLib.script.pipe_command('r.stats',
flags='licn',
input=soilReclassName)
rasterVals = {}
for line in pipe.stdout:
(dn, cat, num) = line.strip().split()
if cat != 'NULL':
rasterVals[cat] = int(dn)
pipe.wait()
print("Writing soil definition files to %s" % (paths.RHESSYS_DEF))
for key in rasterVals.keys():
print("soil '%s' has dn %d" % (key, rasterVals[key]))
paramsFound = paramDB.search(paramConst.SEARCH_TYPE_CONSTRAINED,
result = grassLib.script.run_command('g.region', rast=demRast)
if result != 0:
sys.exit("g.region failed to set region to DEM, returning %s" % (result, ))
# Generate drainage direction map
result = grassLib.script.run_command('r.watershed',
elevation=flowDirDem,
drainage='drain',
accumulation='uaa',
overwrite=args.overwrite)
if result != 0:
sys.exit(
"r.watershed failed creating drainage direction and uaa maps, returning %s"
% (result, ))
RHESSysMetadata.writeGRASSEntry(context, 'drain_rast', 'drain')
RHESSysMetadata.writeGRASSEntry(context, 'uaa_rast', 'uaa')
# Convert gage coordinates into dem_srs coordinates
(easting, northing) = transformCoordinates(studyArea['gage_lon_wgs84'],
studyArea['gage_lat_wgs84'],
t_srs=studyArea['dem_srs'])
RHESSysMetadata.writeRHESSysEntry(context, 'gage_easting_raw', easting)
RHESSysMetadata.writeRHESSysEntry(context, 'gage_northing_raw', northing)
point = "%f|%f\n" % (easting, northing)
result = grassLib.script.write_command('v.in.ascii',
output='gage',
stdin=point,
overwrite=args.overwrite)
sys.exit("r.mask filed, returning %s" % (result,) )
result = grassLib.script.run_command('g.region', rast=demRast)
if result != 0:
sys.exit("g.region failed to set region to DEM, returning %s" % (result,))
# Reclassify landcover into stratum map
stratumRast = 'stratum'
if args.defonly:
stratumRast = grassMetadata['stratum_rast']
else:
# Create stratum map
result = grassLib.script.read_command('r.reclass', input=landcoverRast, output=stratumRast,
rules=stratumRulePath, overwrite=args.overwrite)
if None == result:
sys.exit("r.reclass failed to create stratum map, returning %s" % (result,))
RHESSysMetadata.writeGRASSEntry(context, 'stratum_rast', stratumRast)
# Fetch relevant stratum default files from param DB
pipe = grassLib.script.pipe_command('r.stats', flags='licn', input=stratumRast)
rasterVals = {}
for line in pipe.stdout:
(dn, cat, num) = line.strip().split()
if cat != 'NULL':
rasterVals[cat] = int(dn)
pipe.wait()
print("Writing stratum definition files to %s" % (paths.RHESSYS_DEF) )
for key in rasterVals.keys():
print("stratum '%s' has dn %d" % (key, rasterVals[key]) )
paramsFound = paramDB.search(paramConst.SEARCH_TYPE_HIERARCHICAL, None, key, None, None, None, None, None, None, None, None,
defaultIdOverride=rasterVals[key])
assert(paramsFound)
# Reclassify landcover into stratum map
stratumRast = 'stratum'
if args.defonly:
stratumRast = grassMetadata['stratum_rast']
else:
# Create stratum map
result = grassLib.script.read_command('r.reclass',
input=landcoverRast,
output=stratumRast,
rules=stratumRulePath,
overwrite=args.overwrite)
if None == result:
sys.exit("r.reclass failed to create stratum map, returning %s" %
(result, ))
RHESSysMetadata.writeGRASSEntry(context, 'stratum_rast', stratumRast)
# Fetch relevant stratum default files from param DB
pipe = grassLib.script.pipe_command('r.stats', flags='licn', input=stratumRast)
rasterVals = {}
for line in pipe.stdout:
(dn, cat, num) = line.strip().split()
if cat != 'NULL':
rasterVals[cat] = int(dn)
pipe.wait()
print("Writing stratum definition files to %s" % (paths.RHESSYS_DEF))
for key in rasterVals.keys():
print("stratum '%s' has dn %d" % (key, rasterVals[key]))
paramsFound = paramDB.search(paramConst.SEARCH_TYPE_HIERARCHICAL,
None,
key,
def run(self, *args, **kwargs):
""" Create flow tables for multiple worldfiles
Arguments:
scenario_id -- int ID of the GI Notebook scenario whose GI instances are to be parameterized.
auth_token -- string Authorization token to use for authenticating to the GI Notebook.
host -- string Hostname of GI Notebook server. Default: None.
api_root -- string The root of the API URL to use. Default: None.
use_HTTPS -- boolean Use HTTPS for communication with the GI Notebook.
force -- boolean Force overwrite of existing scenario output. Default: False.
verbose -- boolean Produce verbose output. Default: False.
"""
scenario_id = kwargs.get('scenario_id')
if scenario_id is None:
raise RunException('Scenario ID was not specified.')
auth_token = kwargs.get('auth_token')
if auth_token is None:
raise RunException('Authorization token was not specified.')
host = kwargs.get('host', DEFAULT_HOSTNAME)
api_root = kwargs.get('api_path', DEFAULT_API_ROOT)
use_HTTPS = kwargs.get('use_HTTPS', False)
force = kwargs.get('force', False)
verbose = kwargs.get('verbose', False)
self.checkMetadata()
self.param_const, self.param_db = self._init_paramdb()
self.paths = RHESSysPaths(self.context.projectDir,
self.metadata['rhessys_dir'])
gi_scenario_base = 'gi_scenario'
gi_scenario_data = "{0}.geojson".format(gi_scenario_base)
scenario_geojson_path = os.path.join(self.context.projectDir,
gi_scenario_data)
gi_scenario_soils_base = "{0}_wsoils".format(gi_scenario_base)
gi_scenario_soils = "{0}.geojson".format(gi_scenario_soils_base)
scenario_soils_geojson_path = os.path.join(self.context.projectDir,
gi_scenario_soils)
gi_scenario_landuse_base = "{0}_landuse".format(gi_scenario_base)
gi_scenario_landuse = "{0}.geojson".format(gi_scenario_landuse_base)
scenario_landuse_geojson_path = os.path.join(self.context.projectDir,
gi_scenario_landuse)
gi_scenario_data_key = 'gi_scenario_data'
gi_scenario_soils_data_key = "{0}_soils".format(gi_scenario_data_key)
gi_scenario_landuse_data_key = "{0}_landuse".format(
gi_scenario_data_key)
if gi_scenario_data_key in self.metadata:
if verbose:
self.outfp.write('Existing GI scenario found.\n')
if force:
if verbose:
self.outfp.write(
'Force option specified, overwriting existing GI scenario.\n'
)
if os.path.exists(scenario_geojson_path):
os.unlink(scenario_geojson_path)
if os.path.exists(scenario_soils_geojson_path):
os.unlink(scenario_soils_geojson_path)
if os.path.exists(scenario_landuse_geojson_path):
os.unlink(scenario_landuse_geojson_path)
else:
raise RunException('Exiting. Use force option to overwrite.')
if verbose:
output = None
else:
output = open('/dev/null')
try:
# Connect to GI Notebook and fetch GI instance information (in GeoJSON format)
# for this scenario ID.
if verbose:
self.outfp.write(
"\nDownloading GI scenario {0} from GI database...\n".
format(scenario_id))
nb = GINotebook(hostname=host,
api_root=api_root,
use_https=use_HTTPS,
auth_token=auth_token)
scenario = nb.get_scenario(scenario_id)
scenario_geojson = scenario.get_instances_as_geojson(indent=2,
shorten=True)
(gi_scenario_data_wgs84, scenario_geojson_wgs84_path), (gi_scenario_data, scenario_geojson_path) = \
self._write_geojson_and_reproject(scenario_geojson, gi_scenario_base, verbose=verbose, output=output)
# Filter out instances that do not contain soils data
gi_scenario_soils_base = "{0}_wsoils".format(gi_scenario_base)
scenario_geojson_wsoils = scenario.get_instances_as_geojson(
indent=2,
shorten=True,
filter=lambda a: a.get('e_1_pedid') is not None)
(gi_scenario_soils_wgs84, scenario_soils_geojson_wgs84_path), (gi_scenario_soils, scenario_soils_geojson_path) = \
self._write_geojson_and_reproject(scenario_geojson_wsoils, gi_scenario_soils_base,
verbose=verbose, output=output)
# Import scenario GeoJSON into GRASS
self._import_vector_into_grass(scenario_geojson_path,
gi_scenario_data_key,
force=force,
verbose=verbose,
output=output)
# Import scenario (instances with soils data) GeoJSON into GRASS
self._import_vector_into_grass(scenario_soils_geojson_path,
gi_scenario_soils_data_key,
force=force,
verbose=verbose,
output=output)
# Generate raster layers from vector-based GI Scenario
# Raster for updating soil type
self._rasterize(gi_scenario_soils_data_key,
gi_scenario_soils_data_key,
column='e_1_pedid',
labelcolumn='e_1_pednm',
rast_title='GI soil types',
verbose=verbose,
force=force,
redir_fp=output)
# Raster for updating stratum type
gi_scenario_strata = "gi_scenario_strata"
self._rasterize(gi_scenario_data_key,
gi_scenario_strata,
column='e_1_vegid',
labelcolumn='e_1_vegnm',
rast_title='GI vegetation types',
verbose=verbose,
force=force,
redir_fp=output)
# Raster for updating land use
# Filter out instances that are not rain gardens (i.e. the only GI type for which we currently have a
# land use).
scenario_geojson_landuse = scenario.get_instances_as_geojson(
indent=2,
shorten=True,
filter=lambda a: a.get('type', '') == 'Rain Garden')
(gi_scenario_landuse_wgs84, scenario_landuse_geojson_wgs84_path), \
(gi_scenario_landuse, scenario_landuse_geojson_path) = \
self._write_geojson_and_reproject(scenario_geojson_landuse, gi_scenario_landuse_base,
verbose=verbose, output=output)
# Import land use (i.e. instances that are rain gardens) GeoJSON into GRASS
self._import_vector_into_grass(scenario_landuse_geojson_path,
gi_scenario_landuse_data_key,
force=force,
verbose=verbose,
output=output)
# Search for raster value for rain gardens in RHESSys parameter DB
rg_name = 'raingarden'
rg_found = self.param_db.search(
self.param_const.SEARCH_TYPE_HIERARCHICAL, 'landuse', rg_name,
None, None, None, None, None, None, None, None)
if not rg_found:
raise RunException(
"Unable to find raingarden landuse class in parameter database"
)
rg_id = [c[1][2] for c in self.param_db.classes.iteritems()][0]
# Generate raster layer from vector-based GI Scenario
# Raster for updating landuse type
self._rasterize_single_value(gi_scenario_landuse_data_key,
gi_scenario_landuse_data_key,
value=rg_id,
label=rg_name,
rast_title='GI landuse types',
verbose=verbose,
force=force,
redir_fp=output)
# Write out updated landuse, stratum, and soil rasters and parameter definitions
# Backup landuse raster
self._backup_raster(self.grassMetadata['landuse_rast'])
# Update landuse raster
self._update_raster(self.grassMetadata['landuse_rast'],
gi_scenario_landuse_data_key)
# Generate parameter definition file for landuse raster
self._generate_parameter_definitions_for_raster(
self.grassMetadata['landuse_rast'], 'landuse', verbose=verbose)
# Backup stratum raster
self._backup_raster(self.grassMetadata['stratum_rast'])
# Update stratum raster
self._update_raster(self.grassMetadata['stratum_rast'],
gi_scenario_strata)
# Generate parameter definition file for stratum raster
self._generate_parameter_definitions_for_raster(
self.grassMetadata['stratum_rast'], 'stratum', verbose=verbose)
# Backup soils raster
self._backup_raster(self.grassMetadata['soil_rast'])
# Update soils raster
self._update_raster(self.grassMetadata['soil_rast'],
gi_scenario_soils_data_key)
# Generate parameter definition file for soil raster
self._generate_parameter_definitions_for_raster(
self.grassMetadata['soil_rast'], 'soil', verbose=verbose)
# Write metadata
RHESSysMetadata.writeGRASSEntry(
self.context, "{0}_rast".format(gi_scenario_landuse_data_key),
gi_scenario_landuse_data_key)
RHESSysMetadata.writeGRASSEntry(
self.context, "{0}_rast".format(gi_scenario_soils_data_key),
gi_scenario_soils_data_key)
RHESSysMetadata.writeGRASSEntry(
self.context, "{0}_rast".format(gi_scenario_strata),
gi_scenario_strata)
RHESSysMetadata.writeGRASSEntry(
self.context, "{0}_vect".format(gi_scenario_data_key),
gi_scenario_data_key)
RHESSysMetadata.writeGRASSEntry(
self.context, "{0}_vect".format(gi_scenario_soils_data_key),
gi_scenario_soils_data_key)
RHESSysMetadata.writeGRASSEntry(
self.context, "{0}_vect".format(gi_scenario_landuse_data_key),
gi_scenario_landuse_data_key)
RHESSysMetadata.writeRHESSysEntry(self.context,
gi_scenario_data_key,
gi_scenario_data)
if verbose:
self.outfp.write('\n\nFinished parameterizing GI.\n')
# Write processing history
RHESSysMetadata.appendProcessingHistoryItem(
self.context, RHESSysMetadata.getCommandLine())
finally:
if output:
output.close()
