Changeset 2843 for TI02-CSML


Ignore:
Timestamp:
23/08/07 15:01:43 (12 years ago)
Author:
domlowe
Message:

adding stubs for hdf read methods

File:
1 edited

Legend:

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

    r2638 r2843  
    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                          
    91          
    92                                                          
    93 class 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 
     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                             
     95class 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 
    104106            raise NotImplementedError  
    105                  
    106         def closeFile(self): 
    107            #closes file, probably needs to be overwritten by subclass 
    108             try: 
     107         
     108    def closeFile(self): 
     109       #closes file, probably needs to be overwritten by subclass 
     110        try: 
    109111                self.file.close() 
    110112            except: 
     
    115117           #this may just involve a stub (see NASAAmes interface) or may involve 
    116118           #calling a real set method of the underlying api (see cdunif Interface) 
    117            raise NotImplementedError  
    118                          
     119       raise NotImplementedError  
     120             
    119121        def getDataForAxis(self): 
    120122            #return all data for axis, must be overwritten by subclass 
    121            raise NotImplementedError     
     123       raise NotImplementedError     
    122124         
    123125        def setVariable(self,varname): 
     
    127129        def getDataForVar(self): 
    128130            #return all data for variable, must be overwritten by subclass 
    129            raise NotImplementedError     
     131       raise NotImplementedError     
    130132         
    131133        def getSubsetOfDataForVar(self,**kwargs): 
     
    134136         
    135137         
    136 class NappyInterface(AbstractDI):        
    137         # Data Interface for Nappy (NASA Ames Processing in Python) 
     138class NappyInterface(AbstractDI):     
     139    # Data Interface for Nappy (NASA Ames Processing in Python) 
    138140     
    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: 
     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: 
    169171                        if string.find(string.upper(axis),'SECONDS SINCE') != -1: 
    170                                 #found possible time axis. 
    171                                 if axis[-3:]=='UTC': 
     172                #found possible time axis. 
     173                if axis[-3:]=='UTC': 
    172174                                    units =string.lower(axis[:-4]) #hack! 
    173175                                    units=units.replace('/','-') #try and clean it up 
    174176                                else: 
    175177                                    units=string.lower(axis) 
    176                                 break 
     178                    break 
    177179                        elif string.find(string.upper(axis),'HOURS SINCE') != -1: 
    178                                 #found possible time axis. 
    179                                 units =(str(axis)) 
    180                                 break 
     180                #found possible time axis. 
     181                units =(str(axis)) 
     182                    break 
    181183                        elif string.find(string.upper(axis),'DAYS SINCE') != -1: 
    182                                 #found possible time axis. 
    183                                 units =(str(axis)) 
    184                                 break 
     184                #found possible time axis. 
     185                units =(str(axis)) 
     186                    break 
    185187                         
    186                 #revisit with udunits python library? 
    187                 return units 
    188  
    189  
    190         def getDataForAxis(self):            
     188        #revisit with udunits python library? 
     189        return units 
     190 
     191 
     192    def getDataForAxis(self):            
    191193            if self.file.X == None: 
    192194                    #print 'reading data....' 
     
    208210            return data 
    209211 
    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): 
     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): 
    253255            #NOTE TO SELF: 
    254256            #Review this function (and in fact all of nasa ames data interface...) 
    255                 if self.file.V == None: 
    256                         #print 'reading data....' 
    257                         self.file.readData() 
    258  
    259                 try: 
     257        if self.file.V == None: 
     258            #print 'reading data....' 
     259            self.file.readData() 
     260 
     261        try: 
    260262                    if type(self.file.V[1])==list: 
    261263                        data = self.file.V[self.varstub] 
    262                 #else: 
    263                 #       data =self.file.X 
    264                 #       print data 
     264        #else: 
     265        #    data =self.file.X 
     266        #    print data 
    265267                    return data 
    266268                except: 
     
    269271                    return data 
    270272 
    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): 
     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): 
    282284            #this should return a list. 
    283285            varShape = [] 
     
    286288            return varShape 
    287289 
    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 
     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 
    337339                        elif string.find(string.upper(axis),'SECONDS SINCE') != -1: 
    338                                 #found possible time axis. 
    339                                 self.setAxis(axis) 
    340                                 times=self.getDataForAxis() 
    341                                 break 
     340                #found possible time axis. 
     341                self.setAxis(axis) 
     342                times=self.getDataForAxis() 
     343                    break 
    342344                        elif string.find(string.upper(axis),'HOURS SINCE') != -1: 
    343                                 #found possible time axis. 
    344                                 self.setAxis(axis) 
    345                                 times=self.getDataForAxis() 
    346                                 break 
     345                #found possible time axis. 
     346                self.setAxis(axis) 
     347                times=self.getDataForAxis() 
     348                    break 
    347349                        elif string.find(string.upper(axis),'DAYS SINCE') != -1: 
    348                                 #found possible time axis. 
    349                                 self.setAxis(axis) 
    350                                 times=self.getDataForAxis() 
    351                                 break 
     350                #found possible time axis. 
     351                self.setAxis(axis) 
     352                times=self.getDataForAxis() 
     353                    break 
    352354                times=Numeric.array(times) 
    353355                return times 
    354  
    355  
    356  
     356         
    357357class cdunifInterface(AbstractDI): 
    358358    #Data Interface for cdunif (netcdf & pp formats & grib (not tested with grib) 
     
    728728      if 'fillValue' in kwargs: 
    729729         self.fillValue = kwargs['fillValue'] 
     730 
     731class HDF5Interface(AbstractDI): 
     732    #Data Interface for HDF5 
     733    def __init__(self): 
     734        self.extractType='hdfExtract' 
     735        self.extractPrefix='_hdfextract_' 
     736     
     737    def openFile(self, filename): 
     738        #some code to open the file 
     739        pass 
     740 
     741    def setAxis(self,axis): 
     742        #some code to set an axis to be queried, may not need to do much, depending on your format 
     743        pass 
     744         
     745    def getDataForAxis(self): 
     746        #some code to return the values for an axis 
     747        return data 
     748 
     749    def setVariable(self,varname): 
     750        #some code to set a variable to be queried, may not need to do much, depending on your format 
     751        pass 
     752 
     753    def getDataForVar(self): 
     754        #some code to return all values for a variable 
     755        return data 
     756 
     757    def getSubsetOfDataForVar(self, **kwargs): 
     758        #takes keyword args defining subset eg 
     759        #subset=getSubsetOfDataForVar(latitude=(0.,10.0), longitude=(90, 100.0), ...) 
     760        #and returns a subset of data for tha variable  
     761        return data 
     762 
     763    def closeFile(self): 
     764        #some code to close the file 
     765        pass 
Note: See TracChangeset for help on using the changeset viewer.