Revert "Merge pull request #500 from bknueven/nonant_bounds_buffer"

This reverts commit a2e7d27, reversing
changes made to b6151cf.

Author: bknueven

mpisppy/cylinders/fwph_spoke.py

@@ -27,9 +27,6 @@ def sync(self):
         # Tell the hub about the most recent bound
         self.send_bound(self.opt._local_bound)
 
-        # Update the nonant bounds, if possible
-        self.receive_nonant_bounds()
-
     def finalize(self):
         # The FWPH spoke can call "finalize" before it
         # even starts doing anything, so its possible

mpisppy/cylinders/hub.py

@@ -12,21 +12,22 @@
 import mpisppy.log
 
 from mpisppy.cylinders.spcommunicator import RecvArray, SPCommunicator
+from math import inf
 
 from mpisppy import global_toc
 
 from mpisppy.cylinders.spwindow import Field
 
 # Could also pass, e.g., sys.stdout instead of a filename
-mpisppy.log.setup_logger(__name__,
+mpisppy.log.setup_logger("mpisppy.cylinders.Hub",
                          "hub.log",
                          level=logging.CRITICAL)
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("mpisppy.cylinders.Hub")
 
 class Hub(SPCommunicator):
 
     send_fields = (*SPCommunicator.send_fields, Field.SHUTDOWN, Field.BEST_OBJECTIVE_BOUNDS,)
-    receive_fields = (*SPCommunicator.receive_fields,)
+    receive_fields = (*SPCommunicator.receive_fields, Field.OBJECTIVE_INNER_BOUND, Field.OBJECTIVE_OUTER_BOUND, )
 
     _hub_algo_best_bound_provider = False
 
@@ -36,11 +37,17 @@ def __init__(self, spbase_object, fullcomm, strata_comm, cylinder_comm, communic
         logger.debug(f"Built the hub object on global rank {fullcomm.Get_rank()}")
         # for logging
         self.print_init = True
+        self.latest_ib_char = None
+        self.latest_ob_char = None
+        self.last_ib_idx = None
+        self.last_ob_idx = None
         # for termination based on stalling out
         self.stalled_iter_cnt = 0
         self.last_outer_bound = self.BestOuterBound
         self.last_inner_bound = self.BestInnerBound
 
+        self.initialize_bound_values()
+
         return
 
     @abc.abstractmethod
@@ -170,6 +177,72 @@ def hub_finalize(self):
             global_toc("Statistics at termination", True)
             self.screen_trace()
 
+    def receive_innerbounds(self):
+        """ Get inner bounds from inner bound spokes
+            NOTE: Does not check if there _are_ innerbound spokes
+            (but should be harmless to call if there are none)
+        """
+        logging.debug("Hub is trying to receive from InnerBounds")
+        for idx, cls, recv_buf in self.receive_field_spcomms[Field.OBJECTIVE_INNER_BOUND]:
+            is_new = self.get_receive_buffer(recv_buf, Field.OBJECTIVE_INNER_BOUND, idx)
+            if is_new:
+                bound = recv_buf[0]
+                logging.debug("!! new InnerBound to opt {}".format(bound))
+                self.BestInnerBound = self.InnerBoundUpdate(bound, cls, idx)
+        logging.debug("ph back from InnerBounds")
+
+    def receive_outerbounds(self):
+        """ Get outer bounds from outer bound spokes
+            NOTE: Does not check if there _are_ outerbound spokes
+            (but should be harmless to call if there are none)
+        """
+        logging.debug("Hub is trying to receive from OuterBounds")
+        for idx, cls, recv_buf in self.receive_field_spcomms[Field.OBJECTIVE_OUTER_BOUND]:
+            is_new = self.get_receive_buffer(recv_buf, Field.OBJECTIVE_OUTER_BOUND, idx)
+            if is_new:
+                bound = recv_buf[0]
+                logging.debug("!! new OuterBound to opt {}".format(bound))
+                self.BestOuterBound = self.OuterBoundUpdate(bound, cls, idx)
+        logging.debug("ph back from OuterBounds")
+
+    def OuterBoundUpdate(self, new_bound, cls=None, idx=None, char='*'):
+        current_bound = self.BestOuterBound
+        if self._outer_bound_update(new_bound, current_bound):
+            if cls is None:
+                self.latest_ob_char = char
+                self.last_ob_idx = 0
+            else:
+                self.latest_ob_char = cls.converger_spoke_char
+                self.last_ob_idx = idx
+            return new_bound
+        else:
+            return current_bound
+
+    def InnerBoundUpdate(self, new_bound, cls=None, idx=None, char='*'):
+        current_bound = self.BestInnerBound
+        if self._inner_bound_update(new_bound, current_bound):
+            if cls is None:
+                self.latest_ib_char = char
+                self.last_ib_idx = 0
+            else:
+                self.latest_ib_char = cls.converger_spoke_char
+                self.last_ib_idx = idx
+            return new_bound
+        else:
+            return current_bound
+
+    def initialize_bound_values(self):
+        if self.opt.is_minimizing:
+            self.BestInnerBound = inf
+            self.BestOuterBound = -inf
+            self._inner_bound_update = lambda new, old : (new < old)
+            self._outer_bound_update = lambda new, old : (new > old)
+        else:
+            self.BestInnerBound = -inf
+            self.BestOuterBound = inf
+            self._inner_bound_update = lambda new, old : (new > old)
+            self._outer_bound_update = lambda new, old : (new < old)
+
     def _populate_boundsout_cache(self, buf):
         """ Populate a given buffer with the current bounds
         """
@@ -221,7 +294,6 @@ def send_terminate(self):
         return
 
     def sync_bounds(self):
-        self.receive_nonant_bounds()
         self.receive_outerbounds()
         self.receive_innerbounds()
         self.send_boundsout()

mpisppy/cylinders/lagrangian_bounder.py

@@ -20,8 +20,6 @@ def lagrangian_prep(self):
         self.opt._create_solvers()
 
     def lagrangian(self, need_solution=True, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION):
-        # update the nonant bounds, if possible, for a tighter relaxation
-        self.receive_nonant_bounds()
         verbose = self.opt.options['verbose']
         # This is sort of a hack, but might help folks:
         if "ipopt" in self.opt.options["solver_name"]:
@@ -72,7 +70,7 @@ def do_while_waiting_for_new_Ws(self, need_solution, warmstart=sputils.Warmstart
                 self.send_bound(bound)
 
     def main(self, need_solution=False):
-        self.verbose = self.opt.options['verbose']
+        verbose = self.opt.options['verbose']
         extensions = self.opt.extensions is not None
 
         self.lagrangian_prep()