Observer gurobi refactor

pyomo/contrib/observer/component_collector.py

@@ -33,6 +33,7 @@
 from pyomo.core.base.param import ParamData, ScalarParam
 from pyomo.core.base.expression import ExpressionData, ScalarExpression
 from pyomo.repn.util import ExitNodeDispatcher
+from pyomo.common.numeric_types import native_numeric_types
 from pyomo.common.collections import ComponentSet
 
 
@@ -80,8 +81,6 @@ def handle_skip(node, collector):
 collector_handlers[RangedExpression] = handle_skip
 collector_handlers[InequalityExpression] = handle_skip
 collector_handlers[EqualityExpression] = handle_skip
-collector_handlers[int] = handle_skip
-collector_handlers[float] = handle_skip
 
 
 class _ComponentFromExprCollector(StreamBasedExpressionVisitor):
@@ -93,6 +92,10 @@ def __init__(self, **kwds):
         super().__init__(**kwds)
 
     def exitNode(self, node, data):
+        if type(node) in native_numeric_types:
+            # we need this here to handle numpy
+            # (we can't put numpy in the dispatcher?)
+            return None
         return collector_handlers[node.__class__](node, self)
 
     def beforeChild(self, node, child, child_idx):

pyomo/contrib/observer/model_observer.py

@@ -910,7 +910,7 @@ def _update_variables(self, variables: Optional[Collection[VarData]] = None):
             reason = Reason.no_change
             if _fixed != fixed:
                 reason |= Reason.fixed
-            elif _fixed and (value != _value):
+            elif (_fixed or fixed) and (value != _value):
                 reason |= Reason.value
             if lb is not _lb or ub is not _ub:
                 reason |= Reason.bounds

pyomo/contrib/solver/common/base.py

@@ -321,22 +321,6 @@ def set_objective(self, obj: ObjectiveData):
             f"Derived class {self.__class__.__name__} failed to implement required method 'set_objective'."
         )
 
-    def add_variables(self, variables: List[VarData]):
-        """
-        Add variables to the model.
-        """
-        raise NotImplementedError(
-            f"Derived class {self.__class__.__name__} failed to implement required method 'add_variables'."
-        )
-
-    def add_parameters(self, params: List[ParamData]):
-        """
-        Add parameters to the model.
-        """
-        raise NotImplementedError(
-            f"Derived class {self.__class__.__name__} failed to implement required method 'add_parameters'."
-        )
-
     def add_constraints(self, cons: List[ConstraintData]):
         """
         Add constraints to the model.
@@ -353,22 +337,6 @@ def add_block(self, block: BlockData):
             f"Derived class {self.__class__.__name__} failed to implement required method 'add_block'."
         )
 
-    def remove_variables(self, variables: List[VarData]):
-        """
-        Remove variables from the model.
-        """
-        raise NotImplementedError(
-            f"Derived class {self.__class__.__name__} failed to implement required method 'remove_variables'."
-        )
-
-    def remove_parameters(self, params: List[ParamData]):
-        """
-        Remove parameters from the model.
-        """
-        raise NotImplementedError(
-            f"Derived class {self.__class__.__name__} failed to implement required method 'remove_parameters'."
-        )
-
     def remove_constraints(self, cons: List[ConstraintData]):
         """
         Remove constraints from the model.

pyomo/contrib/solver/common/solution_loader.py

@@ -9,7 +9,7 @@
 #  This software is distributed under the 3-clause BSD License.
 #  ___________________________________________________________________________
 
-from typing import Sequence, Dict, Optional, Mapping, NoReturn
+from typing import Sequence, Dict, Optional, Mapping
 
 from pyomo.core.base.constraint import ConstraintData
 from pyomo.core.base.var import VarData
@@ -23,7 +23,7 @@ class SolutionLoaderBase:
     Intent of this class and its children is to load the solution back into the model.
     """
 
-    def load_vars(self, vars_to_load: Optional[Sequence[VarData]] = None) -> NoReturn:
+    def load_vars(self, vars_to_load: Optional[Sequence[VarData]] = None) -> None:
         """
         Load the solution of the primal variables into the value attribute of the variables.
 

pyomo/contrib/solver/plugins.py

@@ -12,9 +12,9 @@
 
 from .common.factory import SolverFactory
 from .solvers.ipopt import Ipopt, LegacyIpoptSolver
-from .solvers.gurobi_persistent import GurobiPersistent
-from .solvers.gurobi_direct import GurobiDirect
-from .solvers.gurobi_direct_minlp import GurobiDirectMINLP
+from .solvers.gurobi.gurobi_direct import GurobiDirect
+from .solvers.gurobi.gurobi_persistent import GurobiPersistent
+from .solvers.gurobi.gurobi_direct_minlp import GurobiDirectMINLP
 from .solvers.highs import Highs
 from .solvers.knitro.direct import KnitroDirectSolver
 

pyomo/contrib/solver/solvers/gurobi/__init__.py

@@ -0,0 +1,3 @@
+from .gurobi_direct import GurobiDirect
+from .gurobi_persistent import GurobiPersistent
+from .gurobi_direct_minlp import GurobiDirectMINLP

pyomo/contrib/solver/solvers/gurobi/gurobi_direct.py

