Changeset 758 for TI02-CSML


Ignore:
Timestamp:
04/04/06 16:25:57 (14 years ago)
Author:
domlowe
Message:

major rewrite of Scanner to employ Parser module. (not complete)

Location:
TI02-CSML/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/Scanner/csmllibs/__init__.py

    r627 r758  
    1111import csmlfeaturefilemap 
    1212import csmlfiles 
     13#import the parser module, assumes it is in a sibling directory to the one containing csmlscan.py 
     14import os 
     15import sys 
     16currentPath=os.getcwd() 
     17parentPath=os.sep.join(currentPath.split(os.sep)[:-1]) 
     18parserPath=parentPath + '/newparser' 
     19sys.path.append(parserPath) #append the parser path to sys.path 
     20try: 
     21    import Parser 
     22except: 
     23    print 'Could not import CSML Parser module. Make sure the parser code is in ../newparser directory on the same level as ../Scanner directory.' 
     24    sys.exit() 
     25 
  • TI02-CSML/trunk/Scanner/csmllibs/csmlbuilder.py

    r629 r758  
    22 
    33import xml.dom.ext 
     4from xml.dom.minidom import parseString 
     5from cElementTree import tostring 
    46import csmllibs 
     7 
    58 
    69#Class for building the csml document.  
     
    2831        self.createFeatureCollection() 
    2932        self.createFeatures() 
    30         self.closeFC() 
    31         self.closeDS() 
     33        #self.closeFC() 
     34        #self.closeDS() 
    3235        self.saveFile() 
    3336        self.printToScreen() 
     
    3538    def createDataset(self): 
    3639        #************************************************************************************* 
    37         #Creates CSML document with root DATASET element which is then passed to other functions 
    38         # which create child elements of the dataset element. - eg FeatureType elements, 
     40        #Creates empty CSML Dataset object with standard attributes 
    3941        #************************************************************************************* 
    40              #Create blank csml document 
    41         self.csml = xml.dom.minidom.Document() 
    42          
    43         #Add Dataset element to CSML document: 
    44         self.ds_element =self.csml.createElementNS('http://ndg.nerc.ac.uk/csml','Dataset') 
    45         self.ds_element.setAttributeNS('','xmlns:gml','http://www,opengis.net/gml') 
    46         self.ds_element.setAttributeNS('','xmlns:om','http://www,opengis.net/om') 
    47         self.ds_element.setAttributeNS('','xmlns:xsi','http://www,w3.org/2001/XML/Schema-instance') 
    48         self.ds_element.setAttributeNS('','xmlns:xlink','http://www,w3.org/1999/xlink') 
    49         self.ds_element.setAttributeNS('','xsi:schemalocation','http://ndg.nerc.ac.uk/csml CSMLAppSchema.xsd') 
    50          
     42               
     43        ########### The Dataset  ############## 
     44        #Create an Empty Dataset 
     45        self.ds = csmllibs.Parser.Dataset() 
     46        #Set gml:id attribute of dataset to be equal to the directory name. (may want to rethink this later) 
     47        setattr(self.ds,'id',self.directory) 
     48        #setattr(self.ds, 'arrayDescriptors', adlist) 
     49        #setattr(self.ds, 'unitDefinitions', uds) 
     50        #setattr(self.ds, 'phenomenonDefinitions', pds) 
     51        #setattr(self.ds, 'featureCollection',fc) 
     52        ######################################## 
    5153 
    5254    def addGMLMetadata(self): 
    53         #************************************************************************************* 
    54         # Adds main GML Metadata elements to CSML document 
    55         #************************************************************************************* 
    56          
     55        #********************************************************************************* 
     56        # Adds main GML Metadata elements to dataset element 
     57        #********************************************************************************* 
     58        #Note: TODO: The Parser has a problem with gml:Name from AbstractGML. 
    5759        strMetaDataProperty = 'http://ndg.nerc.ac.uk/Metadata' + self.directory 
    5860        strCodespace = 'http://ndg/nerc/ac/uk/NDGData' 
    5961        strGmlDescription = 'Dataset for directory ' + self.directory 
    60         strGmlName = self.directory 
    61                      
    62         #gml:MetaDataProperty element 
    63         gml_MetaDataProperty_element = self.csml.createElement("gml:MetaDataProperty") 
    64         gml_MetaDataProperty_element.setAttribute('xlink:href',strMetaDataProperty) 
    65         self.ds_element.appendChild(gml_MetaDataProperty_element) 
    66              
    67         #gml:description element 
    68         gml_description_element = self.csml.createElement("gml:description") 
    69         gml_description_element.appendChild(self.csml.createTextNode(strGmlDescription)) 
    70         self.ds_element.appendChild(gml_description_element) 
    71              
    72             #gml:name element 
    73         gml_name_element = self.csml.createElement("gml:name") 
    74         gml_name_element.setAttribute('codespace',strCodespace) 
    75         gml_name_element.appendChild(self.csml.createTextNode(strGmlName)) 
    76              
    77             #add to dataset element 
    78         self.ds_element.appendChild(gml_name_element) 
    79  
    80   
     62        self.ds.metaDataProperty=[csmllibs.Parser.MetaDataProperty(href=strMetaDataProperty)] 
     63        self.ds.name=csmllibs.Parser.Name( codeSpace=strCodespace, val=[self.directory]) 
     64        self.ds.description=csmllibs.Parser.Description(strGmlDescription) 
    8165     
    8266    def createCSML(self): 
     
    9882    def makeFileExtracts(self): 
    9983        print "make FEs" 
    100         feBuilder =csmllibs.csmlfileextracts.fileExtractBuilder(self.csml, self.ds_element, self.ffmap) 
    101         self.csml = feBuilder.csmldoc 
    102         self.ds_element = feBuilder.dataset_element 
     84        feBuilder =csmllibs.csmlfileextracts.fileExtractBuilder( self.ds, self.ffmap) 
     85        #self.csml = feBuilder.csmldoc 
     86        self.ds = feBuilder.dataset_element 
     87        #todo, remember ds == dataset_element in this file 
    10388        self.extractType = feBuilder.extractType 
    10489        self.extractPrefix  = feBuilder.extractPrefix 
     
    10691 
    10792    def createFeatureCollection(self): 
    108             #creates empty feature collection Object/tag 
    109         self.gml_FeatureCollection = self.csml.createElement("gml:FeatureCollection") 
    110  
     93        #creates empty feature collection (list) 
     94        self.gml_FeatureCollection = csmllibs.Parser.FeatureCollection() 
     95  
    11196    def createFeatures(self): 
    11297        print "create Features" 
    113         thefeatures = csmllibs.csmlfeaturetypes.featureBuilder(self.csml, self.ds_element,self.gml_FeatureCollection,self.extractType, self.extractPrefix, self.ffmap, self.extractDictionary,self.timedimension) 
    114         self.csml = thefeatures.csml 
    115         self.ds_element=thefeatures.ds_element 
     98        thefeatures = csmllibs.csmlfeaturetypes.featureBuilder( self.ds,self.gml_FeatureCollection,self.extractType, self.extractPrefix, self.ffmap, self.extractDictionary,self.timedimension) 
     99        #self.csml = thefeatures.csml 
     100        self.ds=thefeatures.ds_element 
    116101        self.gml_FeatureCollection = thefeatures.gml_FeatureCollection_element 
    117              
     102        self.ds.featureCollection=self.gml_FeatureCollection 
     103 
     104                     
    118105    def closeFC(self): 
    119106        print "close FC" 
     
    131118         
    132119    def saveFile(self): 
    133         print "Saving file" 
    134         #output csml to file 
    135         self.file_object = open(self.outputfile, "w") 
    136         xml.dom.ext.PrettyPrint(self.csml, self.file_object) 
    137         self.file_object.close() 
     120        print "Creating CSML document and saving file" 
     121        #call the toXML method of the Dataset object: 
     122        csml = self.ds.toXML() 
     123        #parse and pretty print csml 
     124        self.strCSML= parseString(tostring(csml)).toprettyxml() 
     125        #tidy up elementtree style namespaces 
     126        #TODO, where to keep this function? 
     127        #strCSML=removeInlineNS(strCSML) 
     128        #open file, write to it. 
     129        f = open(self.outputfile, "w") 
     130        f.write(self.strCSML) 
     131        f.close() 
    138132 
    139133    def printToScreen(self): 
    140         print "to Screen" 
    141         xml.dom.ext.PrettyPrint(self.csml) 
     134        print "Print to Screen" 
     135         
     136        print self.strCSML 
    142137 
  • TI02-CSML/trunk/Scanner/csmllibs/csmlfeaturetypes.py

    r679 r758  
    1010 
    1111 
    12  
    1312class featureBuilder: 
     13    def __init__(self, dataset_element, gml_FeatureCollection_element,extractType, extractPrefix, ffmap,fileExtractDictionary, timedim): 
     14        self.ds_element=dataset_element 
     15        self.gml_FeatureCollection_element = gml_FeatureCollection_element 
     16        self.extractType = extractType 
     17        self.extractPrefix = extractPrefix 
     18        self.ffmap = ffmap 
     19        self.fileExtractDictionary = fileExtractDictionary 
     20        self.timedim = timedim 
     21         
     22        #empty list to hold featureMembers 
     23        self.fms =[] 
     24         
     25        #at the moment, only one featuretype per CSML Dataset is supported. 
     26        #get the featuretype of the first representative file in the ffmap object 
     27        self.featuretype=  self.ffmap.getRepresentativeFiles()[0].getFeatureType() 
     28         
     29        print "FEATURETYPE: " + str(self.featuretype) 
     30        if self.featuretype == 'GridSeriesFeature': 
     31            self.createCSMLGridSeriesFeatures() 
     32        elif self.featuretype == 'PointSeriesFeature':        
     33            self.createCSMLPointSeriesFeatures() 
     34     
     35    def createCSMLGridSeriesFeatures(self): 
     36        #This function is for model data and assumes that the variables (features) are shared across identically structured files 
     37        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker), with a onetomany file map relationship.(not necessarily one to many) 
     38         
     39        representativeFiles=self.ffmap.getRepresentativeFiles() 
     40        for repfile in representativeFiles: 
     41            listOfFiles=[] 
     42            repfilename=repfile.getRepresentativeFileName() 
     43            listOfFiles.append(repfilename) 
     44            relfiles = repfile.getRelatedFiles() 
     45            for f in relfiles: 
     46                fname = f.getRelatedFileName() 
     47                listOfFiles.append(fname) 
     48                 
     49            #THIS IS THE REALLY SLOW FUNCTION CALL!!!!!######################### 
     50            OrderedFileTimeList = csmllibs.csmltime.getFileTimeList(listOfFiles,self.timedim) 
     51            #build strings to hold times/filenames for current gridseriesfeature 
     52            timeString ='' 
     53            filesinDir = '' 
     54            for j in range (0, len(OrderedFileTimeList)): 
     55                t= OrderedFileTimeList[j][0] 
     56                f = OrderedFileTimeList[j][1] 
     57                timeString = timeString + ' ' + str(t) 
     58                filesinDir = filesinDir + ' ' + f 
     59                #Open representative file and create feature members: 
     60            DI = csmllibs.csmldataiface.DataInterface() 
     61            DI=DI.getUnknownInterfaceType(repfilename) 
     62            DI.openFile(repfilename) 
     63            allVarNames=DI.getListofVariables() 
     64            numFeatures=len(allVarNames) 
     65            for i in range(0, numFeatures): 
     66                print allVarNames[i] 
     67                DI.setVariable(allVarNames[i]) 
     68                dimNames=DI.getVariableAxes() 
     69                if len(dimNames) <= 2: 
     70                    #it's an axis or bounds not a feature, try next variable 
     71                    continue 
     72                GridSeriesFeature_element=csmllibs.Parser.GridSeriesFeature() 
     73                GridSeriesFeature_element.id=str(allVarNames[i]) 
     74                 
     75                #description: need to get the attribute called long_name (?? TODO - is this CF compliant??) 
     76                #use Ag's getbestname from nappy package? 
     77                try: 
     78                    desc=DI.getVariableAttribute('long_name') 
     79                    print desc 
     80                except AttributeError: 
     81                    desc = "missing name" 
     82                GridSeriesFeature_element.description=csmllibs.Parser.Description(desc) 
     83 
     84                #*********************************************************************** 
     85                #GridSeriesDomain: 
     86                #*********************************************************************** 
     87                gsDomain=csmllibs.Parser.GridSeriesDomain() 
     88                tpl=csmllibs.Parser.TimePositionList() 
     89                grid=csmllibs.Parser.Grid() 
     90                     
     91                gsDomain.domainReference=tpl 
     92                gsDomain.domainComplement=grid# 
     93                GridSeriesFeature_element.gridSeriesDomain=gsDomain 
     94                     
     95                    # GridSeriesDomain_element=self.csml.createElement("GridSeriesDomain") 
     96#                 #*********************************************************************** 
     97#                 # gml:coverageFunction element (and sub-element MappingRule) 
     98#                 #*********************************************************************** 
     99#                 gml_coverageFunction_element=self.csml.createElement("gml:coverageFunction") 
     100#                 MappingRule_element=self.csml.createElement("MappingRule") 
     101#                 MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames))) 
     102#                 gml_coverageFunction_element.appendChild(MappingRule_element) 
     103#                 #*********************************************************************** 
     104#                 # gml:rangeSet element (and sub-elements) 
     105#                 #*********************************************************************** 
     106#                 gml_rangeSet_element=self.csml.createElement("gml:rangeSet") 
     107#                 AggregatedArray_element=self.csml.createElement("AggregatedArray") 
     108#                 arraySize_element=self.csml.createElement("arraySize") 
     109#                 #arrSz = getArraySize(var) 
     110#                 arrSz = DI.getArraySizeOfVar() 
     111#                 arraySize_element.appendChild(self.csml.createTextNode(str(arrSz))) 
     112#                 uom_element=self.csml.createElement("uom") 
     113#                 try: 
     114#                     #strUom = var.units 
     115#                     strUom = DI.getVariableAttribute('units') 
     116#                 except AttributeError: 
     117#                     #if units attribute doesn't exist: 
     118#                     strUom ="dimensionless or units not determined" 
     119#                 uom_element.appendChild(self.csml.createTextNode(strUom)) 
     120#                 AggregatedArray_element.appendChild(uom_element) 
     121#                 aggType_element=self.csml.createElement("aggType") 
     122#                 aggType_element.appendChild(self.csml.createTextNode('new')) 
     123#                 aggIndex_element=self.csml.createElement("aggIndex") 
     124#                 aggIndex_element.appendChild(self.csml.createTextNode('1')) 
     125#                 AggregatedArray_element.appendChild(arraySize_element) 
     126#                 AggregatedArray_element.appendChild(aggType_element) 
     127#                 AggregatedArray_element.appendChild(aggIndex_element) 
     128#                 component_element=self.csml.createElement("component") 
     129#                 #FileExtract element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType) 
     130#                 FileExtract_element=self.csml.createElement(self.extractType) 
     131#                 arraySize_element=self.csml.createElement("arraySize") 
     132#                 #varSize =var.shape 
     133#                 varSize=DI.getShapeOfVar() 
     134#                 arraySize_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.cleanString1(str(varSize)))) 
     135#                 FileExtract_element.appendChild(arraySize_element) 
     136#                 fileName_element=self.csml.createElement("fileName") 
     137#                 FileExtract_element.appendChild(fileName_element) 
     138#                 #This is the problem: too many filenames >>templating/wildcard needed 
     139#                 #fileName_element.appendChild(csmldoc.createTextNode(cleanString2(str(allFileNames)))) 
     140#                 #fileName_element.appendChild(csmldoc.createTextNode("WILDCARDNEEDED")) 
     141#                 #fileName_element.appendChild(csmldoc.createTextNode(os.path.dirname(templateFileList[k]) + '/*')) 
     142#                 fileName_element.appendChild(self.csml.createTextNode(filesinDir)) 
     143#                 variableName_element=self.csml.createElement("variableName") 
     144#                 variableName_element.appendChild(self.csml.createTextNode(allVarNames[i])) 
     145#                 FileExtract_element.appendChild(variableName_element) 
     146#                 component_element.appendChild(FileExtract_element) 
     147#                 AggregatedArray_element.appendChild(component_element) 
     148#                 gml_rangeSet_element.appendChild(AggregatedArray_element) 
     149#                 ############################################## 
     150#                 #*********************************************************************** 
     151#                 # domainReference element (and sub-elements)           
     152#                 #*********************************************************************** 
     153#                 domainReference_element=self.csml.createElement("domainReference") 
     154#                 gml_timePositionList_element = self.csml.createElement("gml:TimePositionList") 
     155#                 gml_timePositionList_element.appendChild(self.csml.createTextNode(timeString)) 
     156#                 domainReference_element.appendChild(gml_timePositionList_element) 
     157#                 #*********************************************************************** 
     158#                 #*********************************************************************** 
     159#                 # domainComplement element (and sub-elements) 
     160#                 #*********************************************************************** 
     161#                 domainComplement_element=self.csml.createElement("domainComplement") 
     162#                 Grid_element=self.csml.createElement("Grid") 
     163#                 #need to get no. of spatial dimensions (corresponds to axis in domainComplement) 
     164#                 numSpDims=len(varSize) -1 
     165#                 #numSpDims = len(var.shape) - 1 #assuming one dimension is non-spatial (time) 
     166#                 Grid_element.setAttribute('srsName', 'urn:SomeProjection') 
     167#                 Grid_element.setAttribute( 'srsDimension', str(numSpDims)) 
     168#                 Grid_element.setAttribute('dimension' ,str(numSpDims)) 
     169#                 gml_GridEnvelope_element=self.csml.createElement("gml:GridEnvelope") 
     170#                 gml_limits_element=self.csml.createElement("gml:limits") 
     171#                 gml_low_element=self.csml.createElement("gml:low") 
     172#                 gml_high_element=self.csml.createElement("gml:high") 
     173#                 lowLimits=DI.getLowLimits() 
     174#                 highLimits=DI.getHighLimits() 
     175#                 gml_low_element.appendChild(self.csml.createTextNode(lowLimits)) 
     176#                 gml_high_element.appendChild(self.csml.createTextNode(highLimits)) 
     177#                 gml_GridEnvelope_element.appendChild(gml_low_element) 
     178#                 gml_GridEnvelope_element.appendChild(gml_high_element) 
     179#                 gml_limits_element.appendChild(gml_GridEnvelope_element) 
     180#                 Grid_element.appendChild(gml_limits_element) 
     181#                 #add an axisName element for  each spatial dimension. 
     182#                 for i in range (1, len(dimNames)): 
     183#                     gml_axisName_element=self.csml.createElement("gml:axisName") 
     184#                     gml_axisName_element.appendChild(self.csml.createTextNode("dim" + str(i))) 
     185#                     Grid_element.appendChild(gml_axisName_element) 
     186#                  
     187#                 #Add ordinate element and sub elements: 
     188#                 for i in range (1, len(dimNames)): 
     189#                     ordinate_element=self.csml.createElement("ordinate") 
     190#                     gridAxesSpanned_element=self.csml.createElement("gridAxesSpanned") 
     191#                     gridAxesSpanned_element.appendChild(self.csml.createTextNode("dim" + str(i))) 
     192#                     sequenceRule_element=self.csml.createElement("sequenceRule") 
     193#                     sequenceRule_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.getSeqRule(len(dimNames)))) 
     194#                     definesAxis_element=self.csml.createElement("definesAxis") 
     195#                     dimName = dimNames[len(dimNames)-i] 
     196#                     definesAxis_element.appendChild(self.csml.createTextNode(dimName)) 
     197#                     axisValues_element=self.csml.createElement("axisValues") 
     198#                     #look up file extract name in dictionary 
     199#                     #(axisid stored in dictionary = current filename + variable name) 
     200#                     axisid = repfilename + dimName 
     201#                     axisValues = self.fileExtractDictionary[axisid] 
     202#                     axisValues_element.appendChild(self.csml.createTextNode(axisValues)) 
     203#                     ordinate_element.appendChild(gridAxesSpanned_element) 
     204#                     ordinate_element.appendChild(sequenceRule_element) 
     205#                     ordinate_element.appendChild(definesAxis_element) 
     206#                     ordinate_element.appendChild(axisValues_element) 
     207#                     Grid_element.appendChild(ordinate_element) 
     208#                      
     209#                 domainComplement_element.appendChild(Grid_element) 
     210#                 GridSeriesDomain_element.appendChild(domainReference_element) 
     211#                 GridSeriesDomain_element.appendChild(domainComplement_element) 
     212#                 GridSeriesFeature_element.appendChild(GridSeriesDomain_element) 
     213#                 GridSeriesFeature_element.appendChild(gml_rangeSet_element) 
     214#                 GridSeriesFeature_element.appendChild(gml_coverageFunction_element) 
     215#                 gml_featureMember_element.appendChild(GridSeriesFeature_element) 
     216#                 self.gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
     217                 
     218                self.fms.append(GridSeriesFeature_element) 
     219            DI.closeFile() 
     220        self.gml_FeatureCollection_element.members=self.fms 
     221 
     222######################################################################### 
     223 
     224 
     225    def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim): 
     226            representativeFiles=ffmap.getRepresentativeFiles() 
     227            listOfFiles=[] 
     228            for repfile in representativeFiles: 
     229                    repfilename=repfile.getRepresentativeFileName() 
     230                    listOfFiles.append(repfilename) 
     231                    relfiles = repfile.getRelatedFiles() 
     232                    for f in relfiles: 
     233                            #hopefully there are no related files at the moment! 
     234                            fname = f.getRelatedFileName() 
     235                            listOfFiles.append(fname) 
     236                    print listOfFiles 
     237                     
     238            for file in listOfFiles: 
     239                    DI = csmllibs.csmldataiface.DataInterface() 
     240                    DI=DI.getUnknownInterfaceType(file) 
     241                    print'opening file' 
     242                    DI.openFile(file) 
     243                    print 'getting variables' 
     244                    allVarNames=DI.getListofVariables() 
     245                    print 'getting feature count' 
     246                    numFeatures=len(allVarNames)         
     247                     
     248                    print "FEATURES" 
     249                    print "***********" 
     250                    for i in range (0, len(allVarNames)): 
     251                            print allVarNames[i] 
     252                             
     253                    for i in range (0, numFeatures): 
     254                            gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
     255                            ProfileFeature_element=csmldoc.createElement("ProfileFeature") 
     256                            ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i])) 
     257                            gml_description_element = csmldoc.createElement("gml:description") 
     258                            gml_featureMember_element.appendChild(ProfileFeature_element) 
     259                            #*********************************************************************** 
     260                            #PointSeriesDomain: 
     261                            #*********************************************************************** 
     262                            ProfileDomain_element=csmldoc.createElement("ProfileDomain") 
     263                             
     264                             
     265                            #*********************************************************************** 
     266                            # domainReference element (and sub-elements)                 
     267                            #*********************************************************************** 
     268                            domainReference_element=csmldoc.createElement("domainReference") 
     269                            #orientedPosition_element=csmldoc.createElement("OrientedPosition") 
     270                            #locations_element=csmldoc.createElement("locations") 
     271                            #times_element=csmldoc.createElement("times") 
     272                            #trajectory_element.appendChild(locations_element) 
     273                            #trajectory_element.appendChild(times_element) 
     274                            #domainReference_element.appendChild(orientedPosition_element) 
     275                             
     276                            #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList") 
     277                            #gml_timePositionList_element.appendChild(csmldoc.createTextNode(timeString)) 
     278                            #domainReference_element.appendChild(gml_timePositionList_element) 
     279                            ProfileDomain_element.appendChild(domainReference_element) 
     280                            #*********************************************************************** 
     281                            domainComplement_element=csmldoc.createElement("domainComplement") 
     282                            ProfileDomain_element.appendChild(domainComplement_element) 
     283                             
     284                            #*********************************************************************** 
     285                            # gml:rangeSet_element 
     286                            #*********************************************************************** 
     287                             
     288                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet")   
     289                             
     290                            #*********************************************************************** 
     291                            # gml:coverageFunction element (and sub-element MappingRule)                 
     292                            #*********************************************************************** 
     293                            gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction") 
     294                            MappingRule_element=csmldoc.createElement("MappingRule") 
     295                            #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames))) 
     296                            MappingRule_element.setAttribute('scanOrder','tba') 
     297                            gml_coverageFunction_element.appendChild(MappingRule_element) 
     298                             
     299                             
     300                            gml_featureMember_element.appendChild(ProfileDomain_element) 
     301                            gml_featureMember_element.appendChild(gml_rangeSet_element) 
     302                            gml_featureMember_element.appendChild(gml_coverageFunction_element) 
     303                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)         
     304                             
     305            return csmldoc, dataset_element, gml_FeatureCollection_element 
     306                             
     307    #def createCSMLPointFeatures(csmldoc, dataset_element, #gml_FeatureCollection_element,filename, timedim): 
     308            #csmldoc  = csml instance doc 
     309            #dataset_element = toplevel dataset xml element (and all child elements) 
     310            #gml_FeatureCollection_element= FeatureCollection element and all child elements (all features) 
     311            #filename = full file/path of a single file 
     312            #timedim = name of time variable 
     313             
     314    #   DI = csmllibs.csmldataiface.DataInterface() 
     315    #   DI=DI.getUnknownInterfaceType(filename) 
     316    #   DI.openFile(filename) 
     317    #   allVarNames=DI.getListofVariables() 
     318    #   numFeatures=len(allVarNames)     
     319    #   for i in range(0, numFeatures): 
     320    #           gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
     321    #           PointFeature_element=csmldoc.createElement("PointFeature") 
     322    #           PointFeature_element.setAttribute('gml:id',allVarNames[i]) 
     323    #           gml_description_element = csmldoc.createElement("gml:description") 
     324                    #need to get the attribute called long_name (?? TODO - is this CF compliant??) 
     325                    #use Ag's getbestname from nappy package? 
     326    #           try: 
     327    #                   desc=DI.getVariableAttribute('long_name') 
     328    #                   print desc 
     329    #                   except AttributeError: 
     330    #                   desc = "missing name" 
     331    #                   gml_description_element.appendChild(csmldoc.createTextNode(str(desc)))   
     332    #                   PointFeature_element.appendChild(gml_description_element) 
     333                     
     334    #           gml_featureMember_element.appendChild(PointFeature_element) 
     335    #           gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
     336                             
     337    #   dataset_element.appendChild(gml_FeatureCollection_element) 
     338                                             
     339    #   return csmldoc, dataset_element, gml_FeatureCollection_element 
     340             
     341     
     342    def createCSMLPointSeriesFeatures(csmldoc, dataset_element, gml_FeatureCollection_element, ffmap, timedim): 
     343            representativeFiles=ffmap.getRepresentativeFiles() 
     344            listOfFiles=[] 
     345            for repfile in representativeFiles: 
     346                    repfilename=repfile.getRepresentativeFileName() 
     347                    listOfFiles.append(repfilename) 
     348                    relfiles = repfile.getRelatedFiles() 
     349                    for f in relfiles: 
     350                            #hopefully there are no related files at the moment! 
     351                            fname = f.getRelatedFileName() 
     352                            listOfFiles.append(fname) 
     353                     
     354            for file in listOfFiles: 
     355                    DI = csmllibs.csmldataiface.DataInterface() 
     356                    DI=DI.getUnknownInterfaceType(file) 
     357                    DI.openFile(file) 
     358                    allVarNames=DI.getListofVariables() 
     359                    numFeatures=len(allVarNames)         
     360                    try: 
     361                            DI.setAxis(timedim) 
     362                            times=DI.getDataForAxis() 
     363                    except:                      
     364                            times = DI.getTimes() 
     365                            #times = ['time axis not determined'] 
     366                     
     367                                     
     368                    print "FEATURES" 
     369                    print "***********" 
     370                    for i in range (0, len(allVarNames)): 
     371                            print allVarNames[i] 
     372                                             
     373                    print "numFeatures" + str(numFeatures) 
     374                    for i in range (0, numFeatures): 
     375                            gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
     376                            PointSeriesFeature_element=csmldoc.createElement("PointSeriesFeature") 
     377                            PointSeriesFeature_element.setAttribute('gml:id',str(allVarNames[i])) 
     378                            gml_description_element = csmldoc.createElement("gml:description") 
     379                            gml_featureMember_element.appendChild(PointSeriesFeature_element) 
     380                            #*********************************************************************** 
     381                            #PointSeriesDomain: 
     382                            #*********************************************************************** 
     383                            PointSeriesDomain_element=csmldoc.createElement("PointSeriesDomain") 
     384                             
     385                             
     386                            #*********************************************************************** 
     387                            # domainReference element (and sub-elements)                 
     388                            #*********************************************************************** 
     389                            domainReference_element=csmldoc.createElement("domainReference") 
     390                            trajectory_element=csmldoc.createElement("Trajectory") 
     391                            locations_element=csmldoc.createElement("locations") 
     392                            times_element=csmldoc.createElement("times") 
     393                            times_element.appendChild(csmldoc.createTextNode(str(times)[1:-1]))   
     394                            trajectory_element.appendChild(locations_element) 
     395                            trajectory_element.appendChild(times_element) 
     396                            domainReference_element.appendChild(trajectory_element) 
     397                            PointSeriesDomain_element.appendChild(domainReference_element) 
     398                             
     399                            #*********************************************************************** 
     400                            #domainComplement_element=csmldoc.createElement("domainComplement") 
     401                            #PointSeriesDomain_element.appendChild(domainComplement_element) 
     402                             
     403                            #*********************************************************************** 
     404                            # gml:rangeSet_element 
     405                            #*********************************************************************** 
     406                            DI.setVariable(allVarNames[i]) 
     407                             
     408                            #TO DO: 
     409                            try: 
     410                                    #strUom = var.units 
     411                                    strUom = DI.getVariableAttribute('units') 
     412                            except AttributeError: 
     413                                    #if units attribute doesn't exist: 
     414                                    strUom ="dimensionless or units not determined" 
     415                             
     416                            try:                         
     417                                    measuredvalues = str(DI.getDataForVar()) 
     418                            except: 
     419                                    measuredvalues = ' could not get values ' 
     420                             
     421                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet")   
     422                            gml_QuantityList_element=csmldoc.createElement("gml:QuantityList") 
     423                            gml_QuantityList_element.setAttribute('uom',strUom) 
     424                            gml_QuantityList_element.appendChild(csmldoc.createTextNode(str(measuredvalues)[1:-1])) 
     425                            gml_rangeSet_element.appendChild(gml_QuantityList_element) 
     426                             
     427                            #*********************************************************************** 
     428                            # gml:coverageFunction element (and sub-element MappingRule)                 
     429                            #*********************************************************************** 
     430                            parameter_element=csmldoc.createElement("parameter") 
     431                                             
     432                            gml_featureMember_element.appendChild(PointSeriesDomain_element) 
     433                            gml_featureMember_element.appendChild(gml_rangeSet_element) 
     434                            gml_featureMember_element.appendChild(parameter_element) 
     435                            gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
     436                             
     437            return csmldoc, dataset_element, gml_FeatureCollection_element 
     438             
     439 
     440         
     441 
     442 
     443         
     444################################################## 
     445################################################## 
     446################################################## 
     447#OLD cODE: 
     448###################################################################################################################################################### 
     449 
     450class OLDfeatureBuilder: 
    14451    def __init__(self, csmldoc, dataset_element, gml_FeatureCollection_element,extractType, extractPrefix, ffmap,fileExtractDictionary, timedim): 
    15452        self.csml=csmldoc 
  • TI02-CSML/trunk/Scanner/csmllibs/csmlfileextracts.py

    r627 r758  
    55import csmllibs 
    66import sys 
    7  
    87class fileExtractBuilder: 
    9     def __init__(self, csmldoc, dataset_element, ffmap): 
    10         self.csmldoc = csmldoc 
     8    def __init__(self, dataset_element, ffmap): 
    119        self.dataset_element=dataset_element 
    1210        self.ffmap=ffmap 
     
    1412     
    1513    def createFileExtracts(self): 
    16         print "REPRESENTATIVE FILES:" 
     14        #print "REPRESENTATIVE FILES:" 
    1715        #print self.ffmap.getRepresentativeFiles() 
    1816         
     
    3836                allDimNames=DI.getListOfAxes() 
    3937                numDomains=len(allDimNames) 
    40                 for j in range (0, len(allDimNames)): 
     38         
     39        #adlist is an empty list object to hold CSML ArrayDescriptors eg. NetCDFExtract, GRIBExtract etc 
     40        adlist=[] 
     41        for j in range (0, len(allDimNames)): 
    4142                        #Extract element is one of NetCDFExtract, GRIBExtract, PPExtract 
    42                         Extract_element=self.csmldoc.createElement(self.extractType) 
    43                         Extract_element.setAttribute('gml:id', str(self.extractPrefix+allDimNames[j])) 
    44                          
    45                         arraySize_element=self.csmldoc.createElement("arraySize") 
    46                         #dimValue =fileobj.dimensions[allDimNames[j]] 
    47                         dimValue =DI.getSizeOfAxis(allDimNames[j]) 
    48                         if dimValue == None: 
    49                             dimValue ='' 
    50                         arraySize_element.appendChild(self.csmldoc.createTextNode(str(dimValue))) 
    51                         Extract_element.appendChild(arraySize_element) 
    52                                  
    53                         fileName_element=self.csmldoc.createElement("fileName") 
    54                         Extract_element.appendChild(fileName_element) 
    55                         #this line needs to work for different directories., 
    56                         fileName_element.appendChild(self.csmldoc.createTextNode(filename)) 
    57                                  
    58                         variableName_element=self.csmldoc.createElement("variableName") 
    59                         variableName_element.appendChild(self.csmldoc.createTextNode(allDimNames[j])) 
    60                         Extract_element.appendChild(variableName_element) 
    61                         self.dataset_element.appendChild(Extract_element) 
    62                  
    63                         #keep record of extracts/filenames/variables in dictionary 
    64                         idstr = filename + allDimNames[j] 
    65                         self.fileExtractDictionary[idstr] = self.extractPrefix+allDimNames[j] 
    66                                          
    67                 DI.closeFile()   
    68          
     43            print self.extractType 
     44            print self.extractPrefix 
     45            if self.extractType=='NASAAmesExtract': 
     46                arrayDescriptor=csmllibs.Parser.NASAAmesExtract() 
     47            if self.extractType=='NetCDFExtract': 
     48                arrayDescriptor=csmllibs.Parser.NetCDFAmesExtract() 
     49            if self.extractType=='GRIBExtract': 
     50                arrayDescriptor=csmllibs.Parser.GRIBAmesExtract() 
     51            if self.extractType=='PPExtract': 
     52                arrayDescriptor=csmllibs.Parser.PPAmesExtract() 
     53                arrayDescriptor.id=str(self.extractPrefix+allDimNames[j]) 
    6954 
     55            #SET variableName attribute of file extract 
     56            arrayDescriptor.variableName=str(allDimNames[j]) 
     57 
     58            #SET arraySize attribute of file extract 
     59            dimValue =DI.getSizeOfAxis(allDimNames[j]) 
     60            if dimValue == None: 
     61                dimValue ='1'  #temporary to fix unlimited problem 
     62            arrayDescriptor.arraySize=str(dimValue) 
     63 
     64            #SET filename attribute of file extract 
     65            arrayDescriptor.fileName = filename 
     66                 
     67#                       #keep record of extracts/filenames/variables in dictionary 
     68            idstr = filename + allDimNames[j] 
     69            self.fileExtractDictionary[idstr] = self.extractPrefix+allDimNames[j] 
     70            adlist.append(arrayDescriptor) 
     71        DI.closeFile()   
     72        #Add all the file extracts to the dataset element 
     73        setattr(self.dataset_element, 'arrayDescriptors', adlist) 
     74 
     75 
  • TI02-CSML/trunk/Scanner/csmlscan.py

    r629 r758  
    1414import getopt 
    1515import os 
    16 #import udunits 
    1716#CSML modules 
    1817import csmllibs 
     18 
    1919 
    2020 
     
    103103        print "Invalid options, use --help for help" 
    104104        sys.exit() 
    105  
     105     
    106106# process options 
    107107directory = None 
     
    130130                sys.exit()                               
    131131                 
     132 
     133         
    132134#create CSML: 
    133135if csmlfeaturetype == "PointFeature": 
    134136    #NOT YET IMPLEMENTED# 
    135137    if mapping is None: 
    136         mapping = 'onetoone' #default for PointFeature (?) 
     138        mapping = 'onetoone' #default filemapping for PointFeature (?) 
    137139         
    138140elif csmlfeaturetype == "ProfileFeature": 
    139141    #NOT YET IMPLEMENTED# 
    140142    if mapping is None: 
    141         mapping = 'onetoone' #default for ProfileFeature (?) 
     143        mapping = 'onetoone' #default filemapping for ProfileFeature (?) 
    142144         
    143145elif csmlfeaturetype == "GridFeature": 
    144146        #NOT YET IMPLEMENTED# 
    145147    if mapping is None: 
    146         mapping = 'onetoone' #default for GridFeature  
     148        mapping = 'onetoone' #default filemapping for GridFeature  
    147149 
    148150elif csmlfeaturetype == "PointSeriesFeature": 
     
    150152        mapping = 'onetomany' 
    151153 
    152 # elif csmlfeaturetype == "PointSeriesFeature": 
    153 #       print"creating dataset -PointSeriesFeature" 
    154 #       csml, ds_element = csmllibs.csmlmeta.createDataset() 
    155 #       print "adding GML metadata" 
    156 #       csml, ds_element = csmllibs.csmlmeta.addGMLMetadata(csml, directory, ds_element) 
    157 #       print "creating filemap" 
    158 #       fmm = csmllibs.csmlfiles.FileMapMaker(directory,csmlfeaturetype) 
    159 #       ffmap = fmm.onetoone() #assumption! 
    160 #        
    161 #       #Point series feature should only have one changeable axis. Which should (always?) be time. 
    162 #       #Therefore, create time ref system instead of file extracts. 
    163 #       print "creating time reference system" 
    164 #       csml, ds_element, RefSys_element=csmllibs.csmltime.createRefsys(csml,ds_element) 
    165 #       csml,ds_element,RefSys_element=csmllibs.csmltime.createTimeCoordSystem(csml,ds_element,RefSys_element,ffmap) 
    166 #       csml, ds_element=csmllibs.csmltime.closeRefSys(csml,ds_element,RefSys_element) 
    167 #        
    168 #       #print "creating file extracts" 
    169 #       #csml, ds_element, extractType, extractPrefix, extractDictionary = csmllibs.csmlfileextracts.createFileExtracts(csml, ds_element, ffmap) 
    170 #       print 'creating feature collection' 
    171 #       csml,gml_FeatureCollection=csmllibs.csmlmeta.createFeatureCollection(csml) 
    172 #       print "creating features" 
    173 #       csml, dataset, gml_FeatureCollection = csmllibs.csmlfeaturetypes.createCSMLPointSeriesFeatures(csml, ds_element,gml_FeatureCollection, ffmap, timedimension) 
    174 #       print "closing feature collection" 
    175 #       ds_element=csmllibs.csmlmeta.closeFeatureCollection(ds_element,gml_FeatureCollection) 
    176 #       print 'closing dataset' 
    177 #       csml = csmllibs.csmlmeta.closeDataset(csml,ds_element) 
    178  
    179154elif csmlfeaturetype == "ProfileSeriesFeature": 
    180155    if mapping is None:     #NOT YET IMPLEMENTED# 
    181         mapping = 'onetomany' #default for ProfileSeriesFeature (?) 
     156        mapping = 'onetomany' #default filemapping for ProfileSeriesFeature (?) 
    182157         
    183158elif csmlfeaturetype == "GridSeriesFeature": 
    184159    if mapping is None: 
    185         mapping = 'onetomany' #default for GridSeriesFeature 
     160        mapping = 'onetomany' #default filemapping for GridSeriesFeature 
    186161 
    187162csmldataset=csmllibs.csmlbuilder.csmlBuilder(directory,csmlfeaturetype,mapping,timedimension, outputfile) 
  • TI02-CSML/trunk/newparser/Parser.py

    r742 r758  
    9696    def fromXML(self,csmlFrag): 
    9797        if csmlFrag.attrib.has_key(XLINK('href')): 
    98             self.href = csmlFrag.attrib[XLINK('href')] 
     98             self.href = csmlFrag.attrib[XLINK('href')] 
    9999    def toXML(self,csmlFrag): 
    100100        if hasattr(self,'href'): 
     
    130130            self.codeSpace = csmlFrag.attrib['codeSpace'] 
    131131    def toXML(self,csmlFrag): 
     132        if hasattr(self, 'codeSpace'): 
     133            csmlFrag.attrib['codeSpace'] = self.codeSpace 
    132134        if hasattr(self, 'val'): 
    133135            csmlFrag.text = self.val 
    134         if hasattr(self,'codeSpace'): 
    135             csmlFrag.attrib['codeSpace'] = self.codeSpace 
     136         
    136137        return csmlFrag 
    137138 
     
    183184        if hasattr(self,'name'): 
    184185            for name in self.name: 
     186                print name 
    185187                frag = Element(GML('name')) 
    186188                frag = Name.toXML(name,frag) 
Note: See TracChangeset for help on using the changeset viewer.