[Depends on #3703] Direct and Persistent Interfaces to SCIP

.github/workflows/test_branches.yml

@@ -328,6 +328,12 @@ jobs:
                 || echo "WARNING: Xpress Community Edition is not available"
             python -m pip install --cache-dir cache/pip maingopy \
                 || echo "WARNING: MAiNGO is not available"
+            if [[ ${{matrix.python}} == pypy* ]]; then
+                echo "skipping SCIP for pypy"
+            else
+                python -m pip install --cache-dir cache/pip pyscipopt \
+                    || echo "WARNING: SCIP is not available"
+            fi
             if [[ ${{matrix.python}} == pypy* ]]; then
                 echo "skipping wntr for pypy"
             else
@@ -415,7 +421,7 @@ jobs:
             else
                 XPRESS='xpress'
             fi
-            for PKG in "$CPLEX" docplex gurobi "$XPRESS" cyipopt pymumps scip; do
+            for PKG in "$CPLEX" docplex gurobi "$XPRESS" cyipopt pymumps scip pyscipopt; do
                 echo ""
                 echo "*** Install $PKG ***"
                 echo ""

.github/workflows/test_pr_and_main.yml

@@ -380,6 +380,12 @@ jobs:
                 || echo "WARNING: Xpress Community Edition is not available"
             python -m pip install --cache-dir cache/pip maingopy \
                 || echo "WARNING: MAiNGO is not available"
+            if [[ ${{matrix.python}} == pypy* ]]; then
+                echo "skipping SCIP for pypy"
+            else
+                python -m pip install --cache-dir cache/pip pyscipopt \
+                    || echo "WARNING: SCIP is not available"
+            fi
             if [[ ${{matrix.python}} == pypy* ]]; then
                 echo "skipping wntr for pypy"
             else
@@ -467,7 +473,7 @@ jobs:
             else
                 XPRESS='xpress'
             fi
-            for PKG in "$CPLEX" docplex gurobi "$XPRESS" cyipopt pymumps scip; do
+            for PKG in "$CPLEX" docplex gurobi "$XPRESS" cyipopt pymumps scip pyscipopt; do
                 echo ""
                 echo "*** Install $PKG ***"
                 echo ""

pyomo/contrib/observer/model_observer.py

@@ -739,6 +739,7 @@ def remove_objectives(self, objs: Collection[ObjectiveData]):
     def _check_for_unknown_active_components(self):
         for ctype in self._model.collect_ctypes(active=True, descend_into=True):
             if not issubclass(ctype, ActiveComponent):
+                # strangely, this is needed to skip things like Param
                 continue
             if ctype in self._known_active_ctypes:
                 continue

pyomo/contrib/solver/common/results.py

@@ -21,6 +21,8 @@
     ADVANCED_OPTION,
     DEVELOPER_OPTION,
 )
