source: CSML/trunk/Coapec/csmllibs/csmldataiface.py @ 57

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/CSML/trunk/Coapec/csmllibs/csmldataiface.py@57
Revision 57, 9.0 KB checked in by domlowe, 15 years ago (diff)

some minor bug fixes

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