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

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

switch to declare time data to be stored inline or in file extract

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