示例#1
0
def writeRec(fname, rec):
    """
    Write the record data along with grid info to file
    
    Args:
       fname  (str): Filename to to write to
       rec   (dict): Record meta + data + grid info to write
    Returns:
       None
    """
    print("+ Write %s to: %s" % (rec['nomvar'], fname))
            
    # Open File
    try:
        funit = rmn.fstopenall(fname, rmn.FST_RW)
    except:
        raise rmn.FSTDError("Problem Opening file: %s" % fname)
        
    # Write rec meta + data
    try:
        rmn.fstecr(funit,rec['d'],rec)
    except:
        raise rmn.FSTDError("Problem writing %s record" % rec['nomvar'])

    # Write grid (if need be)
    writeRecGrid(rec, funit, fname)
    
    # Close File
    rmn.fstcloseall(funit)
    
    return
示例#2
0
    def WriteFld(self, outfile, outrecord):
        filename = outfile
        if not os.path.isfile(filename):  # Check that the output file exists
            print 'The output file was not found:', filename
            quit()

        # Open the file
        if not rmn.isFST(
                filename
        ):  # Check that the output file is a standard format file
            raise rmn.FSTDError("Not an FSTD file: %s " % filename)
        try:  # Open the standard format file
            fstID = rmn.fstopenall(filename, rmn.FST_RW_OLD)
            print(fstID)
        except:
            raise rmn.FSTDError("File not found/readable: %s" % filename)

        # Write out the standard format record
        varname = outrecord['nomvar']
        try:
            rmn.fstecr(fstID, outrecord)
        except:
            raise rmn.FSTDError(
                "Problem writing the record " + varname +
                " to file: %s" % filename)  # Issue a warning message

        rmn.fstcloseall(fstID)  # Close the standard format file

        return
示例#3
0
    def test_fstlir_fstlirx_fstlir_witharray(self):
        """fstlir_fstlirx_fstlir_witharray should give known result with known input"""
        rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST)
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        myfile = os.path.join(ATM_MODEL_DFILES.strip(),'bcmk/2009042700_000')
        funit = rmn.fstopenall(myfile,rmn.FST_RO)

        k = rmn.fstinf(funit)['key']
        a = rmn.fstprm(k)
        self.assertEqual(a['nomvar'].strip(),'P0','fstinf/fstprm wrong rec, Got %s expected P0' % (a['nomvar']))
        k = rmn.fstsui(funit)['key']
        a = rmn.fstprm(k)
        self.assertEqual(a['nomvar'].strip(),'TT','fstsui/fstprm wrong rec, Got %s expected TT' % (a['nomvar']))

        k = rmn.fstinf(funit,nomvar='MX')['key']
        a = rmn.fstlir(funit)
        a = rmn.fstlir(funit,dataArray=a['d'])
        self.assertEqual(a['nomvar'].strip(),'P0','fstlir wrong rec, Got %s expected P0' % (a['nomvar']))
        self.assertEqual(int(np.amin(a['d'])),530)
        self.assertEqual(int(np.amax(a['d'])),1039)
  
        k = rmn.fstinf(funit,nomvar='MX')['key']
        a = rmn.fstlirx(k,funit,dataArray=a['d'])
        self.assertEqual(a['nomvar'].strip(),'LA','fstlirx wrong rec, Got %s expected P0' % (a['nomvar']))
        self.assertEqual(int(np.amin(a['d'])),-88)
        self.assertEqual(int(np.amax(a['d'])),88)

        a = rmn.fstlis(funit,dataArray=a['d'])
        self.assertEqual(a['nomvar'].strip(),'LO','fstlis wrong rec, Got %s expected P0' % (a['nomvar']))
        self.assertEqual(int(np.amin(a['d'])),-180)
        self.assertEqual(int(np.amax(a['d'])),178)

        rmn.fstcloseall(funit)
示例#4
0
 def test_openall_closeall_loop(self):
     """Test if close all on linked file actually close them all"""
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
     mydir = os.path.join(ATM_MODEL_DFILES.strip(),'bcmk/')
     for i in range(1000):
         funit = rmn.fstopenall(mydir)
         rmn.fstcloseall(funit)        
示例#5
0
 def _newReadBcmk(self):
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
     fileId = rmn.fstopenall(fileName, rmn.FST_RO)
     vgd0ptr = vgd.vgd_read(fileId)
     rmn.fstcloseall(fileId)
     return vgd0ptr
示例#6
0
    def test_fst_edit_dir_dateo(self):
        """Changing dateo with fst_edit_dir should update datev accordingly"""
        
        [ref_file, new_file] = self.copy_file()

        #Compare before
        [datev,  dateo,  deet,  npas]  = self.read_dateo_npas(ref_file,vname)
        [datev1, dateo1, deet1, npas1] = self.read_dateo_npas(new_file,vname)

        self.assertEqual(deet,deet1)
        self.assertEqual(npas,npas1)
        self.assertEqual(datev,datev1)
        self.assertEqual(dateo,dateo1)
        
        #Edit dateo in ref_file
        [datev,  dateo,  deet,  npas]  = self.read_dateo_npas(ref_file,vname)
        dateo2 = rmn.incdatr(dateo,1.)
        datev2 = rmn.incdatr(datev,1.)

        fnew = rmn.fstopenall(new_file, rmn.FST_RW)
        key  = rmn.fstinf(fnew, nomvar=vname)['key']
        rmn.fst_edit_dir(key, dateo=dateo2)
        rmn.fstcloseall(fnew)

        #Compare after
        [datev,  dateo,  deet,  npas]  = self.read_dateo_npas(ref_file,vname)
        [datev1, dateo1, deet1, npas1] = self.read_dateo_npas(new_file,vname)
        
        self.assertEqual(deet,deet1)
        self.assertEqual(npas,npas1)
        self.assertNotEqual(datev,datev1)
        self.assertEqual(datev2,datev1)
        self.assertNotEqual(dateo,dateo1)
        self.assertEqual(dateo2,dateo1)
示例#7
0
    def test_fstdread3d(self):
        """
        """
        import os, sys, datetime
        import rpnpy.librmn.all as rmn
        import rpnpy.utils.fstd3d as fstd3d
        fdate = datetime.date.today().strftime('%Y%m%d') + '00_048'
        CMCGRIDF = os.getenv('CMCGRIDF').strip()
        fileNameIn = os.path.join(CMCGRIDF, 'prog', 'regeta', fdate)

        # Restrict to the minimum the number of messages printed by librmn
        rmn.fstopt(rmn.FSTOP_MSGLVL, rmn.FSTOPI_MSG_CATAST)

        try:
            fileId = rmn.fstopenall(fileNameIn)
        except:
            sys.stderr.write("Problem opening the files: %s, %s\n" %
                             (fileNameIn, fileNameOut))
            sys.exit(1)

        try:
            rec3d = fstd3d.fst_read_3d(fileId,
                                       nomvar='TT',
                                       getPress=True,
                                       verbose=True)
        except:
            raise
        finally:
            # Properly close files even if an error occured above
            # This is important when editing to avoid corrupted files
            rmn.fstcloseall(fileId)
示例#8
0
    def test_1(self):
        """
        Open/Close File
        
        Note: The following constants may be used to set the file mode: rmn.FST_RW , rmn.FST_RW_OLD , rmn.FST_RO

        See also:
        rpnpy.librmn.fstd98.isFST
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.FSTDError
        rpnpy.librmn.RMNError
        rpnpy.librmn.const
        """
        import os
        import rpnpy.librmn.all as rmn

        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        fileName = os.path.join(ATM_MODEL_DFILES.strip(), 'bcmk/geophy.fst')

        if not rmn.isFST(fileName):
            raise rmn.FSTDError("Not an FSTD file: %s " % fileName)

        # Open
        try:
             fileId = rmn.fstopenall(fileName,rmn.FST_RO)
        except:
            raise rmn.FSTDError("File not found/readable: %s" % fileName)

        # ...

        # Close
        rmn.fstcloseall(fileId)        
