source: TI02-CSML/trunk/csml/csmllibs/csmlfeaturetypes.py @ 3579

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

handling missing units of measure

  • 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 csml.parser as cp
10import csml.csmllibs
11import sys
12import pdb
13   
14
15class featureBuilder(object):
16    ''' for building a feature in CSML'''
17    def __init__(self, dataset_element, featureCollection_element, ffmap,fileExtractDictionary, timedim, timestorage,spatialstorage,valuestorage,minaxes):
18        self.ds_element=dataset_element
19        self.featureCollection = featureCollection_element
20        self.ffmap = ffmap
21        self.fileExtractDictionary = fileExtractDictionary
22        self.timedim = timedim
23        self.timestorage=timestorage
24        self.spatialstorage=spatialstorage
25        self.valuestorage=valuestorage
26        self.minaxes=minaxes
27               
28        #empty list to hold featureMembers
29        self.fms =[]
30               
31        #at the moment, only one featuretype per CSML Dataset is supported.
32        #get the featuretype of the first representative file in the ffmap object
33        self.featuretype=  self.ffmap.getRepresentativeFiles()[0].getFeatureType()
34       #and create the features
35        print 'determining feature type'
36        print self.featuretype
37        if self.featuretype == 'GridSeries':
38            self.createCSMLGridSeriesFeatures()
39        elif self.featuretype == 'PointSeries':       
40            self.createCSMLPointSeriesFeatures()
41        elif self.featuretype == 'ProfileSeries':       
42            self.createCSMLProfileSeriesFeatures()
43        #after the features have been generated append all featureMembers to the feature collection
44        self.featureCollection.featureMembers=self.fms
45       
46    #Some internal methods that are of use to all feature types:
47    def _getDescriptiveName(self,DI):
48        #given a data interface class with the variable or axis set, try to get a descriptive name
49        #eg. long name
50        try:
51            descName=DI.getVariableAttribute('long_name')
52        except AttributeError:
53            descName = "missing description"
54        return descName
55   
56    def _populateListOfFiles(self,repfile):
57        #given a representative file, get list of files: one representative file + all related files
58        listOfFiles=[]
59        repfilename=repfile.getRepresentativeFileName()
60        listOfFiles.append(repfilename)
61        relfiles = repfile.getRelatedFiles()
62        for f in relfiles:
63            fname = f.getRelatedFileName()
64            listOfFiles.append(fname)
65        return repfilename,listOfFiles
66       
67    def _getFilesAndTimes(self):
68        #TODO try and speed up csmllibs.csmltime.getFileTimeList
69        OrderedFileTimeList,self.caltype,self.units = csml.csmllibs.csmltime.getFileTimeList(self.listOfFiles,self.timedim)
70        #build strings to hold times/filenames for current gridseriesfeature
71        self.timeString =''
72        self.filesinDir = ''
73        lastf=''
74        for j in range (0, len(OrderedFileTimeList)):
75            t= OrderedFileTimeList[j][0]
76            f = OrderedFileTimeList[j][1]
77            self.timeString = self.timeString + ' ' + str(t)
78            if f != lastf:
79                self.filesinDir = self.filesinDir + ' ' + f
80                lastf=f
81           
82    def _getCorrectExtractType(self):
83        #returns an empty parser file extract object of the correct type.
84        if self.extractType=='NetCDFExtract':
85            fe = csml.parser.NetCDFExtract()
86        if self.extractType=='NASAAmesExtract':
87            fe = csml.parser.NASAAmesExtract()
88        if self.extractType=='GRIBExtract':
89            fe = csml.parser.GRIBExtract()
90        if self.extractType=='PPExtract':
91            fe = csml.parser.NetCDFExtract()
92        return fe
93       
94   
95   
96    #the following __functions are used by all or most feature types:
97   
98    def __getVarInfo(self, representativeFile):
99        self.repfilename,self.listOfFiles=self._populateListOfFiles(representativeFile)
100        self._getFilesAndTimes()
101        #Open representative file and create feature members:
102        self.DI = csml.csmllibs.csmldataiface.DataInterface()
103        self.DI=self.DI.getUnknownInterfaceType(self.repfilename)
104        self.DI.openFile(self.repfilename)
105        allVarNames=self.DI.getListofVariables()
106        checkedVars=[]
107        for var in allVarNames:
108            self.DI.setVariable(var)
109            numaxes=len(self.DI.getVariableAxes())
110            #ignore any variables below the specified dimension threshold
111            if numaxes > self.minaxes:
112                checkedVars.append(var)             
113        numFeatures=len(checkedVars)
114        return checkedVars, numFeatures
115   
116    def __getGridCoordinatesTable(self,dimNames, crs,axisorder):
117        #referenceableGrid/GridCoordinatesTable
118        gcT=cp.GridCoordinatesTable()     
119        #timeHref is used to store a referencable timepositionlist for reuse
120        if not hasattr(self, 'timeHref'):
121            self.timeHref = None
122        ##add an axisName element(s) for  each spatial dimension.
123        #and an ordinate element
124        axes=''
125        for axis in dimNames:
126            axes =axes + ' '+ axis
127        ordinates=[]
128        for dimName in enumerate(dimNames):
129            ord=cp.GridOrdinateDescription()               
130            #map the grid axis to the crs axis
131            #default to empty element
132            ord.coordAxisLabel=cp.csString('')
133            ord.gridAxesSpanned=cp.csString('')
134            for axis in axisorder:
135                if axisorder[axis]==dimName[0]:
136                    ord.coordAxisLabel=cp.csString(axis)
137                    ord.gridAxesSpanned=cp.csString(dimName[1])
138                    break
139            seqRule= cp.SequenceRule()
140            seqRule.CONTENT='Linear'
141            seqRule.axisOrder='+1'  #TO DO. Work this out.
142            ord.sequenceRule=seqRule           
143            sptList=csml.parser.SpatialOrTemporalPositionList()
144            sptList.id =csml.csmllibs.csmlextra.getRandomID()
145            if dimName[1]==self.timedim:
146                #this is the time dimension. handle calendaring etc when getting the data.
147                if self.timestorage=='fileextract':
148                    #look up file extract name in dictionary
149                    #(axisid stored in dictionary = current filename + variable name)
150                    axisid=self.repfilename+dimName[1]
151                    sptList.timePositionList=cp.TimePositionList(self.fileExtractDictionary[axisid])
152                else:
153                    if self.timeHref == None:
154                        self.timeHref=sptList.id
155                        timeposList=cp.TimePositionList()
156                        timeposList.CONTENT=self.timeString
157                        timeposList.frame='ndg:%s'%self.caltype
158                        sptList.timePositionList=timeposList
159                    else:
160                        sptList.href='#' +self.timeHref
161                        sptList.show='embed'
162                        sptList.arcrole='http://ndg.nerc.ac.uk/xlinkUsage/insert#timePositionList'
163                        sptList.role='http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor'
164                        sptList.timePositionList=cp.TimePositionList()                                       
165            else:  #for all other dimensions, create ordinates
166                if self.spatialstorage=='fileextract':
167                    #look up file extract name in dictionary
168                    #(axisid stored in dictionary = current filename + variable name)
169                    axisid=self.repfilename+dimName[1]
170                    #sptList.coordinateList=cp.csString('#'+ self.fileExtractDictionary[axisid]) #todo, fix xlink
171                    sptList.href='#'+self.fileExtractDictionary[axisid]
172                    sptList.show='embed'
173                    sptList.arcrole='http://ndg.nerc.ac.uk/xlinkUsage/insert#coordinateList'
174                    sptList.role='http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor'
175                else:
176                    #store inline
177                    self.DI.setAxis(dimName[1])
178                    sptList.coordinateList=cp.csString(csml.csmllibs.csmlextra.cleanString(str(self.DI.getDataForAxis())))
179
180            ord.coordAxisValues=sptList
181            gcT.addChildElem('gridOrdinates',ord)             
182        return gcT
183       
184    def __getLocation(self):
185        #attempts to get a fixed location, eg for a ProfileSeriesFeature.
186        lonval=None
187        latval=None
188        heightval=None
189        vars=self.DI.getListofVariables()
190        cat = csml.csmllibs.csmlcrs.CRSCatalogue()
191        axes=[]
192        for var in vars:
193            self.DI.setVariable(var)
194            unitname=self.DI.getVariableAttribute('units')
195            unittype=cat.getUnitType(unitname)
196            if unittype == 'latitude':
197                latval=self.DI.getDataForVar()
198                axes.append(unittype)
199            elif unittype == 'longitude':
200                lonval=self.DI.getDataForVar() 
201                axes.append(unittype)
202            elif unittype=='height':
203                heightval=self.DI.getDataForVar() 
204                axes.append(unittype)
205               
206        #returns lat lon height, but note that any of these may be None     
207        crs=cat.determineCRS(knownCRSAxes =axes) #TODO, may need to rethink csmlcrs module a bit
208        srsName= crs[0].srsName
209        return latval, lonval, heightval, srsName
210       
211    def __getCRS(self,varName,catalogue):
212        self.DI.setVariable(varName)
213        dimNames=self.DI.getVariableAxes() 
214        if len(dimNames) <= 1:
215                #it's an axis or bounds not a feature, try next variable
216            return None, None, None
217        unitlist=[]
218        stdNames=[]
219        for dim in dimNames:
220            self.DI.setAxis(dim)
221            units=self.DI.getAxisAttribute('units')  #need to make special case of units in DI layer
222            stdname =None
223            try:
224                stdname=self.DI.getAxisAttribute('standard_name')               
225            except:
226                pass
227            stdNames.append(stdname)
228            unitlist.append(units)   
229        crs, axisorder=catalogue.determineCRS(dimNames,unitlist, knownCRSAxes=None, stdNames=stdNames)
230        return crs, axisorder, dimNames
231   
232    def __getStdName(self, varName):
233        '''look for the 'standard_name' attribute. Assumes it's a cf compliant standard_name. If not found returns None'''
234        self.DI.setVariable(varName)
235        sn=self.DI.getVariableAttribute('standard_name')   
236        if sn is None:
237            sname = None
238        else:
239            sname='http://cfconventions.org/standard_names/%s'%sn       
240        return sname
241   
242   
243    def __featureMetadata(self,feature, varName):
244        feature.id=csml.csmllibs.csmlextra.getRandomID()
245        feature.name=csml.parser.csString(varName)
246        desc = self._getDescriptiveName(self.DI)
247
248        feature.description=csml.parser.csString(desc)
249
250    def __getGMLRangeset(self,varName):
251        #GML RANGESET
252        rs=csml.parser.RangeSet()
253        self.DI.setVariable(varName)
254        arrSz = self.DI.getArraySizeOfVar()
255        try:
256            strUom = self.DI.getVariableAttribute('units')
257            strUom=strUom.replace(' ','.')
258            if strUom=='':
259                strUom='dimensionless_or_units_not_determined'
260        except AttributeError:
261            # if units attribute doesn't exist:
262            strUom ="dimensionless-or_units_not_determined"
263        if self.valuestorage=='inline':
264            #TO DO, store the rangeset inline - use Datablock class???
265            pass
266        else:
267            #store the rangeSet as an aggregatedArray
268            aa=cp.AggregatedArray()
269            aa.arraySize=cp.csString(arrSz)
270            aa.uom=cp.csString(strUom)
271            aa.aggType=cp.csString('new') #can it be anything else?
272            aa.aggIndex=cp.csString('1')
273            #FileExtract (fe) element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType)
274            self.extractType= self.DI.extractType
275            fe = self._getCorrectExtractType()
276            varSize=self.DI.getShapeOfVar()
277            varSize=csml.csmllibs.csmlextra.cleanString1(str(varSize))
278            fe.arraySize=cp.csString(varSize)
279            fl=cp.FileList()
280            fl.fileNames=cp.csString(self.filesinDir)
281            fe.fileList=fl
282            fe.variableName=cp.csString(varName)
283            aa.components=[fe]
284            aa.id=csml.csmllibs.csmlextra.getRandomID()
285            if hasattr(self.ds_element, 'storageDescriptor'):
286                self.ds_element.storageDescriptor.descriptors.append(aa)
287            else:
288                sd =csml.parser.CSMLStorageDescriptor()
289                sd.descriptors=[aa]
290                setattr(self.ds_element, 'storageDescriptor',sd)
291            va=csml.parser.ValueArray()
292            vc=csml.parser.MeasureOrNullList()
293            vc.href='#%s'%aa.id
294            vc.arcrole="http://ndg.nerc.ac.uk/xlinkUsage/insert#QuantityList"
295            vc.role="http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor"
296            vc.show='embed'
297            vc.uom=strUom
298            va.valueComponent=vc
299            va.id=csml.csmllibs.csmlextra.getRandomID()
300            rs.valueArray=va
301        return rs
302   
303   
304    #the following functions are for creation of specific feature types (and call the __functions above)
305    def createCSMLGridSeriesFeatures(self):
306        #This method assumes that the variables (features) are shared across identically structured files
307        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker)
308        representativeFiles=self.ffmap.getRepresentativeFiles()
309        cat=csml.csmllibs.csmlcrs.CRSCatalogue()
310        for repfile in representativeFiles:
311            #get the names of all the variables in the files:
312            allVarNames, numFeatures = self.__getVarInfo(repfile)
313            #Create a GridSeriesFeature for each variable:
314            for i in range(0, numFeatures):
315                crs,axisorder, dimNames=self.__getCRS(allVarNames[i], cat)
316                if crs == None:
317                    continue            #try next variable
318                gsFeature=cp.GridSeriesFeature()
319                self.__featureMetadata(gsFeature,allVarNames[i])
320                #VALUE (coverage)
321                gsCoverage=cp.GridSeriesCoverage()
322                gsCoverage.id = csml.csmllibs.csmlextra.getRandomID()
323                gsDomain=cp.GridSeriesDomain()
324                gsDomain.id = csml.csmllibs.csmlextra.getRandomID()
325                gsDomain.srsName=crs.srsName
326                gsDomain.axisLabels=crs.axisLabels # note this is the xml attribute axisLabels, not the child element (aLabels)
327                gsDomain.srsDimension=crs.srsDimension
328                gsDomain.dimension=gsDomain.srsDimension
329                if crs.units is not None:
330                    gsDomain.uomLabels=crs.units
331                else:
332                    gsDomain.uomLabels="None"
333                aLabels=''
334                for dim in dimNames:
335                    aLabels=aLabels + dim + ' '
336                gsDomain.aLabels=cp.csString(aLabels)
337                limits=cp.GridEnvelope()
338                limits.low=cp.csString('0 0 0')
339                limits.high=cp.csString('0 0 0')
340                gsDomain.limits=limits
341                gcT=self.__getGridCoordinatesTable(dimNames, crs,axisorder)
342                gsDomain.coordTransformTable=gcT
343                gsCoverage.gridSeriesDomain=gsDomain
344               
345                #COVERAGE FUNCTION
346                #mr =csml.csmllibs.csmlextra.getMappingRule(len(dimNames))
347                #gsCoverage.coverageFunction=cp.csString(mr)
348                rs=self.__getGMLRangeset(allVarNames[i])
349               
350                #RANGESET
351                gsCoverage.rangeSet=rs
352               
353                #phenomenon
354                param=self.__getStdName(allVarNames[i])               
355                if not param:
356                    param='http://badc.rl.ac.uk/localparams#%s'%allVarNames[i]
357                gsFeature.parameter=csml.parser.Phenomenon(href=param)                               
358                gsFeature.value=gsCoverage
359                self.fms.append(gsFeature)
360            self.DI.closeFile()
361    ###End of createCSMLGridSeriesFeatures###
362   
363    def createCSMLProfileSeriesFeatures(self):
364        #This method assumes that the variables (features) are shared across identically structured files
365        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker)
366        representativeFiles=self.ffmap.getRepresentativeFiles()
367        cat=csml.csmllibs.csmlcrs.CRSCatalogue()
368        for repfile in representativeFiles:
369            #get the names of all the variables in the files:
370            allVarNames, numFeatures = self.__getVarInfo(repfile)
371            #Create a ProfileSeriesFeature for each variable:
372            for i in range(0, numFeatures):
373                crs,axisorder, dimNames=self.__getCRS(allVarNames[i], cat)
374                if crs == None:
375                    print 'none'
376                    continue            #try next variable
377                psFeature=cp.ProfileSeriesFeature()
378                self.__featureMetadata(psFeature,allVarNames[i])
379                #VALUE (coverage)
380                psCoverage=cp.ProfileSeriesCoverage()
381                psDomain=cp.ProfileSeriesDomain()
382                psDomain.srsName=crs.srsName
383                psDomain.axisLabels=crs.axisLabels # note this is the xml attribute axisLabels, not the child element (aLabels)
384                psDomain.srsDimension=crs.srsDimension
385                if crs.units is not None:
386                    psDomain.uomLabels=crs.units
387                else:
388                    psDomain.uomLabels="could not get units"
389                aLabels=''
390                for dim in dimNames:
391                    aLabels=aLabels + dim + ' '
392                psDomain.aLabels=cp.csString(aLabels)
393                gcT=self.__getGridCoordinatesTable(dimNames, crs,axisorder)
394                psDomain.coordTransformTable=gcT
395                psCoverage.profileSeriesDomain=psDomain
396               
397                ##COVERAGE FUNCTION
398                #mr =csml.csmllibs.csmlextra.getMappingRule(len(dimNames))
399                #psCoverage.coverageFunction=cp.csString(mr)
400                rs=self.__getGMLRangeset(allVarNames[i])
401               
402                #RANGESET
403                psCoverage.rangeSet=rs
404                psFeature.parameter=csml.parser.Phenomenon(href='http://badc.rl.ac.uk/localparams#%s'%allVarNames[i])
405                psFeature.value=psCoverage
406                (latval, lonval, heightval, srs)=self.__getLocation()
407                posString ='%s %s %s'%(latval, lonval, heightval)
408               
409                psFeature.location=csml.parser.DirectPositionList(CONTENT=posString, srsName=srs)
410                self.fms.append(psFeature)
411            self.DI.closeFile()
412    ###End of createCSMLProfileSeriesFeatures###
413
414        #BELOW THIS POINT ALL NEEDS REWRITING
415####################################
416    def createCSMLPointSeriesFeatures(self): 
417
418        representativeFiles=self.ffmap.getRepresentativeFiles()
419        for repfile in representativeFiles:
420            self.repfilename,self.listOfFiles=self._populateListOfFiles(repfile)
421            self._getFilesAndTimes()
422            DI = csml.csmllibs.csmldataiface.DataInterface()
423            DI=DI.getUnknownInterfaceType(self.repfilename)
424            DI.openFile(self.repfilename)
425            allVarNames=DI.getListofVariables()
426            numFeatures=len(allVarNames)       
427            try:
428                DI.setAxis(self.timedim)
429                times=DI.getDataForAxis()
430            except:                     
431                times = DI.getTimes()
432            #Create features:
433            for i in range (0, numFeatures):
434                PointSeriesFeature_element=csml.parser.PointSeriesFeature()
435                if str(allVarNames[i]).upper() in ['ERROR FLAG', 'ERROR']: #might need to extend this list
436                    break
437                PointSeriesFeature_element.id=str(allVarNames[i])
438                desc=self._getDescriptiveName(DI)
439                PointSeriesFeature_element.description=csml.parser.Description(desc)
440                #DOMAIN
441                psDomain=csml.parser.PointSeriesDomain()
442                t=csml.parser.Trajectory()
443                t.srsName='urn:EPSG:geographicCRS:4326' #TO Do
444                t.locations =csml.parser.DirectPositionList(vals='1 1')
445               
446                if self.timestorage =='inline':
447                    tpl =csml.parser.TimePositionList()
448                    tpl.timePositions=self.timeString
449                    tpl.frame='%s:%s'%(self.caltype,self.units)
450                    t.times=tpl
451                else:
452                    # do something to create a single extract for the times (from the representative file).
453                    tpl.timePositions = csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType, repfilename, self.timedim, len(self.timeString.split())) 
454                    tpl.frame='%s:%s'%(self.caltype,self.units)
455               
456               
457#                 if self.timestorage =='inline':
458#                     t.times=csmllibs.Parser.TimePositionList('#RefSysX',str(times))
459#                 else:
460#                     #todo: depends on the file mapping???
461#                     t.times=csmllibs.Parser.TimePositionList('#RefSysX','blah') #blah = dummy times
462#                 print 'times: ' + str(allVarNames[i])
463#                 print len(times)
464#                 print len(listOfFiles)
465#                 arraySize=len(times) * len(listOfFiles)
466#                 fextract=csmllibs.csmlfileextracts.createSingleExtract(self.extractType,filenames,self.timedim,arraySize)
467#                 tplist = csmllibs.Parser.TimePositionList(timePositions=fextract)
468#                 t.times=tplist                                                                   
469                filenames=csml.csmllibs.csmlextra.cleanString(str(self.listOfFiles))
470                psDomain.domainReference=t
471                #RANGESET
472                DI.setVariable(allVarNames[i])
473                try:
474                    strUom = DI.getVariableAttribute('units')
475                    strUom=strUom.replace(' ','.')
476                except AttributeError:
477                    #if units attribute doesn't exist:
478                    strUom ="dimensionless_or_units_not_determined"
479                 
480                try:                   
481                    measuredvalues = DI.getDataForVar()
482                except:
483                    measuredvalues = ' could not get values '
484                rs=csml.parser.RangeSet()
485                if self.valuestorage=='inline':
486                    #encode inline
487                    rs.quantityList=csml.parser.MeasureOrNullList(uom=strUom, val=str(measuredvalues)[1:-1])                         
488                else:
489                    #create a file extract link
490                    arraySize=len(measuredvalues)*len(self.listOfFiles) 
491                    #TODO this needs to be able to handle inline, use VALUESTORAGE to determine which to use:
492                    self.extractType=DI.extractType
493                    fextract=csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType,filenames,allVarNames[i],arraySize)
494                    qlist = csml.parser.MeasureOrNullList(val=fextract)
495                    rs.quantityList=qlist
496                PointSeriesFeature_element.rangeSet=rs
497                #COVERAGEFUNCTION                           
498                #PARAMETER
499                #need to do parameter and coverageFunction elements
500                PointSeriesFeature_element.domain=psDomain
501                self.fms.append(PointSeriesFeature_element)
502            DI.closeFile()
503       
504
505#This function needs revising in light of a) csml parser and b) new profile feature types
506    def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim):
507            representativeFiles=ffmap.getRepresentativeFiles()
508            listOfFiles=[]
509            for repfile in representativeFiles:
510                    repfilename=repfile.getRepresentativeFileName()
511                    listOfFiles.append(repfilename)
512                    relfiles = repfile.getRelatedFiles()
513                    for f in relfiles:
514                            #hopefully there are no related files at the moment!
515                            fname = f.getRelatedFileName()
516                            listOfFiles.append(fname)
517                    #print listOfFiles
518                   
519            for file in listOfFiles:
520                    DI = csmllibs.csmldataiface.DataInterface()
521                    DI=DI.getUnknownInterfaceType(file)
522                    print'opening file'
523                    DI.openFile(file)
524                    print 'getting variables'
525                    allVarNames=DI.getListofVariables()
526                    print 'getting feature count'
527                    numFeatures=len(allVarNames)       
528                   
529                    print "FEATURES"
530                    print "***********"
531                    for i in range (0, len(allVarNames)):
532                            print allVarNames[i]
533                           
534                    for i in range (0, numFeatures):
535                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
536                            ProfileFeature_element=csmldoc.createElement("ProfileFeature")
537                            ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i]))
538                            gml_description_element = csmldoc.createElement("gml:description")
539                            gml_featureMember_element.appendChild(ProfileFeature_element)
540                            #***********************************************************************
541                            #PointSeriesDomain:
542                            #***********************************************************************
543                            ProfileDomain_element=csmldoc.createElement("ProfileDomain")
544                           
545                           
546                            #***********************************************************************
547                            # domainReference element (and sub-elements)               
548                            #***********************************************************************
549                            domainReference_element=csmldoc.createElement("domainReference")
550                            #orientedPosition_element=csmldoc.createElement("OrientedPosition")
551                            #locations_element=csmldoc.createElement("locations")
552                            #times_element=csmldoc.createElement("times")
553                            #trajectory_element.appendChild(locations_element)
554                            #trajectory_element.appendChild(times_element)
555                            #domainReference_element.appendChild(orientedPosition_element)
556                           
557                            #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList")
558                            #gml_timePositionList_element.appendChild(csmldoc.createTextNode(self.timeString))
559                            #domainReference_element.appendChild(gml_timePositionList_element)
560                            ProfileDomain_element.appendChild(domainReference_element)
561                            #***********************************************************************
562                            domainComplement_element=csmldoc.createElement("domainComplement")
563                            ProfileDomain_element.appendChild(domainComplement_element)
564                           
565                            #***********************************************************************
566                            # gml:rangeSet_element
567                            #***********************************************************************
568                           
569                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
570                           
571                            #***********************************************************************
572                            # gml:coverageFunction element (and sub-element MappingRule)               
573                            #***********************************************************************
574                            gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction")
575                            MappingRule_element=csmldoc.createElement("MappingRule")
576                            #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
577                            MappingRule_element.setAttribute('scanOrder','tba')
578                            gml_coverageFunction_element.appendChild(MappingRule_element)
579                           
580                           
581                            gml_featureMember_element.appendChild(ProfileDomain_element)
582                            gml_featureMember_element.appendChild(gml_rangeSet_element)
583                            gml_featureMember_element.appendChild(gml_coverageFunction_element)
584                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)       
585                           
586            return 
587                           
588       
Note: See TracBrowser for help on using the repository browser.