Changeset 977

Timestamp:

22/05/06 16:41:45 (15 years ago)

Author:

domlowe

Message:

moved gridseries subsetting to new api structure

File:

• TI02-CSML/trunk/parser/csmldoc.py (modified) (2 diffs)

TI02-CSML/trunk/parser/csmldoc.py

@@ -8 +8 @@
 import parser_extra
 
+#import the DataInterface module from the Scanner, assumes it is in a sibling directory to the one containing csmlio.py
+#TODO - how best to organise modules...
+import os
+currentPath=os.getcwd()
+parentPath=os.sep.join(currentPath.split(os.sep)[:-1])
+parserPath=parentPath + '/Scanner/csmllibs'
+sys.path.append(parserPath) #append the parser path to sys.path
+try:
+    import csmldataiface
+except:
+    print 'Could not import CSML Data Interface module. Make sure the Parser code is in ../parser directory on the same level as ../Scanner directory.'
+    sys.exit()
+
+#global to hold top level dataset object - otherwise we will constantly be reparsing it.
+
 class CSMLDataset:
     def __init__(self,csmlfile):
-        #must be provided with csmlfile
-        #parse the csmlfile into self.dataset
+        """must be provided with csmlfile
+        parses the csmlfile into self.dataset """
         self.dataset=Dataset()
         tree = ElementTree(file=csmlfile)
         self.dataset.fromXML(tree.getroot())
         self.dataset =parser_extra.ParserPostProcessor(self.dataset).resolveReferences()
-    
-    #other Dataset methods go here:
-    ############
-    #def getFeaturelist:
-    #def getArrayDescriptors
-    #etc...
+    def getFeatureList(self):
+        #returns a list of feature ids for the dataset
+        self.featureList = []
+        for member in self.dataset.featureCollection.members:
+             self.featureList.append(member.id)
+        return self.featureList
 
     def getFeature(self, featureID):
-        #returns a single feature object, which can be accessed by both the high-level api and the Parser API
+        """ returns a single feature object, which can be accessed by both the high-level api and the Parser API"""
         for member in self.dataset.featureCollection.members:
                 if member.id == featureID:
                     if  isinstance(member,PointFeature):
-                        return CSMLPointFeature(member)
+                        return CSMLPointFeature(member,self.dataset)
                     elif isinstance(member,PointSeriesFeature):
-                        return CSMLPointSeriesFeature(member)
+                        return CSMLPointSeriesFeature(member,self.dataset)
                     elif  isinstance(member,ProfileFeature):
-                        return CSMLProfileFeature(member)
+                        return CSMLProfileFeature(member,self.dataset)
+                    elif  isinstance(member,GridSeriesFeature):
+                        return CSMLGridSeriesFeature(member,self.dataset)
                     #elif etc... for all feature types
 
+    def getFileExtract(self,extractID):
+        for extract in self.dataset.arrayDescriptors:
+            if  extract.id==extractID:
+                return CSMLAbstractFileExtract(extract) 
+
+    #other Dataset level methods go here:
+    ############
+    #def getArrayDescriptors
+    #etc...
+    
+class CSMLAnyFile:
+    def __init__(self,filename):
+        self.DI=csmldataiface.DataInterface()
+        self.DI=self.DI.getUnknownInterfaceType(filename)
+        self.DI.openFile(filename)
+    def getVariableData(self,variableName,**kwargs):
+        #kwargs can contain a subset definition
+        self.DI.setVariable(variableName)
+        if kwargs:
+            data = self.DI.getSubsetOfDataForVar(**kwargs)
+        else:
+            data = self.DI.getDataForVar()
+        return data
+
+class CSMLAbstractFileExtract:
+    def __init__(self,extract):
+        self.parsedExtract=extract
+        self.file=self.parsedExtract.fileName
+        self.variableName=self.parsedExtract.variableName
+        self.DI = csmldataiface.DataInterface()
+        self.DI=self.DI.getUnknownInterfaceType(self.file)
+        self.DI.openFile(self.file)
+    def getAxisData(self):
+        self.DI.setAxis(self.variableName)
+        fulldata = self.DI.getDataForAxis()
+        return fulldata
+    def getVariableData(self,**kwargs):
+        #kwargs can contain a subset definition
+        self.DI.setVariable(self.variableName)
+        if kwargs:
+            data = self.DI.getSubsetOfDataForVar(**kwargs)
+        else:
+            data = self.DI.getDataForVar()
+        return data
+    def close(self):
+        self.DI.closeFile()
+
 class CSMLAbstractFeature: 
