Ignore:
Timestamp:
03/05/06 10:58:41 (14 years ago)
Author:
domlowe
Message:

Basic csml i/o - reading csml doc and extracting correct data from file

File:
1 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/newparser/csmlio.py

    r864 r875  
    6969        #returns csml document as a string 
    7070        strCSML=self.dataset.toXML() 
    71         strCSML= parseString(tostring(strCSML)).toprettyxml() 
    72         strCSML= parser_extra.removeInlineNS(strCSML) 
     71        #strCSML= parseString(tostring(strCSML)).toprettyxml() 
     72        #strCSML= parser_extra.removeInlineNS(strCSML) 
    7373        return strCSML 
    7474 
     
    8282    def getFeatureType(self,featureID): 
    8383        self.__setFeature(featureID) 
    84         print featureID 
    8584        if isinstance(self.currentFeature, PointFeature): 
    8685            featureType = 'PointFeature' 
     
    117116        return fileExtractList 
    118117     
    119     def getData(self, fileExtractID): 
    120         #getData, given the gml:id of a file extract, returns the (full) data for that extract 
     118    def subsetList(self, fileExtractID, valueList, minValue, maxValue): 
     119        #This is a simple list subsetter. Given a List of values (which may have been extracted from a NetCDF/NASAAmes file 
     120        #or may have been taken from inline CSML, it doesn't matter) this function returns a subset based on max and min values. 
     121        #There is inefficiency here as you have to read in the whole  'axis' before subsetting         
     122        # Also It assumes monotonically varying axis (although a non-monotonically varying axis 'might' work depending on it's shape) 
     123        #find position of minValue in list: 
     124#         self.__setArrayDescriptor(fileExtractID) 
     125#          
     126#         DI=csmldataiface.DataInterface() 
     127#         DI=DI.getUnknownInterfaceType(self.currentArrayDescriptor.fileName) 
     128#         variable = self.currentArrayDescriptor.variableName 
     129#         DI = csmldataiface.DataInterface() 
     130#         DI=DI.getUnknownInterfaceType(file)         
     131#         DI.openFile(file) 
     132#         DI.setAxis(variable) 
     133#         DI.getSubsetOfDataForVar( 
     134        #find position of maxValue in list: 
     135        pass 
     136        #slice list: 
     137         
     138        return subset 
     139         
     140     
     141 
     142     
     143    def getDataForExtract(self, fileExtractID): 
     144        #getDataForExtract, given the gml:id of a file extract, returns the (full) data for that extract 
    121145        self.__setArrayDescriptor(fileExtractID) 
    122146        file = self.currentArrayDescriptor.fileName 
    123         print self.currentArrayDescriptor.arraySize 
    124147        variable = self.currentArrayDescriptor.variableName 
    125148        DI = csmldataiface.DataInterface() 
     
    129152        fulldata = DI.getDataForAxis() 
    130153        DI.closeFile() 
     154        print fulldata 
    131155        return fulldata 
    132156         
     157     
     158    def getDataForFeature(self, featureID): 
     159        #getDataForFeature, given the gml:id of a file extract, returns the (full) data for that feature 
     160        #i.e. the rangeSet 
     161        #Needs to use the rangeSet, domainReference and domainComplement to work out how to 
     162        def getDataForVariable(file, variable): 
     163            #given a filename and a variable name, get values for that variable from data interface 
     164            DI = csmldataiface.DataInterface() 
     165            DI=DI.getUnknownInterfaceType(file)         
     166            DI.openFile(file) 
     167            DI.setVariable(variable) 
     168            data = DI.getDataForVar() 
     169            return data 
     170        #extract the data from file 
     171        self.__setFeature(featureID) 
     172        #The RangeSet can be one of: 
     173        #QuantityList 
     174        #DataBlock 
     175        #ArrayDescriptor 
     176        #AggregatedArray 
     177        print self.currentFeature.rangeSet 
     178        if hasattr(self.currentFeature.rangeSet, 'quantityList'): 
     179            print self.currentFeature.rangeSet.quantityList 
     180        elif hasattr(self.currentFeature.rangeSet, 'dataBlock'): 
     181            print self.currentFeature.rangeSet.dataBlock 
     182        elif hasattr(self.currentFeature.rangeSet, 'arrayDescriptor'): 
     183            print self.currentFeature.rangeSet.arrayDescriptor 
     184        elif hasattr(self.currentFeature.rangeSet, 'aggregatedArray'): 
     185            print self.currentFeature.rangeSet.aggregatedArray 
     186            fulldata=None 
     187            for comp in self.currentFeature.rangeSet.aggregatedArray.component: 
     188                var = comp.variableName 
     189                for file in comp.fileName.split(): 
     190                    data = getDataForVariable(file, var) 
     191                    print file + '  ' + var 
     192     
     193                    if fulldata is None: 
     194                        fulldata = data.tolist() 
     195                    else: 
     196                        #print data 
     197                        for item in data.tolist(): 
     198                            fulldata.append(item) 
     199                        #print fulldata 
     200                        print 'length' + str(len(fulldata)) 
     201                        #note, for now treat masked arrays as lists 
     202        return fulldata 
     203         
     204        #return fulldata 
     205     
     206     
     207#     def getSubset(self, featureID, subsetDefinition): 
     208#         #featureID = gml:id of feature 
     209#         #subsetDefinition = dictionary containing subset definition 
     210#          
     211#          
     212#         [("1999-01-01T00:00:00", "1999-01-01T06:00:00"), "axis_1.1.1.1":(30,-30), "axis_1.1.1.2":(30,-30)] 
    133213     
    134214    def getDomainReference(self, featureID): 
    135215        #This will return a list containing one or more ordinates: 
    136         #[Name, values, units(optional)] 
    137         self.__setFeature(featureID) 
    138         domainref=[] 
     216        #currently in form [Name, values] 
     217        self.__setFeature(featureID) 
    139218        #domainReference could be one of: 
    140219        #Trajectory 
     
    142221        #TimePositionList 
    143222        if isinstance(self.currentFeature.domain.domainReference,TimePositionList): 
    144             time = [] 
    145             time.append('Time') 
    146             time.append(self.currentFeature.domain.domainReference.timePositions) 
    147             domainref.append(time) 
     223#             time = [] 
     224#             time.append('t') 
     225#             time.append(self.currentFeature.domain.domainReference.timePositions) 
     226#             domainref.append(time) 
     227             
     228            time = {} 
     229            time['t'] = self.currentFeature.domain.domainReference.timePositions 
     230            domainref  = time 
     231             
    148232        #Position 
    149233        #OrientedPosition 
     
    153237    def getDomainComplement(self, featureID): 
    154238        #This will return a list containing one or more ordinates: 
    155         #[Name, values, units(optional)] 
    156         domaincomp =[] 
     239        #currently in form [Name, values] 
     240        domaincomp ={} 
    157241        self.__setFeature(featureID) 
    158242        dc = self.currentFeature.domain.domainComplement 
     
    163247        #Grid 
    164248        if isinstance(dc, Grid): 
     249         
    165250            for ordinate in dc.ordinates: 
    166                 newaxis = [] 
    167                 newaxis.append(ordinate.definesAxis) 
    168                 data = self.getData(ordinate.axisValues.id) # axisValues has already been resolved to the fileExtract so the gml:id can be passed straight to getData() 
    169                 newaxis.append(data) 
    170                 domaincomp.append(newaxis) 
     251                domaincomp[ordinate.definesAxis]=self.getDataForExtract(ordinate.axisValues.id) 
     252#                 newaxis = [] 
     253#                 newaxis.append(ordinate.definesAxis) 
     254#                 data = self.getData(ordinate.axisValues.id) # axisValues has already been resolved to the fileExtract so the gml:id can be passed straight to getData() 
     255#                 newaxis.append(data) 
     256#                 domaincomp.append(newaxis) 
    171257        return domaincomp 
    172258     
    173259    def getDomain(self, featureID): 
    174         #returns both the domain reference axes and domain compliment axes in a single domain 
    175         domain = [] 
    176         domain.append(self.getDomainReference(featureID)) 
    177         domain.append(self.getDomainComplement(featureID)) 
     260        #returns both the domain reference axes and domain compliment axes in a single domain dictionary 
     261        #axes are in no particular order 
     262        domain = {} 
     263        dc=self.getDomainComplement(featureID) 
     264        dr=self.getDomainReference(featureID) 
     265        for key in dc.keys(): 
     266            domain[key]=dc[key] 
     267        for key in dr.keys(): 
     268            domain[key]=dr[key] 
     269             
     270        #domain.append(self.getDomainComplement(featureID)) 
     271        #domain.append(self.getDomainReference(featureID)) 
    178272        return domain 
Note: See TracChangeset for help on using the changeset viewer.