being more careful about reporting iteration 0 bounds

Author: bknueven

Diff for: mpisppy/cylinders/hub.py

@@ -470,11 +470,6 @@ def setup_hub(self):
                 "Cannot call setup_hub before memory windows are constructed"
             )
 
-        # attribute to set False if some extension
-        # modified the iteration 0 subproblems such
-        # that the trivial bound is no longer valid
-        self.use_trivial_bound = True
-
         self.initialize_spoke_indices()
         self.initialize_bound_values()
 
@@ -536,10 +531,8 @@ def sync_with_spokes(self):
         self.sync()
 
     def is_converged(self):
-        ## might as well get a bound, in this case
-        if self.opt._PHIter == 1 and self.use_trivial_bound:
-            self.BestOuterBound = self.OuterBoundUpdate(self.opt.trivial_bound)
-        self.BestOuterBound = self.OuterBoundUpdate(self.opt.best_bound_obj_val)
+        if self.opt.best_bound_obj_val is not None:
+            self.BestOuterBound = self.OuterBoundUpdate(self.opt.best_bound_obj_val)
 
         if not self.has_innerbound_spokes:
             if self.opt._PHIter == 1:

Diff for: mpisppy/extensions/reduced_costs_fixer.py

@@ -90,7 +90,6 @@ def iter0_post_solver_creation(self):
                 while not self.opt.spcomm.hub_from_spoke(self.opt.spcomm.outerbound_receive_buffers[self.reduced_costs_spoke_index], self.reduced_costs_spoke_index):
                     continue
             self.sync_with_spokes(pre_iter0 = True)
-            self.opt.spcomm.use_trivial_bound = False
         self.fix_fraction_target = self._fix_fraction_target_iter0
 
     def post_iter0_after_sync(self):
@@ -109,11 +108,14 @@ def sync_with_spokes(self, pre_iter0 = False):
             self._last_serial_number = serial_number
             reduced_costs = spcomm.outerbound_receive_buffers[idx][1:1+self.nonant_length]
             this_outer_bound = spcomm.outerbound_receive_buffers[idx][0]
-            new_outer_bound = self._update_best_outer_bound(this_outer_bound)
+            is_new_outer_bound = self._update_best_outer_bound(this_outer_bound)
+            if pre_iter0:
+                # make sure we set the bound we compute prior to iteration 0
+                self.opt.spcomm.BestOuterBound = self.opt.spcomm.OuterBoundUpdate(self._best_outer_bound, idx=idx)
             if not pre_iter0 and self._use_rc_bt:
                 self.reduced_costs_bounds_tightening(reduced_costs, this_outer_bound)
             if self._use_rc_fixer and self.fix_fraction_target > 0.0:
-                if new_outer_bound or not self._rc_fixer_require_improving_lagrangian:
+                if is_new_outer_bound or not self._rc_fixer_require_improving_lagrangian:
                     self.reduced_costs_fixing(reduced_costs)
         else:
             if self.opt.cylinder_rank == 0 and self.verbose:

Diff for: mpisppy/opt/aph.py

@@ -1067,7 +1067,8 @@ def APH_main(self, spcomm=None, finalize=True):
         # End APH-specific Prep
 
         trivial_bound = self.Iter0()
-        self.best_bound_obj_val = trivial_bound
+        if self._can_update_best_bound():
+            self.best_bound_obj_val = trivial_bound
 
         self.setup_Lens()
         self.setup_dispatchrecord()

Diff for: mpisppy/opt/ph.py

@@ -61,7 +61,8 @@ def ph_main(self, finalize=True):
         if (verbose):
             print('Calling PH Iter0 on global rank {}'.format(global_rank))
         trivial_bound = self.Iter0()
-        self.best_bound_obj_val = trivial_bound
+        if self._can_update_best_bound():
+            self.best_bound_obj_val = trivial_bound
         if (verbose):
             print ('Completed PH Iter0 on global rank {}'.format(global_rank))
         if ('asynchronousPH' in self.options) and (self.options['asynchronousPH']):

Diff for: mpisppy/opt/subgradient.py

@@ -8,11 +8,9 @@
 ###############################################################################
 
 import mpisppy.phbase
-import mpisppy.MPI as mpi
+import mpisppy.MPI as _mpi
 
-from pyomo.common.collections import ComponentSet
-
-_global_rank = mpi.COMM_WORLD.Get_rank()
+_global_rank = _mpi.COMM_WORLD.Get_rank()
 
 class Subgradient(mpisppy.phbase.PHBase):
     """ Subgradient Algorithm """