@@ -0,0 +1,157 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2025
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+
+import operator
+
+from pyomo.common.collections import ComponentMap, ComponentSet
+from pyomo.common.shutdown import python_is_shutting_down
+from pyomo.core.staleflag import StaleFlagManager
+from pyomo.repn.plugins.standard_form import LinearStandardFormCompiler
+
+from pyomo.contrib.solver.common.util import (
+    NoDualsError,
+    NoReducedCostsError,
+    NoSolutionError,
+    IncompatibleModelError,
+)
+from pyomo.contrib.solver.common.solution_loader import SolutionLoaderBase
+from .gurobi_direct_base import (
+    GurobiDirectBase,
+    gurobipy,
+    GurobiDirectSolutionLoaderBase,
+)
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class GurobiDirectSolutionLoader(GurobiDirectSolutionLoaderBase):
+    def __init__(self, solver_model, pyomo_vars, gurobi_vars, con_map) -> None:
+        super().__init__(solver_model)
+        self._pyomo_vars = pyomo_vars
+        self._gurobi_vars = gurobi_vars
+        self._con_map = con_map
+
+    def _var_pair_iter(self):
+        return zip(self._pyomo_vars, self._gurobi_vars)
+
+    def _get_var_map(self):
+        return ComponentMap(self._var_pair_iter())
+
+    def _get_con_map(self):
+        return self._con_map
+
+    def __del__(self):
+        super().__del__()
+        if python_is_shutting_down():
+            return
+        # Free the associated model
+        if self._solver_model is not None:
+            self._var_map = None
+            self._con_map = None
+            # explicitly release the model
+            self._solver_model.dispose()
+            self._solver_model = None
+
+
+class GurobiDirect(GurobiDirectBase):
+    _minimum_version = (9, 0, 0)
+
+    def __init__(self, **kwds):
+        super().__init__(**kwds)
+        self._gurobi_vars = None
+        self._pyomo_vars = None
+
+    def _pyomo_gurobi_var_iter(self):
+        return zip(self._pyomo_vars, self._gurobi_vars)
+
+    def _create_solver_model(self, pyomo_model, config):
+        timer = config.timer
+
+        timer.start('compile_model')
+        repn = LinearStandardFormCompiler().write(
+            pyomo_model, mixed_form=True, set_sense=None
+        )
+        timer.stop('compile_model')
+
+        if len(repn.objectives) > 1:
+            raise IncompatibleModelError(
+                f"The {self.__class__.__name__} solver only supports models "
+                f"with zero or one objectives (received {len(repn.objectives)})."
+            )
+
+        timer.start('prepare_matrices')
+        inf = float('inf')
+        ninf = -inf
+        bounds = list(map(operator.attrgetter('bounds'), repn.columns))
+        lb = [ninf if _b is None else _b for _b in map(operator.itemgetter(0), bounds)]
+        ub = [inf if _b is None else _b for _b in map(operator.itemgetter(1), bounds)]
+        CON = gurobipy.GRB.CONTINUOUS
+        BIN = gurobipy.GRB.BINARY
+        INT = gurobipy.GRB.INTEGER
+        vtype = [
+            (
+                CON
+                if v.is_continuous()
+                else BIN if v.is_binary() else INT if v.is_integer() else '?'
+            )
+            for v in repn.columns
+        ]
+        sense_type = list('=<>')  # Note: ordering matches 0, 1, -1
+        sense = [sense_type[r[1]] for r in repn.rows]
+        timer.stop('prepare_matrices')
+
+        gurobi_model = gurobipy.Model(env=self.env())
+
+        timer.start('transfer_model')
+        x = gurobi_model.addMVar(
+            len(repn.columns),
+            lb=lb,
+            ub=ub,
+            obj=repn.c.todense()[0] if repn.c.shape[0] else 0,
+            vtype=vtype,
+        )
+        A = gurobi_model.addMConstr(repn.A, x, sense, repn.rhs)
+        if repn.c.shape[0]:
+            gurobi_model.setAttr('ObjCon', repn.c_offset[0])
+            gurobi_model.setAttr('ModelSense', int(repn.objectives[0].sense))
+        # Note: calling gurobi_model.update() here is not
+        # necessary (it will happen as part of optimize()):
+        # gurobi_model.update()
+        timer.stop('transfer_model')
+
+        self._pyomo_vars = repn.columns
+        timer.start('tolist')
+        self._gurobi_vars = x.tolist()
+        timer.stop('tolist')
+
+        timer.start('create maps')
+        timer.start('con map')
+        con_map = {}
+        for row, gc in zip(repn.rows, A.tolist()):
+            pc = row.constraint
+            if pc in con_map:
+                # range constraint
+                con_map[pc] = (con_map[pc], gc)
+            else:
+                con_map[pc] = gc
+        timer.stop('con map')
+        timer.stop('create maps')
+        solution_loader = GurobiDirectSolutionLoader(
+            solver_model=gurobi_model,
+            pyomo_vars=self._pyomo_vars,
+            gurobi_vars=self._gurobi_vars,
+            con_map=con_map,
+        )
+        has_obj = len(repn.objectives) > 0
+
+        return gurobi_model, solution_loader, has_obj