示例#9
0
    def testDiag_withref8_3d(self):
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
        fileId = rmn.fstopenall(fileName, rmn.FST_RO)

        vgd0ptr = vgd.c_vgd_construct()
        ok = vgd.c_vgd_new_read(vgd0ptr,fileId,-1,-1,-1,-1)

        rfld_name = C_MKSTR(' '*vgd.VGD_MAXSTR_NOMVAR)
        quiet = ct.c_int(0)
        ok = vgd.c_vgd_get_char(vgd0ptr, _C_WCHAR2CHAR('RFLD'), rfld_name, quiet)

        rfld = rmn.fstlir(fileId, nomvar=_C_CHAR2WCHAR(rfld_name.value).strip())['d']
        MB2PA = 100.
        rfld = rfld * MB2PA

        rmn.fstcloseall(fileId)

        ip1list = ct.POINTER(ct.c_int)()
        nip1 = ct.c_int(0)
        quiet = ct.c_int(0)
        ok = vgd.c_vgd_get_int_1d(vgd0ptr, _C_WCHAR2CHAR('VIPM'), ct.byref(ip1list), ct.byref(nip1), quiet)

        ni = rfld.shape[0] ; nj = rfld.shape[1] ; in_log = 0
        levels8 = np.empty((ni, nj, nip1.value), dtype=np.float64, order='FORTRAN')
        rfld8 = np.empty((ni, nj), dtype=np.float64, order='FORTRAN')
        rfld8[:,:] = rfld[:,:]
        ok = vgd.c_vgd_diag_withref_8(vgd0ptr, ni, nj, nip1, ip1list, levels8, rfld8, in_log, vgd.VGD_DIAG_DPIS)
        self.assertEqual(ok,vgd.VGD_OK)
        self.assertEqual([int(x) for x in levels8[ni//2,nj//2,0:5]*10000.],
                         [100000, 138425, 176878, 241408, 305980])
示例#10
0
 def test_ezqkdef_file_ezgprm_ezgfstp(self):
     rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST)
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
     myfile = os.path.join(ATM_MODEL_DFILES.strip(),'bcmk/geophy.fst')
     funit = rmn.fstopenall(myfile,rmn.FST_RO)
     (ni,nj) = (201,100)
     gp = {
         'shape' : (ni,nj),
         'ni' : ni,
         'nj' : nj,
         'grtyp' : 'Z',
         'ig1'   : 2002,
         'ig2'   : 1000,
         'ig3'   : 0,
         'ig4'   : 0,
         'grref' : 'E',
         'ig1ref' : 900,
         'ig2ref' : 0,
         'ig3ref' : 43200,
         'ig4ref' : 43200,
         'iunit'  : funit
         }
     gid1 = rmn.ezqkdef(gp)
     a = rmn.ezgfstp(gid1)
     rmn.fstcloseall(funit)
     self.assertTrue(gid1>=0)
     gp['id'] = gid1
     gprm = rmn.ezgxprm(gid1)
     for k in gprm.keys():
         self.assertEqual(gp[k],gprm[k])
     self.assertEqual(a['nomvarx'].strip(),'>>')
     self.assertEqual(a['nomvary'].strip(),'^^')
     rmn.gdrls(gid1)
示例#11
0
 def test_23qd(self):
     import os, sys, datetime
     from scipy.constants import knot as KNOT2MS
     import numpy as np
     import rpnpy.librmn.all as rmn
     import rpnpy.vgd.all as vgd
     fdate = datetime.date.today().strftime('%Y%m%d') + '00_048'
     fileNameOut = 'uvfstfile.fst'
     fileIdIn = rmn.fstopenall(
         os.getenv('CMCGRIDF') + '/prog/regeta/' + fdate)
     fileIdOut = rmn.fstopenall(fileNameOut, rmn.FST_RW)
     vgd.vgd_write(vgd.vgd_read(fileIdIn), fileIdOut)
     (uu, vv, uvarray, copyGrid) = ({'d': None}, {'d': None}, None, True)
     for k in rmn.fstinl(fileIdIn, nomvar='UU'):
         uu = rmn.fstluk(k, dataArray=uu['d'])
         vv = rmn.fstlir(fileIdIn,
                         nomvar='VV',
                         ip1=uu['ip1'],
                         ip2=uu['ip2'],
                         datev=uu['datev'],
                         dataArray=vv['d'])
         if uvarray is None:
             uvarray = np.empty(uu['d'].shape,
                                dtype=uu['d'].dtype,
                                order='FORTRAN')
         uv = uu.copy()
         uv.update({'d': uvarray, 'nomvar': 'WSPD'})
         uv['d'][:, :] = np.sqrt(uu['d']**2. + vv['d']**2.) * KNOT2MS
         rmn.fstecr(fileIdOut, uv)
         if copyGrid:
             copyGrid = False
             rmn.writeGrid(fileIdOut, rmn.readGrid(fileIdIn, uu))
     rmn.fstcloseall(fileIdIn)
     rmn.fstcloseall(fileIdOut)
     os.unlink(fileNameOut)  # Remove test file
示例#12
0
def writeRec(fname, rec):
    """
    Write the record data along with grid info to file
    
    Args:
       fname  (str): Filename to to write to
       rec   (dict): Record meta + data + grid info to write
    Returns:
       None
    """
    print("+ Write %s to: %s" % (rec['nomvar'], fname))

    # Open File
    try:
        funit = rmn.fstopenall(fname, rmn.FST_RW)
    except:
        raise rmn.FSTDError("Problem Opening file: %s" % fname)

    # Write rec meta + data
    try:
        rmn.fstecr(funit, rec['d'], rec)
    except:
        raise rmn.FSTDError("Problem writing %s record" % rec['nomvar'])

    # Write grid (if need be)
    writeRecGrid(rec, funit, fname)

    # Close File
    rmn.fstcloseall(funit)

    return
示例#13
0
    def testDiag_withref8_3d(self):
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
        fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        
        vgd0ptr = vgd.c_vgd_construct()
        ok = vgd.c_vgd_new_read(vgd0ptr,fileId,-1,-1,-1,-1)

        rfld_name = C_MKSTR(' '*vgd.VGD_MAXSTR_NOMVAR)
        quiet = ct.c_int(0)
        ok = vgd.c_vgd_get_char(vgd0ptr, 'RFLD', rfld_name, quiet)

        rfld = rmn.fstlir(fileId, nomvar=rfld_name.value.strip())['d']
        MB2PA = 100.
        rfld = rfld * MB2PA
        
        rmn.fstcloseall(fileId)

        ip1list = ct.POINTER(ct.c_int)()
        nip1 = ct.c_int(0)
        quiet = ct.c_int(0)
        ok = vgd.c_vgd_get_int_1d(vgd0ptr, 'VIPM', ct.byref(ip1list), ct.byref(nip1), quiet)
        
        ni = rfld.shape[0] ; nj = rfld.shape[1] ; in_log = 0
        levels8 = np.empty((ni, nj, nip1.value), dtype=np.float64, order='FORTRAN')
        rfld8 = np.empty((ni, nj), dtype=np.float64, order='FORTRAN')
        rfld8[:,:] = rfld[:,:]
        ok = vgd.c_vgd_diag_withref_8(vgd0ptr, ni, nj, nip1, ip1list, levels8, rfld8, in_log, vgd.VGD_DIAG_DPIS)
        self.assertEqual(ok,vgd.VGD_OK)
        self.assertEqual([int(x) for x in levels8[ni//2,nj//2,0:5]*10000.],
                         [100000, 138425, 176878, 241408, 305980])
示例#14
0
    def test_fst_edit_dir_dateo(self):
        """Changing dateo with fst_edit_dir should update datev accordingly"""

        [ref_file, new_file] = self.copy_file()

        #Compare before
        [datev, dateo, deet, npas] = self.read_dateo_npas(ref_file, vname)
        [datev1, dateo1, deet1, npas1] = self.read_dateo_npas(new_file, vname)

        self.assertEqual(deet, deet1)
        self.assertEqual(npas, npas1)
        self.assertEqual(datev, datev1)
        self.assertEqual(dateo, dateo1)

        #Edit dateo in ref_file
        [datev, dateo, deet, npas] = self.read_dateo_npas(ref_file, vname)
        dateo2 = rmn.incdatr(dateo, 1.)
        datev2 = rmn.incdatr(datev, 1.)

        fnew = rmn.fstopenall(new_file, rmn.FST_RW)
        key = rmn.fstinf(fnew, nomvar=vname)['key']
        rmn.fst_edit_dir(key, dateo=dateo2)
        rmn.fstcloseall(fnew)

        #Compare after
        [datev, dateo, deet, npas] = self.read_dateo_npas(ref_file, vname)
        [datev1, dateo1, deet1, npas1] = self.read_dateo_npas(new_file, vname)

        self.assertEqual(deet, deet1)
        self.assertEqual(npas, npas1)
        self.assertNotEqual(datev, datev1)
        self.assertEqual(datev2, datev1)
        self.assertNotEqual(dateo, dateo1)
        self.assertEqual(dateo2, dateo1)
示例#15
0
    def test_fst_edit_dir_npas_keepdateo(self):
        """Changing npas with keepdate in fst_edit_dir should update datev accordingly"""
        
        [ref_file, new_file] = self.copy_file()

        #Compare before
        [datev,  dateo,  deet,  npas]  = self.read_dateo_npas(ref_file,vname)
        [datev1, dateo1, deet1, npas1] = self.read_dateo_npas(new_file,vname)

        self.assertEqual(deet,deet1)
        self.assertEqual(npas,npas1)
        self.assertEqual(datev,datev1)
        self.assertEqual(dateo,dateo1)
        
        #Edit npas in ref_file
        [datev,  dateo,  deet,  npas]  = self.read_dateo_npas(ref_file,vname)
        npas2 = npas+1
        dateo2 = dateo
        datev2 = rmn.incdatr(datev,deet/3600.)

        fnew = rmn.fstopenall(new_file, rmn.FST_RW)
        key  = rmn.fstinf(fnew, nomvar=vname)['key']
        rmn.fst_edit_dir(key, npas=npas2,keep_dateo=True)
        rmn.fstcloseall(fnew)

        #Compare after
        [datev,  dateo,  deet,  npas]  = self.read_dateo_npas(ref_file,vname)
        [datev1, dateo1, deet1, npas1] = self.read_dateo_npas(new_file,vname)
        
        self.assertEqual(deet,deet1)
        self.assertEqual(npas2,npas1)
        self.assertNotEqual(datev,datev1)
        self.assertEqual(datev2,datev1)
        self.assertEqual(dateo,dateo1)
        self.assertEqual(dateo2,dateo1)
示例#16
0
 def test_ezqkdef_file_ezgprm_ezgfstp(self):
     rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST)
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
     myfile = os.path.join(ATM_MODEL_DFILES.strip(),'bcmk/geophy.fst')
     funit = rmn.fstopenall(myfile,rmn.FST_RO)
     (ni,nj) = (201,100)
     gp = {
         'shape' : (ni,nj),
         'ni' : ni,
         'nj' : nj,
         'grtyp' : 'Z',
         'ig1'   : 2002,
         'ig2'   : 1000,
         'ig3'   : 0,
         'ig4'   : 0,
         'grref' : 'E',
         'ig1ref' : 900,
         'ig2ref' : 0,
         'ig3ref' : 43200,
         'ig4ref' : 43200,
         'iunit'  : funit
         }
     gid1 = rmn.ezqkdef(gp)
     a = rmn.ezgfstp(gid1)
     rmn.fstcloseall(funit)
     self.assertTrue(gid1>=0)
     gp['id'] = gid1
     gprm = rmn.ezgxprm(gid1)
     for k in gprm.keys():
         self.assertEqual(gp[k],gprm[k])
     self.assertEqual(a['nomvarx'].strip(),'>>')
     self.assertEqual(a['nomvary'].strip(),'^^')
     rmn.gdrls(gid1)
示例#17
0
    def test_fst_edit_dir_npas_keepdateo(self):
        """Changing npas with keepdate in fst_edit_dir should update datev accordingly"""

        [ref_file, new_file] = self.copy_file()

        #Compare before
        [datev, dateo, deet, npas] = self.read_dateo_npas(ref_file, vname)
        [datev1, dateo1, deet1, npas1] = self.read_dateo_npas(new_file, vname)

        self.assertEqual(deet, deet1)
        self.assertEqual(npas, npas1)
        self.assertEqual(datev, datev1)
        self.assertEqual(dateo, dateo1)

        #Edit npas in ref_file
        [datev, dateo, deet, npas] = self.read_dateo_npas(ref_file, vname)
        npas2 = npas + 1
        dateo2 = dateo
        datev2 = rmn.incdatr(datev, deet / 3600.)

        fnew = rmn.fstopenall(new_file, rmn.FST_RW)
        key = rmn.fstinf(fnew, nomvar=vname)['key']
        rmn.fst_edit_dir(key, npas=npas2, keep_dateo=True)
        rmn.fstcloseall(fnew)

        #Compare after
        [datev, dateo, deet, npas] = self.read_dateo_npas(ref_file, vname)
        [datev1, dateo1, deet1, npas1] = self.read_dateo_npas(new_file, vname)

        self.assertEqual(deet, deet1)
        self.assertEqual(npas2, npas1)
        self.assertNotEqual(datev, datev1)
        self.assertEqual(datev2, datev1)
        self.assertEqual(dateo, dateo1)
        self.assertEqual(dateo2, dateo1)
示例#18
0
    def testLevels8_prof(self):
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES, 'bcmk_toctoc',
                                '2009042700_000')
        fileId = rmn.fstopenall(fileName, rmn.FST_RO)

        vgd0ptr = vgd.c_vgd_construct()
        ok = vgd.c_vgd_new_read(vgd0ptr, fileId, -1, -1, -1, -1)

        rmn.fstcloseall(fileId)

        ip1list = ct.POINTER(ct.c_int)()
        nip1 = ct.c_int(0)
        quiet = ct.c_int(0)
        ok = vgd.c_vgd_get_int_1d(vgd0ptr, _C_WCHAR2CHAR('VIPM'),
                                  ct.byref(ip1list), ct.byref(nip1), quiet)

        MB2PA = 100.
        p0_stn_mb = 1013.
        p0_stn = np.empty((1, ), dtype=np.float64, order='FORTRAN')
        p0_stn[0] = p0_stn_mb * MB2PA

        prof8 = np.empty((nip1.value, ), dtype=np.float64, order='FORTRAN')

        ni = 1
        nj = 1
        in_log = 0
        ok = vgd.c_vgd_levels_8(vgd0ptr, ni, nj, nip1, ip1list, prof8, p0_stn,
                                in_log)
        self.assertEqual(ok, vgd.VGD_OK)
        self.assertEqual([int(x) for x in prof8[0:5] * 10000.],
                         [100000, 138426, 176879, 241410, 305984])
示例#19
0
 def test_openall_closeall_loop(self):
     """Test if close all on linked file actually close them all"""
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
     mydir = os.path.join(ATM_MODEL_DFILES.strip(), 'bcmk/')
     for i in range(1000):
         funit = rmn.fstopenall(mydir)
         rmn.fstcloseall(funit)
示例#20
0
    def test_14(self):
        """
        Queries: Get Vertical Grid Info

        This example shows how to get the vertical grid definition and print some info.

        See also:
        rpnpy.librmn.fstd98.fstopt
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.convertIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.vgd.base.vgd_read
        rpnpy.vgd.base.vgd_get
        rpnpy.librmn.const
        rpnpy.vgd.const
        """
        import os, sys, datetime
        import numpy as np
        import rpnpy.librmn.all as rmn
        import rpnpy.vgd.all as vgd

        # Restrict to the minimum the number of messages printed by librmn
        rmn.fstopt(rmn.FSTOP_MSGLVL, rmn.FSTOPI_MSG_CATAST)

        # Open file
        fdate = datetime.date.today().strftime('%Y%m%d') + '00_048'
        CMCGRIDF = os.getenv('CMCGRIDF').strip()
        fileName = os.path.join(CMCGRIDF, 'prog', 'regeta', fdate)
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            sys.stderr.write("Problem opening the file: %s\n" % fileName)
            sys.exit(1)

        try:
            # Get the vgrid definition present in the file
            v = vgd.vgd_read(fileId)

            # Get Some info about the vgrid
            vkind = vgd.vgd_get(v, 'KIND')
            vver = vgd.vgd_get(v, 'VERS')
            tlvl = vgd.vgd_get(v, 'VIPT')
            try:
                ip1diagt = vgd.vgd_get(v, 'DIPT')
            except:
                ip1diagt = 0
            (ldiagval, ldiagkind) = rmn.convertIp(rmn.CONVIP_DECODE, ip1diagt)
            VGD_KIND_VER_INV = dict(
                (v, k) for k, v in vgd.VGD_KIND_VER.items())
            vtype = VGD_KIND_VER_INV[(vkind, vver)]
            print(
                "CB14: Found vgrid type=%s (kind=%d, vers=%d) with %d levels and diag level=%7.2f%s (ip1=%d)"
                % (vtype, vkind, vver, len(tlvl), ldiagval,
                   rmn.kindToString(ldiagkind), ip1diagt))
        except:
            raise
        finally:
            # Close file even if an error occured above
            rmn.fstcloseall(fileId)
示例#21
0
    def test_fstdread3d(self):
        """
        """
        import os, sys, datetime
        import rpnpy.librmn.all as rmn
        import rpnpy.utils.fstd3d as fstd3d
        fdate       = datetime.date.today().strftime('%Y%m%d') + '00_048'
        CMCGRIDF    = os.getenv('CMCGRIDF').strip()
        fileNameIn  = os.path.join(CMCGRIDF, 'prog', 'regeta', fdate)

        # Restrict to the minimum the number of messages printed by librmn
        rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST)

        try:
            fileId = rmn.fstopenall(fileNameIn)
        except:
            sys.stderr.write("Problem opening the files: %s, %s\n" % (fileNameIn, fileNameOut))
            sys.exit(1)

        try:
            rec3d = fstd3d.fst_read_3d(fileId, nomvar='TT', getPress=True, verbose=True)
        except:
            raise
        finally:
            # Properly close files even if an error occured above
            # This is important when editing to avoid corrupted files
            rmn.fstcloseall(fileId)
