Changeset 2849 for TI02-CSML


Ignore:
Timestamp:
28/08/07 16:31:46 (12 years ago)
Author:
domlowe
Message:

fixing up strange indentation in csmldataiface.py

File:
1 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/csml/csmllibs/csmldataiface.py

    r2843 r2849  
    4646 
    4747class DataInterface(object): 
    48     #Use DataInterface and setInterfaceType to instantiate the correct 
    49     #subclass for data  
    50     def __init__(self): 
    51         self.iface ='None' 
    52          
    53     def setInterfaceType(self,interfaceType): 
    54         # function returns approprate data interface 
    55         #set interfaceType: should correspond to available datainterface subclasses 
    56         self.iface =interfaceType 
    57         if self.iface == 'nappy': 
    58             return NappyInterface() 
    59         elif self.iface == 'cdunif': 
    60             return cdunifInterface() 
    61         elif self.iface == 'raw': 
    62             return RawFileInterface() 
    63         elif self.iface == 'image': 
    64             return ImageFileInterface() 
    65          
    66          
    67     def getUnknownInterfaceType(self, filename): 
    68         #if the interface type is not known at the time of instantiation, then use 
    69         #this function to examine the file and return the correct interface (if it exists). 
    70         fileExtension = str(filename)[-3:] 
    71         if fileExtension == '.nc': 
    72             return cdunifInterface() 
    73         if fileExtension == 'qxf': 
    74             return cdunifInterface() 
    75         elif fileExtension == '.pp': 
    76             return cdunifInterface() 
    77         elif fileExtension == 'ctl': 
    78             return cdunifInterface() 
    79         elif fileExtension == 'xml': 
    80             return cdmlInterface() 
    81         elif fileExtensions == 'png' or fileExtension == 'gif': 
    82             return ImageFileInterface() 
    83         else: 
    84             try: 
    85                 nappy.readFFI(filename) in [1001,1010,1020,2010,2110,2160,2310,3010,4010] 
    86                 return NappyInterface() 
    87             except: 
    88                 print "Could not establish file type" 
    89                 print "See csmldataiface.py" 
    90         #hdf test here 
    91         elif 1==1: 
    92             return HDF5Interface() 
    93      
    94                              
    95 class AbstractDI(object):         
    96     #Abstract data interface class 
    97     #does nothing, but contains templates for methods required for a data interface class 
    98     #individual interfaces (e.g NappyInterface) should override these methods 
    99  
    100     def __init__(self): 
    101         self.extractType='' 
    102         self.extractPrefix = '' 
    103                      
    104     def openFile(self, filename): 
    105        #opens file, must be overwritten by subclass 
     48        #Use DataInterface and setInterfaceType to instantiate the correct 
     49        #subclass for data  
     50        def __init__(self): 
     51                self.iface ='None' 
     52                 
     53        def setInterfaceType(self,interfaceType): 
     54                # function returns approprate data interface 
     55                #set interfaceType: should correspond to available datainterface subclasses 
     56                self.iface =interfaceType 
     57                if self.iface == 'nappy': 
     58                        return NappyInterface() 
     59                elif self.iface == 'cdunif': 
     60                        return cdunifInterface() 
     61                elif self.iface == 'raw': 
     62                        return RawFileInterface() 
     63                elif self.iface == 'image': 
     64                        return ImageFileInterface() 
     65                 
     66                 
     67        def getUnknownInterfaceType(self, filename): 
     68                #if the interface type is not known at the time of instantiation, then use 
     69                #this function to examine the file and return the correct interface (if it exists). 
     70                fileExtension = str(filename)[-3:] 
     71                if fileExtension == '.nc': 
     72                        return cdunifInterface() 
     73                if fileExtension == 'qxf': 
     74                        return cdunifInterface() 
     75                elif fileExtension == '.pp': 
     76                        return cdunifInterface() 
     77                elif fileExtension == 'ctl': 
     78                        return cdunifInterface() 
     79                elif fileExtension == 'xml': 
     80                        return cdmlInterface() 
     81                elif fileExtensions == 'png' or fileExtension == 'gif': 
     82                        return ImageFileInterface() 
     83                else: 
     84                        try: 
     85                                nappy.readFFI(filename) in [1001,1010,1020,2010,2110,2160,2310,3010,4010] 
     86                                return NappyInterface() 
     87                        except: 
     88                                print "Could not establish file type" 
     89                                print "See csmldataiface.py" 
     90                         
     91         
     92                                                         
     93class AbstractDI(object):                
     94        #Abstract data interface class 
     95        #does nothing, but contains templates for methods required for a data interface class 
     96        #individual interfaces (e.g NappyInterface) should override these methods 
     97 
     98        def __init__(self): 
     99                self.extractType='' 
     100                self.extractPrefix = '' 
     101                                         
     102        def openFile(self, filename): 
     103           #opens file, must be overwritten by subclass 
    106104            raise NotImplementedError  
    107          
    108     def closeFile(self): 
    109        #closes file, probably needs to be overwritten by subclass 
    110         try: 
     105                 
     106        def closeFile(self): 
     107           #closes file, probably needs to be overwritten by subclass 
     108            try: 
    111109                self.file.close() 
    112110            except: 
     
    117115           #this may just involve a stub (see NASAAmes interface) or may involve 
    118116           #calling a real set method of the underlying api (see cdunif Interface) 
    119        raise NotImplementedError  
    120              
     117           raise NotImplementedError  
     118                         
    121119        def getDataForAxis(self): 
    122120            #return all data for axis, must be overwritten by subclass 
    123        raise NotImplementedError     
     121           raise NotImplementedError     
    124122         
    125123        def setVariable(self,varname): 
     
    129127        def getDataForVar(self): 
    130128            #return all data for variable, must be overwritten by subclass 
    131        raise NotImplementedError     
     129           raise NotImplementedError     
    132130         
    133131        def getSubsetOfDataForVar(self,**kwargs): 
     
    136134         
    137135         
    138 class NappyInterface(AbstractDI):     
    139     # Data Interface for Nappy (NASA Ames Processing in Python) 
     136class NappyInterface(AbstractDI):        
     137        # Data Interface for Nappy (NASA Ames Processing in Python) 
    140138     
    141     def __init__(self): 
    142         self.extractType='NASAAmesExtract' 
    143         self.extractPrefix = '_naextract_' 
    144                      
    145     def openFile(self, filename): 
    146         #print 'opening NA file: ' + str(filename) 
    147         self.file=nappy.openNAFile(filename) 
    148         #print 'reading data....' 
    149         #self.file.readData() 
    150         #print 'nappyopen ' + filename 
    151  
    152     def getListOfAxes(self): 
    153         axes=self.file.XNAME 
    154         #print 'before units stripped' + str(axes) 
    155         axes=self.stripunits(axes) 
    156         #print 'after units stripped' + str(axes) 
    157         return axes 
    158  
    159     def setAxis(self,axis): 
    160         axes = self.getListOfAxes() 
    161         self.axisstub=axes.index(axis) 
    162  
    163     def getAxisAttribute(self, att): 
    164         #need to do something here...? maybe 
    165         attValue=None 
    166         return attValue 
    167  
    168     def getTimeUnits(self): 
    169         axes = self.getListOfAxes() 
    170         for axis in axes: 
     139        def __init__(self): 
     140                self.extractType='NASAAmesExtract' 
     141                self.extractPrefix = '_naextract_' 
     142                                         
     143        def openFile(self, filename): 
     144                #print 'opening NA file: ' + str(filename) 
     145                self.file=nappy.openNAFile(filename) 
     146                #print 'reading data....' 
     147                #self.file.readData() 
     148                #print 'nappyopen ' + filename 
     149 
     150        def getListOfAxes(self): 
     151                axes=self.file.XNAME 
     152                #print 'before units stripped' + str(axes) 
     153                axes=self.stripunits(axes) 
     154                #print 'after units stripped' + str(axes) 
     155                return axes 
     156 
     157        def setAxis(self,axis): 
     158                axes = self.getListOfAxes() 
     159                self.axisstub=axes.index(axis) 
     160 
     161        def getAxisAttribute(self, att): 
     162                #need to do something here...? maybe 
     163                attValue=None 
     164                return attValue 
     165 
     166        def getTimeUnits(self): 
     167                axes = self.getListOfAxes() 
     168                for axis in axes: 
    171169                        if string.find(string.upper(axis),'SECONDS SINCE') != -1: 
    172                 #found possible time axis. 
    173                 if axis[-3:]=='UTC': 
     170                                #found possible time axis. 
     171                                if axis[-3:]=='UTC': 
    174172                                    units =string.lower(axis[:-4]) #hack! 
    175173                                    units=units.replace('/','-') #try and clean it up 
    176174                                else: 
    177175                                    units=string.lower(axis) 
    178                     break 
     176                                break 
    179177                        elif string.find(string.upper(axis),'HOURS SINCE') != -1: 
    180                 #found possible time axis. 
    181                 units =(str(axis)) 
    182                     break 
     178                                #found possible time axis. 
     179                                units =(str(axis)) 
     180                                break 
    183181                        elif string.find(string.upper(axis),'DAYS SINCE') != -1: 
    184                 #found possible time axis. 
    185                 units =(str(axis)) 
    186                     break 
     182                                #found possible time axis. 
     183                                units =(str(axis)) 
     184                                break 
    187185                         
    188         #revisit with udunits python library? 
    189         return units 
    190  
    191  
    192     def getDataForAxis(self):            
     186                #revisit with udunits python library? 
     187                return units 
     188 
     189 
     190        def getDataForAxis(self):            
    193191            if self.file.X == None: 
    194192                    #print 'reading data....' 
     
    210208            return data 
    211209 
    212     def getSizeOfAxis(self,axis): 
    213  
    214         #check this function is okay 
    215         #is time always the first dimension in NA?? 
    216         axes = self.getListOfAxes() 
    217         axisPosition=axes.index(axis) 
    218         #print "axis position" + str( axisPosition) 
    219         #print "NX" + str(self.file.NX) 
    220         try : 
    221             axisSize=self.file.NX[axisPosition-1] 
    222         except: 
    223             axisSize ='Unknown axis size' 
    224         return axisSize 
    225  
    226     def getListofVariables(self): 
    227         variableList=self.stripunits(self.file.VNAME) 
    228         return variableList 
    229  
    230     def setVariable(self,varname): 
    231         vlist=self.getListofVariables() 
    232         self.varstub=vlist.index(varname) 
    233  
    234     def getVariableAxes(self): 
    235         #hmm, now with Nasa Ames the Axis will be the same for all variables. 
    236         #so just use the getListOfAxes function again 
    237         #I think... check this! 
    238         varAxesList=self.getListOfAxes() 
    239         return varAxesList 
    240  
    241     def getVariableAttribute(self,attName): 
    242         if attName =='units': 
    243             #strip the units (attribute) from the variable 
    244             unitslist=self.getUnits(self.file.VNAME) 
    245             attribValue = unitslist[self.varstub] 
    246             try: 
    247                 attribValue = unitslist[self.varstub] 
    248             except: 
    249                 attribValue = 'unknown' 
    250         else: 
    251             attribValue = 'unknown' 
    252         return attribValue 
    253  
    254     def getDataForVar(self): 
     210        def getSizeOfAxis(self,axis): 
     211 
     212                #check this function is okay 
     213                #is time always the first dimension in NA?? 
     214                axes = self.getListOfAxes() 
     215                axisPosition=axes.index(axis) 
     216                #print "axis position" + str( axisPosition) 
     217                #print "NX" + str(self.file.NX) 
     218                try : 
     219                        axisSize=self.file.NX[axisPosition-1] 
     220                except: 
     221                        axisSize ='Unknown axis size' 
     222                return axisSize 
     223 
     224        def getListofVariables(self): 
     225                variableList=self.stripunits(self.file.VNAME) 
     226                return variableList 
     227 
     228        def setVariable(self,varname): 
     229                vlist=self.getListofVariables() 
     230                self.varstub=vlist.index(varname) 
     231 
     232        def getVariableAxes(self): 
     233                #hmm, now with Nasa Ames the Axis will be the same for all variables. 
     234                #so just use the getListOfAxes function again 
     235                #I think... check this! 
     236                varAxesList=self.getListOfAxes() 
     237                return varAxesList 
     238 
     239        def getVariableAttribute(self,attName): 
     240                if attName =='units': 
     241                        #strip the units (attribute) from the variable 
     242                        unitslist=self.getUnits(self.file.VNAME) 
     243                        attribValue = unitslist[self.varstub] 
     244                        try: 
     245                                attribValue = unitslist[self.varstub] 
     246                        except: 
     247                                attribValue = 'unknown' 
     248                else: 
     249                        attribValue = 'unknown' 
     250                return attribValue 
     251 
     252        def getDataForVar(self): 
    255253            #NOTE TO SELF: 
    256254            #Review this function (and in fact all of nasa ames data interface...) 
    257         if self.file.V == None: 
    258             #print 'reading data....' 
    259             self.file.readData() 
    260  
    261         try: 
     255                if self.file.V == None: 
     256                        #print 'reading data....' 
     257                        self.file.readData() 
     258 
     259                try: 
    262260                    if type(self.file.V[1])==list: 
    263261                        data = self.file.V[self.varstub] 
    264         #else: 
    265         #    data =self.file.X 
    266         #    print data 
     262                #else: 
     263                #       data =self.file.X 
     264                #       print data 
    267265                    return data 
    268266                except: 
     
    271269                    return data 
    272270 
    273     def getArraySizeOfVar(self): 
    274     #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27 
    275  
    276         dimlist=self.file.NX 
    277         varsize =1 
    278         for item in dimlist: 
    279             varsize = varsize * item 
    280             #print "VARSISZE" + str(varsize) 
    281         return varsize 
    282  
    283     def getShapeOfVar(self): 
     271        def getArraySizeOfVar(self): 
     272        #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27 
     273 
     274                dimlist=self.file.NX 
     275                varsize =1 
     276                for item in dimlist: 
     277                        varsize = varsize * item 
     278                        #print "VARSISZE" + str(varsize) 
     279                return varsize 
     280 
     281        def getShapeOfVar(self): 
    284282            #this should return a list. 
    285283            varShape = [] 
     
    288286            return varShape 
    289287 
    290     def getLowLimits(self): 
    291         lowlims = "" 
    292         for i in range (0, len(self.file.NX)): 
    293             #for now, assume low limit is always of form 1 1 1 .. 
    294             lowlims =lowlims + str(1)  +' ' 
    295         return lowlims 
    296  
    297     def getHighLimits(self): 
    298         highlims = "" 
    299         for i in range (0, len(self.file.NX)): 
    300             dimValue = self.file.NX[i] 
    301             highlims =highlims  + str(dimValue) +' ' 
    302         return highlims 
    303  
    304  
    305     def stripunits(self,listtostrip): 
    306         #strips units of measure from list 
    307         #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)'] 
    308         #becomes ['Universal time', 'Altitude', 'Latitude', 'Longitude'] 
    309         cleanlist = [] 
    310         for item in listtostrip: 
    311             openbracket=string.find(item,'(') 
    312             if openbracket != -1: 
    313                 #if brackets exist, strip units. 
    314                 item=item[:openbracket-1] 
    315             cleanlist.append(item) 
    316         return cleanlist 
    317  
    318     def getUnits(self,listwithunits): 
    319         #gets units from list 
    320         #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)'] 
    321         #becomes ['hours', 'km', 'degrees', 'degrees'] 
    322         unitlist=[] 
    323         for item in listwithunits: 
    324             openbracket=string.find(item,'(') 
    325             item = item[openbracket+1:-1] 
    326             unitlist.append(item) 
    327         return unitlist 
    328  
    329     def getTimes(self): 
    330         #This function attempts to determine the time axis and read the time data 
    331         #it may well not manage it. 
    332         axes = self.getListOfAxes() 
    333         for axis in axes: 
    334             if string.find(string.upper(axis),'TIME') != -1: 
    335                 #found possible time axis. 
    336                 self.setAxis(axis) 
    337                 times=self.getDataForAxis() 
    338                     break 
     288        def getLowLimits(self): 
     289                lowlims = "" 
     290                for i in range (0, len(self.file.NX)): 
     291                        #for now, assume low limit is always of form 1 1 1 .. 
     292                        lowlims =lowlims + str(1)  +' ' 
     293                return lowlims 
     294 
     295        def getHighLimits(self): 
     296                highlims = "" 
     297                for i in range (0, len(self.file.NX)): 
     298                        dimValue = self.file.NX[i] 
     299                        highlims =highlims  + str(dimValue) +' ' 
     300                return highlims 
     301 
     302 
     303        def stripunits(self,listtostrip): 
     304                #strips units of measure from list 
     305                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)'] 
     306                #becomes ['Universal time', 'Altitude', 'Latitude', 'Longitude'] 
     307                cleanlist = [] 
     308                for item in listtostrip: 
     309                        openbracket=string.find(item,'(') 
     310                        if openbracket != -1: 
     311                                #if brackets exist, strip units. 
     312                                item=item[:openbracket-1] 
     313                        cleanlist.append(item) 
     314                return cleanlist 
     315 
     316        def getUnits(self,listwithunits): 
     317                #gets units from list 
     318                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)'] 
     319                #becomes ['hours', 'km', 'degrees', 'degrees'] 
     320                unitlist=[] 
     321                for item in listwithunits: 
     322                        openbracket=string.find(item,'(') 
     323                        item = item[openbracket+1:-1] 
     324                        unitlist.append(item) 
     325                return unitlist 
     326 
     327        def getTimes(self): 
     328                #This function attempts to determine the time axis and read the time data 
     329                #it may well not manage it. 
     330                axes = self.getListOfAxes() 
     331                for axis in axes: 
     332                        if string.find(string.upper(axis),'TIME') != -1: 
     333                                #found possible time axis. 
     334                                self.setAxis(axis) 
     335                                times=self.getDataForAxis() 
     336                                break 
    339337                        elif string.find(string.upper(axis),'SECONDS SINCE') != -1: 
    340                 #found possible time axis. 
    341                 self.setAxis(axis) 
    342                 times=self.getDataForAxis() 
    343                     break 
     338                                #found possible time axis. 
     339                                self.setAxis(axis) 
     340                                times=self.getDataForAxis() 
     341                                break 
    344342                        elif string.find(string.upper(axis),'HOURS SINCE') != -1: 
    345                 #found possible time axis. 
    346                 self.setAxis(axis) 
    347                 times=self.getDataForAxis() 
    348                     break 
     343                                #found possible time axis. 
     344                                self.setAxis(axis) 
     345                                times=self.getDataForAxis() 
     346                                break 
    349347                        elif string.find(string.upper(axis),'DAYS SINCE') != -1: 
    350                 #found possible time axis. 
    351                 self.setAxis(axis) 
    352                 times=self.getDataForAxis() 
    353                     break 
     348                                #found possible time axis. 
     349                                self.setAxis(axis) 
     350                                times=self.getDataForAxis() 
     351                                break 
    354352                times=Numeric.array(times) 
    355353                return times 
    356          
     354 
     355 
     356 
    357357class cdunifInterface(AbstractDI): 
    358358    #Data Interface for cdunif (netcdf & pp formats & grib (not tested with grib) 
Note: See TracChangeset for help on using the changeset viewer.