Changeset 771


Ignore:
Timestamp:
07/04/06 16:33:46 (13 years ago)
Author:
domlowe
Message:

Scanner rewrite: GridSeriesFeatures? done

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

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/Scanner/csmllibs/csmlfeaturetypes.py

    r758 r771  
    88 
    99import csmllibs 
    10  
     10import sys 
    1111 
    1212class featureBuilder: 
     
    3434     
    3535    def createCSMLGridSeriesFeatures(self): 
    36         #This function is for model data and assumes that the variables (features) are shared across identically structured files 
    37         #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker), with a onetomany file map relationship.(not necessarily one to many) 
     36        #This function assumes that the variables (features) are shared across identically structured files 
     37        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker) 
    3838         
    3939        representativeFiles=self.ffmap.getRepresentativeFiles() 
     
    6363            allVarNames=DI.getListofVariables() 
    6464            numFeatures=len(allVarNames) 
     65            #Create a GridSeriesFeature for each variable: 
    6566            for i in range(0, numFeatures): 
    6667                print allVarNames[i] 
     
    7071                    #it's an axis or bounds not a feature, try next variable 
    7172                    continue 
     73                 
    7274                GridSeriesFeature_element=csmllibs.Parser.GridSeriesFeature() 
    7375                GridSeriesFeature_element.id=str(allVarNames[i]) 
    74                  
    7576                #description: need to get the attribute called long_name (?? TODO - is this CF compliant??) 
    7677                #use Ag's getbestname from nappy package? 
     
    8687                #*********************************************************************** 
    8788                gsDomain=csmllibs.Parser.GridSeriesDomain() 
     89                 
     90                #*********************************************************************** 
     91                # domainReference element  
     92                #*********************************************************************** 
    8893                tpl=csmllibs.Parser.TimePositionList() 
     94                tpl.timePositions=timeString 
     95                gsDomain.domainReference=tpl 
    8996                grid=csmllibs.Parser.Grid() 
    90                      
    91                 gsDomain.domainReference=tpl 
    92                 gsDomain.domainComplement=grid# 
     97                 
    9398                GridSeriesFeature_element.gridSeriesDomain=gsDomain 
    94                      
    95                     # GridSeriesDomain_element=self.csml.createElement("GridSeriesDomain") 
    96 #                 #*********************************************************************** 
    97 #                 # gml:coverageFunction element (and sub-element MappingRule) 
    98 #                 #*********************************************************************** 
    99 #                 gml_coverageFunction_element=self.csml.createElement("gml:coverageFunction") 
    100 #                 MappingRule_element=self.csml.createElement("MappingRule") 
    101 #                 MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames))) 
    102 #                 gml_coverageFunction_element.appendChild(MappingRule_element) 
    103 #                 #*********************************************************************** 
    104 #                 # gml:rangeSet element (and sub-elements) 
    105 #                 #*********************************************************************** 
    106 #                 gml_rangeSet_element=self.csml.createElement("gml:rangeSet") 
    107 #                 AggregatedArray_element=self.csml.createElement("AggregatedArray") 
    108 #                 arraySize_element=self.csml.createElement("arraySize") 
    109 #                 #arrSz = getArraySize(var) 
    110 #                 arrSz = DI.getArraySizeOfVar() 
    111 #                 arraySize_element.appendChild(self.csml.createTextNode(str(arrSz))) 
    112 #                 uom_element=self.csml.createElement("uom") 
    113 #                 try: 
    114 #                     #strUom = var.units 
    115 #                     strUom = DI.getVariableAttribute('units') 
    116 #                 except AttributeError: 
    117 #                     #if units attribute doesn't exist: 
    118 #                     strUom ="dimensionless or units not determined" 
    119 #                 uom_element.appendChild(self.csml.createTextNode(strUom)) 
    120 #                 AggregatedArray_element.appendChild(uom_element) 
    121 #                 aggType_element=self.csml.createElement("aggType") 
    122 #                 aggType_element.appendChild(self.csml.createTextNode('new')) 
    123 #                 aggIndex_element=self.csml.createElement("aggIndex") 
    124 #                 aggIndex_element.appendChild(self.csml.createTextNode('1')) 
    125 #                 AggregatedArray_element.appendChild(arraySize_element) 
    126 #                 AggregatedArray_element.appendChild(aggType_element) 
    127 #                 AggregatedArray_element.appendChild(aggIndex_element) 
    128 #                 component_element=self.csml.createElement("component") 
    129 #                 #FileExtract element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType) 
    130 #                 FileExtract_element=self.csml.createElement(self.extractType) 
    131 #                 arraySize_element=self.csml.createElement("arraySize") 
    132 #                 #varSize =var.shape 
    133 #                 varSize=DI.getShapeOfVar() 
    134 #                 arraySize_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.cleanString1(str(varSize)))) 
    135 #                 FileExtract_element.appendChild(arraySize_element) 
    136 #                 fileName_element=self.csml.createElement("fileName") 
    137 #                 FileExtract_element.appendChild(fileName_element) 
    138 #                 #This is the problem: too many filenames >>templating/wildcard needed 
    139 #                 #fileName_element.appendChild(csmldoc.createTextNode(cleanString2(str(allFileNames)))) 
    140 #                 #fileName_element.appendChild(csmldoc.createTextNode("WILDCARDNEEDED")) 
    141 #                 #fileName_element.appendChild(csmldoc.createTextNode(os.path.dirname(templateFileList[k]) + '/*')) 
    142 #                 fileName_element.appendChild(self.csml.createTextNode(filesinDir)) 
    143 #                 variableName_element=self.csml.createElement("variableName") 
    144 #                 variableName_element.appendChild(self.csml.createTextNode(allVarNames[i])) 
    145 #                 FileExtract_element.appendChild(variableName_element) 
    146 #                 component_element.appendChild(FileExtract_element) 
    147 #                 AggregatedArray_element.appendChild(component_element) 
    148 #                 gml_rangeSet_element.appendChild(AggregatedArray_element) 
    149 #                 ############################################## 
    150 #                 #*********************************************************************** 
    151 #                 # domainReference element (and sub-elements)           
    152 #                 #*********************************************************************** 
    153 #                 domainReference_element=self.csml.createElement("domainReference") 
    154 #                 gml_timePositionList_element = self.csml.createElement("gml:TimePositionList") 
    155 #                 gml_timePositionList_element.appendChild(self.csml.createTextNode(timeString)) 
    156 #                 domainReference_element.appendChild(gml_timePositionList_element) 
    157 #                 #*********************************************************************** 
     99                #*********************************************************************** 
     100                #coverageFunction 
     101                mr =csmllibs.Parser.MappingRule(csmllibs.csmlextra.getMappingRule(len(dimNames))) 
     102             
     103                GridSeriesFeature_element.coverageFunction=mr  
     104 
     105               #*********************************************************************** 
     106              # gml:rangeSet element  
     107              #*********************************************************************** 
     108                arrSz = DI.getArraySizeOfVar() 
     109              
     110                try: 
     111                    strUom = DI.getVariableAttribute('units') 
     112                except AttributeError: 
     113    #                if units attribute doesn't exist: 
     114                        strUom ="dimensionless or units not determined" 
     115 
     116                rs=csmllibs.Parser.RangeSet() 
     117                aa=csmllibs.Parser.AggregatedArray() 
     118                aa.arraySize=str(arrSz) 
     119                aa.uom=strUom 
     120                aa.aggType='new' #can it be anything else? 
     121                aa.aggIndex='1' 
     122                #FileExtract (fe) element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType) 
     123                if self.extractType=='NetCDFExtract': 
     124                    fe = csmllibs.Parser.NetCDFExtract() 
     125                if self.extractType=='NASAAmesExtract': 
     126                    fe = csmllibs.Parser.NASAAmesExtract() 
     127                if self.extractType=='GRIBExtract': 
     128                    fe = csmllibs.Parser.GRIBExtract() 
     129                if self.extractType=='PPExtract': 
     130                    fe = csmllibs.Parser.PPExtract() 
     131                     
     132                varSize=DI.getShapeOfVar() 
     133                fe.arraySize=csmllibs.csmlextra.cleanString1(str(varSize)) 
     134                fe.fileName=filesinDir 
     135                fe.variableName=allVarNames[i] 
     136                aa.component=[fe] 
     137                rs.aggregatedArray=aa 
     138                GridSeriesFeature_element.rangeSet=rs 
     139                ###################################################### 
     140 
     141 
    158142#                 #*********************************************************************** 
    159143#                 # domainComplement element (and sub-elements) 
    160144#                 #*********************************************************************** 
    161 #                 domainComplement_element=self.csml.createElement("domainComplement") 
    162 #                 Grid_element=self.csml.createElement("Grid") 
    163 #                 #need to get no. of spatial dimensions (corresponds to axis in domainComplement) 
    164 #                 numSpDims=len(varSize) -1 
    165 #                 #numSpDims = len(var.shape) - 1 #assuming one dimension is non-spatial (time) 
    166 #                 Grid_element.setAttribute('srsName', 'urn:SomeProjection') 
    167 #                 Grid_element.setAttribute( 'srsDimension', str(numSpDims)) 
    168 #                 Grid_element.setAttribute('dimension' ,str(numSpDims)) 
    169 #                 gml_GridEnvelope_element=self.csml.createElement("gml:GridEnvelope") 
    170 #                 gml_limits_element=self.csml.createElement("gml:limits") 
    171 #                 gml_low_element=self.csml.createElement("gml:low") 
    172 #                 gml_high_element=self.csml.createElement("gml:high") 
    173 #                 lowLimits=DI.getLowLimits() 
    174 #                 highLimits=DI.getHighLimits() 
    175 #                 gml_low_element.appendChild(self.csml.createTextNode(lowLimits)) 
    176 #                 gml_high_element.appendChild(self.csml.createTextNode(highLimits)) 
    177 #                 gml_GridEnvelope_element.appendChild(gml_low_element) 
    178 #                 gml_GridEnvelope_element.appendChild(gml_high_element) 
    179 #                 gml_limits_element.appendChild(gml_GridEnvelope_element) 
    180 #                 Grid_element.appendChild(gml_limits_element) 
    181 #                 #add an axisName element for  each spatial dimension. 
    182 #                 for i in range (1, len(dimNames)): 
    183 #                     gml_axisName_element=self.csml.createElement("gml:axisName") 
    184 #                     gml_axisName_element.appendChild(self.csml.createTextNode("dim" + str(i))) 
    185 #                     Grid_element.appendChild(gml_axisName_element) 
    186 #                  
    187 #                 #Add ordinate element and sub elements: 
    188 #                 for i in range (1, len(dimNames)): 
    189 #                     ordinate_element=self.csml.createElement("ordinate") 
    190 #                     gridAxesSpanned_element=self.csml.createElement("gridAxesSpanned") 
    191 #                     gridAxesSpanned_element.appendChild(self.csml.createTextNode("dim" + str(i))) 
    192 #                     sequenceRule_element=self.csml.createElement("sequenceRule") 
    193 #                     sequenceRule_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.getSeqRule(len(dimNames)))) 
    194 #                     definesAxis_element=self.csml.createElement("definesAxis") 
    195 #                     dimName = dimNames[len(dimNames)-i] 
    196 #                     definesAxis_element.appendChild(self.csml.createTextNode(dimName)) 
    197 #                     axisValues_element=self.csml.createElement("axisValues") 
    198 #                     #look up file extract name in dictionary 
    199 #                     #(axisid stored in dictionary = current filename + variable name) 
    200 #                     axisid = repfilename + dimName 
    201 #                     axisValues = self.fileExtractDictionary[axisid] 
    202 #                     axisValues_element.appendChild(self.csml.createTextNode(axisValues)) 
    203 #                     ordinate_element.appendChild(gridAxesSpanned_element) 
    204 #                     ordinate_element.appendChild(sequenceRule_element) 
    205 #                     ordinate_element.appendChild(definesAxis_element) 
    206 #                     ordinate_element.appendChild(axisValues_element) 
    207 #                     Grid_element.appendChild(ordinate_element) 
    208 #                      
    209 #                 domainComplement_element.appendChild(Grid_element) 
    210 #                 GridSeriesDomain_element.appendChild(domainReference_element) 
    211 #                 GridSeriesDomain_element.appendChild(domainComplement_element) 
    212 #                 GridSeriesFeature_element.appendChild(GridSeriesDomain_element) 
    213 #                 GridSeriesFeature_element.appendChild(gml_rangeSet_element) 
    214 #                 GridSeriesFeature_element.appendChild(gml_coverageFunction_element) 
    215 #                 gml_featureMember_element.appendChild(GridSeriesFeature_element) 
    216 #                 self.gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
     145                grid.srsName='urn:EPSG:GeographicCRS:4326' 
     146                numSpDims=len(varSize) -1  
     147                grid.srsDimension=str(numSpDims) 
     148                grid.dimension=str(numSpDims) 
     149                ge =csmllibs.Parser.GridEnvelope(low=DI.getLowLimits(), high=DI.getHighLimits()) 
     150                grid.limits=ge 
     151 
    217152                 
     153                #add an axisName element(s) for  each spatial dimension. 
     154                # and an ordinate element 
     155                for i in range (1, len(dimNames)): 
     156                    #axisNames 
     157                    axes=[] 
     158                    axisname ='dim'+str(i) 
     159                    axes.append(axisname) 
     160                    grid.axisNames=axes 
     161                     
     162                    #ordinates 
     163                    grid.ordinates=[] 
     164                    for i in range (1, len(dimNames)): 
     165                        ord=csmllibs.Parser.GridOrdinateDescription() 
     166                        ord.gridAxesSpanned='dim' + str(i) 
     167                        ord.sequenceRule=csmllibs.csmlextra.getSeqRule(len(dimNames)) 
     168                        dimName=dimNames[len(dimNames)-i] 
     169                        ord.definesAxis=dimName 
     170                        #look up file extract name in dictionary 
     171                         #(axisid stored in dictionary = current filename + variable name) 
     172                        axisid=repfilename+dimName 
     173                        ord.axisValues=self.fileExtractDictionary[axisid] 
     174                         
     175                        grid.ordinates.append(ord) 
     176 
     177                gsDomain.domainComplement=grid 
    218178                self.fms.append(GridSeriesFeature_element) 
    219179            DI.closeFile() 
  • TI02-CSML/trunk/Scanner/csmllibs/csmlfileextracts.py

    r758 r771  
    1212     
    1313    def createFileExtracts(self): 
    14         #print "REPRESENTATIVE FILES:" 
    15         #print self.ffmap.getRepresentativeFiles() 
    16          
    17         #given a featurefilemap object, create file extracts from the "representativeFiles"      
    18         #used to store extract/filename/variable relationship 
    19         #referenced when creating features 
    20         self.fileExtractDictionary={} 
    21          
    22         fileid=0  #used to distinguish extract names for similar variables from different files 
    23         for repfile in self.ffmap.getRepresentativeFiles(): 
    24                 fileid=fileid+1 
    25                 filename=repfile.getRepresentativeFileName() 
    26                 print 'representative file:' 
    27                 #print repfile.getRepresentativeFileName() 
    28                 print 'feature type:' 
    29                 #print repfile.getFeatureType()  
    30                 DI = csmllibs.csmldataiface.DataInterface() 
    31                 DI = DI.getUnknownInterfaceType(filename) 
    32                 DI.openFile(filename) 
    33                 #creates fileextracts for each variable of each representative file 
    34                 self.extractType = DI.extractType 
    35                 self.extractPrefix = str(fileid)+'_'+DI.extractPrefix    
    36                 allDimNames=DI.getListOfAxes() 
    37                 numDomains=len(allDimNames) 
     14        #print "REPRESENTATIVE FILES:" 
     15        #print self.ffmap.getRepresentativeFiles() 
    3816         
     17        #given a featurefilemap object, create file extracts from the "representativeFiles"      
     18        #used to store extract/filename/variable relationship 
     19        #referenced when creating features 
     20        self.fileExtractDictionary={} 
     21     
     22        fileid=0  #used to distinguish extract names for similar variables from different files 
    3923        #adlist is an empty list object to hold CSML ArrayDescriptors eg. NetCDFExtract, GRIBExtract etc 
    4024        adlist=[] 
    41         for j in range (0, len(allDimNames)): 
    42                         #Extract element is one of NetCDFExtract, GRIBExtract, PPExtract 
    43             print self.extractType 
    44             print self.extractPrefix 
    45             if self.extractType=='NASAAmesExtract': 
    46                 arrayDescriptor=csmllibs.Parser.NASAAmesExtract() 
    47             if self.extractType=='NetCDFExtract': 
    48                 arrayDescriptor=csmllibs.Parser.NetCDFAmesExtract() 
    49             if self.extractType=='GRIBExtract': 
    50                 arrayDescriptor=csmllibs.Parser.GRIBAmesExtract() 
    51             if self.extractType=='PPExtract': 
    52                 arrayDescriptor=csmllibs.Parser.PPAmesExtract() 
     25        for repfile in self.ffmap.getRepresentativeFiles(): 
     26            fileid=fileid+1 
     27            filename=repfile.getRepresentativeFileName() 
     28            print 'representative file:' 
     29            #print repfile.getRepresentativeFileName() 
     30            print 'feature type:' 
     31            #print repfile.getFeatureType()      
     32            DI = csmllibs.csmldataiface.DataInterface() 
     33            DI = DI.getUnknownInterfaceType(filename) 
     34            DI.openFile(filename) 
     35            #creates fileextracts for each variable of each representative file 
     36            self.extractType = DI.extractType 
     37            self.extractPrefix = str(fileid)+'_'+DI.extractPrefix 
     38            allDimNames=DI.getListOfAxes() 
     39            numDomains=len(allDimNames) 
     40            for j in range (0, len(allDimNames)): 
     41                print self.extractType 
     42                print self.extractPrefix 
     43                if self.extractType=='NASAAmesExtract': 
     44                    arrayDescriptor=csmllibs.Parser.NASAAmesExtract() 
     45                if self.extractType=='NetCDFExtract': 
     46                    arrayDescriptor=csmllibs.Parser.NetCDFExtract() 
     47                if self.extractType=='GRIBExtract': 
     48                    arrayDescriptor=csmllibs.Parser.GRIBExtract() 
     49                if self.extractType=='PPExtract': 
     50                    arrayDescriptor=csmllibs.Parser.PPExtract() 
    5351                arrayDescriptor.id=str(self.extractPrefix+allDimNames[j]) 
    54  
    55             #SET variableName attribute of file extract 
    56             arrayDescriptor.variableName=str(allDimNames[j]) 
    57  
    58             #SET arraySize attribute of file extract 
    59             dimValue =DI.getSizeOfAxis(allDimNames[j]) 
    60             if dimValue == None: 
    61                 dimValue ='1'  #temporary to fix unlimited problem 
    62             arrayDescriptor.arraySize=str(dimValue) 
    63  
    64             #SET filename attribute of file extract 
    65             arrayDescriptor.fileName = filename 
    66                  
    67 #                       #keep record of extracts/filenames/variables in dictionary 
    68             idstr = filename + allDimNames[j] 
    69             self.fileExtractDictionary[idstr] = self.extractPrefix+allDimNames[j] 
    70             adlist.append(arrayDescriptor) 
    71         DI.closeFile()   
     52     
     53                #SET variableName attribute of file extract 
     54                arrayDescriptor.variableName=str(allDimNames[j]) 
     55     
     56                #SET arraySize attribute of file extract 
     57                dimValue =DI.getSizeOfAxis(allDimNames[j]) 
     58                if dimValue == None: 
     59                    dimValue ='1'  #temporary to fix unlimited problem 
     60                arrayDescriptor.arraySize=str(dimValue) 
     61     
     62                #SET filename attribute of file extract 
     63                arrayDescriptor.fileName = filename 
     64             
     65    #                   #keep record of extracts/filenames/variables in dictionary 
     66                idstr = filename + allDimNames[j] 
     67                self.fileExtractDictionary[idstr] = self.extractPrefix+allDimNames[j] 
     68                adlist.append(arrayDescriptor) 
     69            DI.closeFile()       
    7270        #Add all the file extracts to the dataset element 
    7371        setattr(self.dataset_element, 'arrayDescriptors', adlist) 
     72     
     73        #    sys.exit() 
     74             
     75     
    7476 
    75  
Note: See TracChangeset for help on using the changeset viewer.