Context Navigation

← Previous Changeset
Next Changeset →

Changeset 3220

Timestamp:

Nov 5, 2010 10:28:29 PM (10 years ago)

Author:

jwatson

Message:

Various fixes to the WW PH extension, bringing it in compliance to previous commit changes.

File:

: 1 edited

coopr.pysp/trunk/coopr/pysp/wwphextension.py (modified) (4 diffs)

Legend:

: Unmodified
: Added
: Removed

coopr.pysp/trunk/coopr/pysp/wwphextension.py

-                      r3073
+                      r3220
       # set up tree storage for statistics that we care about tracking.
+      for stage in ph._scenario_tree._stages:
+         if stage != ph._scenario_tree._stages[-1]:
+            # first, gather all unique variables referenced in self stage
+            # self "gather" step is currently required because we're being lazy
+            # in terms of index management in the scenario tree
+##            stage_variables = {}
+##            for (reference_variable, index_template, reference_index) in stage._variables:
+##               if reference_variable.name not in stage_variables.keys():
+##                  stage_variables[reference_variable.name] = reference_variable
+      for stage in ph._scenario_tree._stages[:-1]:
+         # first, gather all unique variables referenced in self stage
+         # self "gather" step is currently required because we're being lazy
+         # in terms of index management in the scenario tree
+##         stage_variables = {}
+##         for (reference_variable, index_template, reference_index) in stage._variables:
+##            if reference_variable.name not in stage_variables.keys():
+##               stage_variables[reference_variable.name] = reference_variable
 ##
+            for tree_node in stage._tree_nodes:
+               tree_node._num_iters_converged = {}
+               tree_node._last_converged_val = {}
+               tree_node._w_hash = {}
+               tree_node._fixed_var_flag = {}
+               for (variable, index_template, variable_indices) in stage._variables:
+                  variable_name = variable.name
+                  variable_type = variable.domain
+                  # create the parameters for all indices, even though this might be a bit
+                  # wasteful. in practice, this probably won't be the case, and determining
+                  # the reduced index set would probably take longer that it is worth.
+                  new_stat_index = variable._index
+                  new_stat_parameter_name = "NODESTAT_NUM_ITERS_CONVERGED_"+variable.name
+                  new_stat_parameter = None
+                  # this bit of ugliness is due to Pyomo not correctly handling the Param construction
+                  # case when the supplied index set consists strictly of None, i.e., the source variable
+                  # is a singleton. this case be cleaned up when the source issue in Pyomo is fixed.
+                  if (len(new_stat_index) is 1) and (None in new_stat_index):
+                     new_stat_parameter = Param(name=new_stat_parameter_name, mutable=True)
+                  else:
+                     new_stat_parameter = Param(new_stat_index, name=new_stat_parameter_name, mutable=True)
+                  for newindex in new_stat_index:
+                     new_stat_parameter[newindex] = 0
+                  tree_node._num_iters_converged[variable.name] = new_stat_parameter
+         for tree_node in stage._tree_nodes:
+            tree_node._num_iters_converged = {}
+            tree_node._last_converged_val = {}
+            tree_node._w_hash = {}
+            tree_node._fixed_var_flag = {}
+            for (reference_variable, index_template) in stage._variables:
+               variable_name = reference_variable.name
+               variable_type = reference_variable.domain
+               variable_indices = tree_node._variable_indices[variable_name]
+               new_param_index = getattr(ph._instances[tree_node._scenarios[0]._name], variable_name)._index
+               # create the parameters for all indices, even though this might be a bit
+               # wasteful. in practice, this probably won't be the case, and determining
+               # the reduced index set would probably take longer that it is worth.
+               new_stat_index = new_param_index
+               new_stat_parameter_name = "NODESTAT_NUM_ITERS_CONVERGED_"+reference_variable.name
+               new_stat_parameter = None
+               # this bit of ugliness is due to Pyomo not correctly handling the Param construction
+               # case when the supplied index set consists strictly of None, i.e., the source variable
+               # is a singleton. this case be cleaned up when the source issue in Pyomo is fixed.
+               if (len(new_stat_index) is 1) and (None in new_stat_index):
+                  new_stat_parameter = Param(name=new_stat_parameter_name, mutable=True)
+               else:
+                  new_stat_parameter = Param(new_stat_index, name=new_stat_parameter_name, mutable=True)
+               for newindex in new_stat_index:
+                  new_stat_parameter[newindex] = 0
+               tree_node._num_iters_converged[reference_variable.name] = new_stat_parameter
                   # need to know to what we have most recently converged
                   new_conv_index = variable._index
                   new_conv_parameter_name = "NODESTAT_LAST_CONVERGED_VAL_"+variable.name
                   new_conv_parameter = None
                   if (len(new_conv_index) is 1) and (None in new_conv_index):
                      new_conv_parameter = Param(name=new_conv_parameter_name, mutable=True)
                   else:
                      new_conv_parameter = Param(new_conv_index, name=new_conv_parameter_name, mutable=True)
                   for newindex in new_conv_index:
                      new_conv_parameter[newindex] = 0.5 # not an int, so harmless
                   tree_node._last_converged_val[variable.name] = new_conv_parameter
