factoring out ph_main

Author: bknueven

Diff for: mpisppy/opt/ph.py

@@ -28,13 +28,16 @@ class PH(mpisppy.phbase.PHBase):
     # uncomment the line below to get per-rank profile outputs, which can 
     # be examined with snakeviz (or your favorite profile output analyzer)
     #@profile(filename="profile_out")
-    def ph_main(self, finalize=True):
+    def ph_main(self, finalize=True, attach_prox=True):
         """ Execute the PH algorithm.
 
         Args:
             finalize (bool, optional, default=True):
                 If True, call `PH.post_loops()`, if False, do not,
                 and return None for Eobj
+            attach_prox (bool, optional, default=True):
+                If True, use a proximal term, if False, no proximal
+                term is added to the objective function
 
         Returns:
             tuple:
@@ -56,15 +59,15 @@ def ph_main(self, finalize=True):
         """
         verbose = self.options['verbose']
         smoothed = self.options['smoothed']
-        self.PH_Prep(attach_smooth = smoothed)
+        self.PH_Prep(attach_prox=attach_prox, attach_smooth = smoothed)
 
         if (verbose):
-            print('Calling PH Iter0 on global rank {}'.format(global_rank))
+            print(f'Calling {self.__class__.__name__} Iter0 on global rank {global_rank}')
         trivial_bound = self.Iter0()
         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))
+            print(f'Completed {self.__class__.__name__} Iter0 on global rank {global_rank}')
         if ('asynchronousPH' in self.options) and (self.options['asynchronousPH']):
             raise RuntimeError("asynchronousPH is deprecated; use APH")
 

Diff for: mpisppy/opt/subgradient.py

@@ -37,33 +37,13 @@ def subgradient_main(self, finalize=True):
                     The "trivial bound", computed by solving the model with no
                     nonanticipativity constraints (immediately after iter 0).
         """
-        verbose = self.options['verbose']
-        smoothed = self.options['smoothed']
-        if smoothed != 0:
-            raise RuntimeError("Cannnot use smoothing with Subgradient algorithm")
-        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()
-        # 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))
-
-        self.iterk_loop()
-
-        if finalize:
-            Eobj = self.post_loops(self.extensions)
-        else:
-            Eobj = None
-
-        return self.conv, Eobj, trivial_bound
+        return self.ph_main(finalize=finalize)
 
     def ph_main(self, finalize=True):
-        # for working with a PHHub
-        return self.subgradient_main(finalize=finalize)
+        # for use with the PH hub
+        if self.options["smoothed"] != 0:
+            raise RuntimeError("Cannnot use smoothing with Subgradient algorithm")
+        return super().ph_main(finalize=finalize, attach_prox=False)
 
     def solve_loop(self,
                    solver_options=None,