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

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

Scanner now picks up long_name and units

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#!/usr/bin/env python
2#**************************************************************************************
3#csmlfeaturetypes.py
4#For creating CSML featuretypes
5#v0.5 split off 11th November 2005
6#Dominic Lowe, BADC
7#**************************************************************************************
8
9import csmllibs
10import sys
11
12class featureBuilder:
13    def __init__(self, dataset_element, gml_FeatureCollection_element,extractType, extractPrefix, ffmap,fileExtractDictionary, timedim):
14        self.ds_element=dataset_element
15        self.gml_FeatureCollection_element = gml_FeatureCollection_element
16        self.extractType = extractType
17        self.extractPrefix = extractPrefix
18        self.ffmap = ffmap
19        self.fileExtractDictionary = fileExtractDictionary
20        self.timedim = timedim
21       
22        #empty list to hold featureMembers
23        self.fms =[]
24       
25        #at the moment, only one featuretype per CSML Dataset is supported.
26        #get the featuretype of the first representative file in the ffmap object
27        self.featuretype=  self.ffmap.getRepresentativeFiles()[0].getFeatureType()
28        if self.featuretype == 'GridSeriesFeature':
29            self.createCSMLGridSeriesFeatures()
30        elif self.featuretype == 'PointSeriesFeature':       
31            self.createCSMLPointSeriesFeatures()
32       
33        #after the features have been generated append all featureMembers to the feature collection
34        self.gml_FeatureCollection_element.members=self.fms
35       
36    def createCSMLGridSeriesFeatures(self):
37        #This function assumes that the variables (features) are shared across identically structured files
38        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker)
39       
40        representativeFiles=self.ffmap.getRepresentativeFiles()
41        #fileid=0  #prefix used to distinguish variable names for similar variables from different files
42        #don't use this - same variables should not be in same data granule.
43        for repfile in representativeFiles:
44            #fileid=fileid+1
45            listOfFiles=[]
46            repfilename=repfile.getRepresentativeFileName()
47            listOfFiles.append(repfilename)
48            relfiles = repfile.getRelatedFiles()
49            for f in relfiles:
50                fname = f.getRelatedFileName()
51                listOfFiles.append(fname)
52               
53            #THIS IS THE REALLY SLOW FUNCTION CALL!!!!!#########################
54            OrderedFileTimeList = csmllibs.csmltime.getFileTimeList(listOfFiles,self.timedim)
55            #build strings to hold times/filenames for current gridseriesfeature
56            timeString =''
57            filesinDir = ''
58            for j in range (0, len(OrderedFileTimeList)):
59                t= OrderedFileTimeList[j][0]
60                f = OrderedFileTimeList[j][1]
61                timeString = timeString + ' ' + str(t)
62                filesinDir = filesinDir + ' ' + f
63                #Open representative file and create feature members:
64            DI = csmllibs.csmldataiface.DataInterface()
65            DI=DI.getUnknownInterfaceType(repfilename)
66            DI.openFile(repfilename)
67            allVarNames=DI.getListofVariables()
68            numFeatures=len(allVarNames)
69            #Create a GridSeriesFeature for each variable:
70            for i in range(0, numFeatures):
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(fileid)+'__'+str(allVarNames[i])
79                GridSeriesFeature_element.id=str(allVarNames[i])
80                #description: need to get the attribute called long_name (?? TODO - is this CF compliant??)
81                #use Ag's getbestname from nappy package?
82                desc=DI.getVariableAttribute('long_name')
83                try:
84                    desc=DI.getVariableAttribute('long_name')
85                except AttributeError:
86                    desc = "missing name"
87                GridSeriesFeature_element.description=csmllibs.Parser.Description(desc)
88
89                #***********************************************************************
90                #GridSeriesDomain:
91                #***********************************************************************
92                gsDomain=csmllibs.Parser.GridSeriesDomain()
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                axes=[]
160                for i in range (1, len(dimNames)):
161                    #axisNames
162                    axisname ='dim'+str(i)
163                    axes.append(axisname)
164                   
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                    grid.axisNames=axes
181                gsDomain.domainComplement=grid
182                GridSeriesFeature_element.domain=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       
275   
276    def createCSMLPointSeriesFeatures(self):           
277            representativeFiles=self.ffmap.getRepresentativeFiles()
278            listOfFiles=[]
279            for repfile in representativeFiles:
280                    repfilename=repfile.getRepresentativeFileName()
281                    listOfFiles.append(repfilename)
282                    relfiles = repfile.getRelatedFiles()
283                    for f in relfiles:
284                            #hopefully there are no related files at the moment!
285                            fname = f.getRelatedFileName()
286                            listOfFiles.append(fname)
287                   
288            for file in listOfFiles:
289                    DI = csmllibs.csmldataiface.DataInterface()
290                    DI=DI.getUnknownInterfaceType(file)
291                    DI.openFile(file)
292                    allVarNames=DI.getListofVariables()
293                    numFeatures=len(allVarNames)       
294                    try:
295                            DI.setAxis(self.timedim)
296                            times=DI.getDataForAxis()
297                    except:                     
298                            times = DI.getTimes()
299                            #times = ['time axis not determined']
300                   
301                                   
302                    print "FEATURES"
303#                     print "***********"
304#                     for i in range (0, len(allVarNames)):
305#                             print allVarNames[i]
306                                           
307                    print "numFeatures" + str(numFeatures)
308                    for i in range (0, numFeatures):
309                            PointSeriesFeature_element=csmllibs.Parser.PointSeriesFeature()
310                            if str(allVarNames[i]).upper() in ['ERROR FLAG', 'ERROR']: #might need to extend this list
311                                break
312                            PointSeriesFeature_element.id=str(allVarNames[i])
313                            try:
314                                desc=DI.getVariableAttribute('long_name')
315#                                 print desc
316                            except AttributeError:
317                                desc = "missing name"
318                            PointSeriesFeature_element.description=csmllibs.Parser.Description(desc)
319
320                            #***********************************************************************
321                            #PointSeriesDomain:
322                            #***********************************************************************
323                            psDomain=csmllibs.Parser.PointSeriesDomain()
324                                                 
325                           
326                            #***********************************************************************
327                            # domainReference element
328                            #***********************************************************************
329                            t=csmllibs.Parser.Trajectory()
330                            t.srsName='urn:EPSG:geographicCRS:4326' #TO Do
331                            t.locations =csmllibs.Parser.DirectPositionList(vals='1 1')
332                            if len(times) > 200:
333                                #create a file extract link for long lists
334                                fextract=csmllibs.csmlfileextracts.createSingleExtract(self.extractType,file,self.timedim,len(times))
335                                tplist = csmllibs.Parser.TimePositionList(timePositions=fextract)
336                                t.times=tplist                               
337                            else:
338                                #encode short lists inline:
339                                t.times=csmllibs.Parser.TimePositionList('#RefSysX',str(times))
340                                 
341                            psDomain.domainReference=t
342                           
343                            #***********************************************************************
344                            # gml:rangeSet_element
345                            #***********************************************************************
346                            DI.setVariable(allVarNames[i])
347                            try:
348                                    strUom = DI.getVariableAttribute('units')
349                            except AttributeError:
350                                    #if units attribute doesn't exist:
351                                    strUom ="dimensionless or units not determined"
352                           
353                            try:                       
354                                    measuredvalues = str(DI.getDataForVar())
355                            except:
356                                    measuredvalues = ' could not get values '
357                           
358                            rs=csmllibs.Parser.RangeSet()
359                            if len(measuredvalues) > 200:
360                                #create a file extract link for long lists
361                                fextract=csmllibs.csmlfileextracts.createSingleExtract(self.extractType,file,allVarNames[i],len(measuredvalues))
362                                qlist = csmllibs.Parser.MeasureOrNullList(val=fextract)
363                                rs.quantityList=qlist
364                            else:
365                                #encode short lists inline
366                                rs.quantityList=csmllibs.Parser.MeasureOrNullList(uom=strUom, val=str(measuredvalues)[1:-1])                         
367
368                            PointSeriesFeature_element.rangeSet=rs
369                            #***********************************************************************
370                            # gml:coverageFunction element (and sub-element MappingRule)               
371                            #***********************************************************************
372                           
373                            #need to do parameter element
374                           
375
376                            PointSeriesFeature_element.domain=psDomain
377                            self.fms.append(PointSeriesFeature_element)
378                    DI.closeFile()
379           
380
381       
382
383
384class OLDfeatureBuilder:
385#obselete but left here for reference (for a while)                               
386    def __init__(self, csmldoc, dataset_element, gml_FeatureCollection_element,extractType, extractPrefix, ffmap,fileExtractDictionary, timedim):
387        self.csml=csmldoc
388        self.ds_element=dataset_element
389        self.gml_FeatureCollection_element = gml_FeatureCollection_element
390        self.extractType = extractType
391        self.extractPrefix = extractPrefix
392        self.ffmap = ffmap
393        self.fileExtractDictionary = fileExtractDictionary
394        self.timedim = timedim
395        #at the moment, only one featuretype per CSML Dataset is supported.
396        #get the featuretype of the first representative file in the ffmap object
397        self.featuretype=  self.ffmap.getRepresentativeFiles()[0].getFeatureType()
398       
399        print "FEATURETYPE: " + str(self.featuretype)
400        if self.featuretype == 'GridSeriesFeature':
401            self.createCSMLGridSeriesFeatures()
402        elif self.featuretype == 'PointSeriesFeature':       
403            self.createCSMLPointSeriesFeatures()
404       
405       
406    def createCSMLGridSeriesFeatures(self):
407        #This function is for model data and assumes that the variables (features) are shared across identically structured files
408        #in the same directory.
409        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker), with a onetomany file map relationship.(not necessarily one to many)
410       
411        representativeFiles=self.ffmap.getRepresentativeFiles()
412        for repfile in representativeFiles:
413            listOfFiles=[]
414            repfilename=repfile.getRepresentativeFileName()
415            listOfFiles.append(repfilename)
416            relfiles = repfile.getRelatedFiles()
417            for f in relfiles:
418                fname = f.getRelatedFileName()
419                listOfFiles.append(fname)
420               
421            #THIS IS THE REALLY SLOW FUNCTION CALL!!!!!#########################
422            OrderedFileTimeList = csmllibs.csmltime.getFileTimeList(listOfFiles,self.timedim)
423            #build strings to hold times/filenames for current gridseriesfeature
424            timeString =''
425            filesinDir = ''
426            for j in range (0, len(OrderedFileTimeList)):
427                t= OrderedFileTimeList[j][0]
428                f = OrderedFileTimeList[j][1]
429                timeString = timeString + ' ' + str(t)
430                filesinDir = filesinDir + ' ' + f
431                #Open representative file and create feature members:
432            DI = csmllibs.csmldataiface.DataInterface()
433            DI=DI.getUnknownInterfaceType(repfilename)
434            DI.openFile(repfilename)
435            allVarNames=DI.getListofVariables()
436            numFeatures=len(allVarNames)
437            for i in range(0, numFeatures):
438                print allVarNames[i]
439                DI.setVariable(allVarNames[i])
440                dimNames=DI.getVariableAxes()
441                if len(dimNames) <= 2:
442                    #it's an axis or bounds not a feature, try next variable
443                    continue
444                gml_featureMember_element=self.csml.createElement("gml:featureMember")
445                GridSeriesFeature_element=self.csml.createElement("GridSeriesFeature")
446                GridSeriesFeature_element.setAttribute('gml:id',allVarNames[i])
447                gml_description_element = self.csml.createElement("gml:description")
448                #need to get the attribute called long_name (?? TODO - is this CF compliant??)
449                #use Ag's getbestname from nappy package?
450                try:
451                    desc=DI.getVariableAttribute('long_name')
452                    print desc
453                except AttributeError:
454                    desc = "missing name"
455                gml_description_element.appendChild(self.csml.createTextNode(str(desc)))
456                GridSeriesFeature_element.appendChild(gml_description_element)
457                #***********************************************************************
458                #GridSeriesDomain:
459                #***********************************************************************
460                GridSeriesDomain_element=self.csml.createElement("GridSeriesDomain")
461                #***********************************************************************
462                # gml:coverageFunction element (and sub-element MappingRule)
463                #***********************************************************************
464                gml_coverageFunction_element=self.csml.createElement("gml:coverageFunction")
465                MappingRule_element=self.csml.createElement("MappingRule")
466                MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
467                gml_coverageFunction_element.appendChild(MappingRule_element)
468                #***********************************************************************
469                # gml:rangeSet element (and sub-elements)
470                #***********************************************************************
471                gml_rangeSet_element=self.csml.createElement("gml:rangeSet")
472                AggregatedArray_element=self.csml.createElement("AggregatedArray")
473                arraySize_element=self.csml.createElement("arraySize")
474                #arrSz = getArraySize(var)
475                arrSz = DI.getArraySizeOfVar()
476                arraySize_element.appendChild(self.csml.createTextNode(str(arrSz)))
477                uom_element=self.csml.createElement("uom")
478                try:
479                    #strUom = var.units
480                    strUom = DI.getVariableAttribute('units')
481                except AttributeError:
482                    #if units attribute doesn't exist:
483                    strUom ="dimensionless or units not determined"
484                uom_element.appendChild(self.csml.createTextNode(strUom))
485                AggregatedArray_element.appendChild(uom_element)
486                aggType_element=self.csml.createElement("aggType")
487                aggType_element.appendChild(self.csml.createTextNode('new'))
488                aggIndex_element=self.csml.createElement("aggIndex")
489                aggIndex_element.appendChild(self.csml.createTextNode('1'))
490                AggregatedArray_element.appendChild(arraySize_element)
491                AggregatedArray_element.appendChild(aggType_element)
492                AggregatedArray_element.appendChild(aggIndex_element)
493                component_element=self.csml.createElement("component")
494                #FileExtract element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType)
495                FileExtract_element=self.csml.createElement(self.extractType)
496                arraySize_element=self.csml.createElement("arraySize")
497                #varSize =var.shape
498                varSize=DI.getShapeOfVar()
499                arraySize_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.cleanString1(str(varSize))))
500                FileExtract_element.appendChild(arraySize_element)
501                fileName_element=self.csml.createElement("fileName")
502                FileExtract_element.appendChild(fileName_element)
503                #This is the problem: too many filenames >>templating/wildcard needed
504                #fileName_element.appendChild(csmldoc.createTextNode(cleanString2(str(allFileNames))))
505                #fileName_element.appendChild(csmldoc.createTextNode("WILDCARDNEEDED"))
506                #fileName_element.appendChild(csmldoc.createTextNode(os.path.dirname(templateFileList[k]) + '/*'))
507                fileName_element.appendChild(self.csml.createTextNode(filesinDir))
508                variableName_element=self.csml.createElement("variableName")
509                variableName_element.appendChild(self.csml.createTextNode(allVarNames[i]))
510                FileExtract_element.appendChild(variableName_element)
511                component_element.appendChild(FileExtract_element)
512                AggregatedArray_element.appendChild(component_element)
513                gml_rangeSet_element.appendChild(AggregatedArray_element)
514                ##############################################
515                #***********************************************************************
516                # domainReference element (and sub-elements)           
517                #***********************************************************************
518                domainReference_element=self.csml.createElement("domainReference")
519                gml_timePositionList_element = self.csml.createElement("gml:TimePositionList")
520                gml_timePositionList_element.appendChild(self.csml.createTextNode(timeString))
521                domainReference_element.appendChild(gml_timePositionList_element)
522                #***********************************************************************
523                #***********************************************************************
524                # domainComplement element (and sub-elements)
525                #***********************************************************************
526                domainComplement_element=self.csml.createElement("domainComplement")
527                Grid_element=self.csml.createElement("Grid")
528                #need to get no. of spatial dimensions (corresponds to axis in domainComplement)
529                numSpDims=len(varSize) -1
530                #numSpDims = len(var.shape) - 1 #assuming one dimension is non-spatial (time)
531                Grid_element.setAttribute('srsName', 'urn:SomeProjection')
532                Grid_element.setAttribute( 'srsDimension', str(numSpDims))
533                Grid_element.setAttribute('dimension' ,str(numSpDims))
534                gml_GridEnvelope_element=self.csml.createElement("gml:GridEnvelope")
535                gml_limits_element=self.csml.createElement("gml:limits")
536                gml_low_element=self.csml.createElement("gml:low")
537                gml_high_element=self.csml.createElement("gml:high")
538                lowLimits=DI.getLowLimits()
539                highLimits=DI.getHighLimits()
540                gml_low_element.appendChild(self.csml.createTextNode(lowLimits))
541                gml_high_element.appendChild(self.csml.createTextNode(highLimits))
542                gml_GridEnvelope_element.appendChild(gml_low_element)
543                gml_GridEnvelope_element.appendChild(gml_high_element)
544                gml_limits_element.appendChild(gml_GridEnvelope_element)
545                Grid_element.appendChild(gml_limits_element)
546                #add an axisName element for  each spatial dimension.
547                for i in range (1, len(dimNames)):
548                    gml_axisName_element=self.csml.createElement("gml:axisName")
549                    gml_axisName_element.appendChild(self.csml.createTextNode("dim" + str(i)))
550                    Grid_element.appendChild(gml_axisName_element)
551               
552                #Add ordinate element and sub elements:
553                for i in range (1, len(dimNames)):
554                    ordinate_element=self.csml.createElement("ordinate")
555                    gridAxesSpanned_element=self.csml.createElement("gridAxesSpanned")
556                    gridAxesSpanned_element.appendChild(self.csml.createTextNode("dim" + str(i)))
557                    sequenceRule_element=self.csml.createElement("sequenceRule")
558                    sequenceRule_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.getSeqRule(len(dimNames))))
559                    definesAxis_element=self.csml.createElement("definesAxis")
560                    dimName = dimNames[len(dimNames)-i]
561                    definesAxis_element.appendChild(self.csml.createTextNode(dimName))
562                    axisValues_element=self.csml.createElement("axisValues")
563                    #look up file extract name in dictionary
564                    #(axisid stored in dictionary = current filename + variable name)
565                    axisid = repfilename + dimName
566                    axisValues = self.fileExtractDictionary[axisid]
567                    axisValues_element.appendChild(self.csml.createTextNode(axisValues))
568                    ordinate_element.appendChild(gridAxesSpanned_element)
569                    ordinate_element.appendChild(sequenceRule_element)
570                    ordinate_element.appendChild(definesAxis_element)
571                    ordinate_element.appendChild(axisValues_element)
572                    Grid_element.appendChild(ordinate_element)
573                   
574                domainComplement_element.appendChild(Grid_element)
575                GridSeriesDomain_element.appendChild(domainReference_element)
576                GridSeriesDomain_element.appendChild(domainComplement_element)
577                GridSeriesFeature_element.appendChild(GridSeriesDomain_element)
578                GridSeriesFeature_element.appendChild(gml_rangeSet_element)
579                GridSeriesFeature_element.appendChild(gml_coverageFunction_element)
580                gml_featureMember_element.appendChild(GridSeriesFeature_element)
581                self.gml_FeatureCollection_element.appendChild(gml_featureMember_element)
582            DI.closeFile()
583                       
584
585#########################################################################
586
587
588    def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim):
589            representativeFiles=ffmap.getRepresentativeFiles()
590            listOfFiles=[]
591            for repfile in representativeFiles:
592                    repfilename=repfile.getRepresentativeFileName()
593                    listOfFiles.append(repfilename)
594                    relfiles = repfile.getRelatedFiles()
595                    for f in relfiles:
596                            #hopefully there are no related files at the moment!
597                            fname = f.getRelatedFileName()
598                            listOfFiles.append(fname)
599                    print listOfFiles
600                   
601            for file in listOfFiles:
602                    DI = csmllibs.csmldataiface.DataInterface()
603                    DI=DI.getUnknownInterfaceType(file)
604                    print'opening file'
605                    DI.openFile(file)
606                    print 'getting variables'
607                    allVarNames=DI.getListofVariables()
608                    print 'getting feature count'
609                    numFeatures=len(allVarNames)       
610                   
611                    print "FEATURES"
612                    print "***********"
613                    for i in range (0, len(allVarNames)):
614                            print allVarNames[i]
615                           
616                    for i in range (0, numFeatures):
617                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
618                            ProfileFeature_element=csmldoc.createElement("ProfileFeature")
619                            ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i]))
620                            gml_description_element = csmldoc.createElement("gml:description")
621                            gml_featureMember_element.appendChild(ProfileFeature_element)
622                            #***********************************************************************
623                            #PointSeriesDomain:
624                            #***********************************************************************
625                            ProfileDomain_element=csmldoc.createElement("ProfileDomain")
626                           
627                           
628                            #***********************************************************************
629                            # domainReference element (and sub-elements)               
630                            #***********************************************************************
631                            domainReference_element=csmldoc.createElement("domainReference")
632                            #orientedPosition_element=csmldoc.createElement("OrientedPosition")
633                            #locations_element=csmldoc.createElement("locations")
634                            #times_element=csmldoc.createElement("times")
635                            #trajectory_element.appendChild(locations_element)
636                            #trajectory_element.appendChild(times_element)
637                            #domainReference_element.appendChild(orientedPosition_element)
638                           
639                            #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList")
640                            #gml_timePositionList_element.appendChild(csmldoc.createTextNode(timeString))
641                            #domainReference_element.appendChild(gml_timePositionList_element)
642                            ProfileDomain_element.appendChild(domainReference_element)
643                            #***********************************************************************
644                            domainComplement_element=csmldoc.createElement("domainComplement")
645                            ProfileDomain_element.appendChild(domainComplement_element)
646                           
647                            #***********************************************************************
648                            # gml:rangeSet_element
649                            #***********************************************************************
650                           
651                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
652                           
653                            #***********************************************************************
654                            # gml:coverageFunction element (and sub-element MappingRule)               
655                            #***********************************************************************
656                            gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction")
657                            MappingRule_element=csmldoc.createElement("MappingRule")
658                            #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
659                            MappingRule_element.setAttribute('scanOrder','tba')
660                            gml_coverageFunction_element.appendChild(MappingRule_element)
661                           
662                           
663                            gml_featureMember_element.appendChild(ProfileDomain_element)
664                            gml_featureMember_element.appendChild(gml_rangeSet_element)
665                            gml_featureMember_element.appendChild(gml_coverageFunction_element)
666                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)       
667                           
668            return csmldoc, dataset_element, gml_FeatureCollection_element
669                           
670    #def createCSMLPointFeatures(csmldoc, dataset_element, #gml_FeatureCollection_element,filename, timedim):
671            #csmldoc  = csml instance doc
672            #dataset_element = toplevel dataset xml element (and all child elements)
673            #gml_FeatureCollection_element= FeatureCollection element and all child elements (all features)
674            #filename = full file/path of a single file
675            #timedim = name of time variable
676           
677    #   DI = csmllibs.csmldataiface.DataInterface()
678    #   DI=DI.getUnknownInterfaceType(filename)
679    #   DI.openFile(filename)
680    #   allVarNames=DI.getListofVariables()
681    #   numFeatures=len(allVarNames)   
682    #   for i in range(0, numFeatures):
683    #           gml_featureMember_element=csmldoc.createElement("gml:featureMember")
684    #           PointFeature_element=csmldoc.createElement("PointFeature")
685    #           PointFeature_element.setAttribute('gml:id',allVarNames[i])
686    #           gml_description_element = csmldoc.createElement("gml:description")
687                    #need to get the attribute called long_name (?? TODO - is this CF compliant??)
688                    #use Ag's getbestname from nappy package?
689    #           try:
690    #                   desc=DI.getVariableAttribute('long_name')
691    #                   print desc
692    #                   except AttributeError:
693    #                   desc = "missing name"
694    #                   gml_description_element.appendChild(csmldoc.createTextNode(str(desc))) 
695    #                   PointFeature_element.appendChild(gml_description_element)
696                   
697    #           gml_featureMember_element.appendChild(PointFeature_element)
698    #           gml_FeatureCollection_element.appendChild(gml_featureMember_element)
699                           
700    #   dataset_element.appendChild(gml_FeatureCollection_element)
701                                           
702    #   return csmldoc, dataset_element, gml_FeatureCollection_element
703           
704   
705    def createCSMLPointSeriesFeatures(csmldoc, dataset_element, gml_FeatureCollection_element, ffmap, timedim):
706            representativeFiles=ffmap.getRepresentativeFiles()
707            listOfFiles=[]
708            for repfile in representativeFiles:
709                    repfilename=repfile.getRepresentativeFileName()
710                    listOfFiles.append(repfilename)
711                    relfiles = repfile.getRelatedFiles()
712                    for f in relfiles:
713                            #hopefully there are no related files at the moment!
714                            fname = f.getRelatedFileName()
715                            listOfFiles.append(fname)
716                   
717            for file in listOfFiles:
718                    DI = csmllibs.csmldataiface.DataInterface()
719                    DI=DI.getUnknownInterfaceType(file)
720                    DI.openFile(file)
721                    allVarNames=DI.getListofVariables()
722                    numFeatures=len(allVarNames)       
723                    try:
724                            DI.setAxis(timedim)
725                            times=DI.getDataForAxis()
726                    except:                     
727                            times = DI.getTimes()
728                            #times = ['time axis not determined']
729                   
730                                   
731                    print "FEATURES"
732                    print "***********"
733                    for i in range (0, len(allVarNames)):
734                            print allVarNames[i]
735                                           
736                    print "numFeatures" + str(numFeatures)
737                    for i in range (0, numFeatures):
738                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
739                            PointSeriesFeature_element=csmldoc.createElement("PointSeriesFeature")
740                            PointSeriesFeature_element.setAttribute('gml:id',str(allVarNames[i]))
741                            gml_description_element = csmldoc.createElement("gml:description")
742                            gml_featureMember_element.appendChild(PointSeriesFeature_element)
743                            #***********************************************************************
744                            #PointSeriesDomain:
745                            #***********************************************************************
746                            PointSeriesDomain_element=csmldoc.createElement("PointSeriesDomain")
747                           
748                           
749                            #***********************************************************************
750                            # domainReference element (and sub-elements)               
751                            #***********************************************************************
752                            domainReference_element=csmldoc.createElement("domainReference")
753                            trajectory_element=csmldoc.createElement("Trajectory")
754                            locations_element=csmldoc.createElement("locations")
755                            times_element=csmldoc.createElement("times")
756                            times_element.appendChild(csmldoc.createTextNode(str(times)[1:-1])) 
757                            trajectory_element.appendChild(locations_element)
758                            trajectory_element.appendChild(times_element)
759                            domainReference_element.appendChild(trajectory_element)
760                            PointSeriesDomain_element.appendChild(domainReference_element)
761                           
762                            #***********************************************************************
763                            #domainComplement_element=csmldoc.createElement("domainComplement")
764                            #PointSeriesDomain_element.appendChild(domainComplement_element)
765                           
766                            #***********************************************************************
767                            # gml:rangeSet_element
768                            #***********************************************************************
769                            DI.setVariable(allVarNames[i])
770                           
771                            #TO DO:
772                            try:
773                                    #strUom = var.units
774                                    strUom = DI.getVariableAttribute('units')
775                            except AttributeError:
776                                    #if units attribute doesn't exist:
777                                    strUom ="dimensionless or units not determined"
778                           
779                            try:                       
780                                    measuredvalues = str(DI.getDataForVar())
781                            except:
782                                    measuredvalues = ' could not get values '
783                           
784                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
785                            gml_QuantityList_element=csmldoc.createElement("gml:QuantityList")
786                            gml_QuantityList_element.setAttribute('uom',strUom)
787                            gml_QuantityList_element.appendChild(csmldoc.createTextNode(str(measuredvalues)[1:-1]))
788                            gml_rangeSet_element.appendChild(gml_QuantityList_element)
789                           
790                            #***********************************************************************
791                            # gml:coverageFunction element (and sub-element MappingRule)               
792                            #***********************************************************************
793                            parameter_element=csmldoc.createElement("parameter")
794                                           
795                            gml_featureMember_element.appendChild(PointSeriesDomain_element)
796                            gml_featureMember_element.appendChild(gml_rangeSet_element)
797                            gml_featureMember_element.appendChild(parameter_element)
798                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)
799                           
800            return csmldoc, dataset_element, gml_FeatureCollection_element
801           
802
803       
804
805
806       
Note: See TracBrowser for help on using the repository browser.