-        """Contains methods applicable to any feature but methods can be overwritten by individual feature types
-         - see testMethod for example.
-        """
-        def __init__(self,feature):
-            self.parsedFeature=feature
-            '''sets self.parsedFeature to contain the lower level parsed feature'''
-            
-            '''testMethod is the 'default' abstract testMethod - it will be overwritten by subclasses i.e. by specific features'''
-        def testMethod(self):
-            #default "testMethod" for all features
-            print 'underlying feature type:' + str(self.parsedFeature)
-            return 'abstract test method called and not overwritten'
-        def getOutputOptions(self):
-            #return generic output options for abstract features - this may in fact be none... and will be always overwritten within specific feature types
-            pass
+    """Contains methods applicable to any feature but methods can be overwritten by individual feature types
+        - see testMethod for example.
+    """
+    def __init__(self,feature,parentDataset):
+        self.parsedFeature=feature
+        self.parentDataset=parentDataset
+        '''sets self.parsedFeature to contain the lower level parsed feature'''
+    def getAllowedSubsettings(self):
+        return ['none']
+
+    def getFeatureType(self):
+        return str(self.parsedFeature)
+    
+    def testMethod(self):
+        #default "testMethod" for all features
+        print '/n Underlying feature type: ' + str(self.parsedFeature)
+        return 'abstract test method called and not overwritten'
+        
+    def getDomain(self):
+        #should return a list contianing the domain reference and compliment if any.
+        return []
+    
+    def getOutputOptions(self):
+        #return generic output options for abstract features - this may in fact be none... and will be always overwritten within specific feature types
+        pass
+    
+    def getSubset(self, **kwargs):
+        pass
+    def __writeNetCDF(self,var, timeSubset,fulldata,**kwargs):
+        """writes a NetCDF file containing feature data"""
+        pass
+
+    def __writeCSML(self, var, timeSubset,fulldata,**kwargs):
+        """writes a CSML document to descibe subsetted feature"""
+        pass
 
 class CSMLPointFeature(CSMLAbstractFeature):
@@ -85 +169 @@
     #   pass
     
+class CSMLGridSeriesFeature(CSMLAbstractFeature):
+    def __init__(self,feature, dataset):
+        CSMLAbstractFeature.__init__(self,feature,dataset)
+    def getAllowedSubsettings(self):
+        return ['subsetToGridSeries']
+    def getOutputOptions(self):
+            #return output options for GridSeries feature... not implemented
+        pass
+    
+    def __getDomainReference(self):
+        #Inspects a time position list for the domain reference.
+        #TODO, does not handle a file extract in place of a list.
+        if isinstance(self.parsedFeature.domain.domainReference,TimePositionList):          
+            time = {}
+            time['t'] = self.parsedFeature.domain.domainReference.timePositions
+            domainref  = time
+        self.domainReference=domainref
+        return domainref
+        
+    def __getDomainComplement(self):
+        #This will return a list containing one or more ordinates:
+        #currently in form [Name, values]
+        domaincomp ={}
+        dc = self.parsedFeature.domain.domainComplement
+        #dc should be a grid!
+        if isinstance(dc, Grid):
+            for ordinate in dc.ordinates:
+                fe=CSMLAbstractFileExtract(ordinate.axisValues)
+                domaincomp[ordinate.definesAxis]=fe.getAxisData()
+                fe.close()
+        self.domainComplement=domaincomp
+        return domaincomp
+            
+    def getDomain(self):
+        #returns both the domain reference axes and domain compliment axes in a single domain dictionary
+        #axes are in no particular order
+        domain = {}
+        dr=self.__getDomainReference()
+        dc=self.__getDomainComplement()
+        for key in dc.keys():
+            domain[key]=dc[key]
+        for key in dr.keys():
+            domain[key]=dr[key]
+        return domain
+
+    def subsetToGridSeries(self, timeSubset,  **kwargs):
+        domainref = self.__getDomainReference()
+        filelog=[]
+        self.times=timeSubset
+        self.files=[]
+        fulldata=None
+        for time in self.times:
+            listPosition=domainref['t'].split().index(time)
+            for comp in self.parsedFeature.rangeSet.aggregatedArray.component:
+                var = comp.variableName
+                f=CSMLAnyFile(comp.fileName.split()[listPosition])
+                data=f.getVariableData(var, **kwargs)
+                self.files.append(comp.fileName.split()[listPosition])
+                filelog.append(comp.fileName.split()[listPosition]) #needed?
+                if fulldata is None:
+                    fulldata = data.tolist()
+                else:
+                    for item in data.tolist():
+                        fulldata.append(item)
+        ###### create the csml document ###############
+        output_file='temp.xml'
+        dset = self.parentDataset
+        dset.featureCollection.members=[]# clear out all the existing features
+        dset.arrayDescriptors=[]
+        strTimes =''
+        for time in self.times:
+            strTimes= strTimes + ' ' + time 
+        self.parsedFeature.domain.domainReference=TimePositionList(timePositions=strTimes)
+        strFiles=''
+        for file in self.files:
+            strFiles= strFiles + ' ' + file
+        #print dir(feat.rangeSet.aggregatedArray.component)
+        for comp in self.parsedFeature.rangeSet.aggregatedArray.component:
+            comp.fileName=strFiles
+        dset.featureCollection.members.append(self.parsedFeature)
+        csml = dset.toXML()    
+        #Tidy up and print the CSML document:
+        #strCSML= parseString(tostring(csml)).toprettyxml()
+        strCSML=parser_extra.PrettyPrint(csml)
+        strCSML=parser_extra.removeInlineNS(strCSML)
+        print strCSML
+        ################################
+        
+        ######create the netcdf file #############
+        ################################
+        
+        return output_file
+
+        #self.writeNetCDF(var, timeSubset,fulldata,**kwargs)
+        #self.writeCSML(var, timeSubset,fulldata,**kwargs)
+
+    def testMethod(self):
+        """Over writes abstract testMethod"""
+        print 'underlying feature type:' + str(self.parsedFeature)
+        return 'abstract test method overwritten by CSMLGridSeriesFeature class'
     
 # etc.. do same for all features