+               # need to know to what we have most recently converged
+               new_conv_index = new_param_index
+               new_conv_parameter_name = "NODESTAT_LAST_CONVERGED_VAL_"+reference_variable.name
+               new_conv_parameter = None
+               if (len(new_conv_index) is 1) and (None in new_conv_index):
+                  new_conv_parameter = Param(name=new_conv_parameter_name, mutable=True)
+               else:
+                  new_conv_parameter = Param(new_conv_index, name=new_conv_parameter_name, mutable=True)
+               for newindex in new_conv_index:
+                  new_conv_parameter[newindex] = 0.5 # not an int, so harmless
+               tree_node._last_converged_val[reference_variable.name] = new_conv_parameter
                   # need to know to what has been fixed
                   new_fix_index = variable._index
                   new_fix_parameter_name = "NODESTAT_FIXED_FLAG_VAL_"+variable.name
                   new_fix_parameter = None
                   if (len(new_fix_index) is 1) and (None in new_fix_index):
                      new_fix_parameter = Param(name=new_fix_parameter_name, mutable=True)
                   else:
                      new_fix_parameter = Param(new_fix_index, name=new_fix_parameter_name, mutable=True)
                   for newindex in new_fix_index:
                      new_fix_parameter[newindex] = False
                   tree_node._fixed_var_flag[variable.name] = new_fix_parameter
                   # now make the w hash value storage array
                   new_hash_index = variable._index
                   new_hash_parameter_name = "W_HASH_STORAGE_"+variable.name
                   new_hash_parameter = None
                   if (len(new_hash_index) is 1) and (None in new_hash_index):
                      new_hash_parameter = Param(ph._iteration_index_set, name=new_hash_parameter_name, mutable=True)
                   else:
                      new_hash_parameter = Param(new_hash_index, ph._iteration_index_set, name=new_hash_parameter_name, mutable=True)
                   for newindex in new_hash_index:
                      for i in range(0, ph._max_iterations+1):
                         # the following if-then block is a complete hack, due to the
                         # fact that we can't index by None if the Param is unary.
                         if new_hash_parameter.dim() == 1:
                            new_hash_parameter[i] = 0
                         else:
                            new_hash_parameter[newindex,i] = 0
                   tree_node._w_hash[variable.name] = new_hash_parameter
