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

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

added getSubsetOfDataForVar method to cdunif datainterface

  • 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            #NOTE TO SELF:
169            #Review this function (and in fact all of nasa ames data interface...)
170                if self.file.V == None:
171                        #print 'reading data....'
172                        self.file.readData()
173                               
174                try:
175                    if type(self.file.V[1])==list:
176                        data = self.file.V[self.varstub]
177                #else:
178                #       data =self.file.X
179                #       print data
180                    return data         
181                except:
182                    data = self.file.X
183                    print data
184                    return data
185       
186        def getArraySizeOfVar(self):
187        #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27
188           
189                dimlist=self.file.NX
190                varsize =1
191                for item in dimlist:
192                        varsize = varsize * item
193                        print "VARSISZE" + str(varsize)
194                return varsize 
195       
196        def getShapeOfVar(self):
197            #this should return a list.
198            varShape = []
199            for item in self.file.NX:
200                varShape.append(item)
201            return varShape
202       
203        def getLowLimits(self):
204                lowlims = ""
205                for i in range (0, len(self.file.NX)):
206                        #for now, assume low limit is always of form 1 1 1 ..
207                        lowlims =lowlims + str(1)  +' '
208                return lowlims
209               
210        def getHighLimits(self):
211                highlims = ""
212                for i in range (0, len(self.file.NX)):
213                        dimValue = self.file.NX[i] 
214                        highlims =highlims  + str(dimValue) +' '
215                return highlims
216       
217
218        def stripunits(self,listtostrip):
219                #strips units of measure from list
220                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)']
221                #becomes ['Universal time', 'Altitude', 'Latitude', 'Longitude']
222                cleanlist = []
223                for item in listtostrip:
224                        openbracket=string.find(item,'(')
225                        if openbracket != -1:
226                                #if brackets exist, strip units.
227                                item=item[:openbracket-1]
228                        cleanlist.append(item)
229                return cleanlist
230               
231        def getUnits(self,listwithunits):
232                #gets units from list
233                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)']
234                #becomes ['hours', 'km', 'degrees', 'degrees']
235                unitlist=[]
236                for item in listwithunits:
237                        openbracket=string.find(item,'(')
238                        item = item[openbracket+1:-1]
239                        unitlist.append(item)
240                return unitlist
241       
242        def getTimes(self):
243                #This function attempts to determine the time axis and read the time data
244                #it may well not manage it.
245                axes = self.getListOfAxes()
246                for axis in axes:
247                        if string.find(string.upper(axis),'TIME') != -1:
248                                #found possible time axis.
249                                self.setAxis(axis)
250                                times=self.getDataForAxis()
251                                break
252                return times
253                       
254               
255               
256class cdunifInterface(AbstractDI):
257    #Data Interface for cdunif (netcdf & pp formats & grib (not tested with grib)
258   
259    def __init__(self):
260        #these are just temporary values until we can determine whether the
261        #file is netcdf pp or grib             
262        self.extractType='cdunifExtract'
263        self.extractPrefix = '_cdunifextract_'
264       
265    def openFile(self, filename):
266        self.file=cdms.open(filename)
267        print 'cdunifopen ' + filename
268       
269        #now we have the file name can properly determine extractType/Prefix
270        fileExtension = str(filename)[-3:]
271        if fileExtension == '.nc':
272            self.extractType = 'NetCDFExtract'
273            self.extractPrefix = '_ncextract_'
274        elif fileExtension == '.pp':
275            self.extractType  = 'PPExtract'
276            self.extractPrefix = '_ppextract_'
277        elif fileExtension == '.ctl':
278            self.extractType = 'GRIBExtract'
279            self.extractPrefix = '_gribextract_'
280
281    def getListOfAxes(self):
282        axes=self.file.dimensions.keys()
283        return axes
284   
285    def getSizeOfAxis(self,axis):
286        axisSize=self.file.dimensions[axis]
287        return axisSize                         
288   
289    def getListofVariables(self):
290        variableList=self.file.variables.keys()
291        return variableList
292   
293    def setAxis(self,axis):
294        self.axisobj=self.file.getAxis(axis)
295                                                                       
296    def getAxisAttribute(self, att):
297        attValue=self.axisobj.attributes[att]
298        return attValue
299       
300    def getTimeUnits(self):
301        #this does the same as getAxisAttribute, but is a separate function as different formats handle time differently.
302        return self.getAxisAttribute('units')
303               
304    def getDataForAxis(self):
305        data = self.axisobj.getValue()
306        return data
307
308    def setVariable(self,varname):
309        self.varobj=self.file.variables[varname]
310   
311    def getVariableAxes(self):
312        varAxesList=self.varobj.getAxisIds()
313        return varAxesList
314
315    def getVariableAttribute(self,attName):
316        attribValue = self.varobj.attName
317        return attribValue
318
319    def getDataForVar(self):
320        data = self.varobj.getValue()
321        return data
322   
323    def getSubsetOfDataForVar(self, **kwargs):
324        #takes keyword args defining subset eg
325        #subset=getSubsetOfDataForVar(latitude=(0.,10.0), longitude=(90, 100.0))
326       
327        subset=self.varobj.subRegion(**kwargs)
328        data = subset.getValue()
329        return data
330
331    def getArraySizeOfVar(self):
332    #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27
333        var = self.varobj
334        size = var.shape
335        varsize = 1
336        for item in size:
337            varsize = item *varsize
338        return varsize
339   
340    def getShapeOfVar(self):
341        varShape = []
342        for item in self.varobj.shape:
343            varShape.append(item)
344        return varShape
345   
346    def getLowLimits(self):
347        dimNames = self.varobj.getAxisIds()
348        lowlims = ""
349        for i in range (1, len(dimNames)):
350            #for now, assume low limit is always of form 1 1 1 ..
351            lowlims =lowlims + str(1)  +' '
352        return lowlims
353       
354    def getHighLimits(self):
355        dimNames = self.varobj.getAxisIds()
356        highlims = ""
357        for i in range (1, len(dimNames)):
358            dimValue = self.file.dimensions[dimNames[i]] 
359            highlims =highlims  + str(dimValue) +' '
360        return highlims
361       
362   
363
364       
Note: See TracBrowser for help on using the repository browser.