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

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

fixed problem with arraySize list/tuple/string confusion

  • 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                print"axis" + axis
127                axes = self.getListOfAxes()
128                print axes
129                print "listlength" +str(len(axes))
130                axisPosition=axes.index(axis)
131                print "axis position" + str( axisPosition)
132                print "NX" + str(self.file.NX)
133                try :
134                        axisSize=self.file.NX[axisPosition-1]
135                except:
136                        axisSize ='Unknown axis size'
137                return axisSize
138               
139        def getListofVariables(self):
140                variableList=self.stripunits(self.file.VNAME)
141                return variableList
142       
143        def setVariable(self,varname):
144                vlist=self.getListofVariables()
145                self.varstub=vlist.index(varname)
146       
147        def getVariableAxes(self):
148                #hmm, now with Nasa Ames the Axis will be the same for all variables.
149                #so just use the getListOfAxes function again
150                #I think... check this!
151                varAxesList=self.getListOfAxes()               
152                return varAxesList
153       
154        def getVariableAttribute(self,attName):
155                if attName =='units':
156                        #strip the units (attribute) from the variable
157                        unitslist=self.getUnits(self.file.VNAME)
158                        attribValue = unitslist[self.varstub]
159                        try:
160                                attribValue = unitslist[self.varstub]
161                        except:
162                                attribValue = 'unknown'
163                else:
164                        attribValue = 'unknown'
165                return attribValue
166       
167        def getDataForVar(self):
168                if self.file.V == None:
169                        #print 'reading data....'
170                        self.file.readData()
171                               
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               
179               
180                data = self.file.X
181                print data
182                return data
183       
184        def getArraySizeOfVar(self):
185        #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27
186           
187                dimlist=self.file.NX
188                varsize =1
189                for item in dimlist:
190                        varsize = varsize * item
191                        print "VARSISZE" + str(varsize)
192                return varsize 
193       
194        def getShapeOfVar(self):
195            #this should return a list.
196            varShape = []
197            for item in self.file.NX:
198                varShape.append(item)
199            return varshape
200       
201        def getLowLimits(self):
202                lowlims = ""
203                for i in range (0, len(self.file.NX)):
204                        #for now, assume low limit is always of form 1 1 1 ..
205                        lowlims =lowlims + str(1)  +' '
206                return lowlims
207               
208        def getHighLimits(self):
209                highlims = ""
210                for i in range (0, len(self.file.NX)):
211                        dimValue = self.file.NX[i] 
212                        highlims =highlims  + str(dimValue) +' '
213                return highlims
214       
215
216        def stripunits(self,listtostrip):
217                #strips units of measure from list
218                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)']
219                #becomes ['Universal time', 'Altitude', 'Latitude', 'Longitude']
220                cleanlist = []
221                for item in listtostrip:
222                        openbracket=string.find(item,'(')
223                        if openbracket != -1:
224                                #if brackets exist, strip units.
225                                item=item[:openbracket-1]
226                        cleanlist.append(item)
227                return cleanlist
228               
229        def getUnits(self,listwithunits):
230                #gets units from list
231                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)']
232                #becomes ['hours', 'km', 'degrees', 'degrees']
233                unitlist=[]
234                for item in listwithunits:
235                        openbracket=string.find(item,'(')
236                        item = item[openbracket+1:-1]
237                        unitlist.append(item)
238                return unitlist
239       
240        def getTimes(self):
241                #This function attempts to determine the time axis and read the time data
242                #it may well not manage it.
243                axes = self.getListOfAxes()
244                for axis in axes:
245                        if string.find(string.upper(axis),'TIME') != -1:
246                                #found possible time axis.
247                                self.setAxis(axis)
248                                times=self.getDataForAxis()
249                                break
250                return times
251                       
252               
253               
254class cdunifInterface(AbstractDI):
255    #Data Interface for cdunif (netcdf & pp formats & grib (not tested with grib)
256   
257    def __init__(self):
258        #these are just temporary values until we can determine whether the
259        #file is netcdf pp or grib             
260        self.extractType='cdunifExtract'
261        self.extractPrefix = '_cdunifextract_'
262        print "hello"
263       
264    def openFile(self, filename):
265        self.file=cdms.open(filename)
266        print 'cdunifopen ' + filename
267       
268        #now we have the file name can properly determine extractType/Prefix
269        fileExtension = str(filename)[-3:]
270        if fileExtension == '.nc':
271            self.extractType = 'NetCDFExtract'
272            self.extractPrefix = '_ncextract_'
273        elif fileExtension == '.pp':
274            self.extractType  = 'PPExtract'
275            self.extractPrefix = '_ppextract_'
276        elif fileExtension == '.ctl':
277            self.extractType = 'GRIBExtract'
278            self.extractPrefix = '_gribextract_'
279
280    def getListOfAxes(self):
281        axes=self.file.dimensions.keys()
282        return axes
283   
284    def getSizeOfAxis(self,axis):
285        axisSize=self.file.dimensions[axis]
286        return axisSize                         
287   
288    def getListofVariables(self):
289        variableList=self.file.variables.keys()
290        return variableList
291   
292    def setAxis(self,axis):
293        self.axisobj=self.file.getAxis(axis)
294                                                                       
295    def getAxisAttribute(self, att):
296        attValue=self.axisobj.attributes[att]
297        return attValue
298       
299    def getTimeUnits(self):
300        #this does the same as getAxisAttribute, but is a separate function as different formats handle time differently.
301        return self.getAxisAttribute('units')
302               
303    def getDataForAxis(self):
304        data = self.axisobj.getValue()
305        return data
306
307    def setVariable(self,varname):
308        self.varobj=self.file.variables[varname]
309   
310    def getVariableAxes(self):
311        varAxesList=self.varobj.getAxisIds()
312        return varAxesList
313
314    def getVariableAttribute(self,attName):
315        attribValue = self.varobj.attName
316        return attribValue
317
318    def getDataForVar(self):
319        data = self.varobj.getValue()
320        return data
321
322    def getArraySizeOfVar(self):
323    #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27
324        var = self.varobj
325        size = var.shape
326        varsize = 1
327        for item in size:
328            varsize = item *varsize
329        return varsize
330   
331    def getShapeOfVar(self):
332        varShape = []
333        for item in self.varobj.shape:
334            varShape.append(item)
335        return varShape
336   
337    def getLowLimits(self):
338        dimNames = self.varobj.getAxisIds()
339        lowlims = ""
340        for i in range (1, len(dimNames)):
341            #for now, assume low limit is always of form 1 1 1 ..
342            lowlims =lowlims + str(1)  +' '
343        return lowlims
344       
345    def getHighLimits(self):
346        dimNames = self.varobj.getAxisIds()
347        highlims = ""
348        for i in range (1, len(dimNames)):
349            dimValue = self.file.dimensions[dimNames[i]] 
350            highlims =highlims  + str(dimValue) +' '
351        return highlims
352       
353   
354
355       
Note: See TracBrowser for help on using the repository browser.