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

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

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