+               # need to know to what has been fixed
+               new_fix_index = new_param_index
+               new_fix_parameter_name = "NODESTAT_FIXED_FLAG_VAL_"+reference_variable.name
+               new_fix_parameter = None
+               if (len(new_fix_index) is 1) and (None in new_fix_index):
+                  new_fix_parameter = Param(name=new_fix_parameter_name, mutable=True)
+               else:
+                  new_fix_parameter = Param(new_fix_index, name=new_fix_parameter_name, mutable=True)
+               for newindex in new_fix_index:
+                  new_fix_parameter[newindex] = False
+               tree_node._fixed_var_flag[reference_variable.name] = new_fix_parameter
+               # now make the w hash value storage array
+               new_hash_index = new_param_index
+               new_hash_parameter_name = "W_HASH_STORAGE_"+reference_variable.name
+               new_hash_parameter = None
+               if (len(new_hash_index) is 1) and (None in new_hash_index):
+                  new_hash_parameter = Param(ph._iteration_index_set, name=new_hash_parameter_name, mutable=True)
+               else:
+                  new_hash_parameter = Param(new_hash_index, ph._iteration_index_set, name=new_hash_parameter_name, mutable=True)
+               for newindex in new_hash_index:
+                  for i in range(0, ph._max_iterations+1):
+                     # the following if-then block is a complete hack, due to the
+                     # fact that we can't index by None if the Param is unary.
+                     if new_hash_parameter.dim() == 1:
+                        new_hash_parameter[i] = 0
+                     else:
+                        new_hash_parameter[newindex,i] = 0
+               tree_node._w_hash[reference_variable.name] = new_hash_parameter
+                  # JPW has no idea why the following code block is here, or if it is necessary.
+                  for index in variable_indices:
+                     # IMPT: it has bitten us before in this plug-in, so I'll state the obvious:
+                     #       variable values in the last stage of a stochastic program will *not*
+                     #       have a defined _stage attribute.
+                     variable[index]._stage = stage
+               # JPW has no idea why the following code block is here, or if it is necessary.
+               for index in variable_indices:
+                  # IMPT: it has bitten us before in this plug-in, so I'll state the obvious:
+                  #       variable values in the last stage of a stochastic program will *not*
+                  #       have a defined _stage attribute.
+                  # NOTE: the use of the reference variable here, in contrast to a instance-specific
+                  #       variable, is potentially dangerous.
+                  reference_variable[index]._stage = stage
 …
    def post_iteration_0_solves(self, ph):
       for stage in ph._scenario_tree._stages:
+      for stage in ph._scenario_tree._stages[:-1]:
+         if stage != ph._scenario_tree._stages[-1]: # no blending over the final stage
+            for tree_node in stage._tree_nodes:
+               for (variable, index_template, variable_indices) in stage._variables:
+         for tree_node in stage._tree_nodes:
+            for (variable, index_template) in stage._variables:
+                  variable_name = variable.name
+                  variable_type = variable.domain
+                  for index in variable_indices:
+                     # determine if this index is used - otherwise, don't waste time
+                     # fixing and cycle checking. for one, the code will crash :-) with
+                     # none values during the cycle checking computation!
+                     is_used = True # until proven otherwise
+               variable_name = variable.name
+               variable_type = variable.domain
+               variable_indices = tree_node._variable_indices[variable_name]
+               for index in variable_indices:
+                  # determine if this index is used - otherwise, don't waste time
+                  # fixing and cycle checking. for one, the code will crash :-) with
+                  # none values during the cycle checking computation!
+                  is_used = True # until proven otherwise
+                  for scenario in tree_node._scenarios:
+                     instance = ph._instances[scenario._name]
+                     if getattr(instance,variable_name)[index].status == VarStatus.unused:
+                        is_used = False
+                  if is_used is True:
+                     # unlikely, but variables might be fixed even at this stage, depending on
+                     # what weirdness users do prior to the iteration 0 solves.
+                     instance_fixed_count = 0
                      for scenario in tree_node._scenarios:
                         instance = ph._instances[scenario._name]
