source: TI02-CSML/trunk/Scanner/csmllibs/csmldataiface.py @ 1085

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/Scanner/csmllibs/csmldataiface.py@1085
Revision 1085, 10.4 KB checked in by domlowe, 14 years ago (diff)

Scanner now picks up long_name and units

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#!/usr/bin/env python
2
3#**************************************************************************************
4#csmldataIface.py
5#contains classes for interfacing with various files
6#currently supports cdunif (NetCDF, PP, Grib(untested)) And Nappy (NASAAmes)
7#use by instantiating the factory class: DataInterface
8#v0.00 30th November 2005
9#Dominic Lowe, BADC
10#**************************************************************************************
11
12
13import cdms 
14import nappy 
15import string
16import sys
17
18class DataInterface:
19        #Use DataInterface and setInterfaceType to instantiate the correct
20        #subclass for data
21        def __init__(self):
22                self.iface ='None'
23               
24        def setInterfaceType(self,interfaceType):
25                # function returns approprate data interface
26                #set interfaceType: should correspond to available datainterface subclasses
27                self.iface =interfaceType
28                if self.iface == 'nappy':
29                        return NappyInterface()
30                elif self.iface == 'cdunif':
31                        return cdunifInterface()
32               
33               
34        def getUnknownInterfaceType(self, filename):
35                #if the interface type is not known at the time of instantiation, then use
36                #this function to examine the file and return the correct interface (if it exists).
37                fileExtension = str(filename)[-3:]
38                if fileExtension == '.nc':
39                        return cdunifInterface()
40                elif fileExtension == '.pp':
41                        return cdunifInterface()
42                elif fileExtension == 'ctl':
43                        return cdunifInterface()
44                else:
45                        try:
46                                nappy.readFFI(filename) in [1001,1010,1020,2010,2110,2160,2310,3010,4010]
47                                return NappyInterface()
48                        except:
49                                print "Could not establish file type"
50                                print "See csmldataiface.py"
51                       
52       
53                                                       
54class AbstractDI:               
55        #Abstract data interface class
56        #does nothing, but contains templates for methods required for a data interface class
57        #individual interfaces (e.g NappyInterface) should override these methods
58
59        def __init__(self):
60                self.extractType=''
61                self.extractPrefix = ''
62                                       
63        def openFile(self, filename):
64                #opens file
65                self.file=''
66               
67        def closeFile(self):
68                #closes file
69                self.file.close()
70                       
71               
72               
73class NappyInterface(AbstractDI):       
74        # Data Interface for Nappy (NASA Ames Processing in Python)
75   
76        def __init__(self):
77                self.extractType='NASAAmesExtract'
78                self.extractPrefix = '_naextract_'
79                                         
80        def openFile(self, filename):
81                print 'opening NA file: ' + str(filename)
82                self.file=nappy.openNAFile(filename)
83                #print 'reading data....'
84                #self.file.readData()
85                #print 'nappyopen ' + filename
86       
87        def getListOfAxes(self):
88                axes=self.file.XNAME
89                #print 'before units stripped' + str(axes)
90                axes=self.stripunits(axes)
91                #print 'after units stripped' + str(axes)
92                return axes
93       
94        def setAxis(self,axis):
95                axes = self.getListOfAxes()
96                self.axisstub=axes.index(axis)
97               
98        def getAxisAttribute(self, att):
99                        #need to do something here...? maybe
100                pass
101                return attValue
102       
103        def getTimeUnits(self):
104                units ='?'
105                #revisit with udunits python library?
106                return units
107               
108       
109        def getDataForAxis(self):
110
111                if self.file.X == None:
112                        #print 'reading data....'
113                        self.file.readData()
114                                               
115                if type(self.file.X[1])==list:
116                #if len(self.file.X) > 0:
117                        data = self.file.X[self.axisstub]
118                else:
119                        data =self.file.X
120                return data
121               
122        def getSizeOfAxis(self,axis):
123                               
124                #check this function is okay
125                #is time always the first dimension in NA??
126                axes = self.getListOfAxes()
127                axisPosition=axes.index(axis)
128                #print "axis position" + str( axisPosition)
129                #print "NX" + str(self.file.NX)
130                try :
131                        axisSize=self.file.NX[axisPosition-1]
132                except:
133                        axisSize ='Unknown axis size'
134                return axisSize
135               
136        def getListofVariables(self):
137                variableList=self.stripunits(self.file.VNAME)
138                return variableList
139       
140        def setVariable(self,varname):
141                vlist=self.getListofVariables()
142                self.varstub=vlist.index(varname)
143       
144        def getVariableAxes(self):
145                #hmm, now with Nasa Ames the Axis will be the same for all variables.
146                #so just use the getListOfAxes function again
147                #I think... check this!
148                varAxesList=self.getListOfAxes()               
149                return varAxesList
150       
151        def getVariableAttribute(self,attName):
152                if attName =='units':
153                        #strip the units (attribute) from the variable
154                        unitslist=self.getUnits(self.file.VNAME)
155                        attribValue = unitslist[self.varstub]
156                        try:
157                                attribValue = unitslist[self.varstub]
158                        except:
159                                attribValue = 'unknown'
160                else:
161                        attribValue = 'unknown'
162                return attribValue
163       
164        def getDataForVar(self):
165            #NOTE TO SELF:
166            #Review this function (and in fact all of nasa ames data interface...)
167                if self.file.V == None:
168                        #print 'reading data....'
169                        self.file.readData()
170                               
171                try:
172                    if type(self.file.V[1])==list:
173                        data = self.file.V[self.varstub]
174                #else:
175                #       data =self.file.X
176                #       print data
177                    return data         
178                except:
179                    data = self.file.X
180                   # print data
181                    return data
182       
183        def getArraySizeOfVar(self):
184        #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27
185           
186                dimlist=self.file.NX
187                varsize =1
188                for item in dimlist:
189                        varsize = varsize * item
190                        #print "VARSISZE" + str(varsize)
191                return varsize 
192       
193        def getShapeOfVar(self):
194            #this should return a list.
195            varShape = []
196            for item in self.file.NX:
197                varShape.append(item)
198            return varShape
199       
200        def getLowLimits(self):
201                lowlims = ""
202                for i in range (0, len(self.file.NX)):
203                        #for now, assume low limit is always of form 1 1 1 ..
204                        lowlims =lowlims + str(1)  +' '
205                return lowlims
206               
207        def getHighLimits(self):
208                highlims = ""
209                for i in range (0, len(self.file.NX)):
210                        dimValue = self.file.NX[i] 
211                        highlims =highlims  + str(dimValue) +' '
212                return highlims
213       
214
215        def stripunits(self,listtostrip):
216                #strips units of measure from list
217                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)']
218                #becomes ['Universal time', 'Altitude', 'Latitude', 'Longitude']
219                cleanlist = []
220                for item in listtostrip:
221                        openbracket=string.find(item,'(')
222                        if openbracket != -1:
223                                #if brackets exist, strip units.
224                                item=item[:openbracket-1]
225                        cleanlist.append(item)
226                return cleanlist
227               
228        def getUnits(self,listwithunits):
229                #gets units from list
230                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)']
231                #becomes ['hours', 'km', 'degrees', 'degrees']
232                unitlist=[]
233                for item in listwithunits:
234                        openbracket=string.find(item,'(')
235                        item = item[openbracket+1:-1]
236                        unitlist.append(item)
237                return unitlist
238       
239        def getTimes(self):
240                #This function attempts to determine the time axis and read the time data
241                #it may well not manage it.
242                axes = self.getListOfAxes()
243                for axis in axes:
244                        if string.find(string.upper(axis),'TIME') != -1:
245                                #found possible time axis.
246                                self.setAxis(axis)
247                                times=self.getDataForAxis()
248                                break
249                return times
250                       
251               
252               
253class cdunifInterface(AbstractDI):
254    #Data Interface for cdunif (netcdf & pp formats & grib (not tested with grib)
255   
256    def __init__(self):
257        #these are just temporary values until we can determine whether the
258        #file is netcdf pp or grib             
259        self.extractType='cdunifExtract'
260        self.extractPrefix = '_cdunifextract_'
261       
262    def openFile(self, filename):
263        self.file=cdms.open(filename)
264        print 'cdunifopen ' + filename
265       
266        #now we have the file name can properly determine extractType/Prefix
267        fileExtension = str(filename)[-3:]
268        if fileExtension == '.nc':
269            self.extractType = 'NetCDFExtract'
270            self.extractPrefix = '_ncextract_'
271        elif fileExtension == '.pp':
272            self.extractType  = 'PPExtract'
273            self.extractPrefix = '_ppextract_'
274        elif fileExtension == '.ctl':
275            self.extractType = 'GRIBExtract'
276            self.extractPrefix = '_gribextract_'
277
278    def getListOfAxes(self):
279        axes=self.file.dimensions.keys()
280        return axes
281   
282    def getSizeOfAxis(self,axis):
283        axisSize=self.file.dimensions[axis]
284        return axisSize                         
285   
286    def getListofVariables(self):
287        variableList=self.file.variables.keys()
288        return variableList
289   
290    def setAxis(self,axis):
291        self.axisobj=self.file.getAxis(axis)
292                                                                       
293    def getAxisAttribute(self, att):
294        attValue=self.axisobj.attributes[att]
295        return attValue
296       
297    def getTimeUnits(self):
298        #this does the same as getAxisAttribute, but is a separate function as different formats handle time differently.
299        return self.getAxisAttribute('units')
300               
301    def getDataForAxis(self):
302        data = self.axisobj.getValue()
303        return data
304
305    def setVariable(self,varname):
306        self.varobj=self.file.variables[varname]
307   
308    def getVariableAxes(self):
309        varAxesList=self.varobj.getAxisIds()
310        return varAxesList
311
312    def getVariableAttribute(self,attName):
313       
314        #atts=self.varobj.getattributes(attName)
315        #print atts
316        if attName == 'long_name':
317            attribValue = self.varobj.long_name
318        elif attName == 'units':
319            attribValue = self.varobj.units
320           
321           
322        return attribValue
323
324    def getDataForVar(self):
325        data = self.varobj.getValue()
326        return data
327   
328    def getSubsetOfDataForVar(self, **kwargs):
329        #takes keyword args defining subset eg
330        #subset=getSubsetOfDataForVar(latitude=(0.,10.0), longitude=(90, 100.0))
331        sel=cdms.selectors.Selector(**kwargs)
332        subset=self.file(self.varobj.name,sel)
333        data = subset.getValue()
334        return data
335
336    def getArraySizeOfVar(self):
337    #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27
338        var = self.varobj
339        size = var.shape
340        varsize = 1
341        for item in size:
342            varsize = item *varsize
343        return varsize
344   
345    def getShapeOfVar(self):
346        varShape = []
347        for item in self.varobj.shape:
348            varShape.append(item)
349        return varShape
350   
351    def getLowLimits(self):
352        dimNames = self.varobj.getAxisIds()
353        lowlims = ""
354        for i in range (1, len(dimNames)):
355            #for now, assume low limit is always of form 1 1 1 ..
356            lowlims =lowlims + str(1)  +' '
357        return lowlims
358       
359    def getHighLimits(self):
360        dimNames = self.varobj.getAxisIds()
361        highlims = ""
362        for i in range (1, len(dimNames)):
363            dimValue = self.file.dimensions[dimNames[i]] 
364            highlims =highlims  + str(dimValue) +' '
365        return highlims
366       
367   
368
369       
Note: See TracBrowser for help on using the repository browser.