def __init__(self,rf,proc_dict=None,units='umol/m**3', oldnames = False, **props):
"""
Initialization included reading the header and learning
about the format.
see __readheader and __gettimestep() for more info
Keywords (i.e., props) for projection: P_ALP, P_BET, P_GAM, XCENT, YCENT, XORIG, YORIG, XCELL, YCELL
"""
if proc_dict!=None:
self.proc_dict=proc_dict
else:
self.proc_dict=None
self.__rffile=open(rf, 'rb')
self.__rffile.seek(0,2)
if self.__rffile.tell()<2147483648:
warn("For greater speed on files <2GB use ipr_memmap")
self.__rffile.seek(0,0)
self.units=units
self.__readheader()
self.__setDomain__()
self.__gettimestep()
tdim = self.createDimension('TSTEP',self.NSTEPS)
tdim.setunlimited(True)
self.createDimension('DATE-TIME',2)
self.createDimension('VAR',self.NSPCS*self.NPROCESS)
varkeys=["_".join([j[1],j[0]]) for j in [i for i in cartesian([i.strip() for i in self.spcnames['SPECIES'].tolist()],self.proc_dict.keys())]]+['TFLAG']
self.variables=PseudoNetCDFVariables(self.__variables,varkeys)
for k, v in props.items():
setattr(self, k, v)
add_cf_from_ioapi(self)
def __init__(self,rf,mode='r', P_ALP = None, P_BET = None, P_GAM = None, XCENT = None, YCENT = None, GDTYP = None):
"""
Initialization included reading the header and learning
about the format.
see __readheader and __gettimestep() for more info
"""
self.__rffile=rf
self.__mode=mode
self.createDimension('DATE-TIME', 2)
self.__readheader()
# Add IOAPI metavariables
nlays=self.NLAYS=len(self.dimensions['LAY'])
nrows=self.NROWS=len(self.dimensions['ROW'])
ncols=self.NCOLS=len(self.dimensions['COL'])
nvars=self.NVARS=len(self.dimensions['VAR'])
nsteps=self.NSTEPS=len(self.dimensions['TSTEP'])
setattr(self,'VAR-LIST',"".join([i.ljust(16) for i in self.__var_names__]))
self.NAME=self.__emiss_hdr['name'][0,:,0].copy().view('S10')[0].decode()
self.NOTE=self.__emiss_hdr['note'][0,:,0].copy().view('S60')[0].decode()
self.ITZON=self.__emiss_hdr['itzon'][0]
self.FTYPE = 1 ;
self.VGTYP = 2 ;
self.VGTOP = 10000. ;
self.VGLVLS = linspace(0, 1, self.NLAYS + 1)[::-1] ;
self.GDNAM = "CAMx " ;
self.UPNAM = "CAMx " ;
self.FILEDESC = "CAMx ";
# Create variables
self.variables=PseudoNetCDFVariables(self.__variables,self.__var_names__+['TFLAG','ETFLAG'])
tflag = ConvertCAMxTime(self.__memmap__['DATE']['BDATE'], self.__memmap__['DATE']['BTIME'], self.NVARS)
etflag = ConvertCAMxTime(self.__memmap__['DATE']['EDATE'], self.__memmap__['DATE']['ETIME'],self.NVARS)
tflagv = self.createVariable('TFLAG', 'i', ('TSTEP', 'VAR', 'DATE-TIME'), values = tflag, units = 'DATE-TIME', long_name = 'TFLAG'.ljust(16), var_desc = 'TFLAG'.ljust(80))
etflagv = self.createVariable('ETFLAG', 'i', ('TSTEP', 'VAR', 'DATE-TIME'), values = etflag, units = 'DATE-TIME', long_name = 'ETFLAG'.ljust(16), var_desc = 'Ending TFLAG'.ljust(80))
self.SDATE,self.STIME=self.variables['TFLAG'][0,0,:]
self.TSTEP = self.variables['ETFLAG'][0,0,1] - self.variables['TFLAG'][0,0,1]
if not P_ALP is None:
self.P_ALP = P_ALP
if not P_BET is None:
self.P_BET = P_BET
if not P_GAM is None:
self.P_GAM = P_GAM
if not XCENT is None:
self.XCENT = XCENT
if not YCENT is None:
self.YCENT = YCENT
if not GDTYP is None:
self.GDTYP = GDTYP
try:
add_cf_from_ioapi(self)
except Exception as e:
warn(repr(e))
pass
def __init__(self, path):
if isinstance(path, PseudoNetCDFFile):
outf = path
else:
outf = getvarpnc(NetCDFFile(path), ['TFLAG', 'TA', 'PRES'])
add_cf_from_ioapi(outf)
self.groups = dict(METCRO3D = outf)
self.variables = outf.variables
self.dimensions = outf.dimensions
outf.PRES_VAR_NAME = 'PRES'
if 'PERIM' not in self.dimensions:
self.createDimension('PERIM', sum(map(len, [self.dimensions['ROW'], self.dimensions['COL']])) * 2 + 4)
for k in outf.ncattrs():
setattr(self, k, getattr(outf, k))
def __init__(self,
rf,
proc_dict=None,
units='umol/m**3',
oldnames=False,
**props):
"""
Initialization included reading the header and learning
about the format.
see __readheader and __gettimestep() for more info
Keywords (i.e., props) for projection: P_ALP, P_BET, P_GAM, XCENT, YCENT, XORIG, YORIG, XCELL, YCELL
"""
if proc_dict != None:
self.proc_dict = proc_dict
else:
self.proc_dict = None
self.__rffile = open(rf, 'rb')
self.__rffile.seek(0, 2)
if self.__rffile.tell() < 2147483648:
warn("For greater speed on files <2GB use ipr_memmap")
self.__rffile.seek(0, 0)
self.units = units
self.__readheader()
self.__setDomain__()
self.__gettimestep()
tdim = self.createDimension('TSTEP', self.NSTEPS)
tdim.setunlimited(True)
self.createDimension('DATE-TIME', 2)
self.createDimension('VAR', self.NSPCS * self.NPROCESS)
varkeys = [
"_".join([j[1], j[0]]) for j in [
i for i in cartesian([
i.strip()
for i in char.decode(self.spcnames['SPECIES']).tolist()
], self.proc_dict.keys())
]
] + ['TFLAG']
self.variables = PseudoNetCDFVariables(self.__variables, varkeys)
for k, v in props.items():
setattr(self, k, v)
try:
add_cf_from_ioapi(self)
except:
pass
def plot(ifiles, args):
from PseudoNetCDF.coordutil import getsigmamid, getpresmid, gettimes
import pylab as pl
from pylab import figure, NullFormatter, close, rcParams
rcParams['text.usetex'] = False
from matplotlib.colors import LinearSegmentedColormap, BoundaryNorm, LogNorm
scale = args.scale;
minmax = eval(args.minmax)
minmaxq = eval(args.minmaxq)
sigma = args.sigma
maskzeros = args.maskzeros
outunit = args.outunit
tespaths = args.tespaths
omipaths = args.omipaths
edges = args.edges
try:
f, = ifiles
except:
raise ValueError('curtain plot expects one file when done. Try stack time --stack=time to concatenate')
# Add CF conventions if necessary
if 'latitude_bounds' not in f.variables.keys():
try:
from PseudoNetCDF import getvarpnc
from PseudoNetCDF.conventions.ioapi import add_cf_from_ioapi
f = getvarpnc(f, None)
add_cf_from_ioapi(f)
except:
pass
if sigma:
vertcrd = getsigmamid(f)
else:
vertcrd = getpresmid(f, pref = 101325., ptop = getattr(f, 'VGTOP', 10000))
if vertcrd.max() > 2000: vertcrd /= 100.
try:
lonb = f.variables['geos_longitude_bounds']
latb = f.variables['geos_latitude_bounds']
except:
lonb = f.variables['longitude_bounds']
latb = f.variables['latitude_bounds']
for var_name in args.variables:
temp = defaultdict(lambda: 1)
try:
eval(var_name, None, temp)
var = eval(var_name, None, f.variables)[:]
except:
temp[var_name]
var = f.variables[var_name][:]
if maskzeros: var = np.ma.masked_values(var, 0)
unit = f.variables[temp.keys()[0]].units.strip()
if unit in unitconvert:
var = unitconvert.get((unit, outunit), lambda x: x)(var)
else:
outunit = unit
bmap = None
vmin, vmax = np.percentile(np.ma.compressed(var).ravel(), list(minmaxq))
if minmax[0] is not None:
vmin = minmax[0]
if minmax[1] is not None:
vmax = minmax[1]
if edges:
fig = pl.figure(figsize = (16, 4))
offset = 0.05
ax = fig.add_axes([.1 - offset, .15, .22, .725])
ax = fig.add_axes([.325 - offset, .15, .22, .725])
ax = fig.add_axes([.55 - offset, .15, .22, .725])
ax = fig.add_axes([.775 - offset, .15, .22, .725])
ss = 0
se = ss + f.NCOLS + 1
es = se
ee = se + f.NROWS + 1
ns = ee
ne = ee + f.NCOLS + 1
ws = ne
we = ws + f.NROWS + 1
axs = fig.axes
for ax in fig.axes[1:]:
ax.yaxis.set_major_formatter(pl.NullFormatter())
vars = [var[:, :, ss:se], var[:, :, es:ee], var[:, :, ns:ne][:, :, ::-1], var[:, :, ws:we][:, :, ::-1]]
lonbss = [lonb[ss:se], lonb[es:ee], lonb[ns:ne][::-1], lonb[ws:we][::-1]]
latbss = [latb[ss:se], latb[es:ee], latb[ns:ne][::-1], latb[ws:we][::-1]]
else:
fig = pl.figure(figsize = (8, 4))
ax = fig.add_axes([.1, .15, .8, .725])
axs = fig.axes
vars = [var]
lonbss = [lonb[:]]
latbss = [latb[:]]
for ax, var, lonbs, latbs in zip(axs, vars, lonbss, latbss):
vals = var.swapaxes(0, 1).reshape(var.shape[1], -1)
ax.text(.05, .9, 'n = %d' % vals.shape[1], transform = ax.transAxes)
modl, modr = minmaxmean(ax, vals, vertcrd, facecolor = 'k', edgecolor = 'k', alpha = .2, zorder = 4, label = 'GC', ls = '-', lw = 2, color = 'k')
llines = [(modl, modr)]
ymin, ymax = vertcrd.min(), vertcrd.max()
ax.set_ylim(ymax, ymin)
ax.set_xscale(scale)
ax.set_xlim(vmin, vmax)
#if scale == 'log':
# ax.set_xticklabels(['%.1f' % (10**x) for x in ax.get_xticks()])
if 'TFLAG' in f.variables.keys():
SDATE = f.variables['TFLAG'][:][0, 0, 0]
EDATE = f.variables['TFLAG'][:][-1, 0, 0]
STIME = f.variables['TFLAG'][:][0, 0, 1]
ETIME = f.variables['TFLAG'][:][-1, 0, 1]
if SDATE == 0:
SDATE = 1900001
EDATE = 1900001
sdate = datetime.strptime('%07d %06d' % (SDATE, STIME), '%Y%j %H%M%S')
edate = datetime.strptime('%07d %06d' % (EDATE, ETIME), '%Y%j %H%M%S')
elif 'tau0' in f.variables.keys():
sdate = datetime(1985, 1, 1, 0) + timedelta(hours = f.variables['tau0'][0])
edate = datetime(1985, 1, 1, 0) + timedelta(hours = f.variables['tau1'][-1])
else:
times = gettimes(f)
sdate = times[0]
edate = times[-1]
if len(tespaths) > 0:
tesl, tesr = plot_tes(ax, lonbs, latbs, tespaths)
if not tesl is None:
llines.append((tesl, tesr))
if len(omipaths) > 0:
omil, omir = plot_omi(ax, lonbs, latbs, omipaths, airden = f.variables['AIRDEN'][:].mean(0).mean(1), airdenvert = vertcrd)
if not omil is None:
llines.append((omil, omir))
try:
title = '%s to %s' % (sdate.strftime('%Y-%m-%d'), edate.strftime('%Y-%m-%d'))
except:
title = var_name
if sigma:
axs[0].set_ylabel('sigma')
else:
axs[0].set_ylabel('pressure')
xmax = -np.inf
xmin = np.inf
for ax in fig.axes:
tmp_xmin, tmp_xmax = ax.get_xlim()
xmax = max(tmp_xmax, xmax)
xmin = min(tmp_xmin, xmin)
for ax in fig.axes:
ax.set_xlim(xmin, xmax)
if len(axs) == 1:
axs[0].set_xlabel('%s %s' % (var_name, outunit))
else:
axs[0].set_xlabel('South')
axs[1].set_xlabel('East')
axs[2].set_xlabel('North')
axs[3].set_xlabel('West')
fig.text(.5, .90, '%s %s' % (var_name, outunit), horizontalalignment = 'center', fontsize = 16)
nl = 0
for ax in axs:
if len(ax.get_lines()) > nl:
nl = len(ax.get_lines())
pl.sca(ax)
llabels = [l[0].get_label() for l in llines]
pl.legend(llines, llabels, bbox_to_anchor = (.1, 1), loc = 'upper left', bbox_transform = fig.transFigure, ncol = 6)
if edges:
fig.text(0.95, 0.975, title, horizontalalignment = 'right', verticalalignment = "top", fontsize = 16)
else:
fig.text(0.95, 0.025, title, horizontalalignment = 'right', verticalalignment = "bottom", fontsize = 16)
fig.savefig('%s_%s.%s' % (args.outpath, var_name, args.figformat))
pl.close(fig)
return fig
def __init__(self,
rf,
mode='r',
P_ALP=None,
P_BET=None,
P_GAM=None,
XCENT=None,
YCENT=None,
GDTYP=None):
"""
Initialization included reading the header and learning
about the format.
see __readheader and __gettimestep() for more info
"""
self.__rffile = rf
self.__mode = mode
self.createDimension('DATE-TIME', 2)
self.__readheader()
# Add IOAPI metavariables
nlays = self.NLAYS = len(self.dimensions['LAY'])
nrows = self.NROWS = len(self.dimensions['ROW'])
ncols = self.NCOLS = len(self.dimensions['COL'])
nvars = self.NVARS = len(self.dimensions['VAR'])
nsteps = self.NSTEPS = len(self.dimensions['TSTEP'])
setattr(self, 'VAR-LIST',
"".join([i.ljust(16) for i in self.__var_names__]))
self.NAME = self.__emiss_hdr['name'][0, :,
0].copy().view('S10')[0].decode()
self.NOTE = self.__emiss_hdr['note'][0, :,
0].copy().view('S60')[0].decode()
self.ITZON = self.__emiss_hdr['itzon'][0]
self.FTYPE = 1
self.VGTYP = 2
self.VGTOP = 10000.
self.VGLVLS = linspace(0, 1, self.NLAYS + 1)[::-1]
self.GDNAM = "CAMx "
self.UPNAM = "CAMx "
self.FILEDESC = "CAMx "
# Create variables
self.variables = PseudoNetCDFVariables(
self.__variables, self.__var_names__ + ['TFLAG', 'ETFLAG'])
tflag = ConvertCAMxTime(self.__memmap__['DATE']['BDATE'],
self.__memmap__['DATE']['BTIME'], self.NVARS)
etflag = ConvertCAMxTime(self.__memmap__['DATE']['EDATE'],
self.__memmap__['DATE']['ETIME'], self.NVARS)
tflagv = self.createVariable('TFLAG',
'i', ('TSTEP', 'VAR', 'DATE-TIME'),
values=tflag,
units='DATE-TIME',
long_name='TFLAG'.ljust(16),
var_desc='TFLAG'.ljust(80))
etflagv = self.createVariable('ETFLAG',
'i', ('TSTEP', 'VAR', 'DATE-TIME'),
values=etflag,
units='DATE-TIME',
long_name='ETFLAG'.ljust(16),
var_desc='Ending TFLAG'.ljust(80))
self.SDATE, self.STIME = self.variables['TFLAG'][0, 0, :]
self.TSTEP = self.variables['ETFLAG'][
0, 0, 1] - self.variables['TFLAG'][0, 0, 1]
if not P_ALP is None:
self.P_ALP = P_ALP
if not P_BET is None:
self.P_BET = P_BET
if not P_GAM is None:
self.P_GAM = P_GAM
if not XCENT is None:
self.XCENT = XCENT
if not YCENT is None:
self.YCENT = YCENT
if not GDTYP is None:
self.GDTYP = GDTYP
try:
add_cf_from_ioapi(self)
except Exception as e:
warn(repr(e))
pass
def __init__(self, rf, multi=False, **props):
"""
Initialization included reading the header and learning
about the format.
see __readheader and __gettimestep() for more info
Keywords (i.e., props) for projection: P_ALP, P_BET, P_GAM, XCENT, YCENT, XORIG, YORIG, XCELL, YCELL
"""
self.__rffile = OpenRecordFile(rf)
self.__readheader()
self.__ipr_record_type = {
24:
dtype(
dict(names=[
'SPAD', 'DATE', 'TIME', 'SPC', 'PAGRID', 'NEST', 'I', 'J',
'K', 'INIT', 'CHEM', 'EMIS', 'PTEMIS', 'PIG', 'WADV',
'EADV', 'SADV', 'NADV', 'BADV', 'TADV', 'DIL', 'WDIF',
'EDIF', 'SDIF', 'NDIF', 'BDIF', 'TDIF', 'DDEP', 'WDEP',
'AERCHEM', 'FCONC', 'UCNV', 'AVOL', 'EPAD'
],
formats=[
'>i', '>i', '>f', '>S10', '>i', '>i', '>i', '>i',
'>i', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>i'
])),
26:
dtype(
dict(names=[
'SPAD', 'DATE', 'TIME', 'SPC', 'PAGRID', 'NEST', 'I', 'J',
'K', 'INIT', 'CHEM', 'EMIS', 'PTEMIS', 'PIG', 'WADV',
'EADV', 'SADV', 'NADV', 'BADV', 'TADV', 'DIL', 'WDIF',
'EDIF', 'SDIF', 'NDIF', 'BDIF', 'TDIF', 'DDEP', 'WDEP',
'INORGACHEM', 'ORGACHEM', 'AQACHEM', 'FCONC', 'UCNV',
'AVOL', 'EPAD'
],
formats=[
'>i', '>i', '>f', '>S10', '>i', '>i', '>i', '>i',
'>i', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>i'
]))
}[len(self.prcnames)]
prcs = [
'SPAD', 'DATE', 'TIME', 'PAGRID', 'NEST', 'I', 'J', 'K', 'INIT',
'CHEM', 'EMIS', 'PTEMIS', 'PIG', 'WADV', 'EADV', 'SADV', 'NADV',
'BADV', 'TADV', 'DIL', 'WDIF', 'EDIF', 'SDIF', 'NDIF', 'BDIF',
'TDIF', 'DDEP', 'WDEP'
] + {
24: ['AERCHEM'],
26: ['INORGACHEM', 'ORGACHEM', 'AQACHEM']
}[len(self.prcnames)] + ['FCONC', 'UCNV', 'AVOL', 'EPAD']
varkeys = ['_'.join(i) for i in cartesian(prcs, self.spcnames)]
varkeys += [
'SPAD', 'DATE', 'TIME', 'PAGRID', 'NEST', 'I', 'J', 'K', 'TFLAG'
]
self.groups = {}
NSTEPS = len([i_ for i_ in self.timerange()])
NVARS = len(varkeys)
self.createDimension('VAR', NVARS)
self.createDimension('DATE-TIME', 2)
self.createDimension('TSTEP', NSTEPS)
padatatype = []
pavarkeys = []
for di, domain in enumerate(self.padomains):
dk = 'PA%02d' % di
prefix = dk + '_'
grp = self.groups[dk] = PseudoNetCDFFile()
pavarkeys.extend([prefix + k for k in varkeys])
grp.createDimension('VAR', NVARS)
grp.createDimension('DATE-TIME', 2)
grp.createDimension('TSTEP', NSTEPS)
grp.createDimension('COL', domain['iend'] - domain['istart'] + 1)
grp.createDimension('ROW', domain['jend'] - domain['jstart'] + 1)
grp.createDimension('LAY', domain['tlay'] - domain['blay'] + 1)
padatatype.append(
(dk, self.__ipr_record_type, (len(grp.dimensions['ROW']),
len(grp.dimensions['COL']),
len(grp.dimensions['LAY']))))
if len(self.padomains) == 1:
self.createDimension('COL',
domain['iend'] - domain['istart'] + 1)
self.createDimension('ROW',
domain['jend'] - domain['jstart'] + 1)
self.createDimension('LAY',
domain['tlay'] - domain['blay'] + 1)
exec(
"""def varget(k):
return self._ipr__variables('%s', k)""" % dk, dict(self=self),
locals())
if len(self.padomains) == 1:
self.variables = PseudoNetCDFVariables(varget, varkeys)
else:
grp.variables = PseudoNetCDFVariables(varget, varkeys)
self.__memmaps = memmap(self.__rffile.infile.name, dtype(padatatype),
'r', self.data_start_byte).reshape(
NSTEPS, len(self.spcnames))
for k, v in props.items():
setattr(self, k, v)
try:
add_cf_from_ioapi(self)
except:
pass
def __init__(self,rf,multi=False, **props):
"""
Initialization included reading the header and learning
about the format.
see __readheader and __gettimestep() for more info
Keywords (i.e., props) for projection: P_ALP, P_BET, P_GAM, XCENT, YCENT, XORIG, YORIG, XCELL, YCELL
"""
self.__rffile=OpenRecordFile(rf)
self.__readheader()
self.__ipr_record_type={
24: dtype(
dict(
names=['SPAD', 'DATE', 'TIME', 'SPC', 'PAGRID', 'NEST', 'I', 'J', 'K',
'INIT', 'CHEM', 'EMIS', 'PTEMIS', 'PIG', 'WADV', 'EADV', 'SADV',
'NADV', 'BADV', 'TADV', 'DIL', 'WDIF', 'EDIF', 'SDIF', 'NDIF',
'BDIF', 'TDIF', 'DDEP', 'WDEP', 'AERCHEM', 'FCONC', 'UCNV', 'AVOL',
'EPAD'],
formats=['>i', '>i', '>f', '>S10', '>i', '>i', '>i', '>i', '>i',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>f', '>f', '>f', '>f', '>f', '>f', '>i'])),
26: dtype(
dict(
names=['SPAD', 'DATE', 'TIME', 'SPC', 'PAGRID', 'NEST', 'I', 'J', 'K',
'INIT', 'CHEM', 'EMIS', 'PTEMIS', 'PIG', 'WADV', 'EADV', 'SADV',
'NADV', 'BADV', 'TADV', 'DIL', 'WDIF', 'EDIF', 'SDIF', 'NDIF',
'BDIF', 'TDIF', 'DDEP', 'WDEP', 'INORGACHEM', 'ORGACHEM', 'AQACHEM', 'FCONC', 'UCNV', 'AVOL',
'EPAD'],
formats=['>i', '>i', '>f', '>S10', '>i', '>i', '>i', '>i', '>i',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f',
'>f', '>f', '>f', '>f', '>f', '>f', '>f', '>f', '>i']))
}[len(self.prcnames)]
prcs=['SPAD', 'DATE', 'TIME', 'PAGRID', 'NEST', 'I', 'J', 'K',
'INIT', 'CHEM', 'EMIS', 'PTEMIS', 'PIG', 'WADV', 'EADV', 'SADV',
'NADV', 'BADV', 'TADV', 'DIL', 'WDIF', 'EDIF', 'SDIF', 'NDIF',
'BDIF', 'TDIF', 'DDEP', 'WDEP']+{24: ['AERCHEM'], 26: ['INORGACHEM', 'ORGACHEM', 'AQACHEM']}[len(self.prcnames)]+['FCONC', 'UCNV', 'AVOL',
'EPAD']
varkeys=['_'.join(i) for i in cartesian(prcs,self.spcnames)]
varkeys+=['SPAD','DATE','TIME','PAGRID','NEST','I','J','K','TFLAG']
self.groups = {}
NSTEPS = len([i_ for i_ in self.timerange()])
NVARS = len(varkeys)
self.createDimension('VAR', NVARS)
self.createDimension('DATE-TIME', 2)
self.createDimension('TSTEP', NSTEPS)
padatatype = []
pavarkeys = []
for di, domain in enumerate(self.padomains):
dk = 'PA%02d' % di
prefix = dk + '_'
grp = self.groups[dk] = PseudoNetCDFFile()
pavarkeys.extend([prefix + k for k in varkeys])
grp.createDimension('VAR', NVARS)
grp.createDimension('DATE-TIME', 2)
grp.createDimension('TSTEP', NSTEPS)
grp.createDimension('COL', domain['iend'] - domain['istart'] + 1)
grp.createDimension('ROW', domain['jend'] - domain['jstart'] + 1)
grp.createDimension('LAY', domain['tlay'] - domain['blay'] + 1)
padatatype.append((dk, self.__ipr_record_type, (len(grp.dimensions['ROW']), len(grp.dimensions['COL']), len(grp.dimensions['LAY']))))
if len(self.padomains) == 1:
self.createDimension('COL', domain['iend']-domain['istart']+1)
self.createDimension('ROW', domain['jend']-domain['jstart']+1)
self.createDimension('LAY', domain['tlay']-domain['blay']+1)
exec("""def varget(k):
return self._ipr__variables('%s', k)""" % dk, dict(self = self), locals())
if len(self.padomains) == 1:
self.variables = PseudoNetCDFVariables(varget,varkeys)
else:
grp.variables = PseudoNetCDFVariables(varget,varkeys)
self.__memmaps=memmap(self.__rffile.infile.name,dtype(padatatype),'r',self.data_start_byte).reshape(NSTEPS, len(self.spcnames))
for k, v in props.items():
setattr(self, k, v)
try:
add_cf_from_ioapi(self)
except:
pass
def __init__(self,
rf,
mode='r',
P_ALP=None,
P_BET=None,
P_GAM=None,
XCENT=None,
YCENT=None,
GDTYP=None,
endian='big',
chemparam=None):
"""
Initialization included reading the header and learning
about the format.
see __readheader and __gettimestep() for more info
"""
if chemparam is None:
self._aerosol_names = None
else:
self._aerosol_names = get_chemparam_names(chemparam)['aerosol']
ep = self.__endianprefix = dict(big='>', little='<')[endian]
self.__emiss_hdr_fmt = dtype(
dict(names=[
'SPAD', 'name', 'note', 'itzon', 'nspec', 'ibdate', 'btime',
'iedate', 'etime', 'EPAD'
],
formats=[
ep + 'i',
'(10, 4)%sS1' % ep,
'(60,4)%sS1' % ep, ep + 'i', ep + 'i', ep + 'i', ep + 'f',
ep + 'i', ep + 'f', ep + 'i'
]))
self.__grid_hdr_fmt = dtype(
dict(names=[
'SPAD', 'plon', 'plat', 'iutm', 'xorg', 'yorg', 'delx', 'dely',
'nx', 'ny', 'nz', 'iproj', 'istag', 'tlat1', 'tlat2', 'rdum',
'EPAD'
],
formats=[
ep + 'i', ep + 'f', ep + 'f', ep + 'i', ep + 'f',
ep + 'f', ep + 'f', ep + 'f', ep + 'i', ep + 'i',
ep + 'i', ep + 'i', ep + 'i', ep + 'f', ep + 'f',
ep + 'f', ep + 'i'
]))
self.__cell_hdr_fmt = dtype(
dict(names=['SPAD', 'ione1', 'ione2', 'nx', 'ny', 'EPAD'],
formats=[
ep + 'i', ep + 'i', ep + 'i', ep + 'i', ep + 'i', ep + 'i'
]))
self.__time_hdr_fmt = dtype(
dict(names=['SPAD', 'ibdate', 'btime', 'iedate', 'etime', 'EPAD'],
formats=[
ep + 'i', ep + 'i', ep + 'f', ep + 'i', ep + 'f', ep + 'i'
]))
self.__spc_fmt = dtype("(10,4)%sS1" % ep)
self.__rffile = rf
self.__mode = mode
self.createDimension('DATE-TIME', 2)
self.__readheader()
# Add IOAPI metavariables
nlays = self.NLAYS = len(self.dimensions['LAY'])
nrows = self.NROWS = len(self.dimensions['ROW'])
ncols = self.NCOLS = len(self.dimensions['COL'])
nvars = self.NVARS = len(self.dimensions['VAR'])
nsteps = self.NSTEPS = len(self.dimensions['TSTEP'])
setattr(self, 'VAR-LIST',
"".join([i.ljust(16) for i in self.__var_names__]))
self.NAME = self.__emiss_hdr['name'][0, :,
0].copy().view('S10')[0].decode()
self.NOTE = self.__emiss_hdr['note'][0, :,
0].copy().view('S60')[0].decode()
self.ITZON = self.__emiss_hdr['itzon'][0]
self.FTYPE = 1
self.VGTYP = 2
self.VGTOP = 10000.
self.VGLVLS = linspace(0, 1, self.NLAYS + 1)[::-1]
self.GDNAM = "CAMx "
self.UPNAM = "CAMx "
self.FILEDESC = "CAMx "
# Create variables
self.variables = PseudoNetCDFVariables(
self.__variables, ['TFLAG', 'ETFLAG'] + self.__var_names__)
tflag = ConvertCAMxTime(self.__memmap__['DATE']['BDATE'],
self.__memmap__['DATE']['BTIME'], self.NVARS)
etflag = ConvertCAMxTime(self.__memmap__['DATE']['EDATE'],
self.__memmap__['DATE']['ETIME'], self.NVARS)
tflagv = self.createVariable('TFLAG',
'i', ('TSTEP', 'VAR', 'DATE-TIME'),
values=tflag,
units='DATE-TIME',
long_name='TFLAG'.ljust(16),
var_desc='TFLAG'.ljust(80))
etflagv = self.createVariable('ETFLAG',
'i', ('TSTEP', 'VAR', 'DATE-TIME'),
values=etflag,
units='DATE-TIME',
long_name='ETFLAG'.ljust(16),
var_desc='Ending TFLAG'.ljust(80))
self.SDATE, self.STIME = self.variables['TFLAG'][0, 0, :]
self.TSTEP = self.variables['ETFLAG'][
0, 0, 1] - self.variables['TFLAG'][0, 0, 1]
if not P_ALP is None:
self.P_ALP = P_ALP
if not P_BET is None:
self.P_BET = P_BET
if not P_GAM is None:
self.P_GAM = P_GAM
if not XCENT is None:
self.XCENT = XCENT
if not YCENT is None:
self.YCENT = YCENT
if not GDTYP is None:
self.GDTYP = GDTYP
try:
add_cf_from_ioapi(self)
except Exception as e:
warn(repr(e))
pass
def plot(paths, keys = ['O3'], prefix = 'BC', scale = 'log', minmax = (None, None), minmaxq = (0, 100), outunit = 'ppb', sigma = False, maskzeros = False, tespaths = [], omipaths = [], edges = True):
from pylab import figure, NullFormatter, close, rcParams
rcParams['text.usetex'] = False
from matplotlib.colors import LinearSegmentedColormap, BoundaryNorm, LogNorm
if len(paths) == 1:
f = Dataset(paths[0])
else:
f = MFDataset(paths)
# Add CF conventions if necessary
if 'latitude_bounds' not in f.variables.keys():
from PseudoNetCDF import getvarpnc
from PseudoNetCDF.conventions.ioapi import add_cf_from_ioapi
f = getvarpnc(f, None)
add_cf_from_ioapi(f)
try:
if sigma:
vertcrd = f.VGLVLS[:-1] + np.diff(f.VGLVLS)
else:
vertcrd = pres_from_sigma(f.VGLVLS, pref = 101325., ptop = f.VGTOP, avg = True) / 100.
except:
lay = f.variables['layer_edges'][:]
if not sigma:
vertcrd = lay[:-1] + np.diff(lay) / 2.
else:
vertcrd = (lay[:] - lay[-1]) / (lay[0] - lay[-1])
vertcrd = vertcrd[:-1] + np.diff(vertcrd) / 2
try:
lonb = f.variables['geos_longitude_bounds']
latb = f.variables['geos_latitude_bounds']
except:
lonb = f.variables['longitude_bounds']
latb = f.variables['latitude_bounds']
for var_name in keys:
temp = defaultdict(lambda: 1)
try:
eval(var_name, None, temp)
var = eval(var_name, None, f.variables)[:]
except:
temp[var_name]
var = f.variables[var_name][:]
if maskzeros: var = np.ma.masked_values(var, 0)
unit = f.variables[temp.keys()[0]].units.strip()
var = unitconvert.get((unit, outunit), lambda x: x)(var)
bmap = None
vmin, vmax = np.percentile(np.ma.compressed(var).ravel(), list(minmaxq))
if minmax[0] is not None:
vmin = minmax[0]
if minmax[1] is not None:
vmax = minmax[1]
if edges:
fig = pl.figure(figsize = (16, 4))
offset = 0.05
ax = fig.add_axes([.1 - offset, .15, .22, .725])
ax = fig.add_axes([.325 - offset, .15, .22, .725])
ax = fig.add_axes([.55 - offset, .15, .22, .725])
ax = fig.add_axes([.775 - offset, .15, .22, .725])
ss = 0
se = ss + f.NCOLS + 1
es = se
ee = se + f.NROWS + 1
ns = ee
ne = ee + f.NCOLS + 1
ws = ne
we = ws + f.NROWS + 1
axs = fig.axes
for ax in fig.axes[1:]:
ax.yaxis.set_major_formatter(pl.NullFormatter())
vars = [var[:, :, ss:se], var[:, :, es:ee], var[:, :, ns:ne][:, :, ::-1], var[:, :, ws:we][:, :, ::-1]]
lonbss = [lonb[ss:se], lonb[es:ee], lonb[ns:ne][::-1], lonb[ws:we][::-1]]
latbss = [latb[ss:se], latb[es:ee], latb[ns:ne][::-1], latb[ws:we][::-1]]
else:
fig = pl.figure(figsize = (8, 4))
ax = fig.add_axes([.1, .15, .8, .725])
axs = fig.axes
vars = [var]
lonbss = [lonb[:]]
latbss = [latb[:]]
for ax, var, lonbs, latbs in zip(axs, vars, lonbss, latbss):
vals = var.swapaxes(0, 1).reshape(var.shape[1], -1)
ax.text(.05, .9, 'n = %d' % vals.shape[1], transform = ax.transAxes)
modl, modr = minmaxmean(ax, vals, vertcrd, facecolor = 'k', edgecolor = 'k', alpha = .2, zorder = 4, label = 'GC', ls = '-', lw = 2, color = 'k')
llines = [(modl, modr)]
ymin, ymax = vertcrd.min(), vertcrd.max()
ax.set_ylim(ymax, ymin)
ax.set_xscale(scale)
ax.set_xlim(vmin, vmax)
#if scale == 'log':
# ax.set_xticklabels(['%.1f' % (10**x) for x in ax.get_xticks()])
if 'TFLAG' in f.variables.keys():
SDATE = f.variables['TFLAG'][:][0, 0, 0]
EDATE = f.variables['TFLAG'][:][-1, 0, 0]
STIME = f.variables['TFLAG'][:][0, 0, 1]
ETIME = f.variables['TFLAG'][:][-1, 0, 1]
if SDATE == 0:
SDATE = 1900001
EDATE = 1900001
sdate = datetime.strptime('%07d %06d' % (SDATE, STIME), '%Y%j %H%M%S')
edate = datetime.strptime('%07d %06d' % (EDATE, ETIME), '%Y%j %H%M%S')
elif 'tau0' in f.variables.keys():
sdate = datetime(1985, 1, 1, 0) + timedelta(hours = f.variables['tau0'][0])
edate = datetime(1985, 1, 1, 0) + timedelta(hours = f.variables['tau1'][-1])
else:
sdate = datetime(1900, 1, 1, 0)
edate = datetime(1900, 1, 1, 0)
if len(tespaths) > 0:
tesl, tesr = plot_tes(ax, lonbs, latbs, tespaths)
if not tesl is None:
llines.append((tesl, tesr))
if len(omipaths) > 0:
omil, omir = plot_omi(ax, lonbs, latbs, omipaths, airden = f.variables['AIRDEN'][:].mean(0).mean(1), airdenvert = vertcrd)
if not omil is None:
llines.append((omil, omir))
try:
title = '%s to %s' % (sdate.strftime('%Y-%m-%d'), edate.strftime('%Y-%m-%d'))
except:
title = var_name
if sigma:
axs[0].set_ylabel('sigma')
else:
axs[0].set_ylabel('pressure')
xmax = -np.inf
xmin = np.inf
for ax in fig.axes:
tmp_xmin, tmp_xmax = ax.get_xlim()
xmax = max(tmp_xmax, xmax)
xmin = min(tmp_xmin, xmin)
for ax in fig.axes:
ax.set_xlim(xmin, xmax)
if len(axs) == 1:
axs[0].set_xlabel('%s %s' % (var_name, outunit))
else:
axs[0].set_xlabel('South')
axs[1].set_xlabel('East')
axs[2].set_xlabel('North')
axs[3].set_xlabel('West')
nl = 0
for ax in axs:
if len(ax.get_lines()) > nl:
nl = len(ax.get_lines())
pl.sca(ax)
llabels = [l[0].get_label() for l in llines]
pl.legend(llines, llabels, bbox_to_anchor = (.1, 1), loc = 'upper left', bbox_transform = fig.transFigure, ncol = 6)
if edges:
fig.text(0.95, 0.975, title, horizontalalignment = 'right', verticalalignment = "top", fontsize = 16)
else:
fig.text(0.95, 0.025, title, horizontalalignment = 'right', verticalalignment = "bottom", fontsize = 16)
fig.savefig('%s_%s_%s.pdf' % (prefix, var_name, 'profile'))
pl.close(fig)
return fig
