Merge branch 'main' into dispatcher-simplification

Author: jsiirola

doc/OnlineDocs/src/expr/managing.py

@@ -181,7 +181,7 @@ def clone_expression(expr):
 # x[0] + 5*x[1]
 print(str(ce))
 # x[0] + 5*x[1]
-print(e.arg(0) is not ce.arg(0))
+print(e.arg(0) is ce.arg(0))
 # True
 print(e.arg(1) is not ce.arg(1))
 # True

pyomo/contrib/appsi/cmodel/src/expression.cpp

@@ -1548,7 +1548,10 @@ appsi_operator_from_pyomo_expr(py::handle expr, py::handle var_map,
     break;
   }
   case param: {
-    res = param_map[expr_types.id(expr)].cast<std::shared_ptr<Node>>();
+    if (expr.attr("parent_component")().attr("mutable").cast<bool>())
+        res = param_map[expr_types.id(expr)].cast<std::shared_ptr<Node>>();
+    else
+        res = std::make_shared<Constant>(expr.attr("value").cast<double>());
     break;
   }
   case product: {
@@ -1789,7 +1792,8 @@ int build_expression_tree(py::handle pyomo_expr,
 
   if (expr_types.expr_type_map[py::type::of(pyomo_expr)].cast<ExprType>() ==
       named_expr)
-    pyomo_expr = pyomo_expr.attr("expr");
+    return build_expression_tree(pyomo_expr.attr("expr"), appsi_expr, var_map,
+                                 param_map, expr_types);
 
   if (appsi_expr->is_leaf()) {
     ;

pyomo/contrib/appsi/solvers/ipopt.py

@@ -147,6 +147,7 @@ def __init__(self, only_child_vars=False):
         self._primal_sol = ComponentMap()
         self._reduced_costs = ComponentMap()
         self._last_results_object: Optional[Results] = None
+        self._version_timeout = 2
 
     def available(self):
         if self.config.executable.path() is None:
@@ -158,7 +159,7 @@ def available(self):
     def version(self):
         results = subprocess.run(
             [str(self.config.executable), '--version'],
-            timeout=1,
+            timeout=self._version_timeout,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             universal_newlines=True,

pyomo/contrib/appsi/solvers/tests/test_persistent_solvers.py

@@ -918,6 +918,27 @@ def test_bounds_with_params(
         res = opt.solve(m)
         self.assertAlmostEqual(m.y.value, 3)
 
+    @parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
+    def test_bounds_with_immutable_params(
+        self, name: str, opt_class: Type[PersistentSolver], only_child_vars
+    ):
+        # this test is for issue #2574
+        opt: PersistentSolver = opt_class(only_child_vars=only_child_vars)
+        if not opt.available():
+            raise unittest.SkipTest
+        m = pe.ConcreteModel()
+        m.p = pe.Param(mutable=False, initialize=1)
+        m.q = pe.Param([1, 2], mutable=False, initialize=10)
+        m.y = pe.Var()
+        m.y.setlb(m.p)
+        m.y.setub(m.q[1])
+        m.obj = pe.Objective(expr=m.y)
+        res = opt.solve(m)
+        self.assertAlmostEqual(m.y.value, 1)
+        m.y.setlb(m.q[2])
+        res = opt.solve(m)
+        self.assertAlmostEqual(m.y.value, 10)
+
     @parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
     def test_solution_loader(
         self, name: str, opt_class: Type[PersistentSolver], only_child_vars

pyomo/contrib/appsi/tests/test_fbbt.py

@@ -151,3 +151,16 @@ def test_named_exprs(self):
         for x in m.x.values():
             self.assertAlmostEqual(x.lb, 0)
             self.assertAlmostEqual(x.ub, 0)
+
+    def test_named_exprs_nest(self):
+        # test for issue #3184
+        m = pe.ConcreteModel()
+        m.x = pe.Var()
+        m.e = pe.Expression(expr=m.x + 1)
+        m.f = pe.Expression(expr=m.e)
+        m.c = pe.Constraint(expr=(0, m.f, 0))
+        it = appsi.fbbt.IntervalTightener()
+        it.perform_fbbt(m)
+        for x in m.x.values():
+            self.assertAlmostEqual(x.lb, -1)
+            self.assertAlmostEqual(x.ub, -1)

pyomo/contrib/incidence_analysis/scc_solver.py

@@ -18,13 +18,14 @@
     IncidenceGraphInterface,
     _generate_variables_in_constraints,
 )
+from pyomo.contrib.incidence_analysis.config import IncidenceMethod
 
 
 _log = logging.getLogger(__name__)
 
 
 def generate_strongly_connected_components(
-    constraints, variables=None, include_fixed=False
+    constraints, variables=None, include_fixed=False, igraph=None
 ):
     """Yield in order ``_BlockData`` that each contain the variables and
     constraints of a single diagonal block in a block lower triangularization
@@ -41,9 +42,12 @@ def generate_strongly_connected_components(
     variables: List of Pyomo variable data objects
         Variables that may participate in strongly connected components.
         If not provided, all variables in the constraints will be used.
-    include_fixed: Bool
+    include_fixed: Bool, optional
         Indicates whether fixed variables will be included when
         identifying variables in constraints.
+    igraph: IncidenceGraphInterface, optional
+        Incidence graph containing (at least) the provided constraints
+        and variables.
 
     Yields
     ------
@@ -55,11 +59,17 @@ def generate_strongly_connected_components(
     """
     if variables is None:
         variables = list(
-            _generate_variables_in_constraints(constraints, include_fixed=include_fixed)
+            _generate_variables_in_constraints(
+                constraints,
+                include_fixed=include_fixed,
+                method=IncidenceMethod.ampl_repn,
+            )
         )
 
     assert len(variables) == len(constraints)
-    igraph = IncidenceGraphInterface()
+    if igraph is None:
+        igraph = IncidenceGraphInterface()
+
     var_blocks, con_blocks = igraph.block_triangularize(
         variables=variables, constraints=constraints
     )
@@ -73,7 +83,7 @@ def generate_strongly_connected_components(
 
 
 def solve_strongly_connected_components(
-    block, solver=None, solve_kwds=None, calc_var_kwds=None
+    block, *, solver=None, solve_kwds=None, use_calc_var=True, calc_var_kwds=None
 ):
     """Solve a square system of variables and equality constraints by
     solving strongly connected components individually.
@@ -98,6 +108,9 @@ def solve_strongly_connected_components(
         a solve method.
     solve_kwds: Dictionary
         Keyword arguments for the solver's solve method
+    use_calc_var: Bool
+        Whether to use ``calculate_variable_from_constraint`` for one-by-one
+        square system solves
     calc_var_kwds: Dictionary
         Keyword arguments for calculate_variable_from_constraint
 
@@ -112,23 +125,28 @@ def solve_strongly_connected_components(
         calc_var_kwds = {}
 
     igraph = IncidenceGraphInterface(
-        block, active=True, include_fixed=False, include_inequality=False
+        block,
+        active=True,
+        include_fixed=False,
+        include_inequality=False,
+        method=IncidenceMethod.ampl_repn,
     )
     constraints = igraph.constraints
     variables = igraph.variables
 
     res_list = []
     log_blocks = _log.isEnabledFor(logging.DEBUG)
-    for scc, inputs in generate_strongly_connected_components(constraints, variables):
-        with TemporarySubsystemManager(to_fix=inputs):
+    for scc, inputs in generate_strongly_connected_components(
+        constraints, variables, igraph=igraph
+    ):
+        with TemporarySubsystemManager(to_fix=inputs, remove_bounds_on_fix=True):
             N = len(scc.vars)
-            if N == 1:
+            if N == 1 and use_calc_var:
                 if log_blocks:
                     _log.debug(f"Solving 1x1 block: {scc.cons[0].name}.")
                 results = calculate_variable_from_constraint(
                     scc.vars[0], scc.cons[0], **calc_var_kwds
                 )
-                res_list.append(results)
             else:
                 if solver is None:
                     var_names = [var.name for var in scc.vars.values()][:10]
@@ -142,5 +160,5 @@ def solve_strongly_connected_components(
                 if log_blocks:
                     _log.debug(f"Solving {N}x{N} block.")
                 results = solver.solve(scc, **solve_kwds)
-                res_list.append(results)
+            res_list.append(results)
     return res_list