+                        if getattr(instance,variable_name)[index].status == VarStatus.unused:
+                           is_used = False
+                     if is_used is True:
+                        # unlikely, but variables might be fixed even at this stage, depending on
+                        # what weirdness users do prior to the iteration 0 solves.
+                        instance_fixed_count = 0
+                        for scenario in tree_node._scenarios:
+                           instance = ph._instances[scenario._name]
+                           if getattr(instance,variable_name)[index].fixed is True:
+                              instance_fixed_count += 1
+                        if ((instance_fixed_count > 0) and (instance_fixed_count < len(tree_node._scenarios))):
+                           raise RuntimeError, "Variable="+variable_name+str(index)+" is fixed in "+str(instance_fixed_count)+" scenarios, but less than the number of scenarios at tree node="+tree_node._name
+                        if instance_fixed_count == 0:
+                           if isinstance(variable_type, IntegerSet) or isinstance(variable_type, BooleanSet):
+                              node_min = self.Int_If_Close_Enough(ph, value(tree_node._minimums[variable_name][index]))
+                              node_max = self.Int_If_Close_Enough(ph, value(tree_node._maximums[variable_name][index]))
+                              # update convergence prior to checking for fixing.
+                              self._int_convergence_tracking(ph, tree_node, variable_name, index, node_min, node_max)
+                              attrvariable = ph._model_instance.active_components(Var)[variable_name][index]
+                              if hasattr(attrvariable, 'Iter0FixIfConvergedAtLB'):
+                                 lb = getattr(attrvariable, 'Iter0FixIfConvergedAtLB')
+                              else:
+                                 lb = self.Iter0FixIfConvergedAtLB
+                              if hasattr(attrvariable, 'Iter0FixIfConvergedatUB'):
+                                 ub = getattr(attrvariable, 'Iter0FixIfConvergedAtUB')
+                              else:
+                                 ub = self.Iter0FixIfConvergedAtUB
+                              if hasattr(attrvariable, 'Iter0FixIfConvergedAtNB'):
+                                 nb = getattr(attrvariable, 'Iter0FixIfConvergedAtNB')
+                              else:
+                                 nb = self.Iter0FixIfConvergedAtNB
+                              if self._should_fix_discrete_due_to_conv(tree_node, variable, index, lb, ub, nb):
+                                 self._fix_var(ph, tree_node, variable, index, node_min)
+                              elif self.W_hash_history_len > 0:   # if not fixed, then hash - no slamming at iteration 0
+                                 self._w_hash_acct(ph, tree_node, variable_name, index) # obviously not checking for cycles at iteration 0!
+                        if getattr(instance,variable_name)[index].fixed is True:
+                           instance_fixed_count += 1
+                     if ((instance_fixed_count > 0) and (instance_fixed_count < len(tree_node._scenarios))):
+                        raise RuntimeError, "Variable="+variable_name+str(index)+" is fixed in "+str(instance_fixed_count)+" scenarios, but less than the number of scenarios at tree node="+tree_node._name
+                     if instance_fixed_count == 0:
+                        if isinstance(variable_type, IntegerSet) or isinstance(variable_type, BooleanSet):
+                           node_min = self.Int_If_Close_Enough(ph, value(tree_node._minimums[variable_name][index]))
+                           node_max = self.Int_If_Close_Enough(ph, value(tree_node._maximums[variable_name][index]))
+                           # update convergence prior to checking for fixing.
+                           self._int_convergence_tracking(ph, tree_node, variable_name, index, node_min, node_max)
+                           attrvariable = ph._model_instance.active_components(Var)[variable_name][index]
+                           if hasattr(attrvariable, 'Iter0FixIfConvergedAtLB'):
+                              lb = getattr(attrvariable, 'Iter0FixIfConvergedAtLB')
                            else:
+                              lb = self.Iter0FixIfConvergedAtLB
+                           if hasattr(attrvariable, 'Iter0FixIfConvergedatUB'):
+                              ub = getattr(attrvariable, 'Iter0FixIfConvergedAtUB')
+                           else:
+                              ub = self.Iter0FixIfConvergedAtUB
+                           if hasattr(attrvariable, 'Iter0FixIfConvergedAtNB'):
+                              nb = getattr(attrvariable, 'Iter0FixIfConvergedAtNB')
+                           else:
+                              nb = self.Iter0FixIfConvergedAtNB
+                           if self._should_fix_discrete_due_to_conv(tree_node, variable, index, lb, ub, nb):
+                              self._fix_var(ph, tree_node, variable, index, node_min)
+                           elif self.W_hash_history_len > 0:   # if not fixed, then hash - no slamming at iteration 0
+                              self._w_hash_acct(ph, tree_node, variable_name, index) # obviously not checking for cycles at iteration 0!
+                        else:
                               node_min = value(tree_node._minimums[variable_name][index])
                               node_max = value(tree_node._maximums[variable_name][index])
+                           node_min = value(tree_node._minimums[variable_name][index])
+                           node_max = value(tree_node._maximums[variable_name][index])
                               self._continuous_convergence_tracking(ph, tree_node, variable_name, index, node_min, node_max)
