def main(): # Get the options inputs = options["inputs"] sampler = options["sample"] samtype = options["samtype"] intype = options["intype"] separator = grass.separator(options["separator"]) method = options["method"] header = flags["c"] spatial = flags["s"] # Make sure the temporal database exists tgis.init() tgis.sample_stds_by_stds_topology(intype, samtype, inputs, sampler, header, separator, method, spatial, True)
def main(): # Get the options inputs = options["inputs"] sampler = options["sample"] samtype = options["samtype"] intype = options["intype"] separator = grass.separator(options["separator"]) method = options["method"] header = flags["c"] spatial = flags["s"] # Make sure the temporal database exists tgis.init() tgis.sample_stds_by_stds_topology(intype, samtype, inputs, sampler, header, separator, method, spatial, True)
def main(): # Get the options input = options["input"] output = options["output"] strds = options["strds"] where = options["where"] tempwhere = options["t_where"] if output and flags['u']: grass.fatal(_("Cannot combine 'output' option and 'u' flag")) elif not output and not flags['u']: grass.fatal(_("'output' option or 'u' flag must be given")) elif not output and flags['u']: grass.warning(_("Attribute table of vector {name} will be updated...").format(name=input)) if where == "" or where == " " or where == "\n": where = None overwrite = grass.overwrite() quiet = True if grass.verbosity() > 2: quiet = False # Check the number of sample strds and the number of columns strds_names = strds.split(",") # Make sure the temporal database exists tgis.init() # We need a database interface dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() samples = [] first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif) # Single space time raster dataset if len(strds_names) == 1: rows = first_strds.get_registered_maps("name,mapset,start_time,end_time", tempwhere, "start_time", dbif) if not rows: dbif.close() grass.fatal(_("Space time raster dataset <%s> is empty") % first_strds.get_id()) for row in rows: start = row["start_time"] end = row["end_time"] raster_maps = [row["name"] + "@" + row["mapset"], ] s = Sample(start, end, raster_maps, first_strds.get_name()) samples.append(s) else: # Multiple space time raster datasets for name in strds_names[1:]: dataset = tgis.open_old_stds(name, "strds", dbif) if dataset.get_temporal_type() != first_strds.get_temporal_type(): grass.fatal(_("Temporal type of space time raster " "datasets must be equal\n<%(a)s> of type " "%(type_a)s do not match <%(b)s> of type " "%(type_b)s" % {"a": first_strds.get_id(), "type_a": first_strds.get_temporal_type(), "b": dataset.get_id(), "type_b": dataset.get_temporal_type()})) mapmatrizes = tgis.sample_stds_by_stds_topology("strds", "strds", strds_names, strds_names[0], False, None, "equal", False, False) for i in xrange(len(mapmatrizes[0])): isvalid = True mapname_list = [] for mapmatrix in mapmatrizes: entry = mapmatrix[i] if entry["samples"]: sample = entry["samples"][0] name = sample.get_id() if name is None: isvalid = False break else: mapname_list.append(name) if isvalid: entry = mapmatrizes[0][i] map = entry["granule"] start, end = map.get_temporal_extent_as_tuple() s = Sample(start, end, mapname_list, name) samples.append(s) # Get the layer and database connections of the input vector if output: gcopy(input, output, 'vector') else: output = input msgr = Messenger() perc_curr = 0 perc_tot = len(samples) pymap = Vector(output) try: pymap.open('r') except: dbif.close() grass.fatal(_("It is not possible to open the new map %s" % output)) if len(pymap.dblinks) == 0: try: grass.run_command("v.db.addtable", map=output) except CalledModuleError: dbif.close() grass.fatal(_("Impossible add table to vector %s" % output)) pymap.close() for sample in samples: raster_names = sample.raster_names # Call v.what.rast for each raster map for name in raster_names: coltype = "DOUBLE PRECISION" # Get raster map type raster_map = tgis.RasterDataset(name) raster_map.load() if raster_map.metadata.get_datatype() == "CELL": coltype = "INT" day = sample.printDay() column_name = "%s_%s" % (sample.strds_name, day) column_string = "%s %s" % (column_name, coltype) column_string.replace('.', '_') try: grass.run_command("v.db.addcolumn", map=output, column=column_string, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal(_("Unable to add column %s to vector map " "<%s> ") % (column_string, output)) try: grass.run_command("v.what.rast", map=output, raster=name, column=column_name, where=where, quiet=quiet) except CalledModuleError: dbif.close() grass.fatal(_("Unable to run v.what.rast for vector map" " <%s> and raster map <%s>") % (output, str(raster_names))) msgr.percent(perc_curr, perc_tot, 1) perc_curr += 1 dbif.close()
def main(): # Get the options input = options["input"] output = options["output"] strds = options["strds"] tempwhere = options["t_where"] where = options["where"] methods = options["method"] percentile = options["percentile"] overwrite = grass.overwrite() quiet = True if grass.verbosity() > 2: quiet = False if where == "" or where == " " or where == "\n": where = None # Check the number of sample strds and the number of columns strds_names = strds.split(",") # Make sure the temporal database exists tgis.init() # We need a database interface dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() samples = [] first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif) # Single space time raster dataset if len(strds_names) == 1: granu = first_strds.get_granularity() rows = first_strds.get_registered_maps( "name,mapset,start_time,end_time", tempwhere, "start_time", dbif) if not rows: dbif.close() grass.fatal( _("Space time raster dataset <%s> is empty") % first_strds.get_id()) for row in rows: start = row["start_time"] end = row["end_time"] raster_maps = [ row["name"] + "@" + row["mapset"], ] s = Sample(start, end, raster_maps, first_strds.get_name(), granu) samples.append(s) else: # Multiple space time raster datasets for name in strds_names[1:]: dataset = tgis.open_old_stds(name, "strds", dbif) if dataset.get_temporal_type() != first_strds.get_temporal_type(): grass.fatal( _( "Temporal type of space time raster " "datasets must be equal\n<%(a)s> of type " "%(type_a)s do not match <%(b)s> of type " "%(type_b)s" % { "a": first_strds.get_id(), "type_a": first_strds.get_temporal_type(), "b": dataset.get_id(), "type_b": dataset.get_temporal_type() })) mapmatrizes = tgis.sample_stds_by_stds_topology( "strds", "strds", strds_names, strds_names[0], False, None, "equal", False, False) #TODO check granularity for multiple STRDS for i in range(len(mapmatrizes[0])): isvalid = True mapname_list = [] for mapmatrix in mapmatrizes: entry = mapmatrix[i] if entry["samples"]: sample = entry["samples"][0] name = sample.get_id() if name is None: isvalid = False break else: mapname_list.append(name) if isvalid: entry = mapmatrizes[0][i] map = entry["granule"] start, end = map.get_temporal_extent_as_tuple() s = Sample(start, end, mapname_list, name) samples.append(s) # Get the layer and database connections of the input vector if where: try: grass.run_command("v.extract", input=input, where=where, output=output) except CalledModuleError: dbif.close() grass.fatal( _("Unable to run v.extract for vector map" " <%s> and where <%s>") % (input, where)) else: gcopy(input, output, 'vector') msgr = Messenger() perc_curr = 0 perc_tot = len(samples) pymap = Vector(output) try: pymap.open('r') except: dbif.close() grass.fatal(_("Unable to create vector map <%s>" % output)) pymap.close() for sample in samples: raster_names = sample.raster_names # Call v.what.rast for each raster map for name in raster_names: day = sample.printDay() column_name = "%s_%s" % (sample.strds_name, day) try: grass.run_command("v.rast.stats", map=output, raster=name, column=column_name, method=methods, percentile=percentile, quiet=quiet, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal( _("Unable to run v.what.rast for vector map" " <%s> and raster map <%s>") % (output, name)) msgr.percent(perc_curr, perc_tot, 1) perc_curr += 1 dbif.close()
def main(): # Initiate GRASS init = vtkGRASSInit() init.Init("t.rast.RothCModel") init.ExitOnErrorOn() module = vtkGRASSModule() module.SetDescription("Soil organic carbon computation using the RothC model") module.AddKeyword("temporal") module.AddKeyword("RothC") xmlParam = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetFileInputType()) xmlParam.SetKey("param") xmlParam.RequiredOff() xmlParam.SetDescription("The parameter XML file that describes the RothC configuarion ") temperature = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) temperature.SetKey("temperature") temperature.SetDescription("Input space time raster dataset with " "monthly temperature mean [degree C]" ". This dataset will be used to temporally sample all other.") precipitation = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) precipitation.SetKey("precipitation") precipitation.SetDescription("Input space time raster dataset with " "monthly accumulated precipitation [mm]") radiation = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) radiation.SetKey("radiation") radiation.SetDescription("Input space time raster dataset with " "global radiation [J/(cm^2 * day)]") fertilizer = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) fertilizer.SetKey("fertilizer") fertilizer.SetDescription("Input space time raster dataset with organic " "fertilizer of the RothC model [tC/ha]") roots = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) roots.SetKey("roots") roots.SetDescription("Input space time raster dataset with root residuals of the RothC model [tC/ha]") shoots = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) shoots.SetKey("shoots") shoots.SetDescription("Input space time raster dataset with shoot residuals of the RothC model [tC/ha]") # Space time raster datasets soilCover = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) soilCover.SetKey("soilcover") soilCover.SetDescription("Input space time raster dataset with soil cover time series [0;1]") fertId = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) fertId.SetKey("fertid") fertId.RequiredOff() fertId.SetDescription("Input space time raster dataset with fertilizer ids of the RothC model parameter") shootId = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) shootId.SetKey("shootid") shootId.RequiredOff() shootId.SetDescription("Input space time raster dataset with shoot ids of the RothC model parameter") rootId = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) rootId.SetKey("rootid") rootId.RequiredOff() rootId.SetDescription("Input space time raster dataset with root ids of the RothC model parameter") # Raster map input clayContent = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) clayContent.SetKey("claycontent") clayContent.SetDescription("Input raster map with clay content in percent [%]") poolDPM = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) poolDPM.SetKey("dpmpool") poolDPM.SetDescription("Input raster map specifying the DPM pool [tC/ha] at the start " "of the computation (usually from generated by equilibrium run)") poolRPM = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) poolRPM.SetKey("rpmpool") poolRPM.SetDescription("Input raster map specifying the RPM pool [tC/ha] at the start " "of the computation (usually from generated by equilibrium run)") poolHUM = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) poolHUM.SetKey("humpool") poolHUM.SetDescription("Input raster map specifying the HUM pool [tC/ha] at the start " "of the computation (usually from generated by equilibrium run)") poolBIO = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) poolBIO.SetKey("biopool") poolBIO.SetDescription("Input raster map specifying the BIO pool [tC/ha] at the start " "of the computation (usually from generated by equilibrium run)") poolIOM = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) poolIOM.SetKey("iompool") poolIOM.SetDescription("Input raster map specifying the IOM pool [tC/ha] at the start " "of the computation (usually from generated by equilibrium run)") baseName = vtkGRASSOption() baseName.SetKey("base") baseName.SetTypeToString() baseName.MultipleOff() baseName.RequiredOn() baseName.SetDescription("The base name of the new created raster maps") # Soil organic carbon Space time raster datasets soc = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSOutputType()) soc.SetKey("soc") soc.SetDescription("Output space time raster dataset with SOC content [tC/ha]") # INIT paramter = vtkStringArray() for arg in sys.argv: paramter.InsertNextValue(str(arg)) if init.Parser(paramter) == False: return -1 # We need to modify the environment settings so that the # overwrite flag will be recognized os.environ["GRASS_OVERWRITE"] = str(init.Overwrite()) os.environ["GRASS_VERBOSE"] = str(init.Verbosity()) messages = vtkGRASSMessagingInterface() messages.VerboseMessage("Sampling of input datasets") tgis.init() inputNames = "%s,%s,%s,%s,%s,%s"%(precipitation.GetAnswer(), radiation.GetAnswer(), soilCover.GetAnswer(), fertilizer.GetAnswer(), roots.GetAnswer(), shoots.GetAnswer()) if fertId.GetAnswer(): inputNames += ",%s"%(fertId.GetAnswer()) if shootId.GetAnswer() and not fertId.GetAnswer(): print("ERROR: Shoot id and fertilizer id must be set") return -1 if shootId.GetAnswer(): inputNames += ",%s"%(shootId.GetAnswer()) if rootId.GetAnswer() and not shootId.GetAnswer(): print("ERROR: Root id and shoot id must be set") return -1 if rootId.GetAnswer(): inputNames += ",%s"%(rootId.GetAnswer()) mapmatrix = tgis.sample_stds_by_stds_topology("strds", "strds", inputNames, temperature.GetAnswer(), False, "|", "equal,during,contains", False, True) pools = read_pools(poolDPM=poolDPM.GetAnswer(), poolRPM=poolRPM.GetAnswer(), poolHUM=poolHUM.GetAnswer(), poolBIO=poolBIO.GetAnswer(), poolIOM=poolIOM.GetAnswer()) xml = None if xmlParam.GetAnswer(): xml = vtkTAG2ERothCModelParameter() xml.SetFileName(xmlParam.GetAnswer()) xml.Read() xml.GenerateInternalSchemeFromXML() RothCModelRun(mapmatrix, pools, clayContent.GetAnswer(), soc.GetAnswer(), baseName.GetAnswer(), xml, -99999, bool(init.Overwrite())) return 0
def main(): #lazy imports import grass.temporal as tgis # Get the options input = options["input"] output = options["output"] vector_output = options["vector_output"] strds = options["strds"] where = options["where"] columns = options["columns"] if where == "" or where == " " or where == "\n": where = None overwrite = grass.overwrite() # Check the number of sample strds and the number of columns strds_names = strds.split(",") column_names = columns.split(",") if len(strds_names) != len(column_names): grass.fatal(_("The number of columns must be equal to the number of space time raster datasets")) # Make sure the temporal database exists tgis.init() # We need a database interface dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() mapset = grass.gisenv()["MAPSET"] out_sp = tgis.check_new_stds(output, "stvds", dbif, overwrite) samples = [] first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif) # Single space time raster dataset if len(strds_names) == 1: rows = first_strds.get_registered_maps( columns="name,mapset,start_time,end_time", order="start_time", dbif=dbif) if not rows: dbif.close() grass.fatal(_("Space time raster dataset <%s> is empty") % out_sp.get_id()) for row in rows: start = row["start_time"] end = row["end_time"] raster_maps = [row["name"] + "@" + row["mapset"],] s = Sample(start, end, raster_maps) samples.append(s) else: # Multiple space time raster datasets for name in strds_names[1:]: dataset = tgis.open_old_stds(name, "strds", dbif) if dataset.get_temporal_type() != first_strds.get_temporal_type(): grass.fatal(_("Temporal type of space time raster datasets must be equal\n" "<%(a)s> of type %(type_a)s do not match <%(b)s> of type %(type_b)s"% {"a":first_strds.get_id(), "type_a":first_strds.get_temporal_type(), "b":dataset.get_id(), "type_b":dataset.get_temporal_type()})) mapmatrizes = tgis.sample_stds_by_stds_topology("strds", "strds", strds_names, strds_names[0], False, None, "equal", False, False) for i in range(len(mapmatrizes[0])): isvalid = True mapname_list = [] for mapmatrix in mapmatrizes: entry = mapmatrix[i] if entry["samples"]: sample = entry["samples"][0] name = sample.get_id() if name is None: isvalid = False break else: mapname_list.append(name) if isvalid: entry = mapmatrizes[0][i] map = entry["granule"] start, end = map.get_temporal_extent_as_tuple() s = Sample(start, end, mapname_list) samples.append(s) num_samples = len(samples) # Get the layer and database connections of the input vector vector_db = grass.vector.vector_db(input) # We copy the vector table and create the new layers if vector_db: # Use the first layer to copy the categories from layers = "1," else: layers = "" first = True for layer in range(num_samples): layer += 1 # Skip existing layer if vector_db and layer in vector_db and \ vector_db[layer]["layer"] == layer: continue if first: layers += "%i" % (layer) first = False else: layers += ",%i" % (layer) vectmap = vector_output # We create a new vector map using the categories of the original map try: grass.run_command("v.category", input=input, layer=layers, output=vectmap, option="transfer", overwrite=overwrite) except CalledModuleError: grass.fatal(_("Unable to create new layers for vector map <%s>") % (vectmap)) title = _("Observaion of space time raster dataset(s) <%s>") % (strds) description= _("Observation of space time raster dataset(s) <%s>" " with vector map <%s>") % (strds, input) # Create the output space time vector dataset out_sp = tgis.open_new_stds(output, "stvds", first_strds.get_temporal_type(), title, description, first_strds.get_semantic_type(), dbif, overwrite) dummy = out_sp.get_new_map_instance(None) # Sample the space time raster dataset with the vector # map at specific layer with v.what.rast count = 1 for sample in samples: raster_names = sample.raster_names if len(raster_names) != len(column_names): grass.fatal(_("The number of raster maps in a granule must " "be equal to the number of column names")) # Create the columns creation string columns_string = "" for name, column in zip(raster_names, column_names): # The column is by default double precision coltype = "DOUBLE PRECISION" # Get raster map type raster_map = tgis.RasterDataset(name) raster_map.load() if raster_map.metadata.get_datatype() == "CELL": coltype = "INT" tmp_string = "%s %s," %(column, coltype) columns_string += tmp_string # Remove last comma columns_string = columns_string[0:len(columns_string) - 1] # Try to add a column if vector_db and count in vector_db and vector_db[count]["table"]: try: grass.run_command("v.db.addcolumn", map=vectmap, layer=count, column=columns_string, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal(_("Unable to add column %s to vector map <%s> " "with layer %i") % (columns_string, vectmap, count)) else: # Try to add a new table grass.message("Add table to layer %i" % (count)) try: grass.run_command("v.db.addtable", map=vectmap, layer=count, columns=columns_string, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal(_("Unable to add table to vector map " "<%s> with layer %i") % (vectmap, count)) # Call v.what.rast for each raster map for name, column in zip(raster_names, column_names): try: grass.run_command("v.what.rast", map=vectmap, layer=count, raster=name, column=column, where=where) except CalledModuleError: dbif.close() grass.fatal(_("Unable to run v.what.rast for vector map <%s> " "with layer %i and raster map <%s>") % (vectmap, count, str(raster_names))) vect = out_sp.get_new_map_instance(dummy.build_id(vectmap, mapset, str(count))) vect.load() start = sample.start end = sample.end if out_sp.is_time_absolute(): vect.set_absolute_time(start, end) else: vect.set_relative_time( start, end, first_strds.get_relative_time_unit()) if vect.is_in_db(dbif): vect.update_all(dbif) else: vect.insert(dbif) out_sp.register_map(vect, dbif) count += 1 out_sp.update_from_registered_maps(dbif) dbif.close()
def main(): # lazy imports import grass.temporal as tgis from grass.pygrass.utils import copy as gcopy from grass.pygrass.messages import Messenger from grass.pygrass.vector import Vector # Get the options input = options["input"] output = options["output"] strds = options["strds"] where = options["where"] tempwhere = options["t_where"] if output and flags['u']: grass.fatal(_("Cannot combine 'output' option and 'u' flag")) elif not output and not flags['u']: grass.fatal(_("'output' option or 'u' flag must be given")) elif not output and flags['u']: grass.warning( _("Attribute table of vector {name} will be updated...").format( name=input)) if where == "" or where == " " or where == "\n": where = None overwrite = grass.overwrite() quiet = True if grass.verbosity() > 2: quiet = False # Check the number of sample strds and the number of columns strds_names = strds.split(",") # Make sure the temporal database exists tgis.init() # We need a database interface dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() samples = [] first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif) # Single space time raster dataset if len(strds_names) == 1: granu = first_strds.get_granularity() rows = first_strds.get_registered_maps( "name,mapset,start_time,end_time", tempwhere, "start_time", dbif) if not rows: dbif.close() grass.fatal( _("Space time raster dataset <%s> is empty") % first_strds.get_id()) for row in rows: start = row["start_time"] end = row["end_time"] raster_maps = [ row["name"] + "@" + row["mapset"], ] s = Sample(start, end, raster_maps, first_strds.get_name(), granu) samples.append(s) else: # Multiple space time raster datasets for name in strds_names[1:]: dataset = tgis.open_old_stds(name, "strds", dbif) if dataset.get_temporal_type() != first_strds.get_temporal_type(): grass.fatal( _( "Temporal type of space time raster " "datasets must be equal\n<%(a)s> of type " "%(type_a)s do not match <%(b)s> of type " "%(type_b)s" % { "a": first_strds.get_id(), "type_a": first_strds.get_temporal_type(), "b": dataset.get_id(), "type_b": dataset.get_temporal_type() })) mapmatrizes = tgis.sample_stds_by_stds_topology( "strds", "strds", strds_names, strds_names[0], False, None, "equal", False, False) #TODO check granularity for multiple STRDS for i in range(len(mapmatrizes[0])): isvalid = True mapname_list = [] for mapmatrix in mapmatrizes: entry = mapmatrix[i] if entry["samples"]: sample = entry["samples"][0] name = sample.get_id() if name is None: isvalid = False break else: mapname_list.append(name) if isvalid: entry = mapmatrizes[0][i] map = entry["granule"] start, end = map.get_temporal_extent_as_tuple() s = Sample(start, end, mapname_list, name) samples.append(s) # Get the layer and database connections of the input vector if output: gcopy(input, output, 'vector') else: output = input msgr = Messenger() perc_curr = 0 perc_tot = len(samples) pymap = Vector(output) try: pymap.open('r') except: dbif.close() grass.fatal(_("Unable to create vector map <%s>" % output)) if len(pymap.dblinks) == 0: try: pymap.close() grass.run_command("v.db.addtable", map=output) except CalledModuleError: dbif.close() grass.fatal( _("Unable to add table <%s> to vector map <%s>" % output)) if pymap.is_open(): pymap.close() for sample in samples: raster_names = sample.raster_names # Call v.what.rast for each raster map for name in raster_names: coltype = "DOUBLE PRECISION" # Get raster map type raster_map = tgis.RasterDataset(name) raster_map.load() if raster_map.metadata.get_datatype() == "CELL": coltype = "INT" day = sample.printDay() column_name = "%s_%s" % (sample.strds_name, day) column_string = "%s %s" % (column_name, coltype) column_string.replace('.', '_') try: grass.run_command("v.db.addcolumn", map=output, column=column_string, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal( _("Unable to add column %s to vector map " "<%s> ") % (column_string, output)) try: grass.run_command("v.what.rast", map=output, raster=name, column=column_name, where=where, quiet=quiet) except CalledModuleError: dbif.close() grass.fatal( _("Unable to run v.what.rast for vector map" " <%s> and raster map <%s>") % (output, str(raster_names))) msgr.percent(perc_curr, perc_tot, 1) perc_curr += 1 dbif.close()
def main(): # Initiate GRASS init = vtkGRASSInit() init.Init("t.rast.RothCEquilibrium") init.ExitOnErrorOn() module = vtkGRASSModule() module.SetDescription("Compute the RothC soil carbon equilibrium using Brents method") module.AddKeyword("temporal") module.AddKeyword("RothC") temperature = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) temperature.SetKey("temperature") temperature.SetDescription("Input space time raster dataset with long " "term monthly temperature mean [degree C] (at least 12 months)" ". This dataset will be used to temporally sample all other.") precipitation = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) precipitation.SetKey("precipitation") precipitation.SetDescription("Input space time raster dataset with long term " "monthly accumulated precipitation [mm] (at least 12 months)") radiation = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) radiation.SetKey("radiation") radiation.SetDescription("Input space time raster dataset with long term monthly " "global radiation [J/(cm^2 * day)] (at least 12 months)") # Space time raster datasets soilCover = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) soilCover.SetKey("soilcover") soilCover.SetDescription("Input space time raster dataset with long term monthly " "soil cover (at least 12 months)") # Raster map input clayContent = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) clayContent.SetKey("claycontent") clayContent.SetDescription("Input raster map with clay content in percent [%]") soilCarbon = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) soilCarbon.SetKey("soc") soilCarbon.SetDescription("Input raster map with target SOC [tC/ha]") residuals = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterInputType()) residuals.SetKey("residuals") residuals.SetDescription("Input raster map with the initial residuals of the RothC model [tC/ha] " "applied in august of each model year") output = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) output.SetDescription("The model soil organic carbon result raster map at equilibrium") poolDPM = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) poolDPM.SetKey("dpmpool") poolDPM.SetDescription("The model DPM pool result raster map at equilibirum [tC/ha]") poolRPM = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) poolRPM.SetKey("rpmpool") poolRPM.SetDescription("The model RPM pool result raster map at equilibirum [tC/ha]") poolHUM = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) poolHUM.SetKey("humpool") poolHUM.SetDescription("The model HUM pool result raster map at equilibirum [tC/ha]") poolBIO = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) poolBIO.SetKey("biopool") poolBIO.SetDescription("The model BIO pool result raster map at equilibirum [tC/ha]") poolIOM = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) poolIOM.SetKey("iompool") poolIOM.SetDescription("The model IOM pool result raster map at equilibirum [tC/ha]") convergence = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) convergence.SetKey("convergence") convergence.SetDescription("Convergence raster map, 1 convence, 0 no convergence") squaredResiduals = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) squaredResiduals.SetKey("squaredresiduals") squaredResiduals.SetDescription("The squared residuals raster map of the Brent optimization") """ Model input start * Temperature STRDS name * Precipitation STRDS name * Radiation STRDS name * SoilCover STRDS name * Fertilizer STRDS name * Residuals STRDS name """ modelTemperature = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) modelTemperature.SetKey("mtemperature") modelTemperature.RequiredOff() modelTemperature.SetDescription("Input space time raster dataset with monthly temperature mean [degree C]" ". This dataset will be used to temporally sample all other.") modelPrecipitation = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) modelPrecipitation.SetKey("mprecipitation") modelPrecipitation.RequiredOff() modelPrecipitation.SetDescription("Input space time raster dataset with " "accumulated precipitation [mm]") modelRadiation = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) modelRadiation.SetKey("mradiation") modelRadiation.RequiredOff() modelRadiation.SetDescription("Input space time raster dataset with monthly " "global radiation [J/(cm^2 * day)]") modelResiduals = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) modelResiduals.SetKey("mresiduals") modelResiduals.RequiredOff() modelResiduals.SetDescription("Input space time raster dataset with monthly " "residuals tC/ha") modelFertilizer = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) modelFertilizer.SetKey("mfertilizer") modelFertilizer.RequiredOff() modelFertilizer.SetDescription("Input space time raster dataset with monthly " "fertilizer tC/ha") # Space time raster datasets modelSoilCover = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetSTRDSInputType()) modelSoilCover.SetKey("msoilcover") modelSoilCover.RequiredOff() modelSoilCover.SetDescription("Input space time raster dataset with monthly soil cover") """ Model input end """ residualsOut = vtkGRASSOptionFactory().CreateInstance(vtkGRASSOptionFactory.GetRasterOutputType()) residualsOut.SetKey("resout") residualsOut.SetDescription("The computed residuals raster map to reach equilibirum") iterations = vtkGRASSOption() iterations.SetKey("iterations") iterations.MultipleOff() iterations.RequiredOff() iterations.SetDefaultAnswer("20") iterations.SetDescription("The maximum number of iterations to find the equilibrium") iterations.SetTypeToInteger() years = vtkGRASSOption() years.SetKey("years") years.MultipleOff() years.RequiredOff() years.SetDefaultAnswer("300") years.SetDescription("The number of years of the provided temporal cycle") years.SetTypeToInteger() ax = vtkGRASSOption() ax.SetKey("ax") ax.MultipleOff() ax.RequiredOff() ax.SetDefaultAnswer("0") ax.SetDescription("The lower limit of the residual range") ax.SetTypeToDouble() cx = vtkGRASSOption() cx.SetKey("cx") cx.MultipleOff() cx.RequiredOff() cx.SetDefaultAnswer("15") cx.SetDescription("The upper limit of the residual range") cx.SetTypeToDouble() yearly = vtkGRASSFlag() yearly.SetDescription("Compute yearly aggregates for equilibrium run") yearly.SetKey('y') # INIT paramter = vtkStringArray() for arg in sys.argv: paramter.InsertNextValue(str(arg)) if init.Parser(paramter) == False: return -1 # We need to modify the environment settings so that the # overwrite flag will be recognized os.environ["GRASS_OVERWRITE"] = str(init.Overwrite()) os.environ["GRASS_VERBOSE"] = str(init.Verbosity()) tgis.init() messages = vtkGRASSMessagingInterface() messages.VerboseMessage("Reading raster maps into memory") # We define the line length as 30cm lineLengths = vtkDoubleArray() lineLengths.InsertNextValue(0.30) names = vtkStringArray() names.InsertNextValue(clayContent.GetAnswer()) clayReader = vtkGRASSMultiRasterPolyDataLineReader() clayReader.SetRasterNames(names) clayReader.SetDataName("Clay") clayReader.SetLineLengths(lineLengths) clayReader.Update() # We are using the target SOC as initial SOC names = vtkStringArray() names.InsertNextValue(soilCarbon.GetAnswer()) InitialCarbon = vtkGRASSMultiRasterPolyDataLineReader() InitialCarbon.SetRasterNames(names) InitialCarbon.SetDataName("InitialCarbon") InitialCarbon.SetLineLengths(lineLengths) InitialCarbon.Update() names = vtkStringArray() names.InsertNextValue(soilCarbon.GetAnswer()) soilCarbonReader = vtkGRASSMultiRasterPolyDataLineReader() soilCarbonReader.SetRasterNames(names) soilCarbonReader.SetDataName("SoilCarbon") soilCarbonReader.SetLineLengths(lineLengths) soilCarbonReader.Update() names = vtkStringArray() names.InsertNextValue(residuals.GetAnswer()) residualsReader = vtkGRASSMultiRasterPolyDataLineReader() residualsReader.SetRasterNames(names) residualsReader.SetDataName("Residuals") residualsReader.SetLineLengths(lineLengths) residualsReader.Update() inputNames = "%s,%s,%s"%(precipitation.GetAnswer(), radiation.GetAnswer(), soilCover.GetAnswer()) mapmatrix = tgis.sample_stds_by_stds_topology("strds", "strds", inputNames, temperature.GetAnswer(), False, "|", "equal", False, True) dataInputs = [] if len(mapmatrix) > 0: if len(mapmatrix[0]) < 12: messages.FatalError("You must provide at least 12 months of data") for j in range(12): dsList = [] for i in range(len(mapmatrix)): entry = mapmatrix[i][j] samples = entry["samples"] granule = entry["granule"] if len(samples) > 1: messages.Warning("More than one maps found in sample. " "Using the first one only.") for sample in samples: print sample.get_id() sample = samples[0] if sample.get_id() == None: messages.FatalError("Gaps are not allowed") if i == 0: id = sample.get_id() names = vtkStringArray() names.InsertNextValue(id) reader = vtkGRASSMultiRasterPolyDataLineReader() reader.SetRasterNames(names) reader.SetDataName("Precipitation") reader.SetLineLengths(lineLengths) reader.Update() dsList.append(reader.GetOutput()) if i == 1: id = sample.get_id() names = vtkStringArray() names.InsertNextValue(id) reader = vtkGRASSMultiRasterPolyDataLineReader() reader.SetRasterNames(names) reader.SetDataName("GlobalRadiation") reader.SetLineLengths(lineLengths) reader.Update() dsList.append(reader.GetOutput()) if i == 2: id = sample.get_id() names = vtkStringArray() names.InsertNextValue(id) reader = vtkGRASSMultiRasterPolyDataLineReader() reader.SetRasterNames(names) reader.SetDataName("SoilCover") reader.SetLineLengths(lineLengths) reader.Update() dsList.append(reader.GetOutput()) entry = mapmatrix[0][j] map = entry["granule"] id = map.get_id() names = vtkStringArray() names.InsertNextValue(id) reader = vtkGRASSMultiRasterPolyDataLineReader() reader.SetRasterNames(names) reader.SetDataName("MeanTemperature") reader.SetLineLengths(lineLengths) reader.Update() dsList.append(reader.GetOutput()) join = vtkTAG2EDataSetJoinFilter() join.AddInput(clayReader.GetOutput()) join.AddInput(InitialCarbon.GetOutput()) for ds in dsList: join.AddInput(ds) join.Update() dataInputs.append(join.GetOutput()) # Create the module input dictionary """ Model input start * Temperature STRDS name * Precipitation STRDS name * Radiation STRDS name * SoilCover STRDS name * Fertilizer STRDS name * Residuals STRDS name """ ModelRunNames = None if modelTemperature.GetAnswer() and \ modelPrecipitation.GetAnswer() and \ modelRadiation.GetAnswer() and \ modelResiduals.GetAnswer() and \ modelFertilizer.GetAnswer() and \ modelSoilCover.GetAnswer(): ModelRunNames = {} ModelRunNames["Temperature"] = modelTemperature.GetAnswer() ModelRunNames["Precipitation"] = modelPrecipitation.GetAnswer() ModelRunNames["Radiation"] = modelRadiation.GetAnswer() ModelRunNames["SoilCover"] = modelSoilCover.GetAnswer() ModelRunNames["Fertilizer"] = modelFertilizer.GetAnswer() ModelRunNames["Residuals"] = modelResiduals.GetAnswer() ModelRunNames["ClayContent"] = clayContent.GetAnswer() runType = "monthly" if yearly.GetAnswer(): runType = "yearly" new_ds, res_ds = RothCEquilibriumRun(Inputs=dataInputs, ResidualsInput=residualsReader.GetOutput(), SoilCarbonInput=soilCarbonReader.GetOutput(), Years=int(years.GetAnswer()), NumberOfRuns=int(iterations.GetAnswer()), ax=float(ax.GetAnswer()), cx=float(cx.GetAnswer()), ModelRunNames=ModelRunNames, runType=runType) # The layer array needs to be added new_ds.GetCellData().AddArray(soilCarbonReader.GetOutput().GetCellData().GetArray("Layer")) # Write the resulting pools writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(output.GetAnswer()) writer.SetArrayName("SoilCarbon") writer.SetLayer(1) writer.SetInput(new_ds) writer.Update() writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(poolDPM.GetAnswer()) writer.SetArrayName("DPM") writer.SetLayer(1) writer.SetInput(new_ds) writer.Update() writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(poolRPM.GetAnswer()) writer.SetArrayName("RPM") writer.SetLayer(1) writer.SetInput(new_ds) writer.Update() writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(poolHUM.GetAnswer()) writer.SetArrayName("HUM") writer.SetLayer(1) writer.SetInput(new_ds) writer.Update() writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(poolBIO.GetAnswer()) writer.SetArrayName("BIO") writer.SetLayer(1) writer.SetInput(new_ds) writer.Update() writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(poolIOM.GetAnswer()) writer.SetArrayName("IOM") writer.SetLayer(1) writer.SetInput(new_ds) writer.Update() writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(residualsOut.GetAnswer()) writer.SetArrayName("Residuals") writer.SetLayer(1) writer.SetInput(res_ds) writer.Update() writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(convergence.GetAnswer()) writer.SetArrayName("Convergence") writer.SetLayer(1) writer.SetInput(new_ds) writer.Update() writer = vtkGRASSMultiRasterPolyDataLineWriter() writer.SetRasterMapName(squaredResiduals.GetAnswer()) writer.SetArrayName("SquaredResiduals") writer.SetLayer(1) writer.SetInput(new_ds) writer.Update()
def main(): # Get the options input = options["input"] output = options["output"] vector_output = options["vector_output"] strds = options["strds"] where = options["where"] columns = options["columns"] if where == "" or where == " " or where == "\n": where = None overwrite = grass.overwrite() # Check the number of sample strds and the number of columns strds_names = strds.split(",") column_names = columns.split(",") if len(strds_names) != len(column_names): grass.fatal(_("The number of columns must be equal to the number of space time raster datasets")) # Make sure the temporal database exists tgis.init() # We need a database interface dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() mapset = grass.gisenv()["MAPSET"] out_sp = tgis.check_new_stds(output, "stvds", dbif, overwrite) samples = [] first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif) # Single space time raster dataset if len(strds_names) == 1: rows = first_strds.get_registered_maps( columns="name,mapset,start_time,end_time", order="start_time", dbif=dbif) if not rows: dbif.close() grass.fatal(_("Space time raster dataset <%s> is empty") % out_sp.get_id()) for row in rows: start = row["start_time"] end = row["end_time"] raster_maps = [row["name"] + "@" + row["mapset"],] s = Sample(start, end, raster_maps) samples.append(s) else: # Multiple space time raster datasets for name in strds_names[1:]: dataset = tgis.open_old_stds(name, "strds", dbif) if dataset.get_temporal_type() != first_strds.get_temporal_type(): grass.fatal(_("Temporal type of space time raster datasets must be equal\n" "<%(a)s> of type %(type_a)s do not match <%(b)s> of type %(type_b)s"%\ {"a":first_strds.get_id(), "type_a":first_strds.get_temporal_type(), "b":dataset.get_id(), "type_b":dataset.get_temporal_type()})) mapmatrizes = tgis.sample_stds_by_stds_topology("strds", "strds", strds_names, strds_names[0], False, None, "equal", False, False) for i in range(len(mapmatrizes[0])): isvalid = True mapname_list = [] for mapmatrix in mapmatrizes: entry = mapmatrix[i] if entry["samples"]: sample = entry["samples"][0] name = sample.get_id() if name is None: isvalid = False break else: mapname_list.append(name) if isvalid: entry = mapmatrizes[0][i] map = entry["granule"] start, end = map.get_temporal_extent_as_tuple() s = Sample(start, end, mapname_list) samples.append(s) num_samples = len(samples) # Get the layer and database connections of the input vector vector_db = grass.vector.vector_db(input) # We copy the vector table and create the new layers if vector_db: # Use the first layer to copy the categories from layers = "1," else: layers = "" first = True for layer in range(num_samples): layer += 1 # Skip existing layer if vector_db and layer in vector_db and \ vector_db[layer]["layer"] == layer: continue if first: layers += "%i" % (layer) first = False else: layers += ",%i" % (layer) vectmap = vector_output # We create a new vector map using the categories of the original map try: grass.run_command("v.category", input=input, layer=layers, output=vectmap, option="transfer", overwrite=overwrite) except CalledModuleError: grass.fatal(_("Unable to create new layers for vector map <%s>") % (vectmap)) title = _("Observaion of space time raster dataset(s) <%s>") % (strds) description= _("Observation of space time raster dataset(s) <%s>" " with vector map <%s>") % (strds, input) # Create the output space time vector dataset out_sp = tgis.open_new_stds(output, "stvds", first_strds.get_temporal_type(), title, description, first_strds.get_semantic_type(), dbif, overwrite) dummy = out_sp.get_new_map_instance(None) # Sample the space time raster dataset with the vector # map at specific layer with v.what.rast count = 1 for sample in samples: raster_names = sample.raster_names if len(raster_names) != len(column_names): grass.fatal(_("The number of raster maps in a granule must " "be equal to the number of column names")) # Create the columns creation string columns_string = "" for name, column in zip(raster_names, column_names): # The column is by default double precision coltype = "DOUBLE PRECISION" # Get raster map type raster_map = tgis.RasterDataset(name) raster_map.load() if raster_map.metadata.get_datatype() == "CELL": coltype = "INT" tmp_string = "%s %s,"%(column, coltype) columns_string += tmp_string # Remove last comma columns_string = columns_string[0:len(columns_string) - 1] # Try to add a column if vector_db and count in vector_db and vector_db[count]["table"]: try: grass.run_command("v.db.addcolumn", map=vectmap, layer=count, column=columns_string, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal(_("Unable to add column %s to vector map <%s> " "with layer %i") % (columns_string, vectmap, count)) else: # Try to add a new table grass.message("Add table to layer %i" % (count)) try: grass.run_command("v.db.addtable", map=vectmap, layer=count, columns=columns_string, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal(_("Unable to add table to vector map " "<%s> with layer %i") % (vectmap, count)) # Call v.what.rast for each raster map for name, column in zip(raster_names, column_names): try: grass.run_command("v.what.rast", map=vectmap, layer=count, raster=name, column=column, where=where) except CalledModuleError: dbif.close() grass.fatal(_("Unable to run v.what.rast for vector map <%s> " "with layer %i and raster map <%s>") % \ (vectmap, count, str(raster_names))) vect = out_sp.get_new_map_instance(dummy.build_id(vectmap, mapset, str(count))) vect.load() start = sample.start end = sample.end if out_sp.is_time_absolute(): vect.set_absolute_time(start, end) else: vect.set_relative_time( start, end, first_strds.get_relative_time_unit()) if vect.is_in_db(dbif): vect.update_all(dbif) else: vect.insert(dbif) out_sp.register_map(vect, dbif) count += 1 out_sp.update_from_registered_maps(dbif) dbif.close()