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

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

propagating additional args/configs through Scanner code

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