示例#22
0
 def _newReadBcmk(self):
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
     fileId = rmn.fstopenall(fileName, rmn.FST_RO)
     vgd0ptr = vgd.vgd_read(fileId)
     rmn.fstcloseall(fileId)
     return vgd0ptr
示例#23
0
    def testLevels8_prof(self):
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
        fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        
        vgd0ptr = vgd.c_vgd_construct()
        ok = vgd.c_vgd_new_read(vgd0ptr,fileId,-1,-1,-1,-1)

        rmn.fstcloseall(fileId)

        ip1list = ct.POINTER(ct.c_int)()
        nip1 = ct.c_int(0)
        quiet = ct.c_int(0)
        ok = vgd.c_vgd_get_int_1d(vgd0ptr, 'VIPM', ct.byref(ip1list), ct.byref(nip1), quiet)

        MB2PA = 100.
        p0_stn_mb = 1013.
        p0_stn = np.empty((1,), dtype=np.float64, order='FORTRAN')
        p0_stn[0] = p0_stn_mb * MB2PA

        prof8 = np.empty((nip1.value,), dtype=np.float64, order='FORTRAN')

        ni = 1 ; nj = 1 ; in_log = 0
        ok = vgd.c_vgd_levels_8(vgd0ptr, ni, nj, nip1, ip1list, prof8, p0_stn, in_log);
        self.assertEqual(ok,vgd.VGD_OK)
        self.assertEqual([int(x) for x in prof8[0:5]*10000.],
                         [100000, 138426, 176879, 241410, 305984])
