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

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

removed prefixing - should not have variables with same name anyway

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