Merge branch 'main' into feature/3381_quadratic_obj_highs

Author: quantresearch1

Diff for: doc/OnlineDocs/explanation/experimental/solvers.rst

@@ -85,7 +85,6 @@ be used with other Pyomo tools / capabilities.
    :skipif: not ipopt_available
    :hide:
 
-   ...
    2 Var Declarations
    ...
    3 Declarations: x y obj
@@ -117,7 +116,6 @@ future methods of specifying solver options are supported:
    :skipif: not ipopt_available
    :hide:
 
-   ...
    2 Var Declarations
    ...
    3 Declarations: x y obj
@@ -154,7 +152,7 @@ Here we use the new interface by importing it directly:
    :skipif: not ipopt_available
    :hide:
 
-   solution_loader: ...
+   termination_condition: ...
    ...
    3 Declarations: x y obj
 
@@ -190,7 +188,7 @@ Here we use the new interface by retrieving it from the new ``SolverFactory``:
    :skipif: not ipopt_available
    :hide:
 
-   solution_loader: ...
+   termination_condition: ...
    ...
    3 Declarations: x y obj
 
@@ -227,7 +225,7 @@ replace the existing (legacy) SolverFactory and utilities with the new
    :skipif: not ipopt_available
    :hide:
 
-   solution_loader: ...
+   termination_condition: ...
    ...
    3 Declarations: x y obj
 
@@ -313,6 +311,37 @@ which can be manipulated similar to a standard ``dict`` in Python.
    :members:
    :undoc-members:
 
+The new interface has condensed :py:class:`~pyomo.opt.results.solver.SolverStatus`,
+:py:class:`~pyomo.opt.results.solver.TerminationCondition`,
+and :py:class:`~pyomo.opt.results.solution.SolutionStatus` into
+:py:class:`~pyomo.contrib.solver.common.results.TerminationCondition`
+and :py:class:`~pyomo.contrib.solver.common.results.SolutionStatus` to
+reduce complexity. As a result, several legacy
+:py:class:`~pyomo.opt.results.solver.SolutionStatus` values are
+no longer achievable. These are detailed in the table below.
+
+.. list-table:: Mapping from unachievable :py:class:`~pyomo.opt.results.solver.SolutionStatus`
+                to future statuses
+   :header-rows: 1
+
+   * - Legacy :py:class:`~pyomo.opt.results.solver.SolutionStatus`
+     - :py:class:`~pyomo.contrib.solver.common.results.TerminationCondition`
+     - :py:class:`~pyomo.contrib.solver.common.results.SolutionStatus`
+   * - other
+     - unknown
+     - noSolution
+   * - unsure
+     - unknown
+     - noSolution
+   * - locallyOptimal
+     - convergenceCriteriaSatisfied
+     - optimal
+   * - globallyOptimal
+     - convergenceCriteriaSatisfied
+     - optimal
+   * - bestSoFar
+     - convergenceCriteriaSatisfied
+     - feasible
 
 Termination Conditions
 ^^^^^^^^^^^^^^^^^^^^^^

Diff for: pyomo/common/tee.py

@@ -120,9 +120,11 @@ def __init__(self, fd=1, output=None, synchronize=True):
 
     def __enter__(self):
         if self.std:
+            # We used to flush original_file here.  We have removed that
+            # because the std* streams are flushed by capture_output.
+            # Flushing again here caused intermittent errors due to
+            # closed file handles on OSX
             self.original_file = getattr(sys, self.std)
-            # important: flush the current file buffer when redirecting
-            self.original_file.flush()
         # Duplicate the original standard file descriptor(file
         # descriptor 1 or 2) to a different file descriptor number
         self.original_fd = os.dup(self.fd)

Diff for: pyomo/common/tests/test_tee.py

@@ -589,8 +589,18 @@ def test_exit_on_del(self):
         remaining_attempts = 4
         while len(stack) and remaining_attempts:
             gc.collect()
+            time.sleep(((4 - remaining_attempts) / 4.0) ** 2)
             remaining_attempts -= 1
-        self.assertEqual(len(stack), 0)
+        try:
+            self.assertEqual(len(stack), 0)
+        except:
+            # We still want to unwind the context managers if the test fails:
+            while stack:
+                try:
+                    stack.pop().__exit__(None, None, None)
+                except:
+                    pass
+            raise
 
     def test_deadlock(self):
         class MockStream(object):

Diff for: pyomo/contrib/pyros/CHANGELOG.txt

@@ -3,6 +3,13 @@ PyROS CHANGELOG
 ===============
 
 