示例#24
0
 def test_14bqd(self):
     import os, sys, datetime
     import numpy as np
     import rpnpy.librmn.all as rmn
     import rpnpy.vgd.all as vgd
     rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST)
     fdate     = datetime.date.today().strftime('%Y%m%d') + '00_048'
     CMCGRIDF  = os.getenv('CMCGRIDF').strip()
     fileId = rmn.fstopenall(CMCGRIDF+'/prog/regpres/'+fdate, rmn.FST_RO)
     v = vgd.vgd_read(fileId)
     (tlvlkeys, rshape) = ([], None)
     for ip1 in vgd.vgd_get(v, 'VIPT'):
         (lval, lkind) = rmn.convertIp(rmn.CONVIP_DECODE, ip1)
         key = rmn.fstinf(fileId, nomvar='TT', ip2=48, ip1=rmn.ip1_all(lval, lkind))
         if key is not None: tlvlkeys.append((ip1, key['key']))
         if rshape is None and key is not None: rshape = key['shape']
     (r2d, r3d, k, rshape) = ({'d' : None}, None, 0, (rshape[0], rshape[1], len(tlvlkeys)))
     for ip1, key in tlvlkeys:
         r2d = rmn.fstluk(key, dataArray=r2d['d'])
         if r3d is None:
             r3d = r2d.copy()
             r3d['d'] = np.empty(rshape, dtype=r2d['d'].dtype, order='FORTRAN')
         r3d['d'][:,:,k] = r2d['d'][:,:]
     rmn.fstcloseall(fileId)
     r3d.update({'vgd':v, 'ip1list':[x[0] for x in tlvlkeys], 'shape':rshape, 'nk':rshape[2]})
     (i1, j1) = (rshape[0]//2, rshape[1]//2)
     print("CB14bqd: The TT profile at point (%d, %d) is:" % (i1, j1))
     for k in xrange(rshape[2]):
         (ldiagval, ldiagkind) = rmn.convertIp(rmn.CONVIP_DECODE, r3d['ip1list'][k])
         print("CB14bqd: TT(%d, %d, %7.2f %s) = %6.1f C [mean=%6.1f, std=%6.1f, min=%6.1f, max=%6.1f]" %
               (i1, j1, ldiagval, rmn.kindToString(ldiagkind), r3d['d'][i1,j1,k],
                r3d['d'][:,:,k].mean(), r3d['d'][:,:,k].std(), r3d['d'][:,:,k].min(), r3d['d'][:,:,k].max()))
示例#25
0
 def test_23qd(self):
     import os, sys, datetime
     from scipy.constants import knot as KNOT2MS
     import numpy as np
     import rpnpy.librmn.all as rmn
     import rpnpy.vgd.all as vgd
     fdate       = datetime.date.today().strftime('%Y%m%d') + '00_048'
     fileNameOut = 'uvfstfile.fst'
     fileIdIn    = rmn.fstopenall(os.getenv('CMCGRIDF')+'/prog/regeta/'+fdate)
     fileIdOut   = rmn.fstopenall(fileNameOut, rmn.FST_RW)
     vgd.vgd_write(vgd.vgd_read(fileIdIn), fileIdOut)
     (uu, vv, uvarray, copyGrid) = ({'d': None}, {'d': None}, None, True)
     for k in rmn.fstinl(fileIdIn, nomvar='UU'):
         uu = rmn.fstluk(k, dataArray=uu['d'])
         vv = rmn.fstlir(fileIdIn, nomvar='VV', ip1=uu['ip1'], ip2=uu['ip2'],
                         datev=uu['datev'],dataArray=vv['d'])
         if uvarray is None:
             uvarray = np.empty(uu['d'].shape, dtype=uu['d'].dtype, order='FORTRAN')
         uv = uu.copy()
         uv.update({'d':uvarray, 'nomvar': 'WSPD'})
         uv['d'][:,:] = np.sqrt(uu['d']**2. + vv['d']**2.) * KNOT2MS
         rmn.fstecr(fileIdOut, uv)
         if copyGrid:
             copyGrid = False
             rmn.writeGrid(fileIdOut, rmn.readGrid(fileIdIn, uu))
     rmn.fstcloseall(fileIdIn)
     rmn.fstcloseall(fileIdOut)
     os.unlink(fileNameOut)  # Remove test file
示例#26
0
    def test_1(self):
        """
        Open/Close File
        
        Note: The following constants may be used to set the file mode: rmn.FST_RW , rmn.FST_RW_OLD , rmn.FST_RO

        See also:
        rpnpy.librmn.fstd98.isFST
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.FSTDError
        rpnpy.librmn.RMNError
        rpnpy.librmn.const
        """
        import os
        import rpnpy.librmn.all as rmn

        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        fileName = os.path.join(ATM_MODEL_DFILES.strip(), 'bcmk/geophy.fst')

        if not rmn.isFST(fileName):
            raise rmn.FSTDError("Not an FSTD file: %s " % fileName)

        # Open
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            raise rmn.FSTDError("File not found/readable: %s" % fileName)

        # ...

        # Close
        rmn.fstcloseall(fileId)
示例#27
0
 def test_24qd(self):
     import os, sys
     import numpy as np
     import rpnpy.librmn.all as rmn
     import rpnpy.vgd.all as vgd
     g = rmn.defGrid_ZE(90, 45, 35., 250., 0.5, 0.5, 0., 180., 1., 270.)
     lvls = (500.,850.,1000.)
     v = vgd.vgd_new_pres(lvls)
     ip1list = vgd.vgd_get(v, 'VIPT')
     datyp   = rmn.FST_DATYP_LIST['float_IEEE_compressed']
     npdtype = rmn.dtype_fst2numpy(datyp)
     rshape  = (g['ni'], g['nj'], len(ip1list))
     r = rmn.FST_RDE_META_DEFAULT.copy()
     r.update(g)
     r.update({
         'nomvar': 'MASK',   'nk'    : len(ip1list),
         'dateo' : rmn.newdate(rmn.NEWDATE_PRINT2STAMP, 20160302, 1800000),
         'ip2'   : 6,        'deet'  : 3600, 'npas'  : 6,
         'etiket': 'my_etk', 'datyp' : datyp,
         'd'     : np.empty(rshape, dtype=npdtype, order='FORTRAN')
         })
     r['d'][:,:,:] = 0.
     r['d'][10:-11,5:-6,:] = 1.
     fileNameOut = 'newfromscratch.fst'
     fileIdOut = rmn.fstopenall(fileNameOut, rmn.FST_RW)
     r2d = r.copy()
     for k in range(len(ip1list)):
         r2d.update({'nk':1, 'ip1':ip1list[k], 'd':np.asfortranarray(r['d'][:,:,k])})
         rmn.fstecr(fileIdOut, r2d['d'], r2d)
     rmn.writeGrid(fileIdOut, g)
     vgd.vgd_write(v, fileIdOut)
     rmn.fstcloseall(fileIdOut)
     os.unlink(fileNameOut)  # Remove test file
示例#28
0
    def test_isfst_openall_fstnbr(self):
        """isfst_openall_fstnbr should give known result with known input"""
        rmn.fstopt(rmn.FSTOP_MSGLVL, rmn.FSTOPI_MSG_CATAST)
        ## rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST,rmn.FSTOP_GET)

        HOME = os.getenv('HOME')
        a = rmn.isFST(os.path.join(HOME.strip(), '.profile'))
        self.assertFalse(a, 'isFST should return false on non FST files')

        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        myfile = os.path.join(ATM_MODEL_DFILES.strip(), 'bcmk/2009042700_000')
        a = rmn.isFST(myfile)
        self.assertTrue(a, 'isFST should return true on FST files')

        funit = rmn.fstopenall(myfile, rmn.FST_RO)
        self.assertTrue(funit > 0,
                        'fstopenall should return a valid file unit')

        nrec = rmn.c_fstnbrv(funit)
        self.assertEqual(nrec, 1083, ' c_fstnbrv found %d/1083 rec ' % nrec)

        nrec = rmn.fstnbrv(funit)
        self.assertEqual(nrec, 1083, ' fstnbrv found %d/1083 rec ' % nrec)

        rmn.fstcloseall(funit)
示例#29
0
    def test_2(self):
        """
        Find Record / Get Metadata

        Most librmn FSTD functions are supported to look for records matching the provided selection criterion.
        Criteria not specified are not used for selection (wildcard).
        The fstprm function can then be used to get the record metadata.

        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinf
        rpnpy.librmn.fstd98.fstinfx
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstsui
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.FSTDError
        rpnpy.librmn.RMNError
        rpnpy.librmn.const
        """
        import os
        import rpnpy.librmn.all as rmn

        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        fileName = os.path.join(ATM_MODEL_DFILES.strip(),
                                'bcmk/2009042700_012')

        # Open
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            raise rmn.FSTDError("File not found/readable: %s" % fileName)

        # Find
        try:
            k1 = rmn.fstinf(fileId)[
                'key']  #No criterion, this match the first rec in the file
            pr_key = rmn.fstinf(
                fileId,
                nomvar='PR')['key']  #this match the first record named PR
            # pr_key2 = rmn.fstinfx(pr_key, fileId, nomvar='PR')['key']  #this would match the next  record named PR
        except:
            raise rmn.FSTDError("Problem searching in File: %s" % fileName)

        if not pr_key:
            raise rmn.FSTDError("Record not found in File: %s" % fileName)

        # Read Metadata
        try:
            pr_meta = rmn.fstprm(pr_key)
            for k in ('nomvar', 'dateo', 'npas'):
                print("%s = %s" % (k, str(pr_meta[k])))
        except:
            raise rmn.FSTDError("Error: Problem getting record metadata")

        # ...

        # Close
        rmn.fstcloseall(fileId)
示例#30
0
 def testNewRead(self):
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
     fileId = rmn.fstopenall(fileName, rmn.FST_RO)
     vgd0ptr = vgd.c_vgd_construct()
     ok = vgd.c_vgd_new_read(vgd0ptr,fileId,-1,-1,-1,-1)
     rmn.fstcloseall(fileId)
     self.assertEqual(ok,vgd.VGD_OK)
示例#31
0
 def test_openall_closeall_list(self):
     """Test if close all on linked file actually close them all"""
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
     mydir1 = os.path.join(ATM_MODEL_DFILES.strip(), 'bcmk/')
     mydir2 = os.path.join(ATM_MODEL_DFILES.strip(), 'bcmk_p/')
     funit1 = rmn.fstopenall(mydir1)
     funit2 = rmn.fstopenall(mydir2)
     rmn.fstcloseall((funit1, funit2))
示例#32
0
 def testNewRead(self):
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
     fileId = rmn.fstopenall(fileName, rmn.FST_RO)
     vgd0ptr = vgd.c_vgd_construct()
     ok = vgd.c_vgd_new_read(vgd0ptr,fileId,-1,-1,-1,-1)
     rmn.fstcloseall(fileId)
     self.assertEqual(ok,vgd.VGD_OK)
示例#33
0
    def test_6(self):
        """
        Write a record

        Starting from the read a record example above we can change the data and meta before writing
        it as another record in the same file or in another file.
        
        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinf
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.fstluk
        rpnpy.librmn.fstd98.fstlir
        rpnpy.librmn.fstd98.fstecr
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.FSTDError
        rpnpy.librmn.RMNError
        rpnpy.librmn.const
        """
        import os, os.path, sys
        import numpy as np
        import rpnpy.librmn.all as rmn

        # open input file and read PR record
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        fileName = os.path.join(ATM_MODEL_DFILES.strip(),
                                'bcmk/2009042700_012')
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            raise rmn.FSTDError("Problem opening File: %s" % fileName)
        try:
            pr_rec = rmn.fstlir(
                fileId, nomvar='PR')  # Read 1st record matching nomvar=PR
        except:
            sys.stdout.write("Problem reading record in File: %s" % fileName)
        finally:
            rmn.fstcloseall(fileId)

        # open output file and write record
        fileName = 'some_rpnstd_file.fst'
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RW)
        except:
            raise rmn.FSTDError("Problem opening File: %s" % fileName)
        try:
            pr_data = pr_rec['d']
            pr_data /= max(1.e-5, np.amax(pr_data))
            pr_rec['nomvar'] = 'PRN1'
            rmn.fstecr(fileId, pr_data, pr_rec)
        except:
            sys.stdout.write("Problem writing record in File: %s" % fileName)
        finally:
            rmn.fstcloseall(fileId)

        # Erase test file
        os.unlink(fileName)
