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

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

fixed problem with arraySize list/tuple/string confusion

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