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

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 
Note: See TracChangeset for help on using the changeset viewer.