示例#34
0
    def read_dateo_npas(self,fname,vname):
        'Read date of original analysis and time-step number'

        iunit = rmn.fstopenall(fname, rmn.FST_RO)
        key   = rmn.fstinf(iunit, nomvar=vname)['key']
        recmeta = rmn.fstprm(key)
        rmn.fstcloseall(iunit)

        return recmeta['datev'],recmeta['dateo'],recmeta['deet'],recmeta['npas']
示例#35
0
    def test_12(self):
        """
        Queries: Get Data and Meta

        This example shows how to
        * get the data of all records matching selection creterions
        * then print statistics

        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.fstluk
        rpnpy.librmn.fstd98.fstlir
        rpnpy.librmn.fstd98.DecodeIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.const
        """
        import os, sys
        import rpnpy.librmn.all as rmn

        # Restrict to the minimum the number of messages printed by librmn
        rmn.fstopt(rmn.FSTOP_MSGLVL, rmn.FSTOPI_MSG_CATAST)

        # Open all RPNStd files in the $ATM_MODEL_DFILES/bcmk/ directory
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES, 'bcmk')
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            sys.stderr.write("Problem opening the file: %s\n" % fileName)
            sys.exit(1)

        try:
            # Get the list of record keys matching nomvar='TT'
            keylist = rmn.fstinl(fileId, nomvar='TT', ip2=12)

            for k in keylist:

                # Get the record meta data
                r = rmn.fstluk(k)
                d = r['d']

                # Decode level info and Print statistics
                rp1 = rmn.DecodeIp(r['ip1'], r['ip2'], r['ip3'])[0]
                level = "%f %s" % (rp1.v1, rmn.kindToString(rp1.kind))

                print(
                    "CB12: %s (level=%s, ip2=%d) mean=%f, std=%f, min=%f, max=%f"
                    % (r['nomvar'], level, r['ip2'], d.mean(), d.std(),
                       d.min(), d.max()))
        except:
            pass
        finally:
            # Close file even if an error occured above
            rmn.fstcloseall(fileId)
示例#36
0
    def test_6(self):
        """
        Write a record

        Starting from the read a record example above we can change the data and meta before writing
        it as another record in the same file or in another file.
        
        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinf
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.fstluk
        rpnpy.librmn.fstd98.fstlir
        rpnpy.librmn.fstd98.fstecr
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.FSTDError
        rpnpy.librmn.RMNError
        rpnpy.librmn.const
        """
        import os, os.path, sys
        import numpy as np
        import rpnpy.librmn.all as rmn

        # open input file and read PR record
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        fileName  = os.path.join(ATM_MODEL_DFILES.strip(), 'bcmk/2009042700_012')
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            raise rmn.FSTDError("Problem opening File: %s" % fileName)
        try:
            pr_rec = rmn.fstlir(fileId, nomvar='PR')  # Read 1st record matching nomvar=PR
        except:
            sys.stdout.write("Problem reading record in File: %s" % fileName)
        finally:
            rmn.fstcloseall(fileId)

        # open output file and write record
        fileName  = 'some_rpnstd_file.fst'
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RW)
        except:
            raise rmn.FSTDError("Problem opening File: %s" % fileName)
        try:
            pr_data  = pr_rec['d']
            pr_data /= max(1.e-5, np.amax(pr_data))
            pr_rec['nomvar'] = 'PRN1'
            rmn.fstecr(fileId, pr_data, pr_rec)
        except:
            sys.stdout.write("Problem writing record in File: %s" % fileName)
        finally:
            rmn.fstcloseall(fileId)
            
        # Erase test file
        os.unlink(fileName)
示例#37
0
 def _newReadBcmk(self):
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
     fileId = rmn.fstopenall(fileName, rmn.FST_RO)
     vgd0ptr = vgd.c_vgd_construct()
     ok = vgd.c_vgd_new_read(vgd0ptr,fileId,-1,-1,-1,-1)
     ## vgd1ptr = vgd.c_vgd_construct()
     ## ok = vgd.c_vgd_new_read(vgd1ptr,fileId,-1,-1,-1,-1)
     rmn.fstcloseall(fileId)
     return vgd0ptr
示例#38
0
    def read_dateo_npas(self, fname, vname):
        'Read date of original analysis and time-step number'

        iunit = rmn.fstopenall(fname, rmn.FST_RO)
        key = rmn.fstinf(iunit, nomvar=vname)['key']
        recmeta = rmn.fstprm(key)
        rmn.fstcloseall(iunit)

        return recmeta['datev'], recmeta['dateo'], recmeta['deet'], recmeta[
            'npas']
