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