def ConvertCAMxTime(date, time, nvars=1):
    """
    Use camx date and time arrays to produce an
    IOAPI standard TFLAG variable
    """
    f = PseudoNetCDFFile()
    f.dimensions = {'TSTEP': date.shape[0], 'VAR': nvars, 'DATE-TIME': 2}

    a = array([date, time], dtype='i').swapaxes(0, 1)
    if len(a.shape) == 2:
        a = a[:, newaxis, :]
    date = a[:, :, 0]
    if (date < 70000).any():
        date += 2000000
    else:
        date += 1900000
    time = a[:, :, 1]
    while not (time == 0).all() and time.max() < 10000:
        time *= 100
    a = PseudoNetCDFVariable(f,
                             'TFLAG',
                             'i', ('TSTEP', 'VAR', 'DATE-TIME'),
                             values=a[:, [0], :].repeat(nvars, 1))
    a.units = 'DATE-TIME'.ljust(16)
    a.long_name = 'TFLAG'.ljust(16)
    a.var_desc = a.long_name
    return a
示例#2
0
    def setUp(self):
        from permm.mechanisms import small_strato
        from PseudoNetCDF import PseudoNetCDFFile
        from numpy import arange, newaxis
        from numpy.random import normal, poisson, random, seed
        
        self.mech = small_strato()
        mrg = self.mrg = PseudoNetCDFFile()
        
        mrg.createDimension('TSTEP', 10)
        mrg.createDimension('ROW', 3)
        mrg.createDimension('LAY', 4)
        mrg.createDimension('COL', 5)
        mrg.createDimension('VAR', 10)
        mrg.createDimension('DATE-TIME', 2)
        
        tflag = mrg.createVariable('TFLAG', 'i', ('TSTEP', 'VAR', 'DATE-TIME'))
        tflag.units = '<YYYYJJJ, HHMMSS>'
        tflag.long_name = tflag.var_desc = 'time '
        
        tflag[:, :, 0] = 2004001
        tflag[:, :, 1] = arange(10)[:, newaxis] * 10000
        
        for i in range(1, 11):
            var = mrg.createVariable('IRR_%d' % i, 'f', ('TSTEP', 'LAY', 'ROW', 'COL'))
            var.units = 'ppt'
            var.long_name = var.var_desc = 'Integrated rate for IRR ordinal %d' % i
            seed(1)
            if i % 2 == 0:
                data = arange(3 * i, 3 * i + 10)[:, newaxis, newaxis, newaxis].repeat(4, 1).repeat(3, 2).repeat(5, 3)
            elif i % 1 == 0:
                data = arange(2 * i, 2 * i + 10)[:, newaxis, newaxis, newaxis].repeat(4, 1).repeat(3, 2).repeat(5, 3)
            else:
                data = arange(1 * i, 1 * i + 10)[:, newaxis, newaxis, newaxis].repeat(4, 1).repeat(3, 2).repeat(5, 3)

            var[:] = data * {True: -1, False: 1}[i % 2 == True]

        self.mech.set_mrg(mrg)