+                           self._continuous_convergence_tracking(ph, tree_node, variable_name, index, node_min, node_max)
 # jpw: not sure if we care about cycle detection in continuous variables?
 #                              if self.W_hash_history_len > 0:
 #                                 self._w_hash_acct(ph, tree_node, variable_name, index)
+#                           if self.W_hash_history_len > 0:
+#                              self._w_hash_acct(ph, tree_node, variable_name, index)
 …
    def post_iteration_k_solves(self, ph):
       for stage in ph._scenario_tree._stages:
+      for stage in ph._scenario_tree._stages[:-1]:
+         if stage != ph._scenario_tree._stages[-1]: # no blending over the final stage
+            for tree_node in stage._tree_nodes:
+               for (variable, index_template, variable_indices) in stage._variables:
+                  variable_name = variable.name
+                  variable_type = variable.domain
+                  for index in variable_indices:
+                     # determine if this index is used - otherwise, don't waste time
+                     # fixing and cycle checking. for one, the code will crash :-) with
+                     # None values during the cycle checking computation!
+                     is_used = True # until proven otherwise
+         for tree_node in stage._tree_nodes:
+            for (variable, index_template) in stage._variables:
+               variable_name = variable.name
+               variable_type = variable.domain
+               variable_indices = tree_node._variable_indices[variable_name]
+               for index in variable_indices:
+                  # determine if this index is used - otherwise, don't waste time
+                  # fixing and cycle checking. for one, the code will crash :-) with
+                  # None values during the cycle checking computation!
+                  is_used = True # until proven otherwise
+                  for scenario in tree_node._scenarios:
+                     instance = ph._instances[scenario._name]
+                     if getattr(instance,variable_name)[index].status == VarStatus.unused:
+                        is_used = False
+                  if is_used is True:
+                     # determine if the variable is already fixed.
+                     instance_fixed_count = 0
                      for scenario in tree_node._scenarios:
                         instance = ph._instances[scenario._name]
+                        if getattr(instance,variable_name)[index].status == VarStatus.unused:
+                           is_used = False
+                     if is_used is True:
+                        # determine if the variable is already fixed.
+                        instance_fixed_count = 0
+                        for scenario in tree_node._scenarios:
+                           instance = ph._instances[scenario._name]
+                           if getattr(instance,variable_name)[index].fixed is True:
+                              instance_fixed_count += 1
+                        if ((instance_fixed_count > 0) and (instance_fixed_count < len(tree_node._scenarios))):
+                           raise RuntimeError, "Variable="+variable_name+str(index)+" is fixed in "+str(instance_fixed_count)+" scenarios, but less than the number of scenarios at tree node="+tree_node._name
+                        if instance_fixed_count == 0:
+                           if isinstance(variable_type, IntegerSet) or isinstance(variable_type, BooleanSet):
+                              node_min = self.Int_If_Close_Enough(ph, value(tree_node._minimums[variable_name][index]))
+                              node_max = self.Int_If_Close_Enough(ph, value(tree_node._maximums[variable_name][index]))
+                              # update convergence prior to checking for fixing.
+                              self._int_convergence_tracking(ph, tree_node, variable_name, index, node_min, node_max)
+                              # now check on permissions to converge to various placed (e.g., lb is lb permission)
+                              attrvariable = ph._model_instance.active_components(Var)[variable_name][index]
+                              if hasattr(attrvariable, 'FixWhenItersConvergedAtLB'):
+                                 lb = getattr(attrvariable, 'FixWhenItersConvergedAtLB')
+                              else:
+                                 lb = self.FixWhenItersConvergedAtLB
+                              if hasattr(attrvariable, 'FixWhenItersConvergedAtUB'):
+                                 ub = getattr(attrvariable, 'FixWhenItersConvergedAtUB')
+                              else:
+                                 ub = self.FixWhenItersConvergedAtUB
+                              if hasattr(attrvariable, 'FixWhenItersConvergedAtNB'):
+                                 nb = getattr(attrvariable, 'FixWhenItersConvergedAtNB')
+                              else:
+                                 nb = self.FixWhenItersConvergedAtNB
+                        if getattr(instance,variable_name)[index].fixed is True:
+                           instance_fixed_count += 1
+                     if ((instance_fixed_count > 0) and (instance_fixed_count < len(tree_node._scenarios))):
+                        raise RuntimeError, "Variable="+variable_name+str(index)+" is fixed in "+str(instance_fixed_count)+" scenarios, but less than the number of scenarios at tree node="+tree_node._name
+                     if instance_fixed_count == 0:
+                        if isinstance(variable_type, IntegerSet) or isinstance(variable_type, BooleanSet):
+                           node_min = self.Int_If_Close_Enough(ph, value(tree_node._minimums[variable_name][index]))
+                           node_max = self.Int_If_Close_Enough(ph, value(tree_node._maximums[variable_name][index]))
+                           # update convergence prior to checking for fixing.
+                           self._int_convergence_tracking(ph, tree_node, variable_name, index, node_min, node_max)
+                           # now check on permissions to converge to various placed (e.g., lb is lb permission)
+                           attrvariable = ph._model_instance.active_components(Var)[variable_name][index]
+                           if hasattr(attrvariable, 'FixWhenItersConvergedAtLB'):
+                              lb = getattr(attrvariable, 'FixWhenItersConvergedAtLB')
+                           else:
+                              lb = self.FixWhenItersConvergedAtLB
+                           if hasattr(attrvariable, 'FixWhenItersConvergedAtUB'):
+                              ub = getattr(attrvariable, 'FixWhenItersConvergedAtUB')
+                           else:
+                              ub = self.FixWhenItersConvergedAtUB
+                           if hasattr(attrvariable, 'FixWhenItersConvergedAtNB'):
+                              nb = getattr(attrvariable, 'FixWhenItersConvergedAtNB')
+                           else:
+                              nb = self.FixWhenItersConvergedAtNB
                               if self._should_fix_discrete_due_to_conv(tree_node, variable, index, lb, ub, nb):
