def main():
# setting up parser
parser = OptionParser(usage=usage, version=version)
parser.add_option("-o", "--outputFile", action="store", dest="outputFile", default=None, help="Path to output file")
parser.add_option("-i", "--inputDir", action="store", dest="inputDir", help="Path to directory with input files")
parser.add_option(
"-f", "--flip", action="store_true", dest="flip", help="Flip rasters to correct north-south orientation"
)
parser.add_option("-s", "--substances", dest="substances", action="store", help="List of substances")
(options, args) = parser.parse_args()
wd = path.abspath(options.inputDir)
utDir = path.dirname(path.abspath(options.outputFile))
utRastName = path.basename(path.abspath(options.outputFile))
substances = options.substances.split()
# -----------------------------------------------------
for substance in substances:
pathStr = os.path.join(wd, "*" + substance + "*")
fileList = glob.glob(pathStr)
utRast = substance + "_" + utRastName
utRastPath = os.path.join(utDir, utRast)
num = 0
for filePath in fileList:
num += 1
print "reading ", os.path.basename(filePath)
rast = raster.raster()
rast.read(filePath, format="airviro", index=2)
print "Sum of raster is: ", rast.sum()
# airviro rasters are upside-down, this parameter marks that the raster will be turned
if options.flip:
rast.flip()
if num == 1:
totRast = rast
else:
totRast = totRast + rast
print "Sum for total rast: ", totRast.sum()
totRast.write(utRastPath)
print
print "finished merging regions for substance: ", substance
print
def main():
#-----------Setting up and unsing option parser-----------------------
parser=OptionParser(usage= usage, version=version)
parser.add_option("-d","--directory",
action="store",dest="rootDir",
help="Root directory to start search for rasters")
parser.add_option("-f","--rasterFilter",
action="store",dest="rasterFilter",
help="Raster filter", default="*.asc")
parser.add_option("-o","--outputPath",
action="store",dest="outputPath",
help="Output table path")
parser.add_option("-m","--maskFilter",
action="store",dest="maskFilter",
help="Mask raster filter")
parser.add_option("--infoFilter",
action="store",dest="infoFilter",
help="Regular expression to extract metadata, named groups are needed for 'sector', 'substance', 'units', 'year' and 'version', default is: %default",
default=".*/(?P<sector>[a-z]*)(?P<substance>.*?)(?P<units>gpers)(?P<year>[0-9]*)(?P<version>.*?).asc")
(options, args) = parser.parse_args()
if len(args)>0:
parser.error("Wrong number of arguments")
if options.rootDir is None:
parser.error("Needs to specify root directory")
if options.maskFilter is None:
parser.error("Needs to specify mask filter")
rootDir=path.abspath(options.rootDir)
rasterFilter=options.rasterFilter
maskFilter=options.maskFilter
outputTablePath=path.abspath(options.outputPath)
# infoPattern=re.compile("?P<(.*?)>")
# infoLabels =infoPattern.findall()
# try:
# infoLabels.remove("units")
# except ValueError:
# units=None
# desc=[]
# keys=[]
# for l in infoLabels:
# desc.append({"id":l,"type":str})
# keys.append(l)
outputTable= dataTable.DataTable(desc=[{"id":"Zone_id","type":int},
{"id":"Sector","type":str},
{"id":"Year","type":int},
{"id":"Version","type":str}],
keys=["Zone_id","Sector","Year","Version"])
infoPattern=re.compile(options.infoFilter)
maskList=glob.glob(path.abspath(options.maskFilter))
masks=[]
for maski,maskPath in enumerate(maskList):
sys.stdout.write("Reading mask raster %i out of %i..." %(maski,len(maskList)))
mp = path.abspath(maskPath)
mask=raster.raster()
try:
mask.read(mp)
except:
parser.error("Could not read mask raster %s" %mp)
sys.exit(1)
masks.append(mask)
sys.stdout.write("finished\n")
for root, dirs, files in os.walk(rootDir):
print "Scanning directory: %s" %root
rasterPaths=glob.glob(path.join(root,rasterFilter))
for rp in rasterPaths:
match=infoPattern.match(rp)
try:
substance=match.group('substance')
except AttributeError:
substance=path.basename(rp)
try:
sector=match.group('sector')
except AttributeError:
sector="unknown"
if sector=="":
sector="unknown"
try:
units=match.group('units')
except:
units="unknown"
if units=="":
units="unknown"
try:
year=int(match.group('year'))
except:
year=-9999
if year =="":
year=-9999
try:
ver=match.group('version')
except:
ver="default"
if ver=="":
ver=="default"
rast=raster.raster()
rast.read(rp)
for mask in masks:
statistics=zonalStatistics(rast,mask)
if substance not in outputTable.listIds():
outputTable.addCol({"id":substance,"type":float,"unit":units})
for data in statistics:
zone_id=data["zone_id"]
zone_sum=data["sum"]
row=outputTable.ncols()*[None]
row[outputTable.colIndex("Zone_id")]=zone_id
row[outputTable.colIndex("Year")]=year
row[outputTable.colIndex("Sector")]=sector
row[outputTable.colIndex("Version")]=ver
row[outputTable.colIndex(substance)]=zone_sum
outputTable.addRow(row,append=True)
output=open(outputTablePath,"w")
outputTable.write(output)
def main():
# -----------Setting up and unsing option parser-----------------------
parser = OptionParser(usage=usage, version=version)
logger = logging.getLogger("exportEmisGrids.py")
parser.add_option(
"-l",
"--loglevel",
action="store",
dest="loglevel",
default=2,
help="Sets the loglevel (0-3 where 3=full logging)",
)
parser.add_option(
"-d", "--distKey", action="store", dest="distKey", default=None, help="Distribution grid to be weighted"
)
parser.add_option("-r", "--regRast", action="store", dest="regRast", help="Region definition raster")
parser.add_option("-s", "--regStat", action="store", dest="regStat", help="Regional statistics")
parser.add_option(
"-e",
"--emis",
action="store_true",
dest="emis",
default=False,
help="Generate emission grid from key and regional emissions",
)
parser.add_option(
"-c", "--colName", action="store", dest="colName", default=None, help="Title of column in regional statistics"
)
parser.add_option("-o", "--outRaster", action="store", dest="resRast", default=None, help="Result raster filename")
(options, args) = parser.parse_args()
# ------------Setting up logging capabilities -----------
rootLogger = logger2.RootLogger(int(options.loglevel))
logger = rootLogger.getLogger(sys.argv[0])
# -------------------------------------------------------
regRastPath = path.abspath(options.regRast)
keyRastPath = path.abspath(options.distKey)
regStatPath = path.abspath(options.regStat)
resRastPath = path.abspath(options.resRast)
key = raster.raster()
regdef = raster.raster()
logger.debug("Reading region raster")
try:
regdef.read(regRastPath)
except:
logger.error("Could not read regionRaster")
sys.exit(1)
if options.distKey is not None:
logger.debug("Reading key raster")
try:
key.read(keyRastPath)
except:
logger.error("keyRaster does not exist")
sys.exit(1)
else:
keydef.assign(regdef)
keydef.data = numpy.ones(keyRast.data.shape)
logger.debug("No distribution grid specified, using uniform distribution")
key.nodataToZero()
regstat = dataTable.DataTable()
try:
logger.debug("Reading regional statistics")
regstat.read(regStatPath, units=True)
except:
logger.error("Could not read regional totals")
sys.exit(1)
logger.debug("Finished reading data!")
if regdef.xll != key.xll or regdef.yll != key.yll:
logger.error("The raster domain size is differs between key raster and region raster")
sys.exit(1)
# Makes sure that the input rasters have the same cellsize, if not - fix it
if key.cellsize < regdef.cellsize:
regdef = regdef.resample(key.cellsize, keepTotal=False)
else:
if regdef.cellsize < key.cellsize:
key = key.resample(regdef.cellsize, keepTotal=True)
# create a list of IDs from the regional totals (exclude the National total)
try:
gcInd = regstat.colIndex("Geocode")
except ValueError:
logger.error("No column with the title Geocode in regional statistics")
sys.exit(1)
try:
colInd = regstat.colIndex(options.colName)
except ValueError:
logger.error("No column with the title %s in regional statistics" % options.colName)
sys.exit(1)
# create a list of IDs in region raster, remove nodata-marker from the list
defIds = regdef.unique()
if regdef.nodata in defIds:
defIds.remove(regdef.nodata)
codesMissingInRegdef = False
codesMissingInRegstat = False
totFractionList = []
# Calculate the sum of emissions in all regions, for comparison with national total...
regsum = 0
for row in regstat.data:
regTot = float(row[colInd])
if regTot != None:
regsum += regTot
logger.debug("Sum of all gc column %s: %f" % (options.colName, regsum))
statIds = []
defErrMsg = "Geocodes missing in regdef: "
statErrMsg = "Geocodes missing in regstat: "
for row in regstat.data:
gc = int(row[gcInd])
statIds.append(gc)
if gc not in defIds:
codesMissingInRegdef = True
defErrMsg += ", " + str(gc)
emis = row[colInd]
if emis is None:
emis = 0
else:
emis = float(emis)
if regsum == 0:
logger.error("No regional statistics for substance: " + subst)
sys.exit(1)
emisFrac = emis / regsum
logger.debug("Weighting gc: %i, value: %f, weight: %f" % (gc, emis, emisFrac))
totFractionList.append((gc, emisFrac))
for gc in defIds:
if gc not in statIds:
statErrMsg += ", " + str(gc)
codesMissingInRegstat = True
if codesMissingInRegstat or codesMissingInRegdef:
if codesMissingInRegstat:
logger.error(statErrMsg)
if codesMissingInRegdef:
logger.error(defErrMsg)
sys.exit(1)
# create a new raster with the region ID:s replaced by the regions fraction
# of the national total emission
totFractionRast = regdef.replace(totFractionList)
totFractionRast.nodataToZero()
# For all regions, calculate the regional sum, set the key values to key/regSum
resKeyArray = numpy.zeros(key.data.shape)
for gc in defIds:
# regionalizing key
mask = numpy.array(regdef.data == gc)
regKey = mask * key.data
regSum = numpy.sum(numpy.sum(regKey))
if regSum > 0:
resKeyArray = resKeyArray + regKey / regSum
else:
logger.warning("Distribution key is zero for geocode %i in regdef, using uniform distribution" % gc)
resKeyArray = resKeyArray + mask / numpy.sum(numpy.sum(mask))
key.data = resKeyArray
key = totFractionRast * key
key = key / key.sum()
logger.info("Regionalized key")
if options.emis:
totEmis = regstat.sumCol(options.colName)
emisRast = key * totEmis
emisRast.write(resRastPath)
logger.info("Wrote weighted and distributed emission grid")
else:
logger.info("Wrote weighted distribution grid")
key.write(resRastPath)
