source: TI02-CSML/trunk/Scanner/csmllibs/csmlfeaturetypes.py @ 758

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

major rewrite of Scanner to employ Parser module. (not complete)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#!/usr/bin/env python
2#**************************************************************************************
3#csmlfeaturetypes.py
4#For creating CSML featuretypes
5#v0.5 split off 11th November 2005
6#Dominic Lowe, BADC
7#**************************************************************************************
8
9import csmllibs
10
11
12class featureBuilder:
13    def __init__(self, dataset_element, gml_FeatureCollection_element,extractType, extractPrefix, ffmap,fileExtractDictionary, timedim):
14        self.ds_element=dataset_element
15        self.gml_FeatureCollection_element = gml_FeatureCollection_element
16        self.extractType = extractType
17        self.extractPrefix = extractPrefix
18        self.ffmap = ffmap
19        self.fileExtractDictionary = fileExtractDictionary
20        self.timedim = timedim
21       
22        #empty list to hold featureMembers
23        self.fms =[]
24       
25        #at the moment, only one featuretype per CSML Dataset is supported.
26        #get the featuretype of the first representative file in the ffmap object
27        self.featuretype=  self.ffmap.getRepresentativeFiles()[0].getFeatureType()
28       
29        print "FEATURETYPE: " + str(self.featuretype)
30        if self.featuretype == 'GridSeriesFeature':
31            self.createCSMLGridSeriesFeatures()
32        elif self.featuretype == 'PointSeriesFeature':       
33            self.createCSMLPointSeriesFeatures()
34   
35    def createCSMLGridSeriesFeatures(self):
36        #This function is for model data and assumes that the variables (features) are shared across identically structured files
37        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker), with a onetomany file map relationship.(not necessarily one to many)
38       
39        representativeFiles=self.ffmap.getRepresentativeFiles()
40        for repfile in representativeFiles:
41            listOfFiles=[]
42            repfilename=repfile.getRepresentativeFileName()
43            listOfFiles.append(repfilename)
44            relfiles = repfile.getRelatedFiles()
45            for f in relfiles:
46                fname = f.getRelatedFileName()
47                listOfFiles.append(fname)
48               
49            #THIS IS THE REALLY SLOW FUNCTION CALL!!!!!#########################
50            OrderedFileTimeList = csmllibs.csmltime.getFileTimeList(listOfFiles,self.timedim)
51            #build strings to hold times/filenames for current gridseriesfeature
52            timeString =''
53            filesinDir = ''
54            for j in range (0, len(OrderedFileTimeList)):
55                t= OrderedFileTimeList[j][0]
56                f = OrderedFileTimeList[j][1]
57                timeString = timeString + ' ' + str(t)
58                filesinDir = filesinDir + ' ' + f
59                #Open representative file and create feature members:
60            DI = csmllibs.csmldataiface.DataInterface()
61            DI=DI.getUnknownInterfaceType(repfilename)
62            DI.openFile(repfilename)
63            allVarNames=DI.getListofVariables()
64            numFeatures=len(allVarNames)
65            for i in range(0, numFeatures):
66                print allVarNames[i]
67                DI.setVariable(allVarNames[i])
68                dimNames=DI.getVariableAxes()
69                if len(dimNames) <= 2:
70                    #it's an axis or bounds not a feature, try next variable
71                    continue
72                GridSeriesFeature_element=csmllibs.Parser.GridSeriesFeature()
73                GridSeriesFeature_element.id=str(allVarNames[i])
74               
75                #description: need to get the attribute called long_name (?? TODO - is this CF compliant??)
76                #use Ag's getbestname from nappy package?
77                try:
78                    desc=DI.getVariableAttribute('long_name')
79                    print desc
80                except AttributeError:
81                    desc = "missing name"
82                GridSeriesFeature_element.description=csmllibs.Parser.Description(desc)
83
84                #***********************************************************************
85                #GridSeriesDomain:
86                #***********************************************************************
87                gsDomain=csmllibs.Parser.GridSeriesDomain()
88                tpl=csmllibs.Parser.TimePositionList()
89                grid=csmllibs.Parser.Grid()
90                   
91                gsDomain.domainReference=tpl
92                gsDomain.domainComplement=grid#
93                GridSeriesFeature_element.gridSeriesDomain=gsDomain
94                   
95                    # GridSeriesDomain_element=self.csml.createElement("GridSeriesDomain")
96#                 #***********************************************************************
97#                 # gml:coverageFunction element (and sub-element MappingRule)
98#                 #***********************************************************************
99#                 gml_coverageFunction_element=self.csml.createElement("gml:coverageFunction")
100#                 MappingRule_element=self.csml.createElement("MappingRule")
101#                 MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
102#                 gml_coverageFunction_element.appendChild(MappingRule_element)
103#                 #***********************************************************************
104#                 # gml:rangeSet element (and sub-elements)
105#                 #***********************************************************************
106#                 gml_rangeSet_element=self.csml.createElement("gml:rangeSet")
107#                 AggregatedArray_element=self.csml.createElement("AggregatedArray")
108#                 arraySize_element=self.csml.createElement("arraySize")
109#                 #arrSz = getArraySize(var)
110#                 arrSz = DI.getArraySizeOfVar()
111#                 arraySize_element.appendChild(self.csml.createTextNode(str(arrSz)))
112#                 uom_element=self.csml.createElement("uom")
113#                 try:
114#                     #strUom = var.units
115#                     strUom = DI.getVariableAttribute('units')
116#                 except AttributeError:
117#                     #if units attribute doesn't exist:
118#                     strUom ="dimensionless or units not determined"
119#                 uom_element.appendChild(self.csml.createTextNode(strUom))
120#                 AggregatedArray_element.appendChild(uom_element)
121#                 aggType_element=self.csml.createElement("aggType")
122#                 aggType_element.appendChild(self.csml.createTextNode('new'))
123#                 aggIndex_element=self.csml.createElement("aggIndex")
124#                 aggIndex_element.appendChild(self.csml.createTextNode('1'))
125#                 AggregatedArray_element.appendChild(arraySize_element)
126#                 AggregatedArray_element.appendChild(aggType_element)
127#                 AggregatedArray_element.appendChild(aggIndex_element)
128#                 component_element=self.csml.createElement("component")
129#                 #FileExtract element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType)
130#                 FileExtract_element=self.csml.createElement(self.extractType)
131#                 arraySize_element=self.csml.createElement("arraySize")
132#                 #varSize =var.shape
133#                 varSize=DI.getShapeOfVar()
134#                 arraySize_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.cleanString1(str(varSize))))
135#                 FileExtract_element.appendChild(arraySize_element)
136#                 fileName_element=self.csml.createElement("fileName")
137#                 FileExtract_element.appendChild(fileName_element)
138#                 #This is the problem: too many filenames >>templating/wildcard needed
139#                 #fileName_element.appendChild(csmldoc.createTextNode(cleanString2(str(allFileNames))))
140#                 #fileName_element.appendChild(csmldoc.createTextNode("WILDCARDNEEDED"))
141#                 #fileName_element.appendChild(csmldoc.createTextNode(os.path.dirname(templateFileList[k]) + '/*'))
142#                 fileName_element.appendChild(self.csml.createTextNode(filesinDir))
143#                 variableName_element=self.csml.createElement("variableName")
144#                 variableName_element.appendChild(self.csml.createTextNode(allVarNames[i]))
145#                 FileExtract_element.appendChild(variableName_element)
146#                 component_element.appendChild(FileExtract_element)
147#                 AggregatedArray_element.appendChild(component_element)
148#                 gml_rangeSet_element.appendChild(AggregatedArray_element)
149#                 ##############################################
150#                 #***********************************************************************
151#                 # domainReference element (and sub-elements)         
152#                 #***********************************************************************
153#                 domainReference_element=self.csml.createElement("domainReference")
154#                 gml_timePositionList_element = self.csml.createElement("gml:TimePositionList")
155#                 gml_timePositionList_element.appendChild(self.csml.createTextNode(timeString))
156#                 domainReference_element.appendChild(gml_timePositionList_element)
157#                 #***********************************************************************
158#                 #***********************************************************************
159#                 # domainComplement element (and sub-elements)
160#                 #***********************************************************************
161#                 domainComplement_element=self.csml.createElement("domainComplement")
162#                 Grid_element=self.csml.createElement("Grid")
163#                 #need to get no. of spatial dimensions (corresponds to axis in domainComplement)
164#                 numSpDims=len(varSize) -1
165#                 #numSpDims = len(var.shape) - 1 #assuming one dimension is non-spatial (time)
166#                 Grid_element.setAttribute('srsName', 'urn:SomeProjection')
167#                 Grid_element.setAttribute( 'srsDimension', str(numSpDims))
168#                 Grid_element.setAttribute('dimension' ,str(numSpDims))
169#                 gml_GridEnvelope_element=self.csml.createElement("gml:GridEnvelope")
170#                 gml_limits_element=self.csml.createElement("gml:limits")
171#                 gml_low_element=self.csml.createElement("gml:low")
172#                 gml_high_element=self.csml.createElement("gml:high")
173#                 lowLimits=DI.getLowLimits()
174#                 highLimits=DI.getHighLimits()
175#                 gml_low_element.appendChild(self.csml.createTextNode(lowLimits))
176#                 gml_high_element.appendChild(self.csml.createTextNode(highLimits))
177#                 gml_GridEnvelope_element.appendChild(gml_low_element)
178#                 gml_GridEnvelope_element.appendChild(gml_high_element)
179#                 gml_limits_element.appendChild(gml_GridEnvelope_element)
180#                 Grid_element.appendChild(gml_limits_element)
181#                 #add an axisName element for  each spatial dimension.
182#                 for i in range (1, len(dimNames)):
183#                     gml_axisName_element=self.csml.createElement("gml:axisName")
184#                     gml_axisName_element.appendChild(self.csml.createTextNode("dim" + str(i)))
185#                     Grid_element.appendChild(gml_axisName_element)
186#                 
187#                 #Add ordinate element and sub elements:
188#                 for i in range (1, len(dimNames)):
189#                     ordinate_element=self.csml.createElement("ordinate")
190#                     gridAxesSpanned_element=self.csml.createElement("gridAxesSpanned")
191#                     gridAxesSpanned_element.appendChild(self.csml.createTextNode("dim" + str(i)))
192#                     sequenceRule_element=self.csml.createElement("sequenceRule")
193#                     sequenceRule_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.getSeqRule(len(dimNames))))
194#                     definesAxis_element=self.csml.createElement("definesAxis")
195#                     dimName = dimNames[len(dimNames)-i]
196#                     definesAxis_element.appendChild(self.csml.createTextNode(dimName))
197#                     axisValues_element=self.csml.createElement("axisValues")
198#                     #look up file extract name in dictionary
199#                     #(axisid stored in dictionary = current filename + variable name)
200#                     axisid = repfilename + dimName
201#                     axisValues = self.fileExtractDictionary[axisid]
202#                     axisValues_element.appendChild(self.csml.createTextNode(axisValues))
203#                     ordinate_element.appendChild(gridAxesSpanned_element)
204#                     ordinate_element.appendChild(sequenceRule_element)
205#                     ordinate_element.appendChild(definesAxis_element)
206#                     ordinate_element.appendChild(axisValues_element)
207#                     Grid_element.appendChild(ordinate_element)
208#                     
209#                 domainComplement_element.appendChild(Grid_element)
210#                 GridSeriesDomain_element.appendChild(domainReference_element)
211#                 GridSeriesDomain_element.appendChild(domainComplement_element)
212#                 GridSeriesFeature_element.appendChild(GridSeriesDomain_element)
213#                 GridSeriesFeature_element.appendChild(gml_rangeSet_element)
214#                 GridSeriesFeature_element.appendChild(gml_coverageFunction_element)
215#                 gml_featureMember_element.appendChild(GridSeriesFeature_element)
216#                 self.gml_FeatureCollection_element.appendChild(gml_featureMember_element)
217               
218                self.fms.append(GridSeriesFeature_element)
219            DI.closeFile()
220        self.gml_FeatureCollection_element.members=self.fms
221
222#########################################################################
223
224
225    def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim):
226            representativeFiles=ffmap.getRepresentativeFiles()
227            listOfFiles=[]
228            for repfile in representativeFiles:
229                    repfilename=repfile.getRepresentativeFileName()
230                    listOfFiles.append(repfilename)
231                    relfiles = repfile.getRelatedFiles()
232                    for f in relfiles:
233                            #hopefully there are no related files at the moment!
234                            fname = f.getRelatedFileName()
235                            listOfFiles.append(fname)
236                    print listOfFiles
237                   
238            for file in listOfFiles:
239                    DI = csmllibs.csmldataiface.DataInterface()
240                    DI=DI.getUnknownInterfaceType(file)
241                    print'opening file'
242                    DI.openFile(file)
243                    print 'getting variables'
244                    allVarNames=DI.getListofVariables()
245                    print 'getting feature count'
246                    numFeatures=len(allVarNames)       
247                   
248                    print "FEATURES"
249                    print "***********"
250                    for i in range (0, len(allVarNames)):
251                            print allVarNames[i]
252                           
253                    for i in range (0, numFeatures):
254                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
255                            ProfileFeature_element=csmldoc.createElement("ProfileFeature")
256                            ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i]))
257                            gml_description_element = csmldoc.createElement("gml:description")
258                            gml_featureMember_element.appendChild(ProfileFeature_element)
259                            #***********************************************************************
260                            #PointSeriesDomain:
261                            #***********************************************************************
262                            ProfileDomain_element=csmldoc.createElement("ProfileDomain")
263                           
264                           
265                            #***********************************************************************
266                            # domainReference element (and sub-elements)               
267                            #***********************************************************************
268                            domainReference_element=csmldoc.createElement("domainReference")
269                            #orientedPosition_element=csmldoc.createElement("OrientedPosition")
270                            #locations_element=csmldoc.createElement("locations")
271                            #times_element=csmldoc.createElement("times")
272                            #trajectory_element.appendChild(locations_element)
273                            #trajectory_element.appendChild(times_element)
274                            #domainReference_element.appendChild(orientedPosition_element)
275                           
276                            #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList")
277                            #gml_timePositionList_element.appendChild(csmldoc.createTextNode(timeString))
278                            #domainReference_element.appendChild(gml_timePositionList_element)
279                            ProfileDomain_element.appendChild(domainReference_element)
280                            #***********************************************************************
281                            domainComplement_element=csmldoc.createElement("domainComplement")
282                            ProfileDomain_element.appendChild(domainComplement_element)
283                           
284                            #***********************************************************************
285                            # gml:rangeSet_element
286                            #***********************************************************************
287                           
288                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
289                           
290                            #***********************************************************************
291                            # gml:coverageFunction element (and sub-element MappingRule)               
292                            #***********************************************************************
293                            gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction")
294                            MappingRule_element=csmldoc.createElement("MappingRule")
295                            #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
296                            MappingRule_element.setAttribute('scanOrder','tba')
297                            gml_coverageFunction_element.appendChild(MappingRule_element)
298                           
299                           
300                            gml_featureMember_element.appendChild(ProfileDomain_element)
301                            gml_featureMember_element.appendChild(gml_rangeSet_element)
302                            gml_featureMember_element.appendChild(gml_coverageFunction_element)
303                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)       
304                           
305            return csmldoc, dataset_element, gml_FeatureCollection_element
306                           
307    #def createCSMLPointFeatures(csmldoc, dataset_element, #gml_FeatureCollection_element,filename, timedim):
308            #csmldoc  = csml instance doc
309            #dataset_element = toplevel dataset xml element (and all child elements)
310            #gml_FeatureCollection_element= FeatureCollection element and all child elements (all features)
311            #filename = full file/path of a single file
312            #timedim = name of time variable
313           
314    #   DI = csmllibs.csmldataiface.DataInterface()
315    #   DI=DI.getUnknownInterfaceType(filename)
316    #   DI.openFile(filename)
317    #   allVarNames=DI.getListofVariables()
318    #   numFeatures=len(allVarNames)   
319    #   for i in range(0, numFeatures):
320    #           gml_featureMember_element=csmldoc.createElement("gml:featureMember")
321    #           PointFeature_element=csmldoc.createElement("PointFeature")
322    #           PointFeature_element.setAttribute('gml:id',allVarNames[i])
323    #           gml_description_element = csmldoc.createElement("gml:description")
324                    #need to get the attribute called long_name (?? TODO - is this CF compliant??)
325                    #use Ag's getbestname from nappy package?
326    #           try:
327    #                   desc=DI.getVariableAttribute('long_name')
328    #                   print desc
329    #                   except AttributeError:
330    #                   desc = "missing name"
331    #                   gml_description_element.appendChild(csmldoc.createTextNode(str(desc))) 
332    #                   PointFeature_element.appendChild(gml_description_element)
333                   
334    #           gml_featureMember_element.appendChild(PointFeature_element)
335    #           gml_FeatureCollection_element.appendChild(gml_featureMember_element)
336                           
337    #   dataset_element.appendChild(gml_FeatureCollection_element)
338                                           
339    #   return csmldoc, dataset_element, gml_FeatureCollection_element
340           
341   
342    def createCSMLPointSeriesFeatures(csmldoc, dataset_element, gml_FeatureCollection_element, ffmap, timedim):
343            representativeFiles=ffmap.getRepresentativeFiles()
344            listOfFiles=[]
345            for repfile in representativeFiles:
346                    repfilename=repfile.getRepresentativeFileName()
347                    listOfFiles.append(repfilename)
348                    relfiles = repfile.getRelatedFiles()
349                    for f in relfiles:
350                            #hopefully there are no related files at the moment!
351                            fname = f.getRelatedFileName()
352                            listOfFiles.append(fname)
353                   
354            for file in listOfFiles:
355                    DI = csmllibs.csmldataiface.DataInterface()
356                    DI=DI.getUnknownInterfaceType(file)
357                    DI.openFile(file)
358                    allVarNames=DI.getListofVariables()
359                    numFeatures=len(allVarNames)       
360                    try:
361                            DI.setAxis(timedim)
362                            times=DI.getDataForAxis()
363                    except:                     
364                            times = DI.getTimes()
365                            #times = ['time axis not determined']
366                   
367                                   
368                    print "FEATURES"
369                    print "***********"
370                    for i in range (0, len(allVarNames)):
371                            print allVarNames[i]
372                                           
373                    print "numFeatures" + str(numFeatures)
374                    for i in range (0, numFeatures):
375                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
376                            PointSeriesFeature_element=csmldoc.createElement("PointSeriesFeature")
377                            PointSeriesFeature_element.setAttribute('gml:id',str(allVarNames[i]))
378                            gml_description_element = csmldoc.createElement("gml:description")
379                            gml_featureMember_element.appendChild(PointSeriesFeature_element)
380                            #***********************************************************************
381                            #PointSeriesDomain:
382                            #***********************************************************************
383                            PointSeriesDomain_element=csmldoc.createElement("PointSeriesDomain")
384                           
385                           
386                            #***********************************************************************
387                            # domainReference element (and sub-elements)               
388                            #***********************************************************************
389                            domainReference_element=csmldoc.createElement("domainReference")
390                            trajectory_element=csmldoc.createElement("Trajectory")
391                            locations_element=csmldoc.createElement("locations")
392                            times_element=csmldoc.createElement("times")
393                            times_element.appendChild(csmldoc.createTextNode(str(times)[1:-1])) 
394                            trajectory_element.appendChild(locations_element)
395                            trajectory_element.appendChild(times_element)
396                            domainReference_element.appendChild(trajectory_element)
397                            PointSeriesDomain_element.appendChild(domainReference_element)
398                           
399                            #***********************************************************************
400                            #domainComplement_element=csmldoc.createElement("domainComplement")
401                            #PointSeriesDomain_element.appendChild(domainComplement_element)
402                           
403                            #***********************************************************************
404                            # gml:rangeSet_element
405                            #***********************************************************************
406                            DI.setVariable(allVarNames[i])
407                           
408                            #TO DO:
409                            try:
410                                    #strUom = var.units
411                                    strUom = DI.getVariableAttribute('units')
412                            except AttributeError:
413                                    #if units attribute doesn't exist:
414                                    strUom ="dimensionless or units not determined"
415                           
416                            try:                       
417                                    measuredvalues = str(DI.getDataForVar())
418                            except:
419                                    measuredvalues = ' could not get values '
420                           
421                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
422                            gml_QuantityList_element=csmldoc.createElement("gml:QuantityList")
423                            gml_QuantityList_element.setAttribute('uom',strUom)
424                            gml_QuantityList_element.appendChild(csmldoc.createTextNode(str(measuredvalues)[1:-1]))
425                            gml_rangeSet_element.appendChild(gml_QuantityList_element)
426                           
427                            #***********************************************************************
428                            # gml:coverageFunction element (and sub-element MappingRule)               
429                            #***********************************************************************
430                            parameter_element=csmldoc.createElement("parameter")
431                                           
432                            gml_featureMember_element.appendChild(PointSeriesDomain_element)
433                            gml_featureMember_element.appendChild(gml_rangeSet_element)
434                            gml_featureMember_element.appendChild(parameter_element)
435                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)
436                           
437            return csmldoc, dataset_element, gml_FeatureCollection_element
438           
439
440       
441
442
443       
444##################################################
445##################################################
446##################################################
447#OLD cODE:
448######################################################################################################################################################
449
450class OLDfeatureBuilder:
451    def __init__(self, csmldoc, dataset_element, gml_FeatureCollection_element,extractType, extractPrefix, ffmap,fileExtractDictionary, timedim):
452        self.csml=csmldoc
453        self.ds_element=dataset_element
454        self.gml_FeatureCollection_element = gml_FeatureCollection_element
455        self.extractType = extractType
456        self.extractPrefix = extractPrefix
457        self.ffmap = ffmap
458        self.fileExtractDictionary = fileExtractDictionary
459        self.timedim = timedim
460        #at the moment, only one featuretype per CSML Dataset is supported.
461        #get the featuretype of the first representative file in the ffmap object
462        self.featuretype=  self.ffmap.getRepresentativeFiles()[0].getFeatureType()
463       
464        print "FEATURETYPE: " + str(self.featuretype)
465        if self.featuretype == 'GridSeriesFeature':
466            self.createCSMLGridSeriesFeatures()
467        elif self.featuretype == 'PointSeriesFeature':       
468            self.createCSMLPointSeriesFeatures()
469       
470       
471    def createCSMLGridSeriesFeatures(self):
472        #This function is for model data and assumes that the variables (features) are shared across identically structured files
473        #in the same directory.
474        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker), with a onetomany file map relationship.(not necessarily one to many)
475       
476        representativeFiles=self.ffmap.getRepresentativeFiles()
477        for repfile in representativeFiles:
478            listOfFiles=[]
479            repfilename=repfile.getRepresentativeFileName()
480            listOfFiles.append(repfilename)
481            relfiles = repfile.getRelatedFiles()
482            for f in relfiles:
483                fname = f.getRelatedFileName()
484                listOfFiles.append(fname)
485               
486            #THIS IS THE REALLY SLOW FUNCTION CALL!!!!!#########################
487            OrderedFileTimeList = csmllibs.csmltime.getFileTimeList(listOfFiles,self.timedim)
488            #build strings to hold times/filenames for current gridseriesfeature
489            timeString =''
490            filesinDir = ''
491            for j in range (0, len(OrderedFileTimeList)):
492                t= OrderedFileTimeList[j][0]
493                f = OrderedFileTimeList[j][1]
494                timeString = timeString + ' ' + str(t)
495                filesinDir = filesinDir + ' ' + f
496                #Open representative file and create feature members:
497            DI = csmllibs.csmldataiface.DataInterface()
498            DI=DI.getUnknownInterfaceType(repfilename)
499            DI.openFile(repfilename)
500            allVarNames=DI.getListofVariables()
501            numFeatures=len(allVarNames)
502            for i in range(0, numFeatures):
503                print allVarNames[i]
504                DI.setVariable(allVarNames[i])
505                dimNames=DI.getVariableAxes()
506                if len(dimNames) <= 2:
507                    #it's an axis or bounds not a feature, try next variable
508                    continue
509                gml_featureMember_element=self.csml.createElement("gml:featureMember")
510                GridSeriesFeature_element=self.csml.createElement("GridSeriesFeature")
511                GridSeriesFeature_element.setAttribute('gml:id',allVarNames[i])
512                gml_description_element = self.csml.createElement("gml:description")
513                #need to get the attribute called long_name (?? TODO - is this CF compliant??)
514                #use Ag's getbestname from nappy package?
515                try:
516                    desc=DI.getVariableAttribute('long_name')
517                    print desc
518                except AttributeError:
519                    desc = "missing name"
520                gml_description_element.appendChild(self.csml.createTextNode(str(desc)))
521                GridSeriesFeature_element.appendChild(gml_description_element)
522                #***********************************************************************
523                #GridSeriesDomain:
524                #***********************************************************************
525                GridSeriesDomain_element=self.csml.createElement("GridSeriesDomain")
526                #***********************************************************************
527                # gml:coverageFunction element (and sub-element MappingRule)
528                #***********************************************************************
529                gml_coverageFunction_element=self.csml.createElement("gml:coverageFunction")
530                MappingRule_element=self.csml.createElement("MappingRule")
531                MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
532                gml_coverageFunction_element.appendChild(MappingRule_element)
533                #***********************************************************************
534                # gml:rangeSet element (and sub-elements)
535                #***********************************************************************
536                gml_rangeSet_element=self.csml.createElement("gml:rangeSet")
537                AggregatedArray_element=self.csml.createElement("AggregatedArray")
538                arraySize_element=self.csml.createElement("arraySize")
539                #arrSz = getArraySize(var)
540                arrSz = DI.getArraySizeOfVar()
541                arraySize_element.appendChild(self.csml.createTextNode(str(arrSz)))
542                uom_element=self.csml.createElement("uom")
543                try:
544                    #strUom = var.units
545                    strUom = DI.getVariableAttribute('units')
546                except AttributeError:
547                    #if units attribute doesn't exist:
548                    strUom ="dimensionless or units not determined"
549                uom_element.appendChild(self.csml.createTextNode(strUom))
550                AggregatedArray_element.appendChild(uom_element)
551                aggType_element=self.csml.createElement("aggType")
552                aggType_element.appendChild(self.csml.createTextNode('new'))
553                aggIndex_element=self.csml.createElement("aggIndex")
554                aggIndex_element.appendChild(self.csml.createTextNode('1'))
555                AggregatedArray_element.appendChild(arraySize_element)
556                AggregatedArray_element.appendChild(aggType_element)
557                AggregatedArray_element.appendChild(aggIndex_element)
558                component_element=self.csml.createElement("component")
559                #FileExtract element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType)
560                FileExtract_element=self.csml.createElement(self.extractType)
561                arraySize_element=self.csml.createElement("arraySize")
562                #varSize =var.shape
563                varSize=DI.getShapeOfVar()
564                arraySize_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.cleanString1(str(varSize))))
565                FileExtract_element.appendChild(arraySize_element)
566                fileName_element=self.csml.createElement("fileName")
567                FileExtract_element.appendChild(fileName_element)
568                #This is the problem: too many filenames >>templating/wildcard needed
569                #fileName_element.appendChild(csmldoc.createTextNode(cleanString2(str(allFileNames))))
570                #fileName_element.appendChild(csmldoc.createTextNode("WILDCARDNEEDED"))
571                #fileName_element.appendChild(csmldoc.createTextNode(os.path.dirname(templateFileList[k]) + '/*'))
572                fileName_element.appendChild(self.csml.createTextNode(filesinDir))
573                variableName_element=self.csml.createElement("variableName")
574                variableName_element.appendChild(self.csml.createTextNode(allVarNames[i]))
575                FileExtract_element.appendChild(variableName_element)
576                component_element.appendChild(FileExtract_element)
577                AggregatedArray_element.appendChild(component_element)
578                gml_rangeSet_element.appendChild(AggregatedArray_element)
579                ##############################################
580                #***********************************************************************
581                # domainReference element (and sub-elements)           
582                #***********************************************************************
583                domainReference_element=self.csml.createElement("domainReference")
584                gml_timePositionList_element = self.csml.createElement("gml:TimePositionList")
585                gml_timePositionList_element.appendChild(self.csml.createTextNode(timeString))
586                domainReference_element.appendChild(gml_timePositionList_element)
587                #***********************************************************************
588                #***********************************************************************
589                # domainComplement element (and sub-elements)
590                #***********************************************************************
591                domainComplement_element=self.csml.createElement("domainComplement")
592                Grid_element=self.csml.createElement("Grid")
593                #need to get no. of spatial dimensions (corresponds to axis in domainComplement)
594                numSpDims=len(varSize) -1
595                #numSpDims = len(var.shape) - 1 #assuming one dimension is non-spatial (time)
596                Grid_element.setAttribute('srsName', 'urn:SomeProjection')
597                Grid_element.setAttribute( 'srsDimension', str(numSpDims))
598                Grid_element.setAttribute('dimension' ,str(numSpDims))
599                gml_GridEnvelope_element=self.csml.createElement("gml:GridEnvelope")
600                gml_limits_element=self.csml.createElement("gml:limits")
601                gml_low_element=self.csml.createElement("gml:low")
602                gml_high_element=self.csml.createElement("gml:high")
603                lowLimits=DI.getLowLimits()
604                highLimits=DI.getHighLimits()
605                gml_low_element.appendChild(self.csml.createTextNode(lowLimits))
606                gml_high_element.appendChild(self.csml.createTextNode(highLimits))
607                gml_GridEnvelope_element.appendChild(gml_low_element)
608                gml_GridEnvelope_element.appendChild(gml_high_element)
609                gml_limits_element.appendChild(gml_GridEnvelope_element)
610                Grid_element.appendChild(gml_limits_element)
611                #add an axisName element for  each spatial dimension.
612                for i in range (1, len(dimNames)):
613                    gml_axisName_element=self.csml.createElement("gml:axisName")
614                    gml_axisName_element.appendChild(self.csml.createTextNode("dim" + str(i)))
615                    Grid_element.appendChild(gml_axisName_element)
616               
617                #Add ordinate element and sub elements:
618                for i in range (1, len(dimNames)):
619                    ordinate_element=self.csml.createElement("ordinate")
620                    gridAxesSpanned_element=self.csml.createElement("gridAxesSpanned")
621                    gridAxesSpanned_element.appendChild(self.csml.createTextNode("dim" + str(i)))
622                    sequenceRule_element=self.csml.createElement("sequenceRule")
623                    sequenceRule_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.getSeqRule(len(dimNames))))
624                    definesAxis_element=self.csml.createElement("definesAxis")
625                    dimName = dimNames[len(dimNames)-i]
626                    definesAxis_element.appendChild(self.csml.createTextNode(dimName))
627                    axisValues_element=self.csml.createElement("axisValues")
628                    #look up file extract name in dictionary
629                    #(axisid stored in dictionary = current filename + variable name)
630                    axisid = repfilename + dimName
631                    axisValues = self.fileExtractDictionary[axisid]
632                    axisValues_element.appendChild(self.csml.createTextNode(axisValues))
633                    ordinate_element.appendChild(gridAxesSpanned_element)
634                    ordinate_element.appendChild(sequenceRule_element)
635                    ordinate_element.appendChild(definesAxis_element)
636                    ordinate_element.appendChild(axisValues_element)
637                    Grid_element.appendChild(ordinate_element)
638                   
639                domainComplement_element.appendChild(Grid_element)
640                GridSeriesDomain_element.appendChild(domainReference_element)
641                GridSeriesDomain_element.appendChild(domainComplement_element)
642                GridSeriesFeature_element.appendChild(GridSeriesDomain_element)
643                GridSeriesFeature_element.appendChild(gml_rangeSet_element)
644                GridSeriesFeature_element.appendChild(gml_coverageFunction_element)
645                gml_featureMember_element.appendChild(GridSeriesFeature_element)
646                self.gml_FeatureCollection_element.appendChild(gml_featureMember_element)
647            DI.closeFile()
648                       
649
650#########################################################################
651
652
653    def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim):
654            representativeFiles=ffmap.getRepresentativeFiles()
655            listOfFiles=[]
656            for repfile in representativeFiles:
657                    repfilename=repfile.getRepresentativeFileName()
658                    listOfFiles.append(repfilename)
659                    relfiles = repfile.getRelatedFiles()
660                    for f in relfiles:
661                            #hopefully there are no related files at the moment!
662                            fname = f.getRelatedFileName()
663                            listOfFiles.append(fname)
664                    print listOfFiles
665                   
666            for file in listOfFiles:
667                    DI = csmllibs.csmldataiface.DataInterface()
668                    DI=DI.getUnknownInterfaceType(file)
669                    print'opening file'
670                    DI.openFile(file)
671                    print 'getting variables'
672                    allVarNames=DI.getListofVariables()
673                    print 'getting feature count'
674                    numFeatures=len(allVarNames)       
675                   
676                    print "FEATURES"
677                    print "***********"
678                    for i in range (0, len(allVarNames)):
679                            print allVarNames[i]
680                           
681                    for i in range (0, numFeatures):
682                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
683                            ProfileFeature_element=csmldoc.createElement("ProfileFeature")
684                            ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i]))
685                            gml_description_element = csmldoc.createElement("gml:description")
686                            gml_featureMember_element.appendChild(ProfileFeature_element)
687                            #***********************************************************************
688                            #PointSeriesDomain:
689                            #***********************************************************************
690                            ProfileDomain_element=csmldoc.createElement("ProfileDomain")
691                           
692                           
693                            #***********************************************************************
694                            # domainReference element (and sub-elements)               
695                            #***********************************************************************
696                            domainReference_element=csmldoc.createElement("domainReference")
697                            #orientedPosition_element=csmldoc.createElement("OrientedPosition")
698                            #locations_element=csmldoc.createElement("locations")
699                            #times_element=csmldoc.createElement("times")
700                            #trajectory_element.appendChild(locations_element)
701                            #trajectory_element.appendChild(times_element)
702                            #domainReference_element.appendChild(orientedPosition_element)
703                           
704                            #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList")
705                            #gml_timePositionList_element.appendChild(csmldoc.createTextNode(timeString))
706                            #domainReference_element.appendChild(gml_timePositionList_element)
707                            ProfileDomain_element.appendChild(domainReference_element)
708                            #***********************************************************************
709                            domainComplement_element=csmldoc.createElement("domainComplement")
710                            ProfileDomain_element.appendChild(domainComplement_element)
711                           
712                            #***********************************************************************
713                            # gml:rangeSet_element
714                            #***********************************************************************
715                           
716                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
717                           
718                            #***********************************************************************
719                            # gml:coverageFunction element (and sub-element MappingRule)               
720                            #***********************************************************************
721                            gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction")
722                            MappingRule_element=csmldoc.createElement("MappingRule")
723                            #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
724                            MappingRule_element.setAttribute('scanOrder','tba')
725                            gml_coverageFunction_element.appendChild(MappingRule_element)
726                           
727                           
728                            gml_featureMember_element.appendChild(ProfileDomain_element)
729                            gml_featureMember_element.appendChild(gml_rangeSet_element)
730                            gml_featureMember_element.appendChild(gml_coverageFunction_element)
731                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)       
732                           
733            return csmldoc, dataset_element, gml_FeatureCollection_element
734                           
735    #def createCSMLPointFeatures(csmldoc, dataset_element, #gml_FeatureCollection_element,filename, timedim):
736            #csmldoc  = csml instance doc
737            #dataset_element = toplevel dataset xml element (and all child elements)
738            #gml_FeatureCollection_element= FeatureCollection element and all child elements (all features)
739            #filename = full file/path of a single file
740            #timedim = name of time variable
741           
742    #   DI = csmllibs.csmldataiface.DataInterface()
743    #   DI=DI.getUnknownInterfaceType(filename)
744    #   DI.openFile(filename)
745    #   allVarNames=DI.getListofVariables()
746    #   numFeatures=len(allVarNames)   
747    #   for i in range(0, numFeatures):
748    #           gml_featureMember_element=csmldoc.createElement("gml:featureMember")
749    #           PointFeature_element=csmldoc.createElement("PointFeature")
750    #           PointFeature_element.setAttribute('gml:id',allVarNames[i])
751    #           gml_description_element = csmldoc.createElement("gml:description")
752                    #need to get the attribute called long_name (?? TODO - is this CF compliant??)
753                    #use Ag's getbestname from nappy package?
754    #           try:
755    #                   desc=DI.getVariableAttribute('long_name')
756    #                   print desc
757    #                   except AttributeError:
758    #                   desc = "missing name"
759    #                   gml_description_element.appendChild(csmldoc.createTextNode(str(desc))) 
760    #                   PointFeature_element.appendChild(gml_description_element)
761                   
762    #           gml_featureMember_element.appendChild(PointFeature_element)
763    #           gml_FeatureCollection_element.appendChild(gml_featureMember_element)
764                           
765    #   dataset_element.appendChild(gml_FeatureCollection_element)
766                                           
767    #   return csmldoc, dataset_element, gml_FeatureCollection_element
768           
769   
770    def createCSMLPointSeriesFeatures(csmldoc, dataset_element, gml_FeatureCollection_element, ffmap, timedim):
771            representativeFiles=ffmap.getRepresentativeFiles()
772            listOfFiles=[]
773            for repfile in representativeFiles:
774                    repfilename=repfile.getRepresentativeFileName()
775                    listOfFiles.append(repfilename)
776                    relfiles = repfile.getRelatedFiles()
777                    for f in relfiles:
778                            #hopefully there are no related files at the moment!
779                            fname = f.getRelatedFileName()
780                            listOfFiles.append(fname)
781                   
782            for file in listOfFiles:
783                    DI = csmllibs.csmldataiface.DataInterface()
784                    DI=DI.getUnknownInterfaceType(file)
785                    DI.openFile(file)
786                    allVarNames=DI.getListofVariables()
787                    numFeatures=len(allVarNames)       
788                    try:
789                            DI.setAxis(timedim)
790                            times=DI.getDataForAxis()
791                    except:                     
792                            times = DI.getTimes()
793                            #times = ['time axis not determined']
794                   
795                                   
796                    print "FEATURES"
797                    print "***********"
798                    for i in range (0, len(allVarNames)):
799                            print allVarNames[i]
800                                           
801                    print "numFeatures" + str(numFeatures)
802                    for i in range (0, numFeatures):
803                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
804                            PointSeriesFeature_element=csmldoc.createElement("PointSeriesFeature")
805                            PointSeriesFeature_element.setAttribute('gml:id',str(allVarNames[i]))
806                            gml_description_element = csmldoc.createElement("gml:description")
807                            gml_featureMember_element.appendChild(PointSeriesFeature_element)
808                            #***********************************************************************
809                            #PointSeriesDomain:
810                            #***********************************************************************
811                            PointSeriesDomain_element=csmldoc.createElement("PointSeriesDomain")
812                           
813                           
814                            #***********************************************************************
815                            # domainReference element (and sub-elements)               
816                            #***********************************************************************
817                            domainReference_element=csmldoc.createElement("domainReference")
818                            trajectory_element=csmldoc.createElement("Trajectory")
819                            locations_element=csmldoc.createElement("locations")
820                            times_element=csmldoc.createElement("times")
821                            times_element.appendChild(csmldoc.createTextNode(str(times)[1:-1])) 
822                            trajectory_element.appendChild(locations_element)
823                            trajectory_element.appendChild(times_element)
824                            domainReference_element.appendChild(trajectory_element)
825                            PointSeriesDomain_element.appendChild(domainReference_element)
826                           
827                            #***********************************************************************
828                            #domainComplement_element=csmldoc.createElement("domainComplement")
829                            #PointSeriesDomain_element.appendChild(domainComplement_element)
830                           
831                            #***********************************************************************
832                            # gml:rangeSet_element
833                            #***********************************************************************
834                            DI.setVariable(allVarNames[i])
835                           
836                            #TO DO:
837                            try:
838                                    #strUom = var.units
839                                    strUom = DI.getVariableAttribute('units')
840                            except AttributeError:
841                                    #if units attribute doesn't exist:
842                                    strUom ="dimensionless or units not determined"
843                           
844                            try:                       
845                                    measuredvalues = str(DI.getDataForVar())
846                            except:
847                                    measuredvalues = ' could not get values '
848                           
849                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
850                            gml_QuantityList_element=csmldoc.createElement("gml:QuantityList")
851                            gml_QuantityList_element.setAttribute('uom',strUom)
852                            gml_QuantityList_element.appendChild(csmldoc.createTextNode(str(measuredvalues)[1:-1]))
853                            gml_rangeSet_element.appendChild(gml_QuantityList_element)
854                           
855                            #***********************************************************************
856                            # gml:coverageFunction element (and sub-element MappingRule)               
857                            #***********************************************************************
858                            parameter_element=csmldoc.createElement("parameter")
859                                           
860                            gml_featureMember_element.appendChild(PointSeriesDomain_element)
861                            gml_featureMember_element.appendChild(gml_rangeSet_element)
862                            gml_featureMember_element.appendChild(parameter_element)
863                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)
864                           
865            return csmldoc, dataset_element, gml_FeatureCollection_element
866           
867
868       
869
870
871       
Note: See TracBrowser for help on using the repository browser.