@@ -43,13 +41,14 @@ def subgradient_main(self, finalize=True):
         smoothed = self.options['smoothed']
         if smoothed != 0:
             raise RuntimeError("Cannnot use smoothing with Subgradient algorithm")
-        self.create_fixed_nonant_cache()
         self.PH_Prep(attach_prox=False, attach_smooth=smoothed)
 
         if (verbose):
             print('Calling Subgradient Iter0 on global rank {}'.format(_global_rank))
         trivial_bound = self.Iter0()
-        self.best_bound_obj_val = trivial_bound
+        # set self.best_bound_obj_val if we don't have any additional fixed variables
+        if self._can_update_best_bound():
+            self.best_bound_obj_val = trivial_bound
         if (verbose):
             print('Completed Subgradient Iter0 on global rank {}'.format(_global_rank))
 
@@ -126,21 +125,7 @@ def solve_loop(self,
         )
 
         # set self.best_bound_obj_val if we don't have any additional fixed variables
-        if self.can_update_best_bound():
+        if self._can_update_best_bound():
             self.best_bound_obj_val = self.Ebound(verbose)
 
 
-    def create_fixed_nonant_cache(self):
-        self._initial_fixed_varibles = ComponentSet()
-        for s in self.local_scenarios.values():
-            for v in s._mpisppy_data.nonant_indices.values():
-                if v.fixed:
-                    self._initial_fixed_varibles.add(v)
-
-    def can_update_best_bound(self):
-        for s in self.local_scenarios.values():
-            for v in s._mpisppy_data.nonant_indices.values():
-                if v.fixed:
-                    if v not in self._initial_fixed_varibles:
-                        return False
-        return True

Diff for: mpisppy/phbase.py

@@ -931,6 +931,10 @@ def _vb(msg):
         if have_extensions:
             self.extobject.post_iter0()
 
+        self.trivial_bound = self.Ebound(verbose)
+        if self._can_update_best_bound():
+            self.best_bound_obj_val = self.trivial_bound
+
         if self.spcomm is not None:
             self.spcomm.sync()
 
@@ -955,8 +959,6 @@ def _vb(msg):
         #global_toc('Rank: {} - Before iter loop'.format(self.cylinder_rank), True)
         self.conv = None
 
-        self.trivial_bound = self.Ebound(verbose)
-
         if dprogress and self.cylinder_rank == 0:
             print("")
             print("After PH Iteration",self._PHIter)
@@ -1000,6 +1002,10 @@ def iterk_loop(self):
         self.conv = None
 
         max_iterations = int(self.options["PHIterLimit"])
+        if self.spcomm is not None:
+            # print a screen trace for iteration 0
+            if self.spcomm.is_converged():
+                global_toc("Cylinder convergence", self.cylinder_rank == 0)
 
         for self._PHIter in range(1, max_iterations+1):
             iteration_start_time = time.time()
@@ -1159,6 +1165,5 @@ def attach_xbars(self):
                 scenario._mpisppy_data.nonant_indices.keys(), initialize=0.0, mutable=True
             )
 
-
 if __name__ == "__main__":
     print ("No main for PHBase")

Diff for: mpisppy/spopt.py

@@ -19,6 +19,7 @@
 
 import pyomo.environ as pyo
 from pyomo.opt import SolverFactory
+from pyomo.common.collections import ComponentSet
 
 from mpisppy.spbase import SPBase
 import mpisppy.utils.sputils as sputils
@@ -65,6 +66,7 @@ def __init__(
             #       object to get garbage collected to
             #       free the memory the C++ model uses.
             SPPresolve(self).presolve()
+        self._create_fixed_nonant_cache()
         self.current_solver_options = None
         self.extensions = extensions
         self.extension_kwargs = extension_kwargs
@@ -940,6 +942,20 @@ def _create_solvers(self, presolve=True):
                     print("Set instance times: \tmin=%4.2f mean=%4.2f max=%4.2f" %
                       (np.min(asit), np.mean(asit), np.max(asit)))
 
+    def _create_fixed_nonant_cache(self):
+        self._initial_fixed_varibles = ComponentSet()
+        for s in self.local_scenarios.values():
+            for v in s._mpisppy_data.nonant_indices.values():
+                if v.fixed:
+                    self._initial_fixed_varibles.add(v)
+
+    def _can_update_best_bound(self):
+        for s in self.local_scenarios.values():
+            for v in s._mpisppy_data.nonant_indices.values():
+                if v.fixed:
+                    if v not in self._initial_fixed_varibles:
+                        return False
+        return True
 
     def subproblem_scenario_generator(self):
         """