def test_delete(self): RHESSysMetadata.writeRHESSysEntry(self.context, "key1", "value_one") RHESSysMetadata.writeRHESSysEntry(self.context, "key2", "value_two") metadata = RHESSysMetadata.readRHESSysEntries(self.context) self.assertTrue(metadata["key1"] == "value_one") RHESSysMetadata.deleteRHESSysEntry(self.context, "key1") metadata = RHESSysMetadata.readRHESSysEntries(self.context) self.assertTrue(not 'key1' in metadata) # Delete and empty entry RHESSysMetadata.deleteRHESSysEntry(self.context, "not_in_store")
def test_delete(self): RHESSysMetadata.writeRHESSysEntry(self.context, "key1", "value_one") RHESSysMetadata.writeRHESSysEntry(self.context, "key2", "value_two") metadata = RHESSysMetadata.readRHESSysEntries(self.context) self.assertTrue(metadata["key1"] == "value_one") RHESSysMetadata.deleteRHESSysEntry(self.context, "key1") metadata = RHESSysMetadata.readRHESSysEntries(self.context) self.assertTrue(not 'key1' in metadata) # Delete and empty entry RHESSysMetadata.deleteRHESSysEntry(self.context, "not_in_store")
if not os.access(args.ruleDir, os.R_OK): sys.exit("Unable to read rule directory %s" % (ruleDir,) ) ruleDir = os.path.abspath(args.ruleDir) if ruleDir: sys.stdout.write(textwrap.fill("Importing landcover reclass rules from %s ..." % (ruleDir,) ) ) sys.stdout.flush() # Copy rules into project directory roadRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_ROAD) shutil.copy(roadRulePath, projectDirRuleDir) imperviousRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_IMPERVIOUS) shutil.copy(imperviousRulePath, projectDirRuleDir) landuseRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_LANDUSE) shutil.copy(landuseRulePath, projectDirRuleDir) stratumRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_STRATUM) shutil.copy(stratumRulePath, projectDirRuleDir) if args.includeLaiRules: laiRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_LAI) shutil.copy(laiRulePath, projectDirRuleDir) sys.stdout.write('done\n') # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'landcover_stratum_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(stratumRulePath)) ) RHESSysMetadata.writeRHESSysEntry(context, 'landcover_landuse_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(landuseRulePath)) ) RHESSysMetadata.writeRHESSysEntry(context, 'landcover_impervious_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(imperviousRulePath)) ) RHESSysMetadata.writeRHESSysEntry(context, 'landcover_road_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(roadRulePath)) ) if args.includeLaiRules: RHESSysMetadata.writeRHESSysEntry(context, 'landcover_lai_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(laiRulePath)) ) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
def run(self, *args, **kwargs): """ Create flow tables for multiple worldfiles Arguments: routeRoads -- boolean Whether road routing should be enabled in createflowpaths. Default: False. routeRoofs -- boolean Whether roof routing should be enabled in createflowpaths. Default: False. ignoreBurnedDEM -- boolean If true, use the base DEM when running createflowpaths. If false, use the stream-burned DEM (if present). Default: False. force -- boolean Whether to force createflowpaths to run if DEM X resolution != Y resolution. Default: False. verbose -- boolean Produce verbose output. Default: False. """ routeRoads = kwargs.get('routeRoads', False) routeRoofs = kwargs.get('routeRoofs', False) force = kwargs.get('force', False) ignoreBurnedDEM = kwargs.get('ignoreBurnedDEM', False) verbose = kwargs.get('verbose', False) self.checkMetadata(routeRoads=routeRoads, routeRoofs=routeRoofs) rhessysDir = self.metadata['rhessys_dir'] self.paths = RHESSysPaths(self.context.projectDir, rhessysDir) demResX = float(self.studyArea['dem_res_x']) demResY = float(self.studyArea['dem_res_y']) if demResX != demResY: self.outfp.write( "DEM x resolution (%f) does not match y resolution (%f)" % (demResX, demResY)) if not force: raise RunException('Exiting. Use force option to override') # Determine DEM raster to use demRast = self.grassMetadata['dem_rast'] if ('stream_burned_dem_rast' in self.grassMetadata) and (not ignoreBurnedDEM): demRast = self.grassMetadata['stream_burned_dem_rast'] self.outfp.write( "Using raster named '%s' to calculate flow direction map\n" % (demRast, )) # Make sure region is properly set demRast = self.grassMetadata['dem_rast'] result = self.grassLib.script.run_command('g.region', rast=demRast) if result != 0: raise RunException( "g.region failed to set region to DEM, returning {0}".format( result)) # Get paths for CF binary and template cfPath = os.path.join(self.context.projectDir, self.metadata['cf_bin']) templatePath = os.path.join(self.context.projectDir, self.metadata['template']) if verbose: self.outfp.write(self.templatePath) self.outfp.write('\n') # Make output file paths and file name templates flowTableNameBase = "world_{mask}" flowOutpath = os.path.join(self.paths.RHESSYS_FLOW, flowTableNameBase) cfOutpath = os.path.join(self.paths.RHESSYS_FLOW, "cf_{mask}.out") roads = None if routeRoads: roads = self.grassMetadata['roads_rast'] else: roads = self.grassMetadata['zero_rast'] roofs = None impervious = None # These filenames are only for metadata if routeRoofs: roofs = self.grassMetadata['roof_connectivity_rast'] impervious = self.grassMetadata['impervious_rast'] surfaceFlowtableTemplate = "world_{mask}_surface.flow" subsurfaceFlowtableTemplate = "world_{mask}_subsurface.flow" else: surfaceFlowtableTemplate = subsurfaceFlowtableTemplate = "world_{mask}.flow" # Make flowtable for each masked region if verbose: self.outfp.write( 'Running createflowpaths (this may take a few minutes)...') self.outfp.flush() surfaceFlowtables = [] subsurfaceFlowtables = [] masks = self.metadata['subbasin_masks'].split( RHESSysMetadata.VALUE_DELIM) for mask in masks: result = self.grassLib.script.run_command('r.mask', flags='o', input=mask, maskcats='1', quiet=True) if result != 0: raise RunException( "r.mask failed to set mask to sub-basin {0}, returning {1}" .format(mask, result)) # Run CF p = self.grassLib.script.pipe_command( cfPath, out=flowOutpath.format(mask=mask), template=templatePath, dem=demRast, slope=self.grassMetadata['slope_rast'], stream=self.grassMetadata['streams_rast'], road=roads, roof=roofs, impervious=impervious, cellsize=demResX) (pStdout, pStderr) = p.communicate() if verbose: self.outfp.write("CF output:\n") self.outfp.write(pStdout) if pStderr: self.outfp.write(pStderr) if p.returncode != 0: raise RunException("createflowpaths failed, returning %s" % (str(p.returncode), )) # Write cf output to project directory cfOut = open(cfOutpath.format(mask=mask), 'w') cfOut.write(pStdout) if pStderr: cfOut.write("\n\nStandard error output:\n\n") cfOut.write(pStderr) cfOut.close() surfFlow = os.path.join(self.paths.RHESSYS_FLOW, surfaceFlowtableTemplate.format(mask=mask)) surfaceFlowtables.append(surfFlow) subsurfFlow = os.path.join( self.paths.RHESSYS_FLOW, subsurfaceFlowtableTemplate.format(mask=mask)) subsurfaceFlowtables.append(subsurfFlow) # Remove mask result = self.grassLib.script.run_command('r.mask', flags='r', quiet=True) if result != 0: raise RunException("r.mask failed to remove mask") # Write metadata cfCmd = "%s out=%s template=%s dem=%s slope=%s stream=%s road=%s roof=%s impervious=%s cellsize=%s" % \ (cfPath, flowOutpath, templatePath, demRast, self.grassMetadata['slope_rast'], self.grassMetadata['streams_rast'], roads, roofs, impervious, demResX) RHESSysMetadata.writeRHESSysEntry(self.context, 'flowtable_cmd', cfCmd) RHESSysMetadata.writeRHESSysEntry( self.context, 'surface_flowtables', RHESSysMetadata.VALUE_DELIM.join( [self.paths.relpath(s) for s in surfaceFlowtables])) RHESSysMetadata.writeRHESSysEntry( self.context, 'subsurface_flowtables', RHESSysMetadata.VALUE_DELIM.join( [self.paths.relpath(s) for s in subsurfaceFlowtables])) if verbose: self.outfp.write('\n\nFinished creating flow tables\n') # Write processing history RHESSysMetadata.appendProcessingHistoryItem( self.context, RHESSysMetadata.getCommandLine())
cellsize=demResX) (pStdout, pStderr) = p.communicate() if args.verbose: print("CF output:") print(pStdout) if pStderr: print(pStderr) if p.returncode != 0: sys.exit("createflowpaths failed, returning %s" % ( str(p.returncode),)) # Write cf output to project directory cfOut = open(cfOutpath, 'w') cfOut.write(pStdout) if pStderr: cfOut.write("\n\nStandard error output:\n\n") cfOut.write(pStderr) cfOut.close() cfCmd = "%s out=%s template=%s dem=%s slope=%s stream=%s road=%s roof=%s impervious=%s cellsize=%s" % \ (cfPath, flowOutpath, templatePath, grassMetadata['dem_rast'], grassMetadata['slope_rast'], grassMetadata['streams_rast'], roads, roofs, impervious, demResX) RHESSysMetadata.writeRHESSysEntry(context, 'flowtable_cmd', cfCmd) RHESSysMetadata.writeRHESSysEntry(context, 'surface_flowtable', paths.relpath(os.path.join(paths.RHESSYS_FLOW, surfaceFlowtable) ) ) RHESSysMetadata.writeRHESSysEntry(context, 'subsurface_flowtable', paths.relpath(os.path.join(paths.RHESSYS_FLOW, subsurfaceFlowtable) ) ) sys.stdout.write('\nFinished creating flowtable\n') # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
## 3. Write TEC file for redefining the initial world file ## Redefine on the second day of the simulation, write output ## on the third day tecName = 'tec.lairead' tecPath = os.path.join(paths.RHESSYS_TEC, tecName) tecDurOutput = datetime.timedelta(days=2) tecOutput = startDate + tecDurOutput f = open(tecPath, 'w') f.write("%s redefine_world%s" % (datetimeToString(tecRedef), os.linesep) ) f.write("%s output_current_state%s" % (datetimeToString(tecOutput), os.linesep) ) f.close() RHESSysMetadata.writeRHESSysEntry( context, 'tec_lairead', paths.relpath(tecPath) ) ## 4. Run RHESSys for the first 4 legal days with redefine TEC rhessysStart = startDate rhessysDur = datetime.timedelta(days=3) rhessysEnd = startDate + rhessysDur surfaceFlowtablePath = os.path.join(context.projectDir, metadata['surface_flowtable']) subSurfaceFlowtablePath = os.path.join(context.projectDir, metadata['subsurface_flowtable']) rhessysBinPath = os.path.join(context.projectDir, metadata['rhessys_bin']) rhessysCmd = generateCommandString(rhessysBinPath, None, rhessysStart, rhessysEnd, tecPath, oldWorldPath, subSurfaceFlowtablePath, surfaceFlowtablePath) if args.verbose: print(rhessysCmd)
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)
def test_write_and_read(self): RHESSysMetadata.writeRHESSysEntry(self.context, "key1", "value_one") RHESSysMetadata.writeRHESSysEntry(self.context, "key2", "value_two") metadata = RHESSysMetadata.readRHESSysEntries(self.context) self.assertTrue(metadata["key1"] == "value_one")
def run(self, *args, **kwargs): """ Create flow tables for multiple worldfiles Arguments: routeRoads -- boolean Whether road routing should be enabled in createflowpaths. Default: False. routeRoofs -- boolean Whether roof routing should be enabled in createflowpaths. Default: False. ignoreBurnedDEM -- boolean If true, use the base DEM when running createflowpaths. If false, use the stream-burned DEM (if present). Default: False. force -- boolean Whether to force createflowpaths to run if DEM X resolution != Y resolution. Default: False. verbose -- boolean Produce verbose output. Default: False. """ routeRoads = kwargs.get('routeRoads', False) routeRoofs = kwargs.get('routeRoofs', False) force = kwargs.get('force', False) ignoreBurnedDEM = kwargs.get('ignoreBurnedDEM', False) verbose = kwargs.get('verbose', False) self.checkMetadata(routeRoads=routeRoads, routeRoofs=routeRoofs) rhessysDir = self.metadata['rhessys_dir'] self.paths = RHESSysPaths(self.context.projectDir, rhessysDir) demResX = float(self.studyArea['dem_res_x']) demResY = float(self.studyArea['dem_res_y']) if demResX != demResY: self.outfp.write("DEM x resolution (%f) does not match y resolution (%f)" % (demResX, demResY) ) if not force: raise RunException('Exiting. Use force option to override') # Determine DEM raster to use demRast = self.grassMetadata['dem_rast'] if ('stream_burned_dem_rast' in self.grassMetadata) and (not ignoreBurnedDEM): demRast = self.grassMetadata['stream_burned_dem_rast'] self.outfp.write("Using raster named '%s' to calculate flow direction map\n" % (demRast,) ) # Make sure region is properly set demRast = self.grassMetadata['dem_rast'] result = self.grassLib.script.run_command('g.region', rast=demRast) if result != 0: raise RunException("g.region failed to set region to DEM, returning {0}".format(result)) # Get paths for CF binary and template cfPath = os.path.join(self.context.projectDir, self.metadata['cf_bin']) templatePath = os.path.join(self.context.projectDir, self.metadata['template']) if verbose: self.outfp.write(self.templatePath) self.outfp.write('\n') # Make output file paths and file name templates flowTableNameBase = "world_{mask}" flowOutpath = os.path.join(self.paths.RHESSYS_FLOW, flowTableNameBase) cfOutpath = os.path.join(self.paths.RHESSYS_FLOW, "cf_{mask}.out") roads = None if routeRoads: roads = self.grassMetadata['roads_rast'] else: roads = self.grassMetadata['zero_rast'] roofs = None impervious = None # These filenames are only for metadata if routeRoofs: roofs = self.grassMetadata['roof_connectivity_rast'] impervious = self.grassMetadata['impervious_rast'] surfaceFlowtableTemplate = "world_{mask}_surface.flow" subsurfaceFlowtableTemplate = "world_{mask}_subsurface.flow" else: surfaceFlowtableTemplate = subsurfaceFlowtableTemplate = "world_{mask}.flow" # Make flowtable for each masked region if verbose: self.outfp.write('Running createflowpaths (this may take a few minutes)...') self.outfp.flush() surfaceFlowtables = [] subsurfaceFlowtables = [] masks = self.metadata['subbasin_masks'].split(RHESSysMetadata.VALUE_DELIM) for mask in masks: result = self.grassLib.script.run_command('r.mask', flags='o', input=mask, maskcats='1', quiet=True) if result != 0: raise RunException("r.mask failed to set mask to sub-basin {0}, returning {1}".format(mask, result)) # Run CF p = self.grassLib.script.pipe_command(cfPath, out=flowOutpath.format(mask=mask), template=templatePath, dem=demRast, slope=self.grassMetadata['slope_rast'], stream=self.grassMetadata['streams_rast'], road=roads, roof=roofs, impervious=impervious, cellsize=demResX) (pStdout, pStderr) = p.communicate() if verbose: self.outfp.write("CF output:\n") self.outfp.write(pStdout) if pStderr: self.outfp.write(pStderr) if p.returncode != 0: raise RunException("createflowpaths failed, returning %s" % ( str(p.returncode),)) # Write cf output to project directory cfOut = open(cfOutpath.format(mask=mask), 'w') cfOut.write(pStdout) if pStderr: cfOut.write("\n\nStandard error output:\n\n") cfOut.write(pStderr) cfOut.close() surfFlow = os.path.join(self.paths.RHESSYS_FLOW, surfaceFlowtableTemplate.format(mask=mask)) surfaceFlowtables.append(surfFlow) subsurfFlow = os.path.join(self.paths.RHESSYS_FLOW, subsurfaceFlowtableTemplate.format(mask=mask)) subsurfaceFlowtables.append(subsurfFlow) # Remove mask result = self.grassLib.script.run_command('r.mask', flags='r', quiet=True) if result != 0: raise RunException("r.mask failed to remove mask") # Write metadata cfCmd = "%s out=%s template=%s dem=%s slope=%s stream=%s road=%s roof=%s impervious=%s cellsize=%s" % \ (cfPath, flowOutpath, templatePath, demRast, self.grassMetadata['slope_rast'], self.grassMetadata['streams_rast'], roads, roofs, impervious, demResX) RHESSysMetadata.writeRHESSysEntry(self.context, 'flowtable_cmd', cfCmd) RHESSysMetadata.writeRHESSysEntry(self.context, 'surface_flowtables', RHESSysMetadata.VALUE_DELIM.join([self.paths.relpath(s) for s in surfaceFlowtables]) ) RHESSysMetadata.writeRHESSysEntry(self.context, 'subsurface_flowtables', RHESSysMetadata.VALUE_DELIM.join([self.paths.relpath(s) for s in subsurfaceFlowtables]) ) if verbose: self.outfp.write('\n\nFinished creating flow tables\n') # Write processing history RHESSysMetadata.appendProcessingHistoryItem(self.context, RHESSysMetadata.getCommandLine())
subs['impervious_rast'] = grassMetadata['impervious_rast'] subs['wetness_index_rast'] = grassMetadata['wetness_index_rast'] subs['stratum_rast'] = grassMetadata['stratum_rast'] subs['xmap_rast'] = grassMetadata['xmap_rast'] subs['ymap_rast'] = grassMetadata['ymap_rast'] # Third, substitute into the template template, producing the template, which we write to disk for g2w templateStr = '' try: templateStr = templateTemplate.substitute(subs) if args.verbose: print("Template:") print(templateStr) except KeyError as e: sys.exit("ERROR creating worldfile template: template variable %s was not specified" % (str(e),) ) except ValueError: sys.exit("A '$' character was found in the template template, which is illegal") # Write the template to a file stored in paths.RHESSYS_TEMPLATES, using the filename # of the template template as a basis templateFilename = os.path.splitext( os.path.split( metadata['template_template'] )[1] )[0] templateFilepath = os.path.join(paths.RHESSYS_TEMPLATES, templateFilename) f = open(templateFilepath, 'w') f.write(templateStr) f.close() RHESSysMetadata.writeRHESSysEntry(context, 'template', paths.relpath(templateFilepath) ) sys.stdout.write('done\n') # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
stations.append(m.group(1)) # Copy station file and climate data sys.stdout.write( textwrap.fill("Importing climate data from %s...\n" % (args.sourceDir, ))) sys.stdout.flush() for station in stations: # Copy station file sys.stdout.write("\n\tStation '%s'\n" % (station, )) sys.stdout.flush() stationFileName = "%s%s%s" % (station, os.extsep, STATION_FILE_EXTENSION) stationFilePath = os.path.join(args.sourceDir, stationFileName) shutil.copy(stationFilePath, paths.RHESSYS_CLIM) dataRegex = re.compile("^%s\.(.+)$" % (station, )) # Look for climate data files to copy and copy them for entry in contents: m = dataRegex.match(entry) if m: extension = m.group(1) if extension != STATION_FILE_EXTENSION: shutil.copy(os.path.join(args.sourceDir, entry), paths.RHESSYS_CLIM) sys.stdout.write('done\n') # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'climate_stations', RHESSysMetadata.VALUE_DELIM.join(stations)) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
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,)) RHESSysMetadata.writeGRASSEntry(context, 'gage_vect', 'gage') # Snap the gage to the stream findTheRiver = os.path.join(modulePath, 'r.findtheriver') if args.streamWindow: result = grassLib.script.read_command(findTheRiver, verbose=True, accumulation="uaa", easting=easting, northing=northing, threshold=args.streamThreshold,
if os.path.isdir(toDelete): shutil.rmtree(toDelete) else: os.unlink(toDelete) except OSError as e: if e.errno != errno.ENOENT: raise e ## 1. Fetch ParamDB gitCommand = "%s clone %s %s" % (gitPath, PARAM_DB_REPO_URL, paramDBPath) sha1Identifier = 'HEAD' returnCode = os.system(gitCommand) if returnCode != 0: sys.exit("Git command '%s' failed." % (gitCommand, )) # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'paramdb_src', PARAM_DB_REPO_URL) # Get SHA1 hash for version of ParamDB we are using, then store the hash in metadata gitCommand = "%s rev-parse %s" % (gitPath, sha1Identifier) process = Popen(gitCommand, shell=True, stdout=PIPE, cwd=paramDBPath) (processStdout, processStderr) = process.communicate() try: sha = processStdout.splitlines()[0] RHESSysMetadata.writeRHESSysEntry(context, 'paramdb_sha', sha) except IndexError: pass # Find ParamDB contents = os.listdir(paramDBPath) found = False for entry in contents: if entry == paramDBName: found = True
f.write('10 = 10 sand\n') f.write('11 = 11 loamy-sand\n') f.write('12 = 12 sandy-loam\n') f.write('13 = 13 rock\n') f.write('14 = 14 water\n') ruleDir = None sys.stdout.write('done\n') # Import rules from elsewhere if args.ruleDir: if not os.access(args.ruleDir, os.R_OK): sys.exit("Unable to read rule directory %s" % (ruleDir, )) ruleDir = os.path.abspath(args.ruleDir) if ruleDir: sys.stdout.write( textwrap.fill("Importing soil reclass rules from %s ..." % (ruleDir, ))) sys.stdout.flush() # Copy rules into project directory soilsRulePath = os.path.join(ruleDir, RHESSysMetadata.SOILS_RULE) shutil.copy(soilsRulePath, projectDirRuleDir) sys.stdout.write('done\n') # Write metadata RHESSysMetadata.writeRHESSysEntry( context, 'soil_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(soilsRulePath))) # 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)
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()
worldfileName = "%s_init" % (templateFilename.replace("template", "world"),) worldfilePath = os.path.join(paths.RHESSYS_WORLD, worldfileName) g2wPath = os.path.join(context.projectDir, metadata["g2w_bin"]) g2wCommand = "%s -t %s -w %s" % (g2wPath, templateFilepath, worldfilePath) # Make sure g2w can find rat g2wEnv = dict(os.environ) g2wEnv["PATH"] = paths.RHESSYS_BIN + os.pathsep + g2wEnv["PATH"] if args.verbose: print(g2wCommand) sys.stdout.write("\nRunning grass2world from %s..." % (paths.RHESSYS_BIN,)) sys.stdout.flush() cmdArgs = g2wCommand.split() process = Popen(cmdArgs, cwd=paths.RHESSYS_BIN, env=g2wEnv, stdout=PIPE, stderr=PIPE) (process_stdout, process_stderr) = process.communicate() if args.verbose: sys.stdout.write(process_stdout) sys.stderr.write(process_stderr) if process.returncode != 0: sys.exit("\n\ngrass2world failed, returning %s" % (process.returncode,)) RHESSysMetadata.writeRHESSysEntry(context, "worldfile_zero", paths.relpath(worldfilePath)) sys.stdout.write("\n\nFinished creating worldfile\n") # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
f.write('7 = 7 silt\n') f.write('8 = 8 silt-loam\n') f.write('9 = 9 loam\n') f.write('10 = 10 sand\n') f.write('11 = 11 loamy-sand\n') f.write('12 = 12 sandy-loam\n') f.write('13 = 13 rock\n') f.write('14 = 14 water\n') ruleDir = None sys.stdout.write('done\n') # Import rules from elsewhere if args.ruleDir: if not os.access(args.ruleDir, os.R_OK): sys.exit("Unable to read rule directory %s" % (ruleDir,) ) ruleDir = os.path.abspath(args.ruleDir) if ruleDir: sys.stdout.write(textwrap.fill("Importing soil reclass rules from %s ..." % (ruleDir,) ) ) sys.stdout.flush() # Copy rules into project directory soilsRulePath = os.path.join(ruleDir, RHESSysMetadata.SOILS_RULE) shutil.copy(soilsRulePath, projectDirRuleDir) sys.stdout.write('done\n') # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'soil_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(soilsRulePath)) ) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
print("CF output:") print(pStdout) if pStderr: print(pStderr) if p.returncode != 0: sys.exit("createflowpaths failed, returning %s" % (str(p.returncode), )) # Write cf output to project directory cfOut = open(cfOutpath, 'w') cfOut.write(pStdout) if pStderr: cfOut.write("\n\nStandard error output:\n\n") cfOut.write(pStderr) cfOut.close() cfCmd = "%s out=%s template=%s dem=%s slope=%s stream=%s road=%s roof=%s impervious=%s cellsize=%s" % \ (cfPath, flowOutpath, templatePath, grassMetadata['dem_rast'], grassMetadata['slope_rast'], grassMetadata['streams_rast'], roads, roofs, impervious, demResX) RHESSysMetadata.writeRHESSysEntry(context, 'flowtable_cmd', cfCmd) RHESSysMetadata.writeRHESSysEntry( context, 'surface_flowtable', paths.relpath(os.path.join(paths.RHESSYS_FLOW, surfaceFlowtable))) RHESSysMetadata.writeRHESSysEntry( context, 'subsurface_flowtable', paths.relpath(os.path.join(paths.RHESSYS_FLOW, subsurfaceFlowtable))) sys.stdout.write('\nFinished creating flowtable\n') # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
if None == result: sys.exit("r.soils.texture failed, returning %s" % (result,)) RHESSysMetadata.writeGRASSEntry(context, 'soil_rast', soil_rast) sys.stdout.write('done\n') sys.stdout.write('Reading soil parameter definitions from RHESSys ParamDB...') sys.stdout.flush() # Fetch relevant soil default files from param DB pipe = grassLib.script.pipe_command('r.stats', flags='licn', input=soil_rast) textures = {} for line in pipe.stdout: (dn, cat, num, ) = line.strip().split() if cat != 'NULL': textures[cat] = int(dn) pipe.wait() print("Writing soil definition files to %s" % (paths.RHESSYS_DEF) ) for key in textures.keys(): print("soil '%s' has dn %d" % (key, textures[key]) ) paramsFound = paramDB.search(paramConst.SEARCH_TYPE_CONSTRAINED, None, key, None, None, None, None, None, None, None, None, limitToBaseClasses=True, defaultIdOverride=textures[key]) assert(paramsFound) paramDB.writeParamFileForClass(paths.RHESSYS_DEF) # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'soil_defs', True) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
cat, num, ) = line.strip().split() if cat != 'NULL': textures[cat] = int(dn) pipe.wait() print("Writing soil definition files to %s" % (paths.RHESSYS_DEF)) for key in textures.keys(): print("soil '%s' has dn %d" % (key, textures[key])) paramsFound = paramDB.search(paramConst.SEARCH_TYPE_CONSTRAINED, None, key, None, None, None, None, None, None, None, None, limitToBaseClasses=True, defaultIdOverride=textures[key]) assert (paramsFound) paramDB.writeParamFileForClass(paths.RHESSYS_DEF) # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'soil_defs', True) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
def run(self, *args, **kwargs): """ Multiple worldfiles, one worldfile for each subbasin delineated. Arguments: verbose -- boolean Produce verbose output. Default: False. """ verbose = kwargs.get('verbose', False) self.checkMetadata() rhessysDir = self.metadata['rhessys_dir'] self.paths = RHESSysPaths(self.context.projectDir, rhessysDir) templateFilename = os.path.basename(self.metadata['template']) templateFilepath = os.path.join(self.context.projectDir, self.metadata['template']) g2wPath = os.path.join(self.context.projectDir, self.metadata['g2w_bin']) # Make sure g2w can find rat g2wEnv = dict(os.environ) g2wEnv['PATH'] = self.paths.RHESSYS_BIN + os.pathsep + g2wEnv['PATH'] # Make sure region is properly set demRast = self.grassMetadata['dem_rast'] result = self.grassLib.script.run_command('g.region', rast=demRast) if result != 0: raise RunException("g.region failed to set region to DEM, returning {0}".format(result)) # Mask subbasin to basin basin_rast = self.grassMetadata['basin_rast'] result = self.grassLib.script.run_command('r.mask', flags='o', input=basin_rast, maskcats='1', quiet=True) if result != 0: sys.exit("r.mask failed to set mask to basin, returning %s" % (result,)) subbasin_raster = self.grassMetadata['subbasins_rast'] subbasin_mask = "{0}_mask".format(subbasin_raster) mapcalc_input = "{subbasin_mask}={subbasins}".format(subbasin_mask=subbasin_mask, subbasins=subbasin_raster) result = self.grassLib.script.write_command('r.mapcalc', stdin=mapcalc_input, stdout=PIPE, stderr=PIPE) if result != 0: raise RunException("r.mapcalc failed to generate masked subbasin map {0}, input: {1}".format(subbasin_raster, mapcalc_input)) # Get list of subbasins result = self.grassLib.script.read_command('r.stats', flags='n', input=subbasin_raster, quiet=True) if result is None or result == '': raise RunException("Error reading subbasin map {0}".format(subbasin_raster)) subbasins = result.split() subbasin_masks = [] worldfiles = [] for subbasin in subbasins: # Remove mask result = self.grassLib.script.run_command('r.mask', flags='r', quiet=True) if result != 0: raise RunException("r.mask failed to remove mask") # Make a mask layer for the sub-basin mask_name = "subbasin_{0}".format(subbasin) subbasin_masks.append(mask_name) result = self.grassLib.script.write_command('r.mapcalc', stdin="{mask_name}={subbasins} == {subbasin_number}".format(mask_name=mask_name, subbasins=subbasin_mask, subbasin_number=subbasin), stdout=PIPE, stderr=PIPE) if result != 0: raise RunException("r.mapcalc failed to generate mask for subbasin {0}".format(subbasin)) # Mask to the sub-basin result = self.grassLib.script.run_command('r.mask', flags='o', input=mask_name, maskcats='1', quiet=True) if result != 0: raise RunException("r.mask failed to set mask to sub-basin {0}, returning {1}".format(mask_name, result)) worldfileName = "world_subbasin_{0}_init".format(subbasin) worldfilePath = os.path.join(self.paths.RHESSYS_WORLD, worldfileName) worldfiles.append(worldfilePath) g2wCommand = "{g2w} -t {template} -w {worldfile}".format(g2w=g2wPath, template=templateFilepath, worldfile=worldfilePath) if verbose: self.outfp.write("{0}\n".format(g2wCommand)) self.outfp.write("\nRunning grass2world from {0}...".format(self.paths.RHESSYS_BIN)) self.outfp.flush() cmdArgs = g2wCommand.split() process = Popen(cmdArgs, cwd=self.paths.RHESSYS_BIN, env=g2wEnv, stdout=PIPE, stderr=PIPE) (process_stdout, process_stderr) = process.communicate() if process.returncode != 0: raise RunException("grass2world failed, returning {0}".format(process.returncode)) if verbose: self.outfp.write(process_stdout) self.outfp.write(process_stderr) # Remove mask result = self.grassLib.script.run_command('r.mask', flags='r', quiet=True) if result != 0: raise RunException("r.mask failed to remove mask") # Write metadata RHESSysMetadata.writeRHESSysEntry(self.context, 'worldfiles_init', RHESSysMetadata.VALUE_DELIM.join([self.paths.relpath(w) for w in worldfiles])) RHESSysMetadata.writeRHESSysEntry(self.context, 'subbasin_masks', RHESSysMetadata.VALUE_DELIM.join([m for m in subbasin_masks])) if verbose: self.outfp.write('\n\nFinished creating worldfiles\n') # Write processing history RHESSysMetadata.appendProcessingHistoryItem(self.context, RHESSysMetadata.getCommandLine())
sys.exit("\nlairead failed, returning %s" % (result, )) ## 3. Write TEC file for redefining the initial flow table ## Redefine on the second day of the simulation, write output ## on the third day tecName = 'tec.lairead' tecPath = os.path.join(paths.RHESSYS_TEC, tecName) tecDurOutput = datetime.timedelta(days=2) tecOutput = startDate + tecDurOutput f = open(tecPath, 'w') f.write("%s redefine_world%s" % (datetimeToString(tecRedef), os.linesep)) f.write("%s output_current_state%s" % (datetimeToString(tecOutput), os.linesep)) f.close() RHESSysMetadata.writeRHESSysEntry(context, 'tec_lairead', paths.relpath(tecPath)) ## 4. Run RHESSys for the first 4 legal days with redefine TEC rhessysStart = startDate rhessysDur = datetime.timedelta(days=3) rhessysEnd = startDate + rhessysDur surfaceFlowtablePath = os.path.join(context.projectDir, metadata['surface_flowtable']) subSurfaceFlowtablePath = os.path.join(context.projectDir, metadata['subsurface_flowtable']) rhessysBinPath = os.path.join(context.projectDir, metadata['rhessys_bin']) rhessysCmd = generateCommandString(rhessysBinPath, None, rhessysStart, rhessysEnd, tecPath, oldWorldPath, surfaceFlowtablePath, subSurfaceFlowtablePath)
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)
(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)
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()
def run(self, *args, **kwargs): """ Run lairead for multiple worldfiles Arguments: topmodel -- boolean Whether to run RHESSys in TOPMODEL model. Default: False. verbose -- boolean Produce verbose output. Default: False. """ verbose = kwargs.get('verbose', False) topmodel = kwargs.get('topmodel', False) self.checkMetadata(topmodel=topmodel) rhessysDir = self.metadata['rhessys_dir'] self.paths = RHESSysPaths(self.context.projectDir, rhessysDir) rhessysBinPath = os.path.join(self.context.projectDir, self.metadata['rhessys_bin']) # Make sure region is properly set demRast = self.grassMetadata['dem_rast'] result = self.grassLib.script.run_command('g.region', rast=demRast) if result != 0: raise RunException("g.region failed to set region to DEM, returning {0}".format(result)) # Run lairead for each worldfile lairead_tecfiles = [] final_worldfiles = [] worldfiles = self.metadata['worldfiles_init'].split(RHESSysMetadata.VALUE_DELIM) masks = self.metadata['subbasin_masks'].split(RHESSysMetadata.VALUE_DELIM) surfaceFlowtables = subsurfaceFlowtables = None if not topmodel: surfaceFlowtables = self.metadata['surface_flowtables'].split(RHESSysMetadata.VALUE_DELIM) subsurfaceFlowtables = self.metadata['subsurface_flowtables'].split(RHESSysMetadata.VALUE_DELIM) for (i, worldfile) in enumerate(worldfiles): worldfilePath = os.path.join(self.context.projectDir, worldfile) worldfileDir = os.path.dirname(worldfilePath) surfaceFlowtable = subsurfaceFlowtable = None if not topmodel: surfaceFlowtable = surfaceFlowtables[i] # Assumption: worldfiles and flowtables lists are in the same order subsurfaceFlowtable = subsurfaceFlowtables[i] # Assumption: worldfiles and flowtables lists are in the same order # Mask to correct mask mask = masks[i] # Assumption: worldfiles and masks lists are in the same order result = self.grassLib.script.run_command('r.mask', flags='o', input=mask, maskcats='1', quiet=True) if result != 0: raise RunException("r.mask failed to set mask to sub-basin {0}, returning {1}".format(mask, result)) ## 1. Determine legal simulation start and date from climate data # Read first climate station from worldfile header = "{0}.hdr".format(worldfile) headerPath = os.path.join(self.context.projectDir, header) stations = getClimateBaseStationFilenames(headerPath) if not len(stations) > 0: raise RunException("No climate stations found in worldfile header {0}".format(headerPath)) firstStationPath = os.path.normpath( os.path.join(self.paths.RHESSYS_DIR, stations[0]) ) if verbose: self.outfp.write("First climate station in worldfile: %s\n" % (firstStationPath,) ) # Read climate timeseries for start and end date, write to metadata (startDate, endDate) = getStartAndEndDateForClimateStation(firstStationPath, self.paths) if verbose: self.outfp.write("start date: %s, end date: %s\n" % ( str(startDate), str(endDate) ) ) fourDays = datetime.timedelta(days=4) if endDate - startDate < fourDays: raise RunException("Climate time-series defined by station %s is too short to run lairead (less than four-days long)" % (firstStationPath,) ) ## 2. Run LAI read to generate redefine worldfile tecDurRedef = datetime.timedelta(days=1) tecRedef = startDate + tecDurRedef laireadPath = os.path.join(self.context.projectDir, self.metadata['lairead_bin']) oldWorldPath = os.path.join(self.context.projectDir, worldfile) redefWorldName = "%s.Y%dM%dD%dH%d" % \ (worldfile, tecRedef.year, tecRedef.month, tecRedef.day, tecRedef.hour) redefWorldPath = os.path.join(self.context.projectDir, redefWorldName) allomPath = os.path.join(self.context.projectDir, self.metadata['allometric_table']) if verbose: self.outfp.write("\nRunning lairead for subbasin {0}...".format(mask)) p = self.grassLib.script.pipe_command(laireadPath, old=oldWorldPath, redef=redefWorldPath, allom=allomPath, lai=self.grassMetadata['lai_rast'], vegid=self.grassMetadata['stratum_rast'], zone=self.grassMetadata['zone_rast'], hill=self.grassMetadata['hillslope_rast'], patch=self.grassMetadata['patch_rast'], mask=mask) (stdoutStr, stderrStr) = p.communicate() result = p.returncode if result != 0: self.outfp.write(stdoutStr) raise RunException("\nlairead failed, returning %s" % (result,)) if verbose: self.outfp.write('done\n') ## 3. Write TEC file for redefining the initial flow table ## Redefine on the second day of the simulation, write output ## on the third day tecName = "tec.lairead_{0}".format(mask) tecPath = os.path.join(self.paths.RHESSYS_TEC, tecName) tecDurOutput = datetime.timedelta(days=2) tecOutput = startDate + tecDurOutput f = open(tecPath, 'w') f.write("%s redefine_world%s" % (datetimeToString(tecRedef), os.linesep) ) f.write("%s output_current_state%s" % (datetimeToString(tecOutput), os.linesep) ) f.close() lairead_tecfiles.append(tecPath) ## 4. Run RHESSys for the first 4 legal days with redefine TEC rhessysStart = startDate rhessysDur = datetime.timedelta(days=3) rhessysEnd = startDate + rhessysDur surfaceFlowtablePath = subSurfaceFlowtablePath = None if not topmodel: surfaceFlowtablePath = os.path.join(self.context.projectDir, surfaceFlowtable) subsurfaceFlowtablePath = os.path.join(self.context.projectDir, subsurfaceFlowtable) rhessysCmd = generateCommandString(rhessysBinPath, None, rhessysStart, rhessysEnd, tecPath, oldWorldPath, surfaceFlowtablePath, subsurfaceFlowtablePath) if verbose: self.outfp.write('\nRunning RHESSys to redefine worldfile with vegetation carbon stores...\n') self.outfp.write(rhessysCmd) self.outfp.write('\n') cmdArgs = rhessysCmd.split() process = Popen(cmdArgs, cwd=self.paths.RHESSYS_DIR, stdout=PIPE, stderr=PIPE) (process_stdout, process_stderr) = process.communicate() if verbose: self.outfp.write(process_stdout) self.outfp.write(process_stderr) if process.returncode != 0: raise RunException("\n\nRHESSys failed, returning %s" % (process.returncode,) ) if verbose: sys.stdout.write('done\n') ## 5. Rename redefine worldfile, write to metadata outputWorldName = "%s.Y%dM%dD%dH%d.state" % \ (worldfile, tecOutput.year, tecOutput.month, tecOutput.day, tecOutput.hour) outputWorldPath = os.path.join(self.context.projectDir, outputWorldName) if not os.access(outputWorldPath, os.W_OK): raise RunException("Unable to find redefined worldfile %s" % (outputWorldPath,) ) newWorldName = "world_{0}".format(mask) newWorldPath = os.path.join(self.paths.RHESSYS_WORLD, newWorldName) shutil.move(outputWorldPath, newWorldPath) if not os.path.exists(newWorldPath): raise RunException("Failed to copy redefined worldfile %s to %s" % (outputWorldPath, newWorldPath) ) final_worldfiles.append(newWorldPath) # Copy world file header from init worldfile to final world file newHeader = "%s.hdr" % (newWorldName,) newHeaderPath = os.path.join(self.paths.RHESSYS_WORLD, newHeader) shutil.copyfile(headerPath, newHeaderPath) if verbose: sys.stdout.write('\n\nSuccessfully used lairead to initialize vegetation carbon stores.\n') # Write metadata RHESSysMetadata.writeRHESSysEntry(self.context, 'worldfiles', RHESSysMetadata.VALUE_DELIM.join([self.paths.relpath(w) for w in final_worldfiles])) RHESSysMetadata.writeRHESSysEntry(self.context, 'lairead_tecfiles', RHESSysMetadata.VALUE_DELIM.join([self.paths.relpath(t) for t in lairead_tecfiles])) RHESSysMetadata.writeRHESSysEntry(self.context, 'lairead_mode_topmodel', str(topmodel)) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(self.context, RHESSysMetadata.getCommandLine())
def run(self, *args, **kwargs): """ Multiple worldfiles, one worldfile for each subbasin delineated. Arguments: verbose -- boolean Produce verbose output. Default: False. """ verbose = kwargs.get('verbose', False) self.checkMetadata() rhessysDir = self.metadata['rhessys_dir'] self.paths = RHESSysPaths(self.context.projectDir, rhessysDir) templateFilename = os.path.basename(self.metadata['template']) templateFilepath = os.path.join(self.context.projectDir, self.metadata['template']) g2wPath = os.path.join(self.context.projectDir, self.metadata['g2w_bin']) # Make sure g2w can find rat g2wEnv = dict(os.environ) g2wEnv['PATH'] = self.paths.RHESSYS_BIN + os.pathsep + g2wEnv['PATH'] # Make sure region is properly set demRast = self.grassMetadata['dem_rast'] result = self.grassLib.script.run_command('g.region', rast=demRast) if result != 0: raise RunException( "g.region failed to set region to DEM, returning {0}".format( result)) # Mask subbasin to basin basin_rast = self.grassMetadata['basin_rast'] result = self.grassLib.script.run_command('r.mask', flags='o', input=basin_rast, maskcats='1', quiet=True) if result != 0: sys.exit("r.mask failed to set mask to basin, returning %s" % (result, )) subbasin_raster = self.grassMetadata['subbasins_rast'] subbasin_mask = "{0}_mask".format(subbasin_raster) mapcalc_input = "{subbasin_mask}={subbasins}".format( subbasin_mask=subbasin_mask, subbasins=subbasin_raster) result = self.grassLib.script.write_command('r.mapcalc', stdin=mapcalc_input, stdout=PIPE, stderr=PIPE) if result != 0: raise RunException( "r.mapcalc failed to generate masked subbasin map {0}, input: {1}" .format(subbasin_raster, mapcalc_input)) # Get list of subbasins result = self.grassLib.script.read_command('r.stats', flags='n', input=subbasin_raster, quiet=True) if result is None or result == '': raise RunException( "Error reading subbasin map {0}".format(subbasin_raster)) subbasins = result.split() subbasin_masks = [] worldfiles = [] for subbasin in subbasins: # Remove mask result = self.grassLib.script.run_command('r.mask', flags='r', quiet=True) if result != 0: raise RunException("r.mask failed to remove mask") # Make a mask layer for the sub-basin mask_name = "subbasin_{0}".format(subbasin) subbasin_masks.append(mask_name) result = self.grassLib.script.write_command( 'r.mapcalc', stdin="{mask_name}={subbasins} == {subbasin_number}".format( mask_name=mask_name, subbasins=subbasin_mask, subbasin_number=subbasin), stdout=PIPE, stderr=PIPE) if result != 0: raise RunException( "r.mapcalc failed to generate mask for subbasin {0}". format(subbasin)) # Mask to the sub-basin result = self.grassLib.script.run_command('r.mask', flags='o', input=mask_name, maskcats='1', quiet=True) if result != 0: raise RunException( "r.mask failed to set mask to sub-basin {0}, returning {1}" .format(mask_name, result)) worldfileName = "world_subbasin_{0}_init".format(subbasin) worldfilePath = os.path.join(self.paths.RHESSYS_WORLD, worldfileName) worldfiles.append(worldfilePath) g2wCommand = "{g2w} -t {template} -w {worldfile}".format( g2w=g2wPath, template=templateFilepath, worldfile=worldfilePath) if verbose: self.outfp.write("{0}\n".format(g2wCommand)) self.outfp.write("\nRunning grass2world from {0}...".format( self.paths.RHESSYS_BIN)) self.outfp.flush() cmdArgs = g2wCommand.split() process = Popen(cmdArgs, cwd=self.paths.RHESSYS_BIN, env=g2wEnv, stdout=PIPE, stderr=PIPE) (process_stdout, process_stderr) = process.communicate() if process.returncode != 0: raise RunException("grass2world failed, returning {0}".format( process.returncode)) if verbose: self.outfp.write(process_stdout) self.outfp.write(process_stderr) # Remove mask result = self.grassLib.script.run_command('r.mask', flags='r', quiet=True) if result != 0: raise RunException("r.mask failed to remove mask") # Write metadata RHESSysMetadata.writeRHESSysEntry( self.context, 'worldfiles_init', RHESSysMetadata.VALUE_DELIM.join( [self.paths.relpath(w) for w in worldfiles])) RHESSysMetadata.writeRHESSysEntry( self.context, 'subbasin_masks', RHESSysMetadata.VALUE_DELIM.join([m for m in subbasin_masks])) if verbose: self.outfp.write('\n\nFinished creating worldfiles\n') # Write processing history RHESSysMetadata.appendProcessingHistoryItem( self.context, RHESSysMetadata.getCommandLine())
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) if result != 0: sys.exit("v.in.ascii failed to create 'gage' vector, returning %s" % (result, )) RHESSysMetadata.writeGRASSEntry(context, 'gage_vect', 'gage') # Snap the gage to the stream findTheRiver = os.path.join(modulePath, 'r.findtheriver')
def test_write_and_read(self): RHESSysMetadata.writeRHESSysEntry(self.context, "key1", "value_one") RHESSysMetadata.writeRHESSysEntry(self.context, "key2", "value_two") metadata = RHESSysMetadata.readRHESSysEntries(self.context) self.assertTrue(metadata["key1"] == "value_one")
if os.path.isdir(toDelete): shutil.rmtree(toDelete) else: os.unlink(toDelete) except OSError as e: if e.errno != errno.ENOENT: raise e ## 1. Fetch ParamDB gitCommand = "%s clone %s %s" % (gitPath, PARAM_DB_REPO_URL, paramDBPath) sha1Identifier = 'HEAD' returnCode = os.system(gitCommand) if returnCode != 0: sys.exit("Git command '%s' failed." % (gitCommand, ) ) # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'paramdb_src', PARAM_DB_REPO_URL) # Get SHA1 hash for version of ParamDB we are using, then store the hash in metadata gitCommand = "%s rev-parse %s" % (gitPath, sha1Identifier) process = Popen(gitCommand, shell=True, stdout=PIPE, cwd=paramDBPath) (processStdout, processStderr) = process.communicate() try: sha = processStdout.splitlines()[0] RHESSysMetadata.writeRHESSysEntry(context, 'paramdb_sha', sha) except IndexError: pass # Find ParamDB contents = os.listdir(paramDBPath) found = False for entry in contents: if entry == paramDBName: found = True
# Reclassify landcover into impervious map if not args.defonly: result = grassLib.script.read_command('r.reclass', input=landcoverRast, output='impervious', rules=imperviousRulePath, overwrite=args.overwrite) if None == result: sys.exit("r.reclass failed to create impervious map, returning %s" % (result,)) RHESSysMetadata.writeGRASSEntry(context, 'impervious_rast', 'impervious') # Reclassify landcover into LAI map if args.makeLaiMap and (not args.defonly): if RHESSysMetadata.LC_RULE_LAI_COMPAT == os.path.basename(metadata['landcover_lai_rule']): # Compatibility mode, use r.reclass result = grassLib.script.read_command('r.reclass', input=landcoverRast, output='lai', rules=laiRulePath, overwrite=args.overwrite) if None == result: sys.exit("r.reclass failed to create LAI map, returning %s" % (result,)) else: # use r.reclass result = grassLib.script.read_command('r.recode', input=landcoverRast, output='lai', rules=laiRulePath, overwrite=args.overwrite) if None == result: sys.exit("r.reclass failed to create LAI map, returning %s" % (result,)) RHESSysMetadata.writeGRASSEntry(context, 'lai_rast', 'lai') # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'stratum_defs', True) RHESSysMetadata.writeRHESSysEntry(context, 'landuse_defs', True) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
for entry in contents: m = stationRegex.match(entry) if m: stations.append(m.group(1)) # Copy station file and climate data sys.stdout.write(textwrap.fill("Importing climate data from %s...\n" % (args.sourceDir,) ) ) sys.stdout.flush() for station in stations: # Copy station file sys.stdout.write("\n\tStation '%s'\n" % (station,) ) sys.stdout.flush() stationFileName = "%s%s%s" % (station, os.extsep, STATION_FILE_EXTENSION) stationFilePath = os.path.join(args.sourceDir, stationFileName) shutil.copy(stationFilePath, paths.RHESSYS_CLIM) dataRegex = re.compile("^%s\.(.+)$" % (station,) ) # Look for climate data files to copy and copy them for entry in contents: m = dataRegex.match(entry) if m: extension = m.group(1) if extension != STATION_FILE_EXTENSION: shutil.copy( os.path.join(args.sourceDir, entry), paths.RHESSYS_CLIM ) sys.stdout.write('done\n') # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'climate_stations', RHESSysMetadata.VALUE_DELIM.join(stations)) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
shutil.copy(roadRulePath, projectDirRuleDir) imperviousRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_IMPERVIOUS) shutil.copy(imperviousRulePath, projectDirRuleDir) landuseRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_LANDUSE) shutil.copy(landuseRulePath, projectDirRuleDir) stratumRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_STRATUM) shutil.copy(stratumRulePath, projectDirRuleDir) if args.includeLaiRules: laiRulePath = os.path.join(ruleDir, RHESSysMetadata.LC_RULE_LAI) shutil.copy(laiRulePath, projectDirRuleDir) sys.stdout.write('done\n') # Write metadata RHESSysMetadata.writeRHESSysEntry( context, 'landcover_stratum_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(stratumRulePath))) RHESSysMetadata.writeRHESSysEntry( context, 'landcover_landuse_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(landuseRulePath))) RHESSysMetadata.writeRHESSysEntry( context, 'landcover_impervious_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(imperviousRulePath))) RHESSysMetadata.writeRHESSysEntry( context, 'landcover_road_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(roadRulePath))) if args.includeLaiRules: RHESSysMetadata.writeRHESSysEntry( context, 'landcover_lai_rule', os.path.join(RHESSysMetadata.RULES_DIR, os.path.basename(laiRulePath)))
if args.makeLaiMap and (not args.defonly): if RHESSysMetadata.LC_RULE_LAI_COMPAT == os.path.basename( metadata['landcover_lai_rule']): # Compatibility mode, use r.reclass result = grassLib.script.read_command('r.reclass', input=landcoverRast, output='lai', rules=laiRulePath, overwrite=args.overwrite) if None == result: sys.exit("r.reclass failed to create LAI map, returning %s" % (result, )) else: # use r.reclass result = grassLib.script.read_command('r.recode', input=landcoverRast, output='lai', rules=laiRulePath, overwrite=args.overwrite) if None == result: sys.exit("r.reclass failed to create LAI map, returning %s" % (result, )) RHESSysMetadata.writeGRASSEntry(context, 'lai_rast', 'lai') # Write metadata RHESSysMetadata.writeRHESSysEntry(context, 'stratum_defs', True) RHESSysMetadata.writeRHESSysEntry(context, 'landuse_defs', True) # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)
g2wCommand = "%s -t %s -w %s" % (g2wPath, templateFilepath, worldfilePath) # Make sure g2w can find rat g2wEnv = dict(os.environ) g2wEnv['PATH'] = paths.RHESSYS_BIN + os.pathsep + g2wEnv['PATH'] if args.verbose: print(g2wCommand) sys.stdout.write("\nRunning grass2world from %s..." % (paths.RHESSYS_BIN, )) sys.stdout.flush() cmdArgs = g2wCommand.split() process = Popen(cmdArgs, cwd=paths.RHESSYS_BIN, env=g2wEnv, stdout=PIPE, stderr=PIPE) (process_stdout, process_stderr) = process.communicate() if args.verbose: sys.stdout.write(process_stdout) sys.stderr.write(process_stderr) if process.returncode != 0: sys.exit("\n\ngrass2world failed, returning %s" % (process.returncode, )) RHESSysMetadata.writeRHESSysEntry(context, 'worldfile_zero', paths.relpath(worldfilePath)) sys.stdout.write('\n\nFinished creating worldfile\n') # Write processing history RHESSysMetadata.appendProcessingHistoryItem(context, cmdline)