+-------------------------------------------------------------------------------
+PyROS 1.3.7    06 Mar 2025
+-------------------------------------------------------------------------------
+- Modify reformulation of state-variable independent second-stage
+  equality constraints for problems with discrete uncertainty sets
+
+
 -------------------------------------------------------------------------------
 PyROS 1.3.6    06 Mar 2025
 -------------------------------------------------------------------------------

Diff for: pyomo/contrib/pyros/pyros.py

@@ -33,7 +33,7 @@
 )
 
 
-__version__ = "1.3.6"
+__version__ = "1.3.7"
 
 
 default_pyros_solver_logger = setup_pyros_logger()

Diff for: pyomo/contrib/pyros/tests/test_grcs.py

@@ -1998,6 +1998,189 @@ def test_pyros_certain_params_ipopt_degrees_of_freedom(self):
         self.assertEqual(m.x.value, 1)
 
 
+@unittest.skipUnless(baron_available, "BARON not available")
+class TestReformulateSecondStageEqualitiesDiscrete(unittest.TestCase):
+    """
+    Test behavior of PyROS solver when the uncertainty set is
+    discrete and there are second-stage
+    equality constraints that are state-variable independent,
+    and therefore, subject to reformulation.
+    """
+
+    def build_single_stage_model(self):
+        m = ConcreteModel()
+        m.x = Var(range(3), bounds=[-2, 2], initialize=0)
+        m.q = Param(range(3), initialize=0, mutable=True)
+        m.c = Param(range(3), initialize={0: 1, 1: 0, 2: 1})
+        m.obj = Objective(expr=sum(m.x[i] * m.c[i] for i in m.x), sense=maximize)
+        # when uncertainty set is discrete, the
+        # preprocessor should write out this constraint for
+        # each scenario as a first-stage constraint
+        m.xq_con = Constraint(expr=sum(m.x[i] * m.q[i] for i in m.x) == 0)
+        return m
+
+    def build_two_stage_model(self):
+        m = ConcreteModel()
+        m.x = Var(bounds=[None, None], initialize=0)
+        m.z = Var(bounds=[-2, 2], initialize=0)
+        m.q = Param(initialize=2, mutable=True)
+        m.obj = Objective(expr=m.x + m.z, sense=maximize)
+        # when uncertainty set is discrete, the
+        # preprocessor should write out this constraint for
+        # each scenario as a first-stage constraint
+        m.xz_con = Constraint(expr=m.x + m.q * m.z == 0)
+        return m
+
+    def test_single_stage_discrete_set_fullrank(self):
+        m = self.build_single_stage_model()
+        uncertainty_set = DiscreteScenarioSet(
+            # reformulating second-stage equality for these scenarios
+            # should result in first-stage equalities finally being
+            # (full-column-rank matrix) @ (x) == 0
+            # so x=0 is sole robust feasible solution
+            scenarios=[
+                [0] * len(m.q),
+                [1] * len(m.q),
+                list(range(1, len(m.q) + 1)),
+                [(idx + 1) ** 2 for idx in m.q],
+            ]
+        )
+        baron = SolverFactory("baron")
+        res = SolverFactory("pyros").solve(
+            model=m,
+            first_stage_variables=m.x,
+            second_stage_variables=[],
+            uncertain_params=m.q,
+            uncertainty_set=uncertainty_set,
+            local_solver=baron,
+            global_solver=baron,
+            solve_master_globally=True,
+            bypass_local_separation=True,
+            objective_focus="worst_case",
+        )
+        self.assertEqual(
+            res.pyros_termination_condition, pyrosTerminationCondition.robust_optimal
+        )
+        self.assertEqual(res.iterations, 1)
+        self.assertAlmostEqual(res.final_objective_value, 0, places=4)
+        self.assertAlmostEqual(m.x[0].value, 0, places=4)
+        self.assertAlmostEqual(m.x[1].value, 0, places=4)
+        self.assertAlmostEqual(m.x[2].value, 0, places=4)
+
+    def test_single_stage_discrete_set_rank2(self):
+        m = self.build_single_stage_model()
+        uncertainty_set = DiscreteScenarioSet(
+            # reformulating second-stage equality for these scenarios
+            # should make the optimal solution unique
+            scenarios=[[0] * len(m.q), [1] * len(m.q), [(idx + 1) ** 2 for idx in m.q]]
+        )
+        baron = SolverFactory("baron")
+        res = SolverFactory("pyros").solve(
+            model=m,
+            first_stage_variables=m.x,
+            second_stage_variables=[],
+            uncertain_params=m.q,
+            uncertainty_set=uncertainty_set,
+            local_solver=baron,
+            global_solver=baron,
+            solve_master_globally=True,
+            bypass_local_separation=True,
+            objective_focus="worst_case",
+        )
+        self.assertEqual(
+            res.pyros_termination_condition, pyrosTerminationCondition.robust_optimal
+        )
+        self.assertEqual(res.iterations, 1)
+        self.assertAlmostEqual(res.final_objective_value, 2, places=4)
+        # optimal solution is unique
+        self.assertAlmostEqual(m.x[0].value, 5 / 4, places=4)
+        self.assertAlmostEqual(m.x[1].value, -2, places=4)
+        self.assertAlmostEqual(m.x[2].value, 3 / 4, places=4)
+
+    def test_single_stage_discrete_set_rank1(self):
+        m = self.build_single_stage_model()
+        uncertainty_set = DiscreteScenarioSet(
+            scenarios=[[0] * len(m.q), [2] * len(m.q), [3] * len(m.q)]
+        )
+        baron = SolverFactory("baron")
+        res = SolverFactory("pyros").solve(
+            model=m,
+            first_stage_variables=m.x,
+            second_stage_variables=[],
+            uncertain_params=m.q,
+            uncertainty_set=uncertainty_set,
+            local_solver=baron,
+            global_solver=baron,
+            solve_master_globally=True,
+            bypass_local_separation=True,
+            objective_focus="worst_case",
+        )
+        self.assertEqual(
+            res.pyros_termination_condition, pyrosTerminationCondition.robust_optimal
+        )
+        self.assertEqual(res.iterations, 1)
+        self.assertAlmostEqual(res.final_objective_value, 2, places=4)
+        # subject to these scenarios, the optimal solution is non-unique,
+        # but should satisfy this check
+        self.assertAlmostEqual(m.x[1].value, -2, places=4)
+
+    def test_two_stage_discrete_set_rank2_affine_dr(self):
+        m = self.build_two_stage_model()
+        uncertainty_set = DiscreteScenarioSet([[2], [3]])
+        baron = SolverFactory("baron")
+        res = SolverFactory("pyros").solve(
+            model=m,
+            first_stage_variables=m.x,
+            second_stage_variables=m.z,
+            uncertain_params=m.q,
+            uncertainty_set=uncertainty_set,
+            local_solver=baron,
+            global_solver=baron,
+            solve_master_globally=True,
+            bypass_local_separation=True,
+            decision_rule_order=1,
+            objective_focus="worst_case",
+        )
+        self.assertEqual(
+            res.pyros_termination_condition, pyrosTerminationCondition.robust_optimal
+        )
+        self.assertEqual(res.iterations, 1)
+        self.assertAlmostEqual(res.final_objective_value, 0, places=4)
+        # note: this solution is suboptimal (in the context of nonstatic DRs),
+        #       but follows from the current efficiency for DRs
+        #       (i.e. in first iteration, static DRs required)
+        self.assertAlmostEqual(m.x.value, 0, places=4)
+        self.assertAlmostEqual(m.z.value, 0, places=4)
+
+    def test_two_stage_discrete_set_fullrank_affine_dr(self):
+        m = self.build_two_stage_model()
+        uncertainty_set = DiscreteScenarioSet([[2], [3], [4]])
+        baron = SolverFactory("baron")
+        res = SolverFactory("pyros").solve(
+            model=m,
+            first_stage_variables=m.x,
+            second_stage_variables=m.z,
+            uncertain_params=m.q,
+            uncertainty_set=uncertainty_set,
+            local_solver=baron,
+            global_solver=baron,
+            solve_master_globally=True,
+            bypass_local_separation=True,
+            decision_rule_order=1,
+            objective_focus="worst_case",
+        )
+        self.assertEqual(
+            res.pyros_termination_condition, pyrosTerminationCondition.robust_optimal
+        )
+        self.assertEqual(res.iterations, 1)
+        self.assertAlmostEqual(res.final_objective_value, 0, places=4)
+        # the second-stage equalities are a full rank linear system
+        # in x and the DR variables, with RHS 0, so all
+        # variables must be 0
+        self.assertAlmostEqual(m.x.value, 0, places=4)
+        self.assertAlmostEqual(m.z.value, 0, places=4)
+
+
 @unittest.skipUnless(ipopt_available, "IPOPT not available.")
 class TestPyROSVarsAsUncertainParams(unittest.TestCase):
     """