示例#39
0
 def _newReadBcmk(self):
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
     fileId = rmn.fstopenall(fileName, rmn.FST_RO)
     vgd0ptr = vgd.c_vgd_construct()
     ok = vgd.c_vgd_new_read(vgd0ptr,fileId,-1,-1,-1,-1)
     ## vgd1ptr = vgd.c_vgd_construct()
     ## ok = vgd.c_vgd_new_read(vgd1ptr,fileId,-1,-1,-1,-1)
     rmn.fstcloseall(fileId)
     return vgd0ptr
示例#40
0
    def test_14(self):
        """
        Queries: Get Vertical Grid Info

        This example shows how to get the vertical grid definition and print some info.

        See also:
        rpnpy.librmn.fstd98.fstopt
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.convertIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.vgd.base.vgd_read
        rpnpy.vgd.base.vgd_get
        rpnpy.librmn.const
        rpnpy.vgd.const
        """
        import os, sys, datetime
        import numpy as np
        import rpnpy.librmn.all as rmn
        import rpnpy.vgd.all as vgd

        # Restrict to the minimum the number of messages printed by librmn
        rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST)

        # Open file
        fdate    = datetime.date.today().strftime('%Y%m%d') + '00_048'
        CMCGRIDF = os.getenv('CMCGRIDF').strip()
        fileName  = os.path.join(CMCGRIDF, 'prog', 'regpres', fdate)
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            sys.stderr.write("Problem opening the file: %s\n" % fileName)
            sys.exit(1)

        try:
            # Get the vgrid definition present in the file
            v = vgd.vgd_read(fileId)

            # Get Some info about the vgrid
            vkind    = vgd.vgd_get(v, 'KIND')
            vver     = vgd.vgd_get(v, 'VERS')
            ip1diagt = vgd.vgd_get(v, 'DIPT')
            tlvl     = vgd.vgd_get(v, 'VIPT')
            
            VGD_KIND_VER_INV = dict((v, k) for k, v in vgd.VGD_KIND_VER.iteritems())
            vtype = VGD_KIND_VER_INV[(vkind,vver)]
            (ldiagval, ldiagkind) = rmn.convertIp(rmn.CONVIP_DECODE, ip1diagt)
            print("CB14: Found vgrid type=%s (kind=%d, vers=%d) with %d levels and diag level=%7.2f%s (ip1=%d)" %
                (vtype, vkind, vver, len(tlvl), ldiagval, rmn.kindToString(ldiagkind), ip1diagt))
        except:
            raise
        finally:
            # Close file even if an error occured above
            rmn.fstcloseall(fileId)
示例#41
0
    def test_12(self):
        """
        Queries: Get Data and Meta

        This example shows how to
        * get the data of all records matching selection creterions
        * then print statistics

        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.fstluk
        rpnpy.librmn.fstd98.fstlir
        rpnpy.librmn.fstd98.DecodeIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.const
        """
        import os, sys
        import rpnpy.librmn.all as rmn

        # Restrict to the minimum the number of messages printed by librmn
        rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST)

        # Open all RPNStd files in the $ATM_MODEL_DFILES/bcmk/ directory
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES, 'bcmk')
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            sys.stderr.write("Problem opening the file: %s\n" % fileName)
            sys.exit(1)

        try:
            # Get the list of record keys matching nomvar='TT'
            keylist = rmn.fstinl(fileId, nomvar='TT', ip2=12)
            
            for k in keylist:
                
                # Get the record meta data
                r = rmn.fstluk(k)
                d = r['d']

                # Decode level info and Print statistics
                rp1 = rmn.DecodeIp(r['ip1'], r['ip2'], r['ip3'])[0]
                level  = "%f %s" % (rp1.v1, rmn.kindToString(rp1.kind))
                
                print("CB12: %s (level=%s, ip2=%d) mean=%f, std=%f, min=%f, max=%f" %
                      (r['nomvar'], level, r['ip2'], d.mean(), d.std(), d.min(), d.max()))
        except:
            pass
        finally:
            # Close file even if an error occured above
            rmn.fstcloseall(fileId)
示例#42
0
    def test_11(self):
        """
        Queries: Find records, Read meta
        
        This example shows how to
        * get the list of all records matching selection creterions
        * get the metadata and decode it
        * then print some values
        
        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.DecodeIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.librmn.base.newdate
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.const
        """
        import os, sys
        import rpnpy.librmn.all as rmn

        # Open all RPNStd files in the $ATM_MODEL_DFILES/bcmk/ directory
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES, 'bcmk')
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            sys.stderr.write("Problem opening the file: %s\n" % fileName)
            sys.exit(1)

        try:
            # Get the list of record keys matching nomvar='TT', ip2=12
            keylist = rmn.fstinl(fileId, nomvar='TT', ip2=12)

            for k in keylist:

                # Get the record meta data
                m = rmn.fstprm(k)

                # Decode ip1, and dateo
                (rp1, rp2, rp3) = rmn.DecodeIp(m['ip1'], m['ip2'], m['ip3'])
                level = "%f %s" % (rp1.v1, rmn.kindToString(rp1.kind))
                (yyyymmdd, hhmmsshh) = rmn.newdate(rmn.NEWDATE_STAMP2PRINT,
                                                   m['dateo'])
                dateo = "%8.8d.%8.8d" % (yyyymmdd, hhmmsshh)
                nhours = float(m['npas'] * m['deet']) / 3600.

                print("CB11: %s (%d, %d) level=%s, dateo=%s + %s" %
                      (m['nomvar'], m['ip1'], m['ip2'], level, dateo, nhours))
        except:
            pass
        finally:
            # Close file even if an error occured above
            rmn.fstcloseall(fileId)
示例#43
0
    def test_2(self):
        """
        Find Record / Get Metadata

        Most librmn FSTD functions are supported to look for records matching the provided selection criterion.
        Criteria not specified are not used for selection (wildcard).
        The fstprm function can then be used to get the record metadata.

        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinf
        rpnpy.librmn.fstd98.fstinfx
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstsui
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.FSTDError
        rpnpy.librmn.RMNError
        rpnpy.librmn.const
        """
        import os
        import rpnpy.librmn.all as rmn

        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        fileName = os.path.join(ATM_MODEL_DFILES.strip(), 'bcmk/2009042700_012')

        # Open
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            raise rmn.FSTDError("File not found/readable: %s" % fileName)

        # Find
        try:
            k1      = rmn.fstinf(fileId)['key']                    #No criterion, this match the first rec in the file
            pr_key  = rmn.fstinf(fileId, nomvar='PR')['key']       #this match the first record named PR
            # pr_key2 = rmn.fstinfx(pr_key, fileId, nomvar='PR')['key']  #this would match the next  record named PR
        except:
            raise rmn.FSTDError("Problem searching in File: %s" % fileName)

        if not pr_key:
            raise rmn.FSTDError("Record not found in File: %s" % fileName)

        # Read Metadata
        try:
            pr_meta = rmn.fstprm(pr_key)
            for k in ('nomvar', 'dateo', 'npas'):
                print("%s = %s" % (k, str(pr_meta[k])))
        except:
            raise rmn.FSTDError("Error: Problem getting record metadata")

        # ...

        # Close
        rmn.fstcloseall(fileId)
示例#44
0
 def test_11bqd(self):
     import os, sys
     import rpnpy.librmn.all as rmn
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileId = rmn.fstopenall(ATM_MODEL_DFILES+'/bcmk_p/anlp2015070706_000', rmn.FST_RO)
     for k in rmn.fstinl(fileId, nomvar='TT',
                         ip1=rmn.ip1_all(500., rmn.LEVEL_KIND_PMB),
                         datev=rmn.newdate(rmn.NEWDATE_PRINT2STAMP, 20150707, 6000000)):
             m = rmn.fstprm(k)
             print("CB11bqd: %s (%d, %d, %s)" % (m['nomvar'], m['ip1'], m['ip2'], m['datev']))
     rmn.fstcloseall(fileId)
示例#45
0
    def test_11b(self):
        """
        Queries: List/Find records

        This example shows how to
        * get the list of all records matching selection creterions
        * encode parameters (ip1, datev) values to use selection criteria
                
        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.ip1_all
        rpnpy.librmn.fstd98.ip2_all
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.DecodeIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.librmn.base.newdate
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.const
        """
        import os, sys
        import rpnpy.librmn.all as rmn

        # Open all RPNStd files in $ATM_MODEL_DFILES/bcmk_p/anlp2015070706_000
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES, 'bcmk_p',
                                'anlp2015070706_000')
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            sys.stderr.write("Problem opening the file: %s\n" % fileName)
            sys.exit(1)

        try:
            # Encode selection criteria
            ip1 = rmn.ip1_all(500., rmn.LEVEL_KIND_PMB)
            datev = rmn.newdate(rmn.NEWDATE_PRINT2STAMP, 20150707, 6000000)

            # Get the list of record keys matching
            # nomvar='TT' at 500mb and valide date=20150707.06000000
            keylist = rmn.fstinl(fileId, nomvar='TT', ip1=ip1, datev=datev)
            print("CB11b: Found %d records matching TT, ip1=%d, datev=%d" %
                  (len(keylist), ip1, datev))

            # Get every record meta data
            for k in keylist:
                m = rmn.fstprm(k)
                print("CB11b: %s (%d, %d, %s)" %
                      (m['nomvar'], m['ip1'], m['ip2'], m['datev']))
        except:
            pass
        finally:
            # Close file even if an error occured above
            rmn.fstcloseall(fileId)