+from pyomo.contrib.solver.common.util import NoOptimalSolutionError, NoSolutionError
+from pyomo.contrib.solver.common.solution_loader import NoSolutionSolutionLoader
 from pyomo.opt.results.solution import SolutionStatus as LegacySolutionStatus
 from pyomo.opt.results.solver import (
     TerminationCondition as LegacyTerminationCondition,
@@ -242,6 +244,24 @@ def display(
         return super().display(content_filter, indent_spacing, ostream, visibility)
 
 
+def get_infeasible_results(config, err_msg, solver_name, solver_version):
+    res = Results()
+    res.solution_loader = NoSolutionSolutionLoader(err_msg)
+    res.solution_status = SolutionStatus.noSolution
+    res.termination_condition = TerminationCondition.provenInfeasible
+    res.incumbent_objective = None
+    res.objective_bound = None
+    res.timing_info.gurobi_time = None
+    res.solver_config = config
+    res.solver_name = solver_name
+    res.solver_version = solver_version
+    if config.raise_exception_on_nonoptimal_result:
+        raise NoOptimalSolutionError(err_msg)
+    if config.load_solutions:
+        raise NoSolutionError(err_msg)
+    return res
+
+
 # Everything below here preserves backwards compatibility
 
 legacy_termination_condition_map = {

pyomo/contrib/solver/common/solution_loader.py

@@ -19,6 +19,10 @@
 from pyomo.core.base.var import VarData
 from pyomo.core.staleflag import StaleFlagManager
 from pyomo.core.base.suffix import Suffix
+from .util import NoSolutionError
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class SolutionLoader:
@@ -331,6 +335,29 @@ def load_import_suffixes(self):
             return self._loader.load_import_suffixes()
 
 
+class NoSolutionSolutionLoader(SolutionLoader):
+    def __init__(self, err_msg: str) -> None:
+        self.err_msg = err_msg
+
+    def get_number_of_solutions(self) -> int:
+        return 0
+
+    def get_vars(
+        self, vars_to_load: Sequence[VarData] | None = None
+    ) -> Mapping[VarData, float]:
+        raise NoSolutionError(self.err_msg)
+
+    def get_duals(
+        self, cons_to_load: Sequence[ConstraintData] | None = None
+    ) -> dict[ConstraintData, float]:
+        raise NoSolutionError(self.err_msg)
+
+    def get_reduced_costs(
+        self, vars_to_load: Sequence[VarData] | None = None
+    ) -> Mapping[VarData, float]:
+        raise NoSolutionError(self.err_msg)
+
+
 class PersistentSolutionLoader(SolutionLoader):
     """
     Loader for persistent solvers

pyomo/contrib/solver/plugins.py

@@ -14,6 +14,7 @@
 from .solvers.gurobi.gurobi_persistent import GurobiPersistent
 from .solvers.gurobi.gurobi_direct_minlp import GurobiDirectMINLP
 from .solvers.highs import Highs
+from .solvers.scip.scip_direct import ScipDirect, ScipPersistent
 from .solvers.gams import GAMS
 from .solvers.knitro.direct import KnitroDirectSolver
 
@@ -43,6 +44,16 @@ def load():
     SolverFactory.register(name='gams', legacy_name='gams_v2', doc='Interface to GAMS')(
         GAMS
     )
+    SolverFactory.register(
+        name='scip_direct',
+        legacy_name='scip_direct_v2',
+        doc='Direct interface pyscipopt',
+    )(ScipDirect)
+    SolverFactory.register(
+        name='scip_persistent',
+        legacy_name='scip_persistent_v2',
+        doc='Persistent interface pyscipopt',
+    )(ScipPersistent)
     SolverFactory.register(
         name="knitro_direct",
         legacy_name="knitro_direct",

pyomo/contrib/solver/solvers/gams.py

@@ -19,6 +19,7 @@
 import pathlib
 
 from pyomo.common.dependencies import attempt_import
+from pyomo.common.errors import InfeasibleConstraintException
 from pyomo.common.fileutils import Executable, ExecutableData
 from pyomo.common.config import (
     ConfigValue,
@@ -37,6 +38,7 @@
     Results,
     SolutionStatus,
     TerminationCondition,
+    get_infeasible_results,
 )
 from pyomo.contrib.solver.solvers.gms_sol_reader import GMSSolutionLoader
 
@@ -292,110 +294,122 @@ def solve(self, model, **kwds):
 
         output_filename = None
         with TempfileManager.new_context() as tempfile:
-            # IMPORTANT - only delete the whole tmpdir if the solver was the one
-            # that made the directory. Otherwise, just delete the files the solver
-            # made, if not keepfiles. That way the user can select a directory
-            # they already have, like the current directory, without having to
-            # worry about the rest of the contents of that directory being deleted.
-            if not config.working_dir:
-                dname = tempfile.mkdtemp()
-            else:
-                dname = config.working_dir
-            if not os.path.exists(dname):
-                os.mkdir(dname)
-            basename = os.path.join(dname, model_name)
-            output_filename = basename + '.gms'
-            lst_filename = os.path.join(dname, lst)
-
-            timer.start(f'write_gms_file')
-            with open(output_filename, 'w', newline='\n', encoding='utf-8') as gms_file:
-                gms_info = GAMSWriter().write(
-                    model, gms_file, config=config.writer_config
-                )
-                # NOTE: omit InfeasibleConstraintException for now
-            timer.stop(f'write_gms_file')
+            try:
+                # IMPORTANT - only delete the whole tmpdir if the solver was the one
+                # that made the directory. Otherwise, just delete the files the solver
+                # made, if not keepfiles. That way the user can select a directory
+                # they already have, like the current directory, without having to
+                # worry about the rest of the contents of that directory being deleted.
+                if not config.working_dir:
+                    dname = tempfile.mkdtemp()
+                else:
+                    dname = config.working_dir
+                if not os.path.exists(dname):
+                    os.mkdir(dname)
+                basename = os.path.join(dname, model_name)
+                output_filename = basename + '.gms'
+                lst_filename = os.path.join(dname, lst)
+
+                timer.start(f'write_gms_file')
+                with open(
+                    output_filename, 'w', newline='\n', encoding='utf-8'
+                ) as gms_file:
+                    gms_info = GAMSWriter().write(
+                        model, gms_file, config=config.writer_config
+                    )
+                timer.stop(f'write_gms_file')
 
-            if config.writer_config.put_results_format == 'gdx':
-                results_filename = os.path.join(dname, "GAMS_MODEL_p.gdx")
-                statresults_filename = os.path.join(
-                    dname, "%s_s.gdx" % (config.writer_config.put_results,)
-                )
-            else:
-                results_filename = os.path.join(
-                    dname, "%s.dat" % (config.writer_config.put_results,)
-                )
-                statresults_filename = os.path.join(
-                    dname, "%sstat.dat" % (config.writer_config.put_results,)
-                )
+                if config.writer_config.put_results_format == 'gdx':
+                    results_filename = os.path.join(dname, "GAMS_MODEL_p.gdx")
+                    statresults_filename = os.path.join(
+                        dname, "%s_s.gdx" % (config.writer_config.put_results,)
+                    )
+                else:
+                    results_filename = os.path.join(
+                        dname, "%s.dat" % (config.writer_config.put_results,)
+                    )
+                    statresults_filename = os.path.join(
+                        dname, "%sstat.dat" % (config.writer_config.put_results,)
+                    )
 
-            ####################################################################
-            # Apply solver
-            ####################################################################
-            exe_path = config.executable.path()
-            command = [exe_path, output_filename, "o=" + lst, "curdir=" + dname]
+                ####################################################################
+                # Apply solver
+                ####################################################################
+                exe_path = config.executable.path()
+                command = [exe_path, output_filename, "o=" + lst, "curdir=" + dname]
 
-            # handled tee and logfile based on the length of list and
-            # string respectively
-            command.append(self._log_levels[(bool(config.tee), bool(config.logfile))])
+                # handled tee and logfile based on the length of list and
+                # string respectively
+                command.append(
+                    self._log_levels[(bool(config.tee), bool(config.logfile))]
+                )
 
-            ostreams = [StringIO()]
-            if config.tee:
-                ostreams.append(sys.stdout)
+                ostreams = [StringIO()]
+                if config.tee:
+                    ostreams.append(sys.stdout)
 
-            with TeeStream(*ostreams) as t:
-                timer.start('subprocess')
-                subprocess_result = subprocess.run(
-                    command, stdout=t.STDOUT, stderr=t.STDERR, cwd=dname
-                )
-                timer.stop('subprocess')
-            rc = subprocess_result.returncode
-            txt = ostreams[0].getvalue()
-            if config.working_dir:
-                logger.info("\nGAMS WORKING DIRECTORY: %s\n" % config.working_dir)
-
-            if rc:
-                # If nothing was raised, or for all other cases, raise this
-                error_message = f"GAMS process encountered an error (returncode={rc})."
-                if rc == 3:
-                    # Execution Error
-                    # Run check_expr_evaluation, which errors if necessary
-                    error_message += (
-                        "\nError rc=3 (GAMS execution error), to be determined later."
+                with TeeStream(*ostreams) as t:
+                    timer.start('subprocess')
+                    subprocess_result = subprocess.run(
+                        command, stdout=t.STDOUT, stderr=t.STDERR, cwd=dname
                     )
-                error_message += "\nCheck listing file for details.\n"
-                logger.error(error_message)
-                logger.error(txt.strip())
-                if os.path.exists(lst_filename):
-                    with open(lst_filename, 'r') as FILE:
-                        logger.error(
-                            "\nGAMS Listing file:\n\n%s" % (FILE.read().strip(),)
-                        )
-                raise RuntimeError(error_message)
-
-            timer.start('parse_results')
-            if config.writer_config.put_results_format == 'gdx':
-                model_soln, stat_vars = self._parse_gdx_results(
-                    config, results_filename, statresults_filename
-                )
-            else:
-                model_soln, stat_vars = self._parse_dat_results(
-                    config, results_filename, statresults_filename
-                )
-            timer.stop('parse_results')
-
-            ####################################################################
-            # Postsolve (WIP)
-            results = self._postsolve(
-                model, timer, config, model_soln, stat_vars, gms_info
-            )
+                    timer.stop('subprocess')
+                rc = subprocess_result.returncode
+                txt = ostreams[0].getvalue()
+                if config.working_dir:
+                    logger.info("\nGAMS WORKING DIRECTORY: %s\n" % config.working_dir)
+
+                if rc:
+                    # If nothing was raised, or for all other cases, raise this
+                    error_message = (
+                        f"GAMS process encountered an error (returncode={rc})."
+                    )
+                    if rc == 3:
+                        # Execution Error
+                        # Run check_expr_evaluation, which errors if necessary
+                        error_message += "\nError rc=3 (GAMS execution error), to be determined later."
+                    error_message += "\nCheck listing file for details.\n"
+                    logger.error(error_message)
+                    logger.error(txt.strip())
+                    if os.path.exists(lst_filename):
+                        with open(lst_filename, 'r') as FILE:
+                            logger.error(
+                                "\nGAMS Listing file:\n\n%s" % (FILE.read().strip(),)
+                            )
+                    raise RuntimeError(error_message)
+
+                timer.start('parse_results')
+                if config.writer_config.put_results_format == 'gdx':
+                    model_soln, stat_vars = self._parse_gdx_results(
+                        config, results_filename, statresults_filename
+                    )
+                else:
+                    model_soln, stat_vars = self._parse_dat_results(
+                        config, results_filename, statresults_filename
+                    )
+                timer.stop('parse_results')
 
-            results.solver_config = config
-            results.solver_log = ostreams[0].getvalue()
+                ####################################################################
+                # Postsolve (WIP)
+                results = self._postsolve(
+                    model, timer, config, model_soln, stat_vars, gms_info
+                )
 
-            tock = time.perf_counter()
-            results.timing_info.start_timestamp = start_timestamp
-            results.timing_info.wall_time = tock - tick
-            results.timing_info.timer = timer
+                results.solver_config = config
+                results.solver_log = ostreams[0].getvalue()
+
+                tock = time.perf_counter()
+                results.timing_info.start_timestamp = start_timestamp
+                results.timing_info.wall_time = tock - tick
+                results.timing_info.timer = timer
+            except InfeasibleConstraintException as err:
+                err_msg = f'Solution loader does not currently have a valid solution because the problem was proven to be infeasible ({str(err)}). Please check results.termination_condition and/or results.solution_status.'
+                results = get_infeasible_results(
+                    config=config,
+                    err_msg=err_msg,
+                    solver_name=self.name,
+                    solver_version=self.version(),
+                )
             return results
 
     def _postsolve(self, model, timer, config, model_soln, stat_vars, gms_info):