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

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

Scanner rewrite: GridSeriesFeatures? done

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