Changeset 366 for nappy


Ignore:
Timestamp:
15/08/05 10:09:38 (14 years ago)
Author:
astephen
Message:

Latest version - for compatibility with web service. Includes multiple file
output on conversion from NetCDF.

Location:
nappy/trunk
Files:
3 added
23 edited

Legend:

Unmodified
Added
Removed
  • nappy/trunk/bin/na2nc

    r349 r366  
    4646import cdmsMap 
    4747 
    48 def na2cdms(nafile, ncfile, time_units=None, rules=None): 
     48def na2cdms(nafile, ncfile, time_units=None, time_warning="yes", rename_variables={}, rules=None): 
    4949    print "Reading data from: %s" % nafile 
    5050    file=general.openNAFile(nafile) 
     51    if file.FFI in (2110, 2160, 2310):  
     52        print """\nERROR: Cannot convert NASA Ames File Format Index (FFI) %s to NetCDF.  
     53No mapping implemented yet.""" % file.FFI 
     54        return 0 
    5155 
    5256    print "Writing output NetCDF file: %s\n" % ncfile 
    53     file.toCdmsFile(ncfile, time_units=time_units) 
     57    file.toCdmsFile(ncfile, time_units=time_units, time_warning=time_warning, rename_variables=rename_variables) 
    5458     
    5559    print "\nNetCDF file written successfully: %s" % ncfile 
     
    6670         
    6771    time_units=None 
     72    time_warning="yes" 
     73    rename_variables={} 
     74     
    6875    for arg in args: 
    6976        if arg=="-i": 
     
    7380        elif arg=="-t": 
    7481            time_units=args[args.index(arg)+1] 
     82        elif arg=="-n": 
     83            time_warning="no" 
     84        elif arg=="-r": 
     85            renamer=args[args.index(arg)+1].split("=")       
     86            rename_variables[renamer[0]]=renamer[1] 
    7587 
    76     na2cdms(infile, outfile, time_units=time_units)  
     88    na2cdms(infile, outfile, time_units=time_units, time_warning=time_warning, rename_variables=rename_variables)  
    7789 
  • nappy/trunk/bin/nc2na

    r365 r366  
    1414===== 
    1515 
    16     nc2na [<options>] -i <infilename> -o <outfilename> 
     16    nc2na [-v <var_list>] [-j] [-f <float_format>] [-s <spacer>] [-e <ex_var_list>] [<overwrite_global_metadata>] -i <infilename> -o <outfilename> 
    1717 
    1818Where 
     
    2121    infilename  - name of input file (NetCDF). 
    2222    outfilename - name of output file (NASA Ames). 
     23    varlist     - a comma separated list of variables to include in the output file. 
     24    -j          - just display file names that would be produced - without creating files. 
     25    floatformat - a python formatting string such as %s or %5.2f 
     26    spacer      - the spacer you wish to use between data items in the output file such as "   " or "\t" 
    2327    options     - list of options [NOT YET IMPLEMENTED]. 
     28                -  "RDATE", "ANAME", "MNAME", 
     29           "ONAME", "ORG", "SNAME", "VNAME" 
    2430     
    2531""" 
     
    3339 
    3440    args=sys.argv[1:] 
     41 
     42    allowedOverwriteMetadata=["DATE",  "RDATE", "ANAME", "MNAME", 
     43           "ONAME", "ORG", "SNAME", "VNAME"]     
     44    variables=None 
     45     
    3546    if len(args)<4: 
    3647        print helpMessage 
    3748        print "Incorrect number of arguments used." 
    3849        sys.exit() 
    39          
     50 
     51    nFilesOnly="no" 
     52    spacer="    " 
     53    floatFormat="%8.3f"  
    4054    naVars={} 
    4155    for arg in args: 
     
    4458        elif arg=="-o": 
    4559            outfile=args[args.index(arg)+1] 
    46         elif arg=="-DATE": 
    47             naVars["DATE"]=args[args.index(arg)+1] 
     60        elif arg=="-f": 
     61            floatFormat=args[args.index(arg)+1] 
     62        elif arg=="-j": 
     63            nFilesOnly="yes" 
     64        elif arg=="-s": 
     65            spacer=args[args.index(arg)+1]           
     66        elif arg=="-f": 
     67            naVars["DATE"]=args[args.index(arg)+1]           
     68        elif arg[0]=="-" and arg[1:] in allowedOverwriteMetadata: 
     69            naVars[arg[1:]]=args[args.index(arg)+1] 
     70        elif arg in ("-v", "-vars", "-var", "-variables"): 
     71            variables=args[args.index(arg)+1].split(",") 
    4872 
    49     cdms2na(infile, outfile, naVars)  
     73    rtvalue=cdms2na(infile, outfile, naVars, variables, nFilesOnly, spacer=spacer, floatFormat=floatFormat)  
     74    if nFilesOnly=="yes": 
     75        print "\n\nOutput files would be:" 
     76        for file in rtvalue: 
     77            print file 
  • nappy/trunk/cdms2na.py

    r364 r366  
    174174 
    175175 
    176 def fixHeaderLength(file): 
     176def fixHeaderLengthNowDefunct(file): 
    177177    """ 
    178178    Fixes length of header. 
     
    196196 
    197197 
    198 def cdms2na(infilename, outfilename, naVars={}, variables=None, ffi="automatic", rules=None): 
     198def cdms2na(infilename, outfilenames, naVars={}, variables=None, nFilesOnly="no", ffi="automatic", spacer="    ", floatFormat="%8.3f", rules=None): 
    199199    """ 
    200200    Main conversion function that calls the appropriate classes and functions 
    201201    to write a NASA Ames file. 
    202202    """ 
    203     allowedOverwriteMetadata="DATE RDATE".split() 
     203    print infilename, outfilenames, nFilesOnly, naVars, variables 
     204    if type(outfilenames)==type(""): outfilenames=[outfilenames] 
    204205     
    205     print "Reading data from: %s" % infilename 
     206    allowedOverwriteMetadata=["DATE",  "RDATE", "ANAME", "MNAME", 
     207           "ONAME", "ORG", "SNAME", "VNAME"] 
     208    arrayArgs=["DATE", "RDATE", "ANAME", "VNAME"] 
     209    # ANAME[a] - array of 'a' x ANAME strings - aux var names 
     210    # DATE (array of three) - UT date at which the data within the file starts  
     211    # MNAME - mission name  
     212    # ONAME - name of originator(s)  
     213    # ORG - org or affiliation of originator(s)  
     214    # RDATE (array of three) - date of data reduction or revision  
     215    # SNAME - source of measurement or model output VNAME[n] - array of 'n' x  
     216    # VNAME strings - var names. 
     217    outputMessage=[] 
     218    msg="Reading data from: %s" % infilename 
     219    print msg 
     220    outputMessage.append(msg) 
    206221    cdmsfile=cdms.open(infilename) 
    207222    globals=cdmsfile.attributes 
     
    249264    while len(builder.varBin)>0: 
    250265        builder=CdmsToNABuilder(builder.varBin, globals) 
     266        outputMessage=outputMessage+builder.outputMessage 
    251267        builtNADicts.append([builder.naDict, builder.varIDs]) 
    252          
    253     print "%s files to write" % len(builtNADicts) 
     268 
     269    # Return only filenames if only want to know them now. 
     270    count=1     
     271    fileNames=[] 
     272    if nFilesOnly=="yes":  
     273        for i in builtNADicts: 
     274            if len(builtNADicts)==1: 
     275                suffix="" 
     276            else: 
     277                suffix="_%s" % count 
     278            nameparts=outfilenames[0].split(".")     
     279            newname=(".".join(nameparts[:-1]))+suffix+"."+nameparts[-1] 
     280            fileNames.append(newname) 
     281            count=count+1            
     282             
     283        return fileNames 
     284                 
     285    msg="%s files to write" % len(builtNADicts) 
     286    print msg 
     287    outputMessage.append(msg) 
    254288 
    255289    count=1 
    256290    for i in builtNADicts: 
    257         if len(builtNADicts)==1: 
    258             suffix="" 
     291        if len(outfilenames)==1: 
     292            if len(builtNADicts)==1: 
     293                suffix="" 
     294            else: 
     295                suffix="_%s" % count 
     296            nameparts=outfilenames[0].split(".")     
     297            newname=(".".join(nameparts[:-1]))+suffix+"."+nameparts[-1] 
    259298        else: 
    260             suffix="_%s" % count 
    261         nameparts=outfilename.split(".")     
    262         newname=(".".join(nameparts[:-1]))+suffix+"."+nameparts[-1] 
    263         print "\nWriting output NASA Ames file: %s" % newname 
     299            newname=outfilenames[count-1] 
     300  
     301        msg="\nWriting output NASA Ames file: %s" % newname 
     302        print msg 
     303        outputMessage.append(msg) 
     304         
    264305        builtNADict=i[0] 
    265306        for key in naVars.keys(): 
    266307            if key in allowedOverwriteMetadata: 
    267                 if type(builtNADict[key])==list: 
    268                     builtNADict[key]=naVars[key].split() 
     308             
     309                if key in arrayArgs: 
     310                    newItem=naVars[key].split()             
    269311                else: 
    270                     builtNADict[key]=naVars[key] 
    271                 print "Key replace in: ", key, builtNADict[key] 
    272         general.openNAFile(newname, 'w', builtNADict) 
    273         nlhead=fixHeaderLength(newname)   
    274         print "\nWrote the following variables to this file:" 
    275         print "\n\t"+("\n\t".join(i[1][0])) 
     312                    newItem=naVars[key] 
     313                                     
     314                if newItem!=builtNADict[key]: 
     315                    builtNADict[key]=newItem 
     316                    msg="Metadata overwritten in output file: '%s' is now '%s'" % (key, builtNADict[key]) 
     317                    print msg 
     318                    outputMessage.append(msg) 
     319                 
     320        general.openNAFile(newname, 'w', builtNADict, spacer=spacer, floatFormat=floatFormat) 
     321        #nlhead=fixHeaderLength(newname)   
     322        msg="\nWrote the following variables to this file:"+"\n\t"+("\n\t".join(i[1][0])) 
     323        print msg 
     324        outputMessage.append(msg) 
     325         
    276326        if len(i[1][1])>0: 
    277             print "\nWrote the following auxiliary variables to this file:" 
    278             print "\n\t"+("\n\t".join(i[1][1]))  
    279             print "\nNASA Ames file written successfully: %s" % newname 
     327            msg="\nWrote the following auxiliary variables to this file:" 
     328            msg=msg+"\n\t"+("\n\t".join(i[1][1]))        
     329            msg=msg+"\nNASA Ames file written successfully: %s" % newname 
     330            print msg 
     331            outputMessage.append(msg) 
    280332        count=count+1 
    281333               
    282     print "\n%s files written." % (count-1) 
     334    msg="\n%s files written." % (count-1) 
     335    print msg 
     336    outputMessage.append(msg) 
     337    return outputMessage 
    283338 
    284339 
     
    294349        generate sections of NASA Ames file object. 
    295350        """ 
     351        self.outputMessage=[] 
    296352        self.naDict={} 
    297353        self.vars=vars 
     
    299355        (self.orderedVars, auxVars)=self.analyseVariables() 
    300356        if self.orderedVars==None: 
    301             print "All variables located." 
     357            msg="All variables located." 
     358            print msg 
     359            outputMessage.append(msg) 
    302360            self.varBin=[] 
    303361        else: 
     
    333391        count=0 
    334392        for var in self.vars: 
    335             print "Analysing:", var.id 
     393            msg="Analysing: %s" % var.id 
     394            print msg 
     395            self.outputMessage.append(msg) 
    336396            count=count+1 
    337397            #print count 
     
    482542                else: 
    483543                    incr=self.ax0[1]-self.ax0[0] 
     544                    # Set default increment as gap between first two 
     545                    self.naDict["DX"]=[incr] 
     546                    # Now overwrite it as zero if non-uniform interval in axis 
    484547                    for i in range(1, len(self.ax0)): 
    485548                        if (self.ax0[i]-self.ax0[i-1])!=incr: 
    486549                            self.naDict["DX"]=[0] 
    487550                            break 
    488                     else: 
    489                         self.naDict["DX"]=[incr] 
     551 
    490552                # Now sort the rest of the axes 
    491553                for axis in var.getAxisList()[1:]: 
     
    525587        NASA Ames). 
    526588        """ 
    527         self.naDict["NX"].append(len(axis)) 
     589        length=len(axis) 
     590        self.naDict["NX"].append(length) 
    528591        self.naDict["XNAME"].append(getBestName(axis)) 
    529592        # If only one item in axis values 
    530         if len(axis)<3: 
     593        if length<2: 
    531594            self.naDict["DX"].append(0) 
    532             self.naDict["NXDEF"].append(len(axis)) 
     595            self.naDict["NXDEF"].append(length) 
    533596            self.naDict["X"].append(list(axis._data_))         
    534597            return 
    535598    
    536599        incr=axis[1]-axis[0] 
    537         for i in range(1, len(axis)): 
     600        for i in range(1, length): 
    538601            if (axis[i]-axis[i-1])!=incr: 
    539602                self.naDict["DX"].append(0) 
    540                 self.naDict["NXDEF"].append(len(axis)) 
     603                self.naDict["NXDEF"].append(length) 
    541604                self.naDict["X"].append(list(axis._data_)) 
    542605                break 
    543606        else: 
     607            maxLength=length 
     608            if length>3: maxLength=3 
    544609            self.naDict["DX"].append(incr) 
    545             self.naDict["NXDEF"].append(3) 
    546             self.naDict["X"].append(axis[:3]) 
     610            self.naDict["NXDEF"].append(maxLength) 
     611            self.naDict["X"].append(axis[:maxLength]) 
    547612        return 
    548613 
     
    742807                self.naDict["DATE"]=string.replace(str(first_day).split(" ")[0], "-", " ").split() 
    743808            except: 
    744                 print "Nappy Warning: Could not get the first date in the file. You will need to manually edit the output file." 
    745                 self.naDict["DATE"]="<DATE_UNKNOWN>" 
     809                msg="Nappy Warning: Could not get the first date in the file. You will need to manually edit the output file." 
     810                print msg 
     811                self.outputMessage.append(msg) 
     812                self.naDict["DATE"]=("DATE", "NOT", "KNOWN") 
    746813        else:  
    747814            if not self.naDict.has_key("DATE"): 
    748                 print "Nappy Warning: Could not get the first date in the file. You will need to manually edit the output file." 
    749                 self.naDict["DATE"]="<DATE_UNKNOWN>" 
     815                msg="Nappy Warning: Could not get the first date in the file. You will need to manually edit the output file." 
     816                print msg 
     817                self.outputMessage.append(msg) 
     818                self.naDict["DATE"]=("DATE", "NOT", "KNOWN") 
    750819        self.naDict["IVOL"]=1 
    751820        self.naDict["NVOL"]=1 
  • nappy/trunk/data_files/2010.na

    r360 r366  
    1 31  2010 
    2 Mertz, Fred 
    3 Pacific University 
    4 NMC analyzed grid data interpolated to DC-8 flight path 
    5 TAHITI OZONE PROJECT 
    6 1  1 
    7 1991 01 16   1991 01 16 
    8 0.0  30.0 
    9 8 
    10 8 
    11 250 200 150 100 70 50 30 10 
    12 Pressure levels (mb) 
    13 Time (UT seconds) from 00 hours on launch date 
    14 3 
    15 1.0   0.1  1.0E-09 
    16 99999 9999 9999999 
    17 Geopotential height (gpm) 
    18 Temperature (K) 
    19 Potential vorticity (K m**2/(kg s)) 
    20 2 
    21 1.0 0.1 
    22 99999 9999 
    23 Geopotential height (gpm) of the DC-8 
    24 Temperature (K) at DC-8's position 
     143  2010 
     2De Rudder, Anne 
     3Rutherford Appleton Laboratory, Chilton OX11 0QX, UK - Tel.: +44 (0) 1235 445837 
     4Anemometer measurements averaged over longitude 
     5NERC Data Grid (NDG) project 
     67  13 
     71969 01 01  2002 10 31 
     810  20 
     99 
     101 
    25110 
    26 5                   
    27 The geopotential height, temperature, and potential vorticity 
    28 values were interpolated from NMC analyses to a vertical cross- 
    29 section along the DC-8 flight path. 
    30 NOTE: PRELIMINARY data. 
    31         250mb   200mb   150mb   100mb    70mb    50mb    30mb    10mb 
    32         3350  1127 2682 
    33         9994   11395   13219   15762   17970   20000   23016   29411 
    34         2150    2154    2156    2115    2082    2042    1991    2021 
    35         4119    7050    8030   11300   16200   23500   50300  386000 
    36         3380  1289 2671 
    37         9992   11393   13217   15760   17968   19998   23013   29408 
    38         2151    2154    2156    2115    2081    2041    1990    2020 
    39         4128    7050    8040   11300   16200   23500   50400  386000 
    40         3410  1479 2653 
    41         9990   11392   13215   15759   17966   19996   23010   29404 
    42         2151    2154    2156    2115    2081    2041    1990    2020 
    43         4138    7060    8050   11400   16200   23500   50500  386000 
     12Latitude (degrees North) 
     13Altitude (km) 
     141 
     151 
     16200 
     17Mean zonal wind (m/s) 
     181 
     191 
     202000 
     21Pressure (hPa) 
     229 
     23Example of FFI 2010 (b). 
     24This example illustrating NASA Ames file format index 2010 is based on results 
     25from Murgatroyd (1969) as displayed in Brasseur and Solomon, Aeronomy of the 
     26Middle Atmosphere, Reidel, 1984 (p.36). It is representative of the mean zonal 
     27wind distribution in the winter hemisphere as a function of latitude and height. 
     28The first date on line 7 (1st of January 1969) is fictitious. 
     29From line 10 (NXDEF = 1) we know that the latitude points are defined by 
     30X(i) = X(1) + (i-1)DX1 for i = 1, ..., NX 
     31with X(1) = 0 deg (line 11), DX1 = 10 deg (line 8) and NX = 9 (line 9). 
     3211 
     33The files included in this data set illustrate each of the 9 NASA Ames file 
     34format indices (FFI). A detailed description of the NASA Ames format can be 
     35found on the Web site of the British Atmospheric Data Centre (BADC) at 
     36http://www.badc.rl.ac.uk/help/formats/NASA-Ames/ 
     37E-mail contact: badc@rl.ac.uk 
     38Reference: S. E. Gaines and R. S. Hipskind, Format Specification for Data 
     39Exchange, Version 1.3, 1998. This work can be found at 
     40http://cloud1.arc.nasa.gov/solve/archiv/archive.tutorial.html 
     41and a copy of it at 
     42http://www.badc.rl.ac.uk/help/formats/NASA-Ames/G-and-H-June-1998.html 
     43 
     44        0   1013.3 
     45     -3.0     -2.6     -2.3      2.0      4.8      4.6      4.5      3.0     -0.9 
     46       20    55.30 
     47    -15.1     -4.2      6.9     12.8     14.7     20.0     21.5     18.0      8.2 
     48       40     2.30 
     49    -29.0    -15.2      3.4     28.2     41.0     39.1     17.9      8.0      0.1 
     50       60     0.22 
     51    -10.0      8.4     31.2     59.9     78.5     77.7     47.0     17.6     16.0 
     52       80     0.01 
     53    200.0    200.0    200.0    200.0    200.0    200.0    200.0    200.0    200.0 
  • nappy/trunk/data_files/2010b.na

    r360 r366  
    1 43  2010 
    2 De Rudder, Anne 
    3 Rutherford Appleton Laboratory, Chilton OX11 0QX, UK - Tel.: +44 (0) 1235 445837 
    4 Anemometer measurements averaged over longitude 
    5 NERC Data Grid (NDG) project 
    6 7  13 
    7 1969 01 01  2002 10 31 
    8 10  20 
    9 9 
    10 1 
     131  2010 
     2Mertz, Fred 
     3Pacific University 
     4NMC analyzed grid data interpolated to DC-8 flight path 
     5TAHITI OZONE PROJECT 
     61  1 
     71991 01 16   1991 01 16 
     80.0  30.0 
     98 
     108 
     11250 200 150 100 70 50 30 10 
     12Pressure levels (mb) 
     13Time (UT seconds) from 00 hours on launch date 
     143 
     151.0   0.1  1.0E-09 
     1699999 9999 9999999 
     17Geopotential height (gpm) 
     18Temperature (K) 
     19Potential vorticity (K m**2/(kg s)) 
     202 
     211.0 0.1 
     2299999 9999 
     23Geopotential height (gpm) of the DC-8 
     24Temperature (K) at DC-8's position 
    11250 
    12 Latitude (degrees North) 
    13 Altitude (km) 
    14 1 
    15 1 
    16 200 
    17 Mean zonal wind (m/s) 
    18 1 
    19 1 
    20 2000 
    21 Pressure (hPa) 
    22 9 
    23 Example of FFI 2010 (b). 
    24 This example illustrating NASA Ames file format index 2010 is based on results 
    25 from Murgatroyd (1969) as displayed in Brasseur and Solomon, Aeronomy of the 
    26 Middle Atmosphere, Reidel, 1984 (p.36). It is representative of the mean zonal 
    27 wind distribution in the winter hemisphere as a function of latitude and height. 
    28 The first date on line 7 (1st of January 1969) is fictitious. 
    29 From line 10 (NXDEF = 1) we know that the latitude points are defined by 
    30 X(i) = X(1) + (i-1)DX1 for i = 1, ..., NX 
    31 with X(1) = 0 deg (line 11), DX1 = 10 deg (line 8) and NX = 9 (line 9). 
    32 11 
    33 The files included in this data set illustrate each of the 9 NASA Ames file 
    34 format indices (FFI). A detailed description of the NASA Ames format can be 
    35 found on the Web site of the British Atmospheric Data Centre (BADC) at 
    36 http://www.badc.rl.ac.uk/help/formats/NASA-Ames/ 
    37 E-mail contact: badc@rl.ac.uk 
    38 Reference: S. E. Gaines and R. S. Hipskind, Format Specification for Data 
    39 Exchange, Version 1.3, 1998. This work can be found at 
    40 http://cloud1.arc.nasa.gov/solve/archiv/archive.tutorial.html 
    41 and a copy of it at 
    42 http://www.badc.rl.ac.uk/help/formats/NASA-Ames/G-and-H-June-1998.html 
    43  
    44         0   1013.3 
    45      -3.0     -2.6     -2.3      2.0      4.8      4.6      4.5      3.0     -0.9 
    46        20    55.30 
    47     -15.1     -4.2      6.9     12.8     14.7     20.0     21.5     18.0      8.2 
    48        40     2.30 
    49     -29.0    -15.2      3.4     28.2     41.0     39.1     17.9      8.0      0.1 
    50        60     0.22 
    51     -10.0      8.4     31.2     59.9     78.5     77.7     47.0     17.6     16.0 
    52        80     0.01 
    53     200.0    200.0    200.0    200.0    200.0    200.0    200.0    200.0    200.0 
     265                   
     27The geopotential height, temperature, and potential vorticity 
     28values were interpolated from NMC analyses to a vertical cross- 
     29section along the DC-8 flight path. 
     30NOTE: PRELIMINARY data. 
     31        250mb   200mb   150mb   100mb    70mb    50mb    30mb    10mb 
     32        3350  1127 2682 
     33        9994   11395   13219   15762   17970   20000   23016   29411 
     34        2150    2154    2156    2115    2082    2042    1991    2021 
     35        4119    7050    8030   11300   16200   23500   50300  386000 
     36        3380  1289 2671 
     37        9992   11393   13217   15760   17968   19998   23013   29408 
     38        2151    2154    2156    2115    2081    2041    1990    2020 
     39        4128    7050    8040   11300   16200   23500   50400  386000 
     40        3410  1479 2653 
     41        9990   11392   13215   15759   17966   19996   23010   29404 
     42        2151    2154    2156    2115    2081    2041    1990    2020 
     43        4138    7060    8050   11400   16200   23500   50500  386000 
  • nappy/trunk/doc/USAGE.txt

    r356 r366  
    103103Inspect the data array ("V") in the NASA Ames dictionary: 
    104104 
    105 >>> print myfile.naDict["V"] 
     105>>> print myfile.naDict["V"} 
    106106[[[-3.0, -2.6000000000000001, -2.2999999999999998, 2.0, 4.7999999999999998, 4.5999999999999996, 4.5, 3.0, -0.90000000000000002], [-15.1, -4.2000000000000002, 6.9000000000000004, 12.800000000000001, 14.699999999999999, 20.0, 21.5, 18.0, 8.1999999999999993], [-29.0, -15.199999999999999, 3.3999999999999999, 28.199999999999999, 41.0, 39.100000000000001, 17.899999999999999, 8.0, 0.10000000000000001], [-10.0, 8.4000000000000004, 31.199999999999999, 59.899999999999999, 78.5, 77.700000000000003, 47.0, 17.600000000000001, 16.0], [200.0, 200.0, 200.0, 200.0, 200.0, 200.0, 200.0, 200.0, 200.0]]] 
    107107 
  • nappy/trunk/general.py

    r361 r366  
    9191 
    9292 
    93 def openNAFile(filename, mode="r", naDict=None): 
     93def openNAFile(filename, mode="r", naDict=None, spacer="    ", floatFormat="%8.3f"): 
    9494    """ 
    9595    Function wrapper around the NASA Ames File classes. Any NASA Ames 
     
    106106            FFI=chooseFFI(naDict) 
    107107            naDict['FFI']=FFI 
    108             print "\nFormat identified as:", FFI 
    109         return apply(classMap[FFI], (filename, mode, naDict)) 
     108            print "\nFormat identified as:", FFI     
     109        return apply(classMap[FFI], (filename, mode, naDict, spacer, floatFormat)) 
    110110    else: 
    111111        raise "File mode not recognised '%s'." % mode 
  • nappy/trunk/listManipulator.py

    r349 r366  
    1919    return RecursiveListManipulator().populator(inlist, array, dimlist) 
    2020 
    21 def recursiveListWriter(inlist, dimlist, floatFormat="%s"): 
     21 
     22def recursiveListWriter(inlist, dimlist, spacer="    ", floatFormat="%8.3f"): 
    2223    """ 
    2324    Function wrapper around class method RecursiveListManipulator().writeLines(). 
    2425    """ 
    25     return RecursiveListManipulator().writeLines(inlist, dimlist, floatFormat) 
     26    return RecursiveListManipulator().writeLines(inlist, dimlist, spacer=spacer, floatFormat=floatFormat) 
    2627 
    2728 
     
    5455        return inlist 
    5556 
    56     def writeLines(self, inlist, dimlist, floatFormat="%s"): 
     57    def writeLines(self, inlist, dimlist, spacer="    ", floatFormat="%8.3f"): 
    5758        """ 
    5859        Method to walk through all the levels of the multi-level list object 
     
    6465        if len(dimlist[1:])>0: 
    6566            for i in range(dimlist[0]): 
    66                 self.writeLines(inlist[i], dimlist[1:], floatFormat) 
     67                self.writeLines(inlist[i], dimlist[1:], spacer=spacer, floatFormat=floatFormat) 
    6768        else: 
    6869            var_string="" 
    6970            for i in range(dimlist[0]): 
    70                 var_string=var_string+((floatFormat+"    ") % inlist[i]) 
     71                var_string=var_string+((floatFormat+spacer) % inlist[i]) 
    7172            self.rtlines.append("%s\n" % var_string.rstrip()) 
    7273        return self.rtlines 
  • nappy/trunk/na2cdms.py

    r349 r366  
    5959 
    6060if __name__=="__main__": 
    61  
     61    print "I DON'T THINK THIS IS NEEDED, TRY bin/na2nc instead" 
     62    sys.exit() 
    6263    args=sys.argv[1:] 
    6364    if len(args)<4: 
  • nappy/trunk/naCore.py

    r349 r366  
    1818 
    1919class NACore: 
    20  
     20    """ 
     21    Abstract class to hold the empty NASA Ames contents and  
     22    a number of methods to access information in files. This 
     23    class is sub-classed by all NAFile classes. 
     24    """ 
     25     
    2126    pattnBrackets=re.compile("^\s*(.*)\((.+?)\)(.*)\s*$") 
    2227 
    2328    def __init__(self): 
     29        """ 
     30        Creates an instance variable of every type used in all 
     31        NA formats. All are set to None until/unless defined. 
     32        """ 
    2433 
    2534        self.A=None 
     
    5867        self.XNAME=None         
    5968 
     69 
    6070    def getNADict(self): 
     71        """ 
     72        Returns a dictionary of the contents of a NASA Ames file. 
     73        """ 
    6174        allNAVars={"A":self.A, "AMISS":self.AMISS, "ANAME":self.ANAME, 
    6275                     "ASCAL":self.ASCAL, "DATE":self.DATE, "DX":self.DX, 
     
    7790        return self.naDict 
    7891 
     92 
    7993    def __getitem__(self, item): 
    80         """Need to return whatever user wants and to translate 
     94        """ 
     95        Dictionary item access to NASA Ames contents, called NAFileObj['NIV'] 
     96        will return NAFileObj.NIV. 
     97         
     98        Note: In future this might return whatever user wants and to translate 
    8199        NASA Ames variables such as 'NIV' to explanatory strings 
    82100        such as 'number_of_independent_variables'. Need a map for 
    83         this defined at top of the nasaAmesData.py module""" 
     101        this defined at top of the nasaAmesData.py module 
     102        """ 
    84103        if hasattr(self, item): 
    85104            return getattr(self, item) 
     
    87106            return "Item '%s' not found." % item 
    88107 
    89     def getVariable(self, var_number):         
     108 
     109    def getVariable(self, var_number):  
     110        """ 
     111        Returns variable metadata corresponding to the var_number argument in the  
     112        list of varibles. Tuple of (variable_name, units, missing_value, scale_factor) 
     113        is returned. 
     114        """ 
    90115        match=NACore.pattnBrackets.match(self.VNAME[var_number]) 
    91116        if match: 
     
    98123        return (variable.strip(), units, miss, scale) 
    99124 
     125 
    100126    def getIndependentVariable(self, ivar_number): 
     127        """ 
     128        Returns an independent variable name and units in a tuple corresponding to 
     129        the ivar_number index in the list. 
     130        """ 
    101131        match=NACore.pattnBrackets.match(self.XNAME[ivar_number]) 
    102132        if match: 
     
    107137        return (variable.strip(), units) 
    108138 
     139 
    109140    def getAuxVariable(self, avar_number):         
     141        """ 
     142        Returns an auxiliary variable name and units in a tuple corresponding to 
     143        the ivar_number index in the list. 
     144        """ 
    110145        match=NACore.pattnBrackets.match(self.ANAME[avar_number]) 
    111146        if match: 
     
    118153        return (variable.strip(), units, miss, scale)     
    119154 
     155 
    120156    def getVariables(self): 
     157        """ 
     158        Returns metadata for all main (non-auxiliary or independent) variables. 
     159        """ 
    121160        vars=[] 
    122161        for i in range(self.NV): 
     
    125164 
    126165    def getIndependentVariables(self): 
     166        """ 
     167        Returns metadata for all independent variables. 
     168        """ 
    127169        ivars=[] 
    128170        for i in range(self.NIV): 
     
    131173 
    132174    def getAuxVariables(self): 
     175        """ 
     176        Returns metadata for all auxiliary variables. 
     177        """ 
    133178        avars=[] 
    134179        if not hasattr(self, "NAUXV"): 
     
    139184        return avars 
    140185 
     186 
    141187    def getMissingValue(self, var_number): 
     188        """ 
     189        Returns a missing value for a given variable. 
     190        """ 
    142191        return self.VMISS[var_number] 
    143192 
     193 
    144194    def getScaleFactor(self, var_number): 
     195        """ 
     196        Returns a scale factor for a given variable. 
     197        """ 
    145198        return self.VSCAL[var_number] 
     199         
    146200 
    147201    def getAuxMissingValue(self, avar_number): 
     202        """ 
     203        Returns the missing value of an auxiliary variable. 
     204        """ 
    148205        return self.AMISS[avar_number] 
    149206 
     207 
    150208    def getAuxScaleFactor(self, avar_number): 
     209        """ 
     210        Returns the scale factor of an auxiliary variable. 
     211        """  
    151212        return self.ASCAL[avar_number] 
    152213 
     214 
    153215    def getNumHeaderLines(self): 
     216        """ 
     217        Returns the number of header lines. 
     218        """ 
    154219        return self.NLHEAD 
    155220 
     221 
    156222    def getFFI(self): 
     223        """ 
     224        Returns the File Format Index for the file. 
     225        """ 
    157226        return self.FFI 
    158227 
     228 
    159229    def getOriginator(self): 
     230        """ 
     231        Returns the Originator (ONAME) string. 
     232        """ 
    160233        return self.ONAME 
    161234 
     235 
    162236    def getOrganisation(self): 
     237        """ 
     238        Returns the Organisation (ORG) string. 
     239        """ 
    163240        return self.ORG 
    164241 
     242 
    165243    def getOrg(self): 
     244        """ 
     245        Returns the Organisation (ORG) string. 
     246        """ 
    166247        return self.getOrganisation() 
    167248 
     249 
    168250    def getSource(self): 
     251        """ 
     252        Returns the Source (SOURCE) string. 
     253        """ 
    169254        return self.SNAME 
    170255 
     256 
    171257    def getMission(self): 
     258        """ 
     259        Returns the mission (MNAME) string.      
     260        """ 
    172261        return self.MNAME 
    173262 
     263 
    174264    def getVolumes(self): 
     265        """ 
     266        Returns the volume numbers (IVOL and NVOL). 
     267        """ 
    175268        return (self.IVOL, self.NVOL) 
    176269 
     270 
    177271    def getFileDates(self): 
     272        """ 
     273        Returns the first valid date in the data (DATE) and the  
     274        Revision Date (RDATE). 
     275        """ 
    178276        return (self.DATE, self.RDATE) 
    179277 
     278 
    180279    def getNormalComments(self): 
     280        """ 
     281        Returns the Normal Comment (NCOM) lines. 
     282        """ 
    181283        return self.NCOM 
    182284 
     285 
    183286    def getSpecialComments(self): 
     287        """ 
     288        Returns the Special Comments (SCOM) lines. 
     289        """ 
    184290        return self.SCOM 
    185291 
  • nappy/trunk/naFile.py

    r349 r366  
    1818import time 
    1919import re 
     20import StringIO 
    2021 
    2122# Imports from nappy package 
     
    5960        elif mode=="w": 
    6061            self._parseDictionary() 
     62            self.header=StringIO.StringIO() 
    6163            self.writeHeader() 
    6264            self.writeData() 
     
    138140        Writes the header section common to all NASA Ames files. 
    139141        """ 
    140         self.file.write("%s    %s\n" % (self.NLHEAD, self.FFI)) 
    141         self.file.write("%s\n" % self.ONAME) 
    142         self.file.write("%s\n" % self.ORG) 
    143         self.file.write("%s\n" % self.SNAME) 
    144         self.file.write("%s\n" % self.MNAME) 
    145         self.file.write("%s    %s\n" % (self.IVOL, self.NVOL)) 
    146         self.file.write("%s %s %s    %s %s %s\n" % (self.DATE[0], self.DATE[1], self.DATE[2], self.RDATE[0], self.RDATE[1], self.RDATE[2])) 
     142        self.header.write("%s    %s\n" % (self.NLHEAD, self.FFI)) 
     143        self.header.write("%s\n" % self.ONAME) 
     144        self.header.write("%s\n" % self.ORG) 
     145        self.header.write("%s\n" % self.SNAME) 
     146        self.header.write("%s\n" % self.MNAME) 
     147        self.header.write("%s    %s\n" % (self.IVOL, self.NVOL)) 
     148        self.header.write("%s %s %s    %s %s %s\n" % (self.DATE[0], self.DATE[1], self.DATE[2], self.RDATE[0], self.RDATE[1], self.RDATE[2])) 
    147149 
    148150    def _readVariablesHeaderSection(self): 
     
    161163        Assumes we are at the right point in the file. 
    162164        """         
    163         self.file.write("%s\n" % self.NV) 
    164         self.file.write(("%s "*self.NV+"\n") % tuple(self.VSCAL)) 
    165         self.file.write(("%s "*self.NV+"\n")  % tuple(self.VMISS)) 
    166         self.file.write("%s\n"*self.NV % tuple(self.VNAME)) 
     165        self.header.write("%s\n" % self.NV) 
     166        self.header.write(("%s "*self.NV+"\n") % tuple(self.VSCAL)) 
     167        self.header.write(("%s "*self.NV+"\n")  % tuple(self.VMISS)) 
     168        self.header.write("%s\n"*self.NV % tuple(self.VNAME)) 
    167169 
    168170    def _readAuxVariablesHeaderSection(self): 
     
    182184        Assumes we are at the right point in the file. 
    183185        """ 
    184         self.file.write("%s\n" % self.NAUXV) 
     186        self.header.write("%s\n" % self.NAUXV) 
    185187        if self.NAUXV>0: 
    186             self.file.write(("%s "*self.NAUXV+"\n")  % tuple(self.ASCAL)) 
    187             self.file.write(("%s "*self.NAUXV+"\n")  % tuple(self.AMISS)) 
    188             self.file.write("%s\n"*self.NAUXV % tuple(self.ANAME))                      #08/11/04 selatham 
     188            self.header.write(("%s "*self.NAUXV+"\n")  % tuple(self.ASCAL)) 
     189            self.header.write(("%s "*self.NAUXV+"\n")  % tuple(self.AMISS)) 
     190            self.header.write("%s\n"*self.NAUXV % tuple(self.ANAME))                    #08/11/04 selatham 
    189191 
    190192    def _readCharAuxVariablesHeaderSection(self): 
     
    220222        Assumes we are at the right point in the file. 
    221223        """   
    222         self.file.write("%s\n" % self.NSCOML) 
    223         self.file.write("%s\n"*self.NSCOML % tuple(self.SCOM)) 
    224         self.file.write("%s\n" % self.NNCOML) 
    225         self.file.write("%s\n"*self.NNCOML % tuple(self.NCOM)) 
     224        self.header.write("%s\n" % self.NSCOML) 
     225        self.header.write("%s\n"*self.NSCOML % tuple(self.SCOM)) 
     226        self.header.write("%s\n" % self.NNCOML) 
     227        self.header.write("%s\n"*self.NNCOML % tuple(self.NCOM)) 
     228 
     229    def _fixHeaderLength(self, header): 
     230        """ 
     231        Takes the header StringIO object and counts the number of lines to 
     232        return a list of lines with the correct number of header lines in  
     233        the top line. 
     234        """ 
     235        header.seek(0) 
     236        lines=header.readlines() 
     237        headlength=len(lines) 
     238        lines[0]="%s    %s\n" % (headlength, self.FFI) 
     239        return lines 
    226240 
    227241    def _readSpecialComments(self): 
  • nappy/trunk/naFile1001.py

    r349 r366  
    3838        """         
    3939        self._writeCommonHeader() 
    40         self.file.write(("%s "*self.NIV+"\n") % tuple(self.DX)) 
    41         self.file.write("%s\n"*self.NIV % tuple(self.XNAME)) 
     40        self.header.write(("%s "*self.NIV+"\n") % tuple(self.DX)) 
     41        self.header.write("%s\n"*self.NIV % tuple(self.XNAME)) 
    4242        self._writeVariablesHeaderSection() 
    4343        self._writeComments() 
     44        lines=self._fixHeaderLength(self.header) 
     45        self.file.writelines(lines) 
    4446 
    4547    def _setupArrays(self): 
  • nappy/trunk/naFile1010.py

    r349 r366  
    3737 
    3838    def writeHeader(self):                                                              #08/05/04 selatham 
    39          """                                                                                    #08/05/04 selatham 
    40          Writes FFI-specifc header section.                                     #08/05/04 selatham 
    41          """                                                                                    #08/05/04 selatham 
    42          self._writeCommonHeader()                                              #08/05/04 selatham 
    43          self.file.write(("%s "*self.NIV+"\n") % tuple(self.DX))                #08/05/04 selatham 
    44          self.file.write("%s\n"*self.NIV % tuple(self.XNAME))                   #08/05/04 selatham 
    45          self._writeVariablesHeaderSection()                                    #08/05/04 selatham 
    46          self._writeAuxVariablesHeaderSection()                                 #08/05/04 selatham 
    47          self._writeComments()                                                  #08/05/04 selatham 
     39        """                                                                                     #08/05/04 selatham 
     40        Writes FFI-specifc header section.                                      #08/05/04 selatham 
     41        """                                                                                     #08/05/04 selatham 
     42        self._writeCommonHeader()                                               #08/05/04 selatham 
     43        self.header.write(("%s "*self.NIV+"\n") % tuple(self.DX))               #08/05/04 selatham 
     44        self.header.write("%s\n"*self.NIV % tuple(self.XNAME))                  #08/05/04 selatham 
     45        self._writeVariablesHeaderSection()                                     #08/05/04 selatham 
     46        self._writeAuxVariablesHeaderSection()                                  #08/05/04 selatham 
     47        self._writeComments()                                                   #08/05/04 selatham 
     48        lines=self._fixHeaderLength(self.header) 
     49        self.file.writelines(lines)       
    4850 
    4951    def _setupArrays(self): 
  • nappy/trunk/naFile1020.py

    r358 r366  
    7070 
    7171    def writeHeader(self):                                                                              #18/11/04 selatham 
    72          """                                                                                                    #18/11/04 selatham 
    73          Writes FFI-specifc header section.                                                     #18/11/04 selatham 
    74          """                                                                                                    #18/11/04 selatham 
    75          self._writeCommonHeader()                                                              #18/11/04 selatham 
    76          self.file.write(("%s "*self.NIV+"\n") % tuple(self.DX))                                #18/11/04 selatham 
    77          self.file.write(("%s\n") %self.NVPM)                                                   #18/11/04 selatham 
    78          self.file.write("%s\n"*self.NIV % tuple(self.XNAME))                                   #18/11/04 selatham 
    79          self._writeVariablesHeaderSection()                                                    #18/11/04 selatham 
    80          self._writeAuxVariablesHeaderSection()                                                 #18/11/04 selatham 
    81          self._writeComments()                                                                  #18/11/04 selatham 
     72        """                                                                                                     #18/11/04 selatham 
     73        Writes FFI-specifc header section.                                                      #18/11/04 selatham 
     74        """                                                                                                     #18/11/04 selatham 
     75        self._writeCommonHeader()                                                               #18/11/04 selatham 
     76        self.header.write(("%s "*self.NIV+"\n") % tuple(self.DX))                               #18/11/04 selatham 
     77        self.header.write(("%s\n") %self.NVPM)                                                  #18/11/04 selatham 
     78        self.file.write("%s\n"*self.NIV % tuple(self.XNAME))                                    #18/11/04 selatham 
     79        self._writeVariablesHeaderSection()                                                     #18/11/04 selatham 
     80        self._writeAuxVariablesHeaderSection()                                                  #18/11/04 selatham 
     81        self._writeComments()                                                                   #18/11/04 selatham 
     82        lines=self._fixHeaderLength(self.header) 
     83        self.file.writelines(lines) 
    8284 
    8385    def writeData(self):                                                                                        #18/11/04 selatham 
  • nappy/trunk/naFile2010.py

    r360 r366  
    4040            self.X.append(readItemsFromUnknownLines(self.file, self.NXDEF[i], float)) 
    4141        # Unbounded Independent variable should be first so insert empty list at start 
     42        self.X.reverse()                   # Bug fix - Ag Stephens - 21/06/05 
    4243        self.X.insert(0, []) 
    4344        self.XNAME=readItemsFromLines(self._readLines(self.NIV), self.NIV, str) 
     
    5354        self._writeCommonHeader() 
    5455        self.DX.reverse() 
    55         self.file.write(("%s "*self.NIV+"\n") % tuple(self.DX)) 
     56        self.header.write(("%s "*self.NIV+"\n") % tuple(self.DX)) 
    5657        self.NX.reverse() 
    57         self.file.write(("%s "*(self.NIV-1)+"\n") % tuple(self.NX)) 
     58        self.header.write(("%s "*(self.NIV-1)+"\n") % tuple(self.NX)) 
    5859        self.NXDEF.reverse() 
    59         self.file.write(("%s "*(self.NIV-1)+"\n") % tuple(self.NXDEF)) 
     60        self.header.write(("%s "*(self.NIV-1)+"\n") % tuple(self.NXDEF)) 
    6061        self.NXDEF.reverse() 
    6162        X_lines=[] 
    6263        for i in range(self.NIV-1): 
    63             #print (self.floatFormat+self.spacer)*self.NXDEF[i]+"\n", self.NXDEF, self.X[i+1][0:self.NXDEF[i]] 
    6464            X_lines.append(((self.floatFormat+self.spacer)*self.NXDEF[i]+"\n") % tuple(self.X[i+1][0:self.NXDEF[i]])) 
    6565        X_lines.reverse() 
    6666        for line in X_lines: 
    67             self.file.write(line.lstrip()) 
     67            self.header.write(line.lstrip()) 
    6868        self.XNAME.reverse() 
    69         self.file.write("%s\n"*self.NIV % tuple(self.XNAME)) 
     69        self.header.write("%s\n"*self.NIV % tuple(self.XNAME)) 
    7070        self._writeVariablesHeaderSection() 
    7171        self._writeAuxVariablesHeaderSection() 
    7272        self._writeComments()          
     73        lines=self._fixHeaderLength(self.header) 
     74        self.file.writelines(lines) 
    7375 
    7476    def _setupArrays(self): 
     
    122124        for m in range(len(self.X[0])): 
    123125            # Write Independent variable mark and auxiliary variables 
    124             var_string="%s    " % self.X[0][m] 
     126            var_string=(self.floatFormat+self.spacer) % self.X[0][m] 
    125127            for a in range(self.NAUXV): 
    126                 var_string=var_string+("%s    " % self.A[a][m]) 
     128                var_string=var_string+((self.floatFormat+self.spacer) % self.A[a][m]) 
    127129            self.file.write("%s\n" % var_string.rstrip()) 
    128130            # Write Variables 
    129131            for n in range(self.NV): 
    130                 outlines=listManipulator.recursiveListWriter(self.V[n][m], self.NX, self.floatFormat) 
     132                outlines=listManipulator.recursiveListWriter(self.V[n][m], self.NX, spacer=self.spacer, floatFormat=self.floatFormat) 
    131133                for line in outlines: 
    132134                    self.file.write(line) 
  • nappy/trunk/naFile2110.py

    r361 r366  
    4242        self._writeCommonHeader() 
    4343        self.DX.reverse() 
    44         self.file.write(("%s "*self.NIV+"\n") % tuple(self.DX)) 
     44        self.header.write(("%s "*self.NIV+"\n") % tuple(self.DX)) 
    4545        self.XNAME.reverse() 
    46         self.file.write("%s\n"*self.NIV % tuple(self.XNAME)) 
     46        self.header.write("%s\n"*self.NIV % tuple(self.XNAME)) 
    4747        self._writeVariablesHeaderSection() 
    4848        self._writeAuxVariablesHeaderSection() 
    4949        self._writeComments() 
     50        lines=self._fixHeaderLength(self.header) 
     51        self.file.writelines(lines) 
    5052 
    5153    def _setupArrays(self): 
  • nappy/trunk/naFile2160.py

    r361 r366  
    4343        self._writeCommonHeader() 
    4444        self.DX.reverse() 
    45         self.file.write("%s\n" % tuple(self.DX)) 
    46         self.file.write("%s\n" % self.LENX) 
     45        self.header.write("%s\n" % tuple(self.DX)) 
     46        self.header.write("%s\n" % self.LENX) 
    4747        self.XNAME.reverse() 
    48         self.file.write("%s\n"*self.NIV % tuple(self.XNAME)) 
     48        self.header.write("%s\n"*self.NIV % tuple(self.XNAME)) 
    4949        self._writeVariablesHeaderSection() 
    5050        self._writeAuxVariablesHeaderSection() 
    5151        self._writeComments() 
     52        lines=self._fixHeaderLength(self.header) 
     53        self.file.writelines(lines)      
    5254 
    5355    def _writeAuxVariablesHeaderSection(self): 
     
    5658        Assumes we are at the right point in the file. 
    5759        """ 
    58         self.file.write("%s\n" % self.NAUXV) 
    59         self.file.write("%s\n" % self.NAUXC) 
     60        self.header.write("%s\n" % self.NAUXV) 
     61        self.header.write("%s\n" % self.NAUXC) 
    6062        if self.NAUXV>0: 
    61             self.file.write(("%s "*(self.NAUXV-self.NAUXC)+"\n")  % tuple(self.ASCAL)) 
    62             self.file.write(("%s "*(self.NAUXV-self.NAUXC)+"\n")  % tuple(self.AMISS[0:(self.NAUXV-self.NAUXC)])) 
    63             self.file.write(("%s "*self.NAUXC+"\n") % tuple(self.LENA[(self.NAUXV-self.NAUXC):])) 
    64             self.file.write(("%s\n"*self.NAUXC) % tuple(self.AMISS[(self.NAUXV-self.NAUXC):])) 
    65             self.file.write("%s\n"*self.NAUXV % tuple(self.ANAME)) 
     63            self.header.write(("%s "*(self.NAUXV-self.NAUXC)+"\n")  % tuple(self.ASCAL)) 
     64            self.header.write(("%s "*(self.NAUXV-self.NAUXC)+"\n")  % tuple(self.AMISS[0:(self.NAUXV-self.NAUXC)])) 
     65            self.header.write(("%s "*self.NAUXC+"\n") % tuple(self.LENA[(self.NAUXV-self.NAUXC):])) 
     66            self.header.write(("%s\n"*self.NAUXC) % tuple(self.AMISS[(self.NAUXV-self.NAUXC):])) 
     67            self.header.write("%s\n"*self.NAUXV % tuple(self.ANAME)) 
    6668 
    6769    def _setupArrays(self): 
  • nappy/trunk/naFile2310.py

    r361 r366  
    4242        self._writeCommonHeader() 
    4343        #self.DX.reverse() 
    44         self.file.write(("%s\n") % self.DX[0]) 
     44        self.header.write(("%s\n") % self.DX[0]) 
    4545        self.XNAME.reverse() 
    46         self.file.write("%s\n"*self.NIV % tuple(self.XNAME)) 
     46        self.header.write("%s\n"*self.NIV % tuple(self.XNAME)) 
    4747        self._writeVariablesHeaderSection() 
    4848        self._writeAuxVariablesHeaderSection() 
    4949        self._writeComments() 
     50        lines=self._fixHeaderLength(self.header) 
     51        self.file.writelines(lines) 
    5052 
    5153    def _readData1(self, datalines, ivar_count): 
  • nappy/trunk/naToCdms.py

    r351 r366  
    3535 
    3636# Define global variables 
    37 safe_nc_id=re.compile("[\s\[()\]=+-?#~@&$%!*{}\^]+") 
     37safe_nc_id=re.compile("[\s\[\(\)\]\=\+\-\?\#\~\@\&\$\%\!\*\{\}\^]+") 
     38 
    3839time_units_pattn=re.compile("\w+\s+since\s+\d{4}-\d{1,2}-\d{1,2}\s+\d+:\d+:\d+") 
    3940 
    4041class NAToCdms: 
    41  
    42     def toCdmsFile(self, filename, time_units=None, variables="all", aux_variable="all", global_attributes={"Conventions":"CF-1.0"}, ffi=None): 
     42    """ 
     43    Abstract class inherited by standard NAFile classes for mapping of 
     44    NASA Ames to CDMS-type files. 
     45    """ 
     46     
     47    def toCdmsFile(self, filename, time_units=None, time_warning="yes", variables="all", \ 
     48                   aux_variables="all", global_attributes={"Conventions":"CF-1.0"}, \ 
     49                   rename_variables={}, ffi=None): 
     50        """ 
     51        Main method for writing the existing NASA Ames dictionary out 
     52        to a CDMS (NetCDF) file. 
     53        """ 
     54        self.outputMessage=[]  # for output printing message 
     55        if self.FFI in (2110, 2160, 2310):  
     56            msg="""ERROR: Cannot convert NASA Ames File Format Index (FFI) %s to NetCDF.  
     57No mapping implemented yet.""" % self.FFI 
     58            print msg 
     59            self.outputMessage.append(msg) 
     60            sys.exit() 
     61             
     62        print "V:", variables 
     63        #print "A:", aux_variables 
     64        #print "TW:", time_warning 
     65        self.variables=variables 
     66        self.aux_variables=aux_variables 
     67        self.time_warning=time_warning 
     68        self.rename_variables=rename_variables 
     69        # Modify self.rename_variables to give users a chance 
     70        #for key in self.rename_variables.keys(): 
     71        #    value=self.rename_variables[key] 
     72        #    match=re.search(r"^(.*)\s+\([^\)]+\)$", value) 
     73        #    if match: 
     74        #        self.rename_variables[key]=match.groups()[0] 
     75        # 
     76         
    4377        if sys.platform.find("win")>-1: 
    4478            raise NAPlatformError 
     
    102136 
    103137        # Then do auxiliary variables 
    104         if hasattr(self, "NAUXV") and type(self.NAUXV)==int:   # Are there any auxiliary variables? 
     138        if hasattr(self, "NAUXV") and (type(self.NAUXV)==type(1) and self.NAUXV>0):   # Are there any auxiliary variables? 
    105139            if not hasattr(self, 'cdmsAuxVariables'):  self.createCdmsAuxVariables() 
    106140            for avar in self.cdmsAuxVariables: 
     
    111145 
    112146    def createCdmsVariables(self): 
     147        """ 
     148        Creates cdms variable list for writing out. 
     149        """ 
    113150        self.cdmsVariables=[] 
    114         for var_number in range(self.NV): 
    115             self.cdmsVariables.append(self.toCdmsVariable(var_number)) 
     151        if self.variables=="all":     
     152            for var_number in range(self.NV): 
     153                self.cdmsVariables.append(self.toCdmsVariable(var_number)) 
     154        else: 
     155            if type(self.variables[0])==type(1): # They are integers = indices 
     156                for var_number in self.variables: 
     157                    self.cdmsVariables.append(self.toCdmsVariable(var_number))    
     158            elif type(self.variables[0])==type(""): 
     159                for var_name in self.variables: 
     160                    if var_name in self.VNAME: 
     161                        var_number=self.VNAME.index(var_name) 
     162                        self.cdmsVariables.append(self.toCdmsVariable(var_number)) 
     163                    else: 
     164                        raise "Variable name not known: "+var_name 
    116165 
    117166 
    118167    def toCdmsVariable(self, var_number, attributes={}): 
     168        """ 
     169        Creates a single cdms variable from the variable number provided in the list. 
     170        """ 
    119171        if sys.platform.find("win")>-1: 
    120172            raise NAPlatformError 
    121173        (varname, units, miss, scal)=self.getVariable(var_number) 
    122         print self.V 
     174        #print self.V 
     175        msg="\nAdding variable: %s" % self.VNAME[var_number] 
     176        print msg 
     177        self.outputMessage.append(msg) 
    123178        array=Numeric.array(self.V[var_number]) 
    124179        array=array*scal 
     
    134189         
    135190        # Add the best variable name 
    136         if len(varname)<20: 
     191        if len(varname)<40: 
    137192            var.id=safe_nc_id.sub("_", varname).lower() 
    138193        else: 
    139194            var.id="naVariable_%s" % (var_number) 
    140  
    141         var.long_name=var.name=varname 
     195         
     196        # Check if user wants to rename this variable 
     197        #print self.rename_variables, "3"*200 
     198        #if varname in self.rename_variables.keys(): 
     199        #    varname=self.rename_variables[varname] 
     200             
     201        var.long_name=var.name=var.title=varname 
    142202 
    143203        # If we have a standard name list then compare to it 
     
    151211 
    152212    def createCdmsAuxVariables(self): 
     213        """ 
     214        Creates a cdms variable from an auxiliary variable 
     215        """ 
    153216        self.cdmsAuxVariables=[] 
    154         for avar_number in range(self.NAUXV): 
    155             self.cdmsAuxVariables.append(self.auxToCdmsVariable(avar_number)) 
     217 
     218        if self.aux_variables=="all":     
     219            for avar_number in range(self.NAUXV): 
     220                self.cdmsAuxVariables.append(self.auxToCdmsVariable(avar_number)) 
     221        else: 
     222            if type(self.aux_variables[0])==type(1): # They are integers = indices 
     223                for avar_number in self.aux_variables: 
     224                    self.cdmsAuxVariables.append(self.auxToCdmsVariable(avar_number))    
     225            elif type(self.aux_variables[0])==type(""): 
     226                for avar_name in self.aux_variables: 
     227                    if avar_name in self.ANAME: 
     228                        avar_number=self.ANAME.index(avar_name) 
     229                        self.cdmsAuxVariables.append(self.auxToCdmsVariable(avar_number))  
     230                    else: 
     231                        raise "Auxiliary variable name not known: "+avar_name        
    156232 
    157233    def auxToCdmsVariable(self, avar_number, attributes={}): 
     234        """ 
     235        Converts an auxiliary variable to a cdms variable. 
     236        """ 
    158237        if sys.platform.find("win")>-1: 
    159238            raise NAPlatformError 
     
    162241        array=array*scal 
    163242 
     243        msg="\nAdding auxiliary variable: %s" % self.ANAME[avar_number] 
     244        print msg 
     245        self.outputMessage.append(msg) 
    164246        # Set up axes 
    165247        if not hasattr(self, 'cdmsAxes'): 
     
    186268        return var         
    187269 
    188     def createCdmsAxes(self): 
     270    def createCdmsAxes(self):  
     271        """ 
     272        Creates cdms axes from information provided in the NASA Ames dictionary. 
     273        """ 
    189274        if sys.platform.find("win")>-1: 
    190275            raise NAPlatformError 
     
    195280 
    196281    def toCdmsAxis(self, ivar_number): 
     282        """ 
     283        Creates a cdms axis from a NASA Ames independent variable. 
     284        """ 
    197285        if sys.platform.find("win")>-1: 
    198286            raise NAPlatformError 
     
    207295        axis.id=axis.name=axis.long_name=self.XNAME[ivar_number] 
    208296        (varname, units)=self.getIndependentVariable(ivar_number) 
     297         
    209298        # Sort units etc 
    210299        if units:   axis.units=units 
     
    225314                if axis.isTime() and (not hasattr(axis, "units") or not time_units_pattn.match(axis.units)): 
    226315                    if self.time_units==None: 
    227                         print """\nWARNING: Could not recognise time units. For true NetCDF compability 
     316                     
     317                        timeUnitsInput="I WON'T MATCH" 
     318                        while timeUnitsInput!="" and not time_units_pattn.match(timeUnitsInput): 
     319                            message="""\nWARNING: Could not recognise time units. For true NetCDF compability 
    228320please insert the correct time unit string below in the format: 
    229321     
     
    234326    <YYYY> is the year, <MM> is the month, <DD> is the day, 
    235327    <hh> is the hour, <mm> is minutes, <ss> is seconds. 
    236 """ 
    237                         timeUnitsInput="I WON'T MATCH" 
    238                         while timeUnitsInput!="" and not time_units_pattn.match(timeUnitsInput): 
    239                             timeUnitsInput=raw_input("Please insert your time unit string here (or leave blank):").strip() 
     328"""                          
     329                            if self.time_warning=="yes": 
     330                                print message 
     331                                timeUnitsInput=raw_input("Please insert your time unit string here (or leave blank):").strip() 
     332                            else:  
     333                                timeUnitsInput="" 
     334                                self.outputMessage.append(message) 
    240335                        if timeUnitsInput!="": 
    241336                            self.time_units=timeUnitsInput 
     337 
    242338                    axis.units=self.time_units 
    243339                    axis.long_name=axis.name="time (%s)" % self.time_units 
  • nappy/trunk/output/out2010.na

    r361 r366  
    1 31    2010 
    2 Mertz, Fred 
    3 Pacific University 
    4 NMC analyzed grid data interpolated to DC-8 flight path 
    5 TAHITI OZONE PROJECT 
    6 1    1 
    7 1991 1 16    1991 1 16 
    8 0.0 30.0  
    9 8  
    10 8  
    11 250.000     200.000     150.000     100.000      70.000      50.000      30.000      10.000     
    12 Pressure levels (mb) 
    13 Time (UT seconds) from 00 hours on launch date 
    14 3 
    15 1.0 0.1 1e-09  
    16 99999.0 9999.0 9999999.0  
    17 Geopotential height (gpm) 
    18 Temperature (K) 
    19 Potential vorticity (K m**2/(kg s)) 
    20 2 
    21 1.0 0.1  
    22 99999.0 9999.0  
    23 Geopotential height (gpm) of the DC-8 
    24 Temperature (K) at DC-8's position 
    25 0 
    26 5 
    27 The geopotential height, temperature, and potential vorticity 
    28 values were interpolated from NMC analyses to a vertical cross- 
    29 section along the DC-8 flight path. 
    30 NOTE: PRELIMINARY data. 
    31 250mb   200mb   150mb   100mb    70mb    50mb    30mb    10mb 
    32 3350.0    1127.0    2682.0 
    33 9994.000    11395.000    13219.000    15762.000    17970.000    20000.000    23016.000    29411.000 
    34 2150.000    2154.000    2156.000    2115.000    2082.000    2042.000    1991.000    2021.000 
    35 4119.000    7050.000    8030.000    11300.000    16200.000    23500.000    50300.000    386000.000 
    36 3380.0    1289.0    2671.0 
    37 9992.000    11393.000    13217.000    15760.000    17968.000    19998.000    23013.000    29408.000 
    38 2151.000    2154.000    2156.000    2115.000    2081.000    2041.000    1990.000    2020.000 
    39 4128.000    7050.000    8040.000    11300.000    16200.000    23500.000    50400.000    386000.000 
    40 3410.0    1479.0    2653.0 
    41 9990.000    11392.000    13215.000    15759.000    17966.000    19996.000    23010.000    29404.000 
    42 2151.000    2154.000    2156.000    2115.000    2081.000    2041.000    1990.000    2020.000 
    43 4138.000    7060.000    8050.000    11400.000    16200.000    23500.000    50500.000    386000.000 
     143    2010 
     2De Rudder, Anne 
     3Rutherford Appleton Laboratory, Chilton OX11 0QX, UK - Tel.: +44 (0) 1235 445837 
     4Anemometer measurements averaged over longitude 
     5NERC Data Grid (NDG) project 
     67    13 
     71969 1 1    2002 10 31 
     810.0 20.0  
     99  
     101  
     110.000     
     12Latitude (degrees North) 
     13Altitude (km) 
     141 
     151.0  
     16200.0  
     17Mean zonal wind (m/s) 
     181 
     191.0  
     202000.0  
     21Pressure (hPa) 
     229 
     23Example of FFI 2010 (b). 
     24This example illustrating NASA Ames file format index 2010 is based on results 
     25from Murgatroyd (1969) as displayed in Brasseur and Solomon, Aeronomy of the 
     26Middle Atmosphere, Reidel, 1984 (p.36). It is representative of the mean zonal 
     27wind distribution in the winter hemisphere as a function of latitude and height. 
     28The first date on line 7 (1st of January 1969) is fictitious. 
     29From line 10 (NXDEF = 1) we know that the latitude points are defined by 
     30X(i) = X(1) + (i-1)DX1 for i = 1, ..., NX 
     31with X(1) = 0 deg (line 11), DX1 = 10 deg (line 8) and NX = 9 (line 9). 
     3211 
     33The files included in this data set illustrate each of the 9 NASA Ames file 
     34format indices (FFI). A detailed description of the NASA Ames format can be 
     35found on the Web site of the British Atmospheric Data Centre (BADC) at 
     36http://www.badc.rl.ac.uk/help/formats/NASA-Ames/ 
     37E-mail contact: badc@rl.ac.uk 
     38Reference: S. E. Gaines and R. S. Hipskind, Format Specification for Data 
     39Exchange, Version 1.3, 1998. This work can be found at 
     40http://cloud1.arc.nasa.gov/solve/archiv/archive.tutorial.html 
     41and a copy of it at 
     42http://www.badc.rl.ac.uk/help/formats/NASA-Ames/G-and-H-June-1998.html 
     43 
     440.0    1013.3 
     45  -3.000      -2.600      -2.300       2.000       4.800       4.600       4.500       3.000      -0.900 
     4620.0    55.3 
     47 -15.100      -4.200       6.900      12.800      14.700      20.000      21.500      18.000       8.200 
     4840.0    2.3 
     49 -29.000     -15.200       3.400      28.200      41.000      39.100      17.900       8.000       0.100 
     5060.0    0.22 
     51 -10.000       8.400      31.200      59.900      78.500      77.700      47.000      17.600      16.000 
     5280.0    0.01 
     53 200.000     200.000     200.000     200.000     200.000     200.000     200.000     200.000     200.000 
  • nappy/trunk/test/testReadAllFFIs.py

    r361 r366  
    2727    f.readData() 
    2828    print "DX:",f.DX 
    29     print "NX:" ,f.NX 
    30     print "X:", f.X 
    3129    print "VNAME", f.VNAME 
    32     print "V:",f.V[0:] 
    33     f.getNADict() 
    34    # print "NNCOML:",f.NNCOML 
    35    # print "NCOM:",f.NCOM 
     30    print "V:",f.V[0] 
    3631 
    37  
    38     if f.NAUXV>0: 
    39         print "AUXs:" 
    40         print f.ANAME[0:] 
    41         print "AUX scaling factors %s" %f.ASCAL[0:] 
    42         print "AUX missing values %s" %f.AMISS[0:] 
    43         print "AUX lengths %s" %f.LENA 
    44         print "AUX names %s" %f.ANAME[0:] 
    45         print f.A[0:] 
     32    if f.NAUXV>1: 
     33        print "AUX:" 
     34        print f.ANAME[0], f.ASCAL[0] 
     35        print f.A[0] 
  • nappy/trunk/test/testWrites.py

    r361 r366  
    55 
    66# 08/05/04 updated by selatham for bug fixes and new write methods 
    7 # 18/11/04 updated selatham new write method 
     7 
    88""" 
    99testWrites.py 
     
    1818import nappy ; reload(nappy) 
    1919 
    20 for ffi in [1001, 1010, 1020, 2010, 2110, 2160, 2310, 3010, 4010]: 
    21 #for ffi in [2160]:                                     #testing single format 
     20for ffi in [1001, 1010, 2010, 3010, 4010]:                                      #08/05/04 selatham 
    2221    infile=os.path.join("..", "data_files", "%s.na" % ffi) 
    2322    print "Reading in ", infile 
     
    3231    print "\nFile written successfully, so let's open it." 
    3332 
    34     z=nappy.openNAFile(outfile) 
     33    x=nappy.openNAFile(outfile) 
    3534    print "variables are:\n" 
    36     print z.getVariables() 
    37     d2=z.getNADict() 
    38     z.readData() 
    39     print "DX:",z.DX 
    40     print "NX:" ,z.NX 
    41     print "X:", z.X 
    42     print "VNAME", z.VNAME 
    43     print "V:",z.V[0:] 
    44     print "\n" 
     35    print x.getVariables() 
  • nappy/trunk/version.py

    r349 r366  
    1111""" 
    1212 
    13 version="0.0.1" 
     13version="0.0.1.9" 
    1414 
Note: See TracChangeset for help on using the changeset viewer.