+                           if self._should_fix_discrete_due_to_conv(tree_node, variable, index, lb, ub, nb):
                                  self._fix_var(ph, tree_node, variable, index, node_min)
+                              self._fix_var(ph, tree_node, variable, index, node_min)
                               else: # if not fixed, then hash and slam as necessary.
+                           else: # if not fixed, then hash and slam as necessary.
+                                 if self.W_hash_history_len > 0:
+                                    self._w_hash_acct(ph, tree_node, variable_name, index)
+                                    computed_cycle_length,msg = self.hash_hit_len(ph, tree_node, variable_name, index, False)
+                                    if (computed_cycle_length >= self.CycleLengthSlamThreshold) and ((ph._current_iteration - self._last_slam_iter) > self.PH_Iters_Between_Cycle_Slams):
+                                       # TBD: we may not want to slam immediately - it may disappear on it's own after a few iterations, depending on what other variables do.
+                                       # note: we are *not* slamming the offending variable, but a selected variable
+                                       if index is None:
+                                          print "Cycle issue detected with variable="+variable_name
+                                       else:
+                                          print "Cycle issue detected with variable="+variable_name+"["+str(index)+"]"
+                                       print msg
+                                       print "Cycle length exceeds iteration slamming threshold="+str(self.CycleLengthSlamThreshold)+"; choosing a variable to slam"
+                                       self._pick_one_and_slam_it(ph)
+                                    elif (computed_cycle_length > 1) and (computed_cycle_length < self.CycleLengthSlamThreshold):
+                                       # there was a (potential) cycle, but the slam threshold wasn't reached.
+                                       if self.ReportPotentialCycles is True:
+                                          if index is None:
+                                             print "Cycle issue detected with variable="+variable_name
+                                          else:
+                                             print "Cycle issue detected with variable="+variable_name+"["+str(index)+"]"
+                                          print msg
+                                          print "Taking no action to break cycle - length="+str(computed_cycle_length)+" does not exceed slam threshold="+str(self.CycleLengthSlamThreshold)
+                                    elif (computed_cycle_length >= self.CycleLengthSlamThreshold) and ((ph._current_iteration - self._last_slam_iter) > self.PH_Iters_Between_Cycle_Slams):
+                                       # we could have slammed, but we recently did and are taking a break to see if things settle down on their own.
+                              if self.W_hash_history_len > 0:
+                                 self._w_hash_acct(ph, tree_node, variable_name, index)
+                                 computed_cycle_length,msg = self.hash_hit_len(ph, tree_node, variable_name, index, False)
+                                 if (computed_cycle_length >= self.CycleLengthSlamThreshold) and ((ph._current_iteration - self._last_slam_iter) > self.PH_Iters_Between_Cycle_Slams):
+                                    # TBD: we may not want to slam immediately - it may disappear on it's own after a few iterations, depending on what other variables do.
+                                    # note: we are *not* slamming the offending variable, but a selected variable
+                                    if index is None:
+                                       print "Cycle issue detected with variable="+variable_name
+                                    else:
+                                       print "Cycle issue detected with variable="+variable_name+"["+str(index)+"]"
+                                    print msg
+                                    print "Cycle length exceeds iteration slamming threshold="+str(self.CycleLengthSlamThreshold)+"; choosing a variable to slam"
+                                    self._pick_one_and_slam_it(ph)
+                                 elif (computed_cycle_length > 1) and (computed_cycle_length < self.CycleLengthSlamThreshold):
+                                    # there was a (potential) cycle, but the slam threshold wasn't reached.
+                                    if self.ReportPotentialCycles is True:
                                        if index is None:
                                           print "Cycle issue detected with variable="+variable_name
 …
                                           print "Cycle issue detected with variable="+variable_name+"["+str(index)+"]"
                                        print msg
