def _process(argv):
recdim = None
mv = -9999.
try:
opts, args = getopt.getopt(argv,"f:hm:r:v:",["filename=","help","missingvalue=","record=","variable="])
except getopt.GetoptError:
_usage()
sys.exit(2)
for opt,arg in opts:
if opt in ("-h","--help"):
usage()
sys.exit(2)
elif opt in ("-f","--filename"):
filename = arg
elif opt in ("-m","--missingvalue"):
mv = arg
elif opt in ("-v","--variable"):
variable = arg
elif opt in ("-r,--record"):
recdim = arg
ncobj = nctools.ncLoadFile(filename)
lat = nctools.ncGetDims(ncobj, 'lat')
lon = nctools.ncGetDims(ncobj, 'lon')
delta = lon[1] - lon[0]
# Fix incorrectly reported corner of lower left pixel
lon = lon - delta/2
lat = lat - delta/2
if recdim:
recval = nctools.ncGetDims(ncobj,recdim)
#data = nctools.ncGetData(ncobj, variable, missingValue=mv)
data = nctools.ncGetData(ncobj, variable)
ncobj.close()
if recdim:
for i,v in enumerate(recval):
outputfile = "%s.%s.%s"%(os.path.splitext(filename)[0],repr(recval[i]),'txt')
print "Saving data to %s"%outputfile
grid.grdSave(outputfile, numpy.flipud(data[i]), lon, lat, delta, delimiter=' ', nodata=mv, fmt='%6.2f')
else:
outputfile="%s.%s"%(os.path.splitext(filename)[0],'txt')
print "Saving data to %s"%outputfile
grid.grdSave(outputfile, numpy.flipud(data), lon, lat, delta, delimiter=' ', nodata=mv, fmt='%6.2f')
def ltmPressure(jdays, time, lon, lat, ncfile):
"""
Extract pressure value from a daily long-term mean SLP dataset at the
given day of year and lon,lat position
To use this function (and hence some form of daily LTM SLP data) requires
knowledge of the day of year.
:param jdays: Julian day (day of year) values.
:param time: Time of day for each observation (fraction of a day).
:param lon: Longitude of TC position.
:param lat: Latitude of TC position.
:param str ncfile: Path to netCDF file containing daily long-term mean
sea level pressure data.
:type jdays: :class:`numpy.ndarray`
:type time: :class:`numpy.ndarray`
:type lon: :class:`numpy.ndarray`
:type lat: :class:`numpy.ndarray`
:returns: :class:`numpy.ndarray` of long-term mean sea level pressure
values at the day of year and positions given.
"""
jtime = jdays + np.modf(time)[0]
coords = np.array([jtime, lat, lon])
LOG.debug("Sampling data from MSLP data in {0}".format(ncfile))
ncobj = nctools.ncLoadFile(ncfile)
slpunits = getattr(ncobj.variables['slp'], 'units')
data = nctools.ncGetData(ncobj, 'slp')
# Get the MSLP by interpolating to the location of the TC:
penv = interp3d.interp3d(data,
coords,
scale=[365., 180., 360.],
offset=[0., -90., 0.])
penv = metutils.convert(penv, slpunits, 'hPa')
del data
ncobj.close()
del ncobj
return penv
def ltmPressure(jdays, time, lon, lat, ncfile):
"""
Extract pressure value from a daily long-term mean SLP dataset at the
given day of year and lon,lat position
To use this function (and hence some form of daily LTM SLP data) requires
knowledge of the day of year.
:param jdays: Julian day (day of year) values.
:param time: Time of day for each observation (fraction of a day).
:param lon: Longitude of TC position.
:param lat: Latitude of TC position.
:param str ncfile: Path to netCDF file containing daily long-term mean
sea level pressure data.
:type jdays: :class:`numpy.ndarray`
:type time: :class:`numpy.ndarray`
:type lon: :class:`numpy.ndarray`
:type lat: :class:`numpy.ndarray`
:returns: :class:`numpy.ndarray` of long-term mean sea level pressure
values at the day of year and positions given.
"""
jtime = jdays + np.modf(time)[0]
coords = np.array([jtime, lat, lon])
logger.debug("Sampling data from MSLP data in {0}".format(ncfile))
ncobj = nctools.ncLoadFile(ncfile)
slpunits = getattr(ncobj.variables['slp'], 'units')
data = nctools.ncGetData(ncobj, 'slp')
# Get the MSLP by interpolating to the location of the TC:
penv = interp3d.interp3d(data, coords, scale=[365., 180., 360.],
offset=[0., -90., 0.])
penv = metutils.convert(penv, slpunits, 'hPa')
del data
ncobj.close()
del ncobj
return penv
def ltmPressure(jdays, time, lon, lat, ncfile):
"""
Extract pressure value from a daily long-term mean SLP dataset at the
given day of year and lon,lat position
To use this function (and hence some form of daily LTM SLP data) requires
knowledge of the day of year.
"""
jtime = jdays + np.modf(time)[0]
coords = np.array([jtime, lat, lon])
logger.debug("Sampling data from MSLP data in {0}".format(ncfile))
ncobj = nctools.ncLoadFile(ncfile)
slpunits = getattr(ncobj.variables['slp'], 'units')
data = nctools.ncGetData(ncobj, 'slp')
# Get the MSLP by interpolating to the location of the TC:
penv = interp3d.interp3d(data, coords)
penv = metutils.convert(penv, slpunits, 'hPa')
del data
ncobj.close()
del ncobj
return penv
def grdRead(filename, delimiter=None):
"""
Read formatted data from an ascii grid format file.
Returns the longitude and latitude of the grid and the data values
:param str filename: Path to an ascii grid format or netcdf file.
:param delimiter: Delimiter for the ascii format file (optional).
:returns: longitude, latitude, data
:rtype: :class:`numpy.ndarray`
Usage:
longitude, latitude, data = grdRead(filename, [delimiter])
"""
fileext = filename.rsplit('.')[-1]
# If file extention is '.nc' then load as netcdf file
# Otherwise load with grdRead
if fileext == 'nc':
nc_obj = nctools.ncLoadFile(filename)
lon = numpy.array(nctools.ncGetDims(nc_obj, 'lon'),dtype=float)
lat = numpy.array(nctools.ncGetDims(nc_obj, 'lat'),dtype=float)
#lat = numpy.flipud(lat)
data_varname = set.difference(set(nc_obj.variables.keys()),
set(nc_obj.dimensions.keys()))
if len(data_varname) != 1:
raise IOError, 'Cannot resolve data variable in netcdf file: ' + filename
data = numpy.array(nctools.ncGetData(nc_obj, data_varname.pop()),dtype=float)
nc_obj.close()
else:
try:
fh = open(filename, 'r')
except:
#g_logger.flLog("Cannot open %s"%filename)
raise IOError, "Cannot open %s"%filename
return
metadata = {}
metadata["ncols"] = []
metadata["nrows"] = []
metadata["xllcorner"] = []
metadata["yllcorner"] = []
metadata["cellsize"] = []
metadata["NODATA_value"] = []
for i in xrange(0,6):
line = fh.readline()
contents = line.split()
label = contents[0]
metadata[label] = float(contents[1])
lon0 = metadata["xllcorner"]
lon = numpy.array(range(int(metadata["ncols"])), dtype=float)
lon = lon*metadata["cellsize"]+lon0
lat0 = metadata["yllcorner"]
lat = numpy.array(range(int(metadata["nrows"])), dtype=float)
lat = lat*metadata["cellsize"]+lat0
lat = numpy.flipud(lat)
data = numpy.zeros([metadata["nrows"], metadata["ncols"]], dtype=float)
for i in xrange(int(metadata["nrows"])):
row = numpy.zeros([metadata["ncols"]], dtype=float)
line = fh.readline()
for j, val in enumerate(line.split(delimiter)):
value = float(val)
if value == metadata["NODATA_value"]:
value = Nan
row[j] = value
data[i,:] = row
fh.close()
log.debug('filename %s mem:: lon %i lat %i data %i' % (filename, lon.nbytes, lat.nbytes, data.nbytes))
return lon, lat, data
def grdRead(filename, delimiter=None):
"""
Read formatted data from an ascii grid format file.
Returns the longitude and latitude of the grid and the data values
:param str filename: Path to an ascii grid format or netcdf file.
:param delimiter: Delimiter for the ascii format file (optional).
:returns: longitude, latitude, data
:rtype: :class:`numpy.ndarray`
Usage:
longitude, latitude, data = grdRead(filename, [delimiter])
"""
fileext = filename.rsplit('.')[-1]
# If file extention is '.nc' then load as netcdf file
# Otherwise load with grdRead
if fileext == 'nc':
nc_obj = nctools.ncLoadFile(filename)
lon = numpy.array(nctools.ncGetDims(nc_obj, 'lon'), dtype=float)
lat = numpy.array(nctools.ncGetDims(nc_obj, 'lat'), dtype=float)
data_varname = set.difference(set(nc_obj.variables.keys()),
set(nc_obj.dimensions.keys()))
if len(data_varname) != 1:
raise IOError('Cannot resolve data variable in netcdf file: ' +
filename)
data = numpy.array(nctools.ncGetData(nc_obj, data_varname.pop()),
dtype=float)
nc_obj.close()
else:
try:
fh = open(filename, 'r')
except:
raise IOError("Cannot open %s" % filename)
return
metadata = {}
metadata["ncols"] = []
metadata["nrows"] = []
metadata["xllcorner"] = []
metadata["yllcorner"] = []
metadata["cellsize"] = []
metadata["NODATA_value"] = []
for i in xrange(0, 6):
line = fh.readline()
contents = line.split()
label = contents[0]
metadata[label] = float(contents[1])
lon0 = metadata["xllcorner"]
lon = numpy.array(range(int(metadata["ncols"])), dtype=float)
lon = lon * metadata["cellsize"] + lon0
lat0 = metadata["yllcorner"]
lat = numpy.array(range(int(metadata["nrows"])), dtype=float)
lat = lat * metadata["cellsize"] + lat0
lat = numpy.flipud(lat)
data = numpy.zeros([int(metadata["nrows"]),
int(metadata["ncols"])],
dtype=float)
for i in xrange(int(metadata["nrows"])):
row = numpy.zeros([int(metadata["ncols"])], dtype=float)
line = fh.readline()
for j, val in enumerate(line.split(delimiter)):
value = float(val)
if value == metadata["NODATA_value"]:
value = numpy.nan
row[j] = value
data[i, :] = row
fh.close()
log.debug('filename %s mem:: lon %i lat %i data %i' %
(filename, lon.nbytes, lat.nbytes, data.nbytes))
return lon, lat, data
def _process(argv):
"""
A wrapper function to provide an interface between the command line
args and the actual plotField function. This function reads settings
from a configuration file and then passes those arguments to the
plotField function.
"""
if len(argv)==0:
_usage()
sys.exit(2)
logLevel = 'INFO'
verbose = False
configFile = flConfigFile()
try:
opts, args = getopt.getopt(argv, "c:hl:v", ["config=", "help",
"loglevel=", "verbose"])
except getopt.GetoptError:
_usage()
sys.exit(2)
for opt,arg in opts:
if opt in ("-h", "--help"):
_usage()
sys.exit(2)
elif opt in ("-c", "--config"):
configFile = arg
elif opt in ("-l", "--loglevel"):
logLevel = arg
elif opt in ("-v", "--verbose"):
verbose = True
flStartLog(cnfGetIniValue(configFile, 'Logging', 'LogFile', flConfigFile('.log')),
cnfGetIniValue(configFile, 'Logging', 'LogLevel', logLevel),
cnfGetIniValue(configFile, 'Logging', 'Verbose', verbose))
# Input data:
inputFile = cnfGetIniValue(configFile, 'Input', 'File')
inputFormat = cnfGetIniValue(configFile, 'Input', 'Format', os.path.splitext(inputFile)[-1])
varname = cnfGetIniValue(configFile,'Input','Variable','')
record = cnfGetIniValue(configFile,'Input','Record',0)
lvl = cnfGetIniValue(configFile,'Input','Level',0)
# Output settings - the default is to use the input filename, with
# the extension replaced by the image format:
# The smoothing is optional. Set it to the number of grid points to
# smooth over (recommend the reciprocal of the data resolution in degrees).
imgfmt = cnfGetIniValue(configFile, 'Output', 'Format','png')
outputFile = cnfGetIniValue(configFile, 'Output', 'File',
"%s.%s" % (os.path.splitext(inputFile)[0], imgfmt))
smoothing = cnfGetIniValue(configFile, 'Output', 'Smoothing', False)
cmapName = cnfGetIniValue(configFile, 'Output', 'ColourMap', 'gist_ncar')
label = cnfGetIniValue(configFile, 'Output', 'Label', '')
mask = cnfGetIniValue(configFile, 'Output', 'MaskLand', False)
maskocean = cnfGetIniValue(configFile, 'Output', 'MaskOcean', False)
fill = cnfGetIniValue(configFile, 'Output', 'FillContours', True)
title = cnfGetIniValue(configFile,'Plot','Title',None)
# Load data:
if inputFormat == '.txt':
# Attempt to load the dataset:
try:
lon,lat,data = grid.grdRead(inputFile)
except:
logger.critical("Cannot load input file: %s"%inputFile)
raise
elif inputFormat == '.nc':
try:
ncobj = nctools.ncLoadFile(inputFile)
lon = nctools.ncGetDims(ncobj,'lon')
lat = nctools.ncGetDims(ncobj,'lat')
data = nctools.ncGetData(ncobj,varname)
mv = getattr(ncobj.variables[varname],'_FillValue')
ncobj.close()
except:
logger.critical("Cannot load input file: %s"%inputFile)
raise
if len(shape(data))==3:
data = data[record,:,:]
elif len(shape(data))==4:
data = data[record,lvl,:,:]
# Create a masked array:
datamask = (data==mv)
data = ma.array(data,mask=datamask)
else:
logger.critical("Unknown data format")
raise IOError
# Set defaults for the extent of the map to match the data in the
# input file:
llLon = min(lon)
urLon = max(lon)
llLat = min(lat)
urLat = max(lat)
res = 'l'
dl = 10.
# Domain settings - can override the default settings:
domain = cnfGetIniValue(configFile, 'Domain', 'Name', None)
if domain is not None:
llLon = cnfGetIniValue(configFile, domain, 'LowerLeftLon', min(lon))
llLat = cnfGetIniValue(configFile, domain, 'LowerLeftLat', min(lat))
urLon = cnfGetIniValue(configFile, domain, 'UpperRightLon', max(lon))
urLat = cnfGetIniValue(configFile, domain, 'UpperRightLat', max(lat))
res = cnfGetIniValue(configFile, domain, 'Resolution', res)
dl = cnfGetIniValue(configFile, domain, 'GridInterval', dl)
[x,y] = meshgrid(lon, lat)
# Set the scale:
scaleMin = cnfGetIniValue(configFile, 'Output', 'ScaleMin', 0)
scaleMax = cnfGetIniValue(configFile, 'Output', 'ScaleMax', 101)
scaleInt = cnfGetIniValue(configFile, 'Output', 'ScaleInt', 10)
levels = arange(scaleMin, scaleMax, scaleInt)
plotField(x,y,data, llLon, llLat, urLon, urLat, res, dl, levels,
cmapName, smoothing, title=title, xlab='Longitude',
ylab='Latitude', clab=label, maskland=mask,
maskocean=maskocean,outputFile=outputFile,fill=fill)
logger.info("Completed %s"%sys.argv[0])