示例#46
0
 def test_12qd(self):
     import os, sys
     import rpnpy.librmn.all as rmn
     rmn.fstopt(rmn.FSTOP_MSGLVL,rmn.FSTOPI_MSG_CATAST)
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileId = rmn.fstopenall(ATM_MODEL_DFILES+'/bcmk', rmn.FST_RO)
     for k in rmn.fstinl(fileId, nomvar='TT', ip2=2):
         r = rmn.fstluk(k)
         print("CB12qd: %s (ip1=%s, ip2=%d) mean=%f, std=%f, min=%f, max=%f" %
               (r['nomvar'], r['ip1'], r['ip2'], r['d'].mean(), r['d'].std(), r['d'].min(), r['d'].max()))
     rmn.fstcloseall(fileId)
示例#47
0
    def test_11(self):
        """
        Queries: Find records, Read meta
        
        This example shows how to
        * get the list of all records matching selection creterions
        * get the metadata and decode it
        * then print some values
        
        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.DecodeIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.librmn.base.newdate
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.const
        """
        import os, sys
        import rpnpy.librmn.all as rmn

        # Open all RPNStd files in the $ATM_MODEL_DFILES/bcmk/ directory
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES, 'bcmk')
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            sys.stderr.write("Problem opening the file: %s\n" % fileName)
            sys.exit(1)

        try:
            # Get the list of record keys matching nomvar='TT', ip2=12
            keylist = rmn.fstinl(fileId, nomvar='TT', ip2=12)
            
            for k in keylist:
                
                # Get the record meta data
                m = rmn.fstprm(k)

                # Decode ip1, and dateo
                (rp1, rp2, rp3) = rmn.DecodeIp(m['ip1'], m['ip2'], m['ip3'])
                level  = "%f %s" % (rp1.v1, rmn.kindToString(rp1.kind))
                (yyyymmdd,hhmmsshh) = rmn.newdate(rmn.NEWDATE_STAMP2PRINT,m['dateo'])
                dateo  = "%8.8d.%8.8d" % (yyyymmdd,hhmmsshh)
                nhours = float(m['npas'] * m['deet']) / 3600.
                
                print("CB11: %s (%d, %d) level=%s, dateo=%s + %s" %
                      (m['nomvar'], m['ip1'], m['ip2'], level, dateo, nhours))
        except:
            pass
        finally:
            # Close file even if an error occured above
            rmn.fstcloseall(fileId)
示例#48
0
    def test_22(self):
        """
        Edit: Copy records (a la editfst desire)

        This example shows how to
        * select records in a RPNStd file
        * read the record data + meta
        * write the record data + meta

        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.fsrinl
        rpnpy.librmn.fstd98.fsrluk
        rpnpy.librmn.fstd98.fsrecr
        rpnpy.librmn.const
        """
        import os, os.path, sys
        import rpnpy.librmn.all as rmn
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileNameIn = os.path.join(ATM_MODEL_DFILES, 'bcmk')
        fileNameOut = 'myfstfile.fst'

        # Open Files
        try:
            fileIdIn = rmn.fstopenall(fileNameIn)
            fileIdOut = rmn.fstopenall(fileNameOut, rmn.FST_RW)
        except:
            sys.stderr.write("Problem opening the files: %s, %s\n" %
                             (fileNameIn, fileNameOut))
            sys.exit(1)

        try:
            # Get the list of records to copy
            keylist1 = rmn.fstinl(fileIdIn, nomvar='UU')
            keylist2 = rmn.fstinl(fileIdIn, nomvar='VV')

            for k in keylist1 + keylist2:
                # Read record data and meta from fileNameIn
                r = rmn.fstluk(k)

                # Write the record to fileNameOut
                rmn.fstecr(fileIdOut, r)

                print("CB22: Copied %s ip1=%d, ip2=%d, dateo=%s" %
                      (r['nomvar'], r['ip1'], r['ip2'], r['dateo']))
        except:
            pass
        finally:
            # Properly close files even if an error occured above
            # This is important when editing to avoid corrupted files
            rmn.fstcloseall(fileIdIn)
            rmn.fstcloseall(fileIdOut)
            os.unlink(fileNameOut)  # Remove test file
示例#49
0
    def test_22(self):
        """
        Edit: Copy records (a la editfst desire)

        This example shows how to
        * select records in a RPNStd file
        * read the record data + meta
        * write the record data + meta

        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.fsrinl
        rpnpy.librmn.fstd98.fsrluk
        rpnpy.librmn.fstd98.fsrecr
        rpnpy.librmn.const
        """
        import os, os.path, sys
        import rpnpy.librmn.all as rmn
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileNameIn  = os.path.join(ATM_MODEL_DFILES,'bcmk')
        fileNameOut = 'myfstfile.fst'

        # Open Files
        try:
            fileIdIn  = rmn.fstopenall(fileNameIn)
            fileIdOut = rmn.fstopenall(fileNameOut, rmn.FST_RW)
        except:
            sys.stderr.write("Problem opening the files: %s, %s\n" % (fileNameIn, fileNameOut))
            sys.exit(1)

        try:
            # Get the list of records to copy
            keylist1 = rmn.fstinl(fileIdIn, nomvar='UU')
            keylist2 = rmn.fstinl(fileIdIn, nomvar='VV')

            for k in keylist1+keylist2:
                # Read record data and meta from fileNameIn
                r = rmn.fstluk(k)
                
                # Write the record to fileNameOut
                rmn.fstecr(fileIdOut, r)

                print("CB22: Copied %s ip1=%d, ip2=%d, dateo=%s" %
                      (r['nomvar'], r['ip1'], r['ip2'], r['dateo']))
        except:
            pass
        finally:
            # Properly close files even if an error occured above
            # This is important when editing to avoid corrupted files
            rmn.fstcloseall(fileIdIn)
            rmn.fstcloseall(fileIdOut)
            os.unlink(fileNameOut)  # Remove test file