+                                       print "Taking no action to break cycle - length="+str(computed_cycle_length)+" does exceed slam threshold="+str(self.CycleLengthSlamThreshold)+ \
+                                             ", but another variable was slammed within the past "+str(self.PH_Iters_Between_Cycle_Slams)+" iterations"
+                           else:
+                              # obviously don't round in the continuous case.
+                              node_min = value(tree_node._minimums[variable_name][index])
+                              node_max = value(tree_node._maximums[variable_name][index])
+                              # update convergence prior to checking for fixing.
+                              self._continuous_convergence_tracking(ph, tree_node, variable_name, index, node_min, node_max)
+                              if self._should_fix_continuous_due_to_conv(tree_node, variable, index):
+                                 # fixing to max value for safety (could only be an issue due to tolerances).
+                                 self._fix_var(ph, tree_node, variable, index, node_max)
+                                 # note: we currently don't clam continuous variables!
+                                       print "Taking no action to break cycle - length="+str(computed_cycle_length)+" does not exceed slam threshold="+str(self.CycleLengthSlamThreshold)
+                                 elif (computed_cycle_length >= self.CycleLengthSlamThreshold) and ((ph._current_iteration - self._last_slam_iter) > self.PH_Iters_Between_Cycle_Slams):
+                                    # we could have slammed, but we recently did and are taking a break to see if things settle down on their own.
+                                    if index is None:
+                                       print "Cycle issue detected with variable="+variable_name
+                                    else:
+                                       print "Cycle issue detected with variable="+variable_name+"["+str(index)+"]"
+                                    print msg
+                                    print "Taking no action to break cycle - length="+str(computed_cycle_length)+" does exceed slam threshold="+str(self.CycleLengthSlamThreshold)+ \
+                                          ", but another variable was slammed within the past "+str(self.PH_Iters_Between_Cycle_Slams)+" iterations"
+                        else:
+                           # obviously don't round in the continuous case.
+                           node_min = value(tree_node._minimums[variable_name][index])
+                           node_max = value(tree_node._maximums[variable_name][index])
+                           # update convergence prior to checking for fixing.
+                           self._continuous_convergence_tracking(ph, tree_node, variable_name, index, node_min, node_max)
+                           if self._should_fix_continuous_due_to_conv(tree_node, variable, index):
+                              # fixing to max value for safety (could only be an issue due to tolerances).
+                              self._fix_var(ph, tree_node, variable, index, node_max)
+                              # note: we currently don't clam continuous variables!
       # TBD: the 1 might need to be parameterized - TBD - the 1 should be the PH ITERATIONS BETWEEN CYCLE SLAMS

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 3220

Legend:

coopr.pysp/trunk/coopr/pysp/wwphextension.py

Download in other formats: