Changeset 2027 for TI02-CSML/trunk


Ignore:
Timestamp:
22/01/07 15:15:31 (13 years ago)
Author:
domlowe
Message:

unjumbled createGridSeriesFeature method into several reuseable methods

Location:
TI02-CSML/trunk/csml/csmllibs
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/csml/csmllibs/csmlbuilder.py

    r2000 r2027  
    8989    def createFeatureCollection(self): 
    9090        #creates empty feature collection (list) 
    91         self.gml_FeatureCollection = csml.parser.FeatureCollection() 
     91        self.featureCollection = csml.parser.CSMLFeatureCollection() 
    9292  
    9393    def createFeatures(self): 
     
    9797        if not hasattr(self, 'extractDictionary'): 
    9898            self.extractDictionary=None 
    99         thefeatures = csml.csmllibs.csmlfeaturetypes.featureBuilder(self.ds,self.gml_FeatureCollection, self.ffmap, self.extractDictionary,self.timedimension, self.timestorage, self.spatialstorage,self.valuestorage) 
     99        thefeatures = csml.csmllibs.csmlfeaturetypes.featureBuilder(self.ds,self.featureCollection, self.ffmap, self.extractDictionary,self.timedimension, self.timestorage, self.spatialstorage,self.valuestorage) 
    100100                
    101101        #self.csml = thefeatures.csml 
    102102        self.ds=thefeatures.ds_element 
    103         self.gml_FeatureCollection = thefeatures.gml_FeatureCollection_element 
    104         self.ds.featureCollection=self.gml_FeatureCollection 
     103        self.featureCollection = thefeatures.featureCollection 
     104        self.ds.featureCollection=self.featureCollection 
    105105 
    106106                     
  • TI02-CSML/trunk/csml/csmllibs/csmlfeaturetypes.py

    r2015 r2027  
    1313 
    1414class featureBuilder(object): 
    15     def __init__(self, dataset_element, gml_FeatureCollection_element, ffmap,fileExtractDictionary, timedim, timestorage,spatialstorage,valuestorage): 
     15    def __init__(self, dataset_element, featureCollection_element, ffmap,fileExtractDictionary, timedim, timestorage,spatialstorage,valuestorage): 
    1616        self.ds_element=dataset_element 
    17         self.gml_FeatureCollection_element = gml_FeatureCollection_element 
     17        self.featureCollection = featureCollection_element 
    1818        self.ffmap = ffmap 
    1919        self.fileExtractDictionary = fileExtractDictionary 
     
    3838         
    3939        #after the features have been generated append all featureMembers to the feature collection 
    40         self.gml_FeatureCollection_element.members=self.fms 
     40        self.featureCollection.featureMembers=self.fms 
    4141         
    4242    #Some internal methods that are of use to all feature types: 
     
    8888         
    8989     
     90     
     91    #the following __functions are used by all or most feature types: 
     92     
     93    def __getVarInfo(self, representativeFile): 
     94        self.repfilename,self.listOfFiles=self._populateListOfFiles(representativeFile) 
     95        self._getFilesAndTimes() 
     96        #Open representative file and create feature members: 
     97        self.DI = csml.csmllibs.csmldataiface.DataInterface() 
     98        self.DI=self.DI.getUnknownInterfaceType(self.repfilename) 
     99        self.DI.openFile(self.repfilename) 
     100        allVarNames=self.DI.getListofVariables() 
     101        numFeatures=len(allVarNames) 
     102        return allVarNames, numFeatures 
     103     
     104    def __getGridCoordinatesTable(self,dimNames, crs,axisorder): 
     105        #referenceableGrid/GridCoordinatesTable 
     106        gcT=cp.GridCoordinatesTable() 
     107        ##add an axisName element(s) for  each spatial dimension. 
     108        #and an ordinate element 
     109        axes='' 
     110        for axis in dimNames: 
     111            axes =axes + ' '+ axis 
     112        ordinates=[] 
     113        for dimName in enumerate(dimNames): 
     114            ord=cp.GridOrdinateDescription()                 
     115            #map the grid axis to the crs axis 
     116            for axis in axisorder: 
     117                if axisorder[axis]==dimName[0]: 
     118                    ord.coordAxisLabel=cp.csString(axis) 
     119                    ord.gridAxesSpanned=cp.csString(dimName[1]) 
     120                    break 
     121            seqRule= cp.SequenceRule() 
     122            seqRule.CONTENT='Linear' 
     123            seqRule.axisOrder='+1'  #TO DO. Work this out. 
     124            ord.sequenceRule=seqRule 
     125            sptList=cp.SpatialOrTemporalPositionList() 
     126             
     127            if dimName[1]==self.timedim: 
     128                #this is the time dimension. handle calendaring etc when getting the data. 
     129                if self.timestorage=='fileextract': 
     130                    #look up file extract name in dictionary 
     131                    #(axisid stored in dictionary = current filename + variable name) 
     132                    axisid=self.repfilename+dimName[1] 
     133                    sptList.coordinateList=cp.csString('#'+self.fileExtractDictionary[axisid]) 
     134                else: 
     135                    #store times inline 
     136                    self.DI.setAxis(dimName[1]) 
     137                    sptList.coordinateList=cp.csString(self.timeString) 
     138                    sptList.frame='%s:%s'%(self.caltype,self.units) 
     139            else:  #for all other dimensions, create ordinates 
     140                if self.spatialstorage=='fileextract': 
     141                    #look up file extract name in dictionary 
     142                    #(axisid stored in dictionary = current filename + variable name) 
     143                    axisid=self.repfilename+dimName[1] 
     144                    sptList.coordinateList=cp.csString('#'+self.fileExtractDictionary[axisid]) 
     145                else: 
     146                    #store inline 
     147                    self.DI.setAxis(dimName[1]) 
     148                    sptList.coordinateList=cp.csString(csml.csmllibs.csmlextra.cleanString(str(self.DI.getDataForAxis()))) 
     149            ord.coordAxisValues=sptList 
     150            gcT.addChildElem('gridOrdinates',ord)                          
     151        return gcT 
     152     
     153     
     154    def __getCRS(self,varName,catalogue): 
     155        self.DI.setVariable(varName) 
     156        dimNames=self.DI.getVariableAxes()   
     157        if len(dimNames) <= 2: 
     158                #it's an axis or bounds not a feature, try next variable 
     159            return None #(should this be None, None, None ?) 
     160        unitlist=[] 
     161        for dim in dimNames: 
     162            self.DI.setAxis(dim) 
     163            units=self.DI.getAxisAttribute('units')  #need to make special case of units in DI layer 
     164            unitlist.append(units)     
     165        crs, axisorder=catalogue.determineCRS(dimNames,unitlist) 
     166        return crs, axisorder, dimNames 
     167     
     168    def __featureMetadata(self,feature, varName): 
     169        feature.id=str(varName) 
     170        desc = self._getDescriptiveName(self.DI) 
     171        feature.description=desc 
     172         
     173    def __getGMLRangeset(self,varName): 
     174        #GML RANGESET 
     175        rs=csml.parser.RangeSet() 
     176        self.DI.setVariable(varName) 
     177        arrSz = self.DI.getArraySizeOfVar() 
     178        try: 
     179            strUom = self.DI.getVariableAttribute('units') 
     180        except AttributeError: 
     181            # if units attribute doesn't exist: 
     182            strUom ="dimensionless or units not determined" 
     183        if self.valuestorage=='inline': 
     184            #TO DO, store the rangeset inline - use Datablock class??? 
     185            pass 
     186        else: 
     187            #store the rangeSet as an aggregatedArray 
     188            #TODO, need to take this out of the rangeset and use xlink to reference it. 
     189            aa=cp.AggregatedArray() 
     190            aa.arraySize=cp.csString(arrSz) 
     191            aa.uom=cp.csString(strUom) 
     192            aa.aggType=cp.csString('new') #can it be anything else? 
     193            aa.aggIndex=cp.csString('1') 
     194            #FileExtract (fe) element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType) 
     195            self.extractType= self.DI.extractType 
     196            fe = self._getCorrectExtractType() 
     197            varSize=self.DI.getShapeOfVar() 
     198            varSize=csml.csmllibs.csmlextra.cleanString1(str(varSize)) 
     199            fe.arraySize=cp.csString(varSize) 
     200            fe.fileName=cp.csString(self.filesinDir) 
     201            fe.variableName=cp.csString(varName) 
     202            aa.components=[fe] 
     203            aa.id=varName #TODO does this need to have a prefix? 
     204            if hasattr(self.ds_element, 'fileExtracts'): 
     205                self.ds_element.fileExtracts.append(aa) 
     206            else: 
     207                self.ds_element.fileExtracts=[aa] 
     208        va=csml.parser.ValueArray() 
     209        vc=csml.parser.ValueComponent() 
     210        vc.href='linktoaggregatedarray' 
     211        vc.arcrole="http://ndg.nerc.ac.uk/xlinkUsage/insert#QuantityList" 
     212        vc.role="http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor" 
     213        vc.show='embed' 
     214        ql=csml.parser.MeasureOrNullList() 
     215        ql.uom=strUom 
     216        vc.quantityList=ql 
     217        va.valueComponent=vc 
     218        rs.valueArray=va 
     219        return rs 
     220     
     221     
     222    #the following functions are for creation of specific feature types (and call the __functions above) 
    90223    def createCSMLGridSeriesFeatures(self): 
    91224        #This method assumes that the variables (features) are shared across identically structured files 
     
    94227        cat=csml.csmllibs.csmlcrs.CRSCatalogue() 
    95228        for repfile in representativeFiles: 
    96             self.repfilename,self.listOfFiles=self._populateListOfFiles(repfile) 
    97             self._getFilesAndTimes() 
    98             #Open representative file and create feature members: 
    99             DI = csml.csmllibs.csmldataiface.DataInterface() 
    100             DI=DI.getUnknownInterfaceType(self.repfilename) 
    101             DI.openFile(self.repfilename) 
    102             allVarNames=DI.getListofVariables() 
    103             numFeatures=len(allVarNames) 
     229            #get the names of all the variables in the files: 
     230            allVarNames, numFeatures = self.__getVarInfo(repfile) 
    104231            #Create a GridSeriesFeature for each variable: 
    105232            for i in range(0, numFeatures): 
    106                 DI.setVariable(allVarNames[i]) 
    107                 dimNames=DI.getVariableAxes()   
    108                 if len(dimNames) <= 2: 
    109                     #it's an axis or bounds not a feature, try next variable 
    110                     continue 
    111                 unitlist=[] 
    112                 for dim in dimNames: 
    113                     DI.setAxis(dim) 
    114                     units=DI.getAxisAttribute('units')  #need to make special case of units in DI layer 
    115                     unitlist.append(units) 
    116                 crs, axisorder=cat.determineCRS(dimNames,unitlist) 
     233                crs,axisorder, dimNames=self.__getCRS(allVarNames[i], cat) 
     234                if crs == None: 
     235                    continue            #try next variable 
    117236                gsFeature=cp.GridSeriesFeature() 
    118                 gsFeature.id=str(allVarNames[i]) 
    119                 desc = self._getDescriptiveName(DI) 
    120                 #GridSeriesFeature_element.description=csml.parser.Description(desc) 
    121                 gsFeature.description=desc 
     237                self.__featureMetadata(gsFeature,allVarNames[i]) 
     238                 
    122239                #VALUE (coverage) 
    123240                gsCoverage=cp.GridSeriesCoverage() 
     
    130247                    aLabels=aLabels + dim + ' ' 
    131248                gsDomain.aLabels=cp.csString(aLabels) 
    132                 gcT=cp.GridCoordinatesTable() 
    133                 #add an axisName element(s) for  each spatial dimension. 
    134                 #and an ordinate element 
    135                 axes='' 
    136                 for axis in dimNames: 
    137                     axes =axes + ' '+ axis 
    138                 ordinates=[] 
    139                 for dimName in enumerate(dimNames): 
    140                     ord=cp.GridOrdinateDescription()                 
    141                     #map the grid axis to the crs axis 
    142                     for axis in axisorder: 
    143                         if axisorder[axis]==dimName[0]: 
    144                             ord.coordAxisLabel=cp.csString(axis) 
    145                             ord.gridAxesSpanned=cp.csString(dimName[1]) 
    146                             break 
    147                     seqRule= cp.SequenceRule() 
    148                     seqRule.CONTENT='Linear' 
    149                     seqRule.axisOrder='+1'  #TO DO. Work this out. 
    150                     ord.sequenceRule=seqRule 
    151                     sptList=cp.SpatialOrTemporalPositionList() 
    152                      
    153                     if dimName[1]==self.timedim: 
    154                         #this is the time dimension. handle calendaring etc when getting the data. 
    155                         if self.timestorage=='fileextract': 
    156                             #look up file extract name in dictionary 
    157                             #(axisid stored in dictionary = current filename + variable name) 
    158                             axisid=self.repfilename+dimName[1] 
    159                             sptList.coordinateList=cp.csString('#'+self.fileExtractDictionary[axisid]) 
    160                         else: 
    161                             #store times inline 
    162                             DI.setAxis(dimName[1]) 
    163                             sptList.coordinateList=cp.csString(self.timeString) 
    164                             sptList.frame='%s:%s'%(self.caltype,self.units) 
    165                     else:  #for all other dimensions, create ordinates 
    166                         if self.spatialstorage=='fileextract': 
    167                             #look up file extract name in dictionary 
    168                             #(axisid stored in dictionary = current filename + variable name) 
    169                             axisid=self.repfilename+dimName[1] 
    170                             sptList.coordinateList=cp.csString('#'+self.fileExtractDictionary[axisid]) 
    171                         else: 
    172                             #store inline 
    173                             DI.setAxis(dimName[1]) 
    174                             sptList.coordinateList=cp.csString(csml.csmllibs.csmlextra.cleanString(str(DI.getDataForAxis()))) 
    175                     ord.coordAxisValues=sptList 
    176                     gcT.addChildElem('gridOrdinates',ord)                     
     249                gcT=self.__getGridCoordinatesTable(dimNames, crs,axisorder) 
    177250                gsDomain.coordTransformTable=gcT 
    178251                gsCoverage.gridSeriesDomain=gsDomain 
     
    181254                mr =csml.csmllibs.csmlextra.getMappingRule(len(dimNames)) 
    182255                gsCoverage.coverageFunction=cp.csString(mr) 
    183                  
    184                 ##RANGESET 
    185                 rs=csml.parser.RangeSet() 
    186                 arrSz = DI.getArraySizeOfVar() 
    187                 try: 
    188                     strUom = DI.getVariableAttribute('units') 
    189                 except AttributeError: 
    190                     # if units attribute doesn't exist: 
    191                     strUom ="dimensionless or units not determined" 
    192                 if self.valuestorage=='inline': 
    193                     #TO DO, store the rangeset inline - use Datablock class??? 
    194                     pass 
    195                 else: 
    196                     #store the rangeSet as an aggregatedArray 
    197                     #TODO, need to take this out of the rangeset and use xlink to reference it. 
    198                     aa=cp.AggregatedArray() 
    199                     aa.arraySize=cp.csString(arrSz) 
    200                     aa.uom=cp.csString(strUom) 
    201                     aa.aggType=cp.csString('new') #can it be anything else? 
    202                     aa.aggIndex=cp.csString('1') 
    203                     #FileExtract (fe) element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType) 
    204                     self.extractType= DI.extractType 
    205                     fe = self._getCorrectExtractType() 
    206                     varSize=DI.getShapeOfVar() 
    207                     varSize=csml.csmllibs.csmlextra.cleanString1(str(varSize)) 
    208                     fe.arraySize=cp.csString(varSize) 
    209                     fe.fileName=cp.csString(self.filesinDir) 
    210                     fe.variableName=cp.csString(allVarNames[i]) 
    211                     aa.components=[fe] 
    212                     aa.id=allVarNames[i] #TODO does this need to have a prefix? 
    213                     if hasattr(self.ds_element, 'fileExtracts'): 
    214                         self.ds_element.fileExtracts.append(aa) 
    215                     else: 
    216                         self.ds_element.fileExtracts=[aa] 
    217                 rs.href='linktoaggregatedarray' 
    218                 rs.arcrole="http://ndg.nerc.ac.uk/xlinkUsage/insert#QuantityList" 
    219                 rs.role="http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor" 
    220                 rs.show='embed' 
    221                 ql=csml.parser.MeasureOrNullList() 
    222                 ql.uom=strUom 
    223                 rs.quantityList=ql 
     256                rs=self.__getGMLRangeset(allVarNames[i]) 
     257                 
     258                #RANGESET 
    224259                gsCoverage.rangeSet=rs 
    225260                gsFeature.parameter=csml.parser.Phenomenon(href='http://badc.rl.ac.uk/localparams#%s'%allVarNames[i]) 
    226261                gsFeature.value=gsCoverage 
    227                  
    228262                self.fms.append(gsFeature) 
    229             DI.closeFile() 
     263            self.DI.closeFile() 
    230264    ###End of createCSMLGridSeriesFeatures### 
    231265 
    232266    def createCSMLPointSeriesFeatures(self):  
     267        #NEEDS REWRITING 
    233268        representativeFiles=self.ffmap.getRepresentativeFiles() 
    234269        for repfile in representativeFiles: 
Note: See TracChangeset for help on using the changeset viewer.