示例#3
0
    def setUp(self):
        from PseudoNetCDF import PseudoNetCDFFile
        self.checkval = """time,layer,latitude,longitude,test
0.0,0.0,0.0,0.0,0.0
0.0,0.0,0.0,1.0,1.0
0.0,0.0,0.0,2.0,2.0
0.0,0.0,0.0,3.0,3.0
0.0,0.0,0.0,4.0,4.0
0.0,0.0,1.0,0.0,5.0
0.0,0.0,1.0,1.0,6.0
0.0,0.0,1.0,2.0,7.0
0.0,0.0,1.0,3.0,8.0
0.0,0.0,1.0,4.0,9.0
0.0,0.0,2.0,0.0,10.0
0.0,0.0,2.0,1.0,11.0
0.0,0.0,2.0,2.0,12.0
0.0,0.0,2.0,3.0,13.0
0.0,0.0,2.0,4.0,14.0
0.0,0.0,3.0,0.0,15.0
0.0,0.0,3.0,1.0,16.0
0.0,0.0,3.0,2.0,17.0
0.0,0.0,3.0,3.0,18.0
0.0,0.0,3.0,4.0,19.0
0.0,1.0,0.0,0.0,20.0
0.0,1.0,0.0,1.0,21.0
0.0,1.0,0.0,2.0,22.0
0.0,1.0,0.0,3.0,23.0
0.0,1.0,0.0,4.0,24.0
0.0,1.0,1.0,0.0,25.0
0.0,1.0,1.0,1.0,26.0
0.0,1.0,1.0,2.0,27.0
0.0,1.0,1.0,3.0,28.0
0.0,1.0,1.0,4.0,29.0
0.0,1.0,2.0,0.0,30.0
0.0,1.0,2.0,1.0,31.0
0.0,1.0,2.0,2.0,32.0
0.0,1.0,2.0,3.0,33.0
0.0,1.0,2.0,4.0,34.0
0.0,1.0,3.0,0.0,35.0
0.0,1.0,3.0,1.0,36.0
0.0,1.0,3.0,2.0,37.0
0.0,1.0,3.0,3.0,38.0
0.0,1.0,3.0,4.0,39.0
0.0,2.0,0.0,0.0,40.0
0.0,2.0,0.0,1.0,41.0
0.0,2.0,0.0,2.0,42.0
0.0,2.0,0.0,3.0,43.0
0.0,2.0,0.0,4.0,44.0
0.0,2.0,1.0,0.0,45.0
0.0,2.0,1.0,1.0,46.0
0.0,2.0,1.0,2.0,47.0
0.0,2.0,1.0,3.0,48.0
0.0,2.0,1.0,4.0,49.0
0.0,2.0,2.0,0.0,50.0
0.0,2.0,2.0,1.0,51.0
0.0,2.0,2.0,2.0,52.0
0.0,2.0,2.0,3.0,53.0
0.0,2.0,2.0,4.0,54.0
0.0,2.0,3.0,0.0,55.0
0.0,2.0,3.0,1.0,56.0
0.0,2.0,3.0,2.0,57.0
0.0,2.0,3.0,3.0,58.0
0.0,2.0,3.0,4.0,59.0
1.0,0.0,0.0,0.0,60.0
1.0,0.0,0.0,1.0,61.0
1.0,0.0,0.0,2.0,62.0
1.0,0.0,0.0,3.0,63.0
1.0,0.0,0.0,4.0,64.0
1.0,0.0,1.0,0.0,65.0
1.0,0.0,1.0,1.0,66.0
1.0,0.0,1.0,2.0,67.0
1.0,0.0,1.0,3.0,68.0
1.0,0.0,1.0,4.0,69.0
1.0,0.0,2.0,0.0,70.0
1.0,0.0,2.0,1.0,71.0
1.0,0.0,2.0,2.0,72.0
1.0,0.0,2.0,3.0,73.0
1.0,0.0,2.0,4.0,74.0
1.0,0.0,3.0,0.0,75.0
1.0,0.0,3.0,1.0,76.0
1.0,0.0,3.0,2.0,77.0
1.0,0.0,3.0,3.0,78.0
1.0,0.0,3.0,4.0,79.0
1.0,1.0,0.0,0.0,80.0
1.0,1.0,0.0,1.0,81.0
1.0,1.0,0.0,2.0,82.0
1.0,1.0,0.0,3.0,83.0
1.0,1.0,0.0,4.0,84.0
1.0,1.0,1.0,0.0,85.0
1.0,1.0,1.0,1.0,86.0
1.0,1.0,1.0,2.0,87.0
1.0,1.0,1.0,3.0,88.0
1.0,1.0,1.0,4.0,89.0
1.0,1.0,2.0,0.0,90.0
1.0,1.0,2.0,1.0,91.0
1.0,1.0,2.0,2.0,92.0
1.0,1.0,2.0,3.0,93.0
1.0,1.0,2.0,4.0,94.0
1.0,1.0,3.0,0.0,95.0
1.0,1.0,3.0,1.0,96.0
1.0,1.0,3.0,2.0,97.0
1.0,1.0,3.0,3.0,98.0
1.0,1.0,3.0,4.0,99.0
1.0,2.0,0.0,0.0,100.0
1.0,2.0,0.0,1.0,101.0
1.0,2.0,0.0,2.0,102.0
1.0,2.0,0.0,3.0,103.0
1.0,2.0,0.0,4.0,104.0
1.0,2.0,1.0,0.0,105.0
1.0,2.0,1.0,1.0,106.0
1.0,2.0,1.0,2.0,107.0
1.0,2.0,1.0,3.0,108.0
1.0,2.0,1.0,4.0,109.0
1.0,2.0,2.0,0.0,110.0
1.0,2.0,2.0,1.0,111.0
1.0,2.0,2.0,2.0,112.0
1.0,2.0,2.0,3.0,113.0
1.0,2.0,2.0,4.0,114.0
1.0,2.0,3.0,0.0,115.0
1.0,2.0,3.0,1.0,116.0
1.0,2.0,3.0,2.0,117.0
1.0,2.0,3.0,3.0,118.0
1.0,2.0,3.0,4.0,119.0
"""
        testfile = self.testfile = PseudoNetCDFFile()
        testfile.createDimension('time', 2)
        testfile.createDimension('layer', 3)
        testfile.createDimension('latitude', 4)
        testfile.createDimension('longitude', 5)
        for dk, dv in testfile.dimensions.items():
            var = testfile.createVariable(dk, 'f', (dk, ))
            var[:] = np.arange(len(dv), dtype='f')
        var = testfile.createVariable(
            'test', 'f', ('time', 'layer', 'latitude', 'longitude'))
        var[:] = np.arange(2 * 3 * 4 * 5).reshape(2, 3, 4, 5)
示例#4
0
            print(point, isin)

varkeys = ['temperature', 'windDir', 'windSpeed', 'dewpoint', 'altimeter']
vardds = [k + 'DD' for k in varkeys]

