Changeset 2548 for TI02-CSML


Ignore:
Timestamp:
06/06/07 09:52:44 (12 years ago)
Author:
domlowe
Message:

netcdf output of subsetted qxf point series

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

Legend:

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

    r2547 r2548  
    2828 
    2929#AbstractFileExtract methods: 
    30 addMethods(csml.parser.FileExtract, [ops_FileExtract.getData]) 
     30addMethods(csml.parser.FileExtract, [ops_FileExtract.getData,ops_FileExtract.getDataFromChunks]) 
    3131 
    3232#RawFileExtract methods: 
     
    3737 
    3838##AbstractFeature methods: 
    39 addMethods(csml.parser.AbstractFeature, [ops_AbstractFeature.testmethod, ops_AbstractFeature.getAllowedSubsettings, ops_AbstractFeature.getDataFromChunks]) 
     39addMethods(csml.parser.AbstractFeature, [ops_AbstractFeature.testmethod, ops_AbstractFeature.getAllowedSubsettings]) 
    4040 
    4141##PointFeature methods: 
  • TI02-CSML/trunk/csml/API/ops_AbstractFeature.py

    r2547 r2548  
    1414 
    1515 
    16 def getDataFromChunks(self, fileList, minIdx, maxIdx): 
    17     minIndex=minIdx 
    18     maxIndex=maxIdx 
    19     data=[] 
    20     totalarraylength = 0     
    21     for file in fileList: 
    22         DI=csml.csmllibs.csmldataiface.DataInterface() 
    23         DI=DI.getUnknownInterfaceType(file)  
    24         DI.openFile(file) 
    25         DI.setVariable(self.name.CONTENT) 
    26         datachunk=DI.getDataForVar()        
    27         chunklength=len(datachunk) 
    28         startpoint=totalarraylength 
    29         totalarraylength=totalarraylength +chunklength 
    30                  
    31         if minIndex >= totalarraylength: 
    32             #print 'before selection, skipping %s'%file 
    33             continue 
    34          
    35         elif minIndex < totalarraylength: 
    36             if minIndex >= startpoint: 
    37                 sliceMin=minIndex-startpoint 
    38                 #print 'selection starts in %s at index %s'%(file, sliceMin) 
    39                 if maxIndex < totalarraylength: 
    40                     #print 'selection self contained in %s'%file 
    41                     sliceMax=sliceMin + (maxIndex-minIndex) +1 
    42                     data=datachunk[sliceMin:sliceMax] 
    43                     continue 
    44                 else: 
    45                     #print 'selection goes beyond this file' 
    46                     data.append(datachunk[sliceMin: len(datachunk)]) 
    47                     continue 
    48          
    49         if maxIndex  < startpoint: 
    50             #print 'gone past end of selection, skipping %s'%file 
    51             continue 
    52         elif maxIndex >= totalarraylength: 
    53             #get the whole chunk 
    54             data.append(datachunk) 
    55             continue 
    56          
    57         elif maxIndex <= totalarraylength:      
    58             sliceMax=(maxIndex-startpoint) +1 
    59             data.append(datachunk[0:sliceMax]) 
    60             continue     
    61     try: 
    62         result=MA.concatenate(data) 
    63     except: 
    64         result =data 
    65     return result 
     16 
    6617     
    6718 
  • TI02-CSML/trunk/csml/API/ops_FileExtract.py

    r2526 r2548  
    7575    return dataArray, fillvalue, axisorder, units 
    7676         
     77def getDataFromChunks(self, minIdx, maxIdx): 
     78    '''given a list of files of unknown length and an index range spanning some or all of those files, retuns the data from that index range. Only works with single dimensional data.''' 
     79    minIndex=minIdx 
     80    maxIndex=maxIdx 
     81    data=[] 
     82    totalarraylength = 0     
     83    for file in self.fileList.fileNames.CONTENT.split(): 
     84        DI=csml.csmllibs.csmldataiface.DataInterface() 
     85        DI=DI.getUnknownInterfaceType(file)  
     86        DI.openFile(file) 
     87        DI.setVariable(self.variableName.CONTENT) 
     88        datachunk=DI.getDataForVar()                    
     89        chunklength=len(datachunk) 
     90        startpoint=totalarraylength 
     91        totalarraylength=totalarraylength +chunklength 
     92                 
     93        if minIndex >= totalarraylength: 
     94            #print 'before selection, skipping %s'%file 
     95            continue 
     96         
     97        elif minIndex < totalarraylength: 
     98            if minIndex >= startpoint: 
     99                sliceMin=minIndex-startpoint 
     100                #print 'selection starts in %s at index %s'%(file, sliceMin) 
     101                if maxIndex < totalarraylength: 
     102                    #print 'selection self contained in %s'%file 
     103                    sliceMax=sliceMin + (maxIndex-minIndex) +1 
     104                    data=datachunk[sliceMin:sliceMax] 
     105                    continue 
     106                else: 
     107                    #print 'selection goes beyond this file' 
     108                    data.append(datachunk[sliceMin: len(datachunk)]) 
     109                    continue 
     110         
     111        if maxIndex  < startpoint: 
     112            #print 'gone past end of selection, skipping %s'%file 
     113            continue 
     114        elif maxIndex >= totalarraylength: 
     115            #get the whole chunk 
     116            data.append(datachunk) 
     117            continue 
     118         
     119        elif maxIndex <= totalarraylength:      
     120            sliceMax=(maxIndex-startpoint) +1 
     121            data.append(datachunk[0:sliceMax]) 
     122            continue     
     123    fillvalue=DI.getVariableAttribute('_FillValue') 
     124    axisorder=DI.getVariableAxes() 
     125    units=[] 
     126    for axis in axisorder:     
     127        DI.setAxis(axis) 
     128        units.append(DI.getAxisAttribute('units'))     
     129       
     130    DI.closeFile() 
     131    try: 
     132        result=MA.concatenate(data) 
     133    except: 
     134        result =data 
     135    return result, fillvalue, units 
     136         
    77137def __calendar(file,timedim): 
    78138    #open the file 
  • TI02-CSML/trunk/csml/API/ops_PointSeriesFeature.py

    r2547 r2548  
    11''' ops_PointSeriesFeature  contains operations for PointSeriesFeatures''' 
    22import csml,sys 
     3import cdms, MV, MA 
    34 
    45def testmethod(self): 
     
    3839     
    3940def subsetToPointSeries(self, csmlpath=None, ncpath=None,times=None): 
     41    pathToSubsetNetCDF=ncpath 
    4042    if type(times) is str: 
    4143        selection = csml.csmllibs.csmlextra.listify(times) 
     
    4648    for val in self.value.pointSeriesDomain.timePositionList.CONTENT.split(): 
    4749        tlist.append(val) 
     50         
    4851    
    4952    indices=[] 
    50     if  len(selection) ==2: 
     53    if  len(selection) ==2:        
     54        selectedTimes=[] 
    5155        for domaintime in tlist: 
    5256            if selection[0] == domaintime: 
    5357                minIndex=tlist.index(domaintime) 
     58                selectedTimes.append(domaintime) 
     59            if domaintime > selection[0]: 
     60                if domaintime < selection[1]: 
     61                    selectedTimes.append(domaintime)           
    5462            if selection[1] == domaintime: 
    5563                maxIndex=tlist.index(domaintime) 
     64                selectedTimes.append(domaintime)           
    5665                break    
     66                     
    5767    elif len(selection)==1:   #point only 
    5868        for domaintime in tlist: 
     
    6070                minIndex=tlist.index(domaintime) 
    6171                maxIndex=minIndex 
     72                selectedTimes=selection[0] 
    6273                break 
     74     
     75     
    6376     
    6477    fileList=[] 
     
    6679        fileList.append(f) 
    6780     
     81    fextract=self.value.rangeSet.arrayDescriptor.components 
     82    data, fillvalue, units=fextract.getDataFromChunks(minIndex, maxIndex) 
    6883     
    69     data=self.getDataFromChunks(fileList, minIndex, maxIndex) 
    70  
    71     print data 
    72     sys.exit() 
     84    
    7385    #Now write out the CSML Feature 
    7486     
    75     #Now write out the NetCDF File 
    76  
     87    #Now write out the NetCDF File:    
     88    nc=cdms.open(pathToSubsetNetCDF,'w') 
     89    var=MV.array(data) 
     90    var.id=self.name.CONTENT 
     91    var.name=self.name.CONTENT 
     92    var.units=units[0] # hopefully there is just one unit in this list.. 
     93    setattr(var, 'missing_value' ,fillvalue) 
     94     
     95    floatTimes=[] 
     96    #determine base units for times: 
     97    tOne=csml.csmllibs.csmltime.getCDtime(times[0]) 
     98    tbase=csml.csmllibs.csmltime.getBaseUnits(tOne) 
     99    for time in selectedTimes: 
     100        time=csml.csmllibs.csmltime.getCDtime(time).torel(tbase) 
     101        floatTimes.append(time.value) 
     102    timeAx=cdms.createAxis(floatTimes) 
     103    timeAx.designateTime() 
     104    timeAx.id='time' 
     105    timeAx.units=tbase   
     106    var.setAxis(0,timeAx)       
     107    nc.write(var) 
     108    nc.close() 
     109    sys.exit() 
     110    print 'NetCDF file written to %s'%pathToSubsetNetCDF 
     111    return subsettedFeature, pathToSubsetNetCDF, descriptor 
    77112     
    78113     
     
    80115     
    81116     
     117     
  • TI02-CSML/trunk/csml/csmllibs/csmldataiface.py

    r2547 r2548  
    193193                    self.file.readData() 
    194194            for x in self.file.X: 
    195                 print type(x) 
    196             print x 
     195                pass 
     196                #print type(x) 
     197             
    197198             
    198199            d=Numeric.array(self.file.X) 
     
    200201            if type(self.file.X[1])==list: 
    201202            #if len(self.file.X) > 0: 
    202                     print '1' 
    203203                    data = self.file.X[self.axisstub] 
    204204            else: 
    205                     print '2' 
    206205                    data =self.file.X 
    207206            #print data 
     
    451450    def getDataForVar(self): 
    452451        data = self.varobj.getValue() 
    453         print type(data) 
    454452        return data 
    455453 
  • TI02-CSML/trunk/csml/csmllibs/netCDFWriter.py

    r2546 r2548  
    11import cdms,MV 
     2import Numeric 
    23import csml 
    34import sys 
     
    5354         
    5455    def addVariable(self,data, variableName,axesList, fillvalue,  **kwargs):         
    55         #creates a new variable containing data with named attributes from **kwargs 
    56          
    57         dataarray=MV.array(data) 
     56        #creates a new variable containing data with named attributes from **kwargs        
     57        dataarray=MV.array(data)       
    5858        dataarray.id=variableName 
    5959        dataarray.name=variableName 
     
    6161            setattr(dataarray, key,kwargs[key]) 
    6262        axisCount=0 
    63  
     63       
    6464        #depending on whether time is modelled in the underlying data as a dimension or not the shapes may not match 
    6565        if len(dataarray.shape) < len(axesList):   
     
    7575                    if ax.id == axis: 
    7676                        dataarray.setAxis(axisCount,ax)                        
    77                         axisCount = axisCount +1 
     77                        axisCount = axisCount +1       
     78         
    7879        setattr(dataarray, 'missing_value' ,fillvalue) 
     80         
    7981        self.nc.write(dataarray) 
    8082 
Note: See TracChangeset for help on using the changeset viewer.