示例#50
0
 def testDiag_withref8_3d(self):
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
     fileId = rmn.fstopenall(fileName, rmn.FST_RO)
     vgd0ptr = vgd.vgd_read(fileId)
     levels8 = vgd.vgd_levels(vgd0ptr, fileId, double_precision=True)
     rmn.fstcloseall(fileId)
     (ni,nj,nk) = levels8.shape
     self.assertEqual([int(x) for x in levels8[ni//2,nj//2,0:5]*10000.],
                      [100000, 138425, 176878, 241408, 305980])
     self.assertEqual(len(levels8.shape),3)
     self.assertEqual(levels8.dtype,np.float64)
示例#51
0
    def test_12(self):
        """
        Defining Grids

        Grids can be defined from
        * a record in a FSTD file or
        * directly by providing parameters.
        These grids parameters can be used to geolocate the data points and
        for interpolation operations (see below).

        See also:
        """
        import os
        import rpnpy.librmn.all as rmn

        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        fileName = os.path.join(ATM_MODEL_DFILES.strip(),
                                'bcmk/2009042700_012')

        # Define a grid from parameters, a cylindrical equidistant (LatLon) grid with 0.5 deg spacing.
        paramsL = {
            'grtyp': 'L',  # Cylindrical equidistant projection
            'ni': 90,  # Grid dimension: 90 by 45 points
            'nj': 45,
            'lat0':
            0.,  # Grid lower-left (south-west) corner (point 1,1) is located at 0N, 180E
            'lon0': 180.,
            'dlat':
            0.5,  # The grid has a resolution (grid spacing) of 0.5 deg. on both axes
            'dlon': 0.5
        }
        try:
            gridL = rmn.encodeGrid(paramsL)
        except:
            raise rmn.FSTDError(
                "Problem defining a grid with provided parameters: %s " %
                str(paramsL))

        # Get a grid definition from a record in a FSTD file
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
            prKey = rmn.fstinf(fileId, nomvar='PR')['key']
            prMeta = rmn.fstprm(
                prKey)  # Get the record metadata along with partial grid info
            prMeta['iunit'] = fileId
            prGrid0 = rmn.ezqkdef(
                prMeta)  # use ezscint to retreive full grid info
            prGrid = rmn.decodeGrid(
                prGrid0)  # Decode all the grid parameters values
            rmn.fstcloseall(fileId)
        except:
            raise rmn.FSTDError(
                "Problem getting PR record grid meta from file: %s" % fileName)
示例#52
0
 def test_22qd(self):
     import os, os.path
     import rpnpy.librmn.all as rmn
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileNameOut = 'myfstfile.fst'
     fileIdIn  = rmn.fstopenall(ATM_MODEL_DFILES+'/bcmk')
     fileIdOut = rmn.fstopenall(fileNameOut, rmn.FST_RW)
     for k in rmn.fstinl(fileIdIn, nomvar='UU') + rmn.fstinl(fileIdIn, nomvar='VV'):
         rmn.fstecr(fileIdOut, rmn.fstluk(k))
     rmn.fstcloseall(fileIdIn)
     rmn.fstcloseall(fileIdOut)
     os.unlink(fileNameOut)  # Remove test file
示例#53
0
 def testDiag_withref8_3d(self):
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName = os.path.join(ATM_MODEL_DFILES,'bcmk_toctoc','2009042700_000')
     fileId = rmn.fstopenall(fileName, rmn.FST_RO)
     vgd0ptr = vgd.vgd_read(fileId)
     levels8 = vgd.vgd_levels(vgd0ptr, fileId, double_precision=True)
     rmn.fstcloseall(fileId)
     (ni,nj,nk) = levels8.shape
     self.assertEqual([int(x) for x in levels8[ni//2,nj//2,0:5]*10000.],
                      [100000, 138425, 176878, 241408, 305980])
     self.assertEqual(len(levels8.shape),3)
     self.assertEqual(levels8.dtype,np.float64)
示例#54
0
    def test_11b(self):
        """
        Queries: List/Find records

        This example shows how to
        * get the list of all records matching selection creterions
        * encode parameters (ip1, datev) values to use selection criteria
                
        See also:
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.ip1_all
        rpnpy.librmn.fstd98.ip2_all
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.DecodeIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.librmn.base.newdate
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.const
        """
        import os, sys
        import rpnpy.librmn.all as rmn

        # Open all RPNStd files in $ATM_MODEL_DFILES/bcmk_p/anlp2015070706_000
        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
        fileName = os.path.join(ATM_MODEL_DFILES, 'bcmk_p','anlp2015070706_000')
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
        except:
            sys.stderr.write("Problem opening the file: %s\n" % fileName)
            sys.exit(1)

        try:
            # Encode selection criteria
            ip1   = rmn.ip1_all(500., rmn.LEVEL_KIND_PMB)
            datev = rmn.newdate(rmn.NEWDATE_PRINT2STAMP, 20150707, 6000000)

            # Get the list of record keys matching
            # nomvar='TT' at 500mb and valide date=20150707.06000000
            keylist = rmn.fstinl(fileId, nomvar='TT', ip1=ip1, datev=datev)
            print("CB11b: Found %d records matching TT, ip1=%d, datev=%d" %
                  (len(keylist), ip1, datev))

            # Get every record meta data
            for k in keylist:
                m = rmn.fstprm(k)
                print("CB11b: %s (%d, %d, %s)" % (m['nomvar'], m['ip1'], m['ip2'], m['datev']))
        except:
            pass
        finally:
            # Close file even if an error occured above
            rmn.fstcloseall(fileId)
示例#55
0
    def test_9(self):
        """
        Decoding values

        When reading an FSTD record metadata, the ip1, ip2, ip3 contains the encoded time and levels values.
        In the old format, ip1 is used for the level value and ip2 is a none encoded time value in hours.
        In the new format, all ip1, ip2, ip3 can be used to specify time and level as well as ranges.
        
        See also:
        rpnpy.librmn.fstd98.convertIp
        rpnpy.librmn.fstd98.convertIPtoPK
        rpnpy.librmn.fstd98.DecodeIp
        rpnpy.librmn.fstd98.kindToString
        rpnpy.librmn.proto.FLOAT_IP
        rpnpy.librmn.fstd98.fstopenall
        rpnpy.librmn.fstd98.fstinf
        rpnpy.librmn.fstd98.fstinl
        rpnpy.librmn.fstd98.fstprm
        rpnpy.librmn.fstd98.fstcloseall
        rpnpy.librmn.fstd98.FSTDError
        rpnpy.librmn.RMNError
        rpnpy.librmn.const
        """
        import os
        import rpnpy.librmn.all as rmn

        ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES')
        fileName = os.path.join(ATM_MODEL_DFILES.strip(),
                                'bcmk/2009042700_012')

        # Get list of records
        try:
            fileId = rmn.fstopenall(fileName, rmn.FST_RO)
            keyList = rmn.fstinl(fileId, nomvar='TT')
        except:
            raise rmn.FSTDError(
                "Problem getting list of TT records from file: %s" % fileName)

        # Get metadata and Decode level value
        try:
            for k in keyList:
                recMeta = rmn.fstprm(k)
                (level, ikind) = rmn.convertIp(rmn.CONVIP_DECODE,
                                               recMeta['ip1'])
                kindstring = rmn.kindToString(ikind)
                print("Found %s at level %f %s" %
                      (recMeta['nomvar'], level, kindstring))
        except:
            raise rmn.FSTDError(
                "Problem getting metadata for TT from file: %s " % fileName)

        rmn.fstcloseall(fileId)
示例#56
0
 def test_11qd(self):
     import os, sys
     import rpnpy.librmn.all as rmn
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileId = rmn.fstopenall(ATM_MODEL_DFILES+'/bcmk', rmn.FST_RO)
     for k in rmn.fstinl(fileId, nomvar='TT', ip2=12):
         m = rmn.fstprm(k)
         rp1 = rmn.DecodeIp(m['ip1'], m['ip2'], m['ip3'])[0]
         level  = "%f %s" % (rp1.v1, rmn.kindToString(rp1.kind))
         dateo  = "%8.8d.%8.8d" % rmn.newdate(rmn.NEWDATE_STAMP2PRINT,m['dateo'])
         print("CB11qd: %s (%d, %d) level=%s, dateo=%s + %s" %
               (m['nomvar'], m['ip1'], m['ip2'], level, dateo, float(m['npas'] * m['deet']) / 3600.))
     rmn.fstcloseall(fileId)
示例#57
0
 def test_21qd(self):
     import sys, os, os.path, stat, shutil
     import rpnpy.librmn.all as rmn
     fileName  = 'geophy.fst'
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName0 = os.path.join(ATM_MODEL_DFILES,'bcmk',fileName)
     shutil.copyfile(fileName0, fileName)
     st = os.stat(fileName)
     os.chmod(fileName, st.st_mode | stat.S_IWRITE)
     fileId = rmn.fstopenall(fileName, rmn.FST_RW_OLD)
     rmn.fst_edit_dir(rmn.fstinl(fileId), etiket='MY_NEW_ETK')
     rmn.fstcloseall(fileId)
     os.unlink(fileName)  # Remove test file
示例#58
0
 def test_12qd(self):
     import os, sys
     import rpnpy.librmn.all as rmn
     rmn.fstopt(rmn.FSTOP_MSGLVL, rmn.FSTOPI_MSG_CATAST)
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileId = rmn.fstopenall(ATM_MODEL_DFILES + '/bcmk', rmn.FST_RO)
     for k in rmn.fstinl(fileId, nomvar='TT', ip2=2):
         r = rmn.fstluk(k)
         print(
             "CB12qd: %s (ip1=%s, ip2=%d) mean=%f, std=%f, min=%f, max=%f" %
             (r['nomvar'], r['ip1'], r['ip2'], r['d'].mean(), r['d'].std(),
              r['d'].min(), r['d'].max()))
     rmn.fstcloseall(fileId)
示例#59
0
 def test_22qd(self):
     import os, os.path
     import rpnpy.librmn.all as rmn
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileNameOut = 'myfstfile.fst'
     fileIdIn = rmn.fstopenall(ATM_MODEL_DFILES + '/bcmk')
     fileIdOut = rmn.fstopenall(fileNameOut, rmn.FST_RW)
     for k in rmn.fstinl(fileIdIn, nomvar='UU') + rmn.fstinl(fileIdIn,
                                                             nomvar='VV'):
         rmn.fstecr(fileIdOut, rmn.fstluk(k))
     rmn.fstcloseall(fileIdIn)
     rmn.fstcloseall(fileIdOut)
     os.unlink(fileNameOut)  # Remove test file
示例#60
0
 def test_21qd(self):
     import sys, os, os.path, stat, shutil
     import rpnpy.librmn.all as rmn
     fileName = 'geophy.fst'
     ATM_MODEL_DFILES = os.getenv('ATM_MODEL_DFILES').strip()
     fileName0 = os.path.join(ATM_MODEL_DFILES, 'bcmk', fileName)
     shutil.copyfile(fileName0, fileName)
     st = os.stat(fileName)
     os.chmod(fileName, st.st_mode | stat.S_IWRITE)
     fileId = rmn.fstopenall(fileName, rmn.FST_RW_OLD)
     rmn.fst_edit_dir(rmn.fstinl(fileId), etiket='MY_NEW_ETK')
     rmn.fstcloseall(fileId)
     os.unlink(fileName)  # Remove test file