adding method to update nonant bounds; call that method where appropriate

Author: bknueven

Diff for: mpisppy/cylinders/fwph_spoke.py

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

Diff for: mpisppy/cylinders/hub.py

@@ -311,6 +311,7 @@ def sync(self):
         self.update_receive_buffers()
         self.update_outerbounds()
         self.update_innerbounds()
+        self.update_nonant_bounds()
         if self.opt.extensions is not None:
             self.opt.extobject.sync_with_spokes()
 
@@ -321,6 +322,7 @@ def sync_bounds(self):
         self.update_receive_buffers()
         self.update_outerbounds()
         self.update_innerbounds()
+        self.update_nonant_bounds()
         self.send_boundsout()
 
     def sync_extensions(self):
@@ -424,6 +426,7 @@ def sync(self, send_nonants=True):
         self.update_receive_buffers()
         self.update_innerbounds()
         self.update_outerbounds()
+        self.update_nonant_bounds()
         # in case LShaped ever gets extensions
         if getattr(self.opt, "extensions", None) is not None:
             self.opt.extobject.sync_with_spokes()

Diff for: mpisppy/cylinders/lagrangian_bounder.py

@@ -19,6 +19,8 @@ def lagrangian_prep(self):
         self.opt._create_solvers()
 
     def lagrangian(self, need_solution=True):
+        # update the nonant bounds, if possible, for a tighter relaxation
+        self.update_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"]:

Diff for: mpisppy/cylinders/spcommunicator.py

@@ -116,7 +116,7 @@ class SPCommunicator:
         or expects to receive from another SPCommunicator object.
     """
     send_fields = ()
-    receive_fields = ()
+    receive_fields = (Field.NONANT_LOWER_BOUNDS, Field.NONANT_UPPER_BOUNDS,)
 
     def __init__(self, spbase_object, fullcomm, strata_comm, cylinder_comm, communicators, options=None):
         self.fullcomm = fullcomm
@@ -138,7 +138,7 @@ def __init__(self, spbase_object, fullcomm, strata_comm, cylinder_comm, communic
         # Common fields for spokes and hubs
         self.receive_buffers = {}
         self.send_buffers = {}
-        # key: Field, value: list of (strata_rank, SPComm) with that Field
+        # key: Field, value: list of (strata_rank, SPComm, buffer) with that Field
         self.receive_field_spcomms = {}
 
         # setup FieldLengths which calculates
@@ -378,3 +378,27 @@ def update_receive_buffers(self):
             self.get_receive_buffer(recv_buf, field, rank)
         ## End for
         return
+
+    def update_nonant_bounds(self):
+        """ update the bounds on the nonanticipative variables based on
+        Field.NONANT_LOWER_BOUNDS and Field.NONANT_UPPER_BOUNDS. The lower and
+        upper bound buffers should be up-to-date, which can be done by calling
+        `SPCommunicator.update_receive_buffers`.
+        """
+        _INF = float("inf")
+        for _, _, recv_buf in self.receive_field_spcomms[Field.NONANT_LOWER_BOUNDS]:
+            for s in self.opt.local_scenarios.items():
+                for ci, (ndn_i, xvar) in enumerate(s._mpisppy_data.nonant_indices.items()):
+                    xvarlb = xvar.lb
+                    if xvarlb is None:
+                        xvarlb = -_INF
+                    if recv_buf[ci] > xvarlb:
+                        xvar.lb = recv_buf[ci]
+        for _, _, recv_buf in self.receive_field_spcomms[Field.NONANT_UPPER_BOUNDS]:
+            for s in self.opt.local_scenarios.items():
+                for ci, (ndn_i, xvar) in enumerate(s._mpisppy_data.nonant_indices.items()):
+                    xvarub = xvar.ub
+                    if xvarub is None:
+                        xvarub = _INF
+                    if recv_buf[ci] < xvarub:
+                        xvar.ub = recv_buf[ci]