Changeset 3345


Ignore:
Timestamp:
08/02/08 23:02:23 (12 years ago)
Author:
astephen
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • nappy/trunk/nappy/nc_interface/cdms_to_na.py

    r3342 r3345  
    4848 
    4949 
     50cdms2na - 200 lines of code to do main conversion, needs to be split out into other stuff. 
     51 * getVariableCollections(f and varlist) --> (ordered_vars, other_vars) 
     52 * buildNADicts() 
     53 * writeToOutputFiles() 
     54 
     55class CdmsToNABuilder --> NAContentCollector: (naDict, varIDs, varBin) 
     56__init__ --> sets everything up and runs it move some to --> analyse() 
     57analyseVariables 
     58defineNAVars 
     59defineNAAuxVars 
     60getAxisDefinition 
     61defineNAGlobals 
     62defineNAComments 
     63defineGeneralHeader 
     64 
    5065def cdms2na(ncfile, na_file_names, naVars={}, variables=None, nFilesOnly="no",  
    51             rule=None, ffi="automatic", spacer="    ", floatFormat="%g",  
    52             rules=None, sizeLimit=None): 
     66            ffi="automatic", spacer="    ", floatFormat="%g", size_limit=None): 
    5367    """ 
    5468    Main conversion function that calls the appropriate classes and functions 
     
    6074     
    6175    # Get which NASA Ames internal variables are allowed to be overwritten in the output files (i.e. by user inputs) 
    62     allowedOverwriteMetadata = ("DATE",  "RDATE", "ANAME", "MNAME", 
     76    allowed_overwrite_metadata = ("DATE",  "RDATE", "ANAME", "MNAME", 
    6377           "ONAME", "ORG", "SNAME", "VNAME") 
    6478    arrayArgs=["DATE", "RDATE", "ANAME", "VNAME"] 
     
    7185    # SNAME - source of measurement or model output VNAME[n] - array of 'n' x  
    7286    # VNAME strings - var names. 
    73     outputMessage=[] 
     87    output_message=[] 
    7488    msg="Reading data from: %s\n" % infilename 
    7589    print msg 
    76     outputMessage.append(msg) 
    77     cdmsfile=cdms.open(infilename) 
    78     globals=cdmsfile.attributes 
     90    output_message.append(msg) 
     91    cdms_file=cdms.open(infilename) 
     92    globals=cdms_file.attributes 
    7993     
    8094    vars=[] 
    8195    if not variables: 
    82         variables=cdmsfile.listvariables() 
    83         #for var in cdmsfile.listvariables(): 
    84             #vars.append(cdmsfile(var))     
     96        variables=cdms_file.listvariables() 
     97        #for var in cdms_file.listvariables(): 
     98            #vars.append(cdms_file(var))     
    8599             
    86100    for variable in variables: 
    87         varObj=cdmsfile(variable) 
     101        varObj=cdms_file(variable) 
    88102        # Deal with singleton variables 
    89103        if not hasattr(varObj, "rank"): 
    90                 varMetadata=cdmsfile[variable].attributes 
     104                varMetadata=cdms_file[variable].attributes 
    91105                varValue=varObj 
    92106                #print varMetadata, varValue, varMetadata.keys(), varMetadata._obj_.id 
     
    100114         
    101115    # Re-order variables if they have the attribute 'nasa_ames_var_number' 
    102     orderedVars=[None]*1000 
     116    ordered_vars=[None]*1000 
    103117    otherVars=[] 
    104118    for var in vars: 
    105         varMetadata=cdmsfile[var] 
     119        varMetadata=cdms_file[var] 
    106120        if hasattr(varMetadata, "nasa_ames_var_number"): 
    107121            num=varMetadata.nasa_ames_var_number 
    108             orderedVars[num]=var 
     122            ordered_vars[num]=var 
    109123        else: 
    110124            otherVars.append(var) 
    111125     
    112126    vars=[] 
    113     for var in orderedVars: 
     127    for var in ordered_vars: 
    114128        if var!=None: 
    115129            vars.append(var) 
     
    117131    vars=vars+otherVars 
    118132     
    119     builder=CdmsToNABuilder(vars, globals, rule=rule, cdmsfile=cdmsfile) 
     133    builder=NAContentCollector(vars, globals, rule=rule, cdms_file=cdms_file) 
    120134    #print builder.naDict["X"] 
    121135    builtNADicts=[[builder.naDict, builder.varIDs]] 
     
    123137        msg="\nNo files created after variables parsed." 
    124138        print msg 
    125         outputMessage.append(msg) 
    126         return outputMessage 
     139        output_message.append(msg) 
     140        return output_message 
    127141 
    128142    while len(builder.varBin)>0: 
    129         builder=CdmsToNABuilder(builder.varBin, globals, rule=rule, cdmsfile=cdmsfile) 
    130         outputMessage=outputMessage+builder.outputMessage 
     143        builder=NAContentCollector(builder.varBin, globals, rule=rule, cdms_file=cdms_file) 
     144        output_message=output_message+builder.output_message 
    131145        if builder.varIDs!=None:  builtNADicts.append([builder.naDict, builder.varIDs]) 
    132146 
     
    149163    msg="\n%s files to write" % len(builtNADicts) 
    150164    print msg 
    151     outputMessage.append(msg) 
     165    output_message.append(msg) 
    152166 
    153167    count=1 
     
    166180        msg="\nWriting output NASA Ames file: %s" % newname 
    167181        print msg 
    168         outputMessage.append(msg) 
     182        output_message.append(msg) 
    169183         
    170184        builtNADict=i[0] 
    171185        for key in naVars.keys(): 
    172             if key in allowedOverwriteMetadata: 
     186            if key in allowed_overwrite_metadata: 
    173187             
    174188                if key in arrayArgs: 
     
    181195                    msg="Metadata overwritten in output file: '%s' is now '%s'" % (key, builtNADict[key]) 
    182196                    print msg 
    183                     outputMessage.append(msg) 
     197                    output_message.append(msg) 
    184198         
    185199        fileList=[] 
    186200        # Cope with size limits if specified and FFI is 1001 
    187         if sizeLimit and (builtNADict["FFI"]==1001 and len(builtNADict["V"][0])>sizeLimit): 
     201        if size_limit and (builtNADict["FFI"]==1001 and len(builtNADict["V"][0])>size_limit): 
    188202            varList=builtNADict["V"] 
    189203            arrayLength=len(varList[0]) 
    190             nvolInfo=divmod(arrayLength, sizeLimit) 
     204            nvolInfo=divmod(arrayLength, size_limit) 
    191205            nvol=nvolInfo[0] 
    192206            if nvolInfo[1]>0: nvol=nvol+1 
     
    196210            while start<arrayLength: 
    197211                ivol=ivol+1 
    198                 end=start+sizeLimit 
     212                end=start+size_limit 
    199213                if end>arrayLength: 
    200214                    end=arrayLength 
     
    211225                fileList.append(newnamePlusLetter) 
    212226                general.openNAFile(newnamePlusLetter, 'w', NADictCopy, spacer=spacer, floatFormat=floatFormat) 
    213                 msg="\nOutput files split on size limit: %s\nFilename used: %s" % (sizeLimit, newnamePlusLetter) 
     227                msg="\nOutput files split on size limit: %s\nFilename used: %s" % (size_limit, newnamePlusLetter) 
    214228                print msg 
    215                 outputMessage.append(msg) 
     229                output_message.append(msg) 
    216230                letterCount=letterCount+1 
    217231                start=end 
     
    223237        msg="\nWrote the following variables:"+"\n\t"+("\n\t".join(i[1][0])) 
    224238        print msg 
    225         outputMessage.append(msg) 
     239        output_message.append(msg) 
    226240         
    227241        if len(i[1][1])>0: 
     
    242256 
    243257        print msg 
    244         outputMessage.append(msg) 
     258        output_message.append(msg) 
    245259             
    246260    if (count-1)==1: 
     
    250264    msg="\n%s file%s written." % ((count-1), plural) 
    251265    print msg 
    252     outputMessage.append(msg) 
    253     return outputMessage 
    254  
    255  
    256 class CdmsToNABuilder(NACore): 
     266    output_message.append(msg) 
     267    return output_message 
     268 
     269 
     270class NAContentCollector(NACore): 
    257271    """ 
    258272    Class to build a NASA Ames File object from a set of  
     
    260274    """ 
    261275     
    262     def __init__(self, vars, global_attributes={}, cdmsfile=None, rule=None): 
    263         """ 
    264         Sets up instance variables and calls appropriate methods to 
    265         generate sections of NASA Ames file object. 
    266         """ 
    267         self.rule=rule 
    268         self.cdmsfile=cdmsfile 
    269         self.outputMessage=[] 
    270         self.naDict={} 
     276    def __init__(self, vars, global_attributes={}, cdms_file=None): 
     277        """ 
     278        Sets up instance variables and calls appropriate methods to 
     279        generate sections of NASA Ames file object. 
     280        """ 
     281        self.cdms_file=cdms_file 
     282        self.output_message=[] 
     283        self.na_dict={} 
    271284        self.vars=vars 
    272         self.varIDs=None 
     285        self.var_ids=None 
    273286        self.globals=global_attributes   
    274         self.rankZeroVars=[] 
    275         self.rankZeroVarIDs=[] 
    276         (self.orderedVars, auxVars)=self.analyseVariables() 
    277         if self.orderedVars==None: 
    278             self.varBin=[] 
    279         else: 
    280             #print "NAMELISTS:", [var.id for var in self.orderedVars],[var.id for var in auxVars] 
    281             self.varIDs=[[var.id for var in self.orderedVars],[var.id for var in auxVars], self.rankZeroVarIDs] 
    282          
    283             self.naDict["NLHEAD"]="-999" 
    284          
    285             #print [var.id for var in self.orderedVars] 
    286             #print [var.rank() for var in self.orderedVars]      
    287             self.defineNAVars(self.orderedVars) 
     287        self.rank_zero_vars=[] 
     288        self.rank_zero_var_ids=[] 
     289        (self.ordered_vars, auxVars)=self.analyseVariables() 
     290        if self.ordered_vars==None: 
     291            self.var_bin=[] 
     292        else: 
     293 
     294            self.var_ids=[[var.id for var in self.ordered_vars],[var.id for var in auxVars], self.rank_zero_var_ids] 
     295         
     296            self.na_dict["NLHEAD"]="-999" 
     297         
     298            #print [var.id for var in self.ordered_vars] 
     299            #print [var.rank() for var in self.ordered_vars]     
     300            self.defineNAVars(self.ordered_vars) 
    288301            self.defineNAAuxVars(auxVars) 
    289302            self.defineNAGlobals() 
     
    291304            self.defineGeneralHeader() 
    292305            # Quick fudge 
    293             if self.naDict["FFI"]==1001: self.naDict["X"]=self.naDict["X"][0] 
     306            if self.na_dict["FFI"]==1001: self.na_dict["X"]=self.na_dict["X"][0] 
    294307 
    295308 
    296309    def analyseVariables(self): 
    297310        """ 
    298         Method to examine the content of CDMS variables to return 
    299         a tuple of two lists containing variables and auxiliary variables 
    300         for the NASA Ames file object. 
    301         Variables not compatible with the first file are binned to be used next. 
    302         """ 
    303         # Need to group the variables together in bins 
    304         self.varBin=[] 
    305         # Get largest ranked variable as the one we use as standard 
    306         highrank=-1 
    307         bestVar=None 
    308         count=0 
    309         for var in self.vars: 
    310             msg="Analysing: %s" % var.id 
    311             print msg 
    312             self.outputMessage.append(msg) 
    313             count=count+1 
    314  
    315             # get rank 
    316             rank=var.rank() 
    317  
    318             # Deal with specific datasets with special rules 
    319             if self.rule!=None and self.rule[0]=="aircraft": 
    320                 var=self._useLocalRule(var, self.rule) 
    321                 if type(var)==type(None):  
    322                     continue  
    323                 rank=1 
     311        Method to examine the content of CDMS variables to return 
     312        a tuple of two lists containing variables and auxiliary variables 
     313        for the NASA Ames file object. 
     314        Variables not compatible with the first file are binned to be used next. 
     315        """ 
     316        # Need to group the variables together in bins 
     317        self.var_bin=[] 
     318        # Get largest ranked variable as the one we use as standard 
     319        highrank=-1 
     320        best_var=None 
     321        count=0 
     322        for var in self.vars: 
     323            msg="Analysing: %s" % var.id 
     324            print msg 
     325            self.output_message.append(msg) 
     326            count=count+1 
     327 
     328            # get rank 
     329            rank=var.rank() 
    324330 
    325331            # Deal with singleton variables 
    326332            if rank==0:  
    327                 self.rankZeroVars.append(var) 
    328                 self.rankZeroVarIDs.append(var.id) 
     333                self.rank_zero_vars.append(var) 
     334                self.rank_zero_var_ids.append(var.id) 
    329335                continue 
    330336             
    331337            if rank>highrank: 
    332338                highrank=rank 
    333                 bestVar=var 
    334                 bestVarIndex=count 
     339                best_var=var 
     340                best_var_index=count 
    335341            elif rank==highrank: 
    336                 if len(var.flat)>len(bestVar.flat): 
    337                     bestVar=var 
    338                     bestVarIndex=count 
    339          
    340         if len(self.rankZeroVars)==len(self.vars):  return (None, None) 
    341         if not bestVar:   
     342                if len(var.flat)>len(best_var.flat): 
     343                    best_var=var 
     344                    best_var_index=count 
     345         
     346        if len(self.rank_zero_vars)==len(self.vars):  return (None, None) 
     347        if not best_var:   
    342348            print "No variables produced" 
    343349            return (None, None) 
    344350 
    345         vars4NA=[bestVar] 
     351        vars4NA=[best_var] 
    346352        auxVars4NA=[] 
    347         shape=bestVar.shape 
     353        shape=best_var.shape 
    348354        ndims=len(shape) 
    349         self.naDict["NIV"]=ndims 
     355        self.na_dict["NIV"]=ndims 
    350356 
    351357        # Work out which File Format Index is appropriate  
    352358        if ndims in (2,3,4): 
    353             self.naDict["FFI"]=10+(ndims*1000) 
     359            self.na_dict["FFI"]=10+(ndims*1000) 
    354360        elif ndims>4: 
    355361            raise "Cannot write variables defined against greater than 4 axes in NASA Ames format." 
    356362        else: 
    357             if len(auxVars4NA)>0 or (self.naDict.has_key("NAUXV") and self.naDict["NAUXV"]>0): 
    358                 self.naDict["FFI"]=1010 
     363            if len(auxVars4NA)>0 or (self.na_dict.has_key("NAUXV") and self.na_dict["NAUXV"]>0): 
     364                self.na_dict["FFI"]=1010 
    359365            else: 
    360                 self.naDict["FFI"]=1001 
    361         #print self.naDict["FFI"] 
    362         axes=bestVar.getAxisList() 
     366                self.na_dict["FFI"]=1001 
     367        #print self.na_dict["FFI"] 
     368        axes=best_var.getAxisList() 
    363369         
    364370        # Get other variable info 
    365         #print [v.id for v in self.vars], bestVarIndex 
    366         #print [v.id for v in self.vars[:bestVarIndex-1]+self.vars[bestVarIndex:]] 
    367         for var in self.vars[:bestVarIndex-1]+self.vars[bestVarIndex:]: 
    368             # Deal with specific datasets with special rules 
    369             if self.rule!=None and self.rule[0]=="aircraft": 
    370                 if var.rank()==2: 
    371                     var=self._useLocalRule(var, self.rule) 
    372                     if type(var)==type(None): continue 
    373  
    374             #print self.rankZeroVars 
    375             #for rzv in self.rankZeroVars:   
     371        #print [v.id for v in self.vars], best_var_index 
     372        #print [v.id for v in self.vars[:best_var_index-1]+self.vars[best_var_index:]] 
     373        for var in self.vars[:best_var_index-1]+self.vars[best_var_index:]: 
     374 
     375            #print self.rank_zero_vars 
     376            #for rzv in self.rank_zero_vars:   
    376377            #    if var.id==rzv.id and var[0]==rzv[0]: continue 
    377             #print [v.id for v in self.rankZeroVars] 
    378             if var.id in self.rankZeroVarIDs: continue 
     378            #print [v.id for v in self.rank_zero_vars] 
     379            if var.id in self.rank_zero_var_ids: continue 
    379380            #print var.id, ndims, shape, len(var.shape), var.shape 
    380381            if len(var.shape)!=ndims or var.shape!=shape:  
    381382                # Could it be an auxiliary variable  
    382383                if len(var.shape)!=1:  
    383                     self.varBin.append(var) 
     384                    self.var_bin.append(var) 
    384385                    continue 
    385386                caxis=var.getAxis(0) 
    386387                if compareAxes(axes[0], caxis)==0:  
    387                     self.varBin.append(var) 
     388                    self.var_bin.append(var) 
    388389                    continue 
    389390                # I think it is an auxiliary variable 
    390391                auxVars4NA.append(var)  
    391392                # Also put it in var bin because auxiliary vars might be useful 
    392                 self.varBin.append(var) 
     393                self.var_bin.append(var) 
    393394            else: 
    394395                caxes=var.getAxisList() 
     
    396397                for i in range(ndims):             
    397398                    if compareAxes(axes[i], caxes[i])==0: 
    398                         self.varBin.append(var) 
     399                        self.var_bin.append(var) 
    399400                        continue 
    400401                # OK, I think they are compatible 
     
    403404        # Re-order if they previously came from NASA Ames files (i.e. including  
    404405        # the attribute 'nasa_ames_var_number') 
    405         orderedVars=[None]*1000 
     406        ordered_vars=[None]*1000 
    406407        otherVars=[] 
    407408        for var in vars4NA: 
    408409            if hasattr(var, "nasa_ames_var_number"): 
    409                 orderedVars[var.nasa_ames_var_number[0]]=var 
     410                ordered_vars[var.nasa_ames_var_number[0]]=var 
    410411            else: 
    411412                otherVars.append(var) 
    412413        # Remake vars4NA now in order 
    413414        vars4NA=[] 
    414         for var in orderedVars: 
     415        for var in ordered_vars: 
    415416            if var!=None: vars4NA.append(var) 
    416417        vars4NA=vars4NA+otherVars 
     
    439440        associated metadata. 
    440441        """ 
    441         self.naDict["NV"]=len(vars) 
    442         self.naDict["VNAME"]=[] 
    443         self.naDict["VMISS"]=[] 
    444         self.naDict["VSCAL"]=[] 
    445         self.naDict["V"]=[] 
     442        self.na_dict["NV"]=len(vars) 
     443        self.na_dict["VNAME"]=[] 
     444        self.na_dict["VMISS"]=[] 
     445        self.na_dict["VSCAL"]=[] 
     446        self.na_dict["V"]=[] 
    446447        for var in vars: 
    447448            name=getBestName(var) 
    448             self.naDict["VNAME"].append(name) 
     449            self.na_dict["VNAME"].append(name) 
    449450            miss=getMissingValue(var) 
    450451            if type(miss) not in (float, int, long):  miss=miss[0] 
    451             self.naDict["VMISS"].append(miss) 
    452             #print self.naDict["VMISS"] 
    453             self.naDict["VSCAL"].append(1) 
     452            self.na_dict["VMISS"].append(miss) 
     453            #print self.na_dict["VMISS"] 
     454            self.na_dict["VSCAL"].append(1) 
    454455            # AND THE ARRAY 
    455456            # Populate the variable list   
    456457            ######## NOTE - might not have to do this ##### 
    457458            ######## It  might handle writing from a Numeric array ######## 
    458             self.naDict["V"].append(var._data) 
     459            self.na_dict["V"].append(var._data) 
    459460            #listOfListsCreator(inlist, var.shape) 
    460461            #arrayToList(var, inlist) 
    461462 
    462             if not self.naDict.has_key("X"): 
    463                 self.naDict["NXDEF"]=[] 
    464                 self.naDict["NX"]=[] 
     463            if not self.na_dict.has_key("X"): 
     464                self.na_dict["NXDEF"]=[] 
     465                self.na_dict["NX"]=[] 
    465466                # Create independent variable information 
    466467                #print var.id, var.getAxis(0) 
    467468                self.ax0=var.getAxis(0) 
    468                 self.naDict["X"]=[list(self.ax0._data_)] 
    469                 self.naDict["XNAME"]=[getBestName(self.ax0)] 
     469                self.na_dict["X"]=[list(self.ax0._data_)] 
     470                self.na_dict["XNAME"]=[getBestName(self.ax0)] 
    470471                if len(self.ax0)==1: 
    471                     self.naDict["DX"]=[0] 
     472                    self.na_dict["DX"]=[0] 
    472473                else: 
    473474                    incr=self.ax0[1]-self.ax0[0] 
    474475                    # Set default increment as gap between first two 
    475                     self.naDict["DX"]=[incr] 
     476                    self.na_dict["DX"]=[incr] 
    476477                    # Now overwrite it as zero if non-uniform interval in axis 
    477478                    for i in range(1, len(self.ax0)): 
    478479                        if (self.ax0[i]-self.ax0[i-1])!=incr: 
    479                             self.naDict["DX"]=[0] 
     480                            self.na_dict["DX"]=[0] 
    480481                            break 
    481482 
     
    490491        associated metadata. 
    491492        """ 
    492         self.naDict["NAUXV"]=len(auxVars) 
    493         self.naDict["ANAME"]=[] 
    494         self.naDict["AMISS"]=[] 
    495         self.naDict["ASCAL"]=[] 
    496         self.naDict["A"]=[] 
     493        self.na_dict["NAUXV"]=len(auxVars) 
     494        self.na_dict["ANAME"]=[] 
     495        self.na_dict["AMISS"]=[] 
     496        self.na_dict["ASCAL"]=[] 
     497        self.na_dict["A"]=[] 
    497498        for var in auxVars: 
    498499            name=getBestName(var) 
    499             self.naDict["ANAME"].append(name) 
     500            self.na_dict["ANAME"].append(name) 
    500501            miss=getMissingValue(var) 
    501502            if type(miss)!=float:  miss=miss[0] 
    502             self.naDict["AMISS"].append(miss) 
    503             self.naDict["ASCAL"].append(1) 
     503            self.na_dict["AMISS"].append(miss) 
     504            self.na_dict["ASCAL"].append(1) 
    504505            # AND THE ARRAY 
    505506            # Populate the variable list   
    506507            ######## NOTE - might not have to do this ##### 
    507508            ######## It  might handle writing from a Numeric array ######## 
    508             self.naDict["A"].append(var._data) 
     509            self.na_dict["A"].append(var._data) 
    509510            #listOfListsCreator(inlist, var.shape) 
    510511            #arrayToList(var, inlist)      
     
    518519        """ 
    519520        length=len(axis) 
    520         self.naDict["NX"].append(length) 
    521         self.naDict["XNAME"].append(getBestName(axis)) 
     521        self.na_dict["NX"].append(length) 
     522        self.na_dict["XNAME"].append(getBestName(axis)) 
    522523        # If only one item in axis values 
    523524        if length<2: 
    524             self.naDict["DX"].append(0) 
    525             self.naDict["NXDEF"].append(length) 
    526             self.naDict["X"].append(list(axis._data_))         
     525            self.na_dict["DX"].append(0) 
     526            self.na_dict["NXDEF"].append(length) 
     527            self.na_dict["X"].append(list(axis._data_))         
    527528            return 
    528529    
     
    530531        for i in range(1, length): 
    531532            if (axis[i]-axis[i-1])!=incr: 
    532                 self.naDict["DX"].append(0) 
    533                 self.naDict["NXDEF"].append(length) 
    534                 self.naDict["X"].append(list(axis._data_)) 
     533                self.na_dict["DX"].append(0) 
     534                self.na_dict["NXDEF"].append(length) 
     535                self.na_dict["X"].append(list(axis._data_)) 
    535536                break 
    536537        else: 
    537538            maxLength=length 
    538539            if length>3: maxLength=3 
    539             self.naDict["DX"].append(incr) 
    540             self.naDict["NXDEF"].append(maxLength) 
    541             self.naDict["X"].append(axis[:maxLength]) 
     540            self.na_dict["DX"].append(incr) 
     541            self.na_dict["NXDEF"].append(maxLength) 
     542            self.na_dict["X"].append(axis[:maxLength]) 
    542543        return 
    543544 
     
    573574                    match=re.match(r"(.*)\s+\(ONAME from NASA Ames file\);\s+(.*)\s+\(ORG from NASA Ames file\)\.", self.globals[key]) 
    574575                    if match: 
    575                         self.naDict["ONAME"]=match.groups()[0] 
    576                         self.naDict["ORG"]=match.groups()[1] 
     576                        self.na_dict["ONAME"]=match.groups()[0] 
     577                        self.na_dict["ORG"]=match.groups()[1] 
    577578                    else: 
    578                         self.naDict["ONAME"]=self.globals[key] 
    579                         self.naDict["ORG"]=self.globals[key]                 
     579                        self.na_dict["ONAME"]=self.globals[key] 
     580                        self.na_dict["ORG"]=self.globals[key]                
    580581                     
    581582                    # NOte: should probably do the following search and replace on all string lines 
    582                     self.naDict["ONAME"]=self.naDict["ONAME"].replace("\n", "  ") 
    583                     self.naDict["ORG"]=self.naDict["ORG"].replace("\n", "  ") 
     583                    self.na_dict["ONAME"]=self.na_dict["ONAME"].replace("\n", "  ") 
     584                    self.na_dict["ORG"]=self.na_dict["ORG"].replace("\n", "  ") 
    584585                                     
    585586                elif key=="comment": 
     
    612613                                     
    613614                elif key=="first_valid_date_of_data": 
    614                     self.naDict["DATE"]=self.globals[key] 
     615                    self.na_dict["DATE"]=self.globals[key] 
    615616                 
    616617                elif key in ("Conventions", "references"): 
     
    618619                    self.extra_comments[2].append("%s:   %s" % (key, self.globals[key])) 
    619620                else: 
    620                     self.naDict[globalmap[key]]=self.globals[key] 
     621                    self.na_dict[globalmap[key]]=self.globals[key] 
    621622            else: 
    622623                self.extra_comments[2].append("%s:   %s" % (key, self.globals[key])) 
     
    674675 
    675676        # Create a string for the Special comments to hold rank-zero vars 
    676         rankZeroVarsString=[] 
    677         for var in self.rankZeroVars: 
    678             rankZeroVarsString.append("\tVariable %s: %s" % (var.id, getBestName(var))) 
     677        rank_zero_varsString=[] 
     678        for var in self.rank_zero_vars: 
     679            rank_zero_varsString.append("\tVariable %s: %s" % (var.id, getBestName(var))) 
    679680            for att in var.attributes.keys(): 
    680681                value=var.attributes[att] 
    681682                if type(value) in (str, float, int): 
    682                     rankZeroVarsString.append("\t\t%s = %s" % (att, var.attributes[att])) 
    683             #print "VALUES", dir(var), var._data ; rankZeroVarsString.append("\t\tvalue = %s" % var._data) 
    684          
    685         if len(rankZeroVarsString)>0: 
    686             rankZeroVarsString.insert(0, "###Singleton Variables defined in the source file follow###") 
    687             rankZeroVarsString.append("###Singleton Variables defined in the source file end###") 
    688  
    689         for var in self.orderedVars: 
     683                    rank_zero_varsString.append("\t\t%s = %s" % (att, var.attributes[att])) 
     684            #print "VALUES", dir(var), var._data ; rank_zero_varsString.append("\t\tvalue = %s" % var._data) 
     685         
     686        if len(rank_zero_varsString)>0: 
     687            rank_zero_varsString.insert(0, "###Singleton Variables defined in the source file follow###") 
     688            rank_zero_varsString.append("###Singleton Variables defined in the source file end###") 
     689 
     690        for var in self.ordered_vars: 
    690691            varflag="unused" 
    691692            name=getBestName(var) 
     
    698699                            varCommentsFlag=1 
    699700                            if specCommentsFlag==None: 
    700                                 SCOM=["###NASA Ames Special Comments follow###"]+rankZeroVarsString 
     701                                SCOM=["###NASA Ames Special Comments follow###"]+rank_zero_varsString 
    701702                            SCOM.append("Additional Variable Attributes defined in the source file and not translated elsewhere:") 
    702703                            SCOM.append("###Variable attributes from source (NetCDF) file follow###") 
     
    741742                    SCOM_cleaned.append(line) 
    742743                     
    743         self.naDict["NCOM"]=NCOM_cleaned 
    744         self.naDict["NNCOML"]=len(self.naDict["NCOM"])#+hiddenNewLineCount1 
    745         self.naDict["SCOM"]=SCOM_cleaned 
    746         self.naDict["NSCOML"]=len(self.naDict["SCOM"])#+hiddenNewLineCount2 
     744        self.na_dict["NCOM"]=NCOM_cleaned 
     745        self.na_dict["NNCOML"]=len(self.na_dict["NCOM"])#+hiddenNewLineCount1 
     746        self.na_dict["SCOM"]=SCOM_cleaned 
     747        self.na_dict["NSCOML"]=len(self.na_dict["SCOM"])#+hiddenNewLineCount2 
    747748        return 
    748749 
     
    755756        # Check if DATE field previously known in NASA Ames file 
    756757        time_now=time.strftime("%Y %m %d", time.localtime(time.time())).split() 
    757         if not self.naDict.has_key("RDATE"): 
    758             self.naDict["RDATE"]=time_now 
     758        if not self.na_dict.has_key("RDATE"): 
     759            self.na_dict["RDATE"]=time_now 
    759760         
    760761        if self.ax0.isTime(): 
     
    763764                (unit, start_date)=re.match("(\w+)\s+?since\s+?(\d+-\d+-\d+)", self.ax0.units).groups()             
    764765                comptime=cdtime.s2c(start_date) 
    765                 first_day=comptime.add(self.naDict["X"][0][0], getattr(cdtime, unit.capitalize())) 
    766                 self.naDict["DATE"]=string.replace(str(first_day).split(" ")[0], "-", " ").split() 
     766                first_day=comptime.add(self.na_dict["X"][0][0], getattr(cdtime, unit.capitalize())) 
     767                self.na_dict["DATE"]=string.replace(str(first_day).split(" ")[0], "-", " ").split() 
    767768            except: 
    768769                msg="Nappy Warning: Could not get the first date in the file. You will need to manually edit the output file." 
    769770                print msg 
    770                 self.outputMessage.append(msg) 
    771                 self.naDict["DATE"]=("DATE", "NOT", "KNOWN") 
     771                self.output_message.append(msg) 
     772                self.na_dict["DATE"]=("DATE", "NOT", "KNOWN") 
    772773        else:  
    773             if not self.naDict.has_key("DATE"): 
     774            if not self.na_dict.has_key("DATE"): 
    774775                msg="Nappy Warning: Could not get the first date in the file. You will need to manually edit the output file." 
    775776                print msg 
    776                 self.outputMessage.append(msg) 
    777                 self.naDict["DATE"]=("DATE", "NOT", "KNOWN") 
    778         self.naDict["IVOL"]=1 
    779         self.naDict["NVOL"]=1 
     777                self.output_message.append(msg) 
     778                self.na_dict["DATE"]=("DATE", "NOT", "KNOWN") 
     779        self.na_dict["IVOL"]=1 
     780        self.na_dict["NVOL"]=1 
    780781        for key in header_items.keys(): 
    781              self.naDict[key]=header_items[key] 
     782             self.na_dict[key]=header_items[key] 
    782783        return 
    783784 
    784  
    785     def _useLocalRule(self, var, ruleArgs): 
    786         """ 
    787         Applies some logic based on a local rule. 
    788         """ 
    789         ruleName=ruleArgs[0] 
    790         rule=ruleArgs 
    791         if ruleName=="aircraft": 
    792             # Fixes aircraft data 2D time axis, missing values and does sub-selection by default 
    793             flagVar=None 
    794  
    795             # return if variable is time 
    796             if var.id=="Time": 
    797                 return None 
    798  
    799             if len(rule)<2: rule.append("av") 
    800             if len(rule)<3: rule.append("flag") 
    801             if rule[2]=="flag": 
    802                 # Only use flag var for processing real variable 
    803                 if var.id.strip()[-4:]=="FLAG":  
    804                     print "Ignore flag: %s" % var.id 
    805                     return None  
    806  
    807                 flagID=var.id.strip()+"FLAG" 
    808                 try: 
    809                     flagVar=self.cdmsfile(flagID) 
    810                 except: 
    811                     raise "Cannot get flag variable for '%s'" % var.id 
    812             elif rule[2]=="noflag": 
    813                 flagVar=None 
    814  
    815             timeVar=self.cdmsfile("Time") 
    816             import localRules.aircraftData 
    817             ruleArgs=[rule[1]]+rule[3:] 
    818             fixedVar=localRules.aircraftData.AircraftData(var, timeVar, flagVar, ruleArgs).subSampledVar 
    819             return fixedVar 
    820         else: 
    821             raise "Rule '%s' not yet defined." % ruleName 
    822                  
    823  
    824 usenc2nainstead="""if __name__=="__main__": 
    825  
    826     args=sys.argv[1:] 
    827     if len(args)<4: 
    828         print helpMessage 
    829         print "Incorrect number of arguments used." 
    830         sys.exit() 
    831          
    832     for arg in args: 
    833         if arg=="-i": 
    834             infile=args[args.index(arg)+1] 
    835         elif arg=="-o": 
    836             outfile=args[args.index(arg)+1] 
    837  
    838     cdms2na(infile, outfile) """ 
Note: See TracChangeset for help on using the changeset viewer.