Changeset 3999 for coopr.pyomo


Ignore:
Timestamp:
04/15/11 14:16:00 (3 years ago)
Author:
jwatson
Message:

A major re-work of labeling mechanisms, in preparation for their ultimate elimination from PyomoModel? and related components. This fix will significantly streamline this process, in which labels will be generated on-the-fly within solver plugins (if they are needed at all). Likely to break some things that I wasn't able to test, e.g., CPLEX-related baselines.

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

Legend:

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

    r3977 r3999  
    2626 
    2727from coopr.opt import ProblemFormat, ResultsFormat, guess_format 
    28 from coopr.opt.results import SolutionMap 
     28from coopr.opt.results import SolutionMap, SolverResults, Solution 
    2929from coopr.pyomo.base.var import _VarValue, VarStatus, Var 
    3030from coopr.pyomo.base.constraint import ConstraintData 
     
    3232import coopr.opt 
    3333from PyomoModelData import ModelData 
     34from coopr.opt.results.container import MapContainer,UndefinedData 
    3435 
    3536from block import Block 
     
    6465        Block.__init__(self, ctype=Model) 
    6566 
    66         # cached name-based object lookup data to facilitate fast solution loading. 
     67        # cached label-based object lookup data to facilitate fast solution loading. 
    6768        # handled by the various objects (the items in the map) during construction. 
    68         self._name_varmap={} # maps labels to _VarValue objects 
    69         self._name_conmap={} # maps labels to ConstraintData objects 
    70         self._name_objmap={} # maps labels to ObjectiveData objects 
     69        self._label_var_map={}        # maps labels to _VarValue objects 
     70        self._label_constraint_map={} # maps labels to ConstraintData objects 
     71        self._label_objective_map={} # maps labels to ObjectiveData objects 
    7172 
    7273        self.name=name 
     
    100101    def variable(self, name): 
    101102        if isinstance(name,basestring): 
    102             return self._name_varmap[name] 
     103            return self._label_var_map[name] 
    103104        else: 
    104105            return self._var[name-1] 
     
    114115 
    115116    def variables(self): 
    116         return self._name_varmap 
     117        return self._label_var_map 
    117118 
    118119    def nconstraints(self): 
     
    121122    def constraint(self, name): 
    122123        if isinstance(name,basestring): 
    123             return self._name_conmap[name] 
     124            return self._label_constraint_map[name] 
    124125        else: 
    125126            return self._con[name-1] 
    126127 
    127128    def constraints(self): 
    128         return self._name_conmap 
     129        return self._label_constraint_map 
    129130 
    130131    def nobjectives(self): 
     
    133134    def objective(self, name): 
    134135        if isinstance(name,basestring): 
    135             return self._name_objmap[name] 
     136            return self._label_objective_map[name] 
    136137        else: 
    137138            return self._obj[name-1] 
    138139 
    139140    def objectives(self): 
    140         return self._name_objmap 
     141        return self._label_objective_map 
    141142 
    142143    def num_used_variables(self): 
     
    215216        return soln 
    216217 
     218    # this method is a hack, used strictly by the pyomo command-line utility to 
     219    # allow for user-readable names to be present in solver results objects. 
     220    # this should be removed in the very near future, when labels are isolated 
     221    # completely to solver plugins. in that situation, only human-readable 
     222    # names will be present in a SolverResults object, and this method can 
     223    # be removed. 
    217224    def update_results(self, results): 
     225 
     226        new_results = SolverResults() 
     227        new_results.problem = results.problem 
     228        new_results.solver = results.solver 
     229 
    218230        for i in xrange(len(results.solution)): 
    219             soln = results.solution(i+1) 
     231 
     232            input_soln = results.solution(i+1) 
     233            new_soln = Solution() 
     234            new_soln.gap = input_soln.gap 
     235            new_soln.status = input_soln.status 
     236 
    220237            # 
    221238            # Variables 
    222239            # 
    223             vars = SolutionMap() 
    224             flag=False 
    225             for name in soln.variable.keys(): 
    226                 flag=True 
    227                 entry = soln.variable[name] 
     240            vars = new_soln.variable 
     241            for label in input_soln.variable.keys(): 
     242                entry = input_soln.variable[label] 
    228243                # NOTE: the following is a hack, to handle the ONE_VAR_CONSTANT variable 
    229                 if name == "ONE_VAR_CONSTANT": 
     244                if label == "ONE_VAR_CONSTANT": 
    230245                    continue 
    231                 # translate the name first if there is a variable map associated 
    232                 # with the input solution. 
     246                # translate the label first if there is a symbol map  
     247                # associated with the input solution. 
    233248                if results.symbol_map is not None: 
    234                     name = results.symbol_map.get(name, name) 
    235                 if name not in self._name_varmap: 
    236                     msg = "Variable name '%s' is not in model '%s'.  Valid "      \ 
    237                         'variable names: %s' 
     249                    label = results.symbol_map.get(label, label) 
     250                if label not in self._label_var_map: 
     251                    msg = "Variable with label '%s' is not in model '%s'.  Valid "      \ 
     252                        'variable labels: %s' 
    238253                    raise KeyError, msg % ( 
    239                           name, self.name, str(self._name_varmap.keys()) ) 
    240                 var_value = self._name_varmap[name] 
     254                          label, self.name, str(self._label_var_map.keys()) ) 
     255                var_value = self._label_var_map[label] 
    241256                entry.id = var_value.id 
    242                 vars.declare(name) 
    243                 dict.__setitem__(vars,name, entry) 
    244             if flag: 
    245                 dict.__setitem__(soln, 'Variable', vars) 
     257                vars.declare(var_value.name) 
     258                dict.__setitem__(vars,var_value.name,entry) 
     259 
    246260            # 
    247261            # Constraints 
    248262            # 
    249             cons = SolutionMap() 
    250             flag=False 
    251             for name in soln.constraint.keys(): 
    252                 flag=True 
    253                 entry = soln.constraint[name] 
     263            cons = new_soln.constraint 
     264            for label in input_soln.constraint.keys(): 
     265                entry = input_soln.constraint[label] 
    254266                if results.symbol_map is not None: 
    255                     name = results.symbol_map.get(name, name) 
    256                 if name not in self._name_conmap: 
    257                     if name.endswith('ONE_VAR_CONSTANT'): 
     267                    label = results.symbol_map.get(label, label) 
     268                if label not in self._label_constraint_map: 
     269                    if label.endswith('ONE_VAR_CONSTANT'): 
    258270                        # Should this data be filtered from the results object? 
    259271                        continue 
    260                     msg = "Constraint name '%s' is not in model '%s'.  Valid "      \ 
    261                         'constraint names: %s' 
     272                    msg = "Constraint with label '%s' is not in model '%s'.  Valid "      \ 
     273                        'constraint labels: %s' 
    262274                    raise KeyError, msg % ( 
    263                           name, self.name, str(self._name_conmap.keys()) ) 
    264                 con_value = self._name_conmap[name] 
     275                          label, self.name, str(self._label_constraint_map.keys()) ) 
     276                con_value = self._label_constraint_map[label] 
    265277                entry.id = con_value.id 
    266                 cons.declare(name) 
    267                 dict.__setitem__(cons,name, entry) 
    268             if flag: 
    269                 dict.__setitem__(soln, 'Constraint', cons) 
     278                cons.declare(con_value.label) 
     279                dict.__setitem__(cons,con_value.label, entry) 
    270280            # 
    271281            # Objectives 
    272282            # 
    273             objs = SolutionMap() 
    274             flag=False 
    275             for name in soln.objective.keys(): 
    276                 flag=True 
    277                 entry = soln.objective[name] 
     283            objs = new_soln.objective 
     284            for label in input_soln.objective.keys(): 
     285                entry = input_soln.objective[label] 
    278286                if results.symbol_map is not None: 
    279                     name = results.symbol_map.get(name, name) 
    280                 if not name in self._name_objmap: 
    281                     msg = "Objective name '%s' is not in model '%s'.  Valid "      \ 
    282                         'objective names: %s' 
     287                    label = results.symbol_map.get(label, label) 
     288                if not label in self._label_objective_map: 
     289                    msg = "Objective with label '%s' is not in model '%s'.  Valid "      \ 
     290                        'objective labels: %s' 
    283291                    raise KeyError, msg % ( 
    284                           name, self.name, str(self._name_objmap.keys()) ) 
    285                 obj_value = self._name_objmap[name] 
     292                          label, self.name, str(self._label_objective_map.keys()) ) 
     293                obj_value = self._label_objective_map[label] 
    286294                entry.id = obj_value.id 
    287                 objs.declare(name) 
    288                 dict.__setitem__(objs,name, entry) 
    289             if flag: 
    290                 dict.__setitem__(soln, 'Objective', objs) 
     295                objs.declare(obj_value.label) 
     296                dict.__setitem__(objs,obj_value.label, entry) 
     297 
     298        new_results.solution.insert(new_soln) 
     299 
     300        return new_results 
    291301 
    292302    def load(self, arg, namespaces=[None], simplify=None, profile_memory=0): 
     
    448458        # Load variable data 
    449459        # 
    450         for name, entry in soln.variable.iteritems(): 
     460        for label, entry in soln.variable.iteritems(): 
    451461 
    452462            # NOTE: the following is a hack, to handle the ONE_VAR_CONSTANT 
     
    456466            #    constructed. 
    457467 
    458             if name != "ONE_VAR_CONSTANT": 
    459  
    460                 # translate the name first if there is a variable map associated 
     468            if label != "ONE_VAR_CONSTANT": 
     469 
     470                # translate the label first if there is a variable map associated 
    461471                # with the input solution. 
    462472                if symbol_map is not None: 
    463                     name = symbol_map.get(name, name) 
    464                 if name not in self._name_varmap: 
    465                     msg = "Variable name '%s' is not in model '%s'.  Valid "      \ 
    466                           'variable names: %s' 
     473                    label = symbol_map.get(label, label) 
     474                if label not in self._label_var_map: 
     475                    msg = "Variable label '%s' is not in model '%s'.  Valid "      \ 
     476                          'variable labels: %s' 
    467477                    raise KeyError, msg % ( 
    468                               name, self.name, str(self._name_varmap.keys()) ) 
    469  
    470                 if not isinstance(self._name_varmap[name],_VarValue): 
     478                              label, self.name, str(self._label_var_map.keys()) ) 
     479 
     480                if not isinstance(self._label_var_map[label],_VarValue): 
    471481                    msg = "Variable '%s' in model '%s' is type %s" 
    472482                    raise TypeError, msg % ( 
    473                         name, self.name, str(type(self._name_varmap[name])) ) 
    474  
    475                 if self._name_varmap[name].fixed is True: 
     483                        label, self.name, str(type(self._label_var_map[label])) ) 
     484 
     485                if self._label_var_map[label].fixed is True: 
    476486                    msg = "Variable '%s' in model '%s' is currently fixed - new" \ 
    477487                          ' value is not expected in solution' 
    478                     raise TypeError, msg % ( name, self.name ) 
    479  
    480                 if self._name_varmap[name].status is not VarStatus.used: 
     488                    raise TypeError, msg % ( label, self.name ) 
     489 
     490                if self._label_var_map[label].status is not VarStatus.used: 
    481491                    msg = "Variable '%s' in model '%s' is not currently used - no" \ 
    482492                          ' value is expected in solution' 
    483                     raise TypeError, msg % ( name, self.name ) 
    484  
    485                 var_value = self._name_varmap[name] 
     493                    raise TypeError, msg % ( label, self.name ) 
     494 
     495                var_value = self._label_var_map[label] 
    486496                for _key in entry.keys(): 
    487497                    key = _key[0].lower() + _key[1:] 
     
    493503        # Load constraint data 
    494504        # 
    495         for name,entry in soln.constraint.iteritems(): 
     505        for label,entry in soln.constraint.iteritems(): 
    496506                # 
    497507                # This is a hack - see above. 
    498508                # 
    499             if name.endswith('ONE_VAR_CONSTANT'): 
     509            if label.endswith('ONE_VAR_CONSTANT'): 
    500510                continue 
    501511            if symbol_map is not None: 
    502                 name = symbol_map.get(name, name) 
     512                label = symbol_map.get(label, label) 
    503513            # 
    504514            # This is a hack.  Is there a standard convention for constraint 
    505             # names that we can apply to all data formats? 
     515            # labels that we can apply to all data formats? 
    506516            # 
    507             if name[0:2] == 'c_': 
    508                 _name = name[4:-1] 
     517            if label[0:2] == 'c_': 
     518                _label = label[4:-1] 
    509519            else: 
    510                 _name = name 
    511  
    512             if _name not in self._name_conmap: 
    513                 msg = "Constraint name '%s' is not in model '%s'.  Valid "    \ 
    514                       'constraint names: %s' 
     520                _label = label 
     521 
     522            if _label not in self._label_constraint_map: 
     523                msg = "Constraint with label '%s' is not in model '%s'.  Valid "    \ 
     524                      'constraint labels: %s' 
    515525                raise KeyError, msg % ( 
    516                               _name, self.name, str(self._name_conmap.keys()) ) 
    517  
    518             if not isinstance(self._name_conmap[_name],ConstraintData): 
     526                              _label, self.name, str(self._label_constraint_map.keys()) ) 
     527 
     528            if not isinstance(self._label_constraint_map[_label],ConstraintData): 
    519529                msg = "Constraint '%s' in model '%s' is type %s" 
    520530                raise TypeError, msg % ( 
    521                        name, self.name, str(type(self._name_conmap[_name])) ) 
    522  
    523             constraint_data = self._name_conmap[_name] 
     531                       label, self.name, str(type(self._label_constraint_map[_label])) ) 
     532 
     533            constraint_data = self._label_constraint_map[_label] 
    524534            for _key in entry.keys(): 
    525535                key = _key[0].lower() + _key[1:] 
  • coopr.pyomo/trunk/coopr/pyomo/base/constraint.py

    r3982 r3999  
    155155 
    156156    def sync_label(self): 
    157         if self.name is not None: 
    158             self.label = label_from_name(self.name) 
    159             if (self.con is not None) and (self.con.model is not None): 
    160                 self.con.model._name_conmap[self.label] = self 
     157        my_name = self.name 
     158        if my_name is not None: 
     159            self.label = label_from_name(my_name) 
     160            parent_constraint = self.con 
     161            if (parent_constraint is not None) and (parent_constraint.model is not None): 
     162                parent_constraint.model._label_constraint_map[self.label] = self 
    161163        else: 
    162164            self.label = None 
     
    547549 
    548550        # 
    549         # update the parent model (if any) name->constraint map. 
     551        # update the parent model's (if any) label->constraint map. 
    550552        # 
    551553        if self.model is not None: 
    552            self.model._name_conmap[conData.label] = conData 
     554           self.model._label_constraint_map[conData.label] = conData 
    553555 
    554556 
  • coopr.pyomo/trunk/coopr/pyomo/base/label.py

    r3452 r3999  
    99#  _________________________________________________________________________ 
    1010 
     11__all__ = ['label_from_name'] 
     12 
     13import string 
     14 
     15 
    1116# this module provides some basic functionality for generating labels from pyomo 
    1217# names, which often contain characters such as "[" and "]" (e.g., in my_var[1]). 
     
    1419# e.g., CPLEX LP files. the purpose of this module is to provide a simple remap 
    1520# function, that will satisfy broadly problematic symbols. if solver-specific  
    16 # remaps are required, they should be handled either in a preprocessor or a solver 
     21# remaps are required, they should be handled either in the corresponding solver  
    1722# plugin. 
    1823 
    19 __all__ = ['label_from_name'] 
     24# NOTE: Simple single-character substitutions should be handled by adding  
     25#       to the translation table constructed below - first argument is the  
     26#       "from" characters, second argument is the "to" characters. 
     27simple_translation_table = string.maketrans("[]{} -#$%&*+./;<=>?@^!~'",  
     28                                            "()()____________________") 
    2029 
    21 ignore = set(['"', "'", '`']) 
    22 remap = {} 
    23 # Remap as underscores 
    24 remap['-']='_' 
    25 remap['_']='_' 
    26 remap[' ']='_' 
    27 remap['(']='[' 
    28 remap['{']='[' 
    29 remap[')']=']' 
    30 remap['}']=']' 
    31 # Remap as Q+ASCII-Dec 
    32 remap['!']='_Q33_' 
    33 remap['#']='_Q35_' 
    34 remap['$']='_Q36_' 
    35 remap['%']='_Q37_' 
    36 remap['&']='_Q38_' 
    37 remap['*']='_Q42_' 
    38 remap['+']='_Q43_' 
    39 #remap[',']='_Q44_' 
    40 remap['.']='_Q46_' 
    41 remap['/']='_Q47_' 
    42 remap[';']='_Q59_' 
    43 remap['<']='_Q60_' 
    44 remap['=']='_Q61_' 
    45 remap['>']='_Q62_' 
    46 remap['?']='_Q63_' 
    47 remap['@']='_Q63_' 
    48 remap['\\']='_Q92_' 
    49 remap['^']='_Q94_' 
    50 remap['|']='_Q124_' 
    51 remap['~']='_Q126_' 
    5230 
    5331def label_from_name(name): 
    5432 
    55    global ignore 
    56    global remap 
     33   global simple_translation_table 
    5734 
    5835   if name is None: 
    5936      raise RuntimeError, "Illegal name=None supplied to label_from_name function" 
    6037 
    61    label="" 
    62    for c in name: 
    63       if c in remap: 
    64          label += remap[c] 
    65       elif not c in ignore: 
    66          label += c 
    67    return label 
     38   return string.translate(name, simple_translation_table) 
  • coopr.pyomo/trunk/coopr/pyomo/base/objective.py

    r3928 r3999  
    5757            self.label = label_from_name(self.name) 
    5858            if (self.obj is not None) and (self.obj.model is not None): 
    59                 self.obj.model._name_objmap[self.label] = self 
     59                self.obj.model._label_objective_map[self.label] = self 
    6060        else: 
    6161            self.label = None 
     
    250250        if self.model is not None: 
    251251           for objective_data in self._data.itervalues(): 
    252               self.model._name_objmap[objective_data.label] = objective_data 
     252              self.model._label_objective_map[objective_data.label] = objective_data 
    253253 
    254254    def pprint(self, ostream=None): 
  • coopr.pyomo/trunk/coopr/pyomo/base/var.py

    r3982 r3999  
    115115           self.label = label_from_name(self.name) 
    116116           if (self.var is not None) and (self.var.model is not None): 
    117               self.var.model._name_varmap[self.label] = self 
     117              self.var.model._label_var_map[self.label] = self 
    118118        else: 
    119119           self.label = None 
     
    554554        if self.model is not None: 
    555555           for varval in self._varval.itervalues(): 
    556               self.model._name_varmap[varval.label] = varval 
     556              self.model._label_var_map[varval.label] = varval 
    557557 
    558558    def pprint(self, ostream=None): 
  • coopr.pyomo/trunk/coopr/pyomo/io/ampl.py

    r3775 r3999  
    176176 
    177177        elif (isinstance(exp,var._VarValue) or isinstance(exp,var.Var)) and not exp.fixed_value(): 
    178             print >>OUTPUT, "v" + str(exp.ampl_var_id) + " #" + str(exp.label) 
     178            print >>OUTPUT, "v" + str(exp.ampl_var_id) + " #" + str(exp.name) 
    179179             
    180180        elif isinstance(exp,param._ParamValue): 
     
    293293                U = Vars[ndx].ub 
    294294                if L is None or U is None: 
    295                     raise ValueError, "Variable " + str(var.label) +\ 
     295                    raise ValueError, "Variable " + str(var.name) +\ 
    296296                          "is binary, but does not have lb and ub set" 
    297297                elif value(L) == 0 and value(U) == 1: 
     
    461461                                    self._get_bound(constraint_data.lower)-offset,\ 
    462462                                    self._get_bound(constraint_data.upper)-offset, 
    463                 print >>OUTPUT, " # c"+ str(nc)+"  "+constraint_data.label #str(key) + "[" + str(ndx) + "]" 
    464                 symbol_map["c" + str(nc)] = constraint_data.label #str(key) + "[" + str(ndx) + "]" 
     463                print >>OUTPUT, " # c"+ str(nc)+"  "+constraint_data.name #str(key) + "[" + str(ndx) + "]" 
     464                symbol_map["c" + str(nc)] = constraint_data.name #str(key) + "[" + str(ndx) + "]" 
    465465                nc += 1 
    466466        # 
     
    473473            if isinstance(var.domain, BooleanSet): 
    474474                print >>OUTPUT, "0 0 1", 
    475                 print >>OUTPUT, " # v"+str(vv.ampl_var_id)+"  "+vv.label 
    476                 symbol_map["v"+str(vv.ampl_var_id)] = vv.label 
     475                print >>OUTPUT, " # v"+str(vv.ampl_var_id)+"  "+vv.name 
     476                symbol_map["v"+str(vv.ampl_var_id)] = vv.name 
    477477                continue 
    478478            L = vv.lb 
     
    492492            else: 
    493493                print >>OUTPUT, "3", 
    494             print >>OUTPUT, " # v"+str(vv.ampl_var_id)+"  "+vv.label 
    495             symbol_map["v"+str(vv.ampl_var_id)] = vv.label 
     494            print >>OUTPUT, " # v"+str(vv.ampl_var_id)+"  "+vv.name 
     495            symbol_map["v"+str(vv.ampl_var_id)] = vv.name 
    496496        # 
    497497        # "k" lines 
     
    531531                con_vars = set(ampl_repn._linear_terms_var.keys()) 
    532532                con_vars.update(set(ampl_repn._nonlinear_vars.keys())) 
    533                 print >>OUTPUT, "J" + str(nc), len(con_vars), " # ", constraint_data.label 
     533                print >>OUTPUT, "J" + str(nc), len(con_vars), " # ", constraint_data.name 
    534534                nc += 1 
    535535                grad_entries = {} 
     
    856856    # 
    857857    elif type(exp) is _VarValue or exp.type() is Var: 
    858         ampl_repn._linear_terms_coef = {exp.label: 1.0} 
    859         ampl_repn._linear_terms_var = {exp.label: exp} 
     858        ampl_repn._linear_terms_coef = {exp.name: 1.0} 
     859        ampl_repn._linear_terms_var = {exp.name: exp} 
    860860        return ampl_repn 
    861861    # 
  • coopr.pyomo/trunk/coopr/pyomo/io/cpxlp.py

    r3990 r3999  
    151151                 self._no_label_error(var_value) 
    152152 
    153               name = prefix + convert_name(var_value.label) 
     153              name = prefix + var_value.label 
    154154 
    155155              # due to potential disabling of expression simplification, 
     
    222222                 self._no_label_error(var_value) 
    223223   
    224               name = prefix + convert_name(label)               
     224              name = prefix + label               
    225225 
    226226              name_to_coefficient_map[name] = coefficient 
     
    274274                       prefix = convert_name(parent_var.model.name) + "_"                         
    275275 
    276                     name = prefix + convert_name(label)  
     276                    name = prefix + label  
    277277                    term_variables.append(name) 
    278278 
     
    355355                        sign, 
    356356                        str(rho), 
    357                         convert_name(variable.label) 
     357                        variable.label 
    358358                      ) 
    359359 
     
    364364                         sign, 
    365365                         str(abs(rho*offset.value)), 
    366                          convert_name( variable.label ) 
     366                         variable.label 
    367367                      ) 
    368368 
     
    587587                   prefix = constraint.model.name+"_" 
    588588 
    589                con_name = convert_name(constraint_data.label) 
     589               con_name = constraint_data.label 
    590590 
    591591               if constraint_data._equality: 
     
    698698                           else: 
    699699                             print >>OUTPUT, " -inf <= ", 
    700                            name_to_output = prefix+convert_name(var[index].label) 
     700                           name_to_output = prefix + var[index].label 
    701701                           if name_to_output == "e": 
    702702                               msg = 'Attempting to write variable with name' \ 
     
    733733                      continue 
    734734                   if var[index].id != -1: # skip if variable not referenced 
    735                        var_name = prefix+convert_name(var[index].label) 
     735                       var_name = prefix + var[index].label 
    736736                       print >>OUTPUT, ' ', var_name 
    737737 
     
    756756                       continue 
    757757                   if var[index].id != -1: # skip if variable not referenced 
    758                        var_name = prefix+convert_name(var[index].label) 
     758                       var_name = prefix + var[index].label 
    759759                       print >>OUTPUT, ' ', var_name 
    760760 
  • coopr.pyomo/trunk/coopr/pyomo/preprocess/numeric_varlabels.py

    r2359 r3999  
    3434        for id in model._var: 
    3535            model._var[id].label = "x_"+str(id) 
    36             model._name_varmap[model._var[id].label] = model._var[id] 
     36            model._label_var_map[model._var[id].label] = model._var[id] 
    3737        for id in model._con: 
    3838            model._con[id].label = "c_"+str(id) 
  • coopr.pyomo/trunk/coopr/pyomo/scripting/util.py

    r3989 r3999  
    543543    # 
    544544    try: 
    545         instance.update_results(results) 
     545        # transform the results object into human-readable names. 
     546        # IMPT: the resulting object won't be loadable - it's only for output. 
     547        transformed_results = instance.update_results(results) 
    546548    except Exception, e: 
    547         print "Problem loading solver results" 
     549        print "Problem updating solver results" 
    548550        raise 
    549551    # 
     
    553555        else: 
    554556            results_file = 'results.yml' 
    555         results.write(filename=results_file) 
     557        transformed_results.write(filename=results_file) 
    556558        if not options.quiet: 
    557             print "    Number of solutions:", len(results.solution) 
    558             if len(results.solution) > 0: 
     559            print "    Number of solutions:", len(transformed_results.solution) 
     560            if len(transformed_results.solution) > 0: 
    559561                print "    Solution Information" 
    560                 print "      Gap:",results.solution[0].gap 
    561                 print "      Status:",results.solution[0].status 
    562                 if len(results.solution[0].objective) == 1: 
    563                     key = results.solution[0].objective.keys()[0] 
    564                     print "      Function Value:",results.solution[0].objective[key].value 
     562                print "      Gap:",transformed_results.solution[0].gap 
     563                print "      Status:",transformed_results.solution[0].status 
     564                if len(transformed_results.solution[0].objective) == 1: 
     565                    key = transformed_results.solution[0].objective.keys()[0] 
     566                    print "      Function Value:",transformed_results.solution[0].objective[key].value 
    565567            print "    Solver results file:",results_file 
    566568    # 
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_concrete.py

    r3790 r3999  
    3838        #results = opt.solve(instance, keepFiles=True) 
    3939        results = opt.solve(instance) 
    40         instance.update_results(results) 
    41         results.write(filename=currdir+"blend.out") 
     40        new_results = instance.update_results(results) 
     41        new_results.write(filename=currdir+"blend.out") 
    4242        self.assertFileEqualsBaseline(currdir+"blend.out",currdir+"blend.txt") 
    4343 
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_preprocess.py

    r3746 r3999  
    3636        instance.preprocess() 
    3737        self.assertEqual(instance.num_used_variables(),1) 
    38         self.assertEqual(instance.x[1].label,"x[1]") 
    39         self.assertEqual(instance.x[2].label,"x[2]") 
    40         self.assertEqual(instance.y[1].label,"y[1]") 
     38        self.assertEqual(instance.x[1].label,"x(1)") 
     39        self.assertEqual(instance.x[2].label,"x(2)") 
     40        self.assertEqual(instance.y[1].label,"y(1)") 
    4141 
    4242if __name__ == "__main__": 
  • coopr.pyomo/trunk/coopr/pyomo/transform/eliminate_fixed_vars.py

    r3928 r3999  
    5555                    M.statistics.number_of_continuous_variables -= 1 
    5656                M.statistics.number_of_variables -= 1 
    57                 del M._name_varmap[ var.label ] 
     57                del M._label_var_map[ var.label ] 
    5858                del var.var._varval[ var.index ] 
    5959            else: 
Note: See TracChangeset for help on using the changeset viewer.