Changeset 3021

Timestamp:

Sep 19, 2010 9:44:44 PM (11 years ago)

Author:

jwatson

Message:

Various performance improvements to identify_vars.py.

File:

• coopr.pyomo/trunk/coopr/pyomo/preprocess/identify_vars.py (modified) (9 diffs)

coopr.pyomo/trunk/coopr/pyomo/preprocess/identify_vars.py

@@ -36 +36 @@
     #
     def _identify_variables(self, exp, model):
+
         try:
             if exp.fixed_value():
@@ -73 +74 @@
             if exp.id in model._var:
                 return
-            exp.id = self.vnum
-            model._var[self.vnum] = exp
-            self.vnum += 1
+            exp.id = self.var_count
+            model._var[self.var_count] = exp
+            self.var_count += 1
         #
         # Variable Base
@@ -86 +87 @@
             if tmp.id in model._var:
                 return
-            tmp.id = self.vnum
-            model._var[self.vnum] = tmp
-            self.vnum += 1            
+            tmp.id = self.var_count
+            model._var[self.var_count] = tmp
+            self.var_count += 1            
         #
         # If not a constant, then this is an error
@@ -95 +96 @@
             raise ValueError, "Unexpected expression type in identify_variables: " + str(type(exp))+" "+str(exp)
 
+    #
+    # this pre-processor computes a number of attributes of model components, in 
+    # addition to models themselves. for VarValue, ConstraintData, and ObjectiveData,
+    # the routine assigns the "id" attribute. in addition, for VarValues, the routine
+    # sets the "status" attribute - to used or unused, depending on whether it appears
+    # in an active constraint/objective. on the Model object, the routine populates
+    # the "statistics" (variable/constraint/objective counts) attribute, and builds 
+    # the _var, _con, and _obj dictionaries of a Model, which map the id attributes
+    # to the respective VarValue, ConstraintData, or ObjectiveData object.
+    #
+    # NOTE: if variables are fixed, then this preprocessor will flag them as unused
+    #       and consequently not create entries for them in the model _var map. 
+    #
 
     def preprocess(self,model):
@@ -101 +115 @@
         """
 
-        Vars = model.active_components(Var)
-        Con = model.active_components(Constraint)
-        Obj = model.active_components(Objective)
+        active_variables = model.active_components(Var)
+        active_constraints = model.active_components(Constraint)
+        active_objectives = model.active_components(Objective)
 
-        Con.update(model.active_components(SOSConstraint))
+        active_constraints.update(model.active_components(SOSConstraint))
 
-        self.vnum=0
-        self.cnum=0
-        self.onum=0
+        self.var_count=0
+        self.constraint_count=0
+        self.objective_count=0
         
         model.statistics.number_of_binary_variables = 0
@@ -124 +138 @@
         # Until proven otherwise, all variables are unused.
         #
-        for var in Vars.values():
-            for V in var._varval.keys():
-                var._varval[V].status = VarStatus.unused
-                var._varval[V].id = -1
+        for var in active_variables.values():
+            for var_value in var._varval.values():
+                var_value.status = VarStatus.unused
+                var_value.id = -1
 
         #
@@ -133 +147 @@
         # used in the objective and constraints.
         #
-        for key in Obj.keys():
-            for ondx in Obj[key]._data:
-                if not Obj[key]._data[ondx].active:
+        for name, objective in active_objectives.items():
+            for index, objective_data in objective._data.items():
+                if not objective_data.active:
                     continue
                 try:
-                    self._identify_variables(Obj[key]._data[ondx].expr, model)
+                    self._identify_variables(objective_data.expr, model)
                 except ValueError, err:
-                    raise ValueError, "Problem processing objective %s (index %s): %s" % (str(key), str(ondx), str(err))
+                    raise ValueError, "Problem processing objective %s (index %s): %s" % (str(name), str(index), str(err))
 
-                Obj[key]._data[ondx].id = self.onum
-                self.onum += 1
+                objective_data.id = self.objective_count
+                model._obj[self.objective_count] = objective_data
+                self.objective_count += 1
 
-        for key in Con.keys():
-            C = Con[key]
-            for cndx in C.keys():
-                if not C._data[cndx].active:
+        for name, constraint in active_constraints.items():
+            for index, constraint_data in constraint._data.items():
+                if not constraint_data.active:
                     continue
                 try:
-                    self._identify_variables(C._data[cndx].body, model)
+                    self._identify_variables(constraint_data.body, model)
                 except ValueError, err:
-                    raise ValueError, "Problem processing constraint %s (index %s): %s" % (str(key), str(cndx), str(err))
-                C._data[cndx].id = self.cnum
-                model._con[self.cnum] = C._data[cndx]
-                self.cnum += 1
+                    raise ValueError, "Problem processing constraint %s (index %s): %s" % (str(name), str(index), str(err))
+                constraint_data.id = self.constraint_count
+                model._con[self.constraint_count] = constraint_data
+                self.constraint_count += 1
 
         #
@@ -166 +180 @@
         # each variable value.
         #
-        for var in Vars.values():
+        for var in active_variables.values():
             model.statistics.number_of_binary_variables += len(var.binary_keys())
             model.statistics.number_of_integer_variables += len(var.integer_keys())
@@ -175 +189 @@
         #
 
-        model.statistics.number_of_variables = self.vnum
-        model.statistics.number_of_constraints = self.cnum
-        model.statistics.number_of_objectives = self.onum
+        model.statistics.number_of_variables = self.var_count
+        model.statistics.number_of_constraints = self.constraint_count
+        model.statistics.number_of_objectives = self.objective_count
 
         return model