Changeset 627


Ignore:
Timestamp:
16/02/06 11:43:38 (14 years ago)
Author:
domlowe
Message:

added csmlbuilder class to control feature build

Location:
TI02-CSML/trunk/Coapec
Files:
2 added
6 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/Coapec/csmllibs/__init__.py

    r51 r627  
    11#empty 
    22 
     3import csmlbuilder 
    34import csmldataiface 
    45import csmltime 
  • TI02-CSML/trunk/Coapec/csmllibs/csmlfeaturefilemap.py

    r51 r627  
    2727        def getRepresentativeFiles(self): 
    2828                return self.repFiles 
    29          
    30          
     29 
    3130                 
    3231class representativeFile: 
  • TI02-CSML/trunk/Coapec/csmllibs/csmlfeaturetypes.py

    r57 r627  
    99import csmllibs 
    1010 
    11 def createCSMLGridSeriesFeatures(csmldoc, dataset_element, gml_FeatureCollection_element,extractType, extractPrefix, ffmap,fileExtractDictionary, timedim): 
     11 
     12 
     13class featureBuilder: 
     14    def __init__(self, csmldoc, dataset_element, gml_FeatureCollection_element,extractType, extractPrefix, ffmap,fileExtractDictionary, timedim): 
     15        self.csml=csmldoc 
     16        self.ds_element=dataset_element 
     17        self.gml_FeatureCollection_element = gml_FeatureCollection_element 
     18        self.extractType = extractType 
     19        self.extractPrefix = extractPrefix 
     20        self.ffmap = ffmap 
     21        self.fileExtractDictionary = fileExtractDictionary 
     22        self.timedim = timedim 
     23        #at the moment, only one featuretype per CSML Dataset is supported. 
     24        #get the featuretype of the first representative file in the ffmap object 
     25        self.featuretype=  self.ffmap.getRepresentativeFiles()[0].getFeatureType() 
     26         
     27        print "FEATURETYPE: " + str(self.featuretype) 
     28        if self.featuretype == 'GridSeriesFeature': 
     29            self.createCSMLGridSeriesFeatures() 
     30        else:            #other feature typess... TODo 
     31            pass 
     32         
     33         
     34    def createCSMLGridSeriesFeatures(self): 
     35        #This function is for model data and assumes that the variables (features) are shared across identically structured files 
     36        #in the same directory. 
     37        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker), with a onetomany file map relationship.(not necessarily one to many) 
     38         
     39        representativeFiles=self.ffmap.getRepresentativeFiles() 
     40        for repfile in representativeFiles: 
     41            listOfFiles=[] 
     42            repfilename=repfile.getRepresentativeFileName() 
     43            listOfFiles.append(repfilename) 
     44            relfiles = repfile.getRelatedFiles() 
     45            for f in relfiles: 
     46                fname = f.getRelatedFileName() 
     47                listOfFiles.append(fname) 
     48                 
     49            #THIS IS THE REALLY SLOW FUNCTION CALL!!!!!######################### 
     50            OrderedFileTimeList = csmllibs.csmltime.getFileTimeList(listOfFiles,self.timedim) 
     51            #build strings to hold times/filenames for current gridseriesfeature 
     52            timeString ='' 
     53            filesinDir = '' 
     54            for j in range (0, len(OrderedFileTimeList)): 
     55                t= OrderedFileTimeList[j][0] 
     56                f = OrderedFileTimeList[j][1] 
     57                timeString = timeString + ' ' + str(t) 
     58                filesinDir = filesinDir + ' ' + f 
     59                #Open representative file and create feature members: 
     60            DI = csmllibs.csmldataiface.DataInterface() 
     61            DI=DI.getUnknownInterfaceType(repfilename) 
     62            DI.openFile(repfilename) 
     63            allVarNames=DI.getListofVariables() 
     64            numFeatures=len(allVarNames) 
     65            for i in range(0, numFeatures): 
     66                print allVarNames[i] 
     67                DI.setVariable(allVarNames[i]) 
     68                dimNames=DI.getVariableAxes() 
     69                if len(dimNames) <= 2: 
     70                    #it's an axis or bounds not a feature, try next variable 
     71                    continue 
     72                gml_featureMember_element=self.csml.createElement("gml:featureMember") 
     73                GridSeriesFeature_element=self.csml.createElement("GridSeriesFeature") 
     74                GridSeriesFeature_element.setAttribute('gml:id',allVarNames[i]) 
     75                gml_description_element = self.csml.createElement("gml:description") 
     76                #need to get the attribute called long_name (?? TODO - is this CF compliant??) 
     77                #use Ag's getbestname from nappy package? 
     78                try: 
     79                    desc=DI.getVariableAttribute('long_name') 
     80                    print desc 
     81                except AttributeError: 
     82                    desc = "missing name" 
     83                gml_description_element.appendChild(self.csml.createTextNode(str(desc))) 
     84                GridSeriesFeature_element.appendChild(gml_description_element) 
     85                #*********************************************************************** 
     86                #GridSeriesDomain: 
     87                #*********************************************************************** 
     88                GridSeriesDomain_element=self.csml.createElement("GridSeriesDomain") 
     89                #*********************************************************************** 
     90                # gml:coverageFunction element (and sub-element MappingRule) 
     91                #*********************************************************************** 
     92                gml_coverageFunction_element=self.csml.createElement("gml:coverageFunction") 
     93                MappingRule_element=self.csml.createElement("MappingRule") 
     94                MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames))) 
     95                gml_coverageFunction_element.appendChild(MappingRule_element) 
     96                #*********************************************************************** 
     97                # gml:rangeSet element (and sub-elements) 
     98                #*********************************************************************** 
     99                gml_rangeSet_element=self.csml.createElement("gml:rangeSet") 
     100                AggregatedArray_element=self.csml.createElement("AggregatedArray") 
     101                arraySize_element=self.csml.createElement("arraySize") 
     102                #arrSz = getArraySize(var) 
     103                arrSz = DI.getArraySizeOfVar() 
     104                arraySize_element.appendChild(self.csml.createTextNode(str(arrSz))) 
     105                uom_element=self.csml.createElement("uom") 
     106                try: 
     107                    #strUom = var.units 
     108                    strUom = DI.getVariableAttribute('units') 
     109                except AttributeError: 
     110                    #if units attribute doesn't exist: 
     111                    strUom ="dimensionless or units not determined" 
     112                uom_element.appendChild(self.csml.createTextNode(strUom)) 
     113                AggregatedArray_element.appendChild(uom_element) 
     114                aggType_element=self.csml.createElement("aggType") 
     115                aggType_element.appendChild(self.csml.createTextNode('new')) 
     116                aggIndex_element=self.csml.createElement("aggIndex") 
     117                aggIndex_element.appendChild(self.csml.createTextNode('1')) 
     118                AggregatedArray_element.appendChild(arraySize_element) 
     119                AggregatedArray_element.appendChild(aggType_element) 
     120                AggregatedArray_element.appendChild(aggIndex_element) 
     121                component_element=self.csml.createElement("component") 
     122                #FileExtract element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType) 
     123                FileExtract_element=self.csml.createElement(self.extractType) 
     124                arraySize_element=self.csml.createElement("arraySize") 
     125                #varSize =var.shape 
     126                varSize=DI.getShapeOfVar() 
     127                arraySize_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.cleanString1(str(varSize)))) 
     128                FileExtract_element.appendChild(arraySize_element) 
     129                fileName_element=self.csml.createElement("fileName") 
     130                FileExtract_element.appendChild(fileName_element) 
     131                #This is the problem: too many filenames >>templating/wildcard needed 
     132                #fileName_element.appendChild(csmldoc.createTextNode(cleanString2(str(allFileNames)))) 
     133                #fileName_element.appendChild(csmldoc.createTextNode("WILDCARDNEEDED")) 
     134                #fileName_element.appendChild(csmldoc.createTextNode(os.path.dirname(templateFileList[k]) + '/*')) 
     135                fileName_element.appendChild(self.csml.createTextNode(filesinDir)) 
     136                variableName_element=self.csml.createElement("variableName") 
     137                variableName_element.appendChild(self.csml.createTextNode(allVarNames[i])) 
     138                FileExtract_element.appendChild(variableName_element) 
     139                component_element.appendChild(FileExtract_element) 
     140                AggregatedArray_element.appendChild(component_element) 
     141                gml_rangeSet_element.appendChild(AggregatedArray_element) 
     142                ############################################## 
     143                #*********************************************************************** 
     144                # domainReference element (and sub-elements)             
     145                #*********************************************************************** 
     146                domainReference_element=self.csml.createElement("domainReference") 
     147                gml_timePositionList_element = self.csml.createElement("gml:TimePositionList") 
     148                gml_timePositionList_element.appendChild(self.csml.createTextNode(timeString)) 
     149                domainReference_element.appendChild(gml_timePositionList_element) 
     150                #*********************************************************************** 
     151                #*********************************************************************** 
     152                # domainComplement element (and sub-elements) 
     153                #*********************************************************************** 
     154                domainComplement_element=self.csml.createElement("domainComplement") 
     155                Grid_element=self.csml.createElement("Grid") 
     156                #need to get no. of spatial dimensions (corresponds to axis in domainComplement) 
     157                numSpDims=len(varSize) -1 
     158                #numSpDims = len(var.shape) - 1 #assuming one dimension is non-spatial (time) 
     159                Grid_element.setAttribute('srsName', 'urn:SomeProjection') 
     160                Grid_element.setAttribute( 'srsDimension', str(numSpDims)) 
     161                Grid_element.setAttribute('dimension' ,str(numSpDims)) 
     162                gml_GridEnvelope_element=self.csml.createElement("gml:GridEnvelope") 
     163                gml_limits_element=self.csml.createElement("gml:limits") 
     164                gml_low_element=self.csml.createElement("gml:low") 
     165                gml_high_element=self.csml.createElement("gml:high") 
     166                lowLimits=DI.getLowLimits() 
     167                highLimits=DI.getHighLimits() 
     168                gml_low_element.appendChild(self.csml.createTextNode(lowLimits)) 
     169                gml_high_element.appendChild(self.csml.createTextNode(highLimits)) 
     170                gml_GridEnvelope_element.appendChild(gml_low_element) 
     171                gml_GridEnvelope_element.appendChild(gml_high_element) 
     172                gml_limits_element.appendChild(gml_GridEnvelope_element) 
     173                Grid_element.appendChild(gml_limits_element) 
     174                #add an axisName element for  each spatial dimension. 
     175                for i in range (1, len(dimNames)): 
     176                    gml_axisName_element=self.csml.createElement("gml:axisName") 
     177                    gml_axisName_element.appendChild(self.csml.createTextNode("dim" + str(i))) 
     178                    Grid_element.appendChild(gml_axisName_element) 
     179                 
     180                #Add ordinate element and sub elements: 
     181                for i in range (1, len(dimNames)): 
     182                    ordinate_element=self.csml.createElement("ordinate") 
     183                    gridAxesSpanned_element=self.csml.createElement("gridAxesSpanned") 
     184                    gridAxesSpanned_element.appendChild(self.csml.createTextNode("dim" + str(i))) 
     185                    sequenceRule_element=self.csml.createElement("sequenceRule") 
     186                    sequenceRule_element.appendChild(self.csml.createTextNode(csmllibs.csmlextra.getSeqRule(len(dimNames)))) 
     187                    definesAxis_element=self.csml.createElement("definesAxis") 
     188                    dimName = dimNames[len(dimNames)-i] 
     189                    definesAxis_element.appendChild(self.csml.createTextNode(dimName)) 
     190                    axisValues_element=self.csml.createElement("axisValues") 
     191                    #look up file extract name in dictionary 
     192                    #(axisid stored in dictionary = current filename + variable name) 
     193                    axisid = repfilename + dimName 
     194                    axisValues = self.fileExtractDictionary[axisid] 
     195                    axisValues_element.appendChild(self.csml.createTextNode(axisValues)) 
     196                    ordinate_element.appendChild(gridAxesSpanned_element) 
     197                    ordinate_element.appendChild(sequenceRule_element) 
     198                    ordinate_element.appendChild(definesAxis_element) 
     199                    ordinate_element.appendChild(axisValues_element) 
     200                    Grid_element.appendChild(ordinate_element) 
     201                     
     202                domainComplement_element.appendChild(Grid_element) 
     203                #***********************************************************************         GridSeriesDomain_element.appendChild(domainReference_element) 
     204                GridSeriesDomain_element.appendChild(domainComplement_element) 
     205                GridSeriesDomain_element.appendChild(gml_rangeSet_element) 
     206                GridSeriesDomain_element.appendChild(gml_coverageFunction_element) 
     207                GridSeriesFeature_element.appendChild(GridSeriesDomain_element) 
     208                gml_featureMember_element.appendChild(GridSeriesFeature_element) 
     209                self.gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
     210            DI.closeFile() 
     211                         
     212 
     213######################################################################### 
     214 
     215 
     216    def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim): 
     217            representativeFiles=ffmap.getRepresentativeFiles() 
     218            listOfFiles=[] 
     219            for repfile in representativeFiles: 
     220                    repfilename=repfile.getRepresentativeFileName() 
     221                    listOfFiles.append(repfilename) 
     222                    relfiles = repfile.getRelatedFiles() 
     223                    for f in relfiles: 
     224                            #hopefully there are no related files at the moment! 
     225                            fname = f.getRelatedFileName() 
     226                            listOfFiles.append(fname) 
     227                    print listOfFiles 
     228                     
     229            for file in listOfFiles: 
     230                    DI = csmllibs.csmldataiface.DataInterface() 
     231                    DI=DI.getUnknownInterfaceType(file) 
     232                    print'opening file' 
     233                    DI.openFile(file) 
     234                    print 'getting variables' 
     235                    allVarNames=DI.getListofVariables() 
     236                    print 'getting feature count' 
     237                    numFeatures=len(allVarNames)         
     238                     
     239                    print "FEATURES" 
     240                    print "***********" 
     241                    for i in range (0, len(allVarNames)): 
     242                            print allVarNames[i] 
     243                             
     244                    for i in range (0, numFeatures): 
     245                            gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
     246                            ProfileFeature_element=csmldoc.createElement("ProfileFeature") 
     247                            ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i])) 
     248                            gml_description_element = csmldoc.createElement("gml:description") 
     249                            gml_featureMember_element.appendChild(ProfileFeature_element) 
     250                            #*********************************************************************** 
     251                            #PointSeriesDomain: 
     252                            #*********************************************************************** 
     253                            ProfileDomain_element=csmldoc.createElement("ProfileDomain") 
     254                             
     255                             
     256                            #*********************************************************************** 
     257                            # domainReference element (and sub-elements)                 
     258                            #*********************************************************************** 
     259                            domainReference_element=csmldoc.createElement("domainReference") 
     260                            #orientedPosition_element=csmldoc.createElement("OrientedPosition") 
     261                            #locations_element=csmldoc.createElement("locations") 
     262                            #times_element=csmldoc.createElement("times") 
     263                            #trajectory_element.appendChild(locations_element) 
     264                            #trajectory_element.appendChild(times_element) 
     265                            #domainReference_element.appendChild(orientedPosition_element) 
     266                             
     267                            #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList") 
     268                            #gml_timePositionList_element.appendChild(csmldoc.createTextNode(timeString)) 
     269                            #domainReference_element.appendChild(gml_timePositionList_element) 
     270                            ProfileDomain_element.appendChild(domainReference_element) 
     271                            #*********************************************************************** 
     272                            domainComplement_element=csmldoc.createElement("domainComplement") 
     273                            ProfileDomain_element.appendChild(domainComplement_element) 
     274                             
     275                            #*********************************************************************** 
     276                            # gml:rangeSet_element 
     277                            #*********************************************************************** 
     278                             
     279                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet")   
     280                             
     281                            #*********************************************************************** 
     282                            # gml:coverageFunction element (and sub-element MappingRule)                 
     283                            #*********************************************************************** 
     284                            gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction") 
     285                            MappingRule_element=csmldoc.createElement("MappingRule") 
     286                            #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames))) 
     287                            MappingRule_element.setAttribute('scanOrder','tba') 
     288                            gml_coverageFunction_element.appendChild(MappingRule_element) 
     289                             
     290                             
     291                            gml_featureMember_element.appendChild(ProfileDomain_element) 
     292                            gml_featureMember_element.appendChild(gml_rangeSet_element) 
     293                            gml_featureMember_element.appendChild(gml_coverageFunction_element) 
     294                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)         
     295                             
     296            return csmldoc, dataset_element, gml_FeatureCollection_element 
     297                             
     298    #def createCSMLPointFeatures(csmldoc, dataset_element, #gml_FeatureCollection_element,filename, timedim): 
     299            #csmldoc  = csml instance doc 
     300            #dataset_element = toplevel dataset xml element (and all child elements) 
     301            #gml_FeatureCollection_element= FeatureCollection element and all child elements (all features) 
     302            #filename = full file/path of a single file 
     303            #timedim = name of time variable 
     304             
     305    #   DI = csmllibs.csmldataiface.DataInterface() 
     306    #   DI=DI.getUnknownInterfaceType(filename) 
     307    #   DI.openFile(filename) 
     308    #   allVarNames=DI.getListofVariables() 
     309    #   numFeatures=len(allVarNames)     
     310    #   for i in range(0, numFeatures): 
     311    #           gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
     312    #           PointFeature_element=csmldoc.createElement("PointFeature") 
     313    #           PointFeature_element.setAttribute('gml:id',allVarNames[i]) 
     314    #           gml_description_element = csmldoc.createElement("gml:description") 
     315                    #need to get the attribute called long_name (?? TODO - is this CF compliant??) 
     316                    #use Ag's getbestname from nappy package? 
     317    #           try: 
     318    #                   desc=DI.getVariableAttribute('long_name') 
     319    #                   print desc 
     320    #                   except AttributeError: 
     321    #                   desc = "missing name" 
     322    #                   gml_description_element.appendChild(csmldoc.createTextNode(str(desc)))   
     323    #                   PointFeature_element.appendChild(gml_description_element) 
     324                     
     325    #           gml_featureMember_element.appendChild(PointFeature_element) 
     326    #           gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
     327                             
     328    #   dataset_element.appendChild(gml_FeatureCollection_element) 
     329                                             
     330    #   return csmldoc, dataset_element, gml_FeatureCollection_element 
     331             
     332     
     333    def createCSMLPointSeriesFeatures(csmldoc, dataset_element, gml_FeatureCollection_element, ffmap, timedim): 
     334            representativeFiles=ffmap.getRepresentativeFiles() 
     335            listOfFiles=[] 
     336            for repfile in representativeFiles: 
     337                    repfilename=repfile.getRepresentativeFileName() 
     338                    listOfFiles.append(repfilename) 
     339                    relfiles = repfile.getRelatedFiles() 
     340                    for f in relfiles: 
     341                            #hopefully there are no related files at the moment! 
     342                            fname = f.getRelatedFileName() 
     343                            listOfFiles.append(fname) 
     344                     
     345            for file in listOfFiles: 
     346                    DI = csmllibs.csmldataiface.DataInterface() 
     347                    DI=DI.getUnknownInterfaceType(file) 
     348                    DI.openFile(file) 
     349                    allVarNames=DI.getListofVariables() 
     350                    numFeatures=len(allVarNames)         
     351                    try: 
     352                            DI.setAxis(timedim) 
     353                            times=DI.getDataForAxis() 
     354                    except:                      
     355                            times = DI.getTimes() 
     356                            #times = ['time axis not determined'] 
     357                     
     358                                     
     359                    print "FEATURES" 
     360                    print "***********" 
     361                    for i in range (0, len(allVarNames)): 
     362                            print allVarNames[i] 
     363                                             
     364                    print "numFeatures" + str(numFeatures) 
     365                    for i in range (0, numFeatures): 
     366                            gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
     367                            PointSeriesFeature_element=csmldoc.createElement("PointSeriesFeature") 
     368                            PointSeriesFeature_element.setAttribute('gml:id',str(allVarNames[i])) 
     369                            gml_description_element = csmldoc.createElement("gml:description") 
     370                            gml_featureMember_element.appendChild(PointSeriesFeature_element) 
     371                            #*********************************************************************** 
     372                            #PointSeriesDomain: 
     373                            #*********************************************************************** 
     374                            PointSeriesDomain_element=csmldoc.createElement("PointSeriesDomain") 
     375                             
     376                             
     377                            #*********************************************************************** 
     378                            # domainReference element (and sub-elements)                 
     379                            #*********************************************************************** 
     380                            domainReference_element=csmldoc.createElement("domainReference") 
     381                            trajectory_element=csmldoc.createElement("Trajectory") 
     382                            locations_element=csmldoc.createElement("locations") 
     383                            times_element=csmldoc.createElement("times") 
     384                            times_element.appendChild(csmldoc.createTextNode(str(times)[1:-1]))   
     385                            trajectory_element.appendChild(locations_element) 
     386                            trajectory_element.appendChild(times_element) 
     387                            domainReference_element.appendChild(trajectory_element) 
     388                            PointSeriesDomain_element.appendChild(domainReference_element) 
     389                             
     390                            #*********************************************************************** 
     391                            #domainComplement_element=csmldoc.createElement("domainComplement") 
     392                            #PointSeriesDomain_element.appendChild(domainComplement_element) 
     393                             
     394                            #*********************************************************************** 
     395                            # gml:rangeSet_element 
     396                            #*********************************************************************** 
     397                            DI.setVariable(allVarNames[i]) 
     398                             
     399                            #TO DO: 
     400                            try: 
     401                                    #strUom = var.units 
     402                                    strUom = DI.getVariableAttribute('units') 
     403                            except AttributeError: 
     404                                    #if units attribute doesn't exist: 
     405                                    strUom ="dimensionless or units not determined" 
     406                             
     407                            try:                         
     408                                    measuredvalues = str(DI.getDataForVar()) 
     409                            except: 
     410                                    measuredvalues = ' could not get values ' 
     411                             
     412                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet")   
     413                            gml_QuantityList_element=csmldoc.createElement("gml:QuantityList") 
     414                            gml_QuantityList_element.setAttribute('uom',strUom) 
     415                            gml_QuantityList_element.appendChild(csmldoc.createTextNode(str(measuredvalues)[1:-1])) 
     416                            gml_rangeSet_element.appendChild(gml_QuantityList_element) 
     417                             
     418                            #*********************************************************************** 
     419                            # gml:coverageFunction element (and sub-element MappingRule)                 
     420                            #*********************************************************************** 
     421                            parameter_element=csmldoc.createElement("parameter") 
     422                                             
     423                            gml_featureMember_element.appendChild(PointSeriesDomain_element) 
     424                            gml_featureMember_element.appendChild(gml_rangeSet_element) 
     425                            gml_featureMember_element.appendChild(parameter_element) 
     426                            gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
     427                             
     428            return csmldoc, dataset_element, gml_FeatureCollection_element 
     429             
     430 
    12431         
    13         #This function is for model data and assumes that the variables (features) are shared across identically structured files 
    14         #in the same directory. 
     432 
     433 
    15434         
    16         #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker), with a onetomany file map relationship. 
    17                  
    18         #check:I think templateFileList has been superceded by fileExtractDictionary - 07/12/05. 
    19  
    20          
    21         representativeFiles=ffmap.getRepresentativeFiles() 
    22         for repfile in representativeFiles: 
    23                 listOfFiles=[] 
    24                 repfilename=repfile.getRepresentativeFileName() 
    25                 listOfFiles.append(repfilename) 
    26                 relfiles = repfile.getRelatedFiles() 
    27                 for f in relfiles: 
    28                         fname = f.getRelatedFileName() 
    29                         listOfFiles.append(fname) 
    30  
    31          
    32                 #THIS IS THE REALLY SLOW FUNCTION CALL!!!!!######################### 
    33                 OrderedFileTimeList = csmllibs.csmltime.getFileTimeList(listOfFiles,timedim) 
    34                 #build strings to hold times/filenames for current gridseriesfeature 
    35                 timeString ='' 
    36                 filesinDir = '' 
    37                 for j in range (0, len(OrderedFileTimeList)): 
    38                         t= OrderedFileTimeList[j][0] 
    39                         f = OrderedFileTimeList[j][1] 
    40                         timeString = timeString + ' ' + str(t) 
    41                         filesinDir = filesinDir + ' ' + f 
    42                          
    43                 #Open representative file and create feature members: 
    44                  
    45                 DI = csmllibs.csmldataiface.DataInterface() 
    46                 DI=DI.getUnknownInterfaceType(repfilename) 
    47                 DI.openFile(repfilename) 
    48                                                  
    49                 allVarNames=DI.getListofVariables() 
    50                 numFeatures=len(allVarNames)     
    51  
    52                 for i in range(0, numFeatures): 
    53                         print allVarNames[i] 
    54                         DI.setVariable(allVarNames[i]) 
    55                         dimNames=DI.getVariableAxes() 
    56                                                  
    57                         if len(dimNames) <= 2: 
    58                                 #it's an axis or bounds not a feature, try next variable 
    59                                 continue 
    60                         gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
    61                         GridSeriesFeature_element=csmldoc.createElement("GridSeriesFeature") 
    62                         GridSeriesFeature_element.setAttribute('gml:id',allVarNames[i]) 
    63                         gml_description_element = csmldoc.createElement("gml:description") 
    64                         #need to get the attribute called long_name (?? TODO - is this CF compliant??) 
    65                         #use Ag's getbestname from nappy package? 
    66                         try: 
    67                                 desc=DI.getVariableAttribute('long_name') 
    68                                 print desc 
    69                         except AttributeError: 
    70                                 desc = "missing name" 
    71                         gml_description_element.appendChild(csmldoc.createTextNode(str(desc)))   
    72                         GridSeriesFeature_element.appendChild(gml_description_element) 
    73                                  
    74                         #*********************************************************************** 
    75                         #GridSeriesDomain: 
    76                         #*********************************************************************** 
    77                         GridSeriesDomain_element=csmldoc.createElement("GridSeriesDomain") 
    78                          
    79                         #*********************************************************************** 
    80                         # gml:coverageFunction element (and sub-element MappingRule)             
    81                         #*********************************************************************** 
    82                         gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction") 
    83                         MappingRule_element=csmldoc.createElement("MappingRule") 
    84                         MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames))) 
    85                         gml_coverageFunction_element.appendChild(MappingRule_element) 
    86                          
    87                         #*********************************************************************** 
    88                         # gml:rangeSet element (and sub-elements)                
    89                         #*********************************************************************** 
    90                         gml_rangeSet_element=csmldoc.createElement("gml:rangeSet")       
    91                         AggregatedArray_element=csmldoc.createElement("AggregatedArray") 
    92                         arraySize_element=csmldoc.createElement("arraySize") 
    93                         #arrSz = getArraySize(var)               
    94                         arrSz = DI.getArraySizeOfVar() 
    95                         arraySize_element.appendChild(csmldoc.createTextNode(str(arrSz))) 
    96                         uom_element=csmldoc.createElement("uom") 
    97                         try: 
    98                                 #strUom = var.units 
    99                                 strUom = DI.getVariableAttribute('units') 
    100                         except AttributeError: 
    101                                 #if units attribute doesn't exist: 
    102                                 strUom ="dimensionless or units not determined" 
    103                          
    104                         uom_element.appendChild(csmldoc.createTextNode(strUom)) 
    105                         AggregatedArray_element.appendChild(uom_element) 
    106                                  
    107                         aggType_element=csmldoc.createElement("aggType") 
    108                         aggType_element.appendChild(csmldoc.createTextNode('new')) 
    109                         aggIndex_element=csmldoc.createElement("aggIndex") 
    110                         aggIndex_element.appendChild(csmldoc.createTextNode('1')) 
    111                          
    112                         AggregatedArray_element.appendChild(arraySize_element) 
    113                         AggregatedArray_element.appendChild(aggType_element) 
    114                         AggregatedArray_element.appendChild(aggIndex_element) 
    115                  
    116                          
    117                         component_element=csmldoc.createElement("component")                             
    118                         #FileExtract element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType) 
    119                         FileExtract_element=csmldoc.createElement(extractType) 
    120                         arraySize_element=csmldoc.createElement("arraySize") 
    121                         #varSize =var.shape 
    122                         varSize=DI.getShapeOfVar() 
    123                         arraySize_element.appendChild(csmldoc.createTextNode(csmllibs.csmlextra.cleanString1(str(varSize)))) 
    124                         FileExtract_element.appendChild(arraySize_element) 
    125                          
    126                                          
    127                         fileName_element=csmldoc.createElement("fileName") 
    128                         FileExtract_element.appendChild(fileName_element) 
    129                         #This is the problem: too many filenames >>templating/wildcard needed 
    130                         #fileName_element.appendChild(csmldoc.createTextNode(cleanString2(str(allFileNames)))) 
    131                         #fileName_element.appendChild(csmldoc.createTextNode("WILDCARDNEEDED")) 
    132                         #fileName_element.appendChild(csmldoc.createTextNode(os.path.dirname(templateFileList[k]) + '/*')) 
    133                         fileName_element.appendChild(csmldoc.createTextNode(filesinDir)) 
    134                                                                                          
    135                         variableName_element=csmldoc.createElement("variableName") 
    136                         variableName_element.appendChild(csmldoc.createTextNode(allVarNames[i])) 
    137                         FileExtract_element.appendChild(variableName_element) 
    138                          
    139                          
    140                         component_element.appendChild(FileExtract_element) 
    141                         AggregatedArray_element.appendChild(component_element) 
    142                         gml_rangeSet_element.appendChild(AggregatedArray_element)                
    143                         ##############################################                   
    144                          
    145                          
    146                         #*********************************************************************** 
    147                         # domainReference element (and sub-elements)             
    148                         #*********************************************************************** 
    149                         domainReference_element=csmldoc.createElement("domainReference") 
    150                         gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList") 
    151                         gml_timePositionList_element.appendChild(csmldoc.createTextNode(timeString)) 
    152                         domainReference_element.appendChild(gml_timePositionList_element) 
    153                         #*********************************************************************** 
    154                          
    155                         #*********************************************************************** 
    156                         # domainComplement element (and sub-elements)            
    157                         #***********************************************************************                 
    158                         domainComplement_element=csmldoc.createElement("domainComplement") 
    159                         Grid_element=csmldoc.createElement("Grid") 
    160                         #need to get no. of spatial dimensions (corresponds to axis in domainComplement) 
    161                         numSpDims=len(varSize) -1 
    162                         #numSpDims = len(var.shape) - 1 #assuming one dimension is non-spatial (time) 
    163                         Grid_element.setAttribute('srsName', 'urn:SomeProjection') 
    164                         Grid_element.setAttribute( 'srsDimension', str(numSpDims)) 
    165                         Grid_element.setAttribute('dimension' ,str(numSpDims)) 
    166                         gml_GridEnvelope_element=csmldoc.createElement("gml:GridEnvelope") 
    167                         gml_limits_element=csmldoc.createElement("gml:limits") 
    168                         gml_low_element=csmldoc.createElement("gml:low") 
    169                         gml_high_element=csmldoc.createElement("gml:high") 
    170                          
    171                          
    172                         lowLimits=DI.getLowLimits() 
    173                         highLimits=DI.getHighLimits() 
    174                         gml_low_element.appendChild(csmldoc.createTextNode(lowLimits))           
    175                         gml_high_element.appendChild(csmldoc.createTextNode(highLimits))                 
    176                         gml_GridEnvelope_element.appendChild(gml_low_element) 
    177                         gml_GridEnvelope_element.appendChild(gml_high_element) 
    178                         gml_limits_element.appendChild(gml_GridEnvelope_element) 
    179                         Grid_element.appendChild(gml_limits_element) 
    180                          
    181                         #add an axisName element for  each spatial dimension. 
    182                         for i in range (1, len(dimNames)): 
    183                                 gml_axisName_element=csmldoc.createElement("gml:axisName") 
    184                                 gml_axisName_element.appendChild(csmldoc.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=csmldoc.createElement("ordinate") 
    190                                 gridAxesSpanned_element=csmldoc.createElement("gridAxesSpanned") 
    191                                 gridAxesSpanned_element.appendChild(csmldoc.createTextNode("dim" + str(i))) 
    192                                 sequenceRule_element=csmldoc.createElement("sequenceRule") 
    193                                 sequenceRule_element.appendChild(csmldoc.createTextNode(csmllibs.csmlextra.getSeqRule(len(dimNames)))) 
    194                                 definesAxis_element=csmldoc.createElement("definesAxis") 
    195                                 dimName = dimNames[len(dimNames)-i] 
    196                                 definesAxis_element.appendChild(csmldoc.createTextNode(dimName)) 
    197                                 axisValues_element=csmldoc.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 = fileExtractDictionary[axisid] 
    202                                 axisValues_element.appendChild(csmldoc.createTextNode(axisValues)) 
    203                                  
    204                                  
    205                                 ordinate_element.appendChild(gridAxesSpanned_element) 
    206                                 ordinate_element.appendChild(sequenceRule_element) 
    207                                 ordinate_element.appendChild(definesAxis_element) 
    208                                 ordinate_element.appendChild(axisValues_element) 
    209                                 Grid_element.appendChild(ordinate_element) 
    210                                                          
    211                         domainComplement_element.appendChild(Grid_element) 
    212                                          
    213                         #*********************************************************************** 
    214                                          
    215                         GridSeriesDomain_element.appendChild(domainReference_element) 
    216                         GridSeriesDomain_element.appendChild(domainComplement_element) 
    217                         GridSeriesDomain_element.appendChild(gml_rangeSet_element) 
    218                         GridSeriesDomain_element.appendChild(gml_coverageFunction_element) 
    219                         GridSeriesFeature_element.appendChild(GridSeriesDomain_element) 
    220                          
    221                         gml_featureMember_element.appendChild(GridSeriesFeature_element) 
    222                         gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
    223                         #dataset_element.appendChild(gml_FeatureCollection_element) 
    224                          
    225                         #close open file 
    226                          
    227                 DI.closeFile() 
    228          
    229         #return  csml and dataset object 
    230         return csmldoc, dataset_element, gml_FeatureCollection_element   
    231                          
    232  
    233 ######################################################################### 
    234  
    235  
    236 def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim): 
    237         representativeFiles=ffmap.getRepresentativeFiles() 
    238         listOfFiles=[] 
    239         for repfile in representativeFiles: 
    240                 repfilename=repfile.getRepresentativeFileName() 
    241                 listOfFiles.append(repfilename) 
    242                 relfiles = repfile.getRelatedFiles() 
    243                 for f in relfiles: 
    244                         #hopefully there are no related files at the moment! 
    245                         fname = f.getRelatedFileName() 
    246                         listOfFiles.append(fname) 
    247                 print listOfFiles 
    248                  
    249         for file in listOfFiles: 
    250                 DI = csmllibs.csmldataiface.DataInterface() 
    251                 DI=DI.getUnknownInterfaceType(file) 
    252                 print'opening file' 
    253                 DI.openFile(file) 
    254                 print 'getting variables' 
    255                 allVarNames=DI.getListofVariables() 
    256                 print 'getting feature count' 
    257                 numFeatures=len(allVarNames)     
    258                  
    259                 print "FEATURES" 
    260                 print "***********" 
    261                 for i in range (0, len(allVarNames)): 
    262                         print allVarNames[i] 
    263                          
    264                 for i in range (0, numFeatures): 
    265                         gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
    266                         ProfileFeature_element=csmldoc.createElement("ProfileFeature") 
    267                         ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i])) 
    268                         gml_description_element = csmldoc.createElement("gml:description") 
    269                         gml_featureMember_element.appendChild(ProfileFeature_element) 
    270                         #*********************************************************************** 
    271                         #PointSeriesDomain: 
    272                         #*********************************************************************** 
    273                         ProfileDomain_element=csmldoc.createElement("ProfileDomain") 
    274                          
    275                          
    276                         #*********************************************************************** 
    277                         # domainReference element (and sub-elements)             
    278                         #*********************************************************************** 
    279                         domainReference_element=csmldoc.createElement("domainReference") 
    280                         #orientedPosition_element=csmldoc.createElement("OrientedPosition") 
    281                         #locations_element=csmldoc.createElement("locations") 
    282                         #times_element=csmldoc.createElement("times") 
    283                         #trajectory_element.appendChild(locations_element) 
    284                         #trajectory_element.appendChild(times_element) 
    285                         #domainReference_element.appendChild(orientedPosition_element) 
    286                          
    287                         #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList") 
    288                         #gml_timePositionList_element.appendChild(csmldoc.createTextNode(timeString)) 
    289                         #domainReference_element.appendChild(gml_timePositionList_element) 
    290                         ProfileDomain_element.appendChild(domainReference_element) 
    291                         #*********************************************************************** 
    292                         domainComplement_element=csmldoc.createElement("domainComplement") 
    293                         ProfileDomain_element.appendChild(domainComplement_element) 
    294                          
    295                         #*********************************************************************** 
    296                         # gml:rangeSet_element 
    297                         #*********************************************************************** 
    298                          
    299                         gml_rangeSet_element=csmldoc.createElement("gml:rangeSet")       
    300                          
    301                         #*********************************************************************** 
    302                         # gml:coverageFunction element (and sub-element MappingRule)             
    303                         #*********************************************************************** 
    304                         gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction") 
    305                         MappingRule_element=csmldoc.createElement("MappingRule") 
    306                         #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames))) 
    307                         MappingRule_element.setAttribute('scanOrder','tba') 
    308                         gml_coverageFunction_element.appendChild(MappingRule_element) 
    309                          
    310                          
    311                         gml_featureMember_element.appendChild(ProfileDomain_element) 
    312                         gml_featureMember_element.appendChild(gml_rangeSet_element) 
    313                         gml_featureMember_element.appendChild(gml_coverageFunction_element) 
    314                         gml_FeatureCollection_element.appendChild(gml_featureMember_element)     
    315                          
    316         return csmldoc, dataset_element, gml_FeatureCollection_element 
    317                          
    318 #def createCSMLPointFeatures(csmldoc, dataset_element, #gml_FeatureCollection_element,filename, timedim): 
    319         #csmldoc  = csml instance doc 
    320         #dataset_element = toplevel dataset xml element (and all child elements) 
    321         #gml_FeatureCollection_element= FeatureCollection element and all child elements (all features) 
    322         #filename = full file/path of a single file 
    323         #timedim = name of time variable 
    324          
    325 #       DI = csmllibs.csmldataiface.DataInterface() 
    326 #       DI=DI.getUnknownInterfaceType(filename) 
    327 #       DI.openFile(filename) 
    328 #       allVarNames=DI.getListofVariables() 
    329 #       numFeatures=len(allVarNames)     
    330 #       for i in range(0, numFeatures): 
    331 #               gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
    332 #               PointFeature_element=csmldoc.createElement("PointFeature") 
    333 #               PointFeature_element.setAttribute('gml:id',allVarNames[i]) 
    334 #               gml_description_element = csmldoc.createElement("gml:description") 
    335                 #need to get the attribute called long_name (?? TODO - is this CF compliant??) 
    336                 #use Ag's getbestname from nappy package? 
    337 #               try: 
    338 #                       desc=DI.getVariableAttribute('long_name') 
    339 #                       print desc 
    340 #                       except AttributeError: 
    341 #                       desc = "missing name" 
    342 #                       gml_description_element.appendChild(csmldoc.createTextNode(str(desc)))   
    343 #                       PointFeature_element.appendChild(gml_description_element) 
    344                  
    345 #               gml_featureMember_element.appendChild(PointFeature_element) 
    346 #               gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
    347                          
    348 #       dataset_element.appendChild(gml_FeatureCollection_element) 
    349                                          
    350 #       return csmldoc, dataset_element, gml_FeatureCollection_element 
    351          
    352  
    353 def createCSMLPointSeriesFeatures(csmldoc, dataset_element, gml_FeatureCollection_element, ffmap, timedim): 
    354         representativeFiles=ffmap.getRepresentativeFiles() 
    355         listOfFiles=[] 
    356         for repfile in representativeFiles: 
    357                 repfilename=repfile.getRepresentativeFileName() 
    358                 listOfFiles.append(repfilename) 
    359                 relfiles = repfile.getRelatedFiles() 
    360                 for f in relfiles: 
    361                         #hopefully there are no related files at the moment! 
    362                         fname = f.getRelatedFileName() 
    363                         listOfFiles.append(fname) 
    364                  
    365         for file in listOfFiles: 
    366                 DI = csmllibs.csmldataiface.DataInterface() 
    367                 DI=DI.getUnknownInterfaceType(file) 
    368                 DI.openFile(file) 
    369                 allVarNames=DI.getListofVariables() 
    370                 numFeatures=len(allVarNames)     
    371                 try: 
    372                         DI.setAxis(timedim) 
    373                         times=DI.getDataForAxis() 
    374                 except:                  
    375                         times = DI.getTimes() 
    376                         #times = ['time axis not determined'] 
    377                  
    378                                  
    379                 print "FEATURES" 
    380                 print "***********" 
    381                 for i in range (0, len(allVarNames)): 
    382                         print allVarNames[i] 
    383                                          
    384                 print "numFeatures" + str(numFeatures) 
    385                 for i in range (0, numFeatures): 
    386                         gml_featureMember_element=csmldoc.createElement("gml:featureMember") 
    387                         PointSeriesFeature_element=csmldoc.createElement("PointSeriesFeature") 
    388                         PointSeriesFeature_element.setAttribute('gml:id',str(allVarNames[i])) 
    389                         gml_description_element = csmldoc.createElement("gml:description") 
    390                         gml_featureMember_element.appendChild(PointSeriesFeature_element) 
    391                         #*********************************************************************** 
    392                         #PointSeriesDomain: 
    393                         #*********************************************************************** 
    394                         PointSeriesDomain_element=csmldoc.createElement("PointSeriesDomain") 
    395                          
    396                          
    397                         #*********************************************************************** 
    398                         # domainReference element (and sub-elements)             
    399                         #*********************************************************************** 
    400                         domainReference_element=csmldoc.createElement("domainReference") 
    401                         trajectory_element=csmldoc.createElement("Trajectory") 
    402                         locations_element=csmldoc.createElement("locations") 
    403                         times_element=csmldoc.createElement("times") 
    404                         times_element.appendChild(csmldoc.createTextNode(str(times)[1:-1]))   
    405                         trajectory_element.appendChild(locations_element) 
    406                         trajectory_element.appendChild(times_element) 
    407                         domainReference_element.appendChild(trajectory_element) 
    408                         PointSeriesDomain_element.appendChild(domainReference_element) 
    409                          
    410                         #*********************************************************************** 
    411                         #domainComplement_element=csmldoc.createElement("domainComplement") 
    412                         #PointSeriesDomain_element.appendChild(domainComplement_element) 
    413                          
    414                         #*********************************************************************** 
    415                         # gml:rangeSet_element 
    416                         #*********************************************************************** 
    417                         DI.setVariable(allVarNames[i]) 
    418                          
    419                         #TO DO: 
    420                         try: 
    421                                 #strUom = var.units 
    422                                 strUom = DI.getVariableAttribute('units') 
    423                         except AttributeError: 
    424                                 #if units attribute doesn't exist: 
    425                                 strUom ="dimensionless or units not determined" 
    426                          
    427                         try:                     
    428                                 measuredvalues = str(DI.getDataForVar()) 
    429                         except: 
    430                                 measuredvalues = ' could not get values ' 
    431                          
    432                          
    433                          
    434                         gml_rangeSet_element=csmldoc.createElement("gml:rangeSet")       
    435                         gml_QuantityList_element=csmldoc.createElement("gml:QuantityList") 
    436                         gml_QuantityList_element.setAttribute('uom',strUom) 
    437                         gml_QuantityList_element.appendChild(csmldoc.createTextNode(str(measuredvalues)[1:-1])) 
    438                         gml_rangeSet_element.appendChild(gml_QuantityList_element) 
    439                          
    440                         #*********************************************************************** 
    441                         # gml:coverageFunction element (and sub-element MappingRule)             
    442                         #*********************************************************************** 
    443                         parameter_element=csmldoc.createElement("parameter") 
    444                                          
    445                         gml_featureMember_element.appendChild(PointSeriesDomain_element) 
    446                         gml_featureMember_element.appendChild(gml_rangeSet_element) 
    447                         gml_featureMember_element.appendChild(parameter_element) 
    448                         gml_FeatureCollection_element.appendChild(gml_featureMember_element) 
    449                          
    450         return csmldoc, dataset_element, gml_FeatureCollection_element 
    451          
    452          
    453          
    454  
    455  
    456          
  • TI02-CSML/trunk/Coapec/csmllibs/csmlfileextracts.py

    r58 r627  
    66import sys 
    77 
    8 def createFileExtracts(csmldoc, dataset_element, ffmap): 
    9          
     8class fileExtractBuilder: 
     9    def __init__(self, csmldoc, dataset_element, ffmap): 
     10        self.csmldoc = csmldoc 
     11        self.dataset_element=dataset_element 
     12        self.ffmap=ffmap 
     13        self.createFileExtracts() 
     14     
     15    def createFileExtracts(self): 
    1016        print "REPRESENTATIVE FILES:" 
    11         print ffmap.getRepresentativeFiles() 
     17        #print self.ffmap.getRepresentativeFiles() 
    1218         
    1319        #given a featurefilemap object, create file extracts from the "representativeFiles"      
    1420        #used to store extract/filename/variable relationship 
    1521        #referenced when creating features 
    16         fileExtractDictionary={} 
     22        self.fileExtractDictionary={} 
    1723         
    1824        fileid=0  #used to distinguish extract names for similar variables from different files 
    19         for repfile in ffmap.getRepresentativeFiles(): 
     25        for repfile in self.ffmap.getRepresentativeFiles(): 
    2026                fileid=fileid+1 
    2127                filename=repfile.getRepresentativeFileName() 
     
    2834                DI.openFile(filename) 
    2935                #creates fileextracts for each variable of each representative file 
    30                 extractType = DI.extractType 
    31                 extractPrefix = str(fileid)+'_'+DI.extractPrefix         
     36                self.extractType = DI.extractType 
     37                self.extractPrefix = str(fileid)+'_'+DI.extractPrefix    
    3238                allDimNames=DI.getListOfAxes() 
    3339                numDomains=len(allDimNames) 
    3440                for j in range (0, len(allDimNames)): 
    3541                        #Extract element is one of NetCDFExtract, GRIBExtract, PPExtract 
    36                         Extract_element=csmldoc.createElement(extractType) 
    37                         Extract_element.setAttribute('gml:id', str(extractPrefix+allDimNames[j])) 
     42                        Extract_element=self.csmldoc.createElement(self.extractType) 
     43                        Extract_element.setAttribute('gml:id', str(self.extractPrefix+allDimNames[j])) 
    3844                         
    39                         arraySize_element=csmldoc.createElement("arraySize") 
     45                        arraySize_element=self.csmldoc.createElement("arraySize") 
    4046                        #dimValue =fileobj.dimensions[allDimNames[j]] 
    4147                        dimValue =DI.getSizeOfAxis(allDimNames[j]) 
    4248                        if dimValue == None: 
    4349                            dimValue ='' 
    44                         arraySize_element.appendChild(csmldoc.createTextNode(str(dimValue))) 
     50                        arraySize_element.appendChild(self.csmldoc.createTextNode(str(dimValue))) 
    4551                        Extract_element.appendChild(arraySize_element) 
    4652                                 
    47                         fileName_element=csmldoc.createElement("fileName") 
     53                        fileName_element=self.csmldoc.createElement("fileName") 
    4854                        Extract_element.appendChild(fileName_element) 
    4955                        #this line needs to work for different directories., 
    50                         fileName_element.appendChild(csmldoc.createTextNode(filename)) 
     56                        fileName_element.appendChild(self.csmldoc.createTextNode(filename)) 
    5157                                 
    52                         variableName_element=csmldoc.createElement("variableName") 
    53                         variableName_element.appendChild(csmldoc.createTextNode(allDimNames[j])) 
     58                        variableName_element=self.csmldoc.createElement("variableName") 
     59                        variableName_element.appendChild(self.csmldoc.createTextNode(allDimNames[j])) 
    5460                        Extract_element.appendChild(variableName_element) 
    55                         dataset_element.appendChild(Extract_element)             
     61                        self.dataset_element.appendChild(Extract_element) 
    5662                 
    5763                        #keep record of extracts/filenames/variables in dictionary 
    5864                        idstr = filename + allDimNames[j] 
    59                         fileExtractDictionary[idstr] = extractPrefix+allDimNames[j] 
     65                        self.fileExtractDictionary[idstr] = self.extractPrefix+allDimNames[j] 
    6066                                         
    6167                DI.closeFile()   
    6268         
    63         return csmldoc, dataset_element, extractType, extractPrefix, fileExtractDictionary       
    64                                  
    65                          
    66                          
    67 def OLDcreateFileExtracts(csmldoc, dataset_element, tree, individual): 
    68         #Open first file (note this assumes all files in directory are the same structure!)  
    69         #print "RANGE: " + str(len(args)) 
    70         #args is list of paths to files.         
    71         templateFileList = [] 
    72         fileExtractDictionary = {} 
    73                  
    74         directories=tree.getSubDirectories() 
    75         print "directories" +str(directories) 
    76         #sys.exit() 
    77         i=0 
    78         for dtry in directories: 
    79                 i = i+1 
    80                 if individual == True: 
    81                         #then EVERY file must be opened individually (k=0....n) 
    82                         try: 
    83                                 files=tree.getCSMLSupportedFilesInSubDir(dtry) 
    84                                 errtest=files[0] 
    85                                 nfilestoopen = len(files) 
    86                         except: 
    87                                 print "no csml files in this directory" 
    88                                 continue 
    89                 else: 
    90                         #otherwise only first (suitable) file in each directory is opened. 
    91                         try: 
    92                                 files=tree.getCSMLSupportedFilesInSubDir(dtry) 
    93                                 errtest=files[0] 
    94                                 nfilestoopen = 1 
    95                         except: 
    96                                 print "no csml files in this directory" 
    97                                 continue 
    98                 print "Fs"+ str(files)   
    99                 for k in range(0,nfilestoopen): 
    100                         DI = csmllibs.csmldataiface.DataInterface() 
    101                         print "DIRCTRY:" +dtry 
    102                         print "FILE:" + files[k] 
    103                         DI = DI.getUnknownInterfaceType(files[k]) 
    104                         DI.openFile(files[k]) 
    105                  
    106                         #creates fileextracts for each variable of first  
    107                         #file in each directory: 
    108                         extractType = DI.extractType 
    109                         extractPrefix = str(i)+'_'+str(k)+DI.extractPrefix       
    110                         allDimNames=DI.getListOfAxes() 
    111                         numDomains=len(allDimNames) 
    112                         ################################## 
    113                  
    114                         #keep a list containing one file from each directory 
    115                         #useful later when generating featuretypes 
    116                         filen = files[k] 
    117                         templateFileList.append(filen) 
    118                                  
    119                         for j in range (0, len(allDimNames)): 
    120                                         #Extract element is one of NetCDFExtract, GRIBExtract, PPExtract 
    121                                         Extract_element=csmldoc.createElement(extractType) 
    122                                         Extract_element.setAttribute('gml:id', str(extractPrefix+allDimNames[j])) 
    123                                  
    124                                         arraySize_element=csmldoc.createElement("arraySize") 
    125                                         #dimValue =fileobj.dimensions[allDimNames[j]] 
    126                                         dimValue =DI.getSizeOfAxis(allDimNames[j]) 
    127                                         arraySize_element.appendChild(csmldoc.createTextNode(str(dimValue))) 
    128                                         Extract_element.appendChild(arraySize_element) 
    129                                  
    130                                         fileName_element=csmldoc.createElement("fileName") 
    131                                         Extract_element.appendChild(fileName_element) 
    132                                         #this line needs to work for different directories., 
    133                                         fileName_element.appendChild(csmldoc.createTextNode(files[0])) 
    134                                  
    135                                         variableName_element=csmldoc.createElement("variableName") 
    136                                         variableName_element.appendChild(csmldoc.createTextNode(allDimNames[j])) 
    137                                         Extract_element.appendChild(variableName_element) 
    138                                  
    139                                         dataset_element.appendChild(Extract_element)             
    140                                  
    141                                         #keep record of extracts/filenames/variables in dictionary 
    142                                         idstr = files[k] + allDimNames[j] 
    143                                         fileExtractDictionary[idstr] = extractPrefix+allDimNames[j] 
    144                                          
    145                         DI.closeFile() 
    146         print "DICTIONARY:"                                      
    147         print fileExtractDictionary      
    148         return csmldoc, dataset_element, extractType, extractPrefix, templateFileList, fileExtractDictionary 
    149                          
     69 
  • TI02-CSML/trunk/Coapec/csmllibs/csmlmeta.py

    r49 r627  
    22#meta 
    33 
     4""" ALL OBSOLETE - replaced by CSMLBuilder.py"""  
     5 
     6 
     7 
     8 
     9 
    410import xml.dom.minidom 
     11 
     12class csmlmetadata: 
     13    def __init__(): 
     14        createDataset() 
    515def createDataset(): 
    616        #************************************************************************************* 
     
    7383         
    7484 
     85 
  • TI02-CSML/trunk/Coapec/csmlscan.py

    r58 r627  
    9999#Get command line arguments 
    100100try: 
    101         opts, args = getopt.getopt(sys.argv[1:], "d:c:t:rno:h", ["directory=", "csmlfeaturetype=", "timedimension=", "recursive", "outputfile=", "help"]) 
     101        opts, args = getopt.getopt(sys.argv[1:], "d:c:t:fro:h", ["directory=", "csmlfeaturetype=", "timedimension=", "filemapping=", "recursive", "outputfile=", "help"]) 
    102102except getopt.error, msg: 
    103103        print "Invalid options, use --help for help" 
     
    108108csmlfeaturetype = 'GridSeriesFeature'   #default feature type 
    109109timedimension  = 't' 
     110mapping = None 
    110111recursive = 0 
    111112individual = False 
     
    117118                csmlfeaturetype = v 
    118119        elif o in ("-t", "--timedimension"): 
    119                 timedimension = v             
    120         elif o in ("-r", "--recursive"): 
    121                 recursive = 1 
    122         elif o in ("-n", "--recursive"): 
    123                 individual = True 
     120                timedimension = v 
     121        elif o in ("-f", "--filemapping"): 
     122                if v == '11': 
     123                    mapping = 'onetoone' 
     124                elif v == '1n': 
     125                    mapping = 'onetomany' 
    124126        elif o in ("-o", "--outputfile"): 
    125127                outputfile = v 
     
    128130                sys.exit()                               
    129131                 
    130  
    131  
    132 #----------------------------------------------------------- 
    133  
    134 #'tree' represents a directory tree including subdirectories. 
    135  
    136 dataentity=directory #dataentity stringneeded for metadata       
    137 #print "1" 
    138 #tree = csmllibs.csmldirectory.DirectoryTree() 
    139 #print "2" 
    140 #tree.setTopDirectory(directory) 
    141 #print "3" 
    142 #tree.readDirectory() 
    143 #print "4" 
    144 #allFileNames=tree.getAllCSMLSupportedFiles 
    145  
    146                  
    147          
    148  
     132#create CSML: 
    149133if csmlfeaturetype == "PointFeature": 
    150     print"creating dataset" 
    151     print "point feature" 
    152     csml, ds_element = csmllibs.csmlmeta.createDataset() 
    153     print "adding GML metadata" 
    154     csml, ds_element = csmllibs.csmlmeta.addGMLMetadata(csml, dataentity, ds_element) 
    155     print "creating filemap" 
    156     fmm = csmllibs.csmlfiles.FileMapMaker(dataentity,csmlfeaturetype) 
    157     ffmap = fmm.onetomany() # suitable for gridseries features.  #should be one to one for point features. 
    158     print 'creating feature collection' 
    159     csml,gml_FeatureCollection=csmllibs.csmlmeta.createFeatureCollection(csml) 
    160         #for each rep file in file map... 
    161         #send filename to create point feature# 
    162     print "creating point feature" 
    163     csml, ds_element, gml_FeatureCollection = csmllibs.csml 
    164     csml=createCSMLPointFeature(csml, ds_element,gml_FeatureCollection,filename,timedimension) 
    165     print "closing feature collection" 
    166     ds_element=csmllibs.csmlmeta.closeFeatureCollection(ds_element,gml_FeatureCollection) 
    167     print 'closing dataset' 
    168     csml = csmllibs.csmlmeta.closeDataset(csml,ds_element) 
     134    #NOT YET IMPLEMENTED# 
     135    if mapping is None: 
     136        mapping = 'onetoone' #default for PointFeature (?) 
    169137         
    170138elif csmlfeaturetype == "ProfileFeature": 
    171     print"creating dataset" 
    172     print "Profile Feature" 
    173     csml, ds_element = csmllibs.csmlmeta.createDataset() 
    174     print "adding GML metadata" 
    175     csml, ds_element = csmllibs.csmlmeta.addGMLMetadata(csml, dataentity, ds_element) 
    176     print "creating filemap" 
    177     fmm = csmllibs.csmlfiles.FileMapMaker(dataentity,csmlfeaturetype) 
    178     ffmap = fmm.onetoone() #assumption! 
    179    # print "creating file extracts" 
    180     #csml, ds_element, extractType, extractPrefix, extractDictionary = csmllibs.csmlfileextracts.createFileExtracts(csml, ds_element, ffmap) 
    181     print 'creating feature collection' 
    182     csml,gml_FeatureCollection=csmllibs.csmlmeta.createFeatureCollection(csml) 
    183     print "creating features" 
    184     csml, dataset, gml_FeatureCollection = csmllibs.csmlfeaturetypes.createCSMLProfileFeature(csml, ds_element,gml_FeatureCollection, ffmap, timedimension) 
    185     print "closing feature collection" 
    186     ds_element=csmllibs.csmlmeta.closeFeatureCollection(ds_element,gml_FeatureCollection) 
    187     print 'closing dataset' 
    188     csml = csmllibs.csmlmeta.closeDataset(csml,ds_element) 
    189      
     139    #NOT YET IMPLEMENTED# 
     140    if mapping is None: 
     141        mapping = 'onetoone' #default for ProfileFeature (?) 
    190142         
    191143elif csmlfeaturetype == "GridFeature": 
    192         csml=createCSMLGridFeature() 
     144        #NOT YET IMPLEMENTED# 
     145    if mapping is None: 
     146        mapping = 'onetoone' #default for GridFeature  
     147 
     148         
    193149elif csmlfeaturetype == "PointSeriesFeature": 
    194150        print"creating dataset -PointSeriesFeature" 
    195151        csml, ds_element = csmllibs.csmlmeta.createDataset() 
    196152        print "adding GML metadata" 
    197         csml, ds_element = csmllibs.csmlmeta.addGMLMetadata(csml, dataentity, ds_element) 
     153        csml, ds_element = csmllibs.csmlmeta.addGMLMetadata(csml, directory, ds_element) 
    198154        print "creating filemap" 
    199         fmm = csmllibs.csmlfiles.FileMapMaker(dataentity,csmlfeaturetype) 
     155        fmm = csmllibs.csmlfiles.FileMapMaker(directory,csmlfeaturetype) 
    200156        ffmap = fmm.onetoone() #assumption! 
    201157         
     
    219175         
    220176elif csmlfeaturetype == "ProfileSeriesFeature": 
    221         csml=createCSMLProfileSeriesFeature()    
     177    #NOT YET IMPLEMENTED# 
     178    if mapping is None: 
     179        mapping = 'onetomany' #default for ProfileSeriesFeature (?) 
     180         
    222181elif csmlfeaturetype == "GridSeriesFeature": 
    223     print"creating dataset -GridSeriesFeature" 
    224     csml, ds_element = csmllibs.csmlmeta.createDataset() 
    225     print "adding GML metadata" 
    226     csml, ds_element = csmllibs.csmlmeta.addGMLMetadata(csml, dataentity, ds_element) 
    227     print "creating filemap" 
    228     fmm = csmllibs.csmlfiles.FileMapMaker(dataentity,csmlfeaturetype) 
    229     ffmap = fmm.onetomany() # suitable for gridseries features.  
    230    # ffmap = fmm.onetoone() #is this better for era 40? 
    231     print "creating file extracts" 
    232     csml, ds_element, extractType, extractPrefix, extractDictionary = csmllibs.csmlfileextracts.createFileExtracts(csml, ds_element, ffmap) 
    233     print 'creating feature collection' 
    234     csml,gml_FeatureCollection=csmllibs.csmlmeta.createFeatureCollection(csml) 
    235     print "creating features" 
    236     csml, dataset, gml_FeatureCollection = csmllibs.csmlfeaturetypes.createCSMLGridSeriesFeatures(csml, ds_element,gml_FeatureCollection,extractType, extractPrefix, ffmap, extractDictionary,timedimension) 
    237     print "closing feature collection" 
    238     ds_element=csmllibs.csmlmeta.closeFeatureCollection(ds_element,gml_FeatureCollection) 
    239     print 'closing dataset' 
    240     csml = csmllibs.csmlmeta.closeDataset(csml,ds_element) 
    241 #output csml to terminal 
    242 #xml.dom.ext.PrettyPrint(csml) 
    243  
    244 #output csml to file 
    245 file_object = open(outputfile, "w") 
    246 xml.dom.ext.PrettyPrint(csml, file_object) 
    247 file_object.close() 
    248  
     182    if mapping is None: 
     183        mapping = 'onetomany' #default for GridSeriesFeature 
     184 
     185csmldataset=csmllibs.csmlbuilder.csmlBuilder(directory,csmlfeaturetype,mapping,timedimension, outputfile) 
     186csmldataset.build() 
    249187 
    250188 
Note: See TracChangeset for help on using the changeset viewer.