def __time_stks(self):
ep = self.__endianprefix
i = offset = 0
nspcs = len(self.__spc_names)
nstks = len(self.dimensions['NSTK'])
date_block_size = 6
stk_block_size = 4
stk_props_size = 2 + nstks * 5
emiss_block_size = nspcs * (nstks + 13)
hour_block_size = date_block_size + stk_block_size + stk_props_size + emiss_block_size
data = self.__memmap[self.__data_start:]
data = data.reshape(data.size // hour_block_size, hour_block_size)
ntimes = data.shape[0]
self.createDimension('TSTEP', ntimes)
self.createDimension('DATE-TIME', 2)
start = 0
end = date_block_size
date_times = data[:, start:end]
dates = date_times[:, [1, 3]].view(ep + 'i')
times = date_times[:, [2, 4]]
start = end
end = start + stk_block_size
nstk_hdr = data[:, start:end].view(ep + 'i')
if not (nstks == nstk_hdr[:, 2:3]).all():
raise ValueError("Number of stacks varies with time")
start = end
end = start + stk_props_size
self.__hourly_stk_props = data[:, start:end][:, 1:-1].reshape(
ntimes, nstks, 5)
start = end
end = start + emiss_block_size
if not end == data.shape[1]:
raise ValueError("Incorrect shape")
self.__emiss_data = data[:, start:].reshape(ntimes, nspcs,
13 + nstks)[:, :, 12:-1]
bdates = dates[:, 0]
btimes = times[:, 0]
edates = dates[:, 1]
etimes = times[:, 1]
self.NSTEPS = ntimes
self.createDimension('VAR', len(self.__spc_names) + 3)
self.variables['TFLAG'] = ConvertCAMxTime(bdates, btimes,
len(self.dimensions['VAR']))
self.variables['ETFLAG'] = ConvertCAMxTime(edates, etimes,
len(self.dimensions['VAR']))
v = self.variables['NSTKS'] = PseudoNetCDFVariable(self,
'NSTKS',
'i', ('TSTEP', ),
values=array(
nstk_hdr[:, 2]))
v.units = '#'.ljust(16)
v.long_name = 'NSTKS'.ljust(16)
v.var_desc = v.long_name
def __add_variables(self):
tsteps=len(self.dimensions['TSTEP'])
lays=len(self.dimensions['LAY'])
rows=len(self.dimensions['ROW'])
cols=len(self.dimensions['COL'])
offset=len(self.__time_hdr_fmts)+2
block=(rows*cols+2)*2*lays
out_idx=zeros(self.__memmap.shape,'b')
for t in range(tsteps):
start=(t+1)*offset+t*block+t*self.__dummy_length
stop=start+block
out_idx[start:stop].reshape(lays*2,rows*cols+2)[:,1:-1]=1
out_idx[start:stop].reshape(lays*2,rows*cols+2)[:,[0,-1]]=2
out_idx[start-offset:start]=3
buffer=self.__memmap[out_idx==2].reshape(tsteps,lays,2,2)
if not (buffer[:,:,:,0]==buffer[:,:,:,1]).all():
raise ValueError('Fortran unformatted record start and end padding do not match.')
date=self.__memmap[out_idx==3].reshape(tsteps,(out_idx==3).sum()//tsteps)[:,2].view('>i')
time=self.__memmap[out_idx==3].reshape(tsteps,(out_idx==3).sum()//tsteps)[:,1]
self.variables['TFLAG']=ConvertCAMxTime(date,time,2)
self.variables['U']=self.__decorator('U',PseudoNetCDFVariable(self,'U','f',('TSTEP','LAY','ROW','COL'),values=self.__memmap[out_idx==1].reshape(tsteps,lays,2,rows,cols)[:,:,0,:,:]))
self.variables['V']=self.__decorator('V',PseudoNetCDFVariable(self,'V','f',('TSTEP','LAY','ROW','COL'),values=self.__memmap[out_idx==1].reshape(tsteps,lays,2,rows,cols)[:,:,1,:,:]))
def __variables(self, pk, proc_spc):
if proc_spc in self.__ipr_record_type.names:
proc = proc_spc
proc_spc = proc_spc + '_' + self.spcnames[0]
return PseudoNetCDFVariable(
self,
proc_spc,
'f', ('TSTEP', 'LAY', 'ROW', 'COL'),
values=self.__memmaps[pk][:, 0, :, :, :][proc].swapaxes(
1, 3).swapaxes(2, 3))
if proc_spc == 'TFLAG':
thisdate = self.__memmaps[pk][:, 0, :, :, :]['DATE'].swapaxes(
1, 3).swapaxes(2, 3)[..., 0, 0, 0]
thistime = self.__memmaps[pk][:, 0, :, :, :]['TIME'].swapaxes(
1, 3).swapaxes(2, 3)[..., 0, 0, 0]
return ConvertCAMxTime(thisdate, thistime,
len(self.groups[pk].dimensions['VAR']))
for k in self.__ipr_record_type.names:
proc = proc_spc[:len(k)]
spc = proc_spc[len(k) + 1:]
if proc == k and spc in self.spcnames:
spc = self.spcnames.index(spc)
dvals = self.__memmaps[pk][:, spc][proc].swapaxes(1,
3).swapaxes(
2, 3)
return self.__decorator(
proc_spc,
PseudoNetCDFVariable(self,
proc_spc,
'f', ('TSTEP', 'LAY', 'ROW', 'COL'),
values=dvals))
raise KeyError("Bad!")
def __init__(self, rf, mode='r'):
"""
Initialization included reading the header and learning
about the format.
see __readheader and __gettimestep() for more info
"""
self.__rffile = rf
# Establish dimensions
self.createDimension('DATE-TIME', 2)
self.__readheader(mode)
# Add IOAPI metavariables
self.NLAYS = len(self.dimensions['LAY'])
self.NROWS = len(self.dimensions['ROW'])
self.NCOLS = len(self.dimensions['COL'])
self.NVARS = len(self.dimensions['VAR'])
self.NSTEPS = len(self.dimensions['TSTEP'])
varlist = "".join([i.ljust(16) for i in self.__var_names__])
setattr(self, 'VAR-LIST', varlist)
self.GDTYP = 2
# Create variables
self.variables = PseudoNetCDFVariables(self.__variables,
self.__var_names__ + ['TFLAG'])
# Initialize time maps
date = self.__memmap__['DATE']['DATE']
time = self.__memmap__['DATE']['TIME']
self.variables['TFLAG'] = ConvertCAMxTime(date, time, self.NVARS)
self.SDATE, self.STIME = self.variables['TFLAG'][0, 0, :]
def __init__(self, rf, mode='r'):
"""
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__] + ['TFLAG'.ljust(16)]))
self.GDTYP = 2
name = self.__emiss_hdr['name'][0, :, 0].copy().view('S10')[0]
note = self.__emiss_hdr['note'][0, :, 0].copy().view('S60')[0]
if hasattr(name, 'decode'):
name = name.decode()
if hasattr(note, 'decode'):
note = note.decode()
self.NAME = name
self.NOTE = note
self.ITZON = self.__emiss_hdr['itzon'][0]
# Create variables
self.variables = PseudoNetCDFVariables(
self.__variables, self.__var_names__ + ['TFLAG', 'ETFLAG'])
self.variables['TFLAG'] = ConvertCAMxTime(
self.__memmap__['DATE']['BDATE'], self.__memmap__['DATE']['BTIME'],
self.NVARS)
self.variables['ETFLAG'] = ConvertCAMxTime(
self.__memmap__['DATE']['EDATE'], self.__memmap__['DATE']['BTIME'],
self.NVARS)
self.SDATE, self.STIME = self.variables['TFLAG'][0, 0, :]
def __var_get(self, key):
times = len(self.dimensions['TSTEP'])
rows = len(self.dimensions['ROW'])
cols = len(self.dimensions['COL'])
lays = len(self.dimensions['LAY'])
vars = len(list(self.variables.keys())) - 1
hour = 1
date = 2
cloud = 3
rain = 4
snow = 5
graupel = 6
cod = 7
# stagger = 8
out_idx = zeros(self.__memmap.shape, dtype='b')
out_idx.reshape(times,
lays * vars * (rows * cols + 2) + 4)[:, 1] = hour
out_idx.reshape(times,
lays * vars * (rows * cols + 2) + 4)[:, 2] = date
dateblock = self.__memmap[out_idx == date].view('>i')
hourblock = self.__memmap[out_idx == hour]
nvars = len(self.dimensions['VAR'])
self.variables['TFLAG'] = ConvertCAMxTime(dateblock, hourblock, nvars)
newshape1 = (times, lays * vars * (rows * cols + 2) + 4)
newshape2 = (times, lays, vars, rows * cols + 2)
newshape3 = (times, lays, vars, rows, cols)
val_shape = out_idx.reshape(*newshape1)[:, 4:]
val_shape = val_shape.reshape(*newshape2)[:, :, :, 1:-1]
val_shape = val_shape.reshape(*newshape3)
if self.VERSION == '<4.3':
val_shape[:, :, 0, :, :] = cloud
val_shape[:, :, 1, :, :] = rain
val_shape[:, :, 2, :, :] = cod
self.__set_var('CLOUD', out_idx == cloud)
self.__set_var('PRECIP', out_idx == rain)
self.__set_var('COD', out_idx == cod)
else:
val_shape[:, :, 0, :, :] = cloud
val_shape[:, :, 1, :, :] = rain
val_shape[:, :, 2, :, :] = snow
val_shape[:, :, 3, :, :] = graupel
val_shape[:, :, 4, :, :] = cod
self.__set_var('CLOUD', out_idx == cloud)
self.__set_var('RAIN', out_idx == rain)
self.__set_var('SNOW', out_idx == snow)
self.__set_var('GRAUPEL', out_idx == graupel)
self.__set_var('COD', out_idx == cod)
buf = self.__memmap[out_idx == 0].reshape(vars * times * lays + times,
2)
if not (buf[:, 0] == buf[:, 1]).all():
raise ValueError("Buffer")
return self.variables[key]
def __init__(self, rf, rows=None, cols=None):
"""
Initialization included reading the header and learning
about the format.
rows - number of rows in domain (defaults: 1)
cols - number of columns in domain (defaults: size)
"""
self.rffile = rf
self.__memmap = memmap(self.rffile, '>f', 'r', offset=0)
if rows is None and cols is None:
rows = 1
cols = self.__memmap[[-1]].view('>i')[0] // 4 - 2
self.__record_items = rows * cols + 4
self.__records = self.__memmap.shape[0] // self.__record_items
time_date = array(
self.__memmap.reshape(self.__records, self.__record_items)[:, 1:3])
lays = where(time_date != time_date[newaxis, 0])[0][0]
new_hour = slice(0, None, lays)
dates = time_date[:, 1].view('>i')
times = time_date[:, 0]
self.__tflag = array([dates[new_hour], times[new_hour]],
dtype='>f').swapaxes(0, 1)
time_steps = self.__records / lays
self.createDimension('VAR', 1)
self.createDimension('TSTEP', time_steps)
self.createDimension('COL', cols)
self.createDimension('ROW', rows)
self.createDimension('LAY', lays)
self.createDimension('DATE-TIME', 2)
self.FTYPE = 1
self.NVARS = 1
self.NCOLS = cols
self.NROWS = rows
self.NLAYS = lays
self.NTHIK = 1
self.variables = PseudoNetCDFVariables(self.__variables,
[self.var_name])
v = self.variables['TFLAG'] = ConvertCAMxTime(self.__tflag[:, 0],
self.__tflag[:, 1], 1)
self.SDATE, self.STIME = v[0, 0, :]
def __variables(self, pk, rxn):
if rxn == 'TFLAG':
return ConvertCAMxTime(self.__memmaps[pk][:, 0, 0, 0]['DATE'],
self.__memmaps[pk][:, 0, 0, 0]['TIME'],
len(self.groups[pk].dimensions['VAR']))
return self.__decorator(
rxn,
PseudoNetCDFVariable(self,
rxn,
'f', ('TSTEP', 'LAY', 'ROW', 'COL'),
values=self.__memmaps[pk][rxn].swapaxes(
1, 3).swapaxes(2, 3)))
def __var_get(self, key):
lays = len(self.dimensions['LAY'])
times = len(self.dimensions['TSTEP'])
rows = len(self.dimensions['ROW'])
cols = len(self.dimensions['COL'])
surf = 1
air = 2
time = 3
date = 4
out_idx = zeros(self.__memmap.shape,
dtype='b').reshape(times, lays + 1, rows * cols + 4)
out_idx[:, 0, 3:-1] = surf
out_idx[:, 1:, 3:-1] = air
out_idx[:, :, 1] = time
out_idx[:, :, 2] = date
out_idx = out_idx.ravel()
buf = self.__memmap[out_idx == 0].reshape((lays + 1) * times, 2)
if not (buf[:, 0] == buf[:, 1]).all():
raise ValueError("Buffer")
tmpvals = self.__memmap[out_idx == 1].reshape(times, rows, cols)
v = PseudoNetCDFVariable(self,
'SURFTEMP',
'f', ('TSTEP', 'ROW', 'COL'),
values=tmpvals)
self.variables['SURFTEMP'] = v
v.units = 'K'
v.long_name = 'SURFTEMP'
v.var_desc = 'SURFTEMP'
tmpvals = self.__memmap[out_idx == 2].reshape(times, lays, rows, cols)
v = PseudoNetCDFVariable(self,
'AIRTEMP',
'f', ('TSTEP', 'LAY', 'ROW', 'COL'),
values=tmpvals)
self.variables['AIRTEMP'] = v
v.units = 'K'
v.long_name = 'AIRTEMP'
v.var_desc = 'AIRTEMP'
date = self.__memmap[out_idx == date].view('>i')[0:None:lays + 1]
time = self.__memmap[out_idx == time].view('>f')[0:None:lays + 1]
tmpvals = ConvertCAMxTime(date, time, 2)
v = PseudoNetCDFVariable(self,
'TFLAG',
'f', ('TSTEP', 'VAR', 'DATE-TIME'),
values=tmpvals)
self.variables['TFLAG'] = v
return self.variables[key]
def __var_get(self, key):
lays = len(self.dimensions['LAY'])
times = len(self.dimensions['TSTEP'])
rows = len(self.dimensions['ROW'])
cols = len(self.dimensions['COL'])
hght = 1
pres = 2
time = 3
date = 4
out_idx = zeros(self.__memmap.shape,
dtype='b').reshape(times, lays, 2, rows * cols + 4)
out_idx[:, :, 0, 3:-1] = hght
out_idx[:, :, 1, 3:-1] = pres
out_idx[:, :, :, 1] = time
out_idx[:, :, :, 2] = date
out_idx = out_idx.ravel()
buf = self.__memmap[out_idx == 0].reshape(lays * 2 * times, 2)
if not (buf[:, 0] == buf[:, 1]).all():
raise ValueError("Buffer")
v = self.variables['HGHT'] = PseudoNetCDFVariable(
self,
'HGHT',
'f', ('TSTEP', 'LAY', 'ROW', 'COL'),
values=self.__memmap[out_idx == 1].reshape(times, lays, rows,
cols))
v.units = 'm'
v.long_name = 'HGHT'.ljust(16)
v.var_desc = 'Top Height'
v = self.variables['PRES'] = PseudoNetCDFVariable(
self,
'PRES',
'f', ('TSTEP', 'LAY', 'ROW', 'COL'),
values=self.__memmap[out_idx == 2].reshape(times, lays, rows,
cols))
v.units = 'hPA'
v.long_name = 'PRES'.ljust(16)
v.var_desc = 'Pressure at center'
self.variables['TFLAG'] = ConvertCAMxTime(
self.__memmap[out_idx == 4][slice(None, None,
len(self.dimensions['LAY']) *
2)].view('>i'),
self.__memmap[out_idx == 3][slice(None, None,
len(self.dimensions['LAY']) *
2)], len(self.dimensions['VAR']))
return self.variables[key]
def __variables(self, proc_spc):
if proc_spc == 'TFLAG':
time = self.variables['TIME_%s' %
char.decode(self.spcnames)[0][1].strip()]
date = self.variables['DATE_%s' %
char.decode(self.spcnames[0])[1].strip()]
tmpvals = ConvertCAMxTime(date[:, 0, 0, 0],
time[:, 0, 0, 0],
len(self.dimensions['VAR']))
tmpvar = pncvar(self, 'proc_spc', 'i',
('TSTEP', 'VAR', 'DATE-TIME'),
values=tmpvals)
self.variables['TFLAG'] = tmpvar
return self.variables['TFLAG']
self.variables.clear()
spcstrs = char.decode(self.spcnames['SPECIES']).tolist()
for k in self.proc_dict:
proc = proc_spc[:len(k)]
spc = proc_spc[len(k) + 1:]
if proc == k and spc.ljust(10) in spcstrs:
spcprocs = self.__readalltime(spc)
for p, plong in self.proc_dict.items():
var_name = p + '_' + spc
# IPR units are consistent with 'IPR'
if p == 'UCNV':
units = 'm**3/mol'
elif p == 'AVOL':
units = 'm**3'
else:
units = get_uamiv_units('IPR', spc)
tmpvar = pncvar(self, var_name, 'f',
('TSTEP', 'LAY', 'ROW', 'COL'),
values=spcprocs[p],
units=units,
var_desc=var_name.ljust(16),
long_name=var_name.ljust(16))
self.variables[var_name] = tmpvar
del spcprocs
return self.variables[proc_spc]
raise KeyError("Bad!")
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,
mode='r',
P_ALP=None,
P_BET=None,
P_GAM=None,
XCENT=None,
YCENT=None,
GDTYP=None,
endian='big',
chemparam=None):
"""
Parameters
----------
rf : string or RecordFile
usually a path to a CAMx formatted file, can be a FortranFileUtil
RecordFile object.
mode : string
file open mode read ('r'), write ('w'), append ('a', 'r+')
P_ALP : float
see IOAPI GRIDDESC documentation
P_BET : float
see IOAPI GRIDDESC documentation
P_GAM : float
see IOAPI GRIDDESC documentation
XCENT : float
see IOAPI GRIDDESC documentation
YCENT : float
see IOAPI GRIDDESC documentation
GDTYP : float
see IOAPI GRIDDESC documentation
endian : string
'big' or 'little' usually only if mistaken compile
chemparam : None or string
used to identify gases and aerosols
Returns
-------
outf : uamiv
PseudoNetCDFFile populated from file
"""
if chemparam is None:
self._aerosol_names = None
else:
self._aerosol_names = get_chemparam_names(chemparam)['aerosol']
self.__endianprefix = dict(big='>', little='<')[endian]
self._make_header_fmt()
self.__rffile = rf
self.__mode = mode
self.createDimension('DATE-TIME', 2)
self.__readheader()
# Add IOAPI metavariables
self.NLAYS = len(self.dimensions['LAY'])
self.NROWS = len(self.dimensions['ROW'])
self.NCOLS = len(self.dimensions['COL'])
self.NVARS = len(self.dimensions['VAR'])
self.NSTEPS = len(self.dimensions['TSTEP'])
varlist = "".join([i.ljust(16) for i in self.__var_names__])
setattr(self, 'VAR-LIST', varlist)
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 = etflagv[0, 0, 1] - tflagv[0, 0, 1]
if P_ALP is not None:
self.P_ALP = P_ALP
if P_BET is not None:
self.P_BET = P_BET
if P_GAM is not None:
self.P_GAM = P_GAM
if XCENT is not None:
self.XCENT = XCENT
if YCENT is not None:
self.YCENT = YCENT
if GDTYP is not None:
self.GDTYP = GDTYP
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
