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

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

changed obselete GridSeriesDomain? attribute to domain

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