Changeset 2459


Ignore:
Timestamp:
Mar 26, 2010 4:41:48 PM (9 years ago)
Author:
wehart
Message:

Rework of Pyomo parser to allow for the specification of namespaces for data.

Location:
coopr.pyomo/trunk/coopr/pyomo
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/trunk/coopr/pyomo/base/PyomoModel.py

    r2415 r2459  
    240240
    241241
    242     def create(self, filename=None, name=None):
     242    def create(self, filename=None, name=None, scenario=None):
    243243        """
    244244        Create a concrete instance of this Model, possibly using data
     
    247247        if self._defer_construction:
    248248            instance = self.clone()
    249             instance.load(filename)
     249            instance.load(filename, scenario=scenario)
    250250        else:
    251251            instance = self
     
    287287
    288288
    289     def load(self, arg):
     289    def load(self, arg, scenario=None):
    290290        """ Load the model with data from a file or a Solution object """
    291291        if arg is None or type(arg) is str:
    292            self._load_model_data(ModelData(filename=arg,model=self))
     292           self._load_model_data(ModelData(filename=arg,model=self), scenario)
    293293           return True
    294294        elif type(arg) is ModelData:
    295            self._load_model_data(arg)
     295           self._load_model_data(arg, scenario)
    296296           return True
    297297        elif type(arg) is coopr.opt.SolverResults:
     
    340340
    341341
    342     def _load_model_data(self,modeldata):
     342    def _load_model_data(self, modeldata, scenario):
    343343        """
    344344        Load declarations from a ModelData object.
     
    354354                else:
    355355                    declaration.default = modeldata._default[tmp]
    356             if tmp in modeldata._data.keys():
    357                 #print "HERE", declaration.name, str(declaration.dimen),modeldata._data[tmp]
     356            if tmp in modeldata._data.get(scenario,{}).keys():
     357                #print "HERE", declaration.name, str(declaration.dimen),modeldata._data[scenario][tmp]
    358358                if declaration.type() is Set:
    359                     data = self._tuplize(modeldata._data[tmp],declaration)
     359                    data = self._tuplize(modeldata._data[scenario][tmp],declaration)
    360360                else:
    361                     data = modeldata._data[tmp]
     361                    data = modeldata._data[scenario][tmp]
    362362            else:
    363363                data = None
  • coopr.pyomo/trunk/coopr/pyomo/base/PyomoModelData.py

    r2227 r2459  
    3131        #
    3232        self._default={}
     33        # _data[scenario][symbol] -> data
    3334        self._data={}
    3435        #
  • coopr.pyomo/trunk/coopr/pyomo/data/TableData.py

    r2295 r2459  
    5252        Return the data that was extracted from this table
    5353        """
    54         return _process_data(self._info, model, data, default, self.filename)
     54        if not None in data:
     55            data[None] = {}
     56        return _process_data(self._info, model, data[None], default, self.filename)
    5557
    5658    def clear(self):
  • coopr.pyomo/trunk/coopr/pyomo/data/parse_datacmds.py

    r2416 r2459  
    3636    'import' : 'IMPORT',
    3737    'include' : 'INCLUDE',
     38    'namespace' : 'NAMESPACE',
    3839}
    3940
     
    4142tokens = [
    4243    "COMMA",
    43 #    "LBRACE",
    44 #    "RBRACE",
     44    "LBRACE",
     45    "RBRACE",
    4546#    "NUMBER",
    4647    "SEMICOLON",
     
    6768t_LBRACKET  = r"\["
    6869t_RBRACKET  = r"\]"
     70t_LBRACE  = r"\{"
     71t_RBRACE  = r"\}"
    6972#t_NUMBER    = r"[0-9]+(\.[0-9]+){0,1}"
    7073t_SEMICOLON = r";"
     
    7578#t_LT        = r"<"
    7679#t_GT        = r">"
    77 #t_LBRACE    = r"{"
    78 #t_RBRACE    = r"}"
    7980t_LPAREN    = r"\("
    8081t_RPAREN    = r"\)"
     
    132133def p_statements(p):
    133134    '''statements : statement statements
    134                   | statement '''
     135                  | statement
     136                  | NAMESPACE WORD LBRACE statement RBRACE statements
     137                  | NAMESPACE WORD LBRACE statement RBRACE '''
     138    global _parse_info
     139    if len(p) in [2,3]:
     140        if not p[1] is None:
     141            _parse_info[None].append(p[1])
     142    else:
     143        if not p[3] is None:
     144            _parse_info[p[1]].append(p[3])
    135145
    136146def p_statement(p):
     
    148158                 | END SEMICOLON
    149159    '''
    150     global _parse_info
    151160    #print "STATEMENT",len(p), p[1:]
    152161    if p[1] in ['set','param']:
    153         _parse_info.append( flatten(p[1:-1]) )
     162        p[0] = flatten(p[1:-1])
    154163    elif p[1] in ['include']:
    155         _parse_info.append( p[1:-1] )
     164        p[0] = p[1:-1]
    156165    elif p[1] in ['import']:
    157         _parse_info.append( [p[1]]+ p[2] )
    158         #_parse_info.append( [p[1], p[2][0], p[1:-1] )
     166        p[0] = [p[1]]+ p[2]
    159167
    160168def p_setdecl(p):
     
    286294            | COMMA
    287295            | COLON
     296            | LBRACE
     297            | RBRACE
    288298            | LBRACKET
    289299            | RBRACKET
     
    354364    #
    355365    global _parse_info
    356     _parse_info = []
     366    _parse_info = {}
     367    _parse_info[None] = []
    357368
    358369    #
     
    364375        ply_init(_parsedata)
    365376        ampl_dat_yaccer.parse(data, lexer=ampl_dat_lexer, debug=debug)
     377        #print "HERE X",_parse_info
    366378    elif not filename is None:
    367379        f = open(filename)
     
    371383        ply_init(_parsedata)
    372384        ampl_dat_yaccer.parse(data, lexer=ampl_dat_lexer, debug=debug)
    373     else:
     385        #print "HERE Y",_parse_info
     386    else:
     387        #print "HERE Z",_parse_info
    374388        _parse_info = None
    375389    #
  • coopr.pyomo/trunk/coopr/pyomo/data/process_data.py

    r2302 r2459  
    393393
    394394    try:
    395         cmds = parse_data_commands(filename=cmd[1])
     395        scenarios = parse_data_commands(filename=cmd[1])
    396396    except IOError, err:
    397397        raise IOError, "Error parsing file '%s': %s" % (Filename, str(err))
    398     for cmd in cmds:
    399         _process_data(cmd, _model, _data, _default, Filename, Lineno)
     398    if scenarios is None:
     399        return False
     400    for scenario in scenarios:
     401        for cmd in scenarios[scenario]:
     402            #print "SCENARIO",scenario,"CMD",cmd
     403            if scenario not in _data:
     404                _data[scenario] = {}
     405            #print "X _data",_data
     406            if cmd[0] in ('include', 'import'):
     407                _tmpdata = {}
     408                _process_data(cmd, _model, _tmpdata, _default, Filename, Lineno)
     409                #print "X _tmpdata",_tmpdata
     410                if scenario is None:
     411                    for key in _tmpdata:
     412                        if key in _data:
     413                            _data[key].update(_tmpdata[key])
     414                        else:
     415                            _data[key] = _tmpdata[key]
     416                else:
     417                    for key in _tmpdata:
     418                        if key is None:
     419                            _data[scenario].update(_tmpdata[key])
     420                        else:
     421                            raise IOError, "Cannot define a scenario within another scenario"
     422            else:
     423                _process_data(cmd, _model, _data[scenario], _default, Filename, Lineno)
     424            #print "X _data update",_data
    400425    return True
    401426
     
    498523    data.read()
    499524    data.close()
     525    #print "Y",_data
    500526    data.process(_model, _data, _default)
     527    #print "Y",_data
    501528       
    502529   
Note: See TracChangeset for help on using the changeset viewer.