Changeset 2758


Ignore:
Timestamp:
02/08/07 15:43:25 (12 years ago)
Author:
domlowe
Message:

Changes to enable subsetting of Trajectories - not fully working but convenient place to commit

Location:
TI02-CSML/trunk/csml
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/csml/API/__init__.py

    r2642 r2758  
    4242 
    4343 
    44 operationsMap={csml.parser.Dataset:ops_Dataset, csml.parser.FileExtract:ops_FileExtract, csml.parser.RawFileExtract: ops_RawFileExtract, csml.parser.AbstractFeature:ops_AbstractFeature, csml.parser.GridSeriesFeature:ops_GridSeriesFeature, csml.parser.GridFeature:ops_GridFeature, csml.parser.PointSeriesFeature:ops_PointSeriesFeature, csml.parser.PointSeriesFeature:ops_PointSeriesFeature,csml.parser.ProfileSeriesFeature:ops_ProfileSeriesFeature} 
     44operationsMap={csml.parser.Dataset:ops_Dataset, csml.parser.FileExtract:ops_FileExtract, csml.parser.RawFileExtract: ops_RawFileExtract, csml.parser.AbstractFeature:ops_AbstractFeature, csml.parser.GridSeriesFeature:ops_GridSeriesFeature, csml.parser.GridFeature:ops_GridFeature, csml.parser.PointSeriesFeature:ops_PointSeriesFeature, csml.parser.PointSeriesFeature:ops_PointSeriesFeature,csml.parser.ProfileSeriesFeature:ops_ProfileSeriesFeature,csml.parser.TrajectoryFeature:ops_TrajectoryFeature} 
    4545 
    4646 
  • TI02-CSML/trunk/csml/API/genSubset.py

    r2741 r2758  
    301301        crs=cat.getCRS(feature.value.profileSeriesDomain.srsName,labels = feature.value.profileSeriesDomain.axisLabels) 
    302302        gridordinates = feature.value.profileSeriesDomain.coordTransformTable.gridOrdinates 
    303      
     303    elif type(feature) == csml.parser.TrajectoryFeature: 
     304        crs=cat.getCRS(feature.value.trajectoryDomain.srsName,labels = feature.value.trajectoryDomain.axisLabels) 
     305        gridordinates = feature.value.trajectoryDomain.coordTransformTable.gridOrdinates 
    304306    timeName=crs.axes[crs.timeAxis] 
    305307    #Find the original time name (timeAxis) for the file. 
  • TI02-CSML/trunk/csml/API/ops_AbstractFeature.py

    r2692 r2758  
    2828def getAxisLabels(self): 
    2929    return None 
     30 
     31 
     32def getSliceIndices(self, selection): 
     33    ''' Calculates indices to use in slicing (eg for RawFileExtracts) and adds them to the selection dictionary 
     34    #Doesn't work fully due to lack of proper CRS cataloguing so returns empty lists if error is encountered 
     35    ''' 
     36    selLower=[] 
     37    selUpper=[] 
     38    
     39    try: 
     40        #create artificial range for single selections so that (60) becomes (60,60) 
     41        for sel in selection: 
     42            if type(selection[sel]) in [int,float,str]:  #ie. single value as opposed to a list containing a range 
     43                tmp=selection[sel] 
     44                selection[sel]=[tmp,tmp]  
     45            
     46        for sel in selection: 
     47            for item in enumerate(self.domain[sel]): 
     48                index=item[0] 
     49                value=item[1]    
     50                if value==selection[sel][0]: 
     51                    #selLower.append(self.domain[sel].index(item)) 
     52                    limit1=index 
     53                    #selLower.append(item[0]) 
     54                if value==selection[sel][1]: 
     55                    #selUpper.append(self.domain[sel].index(item)) 
     56                    limit2=index 
     57                     
     58            #make sure the lower limit is the smaller of the two selection criteria         
     59            if limit1 <= limit2: 
     60                selLower.append(limit1) 
     61                selUpper.append(limit2+1)#plus 1 to take account of the fact that Numeric (and python) slicing returns only 6 values for [0:6] so, to get the first 7 values say you need to pass [0:7] 
     62            else: 
     63                selLower.append(limit2) 
     64                selUpper.append(limit1 +1) 
     65         
     66         
     67        selection['lower']=tuple(selLower) 
     68        selection['upper']=tuple(selUpper)   
     69         
     70    except: 
     71        pass 
     72    return selection 
  • TI02-CSML/trunk/csml/API/ops_FileExtract.py

    r2668 r2758  
    110110    data=[] 
    111111    totalarraylength = 0     
    112     for file in self.fileList.fileNames.CONTENT.split(): 
     112    filenames=[] 
     113    try: 
     114        for file in self.fileList.fileNames.CONTENT.split(): 
     115            filenames.append[file] 
     116            print 'HERE' 
     117    except: 
     118        filenames.append(self.fileName.CONTENT) 
     119     
     120    for file in filenames: 
    113121        DI=csml.csmllibs.csmldataiface.DataInterface() 
    114122        DI=DI.getUnknownInterfaceType(file)  
  • TI02-CSML/trunk/csml/API/ops_GridSeriesFeature.py

    r2692 r2758  
    2020    return ['subsetToGridSeries', 'subsetToProfileSeries']  #other operations 
    2121 
    22 def getSliceIndices(self, selection): 
    23     ''' Calculates indices to use in slicing (eg for RawFileExtracts) and adds them to the selection dictionary 
    24     #Doesn't work fully due to lack of proper CRS cataloguing so returns empty lists if error is encountered 
    25     ''' 
    26     selLower=[] 
    27     selUpper=[] 
    28      
    29     try: 
    30         #create artificial range for single selections so that (60) becomes (60,60) 
    31         for sel in selection: 
    32             if type(selection[sel]) in [int,float]:  #ie. single value as opposed to a list containing a range 
    33                 tmp=selection[sel] 
    34                 selection[sel]=[tmp,tmp]  
    35              
    36         for sel in selection: 
    37             for item in enumerate(self.domain[sel]): 
    38                 index=item[0] 
    39                 value=item[1]    
    40                 if value==selection[sel][0]: 
    41                     #selLower.append(self.domain[sel].index(item)) 
    42                     limit1=index 
    43                     #selLower.append(item[0]) 
    44                 if value==selection[sel][1]: 
    45                     #selUpper.append(self.domain[sel].index(item)) 
    46                     limit2=index 
    47                      
    48             #make sure the lower limit is the smaller of the two selection criteria         
    49             if limit1 <= limit2: 
    50                 selLower.append(limit1) 
    51                 selUpper.append(limit2+1)#plus 1 to take account of the fact that Numeric (and python) slicing returns only 6 values for [0:6] so, to get the first 7 values say you need to pass [0:7] 
    52             else: 
    53                 selLower.append(limit2) 
    54                 selUpper.append(limit1 +1) 
    55          
    56         selection['lower']=tuple(selLower) 
    57         selection['upper']=tuple(selUpper)   
    58     except: 
    59         pass 
    60     return selection 
     22 
    6123 
    6224 
  • TI02-CSML/trunk/csml/API/ops_TrajectoryFeature.py

    r1686 r2758  
    11''' ops_TrajectoryFeature  contains operations for TrajectoryFeature''' 
    22 
    3 #or movingpintseries - whatever it is called 
     3import csml, cdms, MV 
     4import sys 
    45 
    56def testmethod(self): 
    67    print 'testmethod for TrajectoryFeature' 
    78    return 'testmethod - TrajectoryFeature' 
     9 
     10def getAllowedSubsettings(self): 
     11    return ['subsetToTrajectory']  
     12 
     13 
     14def getDomain(self): 
     15    #returns domain as a dictionary of ordinates {name: [values], ...} 
     16    self.domain={} 
     17    self.gridnames={} 
     18    for gridOrd in self.value.trajectoryDomain.coordTransformTable.gridOrdinates: 
     19        name=gridOrd.coordAxisLabel.CONTENT 
     20        self.gridnames[gridOrd.gridAxesSpanned.CONTENT]=name 
     21        if hasattr(gridOrd.coordAxisValues, 'insertedExtract'): 
     22            self.domain[name], fill, axisorder, units=gridOrd.coordAxisValues.insertedExtract.getData() 
     23            #add to cache 
     24        else:             
     25            valList=[] 
     26            try: 
     27                vals=gridOrd.coordAxisValues.coordinateList.CONTENT 
     28                for val in vals.split():   
     29                    valList.append(eval(val)) 
     30            except: 
     31                vals=gridOrd.coordAxisValues.timePositionList.CONTENT 
     32                for val in vals.split():   
     33                    valList.append(val)             
     34            self.domain[name]=valList     
     35    return self.domain     
     36                 
     37     
     38                 
     39    
     40def subsetToTrajectory(self, outputdir=None, ncname='trajectory.nc' ,times=None): 
     41    ''' subsetting a trajectory feature by time ''' 
     42    if outputdir is not None: 
     43        self.outputdir=outputdir 
     44    elif csml.API.csmlContainer.globalContainer.OUTPUTDIR is not None: 
     45        self.outputdir=csml.API.csmlContainer.globalContainer.OUTPUTDIR 
     46       
     47    if self.outputdir is not None: 
     48        pathToSubsetNetCDF=self.outputdir + '/' +ncname 
     49    else:  
     50        pathToSubsetNetCDF=ncname 
     51    if self.outputdir is not None: 
     52        csml.csmllibs.csmlextra.checkDirExists(self.outputdir) 
     53   
     54    if type(times) is str: 
     55        selection = tuple(csml.csmllibs.csmlextra.listify(times)) 
     56    else: 
     57        selection = times   
     58    tlist=[]     
     59     
     60     
     61    #repurpose the trajectoryDomain 
     62    td=self.value.trajectoryDomain                          
     63       
     64    for gridOrd in td.coordTransformTable.gridOrdinates: 
     65        if hasattr(gridOrd.coordAxisValues, 'timePositionList'): 
     66            for val in gridOrd.coordAxisValues.timePositionList.CONTENT.split(): 
     67                tlist.append(val)        
     68            indices=[] 
     69            if  len(selection) ==2:        
     70                selectedTimes=[] 
     71                for domaintime in tlist: 
     72                    if selection[0] == domaintime: 
     73                        minIndex=tlist.index(domaintime) 
     74                        selectedTimes.append(domaintime) 
     75                    if domaintime > selection[0]: 
     76                        if domaintime < selection[1]: 
     77                            selectedTimes.append(domaintime)           
     78                    if selection[1] == domaintime: 
     79                        maxIndex=tlist.index(domaintime) 
     80                        selectedTimes.append(domaintime)           
     81                        break    
     82                             
     83            elif len(selection)==1:   #point only 
     84                for domaintime in tlist: 
     85                    if selection[0] == domaintime:                 
     86                        minIndex=tlist.index(domaintime) 
     87                        maxIndex=minIndex 
     88                        selectedTimes=selection 
     89                        break 
     90            if len(selectedTimes) ==1: 
     91                timestr=selectedTimes[0] 
     92            else: 
     93                timestr='' 
     94                for t in selectedTimes: 
     95                    timestr = timestr + ' ' + t 
     96            #now substitute these times into the feature as we will use it later to write out a new feature. 
     97            gridOrd.coordAxisValues.timePositionList=csml.parser.csString(timestr) 
     98            break 
     99     
     100    for gridOrd in td.coordTransformTable.gridOrdinates: 
     101        if hasattr(gridOrd.coordAxisValues, 'coordinateList'): 
     102            data, fillvalue=gridOrd.coordAxisValues.insertedExtract.getDataFromChunks(minIndex, maxIndex) 
     103            if len(data)==1: 
     104                datastr=data[0] 
     105            else: 
     106                datastr='' 
     107                for d in data: 
     108                    datastr=datastr + ' ' + d 
     109            gridOrd.coordAxisValues=csml.parser.csString(datastr) 
     110                          
     111    fileList=[] 
     112    try: 
     113        fileList.append(self.value.rangeSet.valueArray.valueComponent.insertedExtract.fileName.CONTENT) 
     114        fextract=self.value.rangeSet.valueArray.valueComponent.insertedExtract 
     115        units=self.value.rangeSet.valueArray.valueComponent.uom 
     116    except: 
     117        for f in self.value.rangeSet.arrayDescriptor.components.fileList.fileNames.CONTENT.split(): 
     118            fileList.append(f) 
     119            fextract=self.value.rangeSet.arrayDescriptor.components 
     120            units= self.value.rangeSet.arrayDescriptor.uom.CONTENT 
     121     
     122    #Now write out the CSML Feature: 
     123    #create a TrajectoryCoverage 
     124    cvg=csml.parser.TrajectoryCoverage() 
     125    cvg.id=csml.csmllibs.csmlextra.getRandomID() 
     126     
     127    td.id=csml.csmllibs.csmlextra.getRandomID() 
     128                 
     129    sdid=csml.csmllibs.csmlextra.getRandomID() # for the storage descriptor 
     130    #create a RangeSet 
     131    rs=csml.parser.RangeSet() 
     132    va=csml.parser.ValueArray() 
     133    vc=csml.parser.MeasureOrNullList() 
     134    vc.href='#%s'%sdid 
     135    vc.arcrole="http://ndg.nerc.ac.uk/xlinkUsage/insert#QuantityList" 
     136    vc.role="http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor" 
     137    vc.show='embed' 
     138    try: 
     139        vc.uom=self.value.rangeSet.valueArray.valueComponent.uom 
     140    except: 
     141        vc.uom = 'unknown'  #TODO, 
     142    va.valueComponent=vc 
     143    va.id=csml.csmllibs.csmlextra.getRandomID() 
     144    rs.valueArray=va 
     145     
     146    #Add the domain and rangeSet as attributes of the coverage 
     147    cvg.trajectoryDomain=td 
     148    cvg.rangeSet=rs 
     149     
     150    totalArraySize=10 
     151    descriptor=csml.parser.NetCDFExtract(id=sdid,fileName=csml.parser.csString(ncname),variableName=self.name,arraySize=csml.parser.csString(totalArraySize)) 
     152 
     153     
     154    #the parameter of the feature is of type Phenomenon, here href creates "xlink:href=..." 
     155    param=self.parameter 
     156     
     157     
     158    #create a stand alone pointseries feature containing this coverage 
     159    csmlWrap=csml.csmllibs.csmlfeaturewrap.CSMLWrapper() 
     160    subsettedFeature=csmlWrap.createTrajectoryFeature(value=cvg,parameter=param,featureID=self.id,description=self.description) 
     161     
     162       
     163     
     164    #Now write out the NetCDF File:    
     165    nc=cdms.open(pathToSubsetNetCDF,'w') 
     166    var=MV.array(data) 
     167    var.id=self.name.CONTENT 
     168    var.name=self.name.CONTENT 
     169    var.units=units[0] # hopefully there is just one unit in this list.. 
     170    setattr(var, 'missing_value' ,fillvalue) 
     171     
     172    floatTimes=[] 
     173     
     174    tOne=csml.csmllibs.csmltime.getCDtime(selection[0]) 
     175    tbase=csml.csmllibs.csmltime.getBaseUnits(tOne) 
     176    for time in selectedTimes: 
     177        time=csml.csmllibs.csmltime.getCDtime(time).torel(tbase) 
     178        floatTimes.append(time.value) 
     179    timeAx=cdms.createAxis(floatTimes) 
     180    timeAx.designateTime() 
     181    timeAx.id='time' 
     182    timeAx.units=tbase   
     183    var.setAxis(0,timeAx)       
     184    nc.write(var) 
     185    nc.close()    
     186    print 'NetCDF file written to %s'%pathToSubsetNetCDF 
     187    return subsettedFeature, pathToSubsetNetCDF, descriptor 
     188 
     189    
     190    
  • TI02-CSML/trunk/csml/csmllibs/csmlbuilder.py

    r2741 r2758  
    108108        self.ds=thefeatures.ds_element 
    109109        self.featureCollection = thefeatures.featureCollection 
    110         self.featureCollection =csml.csmllibs.csmlextra.addEnvelope(self.featureCollection, self.ffmap)         
    111         setattr(self.featureCollection, 'id', csml.csmllibs.csmlextra.getRandomID()) 
     110        try: 
     111            self.featureCollection =csml.csmllibs.csmlextra.addEnvelope(self.featureCollection, self.ffmap)         
     112        except: 
     113            pass 
     114        setattr(self.featureCollection, 'id', csml.csmllibs.csmlextra.getRandomID()) 
    112115        try: 
    113116            self.featureCollection =csml.csmllibs.csmlextra.addEnvelope(self.featureCollection, self.ffmap)         
  • TI02-CSML/trunk/csml/csmllibs/csmlfeaturewrap.py

    r2396 r2758  
    4949        return feature 
    5050     
     51    def createTrajectoryFeature(self,value, parameter=None,featureID=None, name=None, description=None): 
     52        feature=csml.parser.TrajectoryFeature() 
     53        feature= self._createAbstractFeature(feature, value, parameter,featureID, name, description) 
     54        return feature 
     55     
    5156    #def setBoundingEnvelope(self,lowerCorner,upperCorner,timePosition1,timePosition2): 
    5257        ##set the bounding box envelope of the feature collection.  
  • TI02-CSML/trunk/csml/parser_extra.py

    r2741 r2758  
    153153        for feature in csml.csmllibs.csmlextra.listify(self.dataset.featureCollection.featureMembers): 
    154154            cvg = feature.value 
    155             for att in ['gridSeriesDomain', 'pointDomain', 'profileSeriesDomain','blah blah']: 
     155            for att in ['gridSeriesDomain', 'pointDomain', 'profileSeriesDomain','trajectoryDomain','blah blah']: 
    156156                if hasattr(cvg, att): 
    157157                    domain=getattr(cvg,att) 
  • TI02-CSML/trunk/csml/testfiles/gridseries/subset.py

    r2585 r2758  
    5252#subset a feature 
    5353 
    54 f.subsetToGridSeries(ncname='tmp1.nc', outputdir='.', latitude=(-90, 
    55 > 
    56 > 90), longitude=(-180,180), time='1975-07-15T00:00:00.0') 
     54#f.subsetToGridSeries(ncname='tmp1.nc', outputdir='.', latitude=(-90, 90), longitude=(-180,180), time='1975-07-15T00:00:00.0') 
    5755 
    5856    #csmlContainer.add(feature.subsetToGridSeries(outputdir,ncname='mygridseries.nc',**subsetDictionary)) 
Note: See TracChangeset for help on using the changeset viewer.