Changeset 3074

Timestamp:

Oct 4, 2010 9:45:14 PM (11 years ago)

Author:

jwatson

Message:

Added routines to the PySP scenario tree object to return the stage for a constraint and variable.

File:

• coopr.pysp/trunk/coopr/pysp/scenariotree.py (modified) (2 diffs)

coopr.pysp/trunk/coopr/pysp/scenariotree.py

@@ -704 +704 @@
 
          tree_node.snapshotSolutionFromInstances(scenario_instance_map)
+
+   #
+   # a utility to determine the stage to which the input variable belongs.
+   # this is horribly inefficient, lacking an inverse map. fortunately,
+   # it isn't really called that often (yet). stage membership is determined
+   # by comparing the input variable name with the reference instance
+   # variable name (which is what the scenario tree refers to) and the
+   # associated indices.
+   #
+
+   def variableStage(self, variable, index):
+      
+      for stage in self._stages:
+         # stage_var is a VarValue - the rest are strings and list of indices, respectively.         
+         for (stage_var, match_template, match_indices) in stage._variables:
+            if (variable.name == stage_var.name) and (index in match_indices):
+               return stage
+
+         # IMPT: this is a temporary hack - the real fix is to force users to
+         # have every variable assigned to some stage in the model, either
+         # automatically or explicitly.
+         if (variable.name == stage._cost_variable[0].name):
+            return stage 
+
+      raise RuntimeError, "The variable="+str(variable.name)+", index="+str(index)+" does not belong to any stage in the scenario tree"
+
+   #
+   # a utility to determine the stage to which the input constraint "belongs".
+   # a constraint belongs to the latest stage in which referenced variables
+   # in the constraint appears in that stage. 
+   # input is a constraint is of type "Constraint", and an index of that
+   # constraint - which might be None in the case of singleton constraints.
+   # currently doesn't deal with SOS constraints, for no real good reason.
+   # returns an instance of a Stage object.
+   # IMPT: this method works on the canonical representation ("repn" attribute)
+   #       of a constraint. this implies that pre-processing of the instance
+   #       has been performed.
+   # NOTE: there is still the issue of whether the contained variables really
+   #       belong to the same model, but that is a different issue we won't
+   #       address right now (e.g., what does it mean for a constraint in an
+   #       extensive form binding instance to belong to a stage?).
+   #
+
+   def constraintStage(self, constraint, index):
+
+      largest_stage_index = -1
+      largest_stage = None
+      
+      canonical_repn = constraint[index].repn
+      for degree, terms in canonical_repn.items():
+         if degree != -1:
+            for var_key, coefficient in terms.items():
+               var_value = canonical_repn[-1][var_key.keys()[0]]
+               var_stage = self.variableStage(var_value.var, var_value.index)
+               var_stage_index = self._stages.index(var_stage)
+
+               if var_stage_index > largest_stage_index:
+                  largest_stage_index = var_stage_index
+                  largest_stage = var_stage
+
+      return largest_stage
 
    #
@@ -896 +957 @@
          print ""
       print "----------------------------------------------------"
+
+      print "****TESTING****"
+      constraints = self._reference_instance.active_components(Constraint)
+      for name, constraint in constraints.items():
+         print "NAME=",name
+         for index in constraint:
+            print "INDEX=",index
+            stage = self.constraintStage(constraint,index)
+            print "STAGE=",stage._name