if args.verbose > 1:
    print('Subset variables')

getvarkeys = varkeys + vardds + \
    ['stationName', 'timeObs', 'timeNominal', 'elevation', 'latitude', 'longitude']

if args.verbose > 1:
    print('Slicing files')

p2p = Pseudo2NetCDF(verbose=0)
outfile = PseudoNetCDFFile()
p2p.addDimensions(ncff, outfile)
outfile.createDimension('recNum', len(found_point_ids))
p2p.addGlobalProperties(ncff, outfile)

for vark in getvarkeys:
    p2p.addVariable(ncff, outfile, vark, data=False)

for vark in getvarkeys:
    invar = ncff.variables[vark]
    outvar = outfile.variables[vark]
    recid = list(invar.dimensions).index('recNum')
    outvar[:] = invar[:].take(found_point_ids, recid)

if args.humidity:
    varkeys.append('specificHumidity')
示例#5
0
def mrgidx(ipr_paths, irr_paths, idx):
    if isinstance(irr_paths, str):
        irrf = NetCDFFile(irr_paths)
    else:
        irrf = file_master([NetCDFFile(irr_path) for irr_path in irr_paths])

    if isinstance(ipr_paths, str):
        iprf = NetCDFFile(ipr_paths)
    else:
        iprf = file_master([NetCDFFile(ipr_path) for ipr_path in ipr_paths])

    # Process and Reaction keys should exclude TFLAG
    pr_keys = [pr for pr in iprf.variables.keys() if pr not in ('TFLAG', )]
    rr_keys = [rr for rr in irrf.variables.keys() if rr not in ('TFLAG', )]

    # Attempt to order reactions by number
    # this is not necessary, but is nice and clean
    try:
        rr_keys = [(int(rr.split('_')[1]), rr) for rr in rr_keys]
        rr_keys.sort()
        rr_keys = [rr[1] for rr in rr_keys]
    except:
        warn("Cannot sort reaction keys")

    # Processes are predicated by a delimiter
    prcs = list(set(['_'.join(pr.split('_')[:-1]) for pr in pr_keys]))
    # Species are preceded by a delimiter
    spcs = list(set(['_'.join(pr.split('_')[-1:]) for pr in pr_keys]))

    # Select a dummy variable for extracting properties
    pr_tmp = iprf.variables[pr_keys[0]]

    # Create an empty file and decorate
    # it as necessary
    outf = PseudoNetCDFFile()
    outf.Species = "".join([spc.ljust(16) for spc in spcs])
    outf.Process = "".join([prc.ljust(16) for prc in prcs])
    outf.Reactions = "".join([rr_key.ljust(16) for rr_key in rr_keys])
    outf.createDimension("PROCESS", len(prcs))
    outf.createDimension("SPECIES", len(spcs))
    outf.createDimension("RXN", len(rr_keys))
    outf.createDimension("TSTEP", pr_tmp[:, 0, 0, 0].shape[0])
    outf.createDimension("TSTEP_STAG", len(outf.dimensions["TSTEP"]) + 1)
    outf.createDimension("ROW", 1)
    outf.createDimension("LAY", 1)
    outf.createDimension("COL", 1)
    outf.createDimension("VAR", 3)
    outf.createDimension("DATE-TIME", 2)
    tflag = outf.createVariable("TFLAG", "i", ('TSTEP', 'VAR', 'DATE-TIME'))
    tflag.__dict__.update(
        dict(units="<YYYYJJJ,HHDDMM>",
             var_desc='TFLAG'.ljust(16),
             long_name='TFLAG'.ljust(16)))
    tflag[:, :, :] = iprf.variables['TFLAG'][:][:, [0], :]
    shape = outf.createVariable("SHAPE", "i", ("TSTEP", "LAY", "ROW", "COL"))
    shape.__dict__.update(
        dict(units="ON/OFF",
             var_desc="SHAPE".ljust(16),
             long_name="SHAPE".ljust(16)))
    shape[:] = 1
    irr = outf.createVariable("IRR", "f", ("TSTEP", "RXN"))
    irr.__dict__.update(
        dict(units=pr_tmp.units,
             var_desc="IRR".ljust(16),
             long_name="IRR".ljust(16)))
    ipr = outf.createVariable("IPR", "f", ("TSTEP", "SPECIES", "PROCESS"))
    irr.__dict__.update(
        dict(units=pr_tmp.units,
             var_desc="IPR".ljust(16),
             long_name="IPR".ljust(16)))

    for rr, var in zip(rr_keys, irr.swapaxes(0, 1)):
        var[:] = irrf.variables[rr][:][idx]

    for prc, prcvar in zip(prcs, ipr.swapaxes(0, 2)):
        for spc, spcvar in zip(spcs, prcvar):
            try:
                spcvar[:] = iprf.variables['_'.join([prc, spc])][:][idx]
            except KeyError as es:
                warn(str(es))

    return outf
示例#6
0
    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