diff --git a/.coin-or/projDesc.xml b/.coin-or/projDesc.xml
index 1ee247e100f..d13ac8804cf 100644
--- a/.coin-or/projDesc.xml
+++ b/.coin-or/projDesc.xml
@@ -227,8 +227,8 @@ Carl D. Laird, Chair, Pyomo Management Committee, claird at andrew dot cmu dot e
Use explicit overrides to disable use of automated
version reporting.
-->
- 6.7.0
- 6.7.0
+ 6.7.3
+ 6.7.3
diff --git a/.github/workflows/release_wheel_creation.yml b/.github/workflows/release_wheel_creation.yml
index ef44806d6d4..932b0d8eea6 100644
--- a/.github/workflows/release_wheel_creation.yml
+++ b/.github/workflows/release_wheel_creation.yml
@@ -22,14 +22,27 @@ jobs:
name: Build wheels (${{ matrix.wheel-version }}) on ${{ matrix.os }} for native and cross-compiled architecture
runs-on: ${{ matrix.os }}
strategy:
+ fail-fast: true
matrix:
os: [ubuntu-22.04, windows-latest, macos-latest]
arch: [all]
wheel-version: ['cp38*', 'cp39*', 'cp310*', 'cp311*', 'cp312*']
+
+ include:
+ - wheel-version: 'cp38*'
+ TARGET: 'py38'
+ - wheel-version: 'cp39*'
+ TARGET: 'py39'
+ - wheel-version: 'cp310*'
+ TARGET: 'py310'
+ - wheel-version: 'cp311*'
+ TARGET: 'py311'
+ - wheel-version: 'cp312*'
+ TARGET: 'py312'
steps:
- uses: actions/checkout@v4
- name: Build wheels
- uses: pypa/cibuildwheel@v2.16.2
+ uses: pypa/cibuildwheel@v2.16.5
with:
output-dir: dist
env:
@@ -43,8 +56,9 @@ jobs:
CIBW_CONFIG_SETTINGS: '--global-option="--with-cython --with-distributable-extensions"'
- uses: actions/upload-artifact@v4
with:
- name: native_wheels
+ name: native_wheels-${{ matrix.os }}-${{ matrix.TARGET }}
path: dist/*.whl
+ overwrite: true
alternative_wheels:
name: Build wheels (${{ matrix.wheel-version }}) on ${{ matrix.os }} for aarch64
@@ -54,6 +68,18 @@ jobs:
os: [ubuntu-22.04]
arch: [all]
wheel-version: ['cp38*', 'cp39*', 'cp310*', 'cp311*', 'cp312*']
+
+ include:
+ - wheel-version: 'cp38*'
+ TARGET: 'py38'
+ - wheel-version: 'cp39*'
+ TARGET: 'py39'
+ - wheel-version: 'cp310*'
+ TARGET: 'py310'
+ - wheel-version: 'cp311*'
+ TARGET: 'py311'
+ - wheel-version: 'cp312*'
+ TARGET: 'py312'
steps:
- uses: actions/checkout@v4
- name: Set up QEMU
@@ -62,7 +88,7 @@ jobs:
with:
platforms: all
- name: Build wheels
- uses: pypa/cibuildwheel@v2.16.2
+ uses: pypa/cibuildwheel@v2.16.5
with:
output-dir: dist
env:
@@ -74,8 +100,9 @@ jobs:
CIBW_CONFIG_SETTINGS: '--global-option="--with-cython --with-distributable-extensions"'
- uses: actions/upload-artifact@v4
with:
- name: alt_wheels
+ name: alt_wheels-${{ matrix.os }}-${{ matrix.TARGET }}
path: dist/*.whl
+ overwrite: true
generictarball:
name: ${{ matrix.TARGET }}
@@ -106,4 +133,5 @@ jobs:
with:
name: generictarball
path: dist
+ overwrite: true
diff --git a/.github/workflows/test_branches.yml b/.github/workflows/test_branches.yml
index e5513d25975..8ba04eec466 100644
--- a/.github/workflows/test_branches.yml
+++ b/.github/workflows/test_branches.yml
@@ -40,12 +40,27 @@ jobs:
python-version: '3.10'
- name: Black Formatting Check
run: |
- pip install black
+ # Note v24.4.1 fails due to a bug in the parser
+ pip install 'black!=24.4.1'
black . -S -C --check --diff --exclude examples/pyomobook/python-ch/BadIndent.py
- name: Spell Check
uses: crate-ci/typos@master
with:
config: ./.github/workflows/typos.toml
+ - name: URL Checker
+ uses: urlstechie/urlchecker-action@0.0.34
+ with:
+ # A comma-separated list of file types to cover in the URL checks
+ file_types: .md,.rst,.py
+ # Choose whether to include file with no URLs in the prints.
+ print_all: false
+ # More verbose summary at the end of a run
+ verbose: true
+ # How many times to retry a failed request (defaults to 1)
+ retry_count: 3
+ # Exclude Jenkins because it's behind a firewall; ignore RTD because
+ # a magically-generated string is triggering a failure
+ exclude_urls: https://pyomo-jenkins.sandia.gov/,https://pyomo.readthedocs.io/en/%s/errors.html
build:
@@ -66,7 +81,7 @@ jobs:
TARGET: linux
PYENV: pip
- - os: macos-latest
+ - os: macos-13
python: '3.10'
TARGET: osx
PYENV: pip
@@ -75,7 +90,7 @@ jobs:
python: 3.9
TARGET: win
PYENV: conda
- PACKAGES: glpk pytest-qt
+ PACKAGES: glpk pytest-qt filelock
- os: ubuntu-latest
python: '3.11'
@@ -86,13 +101,13 @@ jobs:
PACKAGES: pytest-qt
- os: ubuntu-latest
- python: 3.9
+ python: '3.10'
other: /mpi
mpi: 3
skip_doctest: 1
TARGET: linux
PYENV: conda
- PACKAGES: mpi4py
+ PACKAGES: openmpi mpi4py
- os: ubuntu-latest
python: '3.10'
@@ -180,7 +195,7 @@ jobs:
# Notes:
# - install glpk
# - pyodbc needs: gcc pkg-config unixodbc freetds
- for pkg in bash pkg-config unixodbc freetds glpk; do
+ for pkg in bash pkg-config unixodbc freetds glpk ginac; do
brew list $pkg || brew install $pkg
done
@@ -192,7 +207,8 @@ jobs:
# - install glpk
# - ipopt needs: libopenblas-dev gfortran liblapack-dev
sudo apt-get -o Dir::Cache=${GITHUB_WORKSPACE}/cache/os \
- install libopenblas-dev gfortran liblapack-dev glpk-utils
+ install libopenblas-dev gfortran liblapack-dev glpk-utils \
+ libginac-dev
sudo chmod -R 777 ${GITHUB_WORKSPACE}/cache/os
- name: Update Windows
@@ -263,11 +279,12 @@ jobs:
if test -z "${{matrix.slim}}"; then
python -m pip install --cache-dir cache/pip cplex docplex \
|| echo "WARNING: CPLEX Community Edition is not available"
- python -m pip install --cache-dir cache/pip \
- -i https://pypi.gurobi.com gurobipy==10.0.3 \
+ python -m pip install --cache-dir cache/pip gurobipy==10.0.3 \
|| echo "WARNING: Gurobi is not available"
python -m pip install --cache-dir cache/pip xpress \
|| 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 wntr for pypy"
else
@@ -333,6 +350,7 @@ jobs:
CONDA_DEPENDENCIES="$CONDA_DEPENDENCIES $PKG"
fi
done
+ echo ""
echo "*** Install Pyomo dependencies ***"
# Note: this will fail the build if any installation fails (or
# possibly if it outputs messages to stderr)
@@ -631,7 +649,7 @@ jobs:
$PYTHON_EXE -c "from pyomo.dataportal.parse_datacmds import \
parse_data_commands; parse_data_commands(data='')"
# Note: if we are testing with openmpi, add '--oversubscribe'
- mpirun -np ${{matrix.mpi}} pytest -v \
+ mpirun -np ${{matrix.mpi}} -oversubscribe pytest -v \
--junit-xml=TEST-pyomo-mpi.xml \
-m "mpi" -W ignore::Warning \
pyomo `pwd`/pyomo-model-libraries
@@ -708,12 +726,12 @@ jobs:
strategy:
fail-fast: false
matrix:
- os: [ubuntu-latest, macos-latest, windows-latest]
+ os: [ubuntu-latest, macos-13, windows-latest]
include:
- os: ubuntu-latest
TARGET: linux
- - os: macos-latest
+ - os: macos-13
TARGET: osx
- os: windows-latest
TARGET: win
diff --git a/.github/workflows/test_pr_and_main.yml b/.github/workflows/test_pr_and_main.yml
index c5028606c17..bdf1f7e1aa5 100644
--- a/.github/workflows/test_pr_and_main.yml
+++ b/.github/workflows/test_pr_and_main.yml
@@ -7,6 +7,11 @@ on:
pull_request:
branches:
- main
+ types:
+ - opened
+ - reopened
+ - synchronize
+ - ready_for_review
workflow_dispatch:
inputs:
git-ref:
@@ -34,6 +39,8 @@ jobs:
lint:
name: lint/style-and-typos
runs-on: ubuntu-latest
+ if: |
+ contains(github.event.pull_request.title, '[WIP]') != true && !github.event.pull_request.draft
steps:
- name: Checkout Pyomo source
uses: actions/checkout@v4
@@ -43,12 +50,27 @@ jobs:
python-version: '3.10'
- name: Black Formatting Check
run: |
- pip install black
+ # Note v24.4.1 fails due to a bug in the parser
+ pip install 'black!=24.4.1'
black . -S -C --check --diff --exclude examples/pyomobook/python-ch/BadIndent.py
- name: Spell Check
uses: crate-ci/typos@master
with:
config: ./.github/workflows/typos.toml
+ - name: URL Checker
+ uses: urlstechie/urlchecker-action@0.0.34
+ with:
+ # A comma-separated list of file types to cover in the URL checks
+ file_types: .md,.rst,.py
+ # Choose whether to include file with no URLs in the prints.
+ print_all: false
+ # More verbose summary at the end of a run
+ verbose: true
+ # How many times to retry a failed request (defaults to 1)
+ retry_count: 3
+ # Exclude Jenkins because it's behind a firewall; ignore RTD because
+ # a magically-generated string is triggering a failure
+ exclude_urls: https://pyomo-jenkins.sandia.gov/,https://pyomo.readthedocs.io/en/%s/errors.html
build:
@@ -59,24 +81,29 @@ jobs:
strategy:
fail-fast: false
matrix:
- os: [ubuntu-latest, macos-latest, windows-latest]
+ os: [ubuntu-latest, macos-13, windows-latest]
python: [ 3.8, 3.9, '3.10', '3.11', '3.12' ]
other: [""]
category: [""]
+ # win/3.8 conda builds no longer work due to environment not being able
+ # to resolve. We are skipping it now.
+ exclude:
+ - os: windows-latest
+ python: 3.8
include:
- os: ubuntu-latest
TARGET: linux
PYENV: pip
- - os: macos-latest
+ - os: macos-13
TARGET: osx
PYENV: pip
- os: windows-latest
TARGET: win
PYENV: conda
- PACKAGES: glpk pytest-qt
+ PACKAGES: glpk pytest-qt filelock
- os: ubuntu-latest
python: '3.11'
@@ -87,13 +114,13 @@ jobs:
PACKAGES: pytest-qt
- os: ubuntu-latest
- python: 3.9
+ python: '3.10'
other: /mpi
mpi: 3
skip_doctest: 1
TARGET: linux
PYENV: conda
- PACKAGES: mpi4py
+ PACKAGES: openmpi mpi4py
- os: ubuntu-latest
python: '3.11'
@@ -210,7 +237,7 @@ jobs:
# Notes:
# - install glpk
# - pyodbc needs: gcc pkg-config unixodbc freetds
- for pkg in bash pkg-config unixodbc freetds glpk; do
+ for pkg in bash pkg-config unixodbc freetds glpk ginac; do
brew list $pkg || brew install $pkg
done
@@ -222,7 +249,8 @@ jobs:
# - install glpk
# - ipopt needs: libopenblas-dev gfortran liblapack-dev
sudo apt-get -o Dir::Cache=${GITHUB_WORKSPACE}/cache/os \
- install libopenblas-dev gfortran liblapack-dev glpk-utils
+ install libopenblas-dev gfortran liblapack-dev glpk-utils \
+ libginac-dev
sudo chmod -R 777 ${GITHUB_WORKSPACE}/cache/os
- name: Update Windows
@@ -293,11 +321,12 @@ jobs:
if test -z "${{matrix.slim}}"; then
python -m pip install --cache-dir cache/pip cplex docplex \
|| echo "WARNING: CPLEX Community Edition is not available"
- python -m pip install --cache-dir cache/pip \
- -i https://pypi.gurobi.com gurobipy==10.0.3 \
+ python -m pip install --cache-dir cache/pip gurobipy==10.0.3 \
|| echo "WARNING: Gurobi is not available"
python -m pip install --cache-dir cache/pip xpress \
|| 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 wntr for pypy"
else
@@ -363,6 +392,7 @@ jobs:
CONDA_DEPENDENCIES="$CONDA_DEPENDENCIES $PKG"
fi
done
+ echo ""
echo "*** Install Pyomo dependencies ***"
# Note: this will fail the build if any installation fails (or
# possibly if it outputs messages to stderr)
@@ -605,7 +635,8 @@ jobs:
if: ${{ ! matrix.slim }}
shell: bash
run: |
- $PYTHON_EXE -m pip install --cache-dir cache/pip highspy \
+ echo "NOTE: temporarily pinning to highspy pre-release for testing"
+ $PYTHON_EXE -m pip install --cache-dir cache/pip "highspy>=1.7.1.dev1" \
|| echo "WARNING: highspy is not available"
- name: Set up coverage tracking
@@ -661,7 +692,7 @@ jobs:
$PYTHON_EXE -c "from pyomo.dataportal.parse_datacmds import \
parse_data_commands; parse_data_commands(data='')"
# Note: if we are testing with openmpi, add '--oversubscribe'
- mpirun -np ${{matrix.mpi}} pytest -v \
+ mpirun -np ${{matrix.mpi}} -oversubscribe pytest -v \
--junit-xml=TEST-pyomo-mpi.xml \
-m "mpi" -W ignore::Warning \
pyomo `pwd`/pyomo-model-libraries
@@ -733,18 +764,18 @@ jobs:
cover:
name: process-coverage-${{ matrix.TARGET }}
needs: build
- if: always() # run even if a build job fails
+ if: success() || failure() # run even if a build job fails, but not if cancelled
runs-on: ${{ matrix.os }}
timeout-minutes: 10
strategy:
fail-fast: false
matrix:
- os: [ubuntu-latest, macos-latest, windows-latest]
+ os: [ubuntu-latest, macos-13, windows-latest]
include:
- os: ubuntu-latest
TARGET: linux
- - os: macos-latest
+ - os: macos-13
TARGET: osx
- os: windows-latest
TARGET: win
diff --git a/.github/workflows/typos.toml b/.github/workflows/typos.toml
index 23f94fc8afd..7a38164898b 100644
--- a/.github/workflows/typos.toml
+++ b/.github/workflows/typos.toml
@@ -40,4 +40,31 @@ WRONLY = "WRONLY"
Hax = "Hax"
# Big Sur
Sur = "Sur"
+# contrib package named mis and the acronym whence the name comes
+mis = "mis"
+MIS = "MIS"
+# Ignore the shorthand ans for answer
+ans = "ans"
+# Ignore the keyword arange
+arange = "arange"
+# Ignore IIS
+IIS = "IIS"
+iis = "iis"
+# Ignore PN
+PN = "PN"
+# Ignore hd
+hd = "hd"
+# Ignore opf
+opf = "opf"
+# Ignore FRE
+FRE = "FRE"
+# Ignore MCH
+MCH = "MCH"
+# Ignore RO
+ro = "ro"
+RO = "RO"
+# Ignore EOF - end of file
+EOF = "EOF"
+# Ignore lst as shorthand for list
+lst = "lst"
# AS NEEDED: Add More Words Below
diff --git a/.jenkins.sh b/.jenkins.sh
index 37be6113ed9..696847fd92c 100644
--- a/.jenkins.sh
+++ b/.jenkins.sh
@@ -43,9 +43,6 @@ fi
if test -z "$SLIM"; then
export VENV_SYSTEM_PACKAGES='--system-site-packages'
fi
-if test ! -z "$CATEGORY"; then
- export PY_CAT="-m $CATEGORY"
-fi
if test "$WORKSPACE" != "`pwd`"; then
echo "ERROR: pwd is not WORKSPACE"
@@ -122,10 +119,23 @@ if test -z "$MODE" -o "$MODE" == setup; then
echo "PYOMO_CONFIG_DIR=$PYOMO_CONFIG_DIR"
echo ""
+ # Call Pyomo build scripts to build TPLs that would normally be
+ # skipped by the pyomo download-extensions / build-extensions
+ # actions below
+ if [[ " $CATEGORY " == *" builders "* ]]; then
+ echo ""
+ echo "Running local build scripts..."
+ echo ""
+ set -x
+ python pyomo/contrib/simplification/build.py --build-deps || exit 1
+ set +x
+ fi
+
# Use Pyomo to download & compile binary extensions
i=0
while /bin/true; do
i=$[$i+1]
+ echo ""
echo "Downloading pyomo extensions (attempt $i)"
pyomo download-extensions $PYOMO_DOWNLOAD_ARGS
if test $? == 0; then
@@ -178,7 +188,7 @@ if test -z "$MODE" -o "$MODE" == test; then
python -m pytest -v \
-W ignore::Warning \
--junitxml="TEST-pyomo.xml" \
- $PY_CAT $TEST_SUITES $PYTEST_EXTRA_ARGS
+ -m "$CATEGORY" $TEST_SUITES $PYTEST_EXTRA_ARGS
# Combine the coverage results and upload
if test -z "$DISABLE_COVERAGE"; then
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 553a4f1c3bd..8d1d1e45e3d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,173 @@ Pyomo CHANGELOG
===============
+-------------------------------------------------------------------------------
+Pyomo 6.7.3 (29 May 2024)
+-------------------------------------------------------------------------------
+
+- Core
+ - Deprecate `pyomo.core.plugins.transform.model.to_standard_form()` (#3265)
+ - Reorder definitions to avoid `NameError` in some situations (#3264)
+- Solver Interfaces
+ - NLv2: Fix linear presolver with constant defined vars/external fcns (#3276)
+- Testing
+ - Add URL checking to GHA linting job (#3259, #3261)
+ - Skip Windows Python 3.8 conda GHA job (#3269)
+- Contributed Packages
+ - DoE: Bug fixes for workshop (#3267)
+ - viewer: Update guard for pint import (#3277)
+
+-------------------------------------------------------------------------------
+Pyomo 6.7.2 (9 May 2024)
+-------------------------------------------------------------------------------
+
+- General
+ - Support config domains with either method or attribute domain_name (#3159)
+ - Automate TPL callback registrations (#3167)
+ - Fix type registrations for ExternalFunction arguments (#3168)
+ - Only modify module path and spec for deferred import modules (#3176)
+ - Add "mixed" standard form representation (#3201)
+ - Support "default" dispatchers in `ExitNodeDispatcher` (#3194)
+ - Redefine objective sense as a proper `IntEnum` (#3224)
+ - Fix division-by-0 bug in linear walker (#3246)
+- Core
+ - Allow `Var` objects in `LinearExpression.args` (#3189)
+ - Add type hints to components (#3173)
+ - Simplify expressions generated by `TemplateSumExpression` (#3196)
+ - Make component data public classes (#3221, #3253)
+ - Exploit repeated named expressions in `identify_variables` (#3190)
+- Documentation
+ - NFC: Add link to the HOMOWP companion notebooks (#3195)
+ - Update installation documentation to include Cython instructions (#3208)
+ - Add links to the Pyomo Book Springer page (#3211)
+- Solver Interfaces
+ - Fix division by zero error in linear presolve (#3161)
+ - Subprocess timeout update (#3183)
+ - Solver Refactor - Bug fixes for various components (#3181, #3214, #3228)
+ - NLv2: handle presolved independent linear subsystems (#3193)
+ - Update `LegacySolverWrapper` compatibility with the `pyomo` script (#3202)
+ - Fix mosek_direct to use putqconk instead of putqcon (#3199)
+ - Check _skip_trivial_constraints before the constraint body (#3226)
+ - Fix AMPL solver duplicate funcadd (#3206)
+ - Disable the use of universal newlines in the ipopt_v2 NL file (#3231)
+ - NLv2: fix reporting numbers of nonlinear discrete variables (#3238)
+ - Fix: Get SCIP solving time considering float number with some text (#3234)
+ - Solver Refactor - Add `gurobi_direct` implementation (#3225)
+- Testing
+ - Update TPL package list due to `contrib.solver` (#3164)
+ - Set maxDiff=None on the base TestCase class (#3171)
+ - Testing infrastructure updates (#3175)
+ - Typos update for March 2024 (#3219)
+ - Add openmpi to testing environment to resolve issue in mpi4py (#3236, #3239)
+ - Skip black 24.4.1 due to a bug in the parser (#3247)
+ - Skip tests on draft and WIP pull requests (#3223)
+ - Update GHA to grab gurobipy from PyPI (#3254)
+- GDP
+ - Use private_data for all original / transformed component mappings (#3166)
+ - Fix a bug in gdp.bigm transformation for nested GDPs (#3213)
+- Contributed Packages
+ - APPSI: cmodel: handle non-mutable params in var / constraint bounds (#3182)
+ - APPSI: Allow APPSI FBBT to handle nested named Expressions (#3185)
+ - APPSI: Add MAiNGO solver interface (#3165)
+ - CP: Add SequenceVar and other logical expressions for scheduling (#3227)
+ - DoE: Bug fixes (#3245)
+ - iis: Add minimal intractable system infeasibility diagnostics (#3172)
+ - incidence_analysis: Improve `solve_strongly_connected_components`
+ performance for models with named expressions (#3186)
+ - incidence_analysis: Add function to plot incidence graph in
+ Dulmage-Mendelsohn order (#3207)
+ - incidence_analysis: Require variables and constraints to be specified
+ separately in `IncidenceGraphInterface.remove_nodes` (#3212)
+ - latex_printer: bugfix for set operations / multidimensional sets (#3177)
+ - MindtPy: Add HiGHS support (#2971)
+ - MindtPy: Add call_before_subproblem_solve callback (#3251)
+ - Parmest: New UI using experiment lists (#3160)
+ - piecewise: Add piecewise linear transformations (#3036)
+ - preprocessing: bugfix: intersect domains in variable aggregator (#3241)
+ - PyNumero: Allow CyIpopt to solve problems without objectives (#3163)
+ - PyNumero: Work around bug in CyIpopt 1.4.0 (#3222)
+ - PyNumero: Include "inventory" in readme (#3248)
+ - PyROS: Simplify custom domain validators (#3169)
+ - PyROS: Fix iteration logging for edge case involving discrete sets (#3170)
+ - PyROS: Update solver timing system (#3198)
+ - simplification: expression simplification using GiNaC or SymPy (#3088)
+
+-------------------------------------------------------------------------------
+Pyomo 6.7.1 (21 Feb 2024)
+-------------------------------------------------------------------------------
+
+- General
+ - Add support for tuples in `ComponentMap`; add `DefaultComponentMap` (#3150)
+ - Update `Path`, `PathList`, and `IsInstance` Domain Validators (#3144)
+ - Remove usage of `__all__` (#3142)
+ - Extend Path and Type Checking Validators of `common.config` (#3140)
+ - Update Copyright Statements (#3139)
+ - Update `ExitNodeDispatcher` to better support extensibility (#3125)
+ - Create contributors data gathering script (#3117)
+ - Prevent duplicate entries in ConfigDict declaration order (#3116)
+ - Remove unnecessary `__future__` imports (#3109)
+ - Import pandas through pyomo.common.dependencies (#3102)
+ - Update links to workshop slides (#3079)
+ - Remove incorrect use of identity (is) comparisons (#3061)
+- Core
+ - Add `Block.register_private_data_initializer()` (#3153)
+ - Generalize the simple_constraint_rule decorator (#3152)
+ - Fix edge case assigning new numeric types to Var/Param with units (#3151)
+ - Add private_data to `_BlockData` (#3138)
+ - IndexComponent create implicit sets as "anonymous" sets (#3075)
+ - Add `all_different` and `count_if` to the logical expression system (#3058)
+ - Fix RangeSet.__len__ when defined by floats (#3119)
+ - Overhaul the `Suffix` component (#3072)
+ - Enforce expression immutability in `expr.args` (#3099)
+ - Improve NumPy registration when assigning numpy to Param (#3093)
+ - Track changes in PyPy behavior introduced in 7.3.14 (#3087)
+ - Remove automatic numpy import (#3077)
+ - Fix `range_difference` for Sets with nonzero anchor points (#3063)
+ - Clarify errors raised by accessing Sets by positional index (#3062)
+- Documentation
+ - Update intersphinx links, remove docs for nonfunctional code (#3155)
+ - Update MPC documentation and citation (#3148)
+ - Fix an error in the documentation for LinearExpression (#3090)
+ - Fix Pyomo.DoE documentation (#3070)
+ - Fix latex_printer documentation (#3066)
+- Solver Interfaces
+ - Preview release of new solver interfaces as pyomo.contrib.solver
+ (#3137, #3156)
+ - Make error msg more explicit wrt different interfaces (#3141)
+ - NLv2: only raise exception for empty models in the legacy API (#3135)
+ - Add `to_expr()` to AMPLRepn, fix NLWriterInfo return type (#3095)
+- Testing
+ - Update Release Wheel Builder Action (#3149)
+ - Actions Version Update: Address node.js deprecations (#3118)
+ - New Black Major Release (24.1.0) (#3108)
+ - Use scip for PyROS tests (#3104)
+ - Add missing solver dependency flags for OnlineDocs tests (#3094)
+ - Re-enable `contrib.viewer.tests.test_qt.py` (#3085)
+ - Add automated testing of OnlineDocs examples (#3080)
+ - Silence deprecation warnings emitted by Pyomo tests (#3076)
+ - Fix Python 3.12 tests (manage `pyutilib`, `distutils` dependencies) (#3065)
+- DAE
+ - Replace deprecated `numpy.math` alias with standard `math` module (#3074)
+- GDP
+ - Handle nested GDPs correctly in all the transformations (#3145)
+ - Fix bugs in nested models in gdp.hull transformation (#3143)
+ - Various bug fixes in gdp.mbigm transformation (#3073)
+ - Add GDP => MINLP Transformation (#3082)
+- Contributed Packages
+ - GDPopt: Fix lbb solve_data bug (#3133)
+ - GDPopt: Adding missing import for gdpopt.enumerate (#3105)
+ - FBBT: Extend `fbbt.ExpressionBoundsVisitor` to handle relational
+ expressions and Expr_if (#3129)
+ - incidence_analysis: Method to add an edge in IncidenceGraphInterface (#3120)
+ - incidence_analysis: Add subgraph method to IncidencegraphInterface (#3122)
+ - incidence_analysis: Add `ampl_repn` option (#3069)
+ - incidence_analysis: Update documentation (#3067)
+ - interior_point: Resolve test failure due to Mumps update (#3114)
+ - MindtPy: Various bug fixes (#3034)
+ - PyROS: Update Solver Argument Resolution and Validation Routines (#3126)
+ - PyROS: Update Subproblem Initialization Routines (#3071)
+ - PyROS: Fix DR polishing under nominal objective focus (#3060)
+
-------------------------------------------------------------------------------
Pyomo 6.7.0 (29 Nov 2023)
-------------------------------------------------------------------------------
diff --git a/README.md b/README.md
index 2f8a25403c2..707f1a06c5a 100644
--- a/README.md
+++ b/README.md
@@ -71,8 +71,11 @@ version, we will remove testing for that Python version.
### Tutorials and Examples
+* [Pyomo — Optimization Modeling in Python](https://link.springer.com/book/10.1007/978-3-030-68928-5)
* [Pyomo Workshop Slides](https://github.com/Pyomo/pyomo-tutorials/blob/main/Pyomo-Workshop-December-2023.pdf)
* [Prof. Jeffrey Kantor's Pyomo Cookbook](https://jckantor.github.io/ND-Pyomo-Cookbook/)
+* The [companion notebooks](https://mobook.github.io/MO-book/intro.html)
+ for *Hands-On Mathematical Optimization with Python*
* [Pyomo Gallery](https://github.com/Pyomo/PyomoGallery)
### Getting Help
@@ -83,7 +86,7 @@ To get help from the Pyomo community ask a question on one of the following:
### Developers
-Pyomo development moved to this repository in June, 2016 from
+Pyomo development moved to this repository in June 2016 from
Sandia National Laboratories. Developer discussions are hosted by
[Google Groups](https://groups.google.com/forum/#!forum/pyomo-developers).
diff --git a/RELEASE.md b/RELEASE.md
index 03baa803ac9..e42469cbad5 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,4 +1,4 @@
-We are pleased to announce the release of Pyomo 6.7.0.
+We are pleased to announce the release of Pyomo 6.7.3.
Pyomo is a collection of Python software packages that supports a
diverse set of optimization capabilities for formulating and analyzing
@@ -9,8 +9,15 @@ The following are highlights of the 6.7 release series:
- Added support for Python 3.12
- Removed support for Python 3.7
- New writer for converting linear models to matrix form
+ - Improved handling of nested GDPs
+ - Redesigned user API for parameter estimation
- New packages:
- - latex_printer (print Pyomo models to a LaTeX compatible format)
+ - iis: new capability for identifying minimal intractable systems
+ - latex_printer: print Pyomo models to a LaTeX compatible format
+ - contrib.solver: preview of redesigned solver interfaces
+ - simplification: simplify Pyomo expressions
+ - New solver interfaces
+ - MAiNGO: Mixed-integer nonlinear global optimization
- ...and of course numerous minor bug fixes and performance enhancements
A full list of updates and changes is available in the
diff --git a/conftest.py b/conftest.py
index 7faad6fc89b..34b366f9fd6 100644
--- a/conftest.py
+++ b/conftest.py
@@ -11,6 +11,22 @@
import pytest
+_implicit_markers = {'default'}
+_extended_implicit_markers = _implicit_markers.union({'solver'})
+
+
+def pytest_collection_modifyitems(items):
+ """
+ This method will mark any unmarked tests with the implicit marker ('default')
+
+ """
+ for item in items:
+ try:
+ next(item.iter_markers())
+ except StopIteration:
+ for marker in _implicit_markers:
+ item.add_marker(getattr(pytest.mark, marker))
+
def pytest_runtest_setup(item):
"""
@@ -32,13 +48,10 @@ def pytest_runtest_setup(item):
the default mode; but if solver tests are also marked with an explicit
category (e.g., "expensive"), we will skip them.
"""
- marker = item.iter_markers()
solvernames = [mark.args[0] for mark in item.iter_markers(name="solver")]
solveroption = item.config.getoption("--solver")
markeroption = item.config.getoption("-m")
- implicit_markers = ['default']
- extended_implicit_markers = implicit_markers + ['solver']
- item_markers = set(mark.name for mark in marker)
+ item_markers = set(mark.name for mark in item.iter_markers())
if solveroption:
if solveroption not in solvernames:
pytest.skip("SKIPPED: Test not marked {!r}".format(solveroption))
@@ -46,9 +59,9 @@ def pytest_runtest_setup(item):
elif markeroption:
return
elif item_markers:
- if not set(implicit_markers).issubset(
- item_markers
- ) and not item_markers.issubset(set(extended_implicit_markers)):
+ if not _implicit_markers.issubset(item_markers) and not item_markers.issubset(
+ _extended_implicit_markers
+ ):
pytest.skip('SKIPPED: Only running default, solver, and unmarked tests.')
diff --git a/doc/OnlineDocs/advanced_topics/flattener/index.rst b/doc/OnlineDocs/advanced_topics/flattener/index.rst
index 377de5233ec..f9dd8ea6abb 100644
--- a/doc/OnlineDocs/advanced_topics/flattener/index.rst
+++ b/doc/OnlineDocs/advanced_topics/flattener/index.rst
@@ -30,8 +30,9 @@ The ``pyomo.dae.flatten`` module aims to address this use case by providing
utilities to generate all components indexed, explicitly or implicitly, by
user-provided sets.
-**When we say "flatten a model," we mean "generate all components in the model,
-preserving all user-specified indexing sets."**
+**When we say "flatten a model," we mean "recursively generate all components in
+the model," where a component can be indexed only by user-specified indexing
+sets (or is not indexed at all)**.
Data structures
---------------
@@ -42,3 +43,23 @@ Slices are necessary as they can encode "implicit indexing" -- where a
component is contained in an indexed block. It is natural to return references
to these slices, so they may be accessed and manipulated like any other
component.
+
+Citation
+--------
+If you use the ``pyomo.dae.flatten`` module in your research, we would appreciate
+you citing the following paper, which gives more detail about the motivation for
+and examples of using this functinoality.
+
+.. code-block:: bibtex
+
+ @article{parker2023mpc,
+ title = {Model predictive control simulations with block-hierarchical differential-algebraic process models},
+ journal = {Journal of Process Control},
+ volume = {132},
+ pages = {103113},
+ year = {2023},
+ issn = {0959-1524},
+ doi = {https://doi.org/10.1016/j.jprocont.2023.103113},
+ url = {https://www.sciencedirect.com/science/article/pii/S0959152423002007},
+ author = {Robert B. Parker and Bethany L. Nicholson and John D. Siirola and Lorenz T. Biegler},
+ }
diff --git a/doc/OnlineDocs/bibliography.rst b/doc/OnlineDocs/bibliography.rst
index 6cbb96d3bfb..c12d3f81d8c 100644
--- a/doc/OnlineDocs/bibliography.rst
+++ b/doc/OnlineDocs/bibliography.rst
@@ -39,6 +39,8 @@ Bibliography
John D. Siirola, Jean-Paul Watson, and David L. Woodruff.
Pyomo - Optimization Modeling in Python, 3rd Edition.
Vol. 67. Springer, 2021.
+ doi: `10.1007/978-3-030-68928-5
+ `_
.. [PyomoJournal] William E. Hart, Jean-Paul Watson, David L. Woodruff.
"Pyomo: modeling and solving mathematical programs in
diff --git a/doc/OnlineDocs/conf.py b/doc/OnlineDocs/conf.py
index 89c346f5abc..a06ccfbc9bd 100644
--- a/doc/OnlineDocs/conf.py
+++ b/doc/OnlineDocs/conf.py
@@ -57,8 +57,8 @@
'numpy': ('https://numpy.org/doc/stable/', None),
'pandas': ('https://pandas.pydata.org/docs/', None),
'scikit-learn': ('https://scikit-learn.org/stable/', None),
- 'scipy': ('https://docs.scipy.org/doc/scipy/reference/', None),
- 'Sphinx': ('https://www.sphinx-doc.org/en/stable/', None),
+ 'scipy': ('https://docs.scipy.org/doc/scipy/', None),
+ 'Sphinx': ('https://www.sphinx-doc.org/en/master/', None),
}
# -- General configuration ------------------------------------------------
@@ -83,6 +83,8 @@
'sphinx.ext.doctest',
'sphinx.ext.todo',
'sphinx_copybutton',
+ 'enum_tools.autoenum',
+ 'sphinx.ext.autosectionlabel',
#'sphinx.ext.githubpages',
]
@@ -270,7 +272,7 @@ def check_output(self, want, got, optionflags):
yaml_available, networkx_available, matplotlib_available,
pympler_available, dill_available,
)
-pint_available = attempt_import('pint', defer_check=False)[1]
+pint_available = attempt_import('pint', defer_import=False)[1]
from pyomo.contrib.parmest.parmest import parmest_available
import pyomo.environ as _pe # (trigger all plugin registrations)
diff --git a/doc/OnlineDocs/contributed_packages/iis.rst b/doc/OnlineDocs/contributed_packages/iis.rst
index 98cb9e30771..fa97c2f8c61 100644
--- a/doc/OnlineDocs/contributed_packages/iis.rst
+++ b/doc/OnlineDocs/contributed_packages/iis.rst
@@ -1,6 +1,135 @@
+Infeasibility Diagnostics
+!!!!!!!!!!!!!!!!!!!!!!!!!
+
+There are two closely related tools for infeasibility diagnosis:
+
+ - :ref:`Infeasible Irreducible System (IIS) Tool`
+ - :ref:`Minimal Intractable System finder (MIS) Tool`
+
+The first simply provides a conduit for solvers that compute an
+infeasible irreducible system (e.g., Cplex, Gurobi, or Xpress). The
+second provides similar functionality, but uses the ``mis`` package
+contributed to Pyomo.
+
+
Infeasible Irreducible System (IIS) Tool
========================================
.. automodule:: pyomo.contrib.iis.iis
.. autofunction:: pyomo.contrib.iis.write_iis
+
+Minimal Intractable System finder (MIS) Tool
+============================================
+
+The file ``mis.py`` finds sets of actions that each, independently,
+would result in feasibility. The zero-tolerance is whatever the
+solver uses, so users may want to post-process output if it is going
+to be used for analysis. It also computes a minimal intractable system
+(which is not guaranteed to be unique). It was written by Ben Knueven
+as part of the watertap project (https://github.com/watertap-org/watertap)
+and is therefore governed by a license shown
+at the top of ``mis.py``.
+
+The algorithms come from John Chinneck's slides, see: https://www.sce.carleton.ca/faculty/chinneck/docs/CPAIOR07InfeasibilityTutorial.pdf
+
+Solver
+------
+
+At the time of this writing, you need to use IPopt even for LPs.
+
+Quick Start
+-----------
+
+The file ``trivial_mis.py`` is a tiny example listed at the bottom of
+this help file, which references a Pyomo model with the Python variable
+`m` and has these lines:
+
+.. code-block:: python
+
+ from pyomo.contrib.mis import compute_infeasibility_explanation
+ ipopt = pyo.SolverFactory("ipopt")
+ compute_infeasibility_explanation(m, solver=ipopt)
+
+.. Note::
+ This is done instead of solving the problem.
+
+.. Note::
+ IDAES users can pass ``get_solver()`` imported from ``ideas.core.solvers``
+ as the solver.
+
+Interpreting the Output
+-----------------------
+
+Assuming the dependencies are installed, running ``trivial_mis.py``
+(shown below) will
+produce a lot of warnings from IPopt and then meaningful output (using a logger).
+
+Repair Options
+^^^^^^^^^^^^^^
+
+This output for the trivial example shows three independent ways that the model could be rendered feasible:
+
+
+.. code-block:: text
+
+ Model Trivial Quad may be infeasible. A feasible solution was found with only the following variable bounds relaxed:
+ ub of var x[1] by 4.464126126706818e-05
+ lb of var x[2] by 0.9999553410114216
+ Another feasible solution was found with only the following variable bounds relaxed:
+ lb of var x[1] by 0.7071067726864677
+ ub of var x[2] by 0.41421355687130673
+ ub of var y by 0.7071067651855212
+ Another feasible solution was found with only the following inequality constraints, equality constraints, and/or variable bounds relaxed:
+ constraint: c by 0.9999999861866736
+
+
+Minimal Intractable System (MIS)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This output shows a minimal intractable system:
+
+
+.. code-block:: text
+
+ Computed Minimal Intractable System (MIS)!
+ Constraints / bounds in MIS:
+ lb of var x[2]
+ lb of var x[1]
+ constraint: c
+
+Constraints / bounds in guards for stability
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This part of the report is for nonlinear programs (NLPs).
+
+When we’re trying to reduce the constraint set, for an NLP there may be constraints that when missing cause the solver
+to fail in some catastrophic fashion. In this implementation this is interpreted as failing to get a `results`
+object back from the call to `solve`. In these cases we keep the constraint in the problem but it’s in the
+set of “guard” constraints – we can’t really be sure they’re a source of infeasibility or not,
+just that “bad things” happen when they’re not included.
+
+Perhaps ideally we would put a constraint in the “guard” set if IPopt failed to converge, and only put it in the
+MIS if IPopt converged to a point of local infeasibility. However, right now the code generally makes the
+assumption that if IPopt fails to converge the subproblem is infeasible, though obviously that is far from the truth.
+Hence for difficult NLPs even the “Phase 1” may “fail” – in that when finished the subproblem containing just the
+constraints in the elastic filter may be feasible -- because IPopt failed to converge and we assumed that meant the
+subproblem was not feasible.
+
+Dealing with NLPs is far from clean, but that doesn’t mean the tool can’t return useful results even when its assumptions are not satisfied.
+
+trivial_mis.py
+--------------
+
+.. code-block:: python
+
+ import pyomo.environ as pyo
+ m = pyo.ConcreteModel("Trivial Quad")
+ m.x = pyo.Var([1,2], bounds=(0,1))
+ m.y = pyo.Var(bounds=(0, 1))
+ m.c = pyo.Constraint(expr=m.x[1] * m.x[2] == -1)
+ m.d = pyo.Constraint(expr=m.x[1] + m.y >= 1)
+
+ from pyomo.contrib.mis import compute_infeasibility_explanation
+ ipopt = pyo.SolverFactory("ipopt")
+ compute_infeasibility_explanation(m, solver=ipopt)
diff --git a/doc/OnlineDocs/contributed_packages/mpc/api.rst b/doc/OnlineDocs/contributed_packages/mpc/api.rst
new file mode 100644
index 00000000000..2752fea8af6
--- /dev/null
+++ b/doc/OnlineDocs/contributed_packages/mpc/api.rst
@@ -0,0 +1,10 @@
+.. _mpc_api:
+
+API Reference
+=============
+
+.. toctree::
+ data.rst
+ conversion.rst
+ interface.rst
+ modeling.rst
diff --git a/doc/OnlineDocs/contributed_packages/mpc/conversion.rst b/doc/OnlineDocs/contributed_packages/mpc/conversion.rst
new file mode 100644
index 00000000000..9d9406edb75
--- /dev/null
+++ b/doc/OnlineDocs/contributed_packages/mpc/conversion.rst
@@ -0,0 +1,5 @@
+Data Conversion
+===============
+
+.. automodule:: pyomo.contrib.mpc.data.convert
+ :members:
diff --git a/doc/OnlineDocs/contributed_packages/mpc/data.rst b/doc/OnlineDocs/contributed_packages/mpc/data.rst
new file mode 100644
index 00000000000..73cb6543b1e
--- /dev/null
+++ b/doc/OnlineDocs/contributed_packages/mpc/data.rst
@@ -0,0 +1,17 @@
+Data Structures
+===============
+
+.. automodule:: pyomo.contrib.mpc.data.get_cuid
+ :members:
+
+.. automodule:: pyomo.contrib.mpc.data.dynamic_data_base
+ :members:
+
+.. automodule:: pyomo.contrib.mpc.data.scalar_data
+ :members:
+
+.. automodule:: pyomo.contrib.mpc.data.series_data
+ :members:
+
+.. automodule:: pyomo.contrib.mpc.data.interval_data
+ :members:
diff --git a/doc/OnlineDocs/contributed_packages/mpc/index.rst b/doc/OnlineDocs/contributed_packages/mpc/index.rst
index b93abf223e2..e512d1a6ef5 100644
--- a/doc/OnlineDocs/contributed_packages/mpc/index.rst
+++ b/doc/OnlineDocs/contributed_packages/mpc/index.rst
@@ -1,7 +1,7 @@
MPC
===
-This package contains data structures and utilities for dynamic optimization
+Pyomo MPC contains data structures and utilities for dynamic optimization
and rolling horizon applications, e.g. model predictive control.
.. toctree::
@@ -10,3 +10,23 @@ and rolling horizon applications, e.g. model predictive control.
overview.rst
examples.rst
faq.rst
+ api.rst
+
+Citation
+--------
+
+If you use Pyomo MPC in your research, please cite the following paper:
+
+.. code-block:: bibtex
+
+ @article{parker2023mpc,
+ title = {Model predictive control simulations with block-hierarchical differential-algebraic process models},
+ journal = {Journal of Process Control},
+ volume = {132},
+ pages = {103113},
+ year = {2023},
+ issn = {0959-1524},
+ doi = {https://doi.org/10.1016/j.jprocont.2023.103113},
+ url = {https://www.sciencedirect.com/science/article/pii/S0959152423002007},
+ author = {Robert B. Parker and Bethany L. Nicholson and John D. Siirola and Lorenz T. Biegler},
+ }
diff --git a/doc/OnlineDocs/contributed_packages/mpc/interface.rst b/doc/OnlineDocs/contributed_packages/mpc/interface.rst
new file mode 100644
index 00000000000..eb5bac548fd
--- /dev/null
+++ b/doc/OnlineDocs/contributed_packages/mpc/interface.rst
@@ -0,0 +1,8 @@
+Interfaces
+==========
+
+.. automodule:: pyomo.contrib.mpc.interfaces.model_interface
+ :members:
+
+.. automodule:: pyomo.contrib.mpc.interfaces.var_linker
+ :members:
diff --git a/doc/OnlineDocs/contributed_packages/mpc/modeling.rst b/doc/OnlineDocs/contributed_packages/mpc/modeling.rst
new file mode 100644
index 00000000000..cbae03161b1
--- /dev/null
+++ b/doc/OnlineDocs/contributed_packages/mpc/modeling.rst
@@ -0,0 +1,11 @@
+Modeling Components
+===================
+
+.. automodule:: pyomo.contrib.mpc.modeling.constraints
+ :members:
+
+.. automodule:: pyomo.contrib.mpc.modeling.cost_expressions
+ :members:
+
+.. automodule:: pyomo.contrib.mpc.modeling.terminal
+ :members:
diff --git a/doc/OnlineDocs/contributed_packages/parmest/datarec.rst b/doc/OnlineDocs/contributed_packages/parmest/datarec.rst
index 6b721377e46..2260450192c 100644
--- a/doc/OnlineDocs/contributed_packages/parmest/datarec.rst
+++ b/doc/OnlineDocs/contributed_packages/parmest/datarec.rst
@@ -3,56 +3,52 @@
Data Reconciliation
====================
-The method :class:`~pyomo.contrib.parmest.parmest.Estimator.theta_est`
-can optionally return model values. This feature can be used to return
-reconciled data using a user specified objective. In this case, the list
-of variable names the user wants to estimate (theta_names) is set to an
-empty list and the objective function is defined to minimize
+The optional argument ``return_values`` in :class:`~pyomo.contrib.parmest.parmest.Estimator.theta_est`
+can be used for data reconciliation or to return model values based on the specified objective.
+
+For data reconciliation, the ``m.unknown_parameters`` is empty
+and the objective function is defined to minimize
measurement to model error. Note that the model used for data
reconciliation may differ from the model used for parameter estimation.
-The following example illustrates the use of parmest for data
-reconciliation. The functions
+The functions
:class:`~pyomo.contrib.parmest.graphics.grouped_boxplot` or
:class:`~pyomo.contrib.parmest.graphics.grouped_violinplot` can be used
to visually compare the original and reconciled data.
-Here's a stylized code snippet showing how box plots might be created:
-
-.. doctest::
- :skipif: True
-
- >>> import pyomo.contrib.parmest.parmest as parmest
- >>> pest = parmest.Estimator(model_function, data, [], objective_function)
- >>> obj, theta, data_rec = pest.theta_est(return_values=['A', 'B'])
- >>> parmest.graphics.grouped_boxplot(data, data_rec)
-
-Returned Values
-^^^^^^^^^^^^^^^
+The following example from the reactor design subdirectory returns reconciled values for experiment outputs
+(`ca`, `cb`, `cc`, and `cd`) and then uses those values in
+parameter estimation (`k1`, `k2`, and `k3`).
-Here's a full program that can be run to see returned values (in this case it
-is the response function that is defined in the model file):
+.. literalinclude:: ../../../../pyomo/contrib/parmest/examples/reactor_design/datarec_example.py
+ :language: python
+
+The following example returns model values from a Pyomo Expression.
.. doctest::
:skipif: not ipopt_available or not parmest_available
>>> import pandas as pd
>>> import pyomo.contrib.parmest.parmest as parmest
- >>> from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import rooney_biegler_model
-
- >>> theta_names = ['asymptote', 'rate_constant']
+ >>> from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import RooneyBieglerExperiment
+ >>> # Generate data
>>> data = pd.DataFrame(data=[[1,8.3],[2,10.3],[3,19.0],
... [4,16.0],[5,15.6],[7,19.8]],
... columns=['hour', 'y'])
- >>> def SSE(model, data):
- ... expr = sum((data.y[i]\
- ... - model.response_function[data.hour[i]])**2 for i in data.index)
+ >>> # Create an experiment list
+ >>> exp_list = []
+ >>> for i in range(data.shape[0]):
+ ... exp_list.append(RooneyBieglerExperiment(data.loc[i, :]))
+
+ >>> # Define objective
+ >>> def SSE(model):
+ ... expr = (model.experiment_outputs[model.y]
+ ... - model.response_function[model.experiment_outputs[model.hour]]
+ ... ) ** 2
... return expr
- >>> pest = parmest.Estimator(rooney_biegler_model, data, theta_names, SSE,
- ... solver_options=None)
+ >>> pest = parmest.Estimator(exp_list, obj_function=SSE, solver_options=None)
>>> obj, theta, var_values = pest.theta_est(return_values=['response_function'])
>>> #print(var_values)
-
diff --git a/doc/OnlineDocs/contributed_packages/parmest/driver.rst b/doc/OnlineDocs/contributed_packages/parmest/driver.rst
index 28238928b83..5881d2748f9 100644
--- a/doc/OnlineDocs/contributed_packages/parmest/driver.rst
+++ b/doc/OnlineDocs/contributed_packages/parmest/driver.rst
@@ -4,7 +4,7 @@ Parameter Estimation
==================================
Parameter Estimation using parmest requires a Pyomo model, experimental
-data which defines multiple scenarios, and a list of parameter names
+data which defines multiple scenarios, and parameters
(thetas) to estimate. parmest uses Pyomo [PyomoBookII]_ and (optionally)
mpi-sppy [mpisppy]_ to solve a
two-stage stochastic programming problem, where the experimental data is
@@ -36,13 +36,12 @@ which includes the following methods:
~pyomo.contrib.parmest.parmest.Estimator.likelihood_ratio_test
~pyomo.contrib.parmest.parmest.Estimator.leaveNout_bootstrap_test
-Additional functions are available in parmest to group data, plot
-results, and fit distributions to theta values.
+Additional functions are available in parmest to plot
+results and fit distributions to theta values.
.. autosummary::
:nosignatures:
- ~pyomo.contrib.parmest.parmest.group_data
~pyomo.contrib.parmest.graphics.pairwise_plot
~pyomo.contrib.parmest.graphics.grouped_boxplot
~pyomo.contrib.parmest.graphics.grouped_violinplot
@@ -58,21 +57,33 @@ Section.
.. testsetup:: *
:skipif: not __import__('pyomo.contrib.parmest.parmest').contrib.parmest.parmest.parmest_available
+ # Data
import pandas as pd
- from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import rooney_biegler_model as model_function
- data = pd.DataFrame(data=[[1,8.3],[2,10.3],[3,19.0],
- [4,16.0],[5,15.6],[6,19.8]],
- columns=['hour', 'y'])
- theta_names = ['asymptote', 'rate_constant']
- def objective_function(model, data):
- expr = sum((data.y[i] - model.response_function[data.hour[i]])**2 for i in data.index)
+ data = pd.DataFrame(
+ data=[[1, 8.3], [2, 10.3], [3, 19.0],
+ [4, 16.0], [5, 15.6], [7, 19.8]],
+ columns=['hour', 'y'],
+ )
+
+ # Sum of squared error function
+ def SSE(model):
+ expr = (
+ model.experiment_outputs[model.y]
+ - model.response_function[model.experiment_outputs[model.hour]]
+ ) ** 2
return expr
+ # Create an experiment list
+ from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import RooneyBieglerExperiment
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(RooneyBieglerExperiment(data.loc[i, :]))
+
.. doctest::
:skipif: not __import__('pyomo.contrib.parmest.parmest').contrib.parmest.parmest.parmest_available
>>> import pyomo.contrib.parmest.parmest as parmest
- >>> pest = parmest.Estimator(model_function, data, theta_names, objective_function)
+ >>> pest = parmest.Estimator(exp_list, obj_function=SSE)
Optionally, solver options can be supplied, e.g.,
@@ -80,66 +91,44 @@ Optionally, solver options can be supplied, e.g.,
:skipif: not __import__('pyomo.contrib.parmest.parmest').contrib.parmest.parmest.parmest_available
>>> solver_options = {"max_iter": 6000}
- >>> pest = parmest.Estimator(model_function, data, theta_names, objective_function, solver_options)
-
-
-
-Model function
---------------
-
-The first argument is a function which uses data for a single scenario
-to return a populated and initialized Pyomo model for that scenario.
-
-Parameters that the user would like to estimate can be defined as
-**mutable parameters (Pyomo `Param`) or variables (Pyomo `Var`)**.
-Within parmest, any parameters that are to be estimated are converted to unfixed variables.
-Variables that are to be estimated are also unfixed.
-
-The model does not have to be specifically written as a
-two-stage stochastic programming problem for parmest.
-That is, parmest can modify the
-objective, see :ref:`ObjFunction` below.
-
-Data
-----
-
-The second argument is the data which will be used to populate the Pyomo
-model. Supported data formats include:
-
-* **Pandas Dataframe** where each row is a separate scenario and column
- names refer to observed quantities. Pandas DataFrames are easily
- stored and read in from csv, excel, or databases, or created directly
- in Python.
-* **List of Pandas Dataframe** where each entry in the list is a separate scenario.
- Dataframes store observed quantities, referenced by index and column.
-* **List of dictionaries** where each entry in the list is a separate
- scenario and the keys (or nested keys) refer to observed quantities.
- Dictionaries are often preferred over DataFrames when using static and
- time series data. Dictionaries are easily stored and read in from
- json or yaml files, or created directly in Python.
-* **List of json file names** where each entry in the list contains a
- json file name for a separate scenario. This format is recommended
- when using large datasets in parallel computing.
-
-The data must be compatible with the model function that returns a
-populated and initialized Pyomo model for a single scenario. Data can
-include multiple entries per variable (time series and/or duplicate
-sensors). This information can be included in custom objective
-functions, see :ref:`ObjFunction` below.
-
-Theta names
------------
-
-The third argument is a list of parameters or variable names that the user wants to
-estimate. The list contains strings with `Param` and/or `Var` names from the Pyomo
-model.
+ >>> pest = parmest.Estimator(exp_list, obj_function=SSE, solver_options=solver_options)
+
+
+List of experiment objects
+--------------------------
+
+The first argument is a list of experiment objects which is used to
+create one labeled model for each expeirment.
+The template :class:`~pyomo.contrib.parmest.experiment.Experiment`
+can be used to generate a list of experiment objects.
+
+A labeled Pyomo model ``m`` has the following additional suffixes (Pyomo `Suffix`):
+
+* ``m.experiment_outputs`` which defines experiment output (Pyomo `Param`, `Var`, or `Expression`)
+ and their associated data values (float, int).
+* ``m.unknown_parameters`` which defines the mutable parameters or variables (Pyomo `Param` or `Var`)
+ to estimate along with their component unique identifier (Pyomo `ComponentUID`).
+ Within parmest, any parameters that are to be estimated are converted to unfixed variables.
+ Variables that are to be estimated are also unfixed.
+
+The experiment class has one required method:
+
+* :class:`~pyomo.contrib.parmest.experiment.Experiment.get_labeled_model` which returns the labeled Pyomo model.
+ Note that the model does not have to be specifically written as a
+ two-stage stochastic programming problem for parmest.
+ That is, parmest can modify the
+ objective, see :ref:`ObjFunction` below.
+
+Parmest comes with several :ref:`examplesection` that illustrates how to set up the list of experiment objects.
+The examples commonly include additional :class:`~pyomo.contrib.parmest.experiment.Experiment` class methods to
+create the model, finalize the model, and label the model. The user can customize methods to suit their needs.
.. _ObjFunction:
Objective function
------------------
-The fourth argument is an optional argument which defines the
+The second argument is an optional argument which defines the
optimization objective function to use in parameter estimation.
If no objective function is specified, the Pyomo model is used "as is" and
@@ -150,20 +139,27 @@ stochastic programming problem.
If the Pyomo model is not written as a two-stage stochastic programming problem in
this format, and/or if the user wants to use an objective that is
different than the original model, a custom objective function can be
-defined for parameter estimation. The objective function arguments
-include `model` and `data` and the objective function returns a Pyomo
+defined for parameter estimation. The objective function has a single argument,
+which is the model from a single experiment.
+The objective function returns a Pyomo
expression which is used to define "SecondStageCost". The objective
function can be used to customize data points and weights that are used
in parameter estimation.
+Parmest includes one built in objective function to compute the sum of squared errors ("SSE") between the
+``m.experiment_outputs`` model values and data values.
+
Suggested initialization procedure for parameter estimation problems
--------------------------------------------------------------------
To check the quality of initial guess values provided for the fitted parameters, we suggest solving a
square instance of the problem prior to solving the parameter estimation problem using the following steps:
-1. Create :class:`~pyomo.contrib.parmest.parmest.Estimator` object. To initialize the parameter estimation solve from the square problem solution, set optional argument ``solver_options = {bound_push: 1e-8}``.
+1. Create :class:`~pyomo.contrib.parmest.parmest.Estimator` object. To initialize the parameter
+estimation solve from the square problem solution, set optional argument ``solver_options = {bound_push: 1e-8}``.
-2. Call :class:`~pyomo.contrib.parmest.parmest.Estimator.objective_at_theta` with optional argument ``(initialize_parmest_model=True)``. Different initial guess values for the fitted parameters can be provided using optional argument `theta_values` (**Pandas Dataframe**)
+2. Call :class:`~pyomo.contrib.parmest.parmest.Estimator.objective_at_theta` with optional
+argument ``(initialize_parmest_model=True)``. Different initial guess values for the fitted
+parameters can be provided using optional argument `theta_values` (**Pandas Dataframe**)
3. Solve parameter estimation problem by calling :class:`~pyomo.contrib.parmest.parmest.Estimator.theta_est`
diff --git a/doc/OnlineDocs/contributed_packages/parmest/examples.rst b/doc/OnlineDocs/contributed_packages/parmest/examples.rst
index 793ff3d0c8d..a59d79dfa2b 100644
--- a/doc/OnlineDocs/contributed_packages/parmest/examples.rst
+++ b/doc/OnlineDocs/contributed_packages/parmest/examples.rst
@@ -20,7 +20,7 @@ Additional use cases include:
* Parameter estimation using mpi4py, the example saves results to a file
for later analysis/graphics (semibatch example)
-The description below uses the reactor design example. The file
+The example below uses the reactor design example. The file
**reactor_design.py** includes a function which returns an populated
instance of the Pyomo model. Note that the model is defined to maximize
`cb` and that `k1`, `k2`, and `k3` are fixed. The _main_ program is
diff --git a/doc/OnlineDocs/contributed_packages/parmest/scencreate.rst b/doc/OnlineDocs/contributed_packages/parmest/scencreate.rst
index 66d41d4c606..b63ac5893c2 100644
--- a/doc/OnlineDocs/contributed_packages/parmest/scencreate.rst
+++ b/doc/OnlineDocs/contributed_packages/parmest/scencreate.rst
@@ -18,5 +18,5 @@ scenarios to the screen, accessing them via the ``ScensItator`` a ``print``
:language: python
.. note::
- This example may produce an error message your version of Ipopt is not based
+ This example may produce an error message if your version of Ipopt is not based
on a good linear solver.
diff --git a/doc/OnlineDocs/contributed_packages/pynumero/backward_compatibility.rst b/doc/OnlineDocs/contributed_packages/pynumero/backward_compatibility.rst
new file mode 100644
index 00000000000..036a00bee62
--- /dev/null
+++ b/doc/OnlineDocs/contributed_packages/pynumero/backward_compatibility.rst
@@ -0,0 +1,14 @@
+Backward Compatibility
+======================
+
+While PyNumero is a third-party contribution to Pyomo, we intend to maintain
+the stability of its core functionality. The core functionality of PyNumero
+consists of:
+
+1. The ``NLP`` API and ``PyomoNLP`` implementation of this API
+2. HSL and MUMPS linear solver interfaces
+3. ``BlockVector`` and ``BlockMatrix`` classes
+4. CyIpopt and SciPy solver interfaces
+
+Other parts of PyNumero, such as ``ExternalGreyBoxBlock`` and
+``ImplicitFunctionSolver``, are experimental and subject to change without notice.
diff --git a/doc/OnlineDocs/contributed_packages/pynumero/index.rst b/doc/OnlineDocs/contributed_packages/pynumero/index.rst
index 6ff8b29f812..711bb83eb3b 100644
--- a/doc/OnlineDocs/contributed_packages/pynumero/index.rst
+++ b/doc/OnlineDocs/contributed_packages/pynumero/index.rst
@@ -13,6 +13,7 @@ PyNumero. For more details, see the API documentation (:ref:`pynumero_api`).
installation.rst
tutorial.rst
api.rst
+ backward_compatibility.rst
Developers
diff --git a/doc/OnlineDocs/contributed_packages/pynumero/pynumero.sparse.block_vector.rst b/doc/OnlineDocs/contributed_packages/pynumero/pynumero.sparse.block_vector.rst
index 6e1dc1f20e5..c17d3d1df86 100644
--- a/doc/OnlineDocs/contributed_packages/pynumero/pynumero.sparse.block_vector.rst
+++ b/doc/OnlineDocs/contributed_packages/pynumero/pynumero.sparse.block_vector.rst
@@ -77,7 +77,7 @@ NumPy compatible functions:
* `numpy.arccos() `_
* `numpy.sinh() `_
* `numpy.cosh() `_
- * `numpy.abs() `_
+ * `numpy.abs() `_
* `numpy.tanh() `_
* `numpy.arccosh() `_
* `numpy.arcsinh() `_
diff --git a/doc/OnlineDocs/contributed_packages/pyros.rst b/doc/OnlineDocs/contributed_packages/pyros.rst
index 3062bdf1ee8..95049eded8a 100644
--- a/doc/OnlineDocs/contributed_packages/pyros.rst
+++ b/doc/OnlineDocs/contributed_packages/pyros.rst
@@ -142,6 +142,7 @@ PyROS Solver Interface
Otherwise, the solution returned is certified to only be robust feasible.
+
PyROS Uncertainty Sets
-----------------------------
Uncertainty sets are represented by subclasses of
@@ -518,7 +519,7 @@ correspond to first-stage degrees of freedom.
>>> # === Designate which variables correspond to first-stage
>>> # and second-stage degrees of freedom ===
- >>> first_stage_variables =[
+ >>> first_stage_variables = [
... m.x1, m.x2, m.x3, m.x4, m.x5, m.x6,
... m.x19, m.x20, m.x21, m.x22, m.x23, m.x24, m.x31,
... ]
@@ -657,6 +658,54 @@ For this example, we notice a ~25% decrease in the final objective
value when switching from a static decision rule (no second-stage recourse)
to an affine decision rule.
+
+Specifying Arguments Indirectly Through ``options``
+"""""""""""""""""""""""""""""""""""""""""""""""""""
+Like other Pyomo solver interface methods,
+:meth:`~pyomo.contrib.pyros.PyROS.solve`
+provides support for specifying options indirectly by passing
+a keyword argument ``options``, whose value must be a :class:`dict`
+mapping names of arguments to :meth:`~pyomo.contrib.pyros.PyROS.solve`
+to their desired values.
+For example, the ``solve()`` statement in the
+:ref:`two-stage problem snippet `
+could have been equivalently written as:
+
+.. doctest::
+ :skipif: not (baron.available() and baron.license_is_valid())
+
+ >>> results_2 = pyros_solver.solve(
+ ... model=m,
+ ... first_stage_variables=first_stage_variables,
+ ... second_stage_variables=second_stage_variables,
+ ... uncertain_params=uncertain_parameters,
+ ... uncertainty_set=box_uncertainty_set,
+ ... local_solver=local_solver,
+ ... global_solver=global_solver,
+ ... options={
+ ... "objective_focus": pyros.ObjectiveType.worst_case,
+ ... "solve_master_globally": True,
+ ... "decision_rule_order": 1,
+ ... },
+ ... )
+ ==============================================================================
+ PyROS: The Pyomo Robust Optimization Solver...
+ ...
+ ------------------------------------------------------------------------------
+ Robust optimal solution identified.
+ ------------------------------------------------------------------------------
+ ...
+ ------------------------------------------------------------------------------
+ All done. Exiting PyROS.
+ ==============================================================================
+
+In the event an argument is passed directly
+by position or keyword, *and* indirectly through ``options``,
+an appropriate warning is issued,
+and the value passed directly takes precedence over the value
+passed through ``options``.
+
+
The Price of Robustness
""""""""""""""""""""""""
In conjunction with standard Python control flow tools,
@@ -854,10 +903,10 @@ Observe that the log contains the following information:
:linenos:
==============================================================================
- PyROS: The Pyomo Robust Optimization Solver, v1.2.9.
- Pyomo version: 6.7.0
+ PyROS: The Pyomo Robust Optimization Solver, v1.2.11.
+ Pyomo version: 6.7.2
Commit hash: unknown
- Invoked at UTC 2023-12-16T00:00:00.000000
+ Invoked at UTC 2024-03-28T00:00:00.000000
Developed by: Natalie M. Isenberg (1), Jason A. F. Sherman (1),
John D. Siirola (2), Chrysanthos E. Gounaris (1)
@@ -877,6 +926,7 @@ Observe that the log contains the following information:
keepfiles=False
tee=False
load_solution=True
+ symbolic_solver_labels=False
objective_focus=
nominal_uncertain_param_vals=[0.13248000000000001, 4.97, 4.97, 1800]
decision_rule_order=1
diff --git a/doc/OnlineDocs/contribution_guide.rst b/doc/OnlineDocs/contribution_guide.rst
index 10670627546..9ad5bdfee0e 100644
--- a/doc/OnlineDocs/contribution_guide.rst
+++ b/doc/OnlineDocs/contribution_guide.rst
@@ -71,6 +71,10 @@ at least 70% coverage of the lines modified in the PR and prefer coverage
closer to 90%. We also require that all tests pass before a PR will be
merged.
+.. note::
+ If you are having issues getting tests to pass on your Pull Request,
+ please tag any of the core developers to ask for help.
+
The Pyomo main branch provides a Github Actions workflow (configured
in the ``.github/`` directory) that will test any changes pushed to
a branch with a subset of the complete test harness that includes
@@ -82,13 +86,16 @@ This will enable the tests to run automatically with each push to your fork.
At any point in the development cycle, a "work in progress" pull request
may be opened by including '[WIP]' at the beginning of the PR
-title. This allows your code changes to be tested by the full suite of
-Pyomo's automatic
-testing infrastructure. Any pull requests marked '[WIP]' will not be
+title. Any pull requests marked '[WIP]' or draft will not be
reviewed or merged by the core development team. However, any
'[WIP]' pull request left open for an extended period of time without
active development may be marked 'stale' and closed.
+.. note::
+ Draft and WIP Pull Requests will **NOT** trigger tests. This is an effort to
+ reduce our CI backlog. Please make use of the provided
+ branch test suite for evaluating / testing draft functionality.
+
Python Version Support
++++++++++++++++++++++
@@ -397,50 +404,10 @@ Contrib packages will be tested along with Pyomo. If test failures
arise, then these packages will be disabled and an issue will be
created to resolve these test failures.
-The following two examples illustrate the two ways
-that ``pyomo.contrib`` can be used to integrate third-party
-contributions.
-
-Including External Packages
-+++++++++++++++++++++++++++
-
-The `pyomocontrib_simplemodel
-`_ package
-is derived from Pyomo, and it defines the class SimpleModel that
-illustrates how Pyomo can be used in a simple, less object-oriented
-manner. Specifically, this class mimics the modeling style supported
-by `PuLP `_.
-
-While ``pyomocontrib_simplemodel`` can be installed and used separate
-from Pyomo, this package is included in ``pyomo/contrib/simplemodel``.
-This allows this package to be referenced as if were defined as a
-subpackage of ``pyomo.contrib``. For example::
-
- from pyomo.contrib.simplemodel import *
- from math import pi
-
- m = SimpleModel()
-
- r = m.var('r', bounds=(0,None))
- h = m.var('h', bounds=(0,None))
-
- m += 2*pi*r*(r + h)
- m += pi*h*r**2 == 355
-
- status = m.solve("ipopt")
-
-This example illustrates that a package can be distributed separate
-from Pyomo while appearing to be included in the ``pyomo.contrib``
-subpackage. Pyomo requires a separate directory be defined under
-``pyomo/contrib`` for each such package, and the Pyomo developer
-team will approve the inclusion of third-party packages in this
-manner.
-
-
Contrib Packages within Pyomo
+++++++++++++++++++++++++++++
-Third-party contributions can also be included directly within the
+Third-party contributions can be included directly within the
``pyomo.contrib`` package. The ``pyomo/contrib/example`` package
provides an example of how this can be done, including a directory
for plugins and package tests. For example, this package can be
@@ -458,7 +425,7 @@ import this package, but if an import failure occurs, Pyomo will
silently ignore it. Otherwise, this pyomo package will be treated
like any other. Specifically:
-* Plugin classes defined in this package are loaded when `pyomo.environ` is loaded.
+* Plugin classes defined in this package are loaded when ``pyomo.environ`` is loaded.
* Tests in this package are run with other Pyomo tests.
diff --git a/doc/OnlineDocs/developer_reference/future.rst b/doc/OnlineDocs/developer_reference/future.rst
new file mode 100644
index 00000000000..531c0fdb5c6
--- /dev/null
+++ b/doc/OnlineDocs/developer_reference/future.rst
@@ -0,0 +1,3 @@
+
+.. automodule:: pyomo.__future__
+ :noindex:
diff --git a/doc/OnlineDocs/developer_reference/index.rst b/doc/OnlineDocs/developer_reference/index.rst
index 8c29150015c..0feb33cdab9 100644
--- a/doc/OnlineDocs/developer_reference/index.rst
+++ b/doc/OnlineDocs/developer_reference/index.rst
@@ -12,3 +12,5 @@ scripts using Pyomo.
config.rst
deprecation.rst
expressions/index.rst
+ future.rst
+ solvers.rst
diff --git a/doc/OnlineDocs/developer_reference/solvers.rst b/doc/OnlineDocs/developer_reference/solvers.rst
new file mode 100644
index 00000000000..9e3281246f4
--- /dev/null
+++ b/doc/OnlineDocs/developer_reference/solvers.rst
@@ -0,0 +1,351 @@
+Future Solver Interface Changes
+===============================
+
+.. note::
+
+ The new solver interfaces are still under active development. They
+ are included in the releases as development previews. Please be
+ aware that APIs and functionality may change with no notice.
+
+ We welcome any feedback and ideas as we develop this capability.
+ Please post feedback on
+ `Issue 1030 `_.
+
+Pyomo offers interfaces into multiple solvers, both commercial and open
+source. To support better capabilities for solver interfaces, the Pyomo
+team is actively redesigning the existing interfaces to make them more
+maintainable and intuitive for use. A preview of the redesigned
+interfaces can be found in ``pyomo.contrib.solver``.
+
+.. currentmodule:: pyomo.contrib.solver
+
+
+New Interface Usage
+-------------------
+
+The new interfaces are not completely backwards compatible with the
+existing Pyomo solver interfaces. However, to aid in testing and
+evaluation, we are distributing versions of the new solver interfaces
+that are compatible with the existing ("legacy") solver interface.
+These "legacy" interfaces are registered with the current
+``SolverFactory`` using slightly different names (to avoid conflicts
+with existing interfaces).
+
+.. |br| raw:: html
+
+
+
+.. list-table:: Available Redesigned Solvers and Names Registered
+ in the SolverFactories
+ :header-rows: 1
+
+ * - Solver
+ - Name registered in the |br| ``pyomo.contrib.solver.factory.SolverFactory``
+ - Name registered in the |br| ``pyomo.opt.base.solvers.LegacySolverFactory``
+ * - Ipopt
+ - ``ipopt``
+ - ``ipopt_v2``
+ * - Gurobi (persistent)
+ - ``gurobi``
+ - ``gurobi_v2``
+ * - Gurobi (direct)
+ - ``gurobi_direct``
+ - ``gurobi_direct_v2``
+
+Using the new interfaces through the legacy interface
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Here we use the new interface as exposed through the existing (legacy)
+solver factory and solver interface wrapper. This provides an API that
+is compatible with the existing (legacy) Pyomo solver interface and can
+be used with other Pyomo tools / capabilities.
+
+.. testcode::
+ :skipif: not ipopt_available
+
+ import pyomo.environ as pyo
+ from pyomo.contrib.solver.util import assert_optimal_termination
+
+ model = pyo.ConcreteModel()
+ model.x = pyo.Var(initialize=1.5)
+ model.y = pyo.Var(initialize=1.5)
+
+ def rosenbrock(model):
+ return (1.0 - model.x) ** 2 + 100.0 * (model.y - model.x**2) ** 2
+
+ model.obj = pyo.Objective(rule=rosenbrock, sense=pyo.minimize)
+
+ status = pyo.SolverFactory('ipopt_v2').solve(model)
+ assert_optimal_termination(status)
+ model.pprint()
+
+.. testoutput::
+ :skipif: not ipopt_available
+ :hide:
+
+ 2 Var Declarations
+ ...
+ 3 Declarations: x y obj
+
+In keeping with our commitment to backwards compatibility, both the legacy and
+future methods of specifying solver options are supported:
+
+.. testcode::
+ :skipif: not ipopt_available
+
+ import pyomo.environ as pyo
+
+ model = pyo.ConcreteModel()
+ model.x = pyo.Var(initialize=1.5)
+ model.y = pyo.Var(initialize=1.5)
+
+ def rosenbrock(model):
+ return (1.0 - model.x) ** 2 + 100.0 * (model.y - model.x**2) ** 2
+
+ model.obj = pyo.Objective(rule=rosenbrock, sense=pyo.minimize)
+
+ # Backwards compatible
+ status = pyo.SolverFactory('ipopt_v2').solve(model, options={'max_iter' : 6})
+ # Forwards compatible
+ status = pyo.SolverFactory('ipopt_v2').solve(model, solver_options={'max_iter' : 6})
+ model.pprint()
+
+.. testoutput::
+ :skipif: not ipopt_available
+ :hide:
+
+ 2 Var Declarations
+ ...
+ 3 Declarations: x y obj
+
+Using the new interfaces directly
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Here we use the new interface by importing it directly:
+
+.. testcode::
+ :skipif: not ipopt_available
+
+ # Direct import
+ import pyomo.environ as pyo
+ from pyomo.contrib.solver.util import assert_optimal_termination
+ from pyomo.contrib.solver.ipopt import Ipopt
+
+ model = pyo.ConcreteModel()
+ model.x = pyo.Var(initialize=1.5)
+ model.y = pyo.Var(initialize=1.5)
+
+ def rosenbrock(model):
+ return (1.0 - model.x) ** 2 + 100.0 * (model.y - model.x**2) ** 2
+
+ model.obj = pyo.Objective(rule=rosenbrock, sense=pyo.minimize)
+
+ opt = Ipopt()
+ status = opt.solve(model)
+ assert_optimal_termination(status)
+ # Displays important results information; only available through the new interfaces
+ status.display()
+ model.pprint()
+
+.. testoutput::
+ :skipif: not ipopt_available
+ :hide:
+
+ solution_loader: ...
+ ...
+ 3 Declarations: x y obj
+
+Using the new interfaces through the "new" SolverFactory
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Here we use the new interface by retrieving it from the new ``SolverFactory``:
+
+.. testcode::
+ :skipif: not ipopt_available
+
+ # Import through new SolverFactory
+ import pyomo.environ as pyo
+ from pyomo.contrib.solver.util import assert_optimal_termination
+ from pyomo.contrib.solver.factory import SolverFactory
+
+ model = pyo.ConcreteModel()
+ model.x = pyo.Var(initialize=1.5)
+ model.y = pyo.Var(initialize=1.5)
+
+ def rosenbrock(model):
+ return (1.0 - model.x) ** 2 + 100.0 * (model.y - model.x**2) ** 2
+
+ model.obj = pyo.Objective(rule=rosenbrock, sense=pyo.minimize)
+
+ opt = SolverFactory('ipopt')
+ status = opt.solve(model)
+ assert_optimal_termination(status)
+ # Displays important results information; only available through the new interfaces
+ status.display()
+ model.pprint()
+
+.. testoutput::
+ :skipif: not ipopt_available
+ :hide:
+
+ solution_loader: ...
+ ...
+ 3 Declarations: x y obj
+
+Switching all of Pyomo to use the new interfaces
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We also provide a mechanism to get a "preview" of the future where we
+replace the existing (legacy) SolverFactory and utilities with the new
+(development) version (see :doc:`future`):
+
+.. testcode::
+ :skipif: not ipopt_available
+
+ # Change default SolverFactory version
+ import pyomo.environ as pyo
+ from pyomo.contrib.solver.util import assert_optimal_termination
+ from pyomo.__future__ import solver_factory_v3
+
+ model = pyo.ConcreteModel()
+ model.x = pyo.Var(initialize=1.5)
+ model.y = pyo.Var(initialize=1.5)
+
+ def rosenbrock(model):
+ return (1.0 - model.x) ** 2 + 100.0 * (model.y - model.x**2) ** 2
+
+ model.obj = pyo.Objective(rule=rosenbrock, sense=pyo.minimize)
+
+ status = pyo.SolverFactory('ipopt').solve(model)
+ assert_optimal_termination(status)
+ # Displays important results information; only available through the new interfaces
+ status.display()
+ model.pprint()
+
+.. testoutput::
+ :skipif: not ipopt_available
+ :hide:
+
+ solution_loader: ...
+ ...
+ 3 Declarations: x y obj
+
+.. testcode::
+ :skipif: not ipopt_available
+ :hide:
+
+ from pyomo.__future__ import solver_factory_v1
+
+Linear Presolve and Scaling
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The new interface allows access to new capabilities in the various
+problem writers, including the linear presolve and scaling options
+recently incorporated into the redesigned NL writer. For example, you
+can control the NL writer in the new ``ipopt`` interface through the
+solver's ``writer_config`` configuration option:
+
+.. autoclass:: pyomo.contrib.solver.ipopt.Ipopt
+ :members: solve
+
+.. testcode::
+
+ from pyomo.contrib.solver.ipopt import Ipopt
+ opt = Ipopt()
+ opt.config.writer_config.display()
+
+.. testoutput::
+
+ show_section_timing: false
+ skip_trivial_constraints: true
+ file_determinism: FileDeterminism.ORDERED
+ symbolic_solver_labels: false
+ scale_model: true
+ export_nonlinear_variables: None
+ row_order: None
+ column_order: None
+ export_defined_variables: true
+ linear_presolve: true
+
+Note that, by default, both ``linear_presolve`` and ``scale_model`` are enabled.
+Users can manipulate ``linear_presolve`` and ``scale_model`` to their preferred
+states by changing their values.
+
+.. code-block:: python
+
+ >>> opt.config.writer_config.linear_presolve = False
+
+
+Interface Implementation
+------------------------
+
+All new interfaces should be built upon one of two classes (currently):
+:class:`SolverBase` or
+:class:`PersistentSolverBase`.
+
+All solvers should have the following:
+
+.. autoclass:: pyomo.contrib.solver.base.SolverBase
+ :members:
+
+Persistent solvers include additional members as well as other configuration options:
+
+.. autoclass:: pyomo.contrib.solver.base.PersistentSolverBase
+ :show-inheritance:
+ :members:
+
+Results
+-------
+
+Every solver, at the end of a
+:meth:`solve` call, will
+return a :class:`Results`
+object. This object is a :py:class:`pyomo.common.config.ConfigDict`,
+which can be manipulated similar to a standard ``dict`` in Python.
+
+.. autoclass:: pyomo.contrib.solver.results.Results
+ :show-inheritance:
+ :members:
+ :undoc-members:
+
+
+Termination Conditions
+^^^^^^^^^^^^^^^^^^^^^^
+
+Pyomo offers a standard set of termination conditions to map to solver
+returns. The intent of
+:class:`TerminationCondition`
+is to notify the user of why the solver exited. The user is expected
+to inspect the :class:`Results`
+object or any returned solver messages or logs for more information.
+
+.. autoclass:: pyomo.contrib.solver.results.TerminationCondition
+ :show-inheritance:
+
+
+Solution Status
+^^^^^^^^^^^^^^^
+
+Pyomo offers a standard set of solution statuses to map to solver
+output. The intent of
+:class:`SolutionStatus`
+is to notify the user of what the solver returned at a high level. The
+user is expected to inspect the
+:class:`Results` object or any
+returned solver messages or logs for more information.
+
+.. autoclass:: pyomo.contrib.solver.results.SolutionStatus
+ :show-inheritance:
+
+
+Solution
+--------
+
+Solutions can be loaded back into a model using a ``SolutionLoader``. A specific
+loader should be written for each unique case. Several have already been
+implemented. For example, for ``ipopt``:
+
+.. autoclass:: pyomo.contrib.solver.ipopt.IpoptSolutionLoader
+ :show-inheritance:
+ :members:
+ :inherited-members:
diff --git a/doc/OnlineDocs/installation.rst b/doc/OnlineDocs/installation.rst
index ecba05e13fb..83cd08e7a4a 100644
--- a/doc/OnlineDocs/installation.rst
+++ b/doc/OnlineDocs/installation.rst
@@ -12,7 +12,7 @@ version, Pyomo will remove testing for that Python version.
Using CONDA
~~~~~~~~~~~
-We recommend installation with *conda*, which is included with the
+We recommend installation with ``conda``, which is included with the
Anaconda distribution of Python. You can install Pyomo in your system
Python installation by executing the following in a shell:
@@ -21,7 +21,7 @@ Python installation by executing the following in a shell:
conda install -c conda-forge pyomo
Optimization solvers are not installed with Pyomo, but some open source
-optimization solvers can be installed with conda as well:
+optimization solvers can be installed with ``conda`` as well:
::
@@ -31,7 +31,7 @@ optimization solvers can be installed with conda as well:
Using PIP
~~~~~~~~~
-The standard utility for installing Python packages is *pip*. You
+The standard utility for installing Python packages is ``pip``. You
can install Pyomo in your system Python installation by executing
the following in a shell:
@@ -43,14 +43,14 @@ the following in a shell:
Conditional Dependencies
~~~~~~~~~~~~~~~~~~~~~~~~
-Extensions to Pyomo, and many of the contributions in `pyomo.contrib`,
+Extensions to Pyomo, and many of the contributions in ``pyomo.contrib``,
often have conditional dependencies on a variety of third-party Python
packages including but not limited to: matplotlib, networkx, numpy,
openpyxl, pandas, pint, pymysql, pyodbc, pyro4, scipy, sympy, and
xlrd.
A full list of conditional dependencies can be found in Pyomo's
-`setup.py` and displayed using:
+``setup.py`` and displayed using:
::
@@ -72,3 +72,28 @@ with the standard Anaconda installation.
You can check which Python packages you have installed using the command
``conda list`` or ``pip list``. Additional Python packages may be
installed as needed.
+
+
+Installation with Cython
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Users can opt to install Pyomo with
+`cython `_
+initialized.
+
+.. note::
+ This can only be done via ``pip`` or from source.
+
+Via ``pip``:
+
+::
+
+ pip install pyomo --global-option="--with-cython"
+
+From source (recommended for advanced users only):
+
+::
+
+ git clone https://github.com/Pyomo/pyomo.git
+ cd pyomo
+ python setup.py install --with-cython
diff --git a/doc/OnlineDocs/library_reference/appsi/appsi.solvers.maingo.rst b/doc/OnlineDocs/library_reference/appsi/appsi.solvers.maingo.rst
new file mode 100644
index 00000000000..21e61c38d51
--- /dev/null
+++ b/doc/OnlineDocs/library_reference/appsi/appsi.solvers.maingo.rst
@@ -0,0 +1,14 @@
+MAiNGO
+======
+
+.. autoclass:: pyomo.contrib.appsi.solvers.maingo.MAiNGOConfig
+ :members:
+ :inherited-members:
+ :undoc-members:
+ :show-inheritance:
+
+.. autoclass:: pyomo.contrib.appsi.solvers.maingo.MAiNGO
+ :members:
+ :inherited-members:
+ :undoc-members:
+ :show-inheritance:
diff --git a/doc/OnlineDocs/library_reference/appsi/appsi.solvers.rst b/doc/OnlineDocs/library_reference/appsi/appsi.solvers.rst
index 1c598d95628..f4dcb81b4be 100644
--- a/doc/OnlineDocs/library_reference/appsi/appsi.solvers.rst
+++ b/doc/OnlineDocs/library_reference/appsi/appsi.solvers.rst
@@ -13,3 +13,4 @@ Solvers
appsi.solvers.cplex
appsi.solvers.cbc
appsi.solvers.highs
+ appsi.solvers.maingo
diff --git a/doc/OnlineDocs/library_reference/common/config.rst b/doc/OnlineDocs/library_reference/common/config.rst
index 7a400b26ce3..c5dc607977a 100644
--- a/doc/OnlineDocs/library_reference/common/config.rst
+++ b/doc/OnlineDocs/library_reference/common/config.rst
@@ -36,6 +36,7 @@ Domain validators
NonPositiveFloat
NonNegativeFloat
In
+ IsInstance
InEnum
ListOf
Module
@@ -75,6 +76,7 @@ Domain validators
.. autofunction:: NonPositiveFloat
.. autofunction:: NonNegativeFloat
.. autoclass:: In
+.. autoclass:: IsInstance
.. autoclass:: InEnum
.. autoclass:: ListOf
.. autoclass:: Module
diff --git a/doc/OnlineDocs/library_reference/common/enums.rst b/doc/OnlineDocs/library_reference/common/enums.rst
new file mode 100644
index 00000000000..5ed2dbb1e80
--- /dev/null
+++ b/doc/OnlineDocs/library_reference/common/enums.rst
@@ -0,0 +1,7 @@
+
+pyomo.common.enums
+==================
+
+.. automodule:: pyomo.common.enums
+ :members:
+ :member-order: bysource
diff --git a/doc/OnlineDocs/library_reference/common/index.rst b/doc/OnlineDocs/library_reference/common/index.rst
index c9c99008250..c03436600f2 100644
--- a/doc/OnlineDocs/library_reference/common/index.rst
+++ b/doc/OnlineDocs/library_reference/common/index.rst
@@ -11,6 +11,7 @@ or rely on any other parts of Pyomo.
config.rst
dependencies.rst
deprecation.rst
+ enums.rst
errors.rst
fileutils.rst
formatting.rst
diff --git a/doc/OnlineDocs/library_reference/expressions/context_managers.rst b/doc/OnlineDocs/library_reference/expressions/context_managers.rst
index 0e92f583c73..ae6884d684f 100644
--- a/doc/OnlineDocs/library_reference/expressions/context_managers.rst
+++ b/doc/OnlineDocs/library_reference/expressions/context_managers.rst
@@ -8,6 +8,3 @@ Context Managers
.. autoclass:: pyomo.core.expr.linear_expression
:members:
-.. autoclass:: pyomo.core.expr.current.clone_counter
- :members:
-
diff --git a/doc/OnlineDocs/modeling_extensions/dae.rst b/doc/OnlineDocs/modeling_extensions/dae.rst
index 703e83f4f14..ff0fb75e610 100644
--- a/doc/OnlineDocs/modeling_extensions/dae.rst
+++ b/doc/OnlineDocs/modeling_extensions/dae.rst
@@ -738,7 +738,7 @@ supported by CasADi. A list of available integrators for each package is
given below. Please refer to the `SciPy
`_
and `CasADi
-`_ documentation directly for the most up-to-date information about
+`_ documentation directly for the most up-to-date information about
these packages and for more information about the various integrators and
options.
diff --git a/doc/OnlineDocs/src/expr/managing.py b/doc/OnlineDocs/src/expr/managing.py
index 00d521d16ab..ff149e4fd5c 100644
--- a/doc/OnlineDocs/src/expr/managing.py
+++ b/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
diff --git a/doc/OnlineDocs/tutorial_examples.rst b/doc/OnlineDocs/tutorial_examples.rst
index dc58b6a6f59..a18f9d77d42 100644
--- a/doc/OnlineDocs/tutorial_examples.rst
+++ b/doc/OnlineDocs/tutorial_examples.rst
@@ -3,13 +3,18 @@ Pyomo Tutorial Examples
Additional Pyomo tutorials and examples can be found at the following links:
-`Pyomo Workshop Slides and Exercises
-`_
+* `Pyomo — Optimization Modeling in Python
+ `_ ([PyomoBookIII]_)
-`Prof. Jeffrey Kantor's Pyomo Cookbook
-`_
+* `Pyomo Workshop Slides and Exercises
+ `_
-`Pyomo Gallery
-`_
+* `Prof. Jeffrey Kantor's Pyomo Cookbook
+ `_
+
+* The `companion notebooks `_
+ for *Hands-On Mathematical Optimization with Python*
+
+* `Pyomo Gallery `_
diff --git a/examples/dae/ReactionKinetics.py b/examples/dae/ReactionKinetics.py
index fa747cf8b21..2e474ae40d3 100644
--- a/examples/dae/ReactionKinetics.py
+++ b/examples/dae/ReactionKinetics.py
@@ -304,7 +304,10 @@ def regression_model():
# Model & data from:
#
- # http://www.doiserbia.nb.rs/img/doi/0367-598X/2014/0367-598X1300037A.pdf
+ # https://doiserbia.nb.rs/img/doi/0367-598X/2014/0367-598X1300037A.pdf
+ # Almagrbi, A. M., Hatami, T., Glišić, S., & Orlović, A. (2014).
+ # Determination of kinetic parameters for complex transesterification
+ # reaction by standard optimisation methods.
#
model = ConcreteModel()
diff --git a/examples/pyomobook/pyomo-components-ch/obj_declaration.txt b/examples/pyomobook/pyomo-components-ch/obj_declaration.txt
index 607586a1fb3..e4d4b02a252 100644
--- a/examples/pyomobook/pyomo-components-ch/obj_declaration.txt
+++ b/examples/pyomobook/pyomo-components-ch/obj_declaration.txt
@@ -55,7 +55,7 @@ Model unknown
None
value
x[Q] + 2*x[R]
-1
+minimize
6.5
Model unknown
diff --git a/pyomo/__future__.py b/pyomo/__future__.py
new file mode 100644
index 00000000000..d298e12cab6
--- /dev/null
+++ b/pyomo/__future__.py
@@ -0,0 +1,118 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.environ as _environ
+
+__doc__ = """
+Preview capabilities through ``pyomo.__future__``
+=================================================
+
+This module provides a uniform interface for gaining access to future
+("preview") capabilities that are either slightly incompatible with the
+current official offering, or are still under development with the
+intent to replace the current offering.
+
+Currently supported ``__future__`` offerings include:
+
+.. autosummary::
+
+ solver_factory
+
+.. autofunction:: solver_factory
+
+"""
+
+
+def __getattr__(name):
+ if name in ('solver_factory_v1', 'solver_factory_v2', 'solver_factory_v3'):
+ return solver_factory(int(name[-1]))
+ raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+def solver_factory(version=None):
+ """Get (or set) the active implementation of the SolverFactory
+
+ This allows users to query / set the current implementation of the
+ SolverFactory that should be used throughout Pyomo. Valid options are:
+
+ - ``1``: the original Pyomo SolverFactory
+ - ``2``: the SolverFactory from APPSI
+ - ``3``: the SolverFactory from pyomo.contrib.solver
+
+ The current active version can be obtained by calling the method
+ with no arguments
+
+ .. doctest::
+
+ >>> from pyomo.__future__ import solver_factory
+ >>> solver_factory()
+ 1
+
+ The active factory can be set either by passing the appropriate
+ version to this function:
+
+ .. doctest::
+
+ >>> solver_factory(3)
+
+
+ or by importing the "special" name:
+
+ .. doctest::
+
+ >>> from pyomo.__future__ import solver_factory_v3
+
+ .. doctest::
+ :hide:
+
+ >>> from pyomo.__future__ import solver_factory_v1
+
+ """
+ import pyomo.opt.base.solvers as _solvers
+ import pyomo.contrib.solver.factory as _contrib
+ import pyomo.contrib.appsi.base as _appsi
+
+ versions = {
+ 1: _solvers.LegacySolverFactory,
+ 2: _appsi.SolverFactory,
+ 3: _contrib.SolverFactory,
+ }
+
+ current = getattr(solver_factory, '_active_version', None)
+ # First time through, _active_version is not defined. Go look and
+ # see what it was initialized to in pyomo.environ
+ if current is None:
+ for ver, cls in versions.items():
+ if cls._cls is _environ.SolverFactory._cls:
+ solver_factory._active_version = ver
+ break
+ return solver_factory._active_version
+ #
+ # The user is just asking what the current SolverFactory is; tell them.
+ if version is None:
+ return solver_factory._active_version
+ #
+ # Update the current SolverFactory to be a shim around (shallow copy
+ # of) the new active factory
+ src = versions.get(version, None)
+ if version is not None:
+ solver_factory._active_version = version
+ for attr in ('_description', '_cls', '_doc'):
+ setattr(_environ.SolverFactory, attr, getattr(src, attr))
+ else:
+ raise ValueError(
+ "Invalid value for target solver factory version; expected {1, 2, 3}, "
+ f"received {version}"
+ )
+ return src
+
+
+solver_factory._active_version = solver_factory()
diff --git a/pyomo/common/autoslots.py b/pyomo/common/autoslots.py
index cb79d4a0338..89fefaf4f21 100644
--- a/pyomo/common/autoslots.py
+++ b/pyomo/common/autoslots.py
@@ -29,7 +29,7 @@ def _deepcopy_tuple(obj, memo, _id):
unchanged = False
if unchanged:
# Python does not duplicate "unchanged" tuples (i.e. allows the
- # original objecct to be returned from deepcopy()). We will
+ # original object to be returned from deepcopy()). We will
# preserve that behavior here.
#
# It also appears to be faster *not* to cache the fact that this
diff --git a/pyomo/common/collections/__init__.py b/pyomo/common/collections/__init__.py
index 93785124e3c..717caf87b2c 100644
--- a/pyomo/common/collections/__init__.py
+++ b/pyomo/common/collections/__init__.py
@@ -14,6 +14,6 @@
from collections import UserDict
from .orderedset import OrderedDict, OrderedSet
-from .component_map import ComponentMap
+from .component_map import ComponentMap, DefaultComponentMap
from .component_set import ComponentSet
from .bunch import Bunch
diff --git a/pyomo/common/collections/component_map.py b/pyomo/common/collections/component_map.py
index 80ba5fe0d1c..8dcfdb6c837 100644
--- a/pyomo/common/collections/component_map.py
+++ b/pyomo/common/collections/component_map.py
@@ -9,21 +9,49 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-from collections.abc import MutableMapping as collections_MutableMapping
+import collections
from collections.abc import Mapping as collections_Mapping
from pyomo.common.autoslots import AutoSlots
-def _rebuild_ids(encode, val):
+def _rehash_keys(encode, val):
if encode:
return val
else:
# object id() may have changed after unpickling,
# so we rebuild the dictionary keys
- return {id(obj): (obj, v) for obj, v in val.values()}
+ return {_hasher[obj.__class__](obj): (obj, v) for obj, v in val.values()}
-class ComponentMap(AutoSlots.Mixin, collections_MutableMapping):
+class _Hasher(collections.defaultdict):
+ def __init__(self, *args, **kwargs):
+ super().__init__(lambda: self._missing_impl, *args, **kwargs)
+ self[tuple] = self._tuple
+
+ def _missing_impl(self, val):
+ try:
+ hash(val)
+ self[val.__class__] = self._hashable
+ except:
+ self[val.__class__] = self._unhashable
+ return self[val.__class__](val)
+
+ @staticmethod
+ def _hashable(val):
+ return val
+
+ @staticmethod
+ def _unhashable(val):
+ return id(val)
+
+ def _tuple(self, val):
+ return tuple(self[i.__class__](i) for i in val)
+
+
+_hasher = _Hasher()
+
+
+class ComponentMap(AutoSlots.Mixin, collections.abc.MutableMapping):
"""
This class is a replacement for dict that allows Pyomo
modeling components to be used as entry keys. The
@@ -49,18 +77,18 @@ class ComponentMap(AutoSlots.Mixin, collections_MutableMapping):
"""
__slots__ = ("_dict",)
- __autoslot_mappers__ = {'_dict': _rebuild_ids}
+ __autoslot_mappers__ = {'_dict': _rehash_keys}
def __init__(self, *args, **kwds):
- # maps id(obj) -> (obj,val)
+ # maps id_hash(obj) -> (obj,val)
self._dict = {}
# handle the dict-style initialization scenarios
self.update(*args, **kwds)
def __str__(self):
"""String representation of the mapping."""
- tmp = {str(c) + " (id=" + str(id(c)) + ")": v for c, v in self.items()}
- return "ComponentMap(" + str(tmp) + ")"
+ tmp = {f"{v[0]} (key={k})": v[1] for k, v in self._dict.items()}
+ return f"ComponentMap({tmp})"
#
# Implement MutableMapping abstract methods
@@ -68,18 +96,20 @@ def __str__(self):
def __getitem__(self, obj):
try:
- return self._dict[id(obj)][1]
+ return self._dict[_hasher[obj.__class__](obj)][1]
except KeyError:
- raise KeyError("Component with id '%s': %s" % (id(obj), str(obj)))
+ _id = _hasher[obj.__class__](obj)
+ raise KeyError(f"{obj} (key={_id})") from None
def __setitem__(self, obj, val):
- self._dict[id(obj)] = (obj, val)
+ self._dict[_hasher[obj.__class__](obj)] = (obj, val)
def __delitem__(self, obj):
try:
- del self._dict[id(obj)]
+ del self._dict[_hasher[obj.__class__](obj)]
except KeyError:
- raise KeyError("Component with id '%s': %s" % (id(obj), str(obj)))
+ _id = _hasher[obj.__class__](obj)
+ raise KeyError(f"{obj} (key={_id})") from None
def __iter__(self):
return (obj for obj, val in self._dict.values())
@@ -107,7 +137,7 @@ def __eq__(self, other):
return False
# Note we have already verified the dicts are the same size
for key, val in other.items():
- other_id = id(key)
+ other_id = _hasher[key.__class__](key)
if other_id not in self._dict:
return False
self_val = self._dict[other_id][1]
@@ -130,7 +160,7 @@ def __ne__(self, other):
#
def __contains__(self, obj):
- return id(obj) in self._dict
+ return _hasher[obj.__class__](obj) in self._dict
def clear(self):
'D.clear() -> None. Remove all items from D.'
@@ -149,3 +179,32 @@ def setdefault(self, key, default=None):
else:
self[key] = default
return default
+
+
+class DefaultComponentMap(ComponentMap):
+ """A :py:class:`defaultdict` admitting Pyomo Components as keys
+
+ This class is a replacement for defaultdict that allows Pyomo
+ modeling components to be used as entry keys. The base
+ implementation builds on :py:class:`ComponentMap`.
+
+ """
+
+ __slots__ = ('default_factory',)
+
+ def __init__(self, default_factory=None, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.default_factory = default_factory
+
+ def __missing__(self, key):
+ if self.default_factory is None:
+ raise KeyError(key)
+ self[key] = ans = self.default_factory()
+ return ans
+
+ def __getitem__(self, obj):
+ _key = _hasher[obj.__class__](obj)
+ if _key in self._dict:
+ return self._dict[_key][1]
+ else:
+ return self.__missing__(obj)
diff --git a/pyomo/common/collections/component_set.py b/pyomo/common/collections/component_set.py
index dfeac5cbfa5..6e12bad7277 100644
--- a/pyomo/common/collections/component_set.py
+++ b/pyomo/common/collections/component_set.py
@@ -12,8 +12,30 @@
from collections.abc import MutableSet as collections_MutableSet
from collections.abc import Set as collections_Set
+from pyomo.common.autoslots import AutoSlots
+from pyomo.common.collections.component_map import _hasher
+
+
+def _rehash_keys(encode, val):
+ if encode:
+ # TBD [JDS 2/2024]: if we
+ #
+ # return list(val.values())
+ #
+ # here, then we get a strange failure when deepcopying
+ # ComponentSets containing an _ImplicitAny domain. We could
+ # track it down to the implementation of
+ # autoslots.fast_deepcopy, but couldn't find an obvious bug.
+ # There is no error if we just return the original dict, or if
+ # we return a tuple(val.values)
+ return val
+ else:
+ # object id() may have changed after unpickling,
+ # so we rebuild the dictionary keys
+ return {_hasher[obj.__class__](obj): obj for obj in val.values()}
+
-class ComponentSet(collections_MutableSet):
+class ComponentSet(AutoSlots.Mixin, collections_MutableSet):
"""
This class is a replacement for set that allows Pyomo
modeling components to be used as entries. The
@@ -38,47 +60,32 @@ class ComponentSet(collections_MutableSet):
"""
__slots__ = ("_data",)
+ __autoslot_mappers__ = {'_data': _rehash_keys}
- def __init__(self, *args):
- self._data = dict()
- if len(args) > 0:
- if len(args) > 1:
- raise TypeError(
- "%s expected at most 1 arguments, "
- "got %s" % (self.__class__.__name__, len(args))
- )
- self.update(args[0])
+ def __init__(self, iterable=None):
+ # maps id_hash(obj) -> obj
+ self._data = {}
+ if iterable is not None:
+ self.update(iterable)
def __str__(self):
"""String representation of the mapping."""
- tmp = []
- for objid, obj in self._data.items():
- tmp.append(str(obj) + " (id=" + str(objid) + ")")
- return "ComponentSet(" + str(tmp) + ")"
+ tmp = [f"{v} (key={k})" for k, v in self._data.items()]
+ return f"ComponentSet({tmp})"
- def update(self, args):
+ def update(self, iterable):
"""Update a set with the union of itself and others."""
- self._data.update((id(obj), obj) for obj in args)
-
- #
- # This method must be defined for deepcopy/pickling
- # because this class relies on Python ids.
- #
- def __setstate__(self, state):
- # object id() may have changed after unpickling,
- # so we rebuild the dictionary keys
- assert len(state) == 1
- self._data = {id(obj): obj for obj in state['_data']}
-
- def __getstate__(self):
- return {'_data': tuple(self._data.values())}
+ if isinstance(iterable, ComponentSet):
+ self._data.update(iterable._data)
+ else:
+ self._data.update((_hasher[val.__class__](val), val) for val in iterable)
#
# Implement MutableSet abstract methods
#
def __contains__(self, val):
- return self._data.__contains__(id(val))
+ return _hasher[val.__class__](val) in self._data
def __iter__(self):
return iter(self._data.values())
@@ -88,27 +95,26 @@ def __len__(self):
def add(self, val):
"""Add an element."""
- self._data[id(val)] = val
+ self._data[_hasher[val.__class__](val)] = val
def discard(self, val):
"""Remove an element. Do not raise an exception if absent."""
- if id(val) in self._data:
- del self._data[id(val)]
+ _id = _hasher[val.__class__](val)
+ if _id in self._data:
+ del self._data[_id]
#
# Overload MutableSet default implementations
#
- # We want to avoid generating Pyomo expressions due to
- # comparison of values, so we convert both objects to a
- # plain dictionary mapping key->(type(val), id(val)) and
- # compare that instead.
def __eq__(self, other):
if self is other:
return True
if not isinstance(other, collections_Set):
return False
- return len(self) == len(other) and all(id(key) in self._data for key in other)
+ return len(self) == len(other) and all(
+ _hasher[val.__class__](val) in self._data for val in other
+ )
def __ne__(self, other):
return not (self == other)
@@ -125,6 +131,7 @@ def clear(self):
def remove(self, val):
"""Remove an element. If not a member, raise a KeyError."""
try:
- del self._data[id(val)]
+ del self._data[_hasher[val.__class__](val)]
except KeyError:
- raise KeyError("Component with id '%s': %s" % (id(val), str(val)))
+ _id = _hasher[val.__class__](val)
+ raise KeyError(f"{val} (key={_id})") from None
diff --git a/pyomo/common/collections/orderedset.py b/pyomo/common/collections/orderedset.py
index f29245b75fe..834101e3896 100644
--- a/pyomo/common/collections/orderedset.py
+++ b/pyomo/common/collections/orderedset.py
@@ -9,42 +9,30 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-from collections.abc import MutableSet
from collections import OrderedDict
+from collections.abc import MutableSet
+from pyomo.common.autoslots import AutoSlots
-class OrderedSet(MutableSet):
+class OrderedSet(AutoSlots.Mixin, MutableSet):
__slots__ = ('_dict',)
def __init__(self, iterable=None):
- # TODO: Starting in Python 3.7, dict is ordered (and is faster
- # than OrderedDict). dict began supporting reversed() in 3.8.
- # We should consider changing the underlying data type here from
- # OrderedDict to dict.
- self._dict = OrderedDict()
+ # Starting in Python 3.7, dict is ordered (and is faster than
+ # OrderedDict). dict began supporting reversed() in 3.8.
+ self._dict = {}
if iterable is not None:
- if iterable.__class__ is OrderedSet:
- self._dict.update(iterable._dict)
- else:
- self.update(iterable)
+ self.update(iterable)
def __str__(self):
"""String representation of the mapping."""
return "OrderedSet(%s)" % (', '.join(repr(x) for x in self))
def update(self, iterable):
- for val in iterable:
- self.add(val)
-
- #
- # This method must be defined for deepcopy/pickling
- # because this class is slotized.
- #
- def __setstate__(self, state):
- self._dict = state
-
- def __getstate__(self):
- return self._dict
+ if isinstance(iterable, OrderedSet):
+ self._dict.update(iterable._dict)
+ else:
+ self._dict.update((val, None) for val in iterable)
#
# Implement MutableSet abstract methods
diff --git a/pyomo/common/config.py b/pyomo/common/config.py
index 92613266885..f9c3a725bb8 100644
--- a/pyomo/common/config.py
+++ b/pyomo/common/config.py
@@ -39,7 +39,6 @@
deprecation_warning,
relocated_module_attribute,
)
-from pyomo.common.errors import DeveloperError
from pyomo.common.fileutils import import_file
from pyomo.common.formatting import wrap_reStructuredText
from pyomo.common.modeling import NOTSET
@@ -310,11 +309,16 @@ class IsInstance(object):
----------
*bases : tuple of type
Valid types.
+ document_full_base_names : bool, optional
+ True to prepend full module qualifier to the name of each
+ member of `bases` in ``self.domain_name()`` and/or any
+ error messages generated by this object, False otherwise.
"""
- def __init__(self, *bases):
+ def __init__(self, *bases, document_full_base_names=False):
assert bases
self.baseClasses = bases
+ self.document_full_base_names = document_full_base_names
@staticmethod
def _fullname(klass):
@@ -325,30 +329,40 @@ def _fullname(klass):
module_qual = "" if module_name == "builtins" else f"{module_name}."
return f"{module_qual}{klass.__name__}"
+ def _get_class_name(self, klass):
+ """
+ Get name of class. Module qualifier may be included,
+ depending on value of `self.document_full_base_names`.
+ """
+ if self.document_full_base_names:
+ return self._fullname(klass)
+ else:
+ return klass.__name__
+
def __call__(self, obj):
if isinstance(obj, self.baseClasses):
return obj
if len(self.baseClasses) > 1:
class_names = ", ".join(
- f"{self._fullname(kls)!r}" for kls in self.baseClasses
+ f"{self._get_class_name(kls)!r}" for kls in self.baseClasses
)
msg = (
"Expected an instance of one of these types: "
f"{class_names}, but received value {obj!r} of type "
- f"{self._fullname(type(obj))!r}"
+ f"{self._get_class_name(type(obj))!r}"
)
else:
msg = (
f"Expected an instance of "
- f"{self._fullname(self.baseClasses[0])!r}, "
- f"but received value {obj!r} of type {self._fullname(type(obj))!r}"
+ f"{self._get_class_name(self.baseClasses[0])!r}, "
+ f"but received value {obj!r} of type "
+ f"{self._get_class_name(type(obj))!r}"
)
raise ValueError(msg)
def domain_name(self):
- return (
- f"IsInstance({', '.join(self._fullname(kls) for kls in self.baseClasses)})"
- )
+ class_names = (self._get_class_name(kls) for kls in self.baseClasses)
+ return f"IsInstance({', '.join(class_names)})"
class ListOf(object):
@@ -473,9 +487,14 @@ def __call__(self, module_id):
class Path(object):
- """Domain validator for path-like options.
+ """
+ Domain validator for a
+ :py:term:`path-like object `.
- This will admit any object and convert it to a string. It will then
+ This will admit a path-like object
+ and get the object's file system representation
+ through :py:obj:`os.fsdecode`.
+ It will then
expand any environment variables and leading usernames (e.g.,
"~myuser" or "~/") appearing in either the value or the base path
before concatenating the base path and value, expanding the path to
@@ -538,14 +557,21 @@ def __call__(self, path):
)
return ans
+ def domain_name(self):
+ return type(self).__name__
+
class PathList(Path):
- """Domain validator for a list of path-like objects.
+ """
+ Domain validator for a list of
+ :py:term:`path-like objects `.
- This will admit any iterable or object convertible to a string.
- Iterable objects (other than strings) will have each member
- normalized using :py:class:`Path`. Other types will be passed to
- :py:class:`Path`, returning a list with the single resulting path.
+ This admits a path-like object or iterable of such.
+ If a path-like object is passed, then
+ a singleton list containing the object normalized through
+ :py:class:`Path` is returned.
+ An iterable of path-like objects is cast to a list, each
+ entry of which is normalized through :py:class:`Path`.
Parameters
----------
@@ -562,7 +588,8 @@ class PathList(Path):
"""
def __call__(self, data):
- if hasattr(data, "__iter__") and not isinstance(data, str):
+ is_path_like = isinstance(data, (str, bytes)) or hasattr(data, "__fspath__")
+ if hasattr(data, "__iter__") and not is_path_like:
return [super(PathList, self).__call__(i) for i in data]
else:
return [super(PathList, self).__call__(data)]
@@ -1078,8 +1105,11 @@ class will still create ``c`` instances that only have the single
def _dump(*args, **kwds):
+ # TODO: Change the default behavior to no longer be YAML.
+ # This was a legacy decision that may no longer be the best
+ # decision, given changes to technology over the years.
try:
- from yaml import dump
+ from yaml import safe_dump as dump
except ImportError:
# dump = lambda x,**y: str(x)
# YAML uses lowercase True/False
@@ -1104,7 +1134,11 @@ def _domain_name(domain):
if domain is None:
return ""
elif hasattr(domain, 'domain_name'):
- return domain.domain_name()
+ dn = domain.domain_name
+ if hasattr(dn, '__call__'):
+ return dn()
+ else:
+ return dn
elif domain.__class__ is type:
return domain.__name__
elif inspect.isfunction(domain):
@@ -1140,7 +1174,9 @@ def _value2string(prefix, value, obj):
try:
_data = value._data if value is obj else value
if getattr(builtins, _data.__class__.__name__, None) is not None:
- _str += _dump(_data, default_flow_style=True).rstrip()
+ _str += _dump(
+ _data, default_flow_style=True, allow_unicode=True
+ ).rstrip()
if _str.endswith("..."):
_str = _str[:-3].rstrip()
else:
diff --git a/pyomo/common/dependencies.py b/pyomo/common/dependencies.py
index 9e96fdd5860..4c9e43002ef 100644
--- a/pyomo/common/dependencies.py
+++ b/pyomo/common/dependencies.py
@@ -9,13 +9,16 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-from collections.abc import Mapping
import inspect
import importlib
import logging
import sys
import warnings
+from collections.abc import Mapping
+from types import ModuleType
+from typing import List
+
from .deprecation import deprecated, deprecation_warning, in_testing_environment
from .errors import DeferredImportError
@@ -127,7 +130,7 @@ class DeferredImportModule(object):
This object is returned by :py:func:`attempt_import()` in lieu of
the module when :py:func:`attempt_import()` is called with
- ``defer_check=True``. Any attempts to access attributes on this
+ ``defer_import=True``. Any attempts to access attributes on this
object will trigger the actual module import and return either the
appropriate module attribute or else if the module import fails,
raise a :py:class:`.DeferredImportError` exception.
@@ -312,6 +315,12 @@ def __init__(
self._module = None
self._available = None
self._deferred_submodules = deferred_submodules
+ # If this import has a callback, then record this deferred
+ # import so that any direct imports of this module also trigger
+ # the resolution of this DeferredImportIndicator (and the
+ # corresponding callback)
+ if callback is not None:
+ DeferredImportCallbackFinder._callbacks.setdefault(name, []).append(self)
def __bool__(self):
self.resolve()
@@ -433,6 +442,83 @@ def check_min_version(module, min_version):
check_min_version._parser = None
+#
+# Note that we are duck-typing the Loader and MetaPathFinder base
+# classes from importlib.abc. This avoids a (surprisingly costly)
+# import of importlib.abc
+#
+class DeferredImportCallbackLoader:
+ """Custom Loader to resolve registered :py:class:`DeferredImportIndicator` objects
+
+ This :py:class:`importlib.abc.Loader` loader wraps a regular loader
+ and automatically resolves the registered
+ :py:class:`DeferredImportIndicator` objects after the module is
+ loaded.
+
+ """
+
+ def __init__(self, loader, deferred_indicators: List[DeferredImportIndicator]):
+ self._loader = loader
+ self._deferred_indicators = deferred_indicators
+
+ def module_repr(self, module: ModuleType) -> str:
+ return self._loader.module_repr(module)
+
+ def create_module(self, spec) -> ModuleType:
+ return self._loader.create_module(spec)
+
+ def exec_module(self, module: ModuleType) -> None:
+ self._loader.exec_module(module)
+ # Now that the module has been loaded, trigger the resolution of
+ # the deferred indicators (and their associated callbacks)
+ for deferred in self._deferred_indicators:
+ deferred.resolve()
+
+ def load_module(self, fullname) -> ModuleType:
+ return self._loader.load_module(fullname)
+
+
+class DeferredImportCallbackFinder:
+ """Custom Finder that will wrap the normal loader to trigger callbacks
+
+ This :py:class:`importlib.abc.MetaPathFinder` finder will wrap the
+ normal loader returned by ``PathFinder`` with a loader that will
+ trigger custom callbacks after the module is loaded. We use this to
+ trigger the post import callbacks registered through
+ :py:func:`attempt_import` even when a user imports the target library
+ directly (and not through attribute access on the
+ :py:class:`DeferredImportModule`.
+
+ """
+
+ _callbacks = {}
+
+ def find_spec(self, fullname, path, target=None):
+ if fullname not in self._callbacks:
+ return None
+
+ spec = importlib.machinery.PathFinder.find_spec(fullname, path, target)
+ if spec is None:
+ # Module not found. Returning None will proceed to the next
+ # finder (which is likely to raise a ModuleNotFoundError)
+ return None
+ spec.loader = DeferredImportCallbackLoader(
+ spec.loader, self._callbacks[fullname]
+ )
+ return spec
+
+ def invalidate_caches(self):
+ pass
+
+
+_DeferredImportCallbackFinder = DeferredImportCallbackFinder()
+# Insert the DeferredImportCallbackFinder at the beginning of the
+# sys.meta_path so that it is found before the standard finders (so that
+# we can correctly inject the resolution of the DeferredImportIndicators
+# -- which triggers the needed callbacks)
+sys.meta_path.insert(0, _DeferredImportCallbackFinder)
+
+
def attempt_import(
name,
error_message=None,
@@ -441,7 +527,8 @@ def attempt_import(
alt_names=None,
callback=None,
importer=None,
- defer_check=True,
+ defer_check=None,
+ defer_import=None,
deferred_submodules=None,
catch_exceptions=None,
):
@@ -495,7 +582,8 @@ def attempt_import(
The message for the exception raised by :py:class:`ModuleUnavailable`
only_catch_importerror: bool, optional
- DEPRECATED: use catch_exceptions instead or only_catch_importerror.
+ DEPRECATED: use ``catch_exceptions`` instead of ``only_catch_importerror``.
+
If True (the default), exceptions other than ``ImportError`` raised
during module import will be reraised. If False, any exception
will result in returning a :py:class:`ModuleUnavailable` object.
@@ -506,13 +594,14 @@ def attempt_import(
``module.__version__``)
alt_names: list, optional
- DEPRECATED: alt_names no longer needs to be specified and is ignored.
+ DEPRECATED: ``alt_names`` no longer needs to be specified and is ignored.
+
A list of common alternate names by which to look for this
module in the ``globals()`` namespaces. For example, the alt_names
for NumPy would be ``['np']``. (deprecated in version 6.0)
- callback: function, optional
- A function with the signature "``fcn(module, available)``" that
+ callback: Callable[[ModuleType, bool], None], optional
+ A function with the signature ``fcn(module, available)`` that
will be called after the import is first attempted.
importer: function, optional
@@ -522,10 +611,16 @@ def attempt_import(
want to import/return the first one that is available.
defer_check: bool, optional
- If True (the default), then the attempted import is deferred
- until the first use of either the module or the availability
- flag. The method will return instances of :py:class:`DeferredImportModule`
- and :py:class:`DeferredImportIndicator`.
+ DEPRECATED: renamed to ``defer_import`` (deprecated in version 6.7.2)
+
+ defer_import: bool, optional
+ If True, then the attempted import is deferred until the first
+ use of either the module or the availability flag. The method
+ will return instances of :py:class:`DeferredImportModule` and
+ :py:class:`DeferredImportIndicator`. If False, the import will
+ be attempted immediately. If not set, then the import will be
+ deferred unless the ``name`` is already present in
+ ``sys.modules``.
deferred_submodules: Iterable[str], optional
If provided, an iterable of submodule names within this module
@@ -576,9 +671,26 @@ def attempt_import(
if catch_exceptions is None:
catch_exceptions = (ImportError,)
+ if defer_check is not None:
+ deprecation_warning(
+ 'defer_check=%s is deprecated. Please use defer_import' % (defer_check,),
+ version='6.7.2',
+ )
+ assert defer_import is None
+ defer_import = defer_check
+
+ # If the module has already been imported, there is no reason to
+ # further defer things: just import it.
+ if defer_import is None:
+ if name in sys.modules:
+ defer_import = False
+ deferred_submodules = None
+ else:
+ defer_import = True
+
# If we are going to defer the check until later, return the
# deferred import module object
- if defer_check:
+ if defer_import:
if deferred_submodules:
if isinstance(deferred_submodules, Mapping):
deprecation_warning(
@@ -621,7 +733,7 @@ def attempt_import(
return DeferredImportModule(indicator, deferred, None), indicator
if deferred_submodules:
- raise ValueError("deferred_submodules is only valid if defer_check==True")
+ raise ValueError("deferred_submodules is only valid if defer_import==True")
return _perform_import(
name=name,
@@ -672,6 +784,11 @@ def _perform_import(
return module, False
+@deprecated(
+ "``declare_deferred_modules_as_importable()`` is deprecated. "
+ "Use the :py:class:`declare_modules_as_importable` context manager.",
+ version='6.7.2',
+)
def declare_deferred_modules_as_importable(globals_dict):
"""Make all :py:class:`DeferredImportModules` in ``globals_dict`` importable
@@ -698,6 +815,7 @@ def declare_deferred_modules_as_importable(globals_dict):
... 'scipy', callback=_finalize_scipy,
... deferred_submodules=['stats', 'sparse', 'spatial', 'integrate'])
>>> declare_deferred_modules_as_importable(globals())
+ WARNING: DEPRECATED: ...
Which enables users to use:
@@ -712,20 +830,87 @@ def declare_deferred_modules_as_importable(globals_dict):
:py:class:`ModuleUnavailable` instance.
"""
- _global_name = globals_dict['__name__'] + '.'
- deferred = list(
- (k, v) for k, v in globals_dict.items() if type(v) is DeferredImportModule
- )
- while deferred:
- name, mod = deferred.pop(0)
- mod.__path__ = None
- mod.__spec__ = None
- sys.modules[_global_name + name] = mod
- deferred.extend(
- (name + '.' + k, v)
- for k, v in mod.__dict__.items()
- if type(v) is DeferredImportModule
- )
+ return declare_modules_as_importable(globals_dict).__exit__(None, None, None)
+
+
+class declare_modules_as_importable(object):
+ """Make all :py:class:`ModuleType` and :py:class:`DeferredImportModules`
+ importable through the ``globals_dict`` context.
+
+ This context manager will detect all modules imported into the
+ specified ``globals_dict`` environment (either directly or through
+ :py:func:`attempt_import`) and will make those modules importable
+ from the specified ``globals_dict`` context. It works by detecting
+ changes in the specified ``globals_dict`` dictionary and adding any new
+ modules or instances of :py:class:`DeferredImportModule` that it
+ finds (and any of their deferred submodules) to ``sys.modules`` so
+ that the modules can be imported through the ``globals_dict``
+ namespace.
+
+ For example, ``pyomo/common/dependencies.py`` declares:
+
+ .. doctest::
+ :hide:
+
+ >>> from pyomo.common.dependencies import (
+ ... attempt_import, _finalize_scipy, __dict__ as dep_globals,
+ ... declare_modules_as_importable, )
+ >>> # Sphinx does not provide a proper globals()
+ >>> def globals(): return dep_globals
+
+ .. doctest::
+
+ >>> with declare_modules_as_importable(globals()):
+ ... scipy, scipy_available = attempt_import(
+ ... 'scipy', callback=_finalize_scipy,
+ ... deferred_submodules=['stats', 'sparse', 'spatial', 'integrate'])
+
+ Which enables users to use:
+
+ .. doctest::
+
+ >>> import pyomo.common.dependencies.scipy.sparse as spa
+
+ If the deferred import has not yet been triggered, then the
+ :py:class:`DeferredImportModule` is returned and named ``spa``.
+ However, if the import has already been triggered, then ``spa`` will
+ either be the ``scipy.sparse`` module, or a
+ :py:class:`ModuleUnavailable` instance.
+
+ """
+
+ def __init__(self, globals_dict):
+ self.globals_dict = globals_dict
+ self.init_dict = {}
+ self.init_modules = None
+
+ def __enter__(self):
+ self.init_dict.update(self.globals_dict)
+ self.init_modules = set(sys.modules)
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ _global_name = self.globals_dict['__name__'] + '.'
+ deferred = {
+ k: v
+ for k, v in self.globals_dict.items()
+ if k not in self.init_dict
+ and isinstance(v, (ModuleType, DeferredImportModule))
+ }
+ if self.init_modules:
+ for name in set(sys.modules) - self.init_modules:
+ if '.' in name and name.split('.', 1)[0] in deferred:
+ sys.modules[_global_name + name] = sys.modules[name]
+ while deferred:
+ name, mod = deferred.popitem()
+ sys.modules[_global_name + name] = mod
+ if isinstance(mod, DeferredImportModule):
+ mod.__path__ = None
+ mod.__spec__ = None
+ deferred.update(
+ (name + '.' + k, v)
+ for k, v in mod.__dict__.items()
+ if type(v) is DeferredImportModule
+ )
#
@@ -778,11 +963,18 @@ def _finalize_matplotlib(module, available):
if in_testing_environment():
module.use('Agg')
import matplotlib.pyplot
+ import matplotlib.pylab
+ import matplotlib.backends
def _finalize_numpy(np, available):
if not available:
return
+ # scipy has a dependence on numpy.testing, and if we don't import it
+ # as part of resolving numpy, then certain deferred scipy imports
+ # fail when run under pytest.
+ import numpy.testing
+
from . import numeric_types
# Register ndarray as a native type to prevent 1-element ndarrays
@@ -842,41 +1034,42 @@ def _pyutilib_importer():
return importlib.import_module('pyutilib')
-# Standard libraries that are slower to import and not strictly required
-# on all platforms / situations.
-ctypes, _ = attempt_import(
- 'ctypes', deferred_submodules=['util'], callback=_finalize_ctypes
-)
-random, _ = attempt_import('random')
-
-# Commonly-used optional dependencies
-dill, dill_available = attempt_import('dill')
-mpi4py, mpi4py_available = attempt_import('mpi4py')
-networkx, networkx_available = attempt_import('networkx')
-numpy, numpy_available = attempt_import('numpy', callback=_finalize_numpy)
-pandas, pandas_available = attempt_import('pandas')
-plotly, plotly_available = attempt_import('plotly')
-pympler, pympler_available = attempt_import('pympler', callback=_finalize_pympler)
-pyutilib, pyutilib_available = attempt_import('pyutilib', importer=_pyutilib_importer)
-scipy, scipy_available = attempt_import(
- 'scipy',
- callback=_finalize_scipy,
- deferred_submodules=['stats', 'sparse', 'spatial', 'integrate'],
-)
-yaml, yaml_available = attempt_import('yaml', callback=_finalize_yaml)
-
-# Note that matplotlib.pyplot can generate a runtime error on OSX when
-# not installed as a Framework (as is the case in the CI systems)
-matplotlib, matplotlib_available = attempt_import(
- 'matplotlib',
- callback=_finalize_matplotlib,
- deferred_submodules=['pyplot', 'pylab'],
- catch_exceptions=(ImportError, RuntimeError),
-)
+with declare_modules_as_importable(globals()):
+ # Standard libraries that are slower to import and not strictly required
+ # on all platforms / situations.
+ ctypes, _ = attempt_import(
+ 'ctypes', deferred_submodules=['util'], callback=_finalize_ctypes
+ )
+ random, _ = attempt_import('random')
+
+ # Commonly-used optional dependencies
+ dill, dill_available = attempt_import('dill')
+ mpi4py, mpi4py_available = attempt_import('mpi4py')
+ networkx, networkx_available = attempt_import('networkx')
+ numpy, numpy_available = attempt_import('numpy', callback=_finalize_numpy)
+ pandas, pandas_available = attempt_import('pandas')
+ plotly, plotly_available = attempt_import('plotly')
+ pympler, pympler_available = attempt_import('pympler', callback=_finalize_pympler)
+ pyutilib, pyutilib_available = attempt_import(
+ 'pyutilib', importer=_pyutilib_importer
+ )
+ scipy, scipy_available = attempt_import(
+ 'scipy',
+ callback=_finalize_scipy,
+ deferred_submodules=['stats', 'sparse', 'spatial', 'integrate'],
+ )
+ yaml, yaml_available = attempt_import('yaml', callback=_finalize_yaml)
+
+ # Note that matplotlib.pyplot can generate a runtime error on OSX when
+ # not installed as a Framework (as is the case in the CI systems)
+ matplotlib, matplotlib_available = attempt_import(
+ 'matplotlib',
+ callback=_finalize_matplotlib,
+ deferred_submodules=['pyplot', 'pylab', 'backends'],
+ catch_exceptions=(ImportError, RuntimeError),
+ )
try:
import cPickle as pickle
except ImportError:
import pickle
-
-declare_deferred_modules_as_importable(globals())
diff --git a/pyomo/common/deprecation.py b/pyomo/common/deprecation.py
index 5a6ca456079..c674dcddc78 100644
--- a/pyomo/common/deprecation.py
+++ b/pyomo/common/deprecation.py
@@ -542,7 +542,7 @@ def __renamed__warning__(msg):
if new_class is None and '__renamed__new_class__' not in classdict:
if not any(
- hasattr(base, '__renamed__new_class__')
+ hasattr(mro, '__renamed__new_class__')
for mro in itertools.chain.from_iterable(
base.__mro__ for base in renamed_bases
)
diff --git a/pyomo/common/download.py b/pyomo/common/download.py
index 5332287cfc7..ad3b64060e9 100644
--- a/pyomo/common/download.py
+++ b/pyomo/common/download.py
@@ -29,6 +29,7 @@
urllib_error = attempt_import('urllib.error')[0]
ssl = attempt_import('ssl')[0]
zipfile = attempt_import('zipfile')[0]
+tarfile = attempt_import('tarfile')[0]
gzip = attempt_import('gzip')[0]
distro, distro_available = attempt_import('distro')
@@ -371,7 +372,7 @@ def get_zip_archive(self, url, dirOffset=0):
# Simple sanity checks
for info in zip_file.infolist():
f = info.filename
- if f[0] in '\\/' or '..' in f:
+ if f[0] in '\\/' or '..' in f or os.path.isabs(f):
logger.error(
"malformed (potentially insecure) filename (%s) "
"found in zip archive. Skipping file." % (f,)
@@ -387,6 +388,61 @@ def get_zip_archive(self, url, dirOffset=0):
info.filename = target[-1] + '/' if f[-1] == '/' else target[-1]
zip_file.extract(f, os.path.join(self._fname, *tuple(target[dirOffset:-1])))
+ def get_tar_archive(self, url, dirOffset=0):
+ if self._fname is None:
+ raise DeveloperError(
+ "target file name has not been initialized "
+ "with set_destination_filename"
+ )
+ if os.path.exists(self._fname) and not os.path.isdir(self._fname):
+ raise RuntimeError(
+ "Target directory (%s) exists, but is not a directory" % (self._fname,)
+ )
+
+ def filter_fcn(info):
+ # this mocks up the `tarfile` filter introduced in Python
+ # 3.12 and backported to later releases of Python (e.g.,
+ # 3.8.17, 3.9.17, 3.10.12, and 3.11.4)
+ f = info.name
+ if os.path.isabs(f) or '..' in f or f.startswith(('/', os.sep)):
+ logger.error(
+ "malformed or potentially insecure filename (%s). "
+ "Skipping file." % (f,)
+ )
+ return False
+ target = self._splitpath(f)
+ if len(target) <= dirOffset:
+ if not info.isdir():
+ logger.warning(
+ "Skipping file (%s) in tar archive due to dirOffset." % (f,)
+ )
+ return False
+ info.name = f = '/'.join(target[dirOffset:])
+ target = os.path.realpath(os.path.join(dest, f))
+ try:
+ if os.path.commonpath([target, dest]) != dest:
+ logger.error(
+ "potentially insecure filename (%s) resolves outside target "
+ "directory. Skipping file." % (f,)
+ )
+ return False
+ except ValueError:
+ # commonpath() will raise ValueError for paths that
+ # don't have anything in common (notably, when files are
+ # on different drives on Windows)
+ logger.error(
+ "potentially insecure filename (%s) resolves outside target "
+ "directory. Skipping file." % (f,)
+ )
+ return False
+ # Strip high bits & group/other write bits
+ info.mode &= 0o755
+ return True
+
+ with tarfile.open(fileobj=io.BytesIO(self.retrieve_url(url))) as TAR:
+ dest = os.path.realpath(self._fname)
+ TAR.extractall(dest, filter(filter_fcn, TAR.getmembers()))
+
def get_gzipped_binary_file(self, url):
if self._fname is None:
raise DeveloperError(
diff --git a/pyomo/common/enums.py b/pyomo/common/enums.py
new file mode 100644
index 00000000000..121155d4ae8
--- /dev/null
+++ b/pyomo/common/enums.py
@@ -0,0 +1,170 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+"""This module provides standard :py:class:`enum.Enum` definitions used in
+Pyomo, along with additional utilities for working with custom Enums
+
+Utilities:
+
+.. autosummary::
+
+ ExtendedEnumType
+ NamedIntEnum
+
+Standard Enums:
+
+.. autosummary::
+
+ ObjectiveSense
+
+"""
+
+import enum
+import itertools
+import sys
+
+if sys.version_info[:2] < (3, 11):
+ _EnumType = enum.EnumMeta
+else:
+ _EnumType = enum.EnumType
+
+
+class ExtendedEnumType(_EnumType):
+ """Metaclass for creating an :py:class:`enum.Enum` that extends another Enum
+
+ In general, :py:class:`enum.Enum` classes are not extensible: that is,
+ they are frozen when defined and cannot be the base class of another
+ Enum. This Metaclass provides a workaround for creating a new Enum
+ that extends an existing enum. Members in the base Enum are all
+ present as members on the extended enum.
+
+ Example
+ -------
+
+ .. testcode::
+ :hide:
+
+ import enum
+ from pyomo.common.enums import ExtendedEnumType
+
+ .. testcode::
+
+ class ObjectiveSense(enum.IntEnum):
+ minimize = 1
+ maximize = -1
+
+ class ProblemSense(enum.IntEnum, metaclass=ExtendedEnumType):
+ __base_enum__ = ObjectiveSense
+
+ unknown = 0
+
+ .. doctest::
+
+ >>> list(ProblemSense)
+ [, , ]
+ >>> ProblemSense.unknown
+
+ >>> ProblemSense.maximize
+
+ >>> ProblemSense(0)
+
+ >>> ProblemSense(1)
+
+ >>> ProblemSense('unknown')
+
+ >>> ProblemSense('maximize')
+
+ >>> hasattr(ProblemSense, 'minimize')
+ True
+ >>> ProblemSense.minimize is ObjectiveSense.minimize
+ True
+ >>> ProblemSense.minimize in ProblemSense
+ True
+
+ """
+
+ def __getattr__(cls, attr):
+ try:
+ return getattr(cls.__base_enum__, attr)
+ except:
+ return super().__getattr__(attr)
+
+ def __iter__(cls):
+ # The members of this Enum are the base enum members joined with
+ # the local members
+ return itertools.chain(super().__iter__(), cls.__base_enum__.__iter__())
+
+ def __contains__(cls, member):
+ # This enum "contains" both its local members and the members in
+ # the __base_enum__ (necessary for good auto-enum[sphinx] docs)
+ return super().__contains__(member) or member in cls.__base_enum__
+
+ def __instancecheck__(cls, instance):
+ if cls.__subclasscheck__(type(instance)):
+ return True
+ # Also pretend that members of the extended enum are subclasses
+ # of the __base_enum__. This is needed to circumvent error
+ # checking in enum.__new__ (e.g., for `ProblemSense('minimize')`)
+ return cls.__base_enum__.__subclasscheck__(type(instance))
+
+ def _missing_(cls, value):
+ # Support attribute lookup by value or name
+ for attr in ('value', 'name'):
+ for member in cls:
+ if getattr(member, attr) == value:
+ return member
+ return None
+
+ def __new__(metacls, cls, bases, classdict, **kwds):
+ # Support lookup by name - but only if the new Enum doesn't
+ # specify its own implementation of _missing_
+ if '_missing_' not in classdict:
+ classdict['_missing_'] = classmethod(ExtendedEnumType._missing_)
+ return super().__new__(metacls, cls, bases, classdict, **kwds)
+
+
+class NamedIntEnum(enum.IntEnum):
+ """An extended version of :py:class:`enum.IntEnum` that supports
+ creating members by name as well as value.
+
+ """
+
+ @classmethod
+ def _missing_(cls, value):
+ for member in cls:
+ if member.name == value:
+ return member
+ return None
+
+
+class ObjectiveSense(NamedIntEnum):
+ """Flag indicating if an objective is minimizing (1) or maximizing (-1).
+
+ While the numeric values are arbitrary, there are parts of Pyomo
+ that rely on this particular choice of value. These values are also
+ consistent with some solvers (notably Gurobi).
+
+ """
+
+ minimize = 1
+ maximize = -1
+
+ # Overloading __str__ is needed to match the behavior of the old
+ # pyutilib.enum class (removed June 2020). There are spots in the
+ # code base that expect the string representation for items in the
+ # enum to not include the class name. New uses of enum shouldn't
+ # need to do this.
+ def __str__(self):
+ return self.name
+
+
+minimize = ObjectiveSense.minimize
+maximize = ObjectiveSense.maximize
diff --git a/pyomo/common/fileutils.py b/pyomo/common/fileutils.py
index 2cade36154d..7b6520327a0 100644
--- a/pyomo/common/fileutils.py
+++ b/pyomo/common/fileutils.py
@@ -38,6 +38,7 @@
import os
import platform
import importlib.util
+import subprocess
import sys
from . import envvar
@@ -375,9 +376,27 @@ def find_library(libname, cwd=True, include_PATH=True, pathlist=None):
if libname_base.startswith('lib') and _system() != 'windows':
libname_base = libname_base[3:]
if ext.lower().startswith(('.so', '.dll', '.dylib')):
- return ctypes.util.find_library(libname_base)
+ lib = ctypes.util.find_library(libname_base)
else:
- return ctypes.util.find_library(libname)
+ lib = ctypes.util.find_library(libname)
+ if lib and os.path.sep not in lib:
+ # work around https://github.com/python/cpython/issues/65241,
+ # where python does not return the absolute path on *nix
+ try:
+ libname = lib + ' '
+ with subprocess.Popen(
+ ['/sbin/ldconfig', '-p'],
+ stdin=subprocess.DEVNULL,
+ stderr=subprocess.DEVNULL,
+ stdout=subprocess.PIPE,
+ env={'LC_ALL': 'C', 'LANG': 'C'},
+ ) as p:
+ for line in os.fsdecode(p.stdout.read()).splitlines():
+ if line.lstrip().startswith(libname):
+ return os.path.realpath(line.split()[-1])
+ except:
+ pass
+ return lib
def find_executable(exename, cwd=True, include_PATH=True, pathlist=None):
diff --git a/pyomo/common/gsl.py b/pyomo/common/gsl.py
index 1c14b64bd70..96fab8623b3 100644
--- a/pyomo/common/gsl.py
+++ b/pyomo/common/gsl.py
@@ -23,8 +23,8 @@
)
def get_gsl(downloader):
logger.info(
- "As of February 9, 2023, AMPL GSL can no longer be downloaded\
- through download-extensions. Visit https://portal.ampl.com/\
+ "As of February 9, 2023, AMPL GSL can no longer be downloaded \
+ through download-extensions. Visit https://portal.ampl.com/ \
to download the AMPL GSL binaries."
)
diff --git a/pyomo/common/numeric_types.py b/pyomo/common/numeric_types.py
index ba104203667..2b63038e125 100644
--- a/pyomo/common/numeric_types.py
+++ b/pyomo/common/numeric_types.py
@@ -12,7 +12,6 @@
import logging
import sys
-from pyomo.common.dependencies import numpy_available
from pyomo.common.deprecation import deprecated, relocated_module_attribute
from pyomo.common.errors import TemplateExpressionError
@@ -50,7 +49,6 @@
native_integer_types = {int}
native_logical_types = {bool}
native_complex_types = {complex}
-pyomo_constant_types = set() # includes NumericConstant
_native_boolean_types = {int, bool, str, bytes}
relocated_module_attribute(
@@ -62,6 +60,16 @@
"be treated as if they were bool (as was the case for the other "
"native_*_types sets). Users likely should use native_logical_types.",
)
+_pyomo_constant_types = set() # includes NumericConstant, _PythonCallbackFunctionID
+relocated_module_attribute(
+ 'pyomo_constant_types',
+ 'pyomo.common.numeric_types._pyomo_constant_types',
+ version='6.7.2',
+ msg="The pyomo_constant_types set will be removed in the future: the set "
+ "contained only NumericConstant and _PythonCallbackFunctionID, and provided "
+ "no meaningful value to clients or walkers. Users should likely handle "
+ "these types in the same manner as immutable Params.",
+)
#: Python set used to identify numeric constants and related native
@@ -194,6 +202,67 @@ def RegisterLogicalType(new_type: type):
nonpyomo_leaf_types.add(new_type)
+def check_if_native_type(obj):
+ if isinstance(obj, (str, bytes)):
+ native_types.add(obj.__class__)
+ return True
+ if check_if_logical_type(obj):
+ return True
+ if check_if_numeric_type(obj):
+ return True
+ return False
+
+
+def check_if_logical_type(obj):
+ """Test if the argument behaves like a logical type.
+
+ We check for "logical types" by checking if the type returns sane
+ results for Boolean operators (``^``, ``|``, ``&``) and if it maps
+ ``1`` and ``2`` both to the same equivalent instance. If that
+ works, then we register the type in :py:attr:`native_logical_types`.
+
+ """
+ obj_class = obj.__class__
+ # Do not re-evaluate known native types
+ if obj_class in native_types:
+ return obj_class in native_logical_types
+
+ try:
+ # It is not an error if you can't initialize the type from an
+ # int, but if you can, it should map !0 to True
+ if obj_class(1) != obj_class(2):
+ return False
+ except:
+ pass
+
+ try:
+ # Native logical types *must* be hashable
+ hash(obj)
+ # Native logical types must honor standard Boolean operators
+ if all(
+ (
+ obj_class(False) != obj_class(True),
+ obj_class(False) ^ obj_class(False) == obj_class(False),
+ obj_class(False) ^ obj_class(True) == obj_class(True),
+ obj_class(True) ^ obj_class(False) == obj_class(True),
+ obj_class(True) ^ obj_class(True) == obj_class(False),
+ obj_class(False) | obj_class(False) == obj_class(False),
+ obj_class(False) | obj_class(True) == obj_class(True),
+ obj_class(True) | obj_class(False) == obj_class(True),
+ obj_class(True) | obj_class(True) == obj_class(True),
+ obj_class(False) & obj_class(False) == obj_class(False),
+ obj_class(False) & obj_class(True) == obj_class(False),
+ obj_class(True) & obj_class(False) == obj_class(False),
+ obj_class(True) & obj_class(True) == obj_class(True),
+ )
+ ):
+ RegisterLogicalType(obj_class)
+ return True
+ except:
+ pass
+ return False
+
+
def check_if_numeric_type(obj):
"""Test if the argument behaves like a numeric type.
@@ -208,46 +277,55 @@ def check_if_numeric_type(obj):
if obj_class in native_types:
return obj_class in native_numeric_types
- if 'numpy' in obj_class.__module__:
- # trigger the resolution of numpy_available and check if this
- # type was automatically registered
- bool(numpy_available)
- if obj_class in native_types:
- return obj_class in native_numeric_types
-
try:
obj_plus_0 = obj + 0
obj_p0_class = obj_plus_0.__class__
- # ensure that the object is comparable to 0 in a meaningful way
- # (among other things, this prevents numpy.ndarray objects from
- # being added to native_numeric_types)
+ # Native numeric types *must* be hashable
+ hash(obj)
+ except:
+ return False
+ if obj_p0_class is not obj_class and obj_p0_class not in native_numeric_types:
+ return False
+ #
+ # Check if the numeric type behaves like a complex type
+ #
+ try:
+ if 1.41 < abs(obj_class(1j + 1)) < 1.42:
+ RegisterComplexType(obj_class)
+ return False
+ except:
+ pass
+ #
+ # Ensure that the object is comparable to 0 in a meaningful way
+ #
+ try:
if not ((obj < 0) ^ (obj >= 0)):
return False
- # Native types *must* be hashable
- hash(obj)
except:
return False
- if obj_p0_class is obj_class or obj_p0_class in native_numeric_types:
- #
- # If we get here, this is a reasonably well-behaving
- # numeric type: add it to the native numeric types
- # so that future lookups will be faster.
- #
- RegisterNumericType(obj_class)
- #
- # Generate a warning, since Pyomo's management of third-party
- # numeric types is more robust when registering explicitly.
- #
- logger.warning(
- f"""Dynamically registering the following numeric type:
+ #
+ # If we get here, this is a reasonably well-behaving
+ # numeric type: add it to the native numeric types
+ # so that future lookups will be faster.
+ #
+ RegisterNumericType(obj_class)
+ try:
+ if obj_class(0.4) == obj_class(0):
+ RegisterIntegerType(obj_class)
+ except:
+ pass
+ #
+ # Generate a warning, since Pyomo's management of third-party
+ # numeric types is more robust when registering explicitly.
+ #
+ logger.warning(
+ f"""Dynamically registering the following numeric type:
{obj_class.__module__}.{obj_class.__name__}
Dynamic registration is supported for convenience, but there are known
limitations to this approach. We recommend explicitly registering
numeric types using RegisterNumericType() or RegisterIntegerType()."""
- )
- return True
- else:
- return False
+ )
+ return True
def value(obj, exception=True):
@@ -274,22 +352,10 @@ def value(obj, exception=True):
"""
if obj.__class__ in native_types:
return obj
- if obj.__class__ in pyomo_constant_types:
- #
- # I'm commenting this out for now, but I think we should never expect
- # to see a numeric constant with value None.
- #
- # if exception and obj.value is None:
- # raise ValueError(
- # "No value for uninitialized NumericConstant object %s"
- # % (obj.name,))
- return obj.value
#
# Test if we have a duck typed Pyomo expression
#
- try:
- obj.is_numeric_type()
- except AttributeError:
+ if not hasattr(obj, 'is_numeric_type'):
#
# TODO: Historically we checked for new *numeric* types and
# raised exceptions for anything else. That is inconsistent
@@ -304,7 +370,7 @@ def value(obj, exception=True):
return None
raise TypeError(
"Cannot evaluate object with unknown type: %s" % obj.__class__.__name__
- ) from None
+ )
#
# Evaluate the expression object
#
diff --git a/pyomo/common/tests/dep_mod.py b/pyomo/common/tests/dep_mod.py
index f6add596ed4..34c7219c6eb 100644
--- a/pyomo/common/tests/dep_mod.py
+++ b/pyomo/common/tests/dep_mod.py
@@ -13,8 +13,8 @@
__version__ = '1.5'
-numpy, numpy_available = attempt_import('numpy', defer_check=True)
+numpy, numpy_available = attempt_import('numpy', defer_import=True)
bogus_nonexisting_module, bogus_nonexisting_module_available = attempt_import(
- 'bogus_nonexisting_module', alt_names=['bogus_nem'], defer_check=True
+ 'bogus_nonexisting_module', alt_names=['bogus_nem'], defer_import=True
)
diff --git a/pyomo/common/tests/deps.py b/pyomo/common/tests/deps.py
index d00281553f4..5f8c1fffdf8 100644
--- a/pyomo/common/tests/deps.py
+++ b/pyomo/common/tests/deps.py
@@ -23,15 +23,16 @@
bogus_nonexisting_module_available as has_bogus_nem,
)
-bogus, bogus_available = attempt_import('nonexisting.module.bogus', defer_check=True)
+bogus, bogus_available = attempt_import('nonexisting.module.bogus', defer_import=True)
pkl_test, pkl_available = attempt_import(
- 'nonexisting.module.pickle_test', deferred_submodules=['submod'], defer_check=True
+ 'nonexisting.module.pickle_test', deferred_submodules=['submod'], defer_import=True
)
pyo, pyo_available = attempt_import(
'pyomo',
alt_names=['pyo'],
+ defer_import=True,
deferred_submodules={'version': None, 'common.tests.dep_mod': ['dm']},
)
diff --git a/pyomo/common/tests/test_component_map.py b/pyomo/common/tests/test_component_map.py
new file mode 100644
index 00000000000..7cd4ec2c458
--- /dev/null
+++ b/pyomo/common/tests/test_component_map.py
@@ -0,0 +1,90 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.unittest as unittest
+
+from pyomo.common.collections import ComponentMap, ComponentSet, DefaultComponentMap
+from pyomo.environ import ConcreteModel, Block, Var, Constraint
+
+
+class TestComponentMap(unittest.TestCase):
+ def test_tuple(self):
+ m = ConcreteModel()
+ m.v = Var()
+ m.c = Constraint(expr=m.v >= 0)
+ m.cm = cm = ComponentMap()
+
+ cm[(1, 2)] = 5
+ self.assertEqual(len(cm), 1)
+ self.assertIn((1, 2), cm)
+ self.assertEqual(cm[1, 2], 5)
+
+ cm[(1, 2)] = 50
+ self.assertEqual(len(cm), 1)
+ self.assertIn((1, 2), cm)
+ self.assertEqual(cm[1, 2], 50)
+
+ cm[(1, (2, m.v))] = 10
+ self.assertEqual(len(cm), 2)
+ self.assertIn((1, (2, m.v)), cm)
+ self.assertEqual(cm[1, (2, m.v)], 10)
+
+ cm[(1, (2, m.v))] = 100
+ self.assertEqual(len(cm), 2)
+ self.assertIn((1, (2, m.v)), cm)
+ self.assertEqual(cm[1, (2, m.v)], 100)
+
+ i = m.clone()
+ self.assertIn((1, 2), i.cm)
+ self.assertIn((1, (2, i.v)), i.cm)
+ self.assertNotIn((1, (2, i.v)), m.cm)
+ self.assertIn((1, (2, m.v)), m.cm)
+ self.assertNotIn((1, (2, m.v)), i.cm)
+
+
+class TestDefaultComponentMap(unittest.TestCase):
+ def test_default_component_map(self):
+ dcm = DefaultComponentMap(ComponentSet)
+
+ m = ConcreteModel()
+ m.x = Var()
+ m.b = Block()
+ m.b.y = Var()
+
+ self.assertEqual(len(dcm), 0)
+
+ dcm[m.x].add(m)
+ self.assertEqual(len(dcm), 1)
+ self.assertIn(m.x, dcm)
+ self.assertIn(m, dcm[m.x])
+
+ dcm[m.b.y].add(m.b)
+ self.assertEqual(len(dcm), 2)
+ self.assertIn(m.b.y, dcm)
+ self.assertNotIn(m, dcm[m.b.y])
+ self.assertIn(m.b, dcm[m.b.y])
+
+ dcm[m.b.y].add(m)
+ self.assertEqual(len(dcm), 2)
+ self.assertIn(m.b.y, dcm)
+ self.assertIn(m, dcm[m.b.y])
+ self.assertIn(m.b, dcm[m.b.y])
+
+ def test_no_default_factory(self):
+ dcm = DefaultComponentMap()
+
+ dcm['found'] = 5
+ self.assertEqual(len(dcm), 1)
+ self.assertIn('found', dcm)
+ self.assertEqual(dcm['found'], 5)
+
+ with self.assertRaisesRegex(KeyError, "'missing'"):
+ dcm["missing"]
diff --git a/pyomo/common/tests/test_config.py b/pyomo/common/tests/test_config.py
index 068017d836f..a47f5e0d8af 100644
--- a/pyomo/common/tests/test_config.py
+++ b/pyomo/common/tests/test_config.py
@@ -469,13 +469,18 @@ def __repr__(self):
c.val2 = testinst
self.assertEqual(c.val2, testinst)
exc_str = (
- r"Expected an instance of '.*\.TestClass', "
+ r"Expected an instance of 'TestClass', "
"but received value 2.4 of type 'float'"
)
with self.assertRaisesRegex(ValueError, exc_str):
c.val2 = 2.4
- c.declare("val3", ConfigValue(None, IsInstance(int, TestClass)))
+ c.declare(
+ "val3",
+ ConfigValue(
+ None, IsInstance(int, TestClass, document_full_base_names=True)
+ ),
+ )
self.assertRegex(
c.get("val3").domain_name(), r"IsInstance\(int, .*\.TestClass\)"
)
@@ -488,6 +493,22 @@ def __repr__(self):
with self.assertRaisesRegex(ValueError, exc_str):
c.val3 = 2.4
+ c.declare(
+ "val4",
+ ConfigValue(
+ None, IsInstance(int, TestClass, document_full_base_names=False)
+ ),
+ )
+ self.assertEqual(c.get("val4").domain_name(), "IsInstance(int, TestClass)")
+ c.val4 = 2
+ self.assertEqual(c.val4, 2)
+ exc_str = (
+ r"Expected an instance of one of these types: 'int', 'TestClass'"
+ r", but received value 2.4 of type 'float'"
+ )
+ with self.assertRaisesRegex(ValueError, exc_str):
+ c.val4 = 2.4
+
def test_Path(self):
def norm(x):
if cwd[1] == ':' and x[0] == '/':
@@ -505,6 +526,8 @@ def __str__(self):
path_str = str(self.path)
return f"{type(self).__name__}({path_str})"
+ self.assertEqual(Path().domain_name(), "Path")
+
cwd = os.getcwd() + os.path.sep
c = ConfigDict()
@@ -725,6 +748,8 @@ def norm(x):
cwd = os.getcwd() + os.path.sep
c = ConfigDict()
+ self.assertEqual(PathList().domain_name(), "PathList")
+
c.declare('a', ConfigValue(None, PathList()))
self.assertEqual(c.a, None)
c.a = "/a/b/c"
@@ -747,6 +772,13 @@ def norm(x):
self.assertEqual(len(c.a), 0)
self.assertIs(type(c.a), list)
+ exc_str = r".*expected str, bytes or os.PathLike.*int"
+
+ with self.assertRaisesRegex(ValueError, exc_str):
+ c.a = 2
+ with self.assertRaisesRegex(ValueError, exc_str):
+ c.a = ["/a/b/c", 2]
+
def test_ListOf(self):
c = ConfigDict()
c.declare('a', ConfigValue(domain=ListOf(int), default=None))
@@ -1638,7 +1670,7 @@ def test_parseDisplay_userdata_add_block_nonDefault(self):
self.config.add("bar", ConfigDict(implicit=True)).add("baz", ConfigDict())
test = _display(self.config, 'userdata')
sys.stdout.write(test)
- self.assertEqual(yaml_load(test), {'bar': {'baz': None}, foo: 0})
+ self.assertEqual(yaml_load(test), {'bar': {'baz': None}, 'foo': 0})
@unittest.skipIf(not yaml_available, "Test requires PyYAML")
def test_parseDisplay_userdata_add_block(self):
@@ -2066,7 +2098,6 @@ def test_generate_custom_documentation(self):
"generate_documentation is deprecated.",
LOG,
)
- self.maxDiff = None
# print(test)
self.assertEqual(test, reference)
@@ -2081,7 +2112,6 @@ def test_generate_custom_documentation(self):
)
)
self.assertEqual(LOG.getvalue(), "")
- self.maxDiff = None
# print(test)
self.assertEqual(test, reference)
@@ -2127,7 +2157,6 @@ def test_generate_custom_documentation(self):
"generate_documentation is deprecated.",
LOG,
)
- self.maxDiff = None
# print(test)
self.assertEqual(test, reference)
@@ -2545,7 +2574,6 @@ def test_argparse_help_implicit_disable(self):
parser = argparse.ArgumentParser(prog='tester')
self.config.initialize_argparse(parser)
help = parser.format_help()
- self.maxDiff = None
self.assertIn(
"""
-h, --help show this help message and exit
@@ -3074,8 +3102,6 @@ def test_declare_from(self):
cfg2.declare_from({})
def test_docstring_decorator(self):
- self.maxDiff = None
-
@document_kwargs_from_configdict('CONFIG')
class ExampleClass(object):
CONFIG = ExampleConfig()
@@ -3233,6 +3259,41 @@ def __init__(
OUT.getvalue().replace('null', 'None'),
)
+ def test_domain_name(self):
+ cfg = ConfigDict()
+
+ cfg.declare('none', ConfigValue())
+ self.assertEqual(cfg.get('none').domain_name(), '')
+
+ def fcn(val):
+ return val
+
+ cfg.declare('fcn', ConfigValue(domain=fcn))
+ self.assertEqual(cfg.get('fcn').domain_name(), 'fcn')
+
+ fcn.domain_name = 'custom fcn'
+ self.assertEqual(cfg.get('fcn').domain_name(), 'custom fcn')
+
+ class functor:
+ def __call__(self, val):
+ return val
+
+ cfg.declare('functor', ConfigValue(domain=functor()))
+ self.assertEqual(cfg.get('functor').domain_name(), 'functor')
+
+ class cfunctor:
+ def __call__(self, val):
+ return val
+
+ def domain_name(self):
+ return 'custom functor'
+
+ cfg.declare('cfunctor', ConfigValue(domain=cfunctor()))
+ self.assertEqual(cfg.get('cfunctor').domain_name(), 'custom functor')
+
+ cfg.declare('type', ConfigValue(domain=int))
+ self.assertEqual(cfg.get('type').domain_name(), 'int')
+
if __name__ == "__main__":
unittest.main()
diff --git a/pyomo/common/tests/test_dependencies.py b/pyomo/common/tests/test_dependencies.py
index 30822a4f81f..31f9520b613 100644
--- a/pyomo/common/tests/test_dependencies.py
+++ b/pyomo/common/tests/test_dependencies.py
@@ -45,7 +45,7 @@ def test_import_error(self):
module_obj, module_available = attempt_import(
'__there_is_no_module_named_this__',
'Testing import of a non-existent module',
- defer_check=False,
+ defer_import=False,
)
self.assertFalse(module_available)
with self.assertRaisesRegex(
@@ -85,7 +85,7 @@ def test_pickle(self):
def test_import_success(self):
module_obj, module_available = attempt_import(
- 'ply', 'Testing import of ply', defer_check=False
+ 'ply', 'Testing import of ply', defer_import=False
)
self.assertTrue(module_available)
import ply
@@ -123,7 +123,7 @@ def test_imported_deferred_import(self):
def test_min_version(self):
mod, avail = attempt_import(
- 'pyomo.common.tests.dep_mod', minimum_version='1.0', defer_check=False
+ 'pyomo.common.tests.dep_mod', minimum_version='1.0', defer_import=False
)
self.assertTrue(avail)
self.assertTrue(inspect.ismodule(mod))
@@ -131,7 +131,7 @@ def test_min_version(self):
self.assertFalse(check_min_version(mod, '2.0'))
mod, avail = attempt_import(
- 'pyomo.common.tests.dep_mod', minimum_version='2.0', defer_check=False
+ 'pyomo.common.tests.dep_mod', minimum_version='2.0', defer_import=False
)
self.assertFalse(avail)
self.assertIs(type(mod), ModuleUnavailable)
@@ -146,7 +146,7 @@ def test_min_version(self):
'pyomo.common.tests.dep_mod',
error_message="Failed import",
minimum_version='2.0',
- defer_check=False,
+ defer_import=False,
)
self.assertFalse(avail)
self.assertIs(type(mod), ModuleUnavailable)
@@ -159,10 +159,10 @@ def test_min_version(self):
# Verify check_min_version works with deferred imports
- mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_check=True)
+ mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_import=True)
self.assertTrue(check_min_version(mod, '1.0'))
- mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_check=True)
+ mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_import=True)
self.assertFalse(check_min_version(mod, '2.0'))
# Verify check_min_version works when called directly
@@ -174,10 +174,10 @@ def test_min_version(self):
self.assertFalse(check_min_version(mod, '1.0'))
def test_and_or(self):
- mod0, avail0 = attempt_import('ply', defer_check=True)
- mod1, avail1 = attempt_import('pyomo.common.tests.dep_mod', defer_check=True)
+ mod0, avail0 = attempt_import('ply', defer_import=True)
+ mod1, avail1 = attempt_import('pyomo.common.tests.dep_mod', defer_import=True)
mod2, avail2 = attempt_import(
- 'pyomo.common.tests.dep_mod', minimum_version='2.0', defer_check=True
+ 'pyomo.common.tests.dep_mod', minimum_version='2.0', defer_import=True
)
_and = avail0 & avail1
@@ -233,11 +233,11 @@ def test_callbacks(self):
def _record_avail(module, avail):
ans.append(avail)
- mod0, avail0 = attempt_import('ply', defer_check=True, callback=_record_avail)
+ mod0, avail0 = attempt_import('ply', defer_import=True, callback=_record_avail)
mod1, avail1 = attempt_import(
'pyomo.common.tests.dep_mod',
minimum_version='2.0',
- defer_check=True,
+ defer_import=True,
callback=_record_avail,
)
@@ -250,7 +250,7 @@ def _record_avail(module, avail):
def test_import_exceptions(self):
mod, avail = attempt_import(
'pyomo.common.tests.dep_mod_except',
- defer_check=True,
+ defer_import=True,
only_catch_importerror=True,
)
with self.assertRaisesRegex(ValueError, "cannot import module"):
@@ -260,7 +260,7 @@ def test_import_exceptions(self):
mod, avail = attempt_import(
'pyomo.common.tests.dep_mod_except',
- defer_check=True,
+ defer_import=True,
only_catch_importerror=False,
)
self.assertFalse(avail)
@@ -268,7 +268,7 @@ def test_import_exceptions(self):
mod, avail = attempt_import(
'pyomo.common.tests.dep_mod_except',
- defer_check=True,
+ defer_import=True,
catch_exceptions=(ImportError, ValueError),
)
self.assertFalse(avail)
@@ -280,7 +280,7 @@ def test_import_exceptions(self):
):
mod, avail = attempt_import(
'pyomo.common.tests.dep_mod_except',
- defer_check=True,
+ defer_import=True,
only_catch_importerror=True,
catch_exceptions=(ImportError,),
)
@@ -288,7 +288,7 @@ def test_import_exceptions(self):
def test_generate_warning(self):
mod, avail = attempt_import(
'pyomo.common.tests.dep_mod_except',
- defer_check=True,
+ defer_import=True,
only_catch_importerror=False,
)
@@ -324,7 +324,7 @@ def test_generate_warning(self):
def test_log_warning(self):
mod, avail = attempt_import(
'pyomo.common.tests.dep_mod_except',
- defer_check=True,
+ defer_import=True,
only_catch_importerror=False,
)
log = StringIO()
@@ -366,9 +366,9 @@ def test_importer(self):
def _importer():
attempted_import.append(True)
- return attempt_import('pyomo.common.tests.dep_mod', defer_check=False)[0]
+ return attempt_import('pyomo.common.tests.dep_mod', defer_import=False)[0]
- mod, avail = attempt_import('foo', importer=_importer, defer_check=True)
+ mod, avail = attempt_import('foo', importer=_importer, defer_import=True)
self.assertEqual(attempted_import, [])
self.assertIsInstance(mod, DeferredImportModule)
@@ -401,17 +401,17 @@ def test_deferred_submodules(self):
self.assertTrue(inspect.ismodule(deps.dm))
with self.assertRaisesRegex(
- ValueError, "deferred_submodules is only valid if defer_check==True"
+ ValueError, "deferred_submodules is only valid if defer_import==True"
):
mod, mod_available = attempt_import(
'nonexisting.module',
- defer_check=False,
+ defer_import=False,
deferred_submodules={'submod': None},
)
mod, mod_available = attempt_import(
'nonexisting.module',
- defer_check=True,
+ defer_import=True,
deferred_submodules={'submod.subsubmod': None},
)
self.assertIs(type(mod), DeferredImportModule)
@@ -427,7 +427,7 @@ def test_UnavailableClass(self):
module_obj, module_available = attempt_import(
'__there_is_no_module_named_this__',
'Testing import of a non-existent module',
- defer_check=False,
+ defer_import=False,
)
class A_Class(UnavailableClass(module_obj)):
diff --git a/pyomo/common/tests/test_deprecated.py b/pyomo/common/tests/test_deprecated.py
index 377e229c775..37e1ba81bb3 100644
--- a/pyomo/common/tests/test_deprecated.py
+++ b/pyomo/common/tests/test_deprecated.py
@@ -529,7 +529,10 @@ class DeprecatedClassSubclass(DeprecatedClass):
out = StringIO()
with LoggingIntercept(out):
- class DeprecatedClassSubSubclass(DeprecatedClassSubclass):
+ class otherClass:
+ pass
+
+ class DeprecatedClassSubSubclass(DeprecatedClassSubclass, otherClass):
attr = 'DeprecatedClassSubSubclass'
self.assertEqual(out.getvalue(), "")
diff --git a/pyomo/common/tests/test_download.py b/pyomo/common/tests/test_download.py
index 87108be1c59..8fee0ba7e31 100644
--- a/pyomo/common/tests/test_download.py
+++ b/pyomo/common/tests/test_download.py
@@ -9,12 +9,14 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
+import io
import os
import platform
import re
import shutil
-import tempfile
import subprocess
+import tarfile
+import tempfile
import pyomo.common.unittest as unittest
import pyomo.common.envvar as envvar
@@ -22,6 +24,7 @@
from pyomo.common import DeveloperError
from pyomo.common.fileutils import this_file
from pyomo.common.download import FileDownloader, distro_available
+from pyomo.common.log import LoggingIntercept
from pyomo.common.tee import capture_output
@@ -242,7 +245,7 @@ def test_get_files_requires_set_destination(self):
):
f.get_gzipped_binary_file('bogus')
- def test_get_test_binary_file(self):
+ def test_get_text_binary_file(self):
tmpdir = tempfile.mkdtemp()
try:
f = FileDownloader()
@@ -263,3 +266,66 @@ def test_get_test_binary_file(self):
self.assertEqual(os.path.getsize(target), len(os.linesep))
finally:
shutil.rmtree(tmpdir)
+
+ def test_get_tar_archive(self):
+ tmpdir = tempfile.mkdtemp()
+ try:
+ f = FileDownloader()
+
+ # Mock retrieve_url so network connections are not necessary
+ buf = io.BytesIO()
+ with tarfile.open(mode="w:gz", fileobj=buf) as TAR:
+ info = tarfile.TarInfo('b/lnk')
+ info.size = 0
+ info.type = tarfile.SYMTYPE
+ info.linkname = envvar.PYOMO_CONFIG_DIR
+ TAR.addfile(info)
+ for fname in ('a', 'b/c', 'b/d', '/root', 'b/lnk/test'):
+ info = tarfile.TarInfo(fname)
+ info.size = 0
+ info.type = tarfile.REGTYPE
+ info.mode = 0o644
+ info.mtime = info.uid = info.gid = 0
+ info.uname = info.gname = 'root'
+ TAR.addfile(info)
+ f.retrieve_url = lambda url: buf.getvalue()
+
+ with self.assertRaisesRegex(
+ DeveloperError,
+ r"(?s)target file name has not been initialized "
+ r"with set_destination_filename".replace(' ', r'\s+'),
+ ):
+ f.get_tar_archive(None, 1)
+
+ _tmp = os.path.join(tmpdir, 'a_file')
+ with open(_tmp, 'w'):
+ pass
+ f.set_destination_filename(_tmp)
+ with self.assertRaisesRegex(
+ RuntimeError,
+ r"Target directory \(.*a_file\) exists, but is not a directory",
+ ):
+ f.get_tar_archive(None, 1)
+
+ f.set_destination_filename(tmpdir)
+ with LoggingIntercept() as LOG:
+ f.get_tar_archive(None, 1)
+
+ self.assertEqual(
+ LOG.getvalue().strip(),
+ """
+Skipping file (a) in tar archive due to dirOffset.
+malformed or potentially insecure filename (/root). Skipping file.
+potentially insecure filename (lnk/test) resolves outside target directory. Skipping file.
+""".strip(),
+ )
+ for f in ('c', 'd'):
+ fname = os.path.join(tmpdir, f)
+ self.assertTrue(os.path.exists(fname))
+ self.assertTrue(os.path.isfile(fname))
+ for f in ('lnk',):
+ fname = os.path.join(tmpdir, f)
+ self.assertTrue(os.path.exists(fname))
+ self.assertTrue(os.path.islink(fname))
+ finally:
+ shutil.rmtree(tmpdir)
diff --git a/pyomo/common/tests/test_enums.py b/pyomo/common/tests/test_enums.py
new file mode 100644
index 00000000000..80d081505e9
--- /dev/null
+++ b/pyomo/common/tests/test_enums.py
@@ -0,0 +1,97 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 enum
+
+import pyomo.common.unittest as unittest
+
+from pyomo.common.enums import ExtendedEnumType, ObjectiveSense
+
+
+class ProblemSense(enum.IntEnum, metaclass=ExtendedEnumType):
+ __base_enum__ = ObjectiveSense
+
+ unknown = 0
+
+
+class TestExtendedEnumType(unittest.TestCase):
+ def test_members(self):
+ self.assertEqual(
+ list(ProblemSense),
+ [ProblemSense.unknown, ObjectiveSense.minimize, ObjectiveSense.maximize],
+ )
+
+ def test_isinstance(self):
+ self.assertIsInstance(ProblemSense.unknown, ProblemSense)
+ self.assertIsInstance(ProblemSense.minimize, ProblemSense)
+ self.assertIsInstance(ProblemSense.maximize, ProblemSense)
+
+ self.assertTrue(ProblemSense.__instancecheck__(ProblemSense.unknown))
+ self.assertTrue(ProblemSense.__instancecheck__(ProblemSense.minimize))
+ self.assertTrue(ProblemSense.__instancecheck__(ProblemSense.maximize))
+
+ def test_getattr(self):
+ self.assertIs(ProblemSense.unknown, ProblemSense.unknown)
+ self.assertIs(ProblemSense.minimize, ObjectiveSense.minimize)
+ self.assertIs(ProblemSense.maximize, ObjectiveSense.maximize)
+
+ def test_hasattr(self):
+ self.assertTrue(hasattr(ProblemSense, 'unknown'))
+ self.assertTrue(hasattr(ProblemSense, 'minimize'))
+ self.assertTrue(hasattr(ProblemSense, 'maximize'))
+
+ def test_call(self):
+ self.assertIs(ProblemSense(0), ProblemSense.unknown)
+ self.assertIs(ProblemSense(1), ObjectiveSense.minimize)
+ self.assertIs(ProblemSense(-1), ObjectiveSense.maximize)
+
+ self.assertIs(ProblemSense('unknown'), ProblemSense.unknown)
+ self.assertIs(ProblemSense('minimize'), ObjectiveSense.minimize)
+ self.assertIs(ProblemSense('maximize'), ObjectiveSense.maximize)
+
+ with self.assertRaisesRegex(ValueError, "'foo' is not a valid ProblemSense"):
+ ProblemSense('foo')
+ with self.assertRaisesRegex(ValueError, "2 is not a valid ProblemSense"):
+ ProblemSense(2)
+
+ def test_contains(self):
+ self.assertIn(ProblemSense.unknown, ProblemSense)
+ self.assertIn(ProblemSense.minimize, ProblemSense)
+ self.assertIn(ProblemSense.maximize, ProblemSense)
+
+ self.assertNotIn(ProblemSense.unknown, ObjectiveSense)
+ self.assertIn(ProblemSense.minimize, ObjectiveSense)
+ self.assertIn(ProblemSense.maximize, ObjectiveSense)
+
+
+class TestObjectiveSense(unittest.TestCase):
+ def test_members(self):
+ self.assertEqual(
+ list(ObjectiveSense), [ObjectiveSense.minimize, ObjectiveSense.maximize]
+ )
+
+ def test_hasattr(self):
+ self.assertTrue(hasattr(ProblemSense, 'minimize'))
+ self.assertTrue(hasattr(ProblemSense, 'maximize'))
+
+ def test_call(self):
+ self.assertIs(ObjectiveSense(1), ObjectiveSense.minimize)
+ self.assertIs(ObjectiveSense(-1), ObjectiveSense.maximize)
+
+ self.assertIs(ObjectiveSense('minimize'), ObjectiveSense.minimize)
+ self.assertIs(ObjectiveSense('maximize'), ObjectiveSense.maximize)
+
+ with self.assertRaisesRegex(ValueError, "'foo' is not a valid ObjectiveSense"):
+ ObjectiveSense('foo')
+
+ def test_str(self):
+ self.assertEqual(str(ObjectiveSense.minimize), 'minimize')
+ self.assertEqual(str(ObjectiveSense.maximize), 'maximize')
diff --git a/pyomo/common/tests/test_log.py b/pyomo/common/tests/test_log.py
index 64691c0015a..166e1e44cdb 100644
--- a/pyomo/common/tests/test_log.py
+++ b/pyomo/common/tests/test_log.py
@@ -511,7 +511,6 @@ def test_verbatim(self):
"\n"
" quote block\n"
)
- self.maxDiff = None
self.assertEqual(self.stream.getvalue(), ans)
diff --git a/pyomo/common/tests/test_numeric_types.py b/pyomo/common/tests/test_numeric_types.py
new file mode 100644
index 00000000000..b7ffb5fb255
--- /dev/null
+++ b/pyomo/common/tests/test_numeric_types.py
@@ -0,0 +1,219 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.numeric_types as nt
+import pyomo.common.unittest as unittest
+
+from pyomo.common.dependencies import numpy, numpy_available
+from pyomo.core.expr import LinearExpression
+from pyomo.environ import Var
+
+_type_sets = (
+ 'native_types',
+ 'native_numeric_types',
+ 'native_logical_types',
+ 'native_integer_types',
+ 'native_complex_types',
+)
+
+
+class TestNativeTypes(unittest.TestCase):
+ def setUp(self):
+ bool(numpy_available)
+ for s in _type_sets:
+ setattr(self, s, set(getattr(nt, s)))
+ getattr(nt, s).clear()
+
+ def tearDown(self):
+ for s in _type_sets:
+ getattr(nt, s).clear()
+ getattr(nt, s).update(getattr(self, s))
+
+ def test_check_if_native_type(self):
+ self.assertEqual(nt.native_types, set())
+ self.assertEqual(nt.native_logical_types, set())
+ self.assertEqual(nt.native_numeric_types, set())
+ self.assertEqual(nt.native_integer_types, set())
+ self.assertEqual(nt.native_complex_types, set())
+
+ self.assertTrue(nt.check_if_native_type("a"))
+ self.assertIn(str, nt.native_types)
+ self.assertNotIn(str, nt.native_logical_types)
+ self.assertNotIn(str, nt.native_numeric_types)
+ self.assertNotIn(str, nt.native_integer_types)
+ self.assertNotIn(str, nt.native_complex_types)
+
+ self.assertTrue(nt.check_if_native_type(1))
+ self.assertIn(int, nt.native_types)
+ self.assertNotIn(int, nt.native_logical_types)
+ self.assertIn(int, nt.native_numeric_types)
+ self.assertIn(int, nt.native_integer_types)
+ self.assertNotIn(int, nt.native_complex_types)
+
+ self.assertTrue(nt.check_if_native_type(1.5))
+ self.assertIn(float, nt.native_types)
+ self.assertNotIn(float, nt.native_logical_types)
+ self.assertIn(float, nt.native_numeric_types)
+ self.assertNotIn(float, nt.native_integer_types)
+ self.assertNotIn(float, nt.native_complex_types)
+
+ self.assertTrue(nt.check_if_native_type(True))
+ self.assertIn(bool, nt.native_types)
+ self.assertIn(bool, nt.native_logical_types)
+ self.assertNotIn(bool, nt.native_numeric_types)
+ self.assertNotIn(bool, nt.native_integer_types)
+ self.assertNotIn(bool, nt.native_complex_types)
+
+ self.assertFalse(nt.check_if_native_type(slice(None, None, None)))
+ self.assertNotIn(slice, nt.native_types)
+ self.assertNotIn(slice, nt.native_logical_types)
+ self.assertNotIn(slice, nt.native_numeric_types)
+ self.assertNotIn(slice, nt.native_integer_types)
+ self.assertNotIn(slice, nt.native_complex_types)
+
+ def test_check_if_logical_type(self):
+ self.assertEqual(nt.native_types, set())
+ self.assertEqual(nt.native_logical_types, set())
+ self.assertEqual(nt.native_numeric_types, set())
+ self.assertEqual(nt.native_integer_types, set())
+ self.assertEqual(nt.native_complex_types, set())
+
+ self.assertFalse(nt.check_if_logical_type("a"))
+ self.assertNotIn(str, nt.native_types)
+ self.assertNotIn(str, nt.native_logical_types)
+ self.assertNotIn(str, nt.native_numeric_types)
+ self.assertNotIn(str, nt.native_integer_types)
+ self.assertNotIn(str, nt.native_complex_types)
+
+ self.assertFalse(nt.check_if_logical_type("a"))
+
+ self.assertTrue(nt.check_if_logical_type(True))
+ self.assertIn(bool, nt.native_types)
+ self.assertIn(bool, nt.native_logical_types)
+ self.assertNotIn(bool, nt.native_numeric_types)
+ self.assertNotIn(bool, nt.native_integer_types)
+ self.assertNotIn(bool, nt.native_complex_types)
+
+ self.assertTrue(nt.check_if_logical_type(True))
+
+ self.assertFalse(nt.check_if_logical_type(1))
+ self.assertNotIn(int, nt.native_types)
+ self.assertNotIn(int, nt.native_logical_types)
+ self.assertNotIn(int, nt.native_numeric_types)
+ self.assertNotIn(int, nt.native_integer_types)
+ self.assertNotIn(int, nt.native_complex_types)
+
+ if numpy_available:
+ self.assertTrue(nt.check_if_logical_type(numpy.bool_(1)))
+ self.assertIn(numpy.bool_, nt.native_types)
+ self.assertIn(numpy.bool_, nt.native_logical_types)
+ self.assertNotIn(numpy.bool_, nt.native_numeric_types)
+ self.assertNotIn(numpy.bool_, nt.native_integer_types)
+ self.assertNotIn(numpy.bool_, nt.native_complex_types)
+
+ def test_check_if_numeric_type(self):
+ self.assertEqual(nt.native_types, set())
+ self.assertEqual(nt.native_logical_types, set())
+ self.assertEqual(nt.native_numeric_types, set())
+ self.assertEqual(nt.native_integer_types, set())
+ self.assertEqual(nt.native_complex_types, set())
+
+ self.assertFalse(nt.check_if_numeric_type("a"))
+ self.assertFalse(nt.check_if_numeric_type("a"))
+ self.assertNotIn(str, nt.native_types)
+ self.assertNotIn(str, nt.native_logical_types)
+ self.assertNotIn(str, nt.native_numeric_types)
+ self.assertNotIn(str, nt.native_integer_types)
+ self.assertNotIn(str, nt.native_complex_types)
+
+ self.assertFalse(nt.check_if_numeric_type(True))
+ self.assertFalse(nt.check_if_numeric_type(True))
+ self.assertNotIn(bool, nt.native_types)
+ self.assertNotIn(bool, nt.native_logical_types)
+ self.assertNotIn(bool, nt.native_numeric_types)
+ self.assertNotIn(bool, nt.native_integer_types)
+ self.assertNotIn(bool, nt.native_complex_types)
+
+ self.assertTrue(nt.check_if_numeric_type(1))
+ self.assertTrue(nt.check_if_numeric_type(1))
+ self.assertIn(int, nt.native_types)
+ self.assertNotIn(int, nt.native_logical_types)
+ self.assertIn(int, nt.native_numeric_types)
+ self.assertIn(int, nt.native_integer_types)
+ self.assertNotIn(int, nt.native_complex_types)
+
+ self.assertTrue(nt.check_if_numeric_type(1.5))
+ self.assertTrue(nt.check_if_numeric_type(1.5))
+ self.assertIn(float, nt.native_types)
+ self.assertNotIn(float, nt.native_logical_types)
+ self.assertIn(float, nt.native_numeric_types)
+ self.assertNotIn(float, nt.native_integer_types)
+ self.assertNotIn(float, nt.native_complex_types)
+
+ self.assertFalse(nt.check_if_numeric_type(1j))
+ self.assertIn(complex, nt.native_types)
+ self.assertNotIn(complex, nt.native_logical_types)
+ self.assertNotIn(complex, nt.native_numeric_types)
+ self.assertNotIn(complex, nt.native_integer_types)
+ self.assertIn(complex, nt.native_complex_types)
+
+ v = Var()
+ v.construct()
+ self.assertFalse(nt.check_if_numeric_type(v))
+ self.assertNotIn(type(v), nt.native_types)
+ self.assertNotIn(type(v), nt.native_logical_types)
+ self.assertNotIn(type(v), nt.native_numeric_types)
+ self.assertNotIn(type(v), nt.native_integer_types)
+ self.assertNotIn(type(v), nt.native_complex_types)
+
+ e = LinearExpression([1])
+ self.assertFalse(nt.check_if_numeric_type(e))
+ self.assertNotIn(type(e), nt.native_types)
+ self.assertNotIn(type(e), nt.native_logical_types)
+ self.assertNotIn(type(e), nt.native_numeric_types)
+ self.assertNotIn(type(e), nt.native_integer_types)
+ self.assertNotIn(type(e), nt.native_complex_types)
+
+ if numpy_available:
+ self.assertFalse(nt.check_if_numeric_type(numpy.bool_(1)))
+ self.assertNotIn(numpy.bool_, nt.native_types)
+ self.assertNotIn(numpy.bool_, nt.native_logical_types)
+ self.assertNotIn(numpy.bool_, nt.native_numeric_types)
+ self.assertNotIn(numpy.bool_, nt.native_integer_types)
+ self.assertNotIn(numpy.bool_, nt.native_complex_types)
+
+ self.assertFalse(nt.check_if_numeric_type(numpy.array([1])))
+ self.assertNotIn(numpy.ndarray, nt.native_types)
+ self.assertNotIn(numpy.ndarray, nt.native_logical_types)
+ self.assertNotIn(numpy.ndarray, nt.native_numeric_types)
+ self.assertNotIn(numpy.ndarray, nt.native_integer_types)
+ self.assertNotIn(numpy.ndarray, nt.native_complex_types)
+
+ self.assertTrue(nt.check_if_numeric_type(numpy.float64(1)))
+ self.assertIn(numpy.float64, nt.native_types)
+ self.assertNotIn(numpy.float64, nt.native_logical_types)
+ self.assertIn(numpy.float64, nt.native_numeric_types)
+ self.assertNotIn(numpy.float64, nt.native_integer_types)
+ self.assertNotIn(numpy.float64, nt.native_complex_types)
+
+ self.assertTrue(nt.check_if_numeric_type(numpy.int64(1)))
+ self.assertIn(numpy.int64, nt.native_types)
+ self.assertNotIn(numpy.int64, nt.native_logical_types)
+ self.assertIn(numpy.int64, nt.native_numeric_types)
+ self.assertIn(numpy.int64, nt.native_integer_types)
+ self.assertNotIn(numpy.int64, nt.native_complex_types)
+
+ self.assertFalse(nt.check_if_numeric_type(numpy.complex128(1)))
+ self.assertIn(numpy.complex128, nt.native_types)
+ self.assertNotIn(numpy.complex128, nt.native_logical_types)
+ self.assertNotIn(numpy.complex128, nt.native_numeric_types)
+ self.assertNotIn(numpy.complex128, nt.native_integer_types)
+ self.assertIn(numpy.complex128, nt.native_complex_types)
diff --git a/pyomo/common/tests/test_timing.py b/pyomo/common/tests/test_timing.py
index 0a4224c5476..90f4cdcd034 100644
--- a/pyomo/common/tests/test_timing.py
+++ b/pyomo/common/tests/test_timing.py
@@ -35,7 +35,7 @@
Any,
TransformationFactory,
)
-from pyomo.core.base.var import _VarData
+from pyomo.core.base.var import VarData
class _pseudo_component(Var):
@@ -62,7 +62,7 @@ def test_raw_construction_timer(self):
)
v = Var()
v.construct()
- a = ConstructionTimer(_VarData(v))
+ a = ConstructionTimer(VarData(v))
self.assertRegex(
str(a),
r"ConstructionTimer object for Var ScalarVar\[NOTSET\]; "
@@ -107,7 +107,6 @@ def test_report_timing(self):
m.y = Var(Any, dense=False)
xfrm.apply_to(m)
result = out.getvalue().strip()
- self.maxDiff = None
for l, r in zip(result.splitlines(), ref.splitlines()):
self.assertRegex(str(l.strip()), str(r.strip()))
finally:
@@ -122,7 +121,6 @@ def test_report_timing(self):
m.y = Var(Any, dense=False)
xfrm.apply_to(m)
result = os.getvalue().strip()
- self.maxDiff = None
for l, r in zip(result.splitlines(), ref.splitlines()):
self.assertRegex(str(l.strip()), str(r.strip()))
finally:
@@ -135,7 +133,6 @@ def test_report_timing(self):
m.y = Var(Any, dense=False)
xfrm.apply_to(m)
result = os.getvalue().strip()
- self.maxDiff = None
for l, r in zip(result.splitlines(), ref.splitlines()):
self.assertRegex(str(l.strip()), str(r.strip()))
self.assertEqual(buf.getvalue().strip(), "")
@@ -172,7 +169,6 @@ def test_report_timing_context_manager(self):
xfrm.apply_to(m)
self.assertEqual(OUT.getvalue(), "")
result = OS.getvalue().strip()
- self.maxDiff = None
for l, r in zip_longest(result.splitlines(), ref.splitlines()):
self.assertRegex(str(l.strip()), str(r.strip()))
# Active reporting is False: the previous log should not have changed
diff --git a/pyomo/common/unittest.py b/pyomo/common/unittest.py
index 9a21b35faa8..84d962eb784 100644
--- a/pyomo/common/unittest.py
+++ b/pyomo/common/unittest.py
@@ -498,6 +498,10 @@ class TestCase(_unittest.TestCase):
__doc__ += _unittest.TestCase.__doc__
+ # By default, we always want to spend the time to create the full
+ # diff of the test reault and the baseline
+ maxDiff = None
+
def assertStructuredAlmostEqual(
self,
first,
@@ -631,7 +635,7 @@ def initialize_dependencies(self):
cls.package_modules = {}
packages_used = set(sum(list(cls.package_dependencies.values()), []))
for package_ in packages_used:
- pack, pack_avail = attempt_import(package_, defer_check=False)
+ pack, pack_avail = attempt_import(package_, defer_import=False)
cls.package_available[package_] = pack_avail
cls.package_modules[package_] = pack
diff --git a/pyomo/contrib/appsi/base.py b/pyomo/contrib/appsi/base.py
index 80e3cecec6d..6d2b5ccfcd4 100644
--- a/pyomo/contrib/appsi/base.py
+++ b/pyomo/contrib/appsi/base.py
@@ -21,12 +21,12 @@
Tuple,
MutableMapping,
)
-from pyomo.core.base.constraint import _GeneralConstraintData, Constraint
-from pyomo.core.base.sos import _SOSConstraintData, SOSConstraint
-from pyomo.core.base.var import _GeneralVarData, Var
-from pyomo.core.base.param import _ParamData, Param
-from pyomo.core.base.block import _BlockData, Block
-from pyomo.core.base.objective import _GeneralObjectiveData
+from pyomo.core.base.constraint import ConstraintData, Constraint
+from pyomo.core.base.sos import SOSConstraintData, SOSConstraint
+from pyomo.core.base.var import VarData, Var
+from pyomo.core.base.param import ParamData, Param
+from pyomo.core.base.block import BlockData, Block
+from pyomo.core.base.objective import ObjectiveData
from pyomo.common.collections import ComponentMap
from .utils.get_objective import get_objective
from .utils.collect_vars_and_named_exprs import collect_vars_and_named_exprs
@@ -179,9 +179,7 @@ def __init__(
class SolutionLoaderBase(abc.ABC):
- def load_vars(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> NoReturn:
+ def load_vars(self, vars_to_load: Optional[Sequence[VarData]] = None) -> NoReturn:
"""
Load the solution of the primal variables into the value attribute of the variables.
@@ -197,8 +195,8 @@ def load_vars(
@abc.abstractmethod
def get_primals(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
"""
Returns a ComponentMap mapping variable to var value.
@@ -216,8 +214,8 @@ def get_primals(
pass
def get_duals(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
"""
Returns a dictionary mapping constraint to dual value.
@@ -235,8 +233,8 @@ def get_duals(
raise NotImplementedError(f'{type(self)} does not support the get_duals method')
def get_slacks(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
"""
Returns a dictionary mapping constraint to slack.
@@ -256,8 +254,8 @@ def get_slacks(
)
def get_reduced_costs(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
"""
Returns a ComponentMap mapping variable to reduced cost.
@@ -303,8 +301,8 @@ def __init__(
self._reduced_costs = reduced_costs
def get_primals(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
if self._primals is None:
raise RuntimeError(
'Solution loader does not currently have a valid solution. Please '
@@ -319,8 +317,8 @@ def get_primals(
return primals
def get_duals(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
if self._duals is None:
raise RuntimeError(
'Solution loader does not currently have valid duals. Please '
@@ -336,8 +334,8 @@ def get_duals(
return duals
def get_slacks(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
if self._slacks is None:
raise RuntimeError(
'Solution loader does not currently have valid slacks. Please '
@@ -353,8 +351,8 @@ def get_slacks(
return slacks
def get_reduced_costs(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
if self._reduced_costs is None:
raise RuntimeError(
'Solution loader does not currently have valid reduced costs. Please '
@@ -621,13 +619,13 @@ def __str__(self):
return self.name
@abc.abstractmethod
- def solve(self, model: _BlockData, timer: HierarchicalTimer = None) -> Results:
+ def solve(self, model: BlockData, timer: HierarchicalTimer = None) -> Results:
"""
Solve a Pyomo model.
Parameters
----------
- model: _BlockData
+ model: BlockData
The Pyomo model to be solved
timer: HierarchicalTimer
An option timer for reporting timing
@@ -708,9 +706,7 @@ class PersistentSolver(Solver):
def is_persistent(self):
return True
- def load_vars(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> NoReturn:
+ def load_vars(self, vars_to_load: Optional[Sequence[VarData]] = None) -> NoReturn:
"""
Load the solution of the primal variables into the value attribute of the variables.
@@ -726,13 +722,13 @@ def load_vars(
@abc.abstractmethod
def get_primals(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
pass
def get_duals(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
"""
Declare sign convention in docstring here.
@@ -752,8 +748,8 @@ def get_duals(
)
def get_slacks(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
"""
Parameters
----------
@@ -771,8 +767,8 @@ def get_slacks(
)
def get_reduced_costs(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
"""
Parameters
----------
@@ -799,43 +795,43 @@ def set_instance(self, model):
pass
@abc.abstractmethod
- def add_variables(self, variables: List[_GeneralVarData]):
+ def add_variables(self, variables: List[VarData]):
pass
@abc.abstractmethod
- def add_params(self, params: List[_ParamData]):
+ def add_params(self, params: List[ParamData]):
pass
@abc.abstractmethod
- def add_constraints(self, cons: List[_GeneralConstraintData]):
+ def add_constraints(self, cons: List[ConstraintData]):
pass
@abc.abstractmethod
- def add_block(self, block: _BlockData):
+ def add_block(self, block: BlockData):
pass
@abc.abstractmethod
- def remove_variables(self, variables: List[_GeneralVarData]):
+ def remove_variables(self, variables: List[VarData]):
pass
@abc.abstractmethod
- def remove_params(self, params: List[_ParamData]):
+ def remove_params(self, params: List[ParamData]):
pass
@abc.abstractmethod
- def remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def remove_constraints(self, cons: List[ConstraintData]):
pass
@abc.abstractmethod
- def remove_block(self, block: _BlockData):
+ def remove_block(self, block: BlockData):
pass
@abc.abstractmethod
- def set_objective(self, obj: _GeneralObjectiveData):
+ def set_objective(self, obj: ObjectiveData):
pass
@abc.abstractmethod
- def update_variables(self, variables: List[_GeneralVarData]):
+ def update_variables(self, variables: List[VarData]):
pass
@abc.abstractmethod
@@ -857,20 +853,20 @@ def get_primals(self, vars_to_load=None):
return self._solver.get_primals(vars_to_load=vars_to_load)
def get_duals(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
self._assert_solution_still_valid()
return self._solver.get_duals(cons_to_load=cons_to_load)
def get_slacks(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
self._assert_solution_still_valid()
return self._solver.get_slacks(cons_to_load=cons_to_load)
def get_reduced_costs(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
self._assert_solution_still_valid()
return self._solver.get_reduced_costs(vars_to_load=vars_to_load)
@@ -954,10 +950,10 @@ def set_instance(self, model):
self.set_objective(None)
@abc.abstractmethod
- def _add_variables(self, variables: List[_GeneralVarData]):
+ def _add_variables(self, variables: List[VarData]):
pass
- def add_variables(self, variables: List[_GeneralVarData]):
+ def add_variables(self, variables: List[VarData]):
for v in variables:
if id(v) in self._referenced_variables:
raise ValueError(
@@ -975,19 +971,19 @@ def add_variables(self, variables: List[_GeneralVarData]):
self._add_variables(variables)
@abc.abstractmethod
- def _add_params(self, params: List[_ParamData]):
+ def _add_params(self, params: List[ParamData]):
pass
- def add_params(self, params: List[_ParamData]):
+ def add_params(self, params: List[ParamData]):
for p in params:
self._params[id(p)] = p
self._add_params(params)
@abc.abstractmethod
- def _add_constraints(self, cons: List[_GeneralConstraintData]):
+ def _add_constraints(self, cons: List[ConstraintData]):
pass
- def _check_for_new_vars(self, variables: List[_GeneralVarData]):
+ def _check_for_new_vars(self, variables: List[VarData]):
new_vars = dict()
for v in variables:
v_id = id(v)
@@ -995,7 +991,7 @@ def _check_for_new_vars(self, variables: List[_GeneralVarData]):
new_vars[v_id] = v
self.add_variables(list(new_vars.values()))
- def _check_to_remove_vars(self, variables: List[_GeneralVarData]):
+ def _check_to_remove_vars(self, variables: List[VarData]):
vars_to_remove = dict()
for v in variables:
v_id = id(v)
@@ -1004,7 +1000,7 @@ def _check_to_remove_vars(self, variables: List[_GeneralVarData]):
vars_to_remove[v_id] = v
self.remove_variables(list(vars_to_remove.values()))
- def add_constraints(self, cons: List[_GeneralConstraintData]):
+ def add_constraints(self, cons: List[ConstraintData]):
all_fixed_vars = dict()
for con in cons:
if con in self._named_expressions:
@@ -1034,10 +1030,10 @@ def add_constraints(self, cons: List[_GeneralConstraintData]):
v.fix()
@abc.abstractmethod
- def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _add_sos_constraints(self, cons: List[SOSConstraintData]):
pass
- def add_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def add_sos_constraints(self, cons: List[SOSConstraintData]):
for con in cons:
if con in self._vars_referenced_by_con:
raise ValueError(
@@ -1054,10 +1050,10 @@ def add_sos_constraints(self, cons: List[_SOSConstraintData]):
self._add_sos_constraints(cons)
@abc.abstractmethod
- def _set_objective(self, obj: _GeneralObjectiveData):
+ def _set_objective(self, obj: ObjectiveData):
pass
- def set_objective(self, obj: _GeneralObjectiveData):
+ def set_objective(self, obj: ObjectiveData):
if self._objective is not None:
for v in self._vars_referenced_by_obj:
self._referenced_variables[id(v)][2] = None
@@ -1132,10 +1128,10 @@ def add_block(self, block):
self.set_objective(obj)
@abc.abstractmethod
- def _remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def _remove_constraints(self, cons: List[ConstraintData]):
pass
- def remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def remove_constraints(self, cons: List[ConstraintData]):
self._remove_constraints(cons)
for con in cons:
if con not in self._named_expressions:
@@ -1154,10 +1150,10 @@ def remove_constraints(self, cons: List[_GeneralConstraintData]):
del self._vars_referenced_by_con[con]
@abc.abstractmethod
- def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _remove_sos_constraints(self, cons: List[SOSConstraintData]):
pass
- def remove_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def remove_sos_constraints(self, cons: List[SOSConstraintData]):
self._remove_sos_constraints(cons)
for con in cons:
if con not in self._vars_referenced_by_con:
@@ -1174,10 +1170,10 @@ def remove_sos_constraints(self, cons: List[_SOSConstraintData]):
del self._vars_referenced_by_con[con]
@abc.abstractmethod
- def _remove_variables(self, variables: List[_GeneralVarData]):
+ def _remove_variables(self, variables: List[VarData]):
pass
- def remove_variables(self, variables: List[_GeneralVarData]):
+ def remove_variables(self, variables: List[VarData]):
self._remove_variables(variables)
for v in variables:
v_id = id(v)
@@ -1198,10 +1194,10 @@ def remove_variables(self, variables: List[_GeneralVarData]):
del self._vars[v_id]
@abc.abstractmethod
- def _remove_params(self, params: List[_ParamData]):
+ def _remove_params(self, params: List[ParamData]):
pass
- def remove_params(self, params: List[_ParamData]):
+ def remove_params(self, params: List[ParamData]):
self._remove_params(params)
for p in params:
del self._params[id(p)]
@@ -1246,10 +1242,10 @@ def remove_block(self, block):
)
@abc.abstractmethod
- def _update_variables(self, variables: List[_GeneralVarData]):
+ def _update_variables(self, variables: List[VarData]):
pass
- def update_variables(self, variables: List[_GeneralVarData]):
+ def update_variables(self, variables: List[VarData]):
for v in variables:
self._vars[id(v)] = (
v,
@@ -1334,12 +1330,12 @@ def update(self, timer: HierarchicalTimer = None):
for c in self._vars_referenced_by_con.keys():
if c not in current_cons_dict and c not in current_sos_dict:
if (c.ctype is Constraint) or (
- c.ctype is None and isinstance(c, _GeneralConstraintData)
+ c.ctype is None and isinstance(c, ConstraintData)
):
old_cons.append(c)
else:
assert (c.ctype is SOSConstraint) or (
- c.ctype is None and isinstance(c, _SOSConstraintData)
+ c.ctype is None and isinstance(c, SOSConstraintData)
)
old_sos.append(c)
self.remove_constraints(old_cons)
@@ -1529,7 +1525,7 @@ def update(self, timer: HierarchicalTimer = None):
class LegacySolverInterface(object):
def solve(
self,
- model: _BlockData,
+ model: BlockData,
tee: bool = False,
load_solutions: bool = True,
logfile: Optional[str] = None,
@@ -1665,7 +1661,7 @@ def license_is_valid(self) -> bool:
@property
def options(self):
- for solver_name in ['gurobi', 'ipopt', 'cplex', 'cbc', 'highs']:
+ for solver_name in ['gurobi', 'ipopt', 'cplex', 'cbc', 'highs', 'maingo']:
if hasattr(self, solver_name + '_options'):
return getattr(self, solver_name + '_options')
raise NotImplementedError('Could not find the correct options')
@@ -1673,7 +1669,7 @@ def options(self):
@options.setter
def options(self, val):
found = False
- for solver_name in ['gurobi', 'ipopt', 'cplex', 'cbc', 'highs']:
+ for solver_name in ['gurobi', 'ipopt', 'cplex', 'cbc', 'highs', 'maingo']:
if hasattr(self, solver_name + '_options'):
setattr(self, solver_name + '_options', val)
found = True
@@ -1696,7 +1692,7 @@ def decorator(cls):
class LegacySolver(LegacySolverInterface, cls):
pass
- LegacySolverFactory.register(name, doc)(LegacySolver)
+ LegacySolverFactory.register('appsi_' + name, doc)(LegacySolver)
return cls
diff --git a/pyomo/contrib/appsi/build.py b/pyomo/contrib/appsi/build.py
index b3d78467f01..38f8cb713ca 100644
--- a/pyomo/contrib/appsi/build.py
+++ b/pyomo/contrib/appsi/build.py
@@ -16,15 +16,6 @@
import tempfile
-def handleReadonly(function, path, excinfo):
- excvalue = excinfo[1]
- if excvalue.errno == errno.EACCES:
- os.chmod(path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO) # 0777
- function(path)
- else:
- raise
-
-
def get_appsi_extension(in_setup=False, appsi_root=None):
from pybind11.setup_helpers import Pybind11Extension
@@ -66,6 +57,7 @@ def build_appsi(args=[]):
from setuptools import Distribution
from pybind11.setup_helpers import build_ext
import pybind11.setup_helpers
+ from pyomo.common.cmake_builder import handleReadonly
from pyomo.common.envvar import PYOMO_CONFIG_DIR
from pyomo.common.fileutils import this_file_dir
diff --git a/pyomo/contrib/appsi/cmodel/src/cmodel_bindings.cpp b/pyomo/contrib/appsi/cmodel/src/cmodel_bindings.cpp
index 6acc1d79845..5a838ffd786 100644
--- a/pyomo/contrib/appsi/cmodel/src/cmodel_bindings.cpp
+++ b/pyomo/contrib/appsi/cmodel/src/cmodel_bindings.cpp
@@ -63,7 +63,8 @@ PYBIND11_MODULE(appsi_cmodel, m) {
m.def("appsi_exprs_from_pyomo_exprs", &appsi_exprs_from_pyomo_exprs);
m.def("appsi_expr_from_pyomo_expr", &appsi_expr_from_pyomo_expr);
m.def("prep_for_repn", &prep_for_repn);
- py::class_(m, "PyomoExprTypes").def(py::init<>());
+ py::class_(m, "PyomoExprTypes", py::module_local())
+ .def(py::init<>());
py::class_>(m, "Node")
.def("is_variable_type", &Node::is_variable_type)
.def("is_param_type", &Node::is_param_type)
@@ -165,7 +166,7 @@ PYBIND11_MODULE(appsi_cmodel, m) {
.def(py::init<>())
.def("write", &LPWriter::write)
.def("get_solve_cons", &LPWriter::get_solve_cons);
- py::enum_(m, "ExprType")
+ py::enum_(m, "ExprType", py::module_local())
.value("py_float", ExprType::py_float)
.value("var", ExprType::var)
.value("param", ExprType::param)
diff --git a/pyomo/contrib/appsi/cmodel/src/expression.cpp b/pyomo/contrib/appsi/cmodel/src/expression.cpp
index 234ef47e86f..a49d6f2e499 100644
--- a/pyomo/contrib/appsi/cmodel/src/expression.cpp
+++ b/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>();
+ if (expr.attr("parent_component")().attr("mutable").cast())
+ res = param_map[expr_types.id(expr)].cast>();
+ else
+ res = std::make_shared(expr.attr("value").cast());
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() ==
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()) {
;
diff --git a/pyomo/contrib/appsi/cmodel/src/expression.hpp b/pyomo/contrib/appsi/cmodel/src/expression.hpp
index 0c0777ef468..e91ca0af3b3 100644
--- a/pyomo/contrib/appsi/cmodel/src/expression.hpp
+++ b/pyomo/contrib/appsi/cmodel/src/expression.hpp
@@ -680,10 +680,10 @@ class PyomoExprTypes {
expr_type_map[np_float32] = py_float;
expr_type_map[np_float64] = py_float;
expr_type_map[ScalarVar] = var;
- expr_type_map[_GeneralVarData] = var;
+ expr_type_map[VarData] = var;
expr_type_map[AutoLinkedBinaryVar] = var;
expr_type_map[ScalarParam] = param;
- expr_type_map[_ParamData] = param;
+ expr_type_map[ParamData] = param;
expr_type_map[MonomialTermExpression] = product;
expr_type_map[ProductExpression] = product;
expr_type_map[NPV_ProductExpression] = product;
@@ -700,7 +700,7 @@ class PyomoExprTypes {
expr_type_map[UnaryFunctionExpression] = unary_func;
expr_type_map[NPV_UnaryFunctionExpression] = unary_func;
expr_type_map[LinearExpression] = linear;
- expr_type_map[_GeneralExpressionData] = named_expr;
+ expr_type_map[ExpressionData] = named_expr;
expr_type_map[ScalarExpression] = named_expr;
expr_type_map[Integral] = named_expr;
expr_type_map[ScalarIntegral] = named_expr;
@@ -728,12 +728,12 @@ class PyomoExprTypes {
py::type np_float64 = np.attr("float64");
py::object ScalarParam =
py::module_::import("pyomo.core.base.param").attr("ScalarParam");
- py::object _ParamData =
- py::module_::import("pyomo.core.base.param").attr("_ParamData");
+ py::object ParamData =
+ py::module_::import("pyomo.core.base.param").attr("ParamData");
py::object ScalarVar =
py::module_::import("pyomo.core.base.var").attr("ScalarVar");
- py::object _GeneralVarData =
- py::module_::import("pyomo.core.base.var").attr("_GeneralVarData");
+ py::object VarData =
+ py::module_::import("pyomo.core.base.var").attr("VarData");
py::object AutoLinkedBinaryVar =
py::module_::import("pyomo.gdp.disjunct").attr("AutoLinkedBinaryVar");
py::object numeric_expr = py::module_::import("pyomo.core.expr.numeric_expr");
@@ -765,8 +765,8 @@ class PyomoExprTypes {
py::object NumericConstant =
py::module_::import("pyomo.core.expr.numvalue").attr("NumericConstant");
py::object expr_module = py::module_::import("pyomo.core.base.expression");
- py::object _GeneralExpressionData =
- expr_module.attr("_GeneralExpressionData");
+ py::object ExpressionData =
+ expr_module.attr("ExpressionData");
py::object ScalarExpression = expr_module.attr("ScalarExpression");
py::object ScalarIntegral =
py::module_::import("pyomo.dae.integral").attr("ScalarIntegral");
diff --git a/pyomo/contrib/appsi/fbbt.py b/pyomo/contrib/appsi/fbbt.py
index 8b6cc52d2aa..8e0c74b00e9 100644
--- a/pyomo/contrib/appsi/fbbt.py
+++ b/pyomo/contrib/appsi/fbbt.py
@@ -18,12 +18,12 @@
)
from .cmodel import cmodel, cmodel_available
from typing import List, Optional
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.param import _ParamData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.sos import _SOSConstraintData
-from pyomo.core.base.objective import _GeneralObjectiveData, minimize, maximize
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.sos import SOSConstraintData
+from pyomo.core.base.objective import ObjectiveData, minimize, maximize
+from pyomo.core.base.block import BlockData
from pyomo.core.base import SymbolMap, TextLabeler
from pyomo.common.errors import InfeasibleConstraintException
@@ -121,7 +121,7 @@ def set_instance(self, model, symbolic_solver_labels: Optional[bool] = None):
if self._objective is None:
self.set_objective(None)
- def _add_variables(self, variables: List[_GeneralVarData]):
+ def _add_variables(self, variables: List[VarData]):
if self._symbolic_solver_labels:
set_name = True
symbol_map = self._symbol_map
@@ -143,7 +143,7 @@ def _add_variables(self, variables: List[_GeneralVarData]):
False,
)
- def _add_params(self, params: List[_ParamData]):
+ def _add_params(self, params: List[ParamData]):
cparams = cmodel.create_params(len(params))
for ndx, p in enumerate(params):
cp = cparams[ndx]
@@ -154,7 +154,7 @@ def _add_params(self, params: List[_ParamData]):
cp = cparams[ndx]
cp.name = self._symbol_map.getSymbol(p, self._param_labeler)
- def _add_constraints(self, cons: List[_GeneralConstraintData]):
+ def _add_constraints(self, cons: List[ConstraintData]):
cmodel.process_fbbt_constraints(
self._cmodel,
self._pyomo_expr_types,
@@ -169,13 +169,13 @@ def _add_constraints(self, cons: List[_GeneralConstraintData]):
for c, cc in self._con_map.items():
cc.name = self._symbol_map.getSymbol(c, self._con_labeler)
- def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _add_sos_constraints(self, cons: List[SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError(
'IntervalTightener does not support SOS constraints'
)
- def _remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def _remove_constraints(self, cons: List[ConstraintData]):
if self._symbolic_solver_labels:
for c in cons:
self._symbol_map.removeSymbol(c)
@@ -184,13 +184,13 @@ def _remove_constraints(self, cons: List[_GeneralConstraintData]):
self._cmodel.remove_constraint(cc)
del self._rcon_map[cc]
- def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _remove_sos_constraints(self, cons: List[SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError(
'IntervalTightener does not support SOS constraints'
)
- def _remove_variables(self, variables: List[_GeneralVarData]):
+ def _remove_variables(self, variables: List[VarData]):
if self._symbolic_solver_labels:
for v in variables:
self._symbol_map.removeSymbol(v)
@@ -198,14 +198,14 @@ def _remove_variables(self, variables: List[_GeneralVarData]):
cvar = self._var_map.pop(id(v))
del self._rvar_map[cvar]
- def _remove_params(self, params: List[_ParamData]):
+ def _remove_params(self, params: List[ParamData]):
if self._symbolic_solver_labels:
for p in params:
self._symbol_map.removeSymbol(p)
for p in params:
del self._param_map[id(p)]
- def _update_variables(self, variables: List[_GeneralVarData]):
+ def _update_variables(self, variables: List[VarData]):
cmodel.process_pyomo_vars(
self._pyomo_expr_types,
variables,
@@ -224,13 +224,13 @@ def update_params(self):
cp = self._param_map[p_id]
cp.value = p.value
- def set_objective(self, obj: _GeneralObjectiveData):
+ def set_objective(self, obj: ObjectiveData):
if self._symbolic_solver_labels:
if self._objective is not None:
self._symbol_map.removeSymbol(self._objective)
super().set_objective(obj)
- def _set_objective(self, obj: _GeneralObjectiveData):
+ def _set_objective(self, obj: ObjectiveData):
if obj is None:
ce = cmodel.Constant(0)
sense = 0
@@ -275,7 +275,7 @@ def _deactivate_satisfied_cons(self):
c.deactivate()
def perform_fbbt(
- self, model: _BlockData, symbolic_solver_labels: Optional[bool] = None
+ self, model: BlockData, symbolic_solver_labels: Optional[bool] = None
):
if model is not self._model:
self.set_instance(model, symbolic_solver_labels=symbolic_solver_labels)
@@ -304,7 +304,7 @@ def perform_fbbt(
self._deactivate_satisfied_cons()
return n_iter
- def perform_fbbt_with_seed(self, model: _BlockData, seed_var: _GeneralVarData):
+ def perform_fbbt_with_seed(self, model: BlockData, seed_var: VarData):
if model is not self._model:
self.set_instance(model)
else:
diff --git a/pyomo/contrib/appsi/plugins.py b/pyomo/contrib/appsi/plugins.py
index b5cfd080b32..3e1b639ce3b 100644
--- a/pyomo/contrib/appsi/plugins.py
+++ b/pyomo/contrib/appsi/plugins.py
@@ -11,24 +11,25 @@
from pyomo.common.extensions import ExtensionBuilderFactory
from .base import SolverFactory
-from .solvers import Gurobi, Ipopt, Cbc, Cplex, Highs
+from .solvers import Gurobi, Ipopt, Cbc, Cplex, Highs, MAiNGO
from .build import AppsiBuilder
def load():
ExtensionBuilderFactory.register('appsi')(AppsiBuilder)
SolverFactory.register(
- name='appsi_gurobi', doc='Automated persistent interface to Gurobi'
+ name='gurobi', doc='Automated persistent interface to Gurobi'
)(Gurobi)
+ SolverFactory.register(name='cplex', doc='Automated persistent interface to Cplex')(
+ Cplex
+ )
+ SolverFactory.register(name='ipopt', doc='Automated persistent interface to Ipopt')(
+ Ipopt
+ )
+ SolverFactory.register(name='cbc', doc='Automated persistent interface to Cbc')(Cbc)
+ SolverFactory.register(name='highs', doc='Automated persistent interface to Highs')(
+ Highs
+ )
SolverFactory.register(
- name='appsi_cplex', doc='Automated persistent interface to Cplex'
- )(Cplex)
- SolverFactory.register(
- name='appsi_ipopt', doc='Automated persistent interface to Ipopt'
- )(Ipopt)
- SolverFactory.register(
- name='appsi_cbc', doc='Automated persistent interface to Cbc'
- )(Cbc)
- SolverFactory.register(
- name='appsi_highs', doc='Automated persistent interface to Highs'
- )(Highs)
+ name='maingo', doc='Automated persistent interface to MAiNGO'
+ )(MAiNGO)
diff --git a/pyomo/contrib/appsi/solvers/__init__.py b/pyomo/contrib/appsi/solvers/__init__.py
index c03523a69d4..352571b98f8 100644
--- a/pyomo/contrib/appsi/solvers/__init__.py
+++ b/pyomo/contrib/appsi/solvers/__init__.py
@@ -15,3 +15,4 @@
from .cplex import Cplex
from .highs import Highs
from .wntr import Wntr, WntrResults
+from .maingo import MAiNGO
diff --git a/pyomo/contrib/appsi/solvers/cbc.py b/pyomo/contrib/appsi/solvers/cbc.py
index 2c522af864d..08833e747e2 100644
--- a/pyomo/contrib/appsi/solvers/cbc.py
+++ b/pyomo/contrib/appsi/solvers/cbc.py
@@ -26,11 +26,11 @@
import math
from pyomo.common.collections import ComponentMap
from typing import Optional, Sequence, NoReturn, List, Mapping
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.block import _BlockData
-from pyomo.core.base.param import _ParamData
-from pyomo.core.base.objective import _GeneralObjectiveData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.block import BlockData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.objective import ObjectiveData
from pyomo.common.timing import HierarchicalTimer
from pyomo.common.tee import TeeStream
import sys
@@ -164,34 +164,34 @@ def symbol_map(self):
def set_instance(self, model):
self._writer.set_instance(model)
- def add_variables(self, variables: List[_GeneralVarData]):
+ def add_variables(self, variables: List[VarData]):
self._writer.add_variables(variables)
- def add_params(self, params: List[_ParamData]):
+ def add_params(self, params: List[ParamData]):
self._writer.add_params(params)
- def add_constraints(self, cons: List[_GeneralConstraintData]):
+ def add_constraints(self, cons: List[ConstraintData]):
self._writer.add_constraints(cons)
- def add_block(self, block: _BlockData):
+ def add_block(self, block: BlockData):
self._writer.add_block(block)
- def remove_variables(self, variables: List[_GeneralVarData]):
+ def remove_variables(self, variables: List[VarData]):
self._writer.remove_variables(variables)
- def remove_params(self, params: List[_ParamData]):
+ def remove_params(self, params: List[ParamData]):
self._writer.remove_params(params)
- def remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def remove_constraints(self, cons: List[ConstraintData]):
self._writer.remove_constraints(cons)
- def remove_block(self, block: _BlockData):
+ def remove_block(self, block: BlockData):
self._writer.remove_block(block)
- def set_objective(self, obj: _GeneralObjectiveData):
+ def set_objective(self, obj: ObjectiveData):
self._writer.set_objective(obj)
- def update_variables(self, variables: List[_GeneralVarData]):
+ def update_variables(self, variables: List[VarData]):
self._writer.update_variables(variables)
def update_params(self):
@@ -411,9 +411,11 @@ def _check_and_escape_options():
if cp.returncode != 0:
if self.config.load_solution:
raise RuntimeError(
- 'A feasible solution was not found, so no solution can be loaded.'
- 'Please set opt.config.load_solution=False and check '
- 'results.termination_condition and '
+ 'A feasible solution was not found, so no solution can be loaded. '
+ 'If using the appsi.solvers.Cbc interface, you can '
+ 'set opt.config.load_solution=False. If using the environ.SolverFactory '
+ 'interface, you can set opt.solve(model, load_solutions = False). '
+ 'Then you can check results.termination_condition and '
'results.best_feasible_objective before loading a solution.'
)
results = Results()
@@ -438,8 +440,8 @@ def _check_and_escape_options():
return results
def get_primals(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
if (
self._last_results_object is None
or self._last_results_object.best_feasible_objective is None
@@ -475,8 +477,8 @@ def get_duals(self, cons_to_load=None):
return {c: self._dual_sol[c] for c in cons_to_load}
def get_reduced_costs(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
if (
self._last_results_object is None
or self._last_results_object.termination_condition
diff --git a/pyomo/contrib/appsi/solvers/cplex.py b/pyomo/contrib/appsi/solvers/cplex.py
index 1d7147f16e8..10de981ce7d 100644
--- a/pyomo/contrib/appsi/solvers/cplex.py
+++ b/pyomo/contrib/appsi/solvers/cplex.py
@@ -22,11 +22,11 @@
import math
from pyomo.common.collections import ComponentMap
from typing import Optional, Sequence, NoReturn, List, Mapping, Dict
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.block import _BlockData
-from pyomo.core.base.param import _ParamData
-from pyomo.core.base.objective import _GeneralObjectiveData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.block import BlockData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.objective import ObjectiveData
from pyomo.common.timing import HierarchicalTimer
import sys
import time
@@ -179,34 +179,34 @@ def update_config(self):
def set_instance(self, model):
self._writer.set_instance(model)
- def add_variables(self, variables: List[_GeneralVarData]):
+ def add_variables(self, variables: List[VarData]):
self._writer.add_variables(variables)
- def add_params(self, params: List[_ParamData]):
+ def add_params(self, params: List[ParamData]):
self._writer.add_params(params)
- def add_constraints(self, cons: List[_GeneralConstraintData]):
+ def add_constraints(self, cons: List[ConstraintData]):
self._writer.add_constraints(cons)
- def add_block(self, block: _BlockData):
+ def add_block(self, block: BlockData):
self._writer.add_block(block)
- def remove_variables(self, variables: List[_GeneralVarData]):
+ def remove_variables(self, variables: List[VarData]):
self._writer.remove_variables(variables)
- def remove_params(self, params: List[_ParamData]):
+ def remove_params(self, params: List[ParamData]):
self._writer.remove_params(params)
- def remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def remove_constraints(self, cons: List[ConstraintData]):
self._writer.remove_constraints(cons)
- def remove_block(self, block: _BlockData):
+ def remove_block(self, block: BlockData):
self._writer.remove_block(block)
- def set_objective(self, obj: _GeneralObjectiveData):
+ def set_objective(self, obj: ObjectiveData):
self._writer.set_objective(obj)
- def update_variables(self, variables: List[_GeneralVarData]):
+ def update_variables(self, variables: List[VarData]):
self._writer.update_variables(variables)
def update_params(self):
@@ -341,9 +341,11 @@ def _postsolve(self, timer: HierarchicalTimer, solve_time):
if config.load_solution:
if cpxprob.solution.get_solution_type() == cpxprob.solution.type.none:
raise RuntimeError(
- 'A feasible solution was not found, so no solution can be loades. '
- 'Please set opt.config.load_solution=False and check '
- 'results.termination_condition and '
+ 'A feasible solution was not found, so no solution can be loaded. '
+ 'If using the appsi.solvers.Cplex interface, you can '
+ 'set opt.config.load_solution=False. If using the environ.SolverFactory '
+ 'interface, you can set opt.solve(model, load_solutions = False). '
+ 'Then you can check results.termination_condition and '
'results.best_feasible_objective before loading a solution.'
)
else:
@@ -360,8 +362,8 @@ def _postsolve(self, timer: HierarchicalTimer, solve_time):
return results
def get_primals(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
if (
self._cplex_model.solution.get_solution_type()
== self._cplex_model.solution.type.none
@@ -387,8 +389,8 @@ def get_primals(
return res
def get_duals(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ) -> Dict[_GeneralConstraintData, float]:
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
if (
self._cplex_model.solution.get_solution_type()
== self._cplex_model.solution.type.none
@@ -438,8 +440,8 @@ def get_duals(
return res
def get_reduced_costs(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
if (
self._cplex_model.solution.get_solution_type()
== self._cplex_model.solution.type.none
diff --git a/pyomo/contrib/appsi/solvers/gurobi.py b/pyomo/contrib/appsi/solvers/gurobi.py
index aa233ef77d6..2719ecc2a00 100644
--- a/pyomo/contrib/appsi/solvers/gurobi.py
+++ b/pyomo/contrib/appsi/solvers/gurobi.py
@@ -23,10 +23,10 @@
from pyomo.common.config import ConfigValue, NonNegativeInt
from pyomo.core.kernel.objective import minimize, maximize
from pyomo.core.base import SymbolMap, NumericLabeler, TextLabeler
-from pyomo.core.base.var import Var, _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.sos import _SOSConstraintData
-from pyomo.core.base.param import _ParamData
+from pyomo.core.base.var import Var, VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.sos import SOSConstraintData
+from pyomo.core.base.param import ParamData
from pyomo.core.expr.numvalue import value, is_constant, is_fixed, native_numeric_types
from pyomo.repn import generate_standard_repn
from pyomo.core.expr.numeric_expr import NPV_MaxExpression, NPV_MinExpression
@@ -458,7 +458,7 @@ def _process_domain_and_bounds(
return lb, ub, vtype
- def _add_variables(self, variables: List[_GeneralVarData]):
+ def _add_variables(self, variables: List[VarData]):
var_names = list()
vtypes = list()
lbs = list()
@@ -489,7 +489,7 @@ def _add_variables(self, variables: List[_GeneralVarData]):
self._vars_added_since_update.update(variables)
self._needs_updated = True
- def _add_params(self, params: List[_ParamData]):
+ def _add_params(self, params: List[ParamData]):
pass
def _reinit(self):
@@ -579,7 +579,7 @@ def _get_expr_from_pyomo_expr(self, expr):
mutable_quadratic_coefficients,
)
- def _add_constraints(self, cons: List[_GeneralConstraintData]):
+ def _add_constraints(self, cons: List[ConstraintData]):
for con in cons:
conname = self._symbol_map.getSymbol(con, self._labeler)
(
@@ -709,7 +709,7 @@ def _add_constraints(self, cons: List[_GeneralConstraintData]):
self._constraints_added_since_update.update(cons)
self._needs_updated = True
- def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _add_sos_constraints(self, cons: List[SOSConstraintData]):
for con in cons:
conname = self._symbol_map.getSymbol(con, self._labeler)
level = con.level
@@ -735,7 +735,7 @@ def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
self._constraints_added_since_update.update(cons)
self._needs_updated = True
- def _remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def _remove_constraints(self, cons: List[ConstraintData]):
for con in cons:
if con in self._constraints_added_since_update:
self._update_gurobi_model()
@@ -749,7 +749,7 @@ def _remove_constraints(self, cons: List[_GeneralConstraintData]):
self._mutable_quadratic_helpers.pop(con, None)
self._needs_updated = True
- def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _remove_sos_constraints(self, cons: List[SOSConstraintData]):
for con in cons:
if con in self._constraints_added_since_update:
self._update_gurobi_model()
@@ -759,7 +759,7 @@ def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
del self._pyomo_sos_to_solver_sos_map[con]
self._needs_updated = True
- def _remove_variables(self, variables: List[_GeneralVarData]):
+ def _remove_variables(self, variables: List[VarData]):
for var in variables:
v_id = id(var)
if var in self._vars_added_since_update:
@@ -771,10 +771,10 @@ def _remove_variables(self, variables: List[_GeneralVarData]):
self._mutable_bounds.pop(v_id, None)
self._needs_updated = True
- def _remove_params(self, params: List[_ParamData]):
+ def _remove_params(self, params: List[ParamData]):
pass
- def _update_variables(self, variables: List[_GeneralVarData]):
+ def _update_variables(self, variables: List[VarData]):
for var in variables:
var_id = id(var)
if var_id not in self._pyomo_var_to_solver_var_map:
@@ -946,9 +946,11 @@ def _postsolve(self, timer: HierarchicalTimer):
self.load_vars()
else:
raise RuntimeError(
- 'A feasible solution was not found, so no solution can be loaded.'
- 'Please set opt.config.load_solution=False and check '
- 'results.termination_condition and '
+ 'A feasible solution was not found, so no solution can be loaded. '
+ 'If using the appsi.solvers.Gurobi interface, you can '
+ 'set opt.config.load_solution=False. If using the environ.SolverFactory '
+ 'interface, you can set opt.solve(model, load_solutions = False). '
+ 'Then you can check results.termination_condition and '
'results.best_feasible_objective before loading a solution.'
)
timer.stop('load solution')
@@ -1193,7 +1195,7 @@ def set_linear_constraint_attr(self, con, attr, val):
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The pyomo constraint for which the corresponding gurobi constraint attribute
should be modified.
attr: str
@@ -1219,7 +1221,7 @@ def set_var_attr(self, var, attr, val):
Parameters
----------
- var: pyomo.core.base.var._GeneralVarData
+ var: pyomo.core.base.var.VarData
The pyomo var for which the corresponding gurobi var attribute
should be modified.
attr: str
@@ -1254,7 +1256,7 @@ def get_var_attr(self, var, attr):
Parameters
----------
- var: pyomo.core.base.var._GeneralVarData
+ var: pyomo.core.base.var.VarData
The pyomo var for which the corresponding gurobi var attribute
should be retrieved.
attr: str
@@ -1270,7 +1272,7 @@ def get_linear_constraint_attr(self, con, attr):
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The pyomo constraint for which the corresponding gurobi constraint attribute
should be retrieved.
attr: str
@@ -1286,7 +1288,7 @@ def get_sos_attr(self, con, attr):
Parameters
----------
- con: pyomo.core.base.sos._SOSConstraintData
+ con: pyomo.core.base.sos.SOSConstraintData
The pyomo SOS constraint for which the corresponding gurobi SOS constraint attribute
should be retrieved.
attr: str
@@ -1302,7 +1304,7 @@ def get_quadratic_constraint_attr(self, con, attr):
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The pyomo constraint for which the corresponding gurobi constraint attribute
should be retrieved.
attr: str
@@ -1423,7 +1425,7 @@ def cbCut(self, con):
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The cut to add
"""
if not con.active:
@@ -1508,7 +1510,7 @@ def cbLazy(self, con):
"""
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The lazy constraint to add
"""
if not con.active:
diff --git a/pyomo/contrib/appsi/solvers/highs.py b/pyomo/contrib/appsi/solvers/highs.py
index a9a23682355..c948444839d 100644
--- a/pyomo/contrib/appsi/solvers/highs.py
+++ b/pyomo/contrib/appsi/solvers/highs.py
@@ -20,10 +20,10 @@
from pyomo.common.log import LogStream
from pyomo.core.kernel.objective import minimize, maximize
from pyomo.core.base import SymbolMap
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.sos import _SOSConstraintData
-from pyomo.core.base.param import _ParamData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.sos import SOSConstraintData
+from pyomo.core.base.param import ParamData
from pyomo.core.expr.numvalue import value, is_constant
from pyomo.repn import generate_standard_repn
from pyomo.core.expr.numeric_expr import NPV_MaxExpression, NPV_MinExpression
@@ -176,11 +176,19 @@ def available(self):
return self.Availability.NotFound
def version(self):
- version = (
- highspy.HIGHS_VERSION_MAJOR,
- highspy.HIGHS_VERSION_MINOR,
- highspy.HIGHS_VERSION_PATCH,
- )
+ try:
+ version = (
+ highspy.HIGHS_VERSION_MAJOR,
+ highspy.HIGHS_VERSION_MINOR,
+ highspy.HIGHS_VERSION_PATCH,
+ )
+ except AttributeError:
+ # Older versions of Highs do not have the above attributes
+ # and the solver version can only be obtained by making
+ # an instance of the solver class.
+ tmp = highspy.Highs()
+ version = (tmp.versionMajor(), tmp.versionMinor(), tmp.versionPatch())
+
return version
@property
@@ -308,7 +316,7 @@ def _process_domain_and_bounds(self, var_id):
return lb, ub, vtype
- def _add_variables(self, variables: List[_GeneralVarData]):
+ def _add_variables(self, variables: List[VarData]):
self._sol = None
if self._last_results_object is not None:
self._last_results_object.solution_loader.invalidate()
@@ -335,7 +343,7 @@ def _add_variables(self, variables: List[_GeneralVarData]):
len(vtypes), np.array(indices), np.array(vtypes)
)
- def _add_params(self, params: List[_ParamData]):
+ def _add_params(self, params: List[ParamData]):
pass
def _reinit(self):
@@ -376,7 +384,7 @@ def set_instance(self, model):
if self._objective is None:
self.set_objective(None)
- def _add_constraints(self, cons: List[_GeneralConstraintData]):
+ def _add_constraints(self, cons: List[ConstraintData]):
self._sol = None
if self._last_results_object is not None:
self._last_results_object.solution_loader.invalidate()
@@ -456,13 +464,13 @@ def _add_constraints(self, cons: List[_GeneralConstraintData]):
np.array(coef_values, dtype=np.double),
)
- def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _add_sos_constraints(self, cons: List[SOSConstraintData]):
if cons:
raise NotImplementedError(
'Highs interface does not support SOS constraints'
)
- def _remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def _remove_constraints(self, cons: List[ConstraintData]):
self._sol = None
if self._last_results_object is not None:
self._last_results_object.solution_loader.invalidate()
@@ -487,13 +495,13 @@ def _remove_constraints(self, cons: List[_GeneralConstraintData]):
{v: k for k, v in self._pyomo_con_to_solver_con_map.items()}
)
- def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _remove_sos_constraints(self, cons: List[SOSConstraintData]):
if cons:
raise NotImplementedError(
'Highs interface does not support SOS constraints'
)
- def _remove_variables(self, variables: List[_GeneralVarData]):
+ def _remove_variables(self, variables: List[VarData]):
self._sol = None
if self._last_results_object is not None:
self._last_results_object.solution_loader.invalidate()
@@ -515,10 +523,10 @@ def _remove_variables(self, variables: List[_GeneralVarData]):
self._pyomo_var_to_solver_var_map.clear()
self._pyomo_var_to_solver_var_map.update(new_var_map)
- def _remove_params(self, params: List[_ParamData]):
+ def _remove_params(self, params: List[ParamData]):
pass
- def _update_variables(self, variables: List[_GeneralVarData]):
+ def _update_variables(self, variables: List[VarData]):
self._sol = None
if self._last_results_object is not None:
self._last_results_object.solution_loader.invalidate()
@@ -680,9 +688,11 @@ def _postsolve(self, timer: HierarchicalTimer):
self.load_vars()
else:
raise RuntimeError(
- 'A feasible solution was not found, so no solution can be loaded.'
- 'Please set opt.config.load_solution=False and check '
- 'results.termination_condition and '
+ 'A feasible solution was not found, so no solution can be loaded. '
+ 'If using the appsi.solvers.Highs interface, you can '
+ 'set opt.config.load_solution=False. If using the environ.SolverFactory '
+ 'interface, you can set opt.solve(model, load_solutions = False). '
+ 'Then you can check results.termination_condition and '
'results.best_feasible_objective before loading a solution.'
)
timer.stop('load solution')
diff --git a/pyomo/contrib/appsi/solvers/ipopt.py b/pyomo/contrib/appsi/solvers/ipopt.py
index d7a786e6c2c..76cd204e36d 100644
--- a/pyomo/contrib/appsi/solvers/ipopt.py
+++ b/pyomo/contrib/appsi/solvers/ipopt.py
@@ -28,11 +28,11 @@
from pyomo.core.expr.numvalue import value
from pyomo.core.expr.visitor import replace_expressions
from typing import Optional, Sequence, NoReturn, List, Mapping
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.block import _BlockData
-from pyomo.core.base.param import _ParamData
-from pyomo.core.base.objective import _GeneralObjectiveData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.block import BlockData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.objective import ObjectiveData
from pyomo.common.timing import HierarchicalTimer
from pyomo.common.tee import TeeStream
import sys
@@ -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,
@@ -227,34 +228,34 @@ def set_instance(self, model):
self._writer.config.symbolic_solver_labels = self.config.symbolic_solver_labels
self._writer.set_instance(model)
- def add_variables(self, variables: List[_GeneralVarData]):
+ def add_variables(self, variables: List[VarData]):
self._writer.add_variables(variables)
- def add_params(self, params: List[_ParamData]):
+ def add_params(self, params: List[ParamData]):
self._writer.add_params(params)
- def add_constraints(self, cons: List[_GeneralConstraintData]):
+ def add_constraints(self, cons: List[ConstraintData]):
self._writer.add_constraints(cons)
- def add_block(self, block: _BlockData):
+ def add_block(self, block: BlockData):
self._writer.add_block(block)
- def remove_variables(self, variables: List[_GeneralVarData]):
+ def remove_variables(self, variables: List[VarData]):
self._writer.remove_variables(variables)
- def remove_params(self, params: List[_ParamData]):
+ def remove_params(self, params: List[ParamData]):
self._writer.remove_params(params)
- def remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def remove_constraints(self, cons: List[ConstraintData]):
self._writer.remove_constraints(cons)
- def remove_block(self, block: _BlockData):
+ def remove_block(self, block: BlockData):
self._writer.remove_block(block)
- def set_objective(self, obj: _GeneralObjectiveData):
+ def set_objective(self, obj: ObjectiveData):
self._writer.set_objective(obj)
- def update_variables(self, variables: List[_GeneralVarData]):
+ def update_variables(self, variables: List[VarData]):
self._writer.update_variables(variables)
def update_params(self):
@@ -421,9 +422,11 @@ def _parse_sol(self):
results.best_feasible_objective = value(obj_expr_evaluated)
elif self.config.load_solution:
raise RuntimeError(
- 'A feasible solution was not found, so no solution can be loaded.'
- 'Please set opt.config.load_solution=False and check '
- 'results.termination_condition and '
+ 'A feasible solution was not found, so no solution can be loaded. '
+ 'If using the appsi.solvers.Ipopt interface, you can '
+ 'set opt.config.load_solution=False. If using the environ.SolverFactory '
+ 'interface, you can set opt.solve(model, load_solutions = False). '
+ 'Then you can check results.termination_condition and '
'results.best_feasible_objective before loading a solution.'
)
@@ -511,8 +514,8 @@ def _apply_solver(self, timer: HierarchicalTimer):
return results
def get_primals(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
if (
self._last_results_object is None
or self._last_results_object.best_feasible_objective is None
@@ -531,9 +534,7 @@ def get_primals(
res[v] = self._primal_sol[v]
return res
- def get_duals(
- self, cons_to_load: Optional[Sequence[_GeneralConstraintData]] = None
- ):
+ def get_duals(self, cons_to_load: Optional[Sequence[ConstraintData]] = None):
if (
self._last_results_object is None
or self._last_results_object.termination_condition
@@ -550,8 +551,8 @@ def get_duals(
return {c: self._dual_sol[c] for c in cons_to_load}
def get_reduced_costs(
- self, vars_to_load: Optional[Sequence[_GeneralVarData]] = None
- ) -> Mapping[_GeneralVarData, float]:
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
if (
self._last_results_object is None
or self._last_results_object.termination_condition
diff --git a/pyomo/contrib/appsi/solvers/maingo.py b/pyomo/contrib/appsi/solvers/maingo.py
new file mode 100644
index 00000000000..e52130061f7
--- /dev/null
+++ b/pyomo/contrib/appsi/solvers/maingo.py
@@ -0,0 +1,568 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from collections import namedtuple
+import logging
+import math
+import sys
+from typing import Optional, List, Dict
+
+from pyomo.contrib.appsi.base import (
+ PersistentSolver,
+ Results,
+ TerminationCondition,
+ MIPSolverConfig,
+ PersistentBase,
+ PersistentSolutionLoader,
+)
+from pyomo.contrib.appsi.cmodel import cmodel, cmodel_available
+from pyomo.common.collections import ComponentMap
+from pyomo.common.config import (
+ ConfigValue,
+ ConfigDict,
+ NonNegativeInt,
+ NonNegativeFloat,
+)
+from pyomo.common.dependencies import attempt_import
+from pyomo.common.errors import PyomoException
+from pyomo.common.log import LogStream
+from pyomo.common.tee import capture_output, TeeStream
+from pyomo.common.timing import HierarchicalTimer
+from pyomo.core.base import SymbolMap, NumericLabeler, TextLabeler
+from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.base.expression import ScalarExpression
+from pyomo.core.base.param import _ParamData
+from pyomo.core.base.sos import _SOSConstraintData
+from pyomo.core.base.var import Var, ScalarVar, _GeneralVarData
+import pyomo.core.expr.expr_common as common
+import pyomo.core.expr as EXPR
+from pyomo.core.expr.numvalue import (
+ value,
+ is_constant,
+ is_fixed,
+ native_numeric_types,
+ native_types,
+ nonpyomo_leaf_types,
+)
+from pyomo.core.kernel.objective import minimize, maximize
+from pyomo.core.staleflag import StaleFlagManager
+from pyomo.repn.util import valid_expr_ctypes_minlp
+
+
+def _import_SolverModel():
+ try:
+ from . import maingo_solvermodel
+ except ImportError:
+ raise
+ return maingo_solvermodel
+
+
+maingo_solvermodel, solvermodel_available = attempt_import(
+ "maingo_solvermodel", importer=_import_SolverModel
+)
+
+MaingoVar = namedtuple("MaingoVar", "type name lb ub init")
+
+logger = logging.getLogger(__name__)
+
+
+def _import_maingopy():
+ try:
+ import maingopy
+ except ImportError:
+ MAiNGO._available = MAiNGO.Availability.NotFound
+ raise
+ return maingopy
+
+
+maingopy, maingopy_available = attempt_import("maingopy", importer=_import_maingopy)
+
+
+class MAiNGOConfig(MIPSolverConfig):
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super(MAiNGOConfig, self).__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+ self.tolerances: ConfigDict = self.declare(
+ 'tolerances', ConfigDict(implicit=True)
+ )
+
+ self.tolerances.epsilonA: Optional[float] = self.tolerances.declare(
+ 'epsilonA',
+ ConfigValue(
+ domain=NonNegativeFloat,
+ default=1e-5,
+ description="Absolute optimality tolerance",
+ ),
+ )
+ self.tolerances.epsilonR: Optional[float] = self.tolerances.declare(
+ 'epsilonR',
+ ConfigValue(
+ domain=NonNegativeFloat,
+ default=1e-5,
+ description="Relative optimality tolerance",
+ ),
+ )
+ self.tolerances.deltaEq: Optional[float] = self.tolerances.declare(
+ 'deltaEq',
+ ConfigValue(
+ domain=NonNegativeFloat, default=1e-6, description="Equality tolerance"
+ ),
+ )
+
+ self.tolerances.deltaIneq: Optional[float] = self.tolerances.declare(
+ 'deltaIneq',
+ ConfigValue(
+ domain=NonNegativeFloat,
+ default=1e-6,
+ description="Inequality tolerance",
+ ),
+ )
+ self.declare("logfile", ConfigValue(domain=str, default=""))
+ self.declare("solver_output_logger", ConfigValue(default=logger))
+ self.declare(
+ "log_level", ConfigValue(domain=NonNegativeInt, default=logging.INFO)
+ )
+
+
+class MAiNGOSolutionLoader(PersistentSolutionLoader):
+ def load_vars(self, vars_to_load=None):
+ self._assert_solution_still_valid()
+ self._solver.load_vars(vars_to_load=vars_to_load)
+
+ def get_primals(self, vars_to_load=None):
+ self._assert_solution_still_valid()
+ return self._solver.get_primals(vars_to_load=vars_to_load)
+
+
+class MAiNGOResults(Results):
+ def __init__(self, solver):
+ super(MAiNGOResults, self).__init__()
+ self.wallclock_time = None
+ self.cpu_time = None
+ self.globally_optimal = None
+ self.solution_loader = MAiNGOSolutionLoader(solver=solver)
+
+
+class MAiNGO(PersistentBase, PersistentSolver):
+ """
+ Interface to MAiNGO
+ """
+
+ _available = None
+
+ def __init__(self, only_child_vars=False):
+ super(MAiNGO, self).__init__(only_child_vars=only_child_vars)
+ self._config = MAiNGOConfig()
+ self._solver_options = dict()
+ self._solver_model = None
+ self._mymaingo = None
+ self._symbol_map = SymbolMap()
+ self._labeler = None
+ self._maingo_vars = []
+ self._objective = None
+ self._cons = []
+ self._pyomo_var_to_solver_var_id_map = dict()
+ self._last_results_object: Optional[MAiNGOResults] = None
+
+ def available(self):
+ if not maingopy_available:
+ return self.Availability.NotFound
+ self._available = True
+ return self._available
+
+ def version(self):
+ import pkg_resources
+
+ version = pkg_resources.get_distribution('maingopy').version
+
+ return tuple(int(k) for k in version.split('.'))
+
+ @property
+ def config(self) -> MAiNGOConfig:
+ return self._config
+
+ @config.setter
+ def config(self, val: MAiNGOConfig):
+ self._config = val
+
+ @property
+ def maingo_options(self):
+ """
+ A dictionary mapping solver options to values for those options. These
+ are solver specific.
+
+ Returns
+ -------
+ dict
+ A dictionary mapping solver options to values for those options
+ """
+ return self._solver_options
+
+ @maingo_options.setter
+ def maingo_options(self, val: Dict):
+ self._solver_options = val
+
+ @property
+ def symbol_map(self):
+ return self._symbol_map
+
+ def _solve(self, timer: HierarchicalTimer):
+ ostreams = [
+ LogStream(
+ level=self.config.log_level, logger=self.config.solver_output_logger
+ )
+ ]
+ if self.config.stream_solver:
+ ostreams.append(sys.stdout)
+
+ with TeeStream(*ostreams) as t:
+ with capture_output(output=t.STDOUT, capture_fd=False):
+ config = self.config
+ options = self.maingo_options
+
+ self._mymaingo = maingopy.MAiNGO(self._solver_model)
+
+ self._mymaingo.set_option("loggingDestination", 2)
+ self._mymaingo.set_log_file_name(config.logfile)
+ self._mymaingo.set_option("epsilonA", config.tolerances.epsilonA)
+ self._mymaingo.set_option("epsilonR", config.tolerances.epsilonR)
+ self._mymaingo.set_option("deltaEq", config.tolerances.deltaEq)
+ self._mymaingo.set_option("deltaIneq", config.tolerances.deltaIneq)
+
+ if config.time_limit is not None:
+ self._mymaingo.set_option("maxTime", config.time_limit)
+ if config.mip_gap is not None:
+ self._mymaingo.set_option("epsilonR", config.mip_gap)
+ for key, option in options.items():
+ self._mymaingo.set_option(key, option)
+
+ timer.start("MAiNGO solve")
+ self._mymaingo.solve()
+ timer.stop("MAiNGO solve")
+
+ return self._postsolve(timer)
+
+ def solve(self, model, timer: HierarchicalTimer = None):
+ StaleFlagManager.mark_all_as_stale()
+
+ if self._last_results_object is not None:
+ self._last_results_object.solution_loader.invalidate()
+ if timer is None:
+ timer = HierarchicalTimer()
+ if model is not self._model:
+ timer.start("set_instance")
+ self.set_instance(model)
+ timer.stop("set_instance")
+ else:
+ timer.start("Update")
+ self.update(timer=timer)
+ timer.stop("Update")
+ res = self._solve(timer)
+ self._last_results_object = res
+ if self.config.report_timing:
+ logger.info("\n" + str(timer))
+ return res
+
+ def _process_domain_and_bounds(self, var):
+ _v, _lb, _ub, _fixed, _domain_interval, _value = self._vars[id(var)]
+ lb, ub, step = _domain_interval
+
+ if _fixed:
+ lb = _value
+ ub = _value
+ else:
+ if lb is None and _lb is None:
+ logger.warning(
+ "No lower bound for variable "
+ + var.getname()
+ + " set. Using -1e10 instead. Please consider setting a valid lower bound."
+ )
+ if ub is None and _ub is None:
+ logger.warning(
+ "No upper bound for variable "
+ + var.getname()
+ + " set. Using +1e10 instead. Please consider setting a valid upper bound."
+ )
+
+ if _lb is None:
+ _lb = -1e10
+ if _ub is None:
+ _ub = 1e10
+ if lb is None:
+ lb = -1e10
+ if ub is None:
+ ub = 1e10
+
+ lb = max(value(_lb), lb)
+ ub = min(value(_ub), ub)
+
+ if step == 0:
+ vtype = maingopy.VT_CONTINUOUS
+ elif step == 1:
+ if lb == 0 and ub == 1:
+ vtype = maingopy.VT_BINARY
+ else:
+ vtype = maingopy.VT_INTEGER
+ else:
+ raise ValueError(
+ f"Unrecognized domain step: {step} (should be either 0 or 1)"
+ )
+
+ return lb, ub, vtype
+
+ def _add_variables(self, variables: List[_GeneralVarData]):
+ for var in variables:
+ varname = self._symbol_map.getSymbol(var, self._labeler)
+ lb, ub, vtype = self._process_domain_and_bounds(var)
+ self._maingo_vars.append(
+ MaingoVar(name=varname, type=vtype, lb=lb, ub=ub, init=var.value)
+ )
+ self._pyomo_var_to_solver_var_id_map[id(var)] = len(self._maingo_vars) - 1
+
+ def _add_params(self, params: List[_ParamData]):
+ pass
+
+ def _reinit(self):
+ saved_config = self.config
+ saved_options = self.maingo_options
+ saved_update_config = self.update_config
+ self.__init__(only_child_vars=self._only_child_vars)
+ self.config = saved_config
+ self.maingo_options = saved_options
+ self.update_config = saved_update_config
+
+ def set_instance(self, model):
+ if self._last_results_object is not None:
+ self._last_results_object.solution_loader.invalidate()
+ if not self.available():
+ c = self.__class__
+ raise PyomoException(
+ f"Solver {c.__module__}.{c.__qualname__} is not available "
+ f"({self.available()})."
+ )
+ self._reinit()
+ self._model = model
+ if self.use_extensions and cmodel_available:
+ self._expr_types = cmodel.PyomoExprTypes()
+
+ if self.config.symbolic_solver_labels:
+ self._labeler = TextLabeler()
+ else:
+ self._labeler = NumericLabeler("x")
+
+ self.add_block(model)
+
+ self._solver_model = maingo_solvermodel.SolverModel(
+ var_list=self._maingo_vars,
+ con_list=self._cons,
+ objective=self._objective,
+ idmap=self._pyomo_var_to_solver_var_id_map,
+ logger=logger,
+ )
+
+ def _add_constraints(self, cons: List[_GeneralConstraintData]):
+ self._cons += cons
+
+ def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
+ if len(cons) >= 1:
+ raise NotImplementedError(
+ "MAiNGO does not currently support SOS constraints."
+ )
+ pass
+
+ def _remove_constraints(self, cons: List[_GeneralConstraintData]):
+ for con in cons:
+ self._cons.remove(con)
+
+ def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
+ if len(cons) >= 1:
+ raise NotImplementedError(
+ "MAiNGO does not currently support SOS constraints."
+ )
+ pass
+
+ def _remove_variables(self, variables: List[_GeneralVarData]):
+ removed_maingo_vars = []
+ for var in variables:
+ varname = self._symbol_map.getSymbol(var, self._labeler)
+ del self._maingo_vars[self._pyomo_var_to_solver_var_id_map[id(var)]]
+ removed_maingo_vars += [self._pyomo_var_to_solver_var_id_map[id(var)]]
+ del self._pyomo_var_to_solver_var_id_map[id(var)]
+
+ # Update _pyomo_var_to_solver_var_id_map to account for removed variables
+ for pyomo_var, maingo_var_id in self._pyomo_var_to_solver_var_id_map.items():
+ num_removed = 0
+ for removed_var in removed_maingo_vars:
+ if removed_var <= maingo_var_id:
+ num_removed += 1
+ self._pyomo_var_to_solver_var_id_map[pyomo_var] = (
+ maingo_var_id - num_removed
+ )
+
+ def _remove_params(self, params: List[_ParamData]):
+ pass
+
+ def _update_variables(self, variables: List[_GeneralVarData]):
+ for var in variables:
+ if id(var) not in self._pyomo_var_to_solver_var_id_map:
+ raise ValueError(
+ 'The Var provided to update_var needs to be added first: {0}'.format(
+ var
+ )
+ )
+ lb, ub, vtype = self._process_domain_and_bounds(var)
+ self._maingo_vars[self._pyomo_var_to_solver_var_id_map[id(var)]] = (
+ MaingoVar(name=var.name, type=vtype, lb=lb, ub=ub, init=var.value)
+ )
+
+ def update_params(self):
+ vars = [var[0] for var in self._vars.values()]
+ self._update_variables(vars)
+
+ def _set_objective(self, obj):
+
+ if not obj.sense in {minimize, maximize}:
+ raise ValueError("Objective sense is not recognized: {0}".format(obj.sense))
+ self._objective = obj
+
+ def _postsolve(self, timer: HierarchicalTimer):
+ config = self.config
+
+ mprob = self._mymaingo
+ status = mprob.get_status()
+ results = MAiNGOResults(solver=self)
+ results.wallclock_time = mprob.get_wallclock_solution_time()
+ results.cpu_time = mprob.get_cpu_solution_time()
+
+ if status in {maingopy.GLOBALLY_OPTIMAL, maingopy.FEASIBLE_POINT}:
+ results.termination_condition = TerminationCondition.optimal
+ results.globally_optimal = True
+ if status == maingopy.FEASIBLE_POINT:
+ results.globally_optimal = False
+ logger.warning(
+ "MAiNGO found a feasible solution but did not prove its global optimality."
+ )
+ elif status == maingopy.INFEASIBLE:
+ results.termination_condition = TerminationCondition.infeasible
+ else:
+ results.termination_condition = TerminationCondition.unknown
+
+ results.best_feasible_objective = None
+ results.best_objective_bound = None
+ if self._objective is not None:
+ try:
+ if self._objective.sense == maximize:
+ results.best_feasible_objective = -mprob.get_objective_value()
+ else:
+ results.best_feasible_objective = mprob.get_objective_value()
+ except:
+ results.best_feasible_objective = None
+ try:
+ if self._objective.sense == maximize:
+ results.best_objective_bound = -mprob.get_final_LBD()
+ else:
+ results.best_objective_bound = mprob.get_final_LBD()
+ except:
+ if self._objective.sense == maximize:
+ results.best_objective_bound = math.inf
+ else:
+ results.best_objective_bound = -math.inf
+
+ if results.best_feasible_objective is not None and not math.isfinite(
+ results.best_feasible_objective
+ ):
+ results.best_feasible_objective = None
+
+ timer.start("load solution")
+ if config.load_solution:
+ if results.termination_condition is TerminationCondition.optimal:
+ if not results.globally_optimal:
+ logger.warning(
+ "Loading a feasible but suboptimal solution. "
+ "Please set load_solution=False and check "
+ "results.termination_condition and "
+ "results.found_feasible_solution() before loading a solution."
+ )
+ self.load_vars()
+ else:
+ raise RuntimeError(
+ "A feasible solution was not found, so no solution can be loaded."
+ "Please set opt.config.load_solution=False and check "
+ "results.termination_condition and "
+ "results.best_feasible_objective before loading a solution."
+ )
+ timer.stop("load solution")
+
+ return results
+
+ def load_vars(self, vars_to_load=None):
+ for v, val in self.get_primals(vars_to_load=vars_to_load).items():
+ v.set_value(val, skip_validation=True)
+ StaleFlagManager.mark_all_as_stale(delayed=True)
+
+ def get_primals(self, vars_to_load=None):
+ if not self._mymaingo.get_status() in {
+ maingopy.GLOBALLY_OPTIMAL,
+ maingopy.FEASIBLE_POINT,
+ }:
+ raise RuntimeError(
+ "Solver does not currently have a valid solution."
+ "Please check the termination condition."
+ )
+
+ var_id_map = self._pyomo_var_to_solver_var_id_map
+ ref_vars = self._referenced_variables
+ if vars_to_load is None:
+ vars_to_load = var_id_map.keys()
+ else:
+ vars_to_load = [id(v) for v in vars_to_load]
+
+ maingo_var_ids_to_load = [
+ var_id_map[pyomo_var_id] for pyomo_var_id in vars_to_load
+ ]
+
+ solution_point = self._mymaingo.get_solution_point()
+ vals = [solution_point[var_id] for var_id in maingo_var_ids_to_load]
+
+ res = ComponentMap()
+ for var_id, val in zip(vars_to_load, vals):
+ using_cons, using_sos, using_obj = ref_vars[var_id]
+ if using_cons or using_sos or (using_obj is not None):
+ res[self._vars[var_id][0]] = val
+ return res
+
+ def get_reduced_costs(self, vars_to_load=None):
+ raise ValueError("MAiNGO does not support returning Reduced Costs")
+
+ def get_duals(self, cons_to_load=None):
+ raise ValueError("MAiNGO does not support returning Duals")
+
+ def update(self, timer: HierarchicalTimer = None):
+ super(MAiNGO, self).update(timer=timer)
+ self._solver_model = maingo_solvermodel.SolverModel(
+ var_list=self._maingo_vars,
+ con_list=self._cons,
+ objective=self._objective,
+ idmap=self._pyomo_var_to_solver_var_id_map,
+ logger=logger,
+ )
diff --git a/pyomo/contrib/appsi/solvers/maingo_solvermodel.py b/pyomo/contrib/appsi/solvers/maingo_solvermodel.py
new file mode 100644
index 00000000000..ca746c4a9b7
--- /dev/null
+++ b/pyomo/contrib/appsi/solvers/maingo_solvermodel.py
@@ -0,0 +1,291 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 math
+
+from pyomo.common.dependencies import attempt_import
+from pyomo.core.base.var import ScalarVar
+from pyomo.core.base.expression import ScalarExpression
+import pyomo.core.expr.expr_common as common
+import pyomo.core.expr as EXPR
+from pyomo.core.expr.numvalue import (
+ value,
+ is_constant,
+ is_fixed,
+ native_numeric_types,
+ native_types,
+ nonpyomo_leaf_types,
+)
+from pyomo.core.kernel.objective import minimize, maximize
+from pyomo.repn.util import valid_expr_ctypes_minlp
+
+
+def _import_maingopy():
+ try:
+ import maingopy
+ except ImportError:
+ raise
+ return maingopy
+
+
+maingopy, maingopy_available = attempt_import("maingopy", importer=_import_maingopy)
+
+_plusMinusOne = {1, -1}
+
+LEFT_TO_RIGHT = common.OperatorAssociativity.LEFT_TO_RIGHT
+RIGHT_TO_LEFT = common.OperatorAssociativity.RIGHT_TO_LEFT
+
+
+class ToMAiNGOVisitor(EXPR.ExpressionValueVisitor):
+ def __init__(self, variables, idmap):
+ super(ToMAiNGOVisitor, self).__init__()
+ self.variables = variables
+ self.idmap = idmap
+ self._pyomo_func_to_maingo_func = {
+ "log": maingopy.log,
+ "log10": ToMAiNGOVisitor.maingo_log10,
+ "sin": maingopy.sin,
+ "cos": maingopy.cos,
+ "tan": maingopy.tan,
+ "cosh": maingopy.cosh,
+ "sinh": maingopy.sinh,
+ "tanh": maingopy.tanh,
+ "asin": maingopy.asin,
+ "acos": maingopy.acos,
+ "atan": maingopy.atan,
+ "exp": maingopy.exp,
+ "sqrt": maingopy.sqrt,
+ "asinh": ToMAiNGOVisitor.maingo_asinh,
+ "acosh": ToMAiNGOVisitor.maingo_acosh,
+ "atanh": ToMAiNGOVisitor.maingo_atanh,
+ }
+
+ @classmethod
+ def maingo_log10(cls, x):
+ return maingopy.log(x) / math.log(10)
+
+ @classmethod
+ def maingo_asinh(cls, x):
+ return maingopy.log(x + maingopy.sqrt(maingopy.pow(x, 2) + 1))
+
+ @classmethod
+ def maingo_acosh(cls, x):
+ return maingopy.log(x + maingopy.sqrt(maingopy.pow(x, 2) - 1))
+
+ @classmethod
+ def maingo_atanh(cls, x):
+ return 0.5 * maingopy.log(x + 1) - 0.5 * maingopy.log(1 - x)
+
+ def visit(self, node, values):
+ """Visit nodes that have been expanded"""
+ for i, val in enumerate(values):
+ arg = node._args_[i]
+
+ if arg is None:
+ values[i] = "Undefined"
+ elif arg.__class__ in native_numeric_types:
+ pass
+ elif arg.__class__ in nonpyomo_leaf_types:
+ values[i] = val
+ else:
+ parens = False
+ if arg.is_expression_type() and node.PRECEDENCE is not None:
+ if arg.PRECEDENCE is None:
+ pass
+ elif node.PRECEDENCE < arg.PRECEDENCE:
+ parens = True
+ elif node.PRECEDENCE == arg.PRECEDENCE:
+ if i == 0:
+ parens = node.ASSOCIATIVITY != LEFT_TO_RIGHT
+ elif i == len(node._args_) - 1:
+ parens = node.ASSOCIATIVITY != RIGHT_TO_LEFT
+ else:
+ parens = True
+ if parens:
+ values[i] = val
+
+ if node.__class__ in EXPR.NPV_expression_types:
+ return value(node)
+
+ if node.__class__ in {EXPR.ProductExpression, EXPR.MonomialTermExpression}:
+ return values[0] * values[1]
+
+ if node.__class__ in {EXPR.SumExpression}:
+ return sum(values)
+
+ if node.__class__ in {EXPR.PowExpression}:
+ return maingopy.pow(values[0], values[1])
+
+ if node.__class__ in {EXPR.DivisionExpression}:
+ return values[0] / values[1]
+
+ if node.__class__ in {EXPR.NegationExpression}:
+ return -values[0]
+
+ if node.__class__ in {EXPR.AbsExpression}:
+ return maingopy.abs(values[0])
+
+ if node.__class__ in {EXPR.UnaryFunctionExpression}:
+ pyomo_func = node.getname()
+ maingo_func = self._pyomo_func_to_maingo_func[pyomo_func]
+ return maingo_func(values[0])
+
+ if node.__class__ in {ScalarExpression}:
+ return values[0]
+
+ raise ValueError(f"Unknown function expression encountered: {node.getname()}")
+
+ def visiting_potential_leaf(self, node):
+ """
+ Visiting a potential leaf.
+
+ Return True if the node is not expanded.
+ """
+ if node.__class__ in native_types:
+ return True, node
+
+ if node.is_expression_type():
+ if node.__class__ is EXPR.MonomialTermExpression:
+ return True, self._monomial_to_maingo(node)
+ if node.__class__ is EXPR.LinearExpression:
+ return True, self._linear_to_maingo(node)
+ return False, None
+
+ if node.is_component_type():
+ if node.ctype not in valid_expr_ctypes_minlp:
+ # Make sure all components in active constraints
+ # are basic ctypes we know how to deal with.
+ raise RuntimeError(
+ "Unallowable component '%s' of type %s found in an active "
+ "constraint or objective.\nMAiNGO cannot export "
+ "expressions with this component type."
+ % (node.name, node.ctype.__name__)
+ )
+
+ if node.is_fixed():
+ return True, node()
+ else:
+ assert node.is_variable_type()
+ maingo_var_id = self.idmap[id(node)]
+ maingo_var = self.variables[maingo_var_id]
+ return True, maingo_var
+
+ def _monomial_to_maingo(self, node):
+ const, var = node.args
+ if const.__class__ not in native_types:
+ const = value(const)
+ if var.is_fixed():
+ return const * var.value
+ if not const:
+ return 0
+ maingo_var = self._var_to_maingo(var)
+ if const in _plusMinusOne:
+ if const < 0:
+ return -maingo_var
+ else:
+ return maingo_var
+ return const * maingo_var
+
+ def _var_to_maingo(self, var):
+ maingo_var_id = self.idmap[id(var)]
+ maingo_var = self.variables[maingo_var_id]
+ return maingo_var
+
+ def _linear_to_maingo(self, node):
+ values = [
+ (
+ self._monomial_to_maingo(arg)
+ if (arg.__class__ is EXPR.MonomialTermExpression)
+ else (
+ value(arg)
+ if arg.__class__ in native_numeric_types
+ else (
+ self._var_to_maingo(arg)
+ if arg.is_variable_type()
+ else value(arg)
+ )
+ )
+ )
+ for arg in node.args
+ ]
+ return sum(values)
+
+
+class SolverModel(maingopy.MAiNGOmodel):
+ def __init__(self, var_list, objective, con_list, idmap, logger):
+ maingopy.MAiNGOmodel.__init__(self)
+ self._var_list = var_list
+ self._con_list = con_list
+ self._objective = objective
+ self._idmap = idmap
+ self._logger = logger
+ self._no_objective = False
+
+ if self._objective is None:
+ self._logger.warning("No objective given, setting a dummy objective of 1.")
+ self._no_objective = True
+
+ def build_maingo_objective(self, obj, visitor):
+ if self._no_objective:
+ return visitor.variables[-1]
+ maingo_obj = visitor.dfs_postorder_stack(obj.expr)
+ if obj.sense == maximize:
+ return -1 * maingo_obj
+ return maingo_obj
+
+ def build_maingo_constraints(self, cons, visitor):
+ eqs = []
+ ineqs = []
+ for con in cons:
+ if con.equality:
+ eqs += [visitor.dfs_postorder_stack(con.body - con.lower)]
+ elif con.has_ub() and con.has_lb():
+ ineqs += [visitor.dfs_postorder_stack(con.body - con.upper)]
+ ineqs += [visitor.dfs_postorder_stack(con.lower - con.body)]
+ elif con.has_ub():
+ ineqs += [visitor.dfs_postorder_stack(con.body - con.upper)]
+ elif con.has_lb():
+ ineqs += [visitor.dfs_postorder_stack(con.lower - con.body)]
+ else:
+ raise ValueError(
+ "Constraint does not have a lower "
+ "or an upper bound: {0} \n".format(con)
+ )
+ return eqs, ineqs
+
+ def get_variables(self):
+ vars = [
+ maingopy.OptimizationVariable(
+ maingopy.Bounds(var.lb, var.ub), var.type, var.name
+ )
+ for var in self._var_list
+ ]
+ if self._no_objective:
+ vars += [maingopy.OptimizationVariable(maingopy.Bounds(1, 1), "dummy_obj")]
+ return vars
+
+ def get_initial_point(self):
+ initial = [
+ var.init if not var.init is None else (var.lb + var.ub) / 2.0
+ for var in self._var_list
+ ]
+ if self._no_objective:
+ initial += [1]
+ return initial
+
+ def evaluate(self, maingo_vars):
+ visitor = ToMAiNGOVisitor(maingo_vars, self._idmap)
+ result = maingopy.EvaluationContainer()
+ result.objective = self.build_maingo_objective(self._objective, visitor)
+ eqs, ineqs = self.build_maingo_constraints(self._con_list, visitor)
+ result.eq = eqs
+ result.ineq = ineqs
+ return result
diff --git a/pyomo/contrib/appsi/solvers/tests/test_persistent_solvers.py b/pyomo/contrib/appsi/solvers/tests/test_persistent_solvers.py
index af615d1ed8b..67088297cf4 100644
--- a/pyomo/contrib/appsi/solvers/tests/test_persistent_solvers.py
+++ b/pyomo/contrib/appsi/solvers/tests/test_persistent_solvers.py
@@ -17,7 +17,7 @@
parameterized = parameterized.parameterized
from pyomo.contrib.appsi.base import TerminationCondition, Results, PersistentSolver
from pyomo.contrib.appsi.cmodel import cmodel_available
-from pyomo.contrib.appsi.solvers import Gurobi, Ipopt, Cplex, Cbc, Highs
+from pyomo.contrib.appsi.solvers import Gurobi, Ipopt, Cplex, Cbc, Highs, MAiNGO
from typing import Type
from pyomo.core.expr.numeric_expr import LinearExpression
import os
@@ -36,11 +36,23 @@
('cplex', Cplex),
('cbc', Cbc),
('highs', Highs),
+ ('maingo', MAiNGO),
]
-mip_solvers = [('gurobi', Gurobi), ('cplex', Cplex), ('cbc', Cbc), ('highs', Highs)]
-nlp_solvers = [('ipopt', Ipopt)]
-qcp_solvers = [('gurobi', Gurobi), ('ipopt', Ipopt), ('cplex', Cplex)]
-miqcqp_solvers = [('gurobi', Gurobi), ('cplex', Cplex)]
+mip_solvers = [
+ ('gurobi', Gurobi),
+ ('cplex', Cplex),
+ ('cbc', Cbc),
+ ('highs', Highs),
+ ('maingo', MAiNGO),
+]
+nlp_solvers = [('ipopt', Ipopt), ('maingo', MAiNGO)]
+qcp_solvers = [
+ ('gurobi', Gurobi),
+ ('ipopt', Ipopt),
+ ('cplex', Cplex),
+ ('maingo', MAiNGO),
+]
+miqcqp_solvers = [('gurobi', Gurobi), ('cplex', Cplex), ('maingo', MAiNGO)]
only_child_vars_options = [True, False]
@@ -172,14 +184,16 @@ def test_range_constraint(
res = opt.solve(m)
self.assertEqual(res.termination_condition, TerminationCondition.optimal)
self.assertAlmostEqual(m.x.value, -1)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c], 1)
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c], 1)
m.obj.sense = pe.maximize
res = opt.solve(m)
self.assertEqual(res.termination_condition, TerminationCondition.optimal)
self.assertAlmostEqual(m.x.value, 1)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c], 1)
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c], 1)
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_reduced_costs(
@@ -196,9 +210,10 @@ def test_reduced_costs(
self.assertEqual(res.termination_condition, TerminationCondition.optimal)
self.assertAlmostEqual(m.x.value, -1)
self.assertAlmostEqual(m.y.value, -2)
- rc = opt.get_reduced_costs()
- self.assertAlmostEqual(rc[m.x], 3)
- self.assertAlmostEqual(rc[m.y], 4)
+ if opt_class != MAiNGO:
+ rc = opt.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], 3)
+ self.assertAlmostEqual(rc[m.y], 4)
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_reduced_costs2(
@@ -213,14 +228,16 @@ def test_reduced_costs2(
res = opt.solve(m)
self.assertEqual(res.termination_condition, TerminationCondition.optimal)
self.assertAlmostEqual(m.x.value, -1)
- rc = opt.get_reduced_costs()
- self.assertAlmostEqual(rc[m.x], 1)
+ if opt_class != MAiNGO:
+ rc = opt.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], 1)
m.obj.sense = pe.maximize
res = opt.solve(m)
self.assertEqual(res.termination_condition, TerminationCondition.optimal)
self.assertAlmostEqual(m.x.value, 1)
- rc = opt.get_reduced_costs()
- self.assertAlmostEqual(rc[m.x], 1)
+ if opt_class != MAiNGO:
+ rc = opt.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], 1)
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_param_changes(
@@ -252,9 +269,10 @@ def test_param_changes(
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value)
self.assertTrue(res.best_objective_bound <= m.y.value)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
- self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_immutable_param(
@@ -290,9 +308,10 @@ def test_immutable_param(
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value)
self.assertTrue(res.best_objective_bound <= m.y.value)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
- self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_equality(
@@ -324,9 +343,10 @@ def test_equality(
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value)
self.assertTrue(res.best_objective_bound <= m.y.value)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
- self.assertAlmostEqual(duals[m.c2], -a1 / (a2 - a1))
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], -a1 / (a2 - a1))
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_linear_expression(
@@ -394,9 +414,10 @@ def test_no_objective(
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
self.assertEqual(res.best_feasible_objective, None)
self.assertEqual(res.best_objective_bound, None)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c1], 0)
- self.assertAlmostEqual(duals[m.c2], 0)
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c1], 0)
+ self.assertAlmostEqual(duals[m.c2], 0)
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_add_remove_cons(
@@ -423,9 +444,10 @@ def test_add_remove_cons(
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value)
self.assertTrue(res.best_objective_bound <= m.y.value)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a2 - a1)))
- self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
m.c3 = pe.Constraint(expr=m.y >= a3 * m.x + b3)
res = opt.solve(m)
@@ -434,10 +456,11 @@ def test_add_remove_cons(
self.assertAlmostEqual(m.y.value, a1 * (b3 - b1) / (a1 - a3) + b1)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value)
self.assertTrue(res.best_objective_bound <= m.y.value)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a3 - a1)))
- self.assertAlmostEqual(duals[m.c2], 0)
- self.assertAlmostEqual(duals[m.c3], a1 / (a3 - a1))
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a3 - a1)))
+ self.assertAlmostEqual(duals[m.c2], 0)
+ self.assertAlmostEqual(duals[m.c3], a1 / (a3 - a1))
del m.c3
res = opt.solve(m)
@@ -446,9 +469,10 @@ def test_add_remove_cons(
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value)
self.assertTrue(res.best_objective_bound <= m.y.value)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a2 - a1)))
- self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_results_infeasible(
@@ -487,14 +511,15 @@ def test_results_infeasible(
RuntimeError, '.*does not currently have a valid solution.*'
):
res.solution_loader.load_vars()
- with self.assertRaisesRegex(
- RuntimeError, '.*does not currently have valid duals.*'
- ):
- res.solution_loader.get_duals()
- with self.assertRaisesRegex(
- RuntimeError, '.*does not currently have valid reduced costs.*'
- ):
- res.solution_loader.get_reduced_costs()
+ if opt_class != MAiNGO:
+ with self.assertRaisesRegex(
+ RuntimeError, '.*does not currently have valid duals.*'
+ ):
+ res.solution_loader.get_duals()
+ with self.assertRaisesRegex(
+ RuntimeError, '.*does not currently have valid reduced costs.*'
+ ):
+ res.solution_loader.get_reduced_costs()
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_duals(self, name: str, opt_class: Type[PersistentSolver], only_child_vars):
@@ -511,13 +536,14 @@ def test_duals(self, name: str, opt_class: Type[PersistentSolver], only_child_va
res = opt.solve(m)
self.assertAlmostEqual(m.x.value, 1)
self.assertAlmostEqual(m.y.value, 1)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.c1], 0.5)
- self.assertAlmostEqual(duals[m.c2], 0.5)
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.c1], 0.5)
+ self.assertAlmostEqual(duals[m.c2], 0.5)
- duals = opt.get_duals(cons_to_load=[m.c1])
- self.assertAlmostEqual(duals[m.c1], 0.5)
- self.assertNotIn(m.c2, duals)
+ duals = opt.get_duals(cons_to_load=[m.c1])
+ self.assertAlmostEqual(duals[m.c1], 0.5)
+ self.assertNotIn(m.c2, duals)
@parameterized.expand(input=_load_tests(qcp_solvers, only_child_vars_options))
def test_mutable_quadratic_coefficient(
@@ -672,7 +698,7 @@ def test_fixed_vars_4(
):
opt: PersistentSolver = opt_class(only_child_vars=only_child_vars)
opt.update_config.treat_fixed_vars_as_params = True
- if not opt.available():
+ if not opt.available() or opt_class == MAiNGO:
raise unittest.SkipTest
m = pe.ConcreteModel()
m.x = pe.Var()
@@ -765,17 +791,19 @@ def test_mutable_param_with_range(
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1, 6)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value, 6)
self.assertTrue(res.best_objective_bound <= m.y.value + 1e-12)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.con1], (1 + a1 / (a2 - a1)), 6)
- self.assertAlmostEqual(duals[m.con2], -a1 / (a2 - a1), 6)
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.con1], (1 + a1 / (a2 - a1)), 6)
+ self.assertAlmostEqual(duals[m.con2], -a1 / (a2 - a1), 6)
else:
self.assertAlmostEqual(m.x.value, (c2 - c1) / (a1 - a2), 6)
self.assertAlmostEqual(m.y.value, a1 * (c2 - c1) / (a1 - a2) + c1, 6)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value, 6)
self.assertTrue(res.best_objective_bound >= m.y.value - 1e-12)
- duals = opt.get_duals()
- self.assertAlmostEqual(duals[m.con1], (1 + a1 / (a2 - a1)), 6)
- self.assertAlmostEqual(duals[m.con2], -a1 / (a2 - a1), 6)
+ if opt_class != MAiNGO:
+ duals = opt.get_duals()
+ self.assertAlmostEqual(duals[m.con1], (1 + a1 / (a2 - a1)), 6)
+ self.assertAlmostEqual(duals[m.con2], -a1 / (a2 - a1), 6)
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_add_and_remove_vars(
@@ -837,13 +865,13 @@ def test_exp(self, name: str, opt_class: Type[PersistentSolver], only_child_vars
m.obj = pe.Objective(expr=m.x**2 + m.y**2)
m.c1 = pe.Constraint(expr=m.y >= pe.exp(m.x))
res = opt.solve(m)
- self.assertAlmostEqual(m.x.value, -0.42630274815985264)
- self.assertAlmostEqual(m.y.value, 0.6529186341994245)
+ self.assertAlmostEqual(m.x.value, -0.42630274815985264, 6)
+ self.assertAlmostEqual(m.y.value, 0.6529186341994245, 6)
@parameterized.expand(input=_load_tests(nlp_solvers, only_child_vars_options))
def test_log(self, name: str, opt_class: Type[PersistentSolver], only_child_vars):
opt = opt_class(only_child_vars=only_child_vars)
- if not opt.available():
+ if not opt.available() or opt_class == MAiNGO:
raise unittest.SkipTest
m = pe.ConcreteModel()
m.x = pe.Var(initialize=1)
@@ -918,6 +946,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
@@ -952,31 +1001,32 @@ def test_solution_loader(
self.assertNotIn(m.x, primals)
self.assertIn(m.y, primals)
self.assertAlmostEqual(primals[m.y], 1)
- reduced_costs = res.solution_loader.get_reduced_costs()
- self.assertIn(m.x, reduced_costs)
- self.assertIn(m.y, reduced_costs)
- self.assertAlmostEqual(reduced_costs[m.x], 1)
- self.assertAlmostEqual(reduced_costs[m.y], 0)
- reduced_costs = res.solution_loader.get_reduced_costs([m.y])
- self.assertNotIn(m.x, reduced_costs)
- self.assertIn(m.y, reduced_costs)
- self.assertAlmostEqual(reduced_costs[m.y], 0)
- duals = res.solution_loader.get_duals()
- self.assertIn(m.c1, duals)
- self.assertIn(m.c2, duals)
- self.assertAlmostEqual(duals[m.c1], 1)
- self.assertAlmostEqual(duals[m.c2], 0)
- duals = res.solution_loader.get_duals([m.c1])
- self.assertNotIn(m.c2, duals)
- self.assertIn(m.c1, duals)
- self.assertAlmostEqual(duals[m.c1], 1)
+ if opt_class != MAiNGO:
+ reduced_costs = res.solution_loader.get_reduced_costs()
+ self.assertIn(m.x, reduced_costs)
+ self.assertIn(m.y, reduced_costs)
+ self.assertAlmostEqual(reduced_costs[m.x], 1)
+ self.assertAlmostEqual(reduced_costs[m.y], 0)
+ reduced_costs = res.solution_loader.get_reduced_costs([m.y])
+ self.assertNotIn(m.x, reduced_costs)
+ self.assertIn(m.y, reduced_costs)
+ self.assertAlmostEqual(reduced_costs[m.y], 0)
+ duals = res.solution_loader.get_duals()
+ self.assertIn(m.c1, duals)
+ self.assertIn(m.c2, duals)
+ self.assertAlmostEqual(duals[m.c1], 1)
+ self.assertAlmostEqual(duals[m.c2], 0)
+ duals = res.solution_loader.get_duals([m.c1])
+ self.assertNotIn(m.c2, duals)
+ self.assertIn(m.c1, duals)
+ self.assertAlmostEqual(duals[m.c1], 1)
@parameterized.expand(input=_load_tests(all_solvers, only_child_vars_options))
def test_time_limit(
self, name: str, opt_class: Type[PersistentSolver], only_child_vars
):
opt: PersistentSolver = opt_class(only_child_vars=only_child_vars)
- if not opt.available():
+ if not opt.available() or opt_class == MAiNGO:
raise unittest.SkipTest
from sys import platform
@@ -1057,13 +1107,14 @@ def test_objective_changes(
m.obj.sense = pe.maximize
opt.config.load_solution = False
res = opt.solve(m)
- self.assertIn(
- res.termination_condition,
- {
- TerminationCondition.unbounded,
- TerminationCondition.infeasibleOrUnbounded,
- },
- )
+ if opt_class != MAiNGO:
+ self.assertIn(
+ res.termination_condition,
+ {
+ TerminationCondition.unbounded,
+ TerminationCondition.infeasibleOrUnbounded,
+ },
+ )
m.obj.sense = pe.minimize
opt.config.load_solution = True
m.obj = pe.Objective(expr=m.x * m.y)
@@ -1160,19 +1211,19 @@ def test_fixed_binaries(
m.c = pe.Constraint(expr=m.y >= m.x)
m.x.fix(0)
res = opt.solve(m)
- self.assertAlmostEqual(res.best_feasible_objective, 0)
+ self.assertAlmostEqual(res.best_feasible_objective, 0, 5)
m.x.fix(1)
res = opt.solve(m)
- self.assertAlmostEqual(res.best_feasible_objective, 1)
+ self.assertAlmostEqual(res.best_feasible_objective, 1, 5)
opt: PersistentSolver = opt_class(only_child_vars=only_child_vars)
opt.update_config.treat_fixed_vars_as_params = False
m.x.fix(0)
res = opt.solve(m)
- self.assertAlmostEqual(res.best_feasible_objective, 0)
+ self.assertAlmostEqual(res.best_feasible_objective, 0, 5)
m.x.fix(1)
res = opt.solve(m)
- self.assertAlmostEqual(res.best_feasible_objective, 1)
+ self.assertAlmostEqual(res.best_feasible_objective, 1, 5)
@parameterized.expand(input=_load_tests(mip_solvers, only_child_vars_options))
def test_with_gdp(
@@ -1196,16 +1247,16 @@ def test_with_gdp(
pe.TransformationFactory("gdp.bigm").apply_to(m)
res = opt.solve(m)
- self.assertAlmostEqual(res.best_feasible_objective, 1)
- self.assertAlmostEqual(m.x.value, 0)
- self.assertAlmostEqual(m.y.value, 1)
+ self.assertAlmostEqual(res.best_feasible_objective, 1, 6)
+ self.assertAlmostEqual(m.x.value, 0, 6)
+ self.assertAlmostEqual(m.y.value, 1, 6)
opt: PersistentSolver = opt_class(only_child_vars=only_child_vars)
opt.use_extensions = True
res = opt.solve(m)
- self.assertAlmostEqual(res.best_feasible_objective, 1)
- self.assertAlmostEqual(m.x.value, 0)
- self.assertAlmostEqual(m.y.value, 1)
+ self.assertAlmostEqual(res.best_feasible_objective, 1, 6)
+ self.assertAlmostEqual(m.x.value, 0, 6)
+ self.assertAlmostEqual(m.y.value, 1, 6)
@parameterized.expand(input=all_solvers)
def test_variables_elsewhere(self, name: str, opt_class: Type[PersistentSolver]):
@@ -1338,7 +1389,8 @@ def test_param_updates(self, name: str, opt_class: Type[PersistentSolver]):
m.obj = pe.Objective(expr=m.y)
m.c1 = pe.Constraint(expr=(0, m.y - m.a1 * m.x - m.b1, None))
m.c2 = pe.Constraint(expr=(None, -m.y + m.a2 * m.x + m.b2, 0))
- m.dual = pe.Suffix(direction=pe.Suffix.IMPORT)
+ if opt_class != MAiNGO:
+ m.dual = pe.Suffix(direction=pe.Suffix.IMPORT)
params_to_test = [(1, -1, 2, 1), (1, -2, 2, 1), (1, -1, 3, 1)]
for a1, a2, b1, b2 in params_to_test:
@@ -1350,8 +1402,9 @@ def test_param_updates(self, name: str, opt_class: Type[PersistentSolver]):
pe.assert_optimal_termination(res)
self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
- self.assertAlmostEqual(m.dual[m.c1], (1 + a1 / (a2 - a1)))
- self.assertAlmostEqual(m.dual[m.c2], a1 / (a2 - a1))
+ if opt_class != MAiNGO:
+ self.assertAlmostEqual(m.dual[m.c1], (1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(m.dual[m.c2], a1 / (a2 - a1))
@parameterized.expand(input=all_solvers)
def test_load_solutions(self, name: str, opt_class: Type[PersistentSolver]):
@@ -1362,11 +1415,14 @@ def test_load_solutions(self, name: str, opt_class: Type[PersistentSolver]):
m.x = pe.Var()
m.obj = pe.Objective(expr=m.x)
m.c = pe.Constraint(expr=(-1, m.x, 1))
- m.dual = pe.Suffix(direction=pe.Suffix.IMPORT)
+ if opt_class != MAiNGO:
+ m.dual = pe.Suffix(direction=pe.Suffix.IMPORT)
res = opt.solve(m, load_solutions=False)
pe.assert_optimal_termination(res)
self.assertIsNone(m.x.value)
- self.assertNotIn(m.c, m.dual)
+ if opt_class != MAiNGO:
+ self.assertNotIn(m.c, m.dual)
m.solutions.load_from(res)
self.assertAlmostEqual(m.x.value, -1)
- self.assertAlmostEqual(m.dual[m.c], 1)
+ if opt_class != MAiNGO:
+ self.assertAlmostEqual(m.dual[m.c], 1)
diff --git a/pyomo/contrib/appsi/solvers/wntr.py b/pyomo/contrib/appsi/solvers/wntr.py
index e1835b810b0..0a66cc640e5 100644
--- a/pyomo/contrib/appsi/solvers/wntr.py
+++ b/pyomo/contrib/appsi/solvers/wntr.py
@@ -39,10 +39,10 @@
from pyomo.common.collections import ComponentMap
from pyomo.core.expr.numvalue import native_numeric_types
from typing import Dict, Optional, List
-from pyomo.core.base.block import _BlockData
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.param import _ParamData
-from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.base.block import BlockData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.constraint import ConstraintData
from pyomo.common.timing import HierarchicalTimer
from pyomo.core.base import SymbolMap, NumericLabeler, TextLabeler
from pyomo.common.dependencies import attempt_import
@@ -169,14 +169,16 @@ def _solve(self, timer: HierarchicalTimer):
timer.stop('load solution')
else:
raise RuntimeError(
- 'A feasible solution was not found, so no solution can be loaded.'
- 'Please set opt.config.load_solution=False and check '
- 'results.termination_condition and '
+ 'A feasible solution was not found, so no solution can be loaded. '
+ 'If using the appsi.solvers.Wntr interface, you can '
+ 'set opt.config.load_solution=False. If using the environ.SolverFactory '
+ 'interface, you can set opt.solve(model, load_solutions = False). '
+ 'Then you can check results.termination_condition and '
'results.best_feasible_objective before loading a solution.'
)
return results
- def solve(self, model: _BlockData, timer: HierarchicalTimer = None) -> Results:
+ def solve(self, model: BlockData, timer: HierarchicalTimer = None) -> Results:
StaleFlagManager.mark_all_as_stale()
if self._last_results_object is not None:
self._last_results_object.solution_loader.invalidate()
@@ -237,7 +239,7 @@ def set_instance(self, model):
self.add_block(model)
- def _add_variables(self, variables: List[_GeneralVarData]):
+ def _add_variables(self, variables: List[VarData]):
aml = wntr.sim.aml.aml
for var in variables:
varname = self._symbol_map.getSymbol(var, self._labeler)
@@ -268,7 +270,7 @@ def _add_variables(self, variables: List[_GeneralVarData]):
)
self._needs_updated = True
- def _add_params(self, params: List[_ParamData]):
+ def _add_params(self, params: List[ParamData]):
aml = wntr.sim.aml.aml
for p in params:
pname = self._symbol_map.getSymbol(p, self._labeler)
@@ -276,7 +278,7 @@ def _add_params(self, params: List[_ParamData]):
setattr(self._solver_model, pname, wntr_p)
self._pyomo_param_to_solver_param_map[id(p)] = wntr_p
- def _add_constraints(self, cons: List[_GeneralConstraintData]):
+ def _add_constraints(self, cons: List[ConstraintData]):
aml = wntr.sim.aml.aml
for con in cons:
if not con.equality:
@@ -292,7 +294,7 @@ def _add_constraints(self, cons: List[_GeneralConstraintData]):
self._pyomo_con_to_solver_con_map[con] = wntr_con
self._needs_updated = True
- def _remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def _remove_constraints(self, cons: List[ConstraintData]):
for con in cons:
solver_con = self._pyomo_con_to_solver_con_map[con]
delattr(self._solver_model, solver_con.name)
@@ -300,7 +302,7 @@ def _remove_constraints(self, cons: List[_GeneralConstraintData]):
del self._pyomo_con_to_solver_con_map[con]
self._needs_updated = True
- def _remove_variables(self, variables: List[_GeneralVarData]):
+ def _remove_variables(self, variables: List[VarData]):
for var in variables:
v_id = id(var)
solver_var = self._pyomo_var_to_solver_var_map[v_id]
@@ -312,7 +314,7 @@ def _remove_variables(self, variables: List[_GeneralVarData]):
del self._solver_model._wntr_fixed_var_cons[v_id]
self._needs_updated = True
- def _remove_params(self, params: List[_ParamData]):
+ def _remove_params(self, params: List[ParamData]):
for p in params:
p_id = id(p)
solver_param = self._pyomo_param_to_solver_param_map[p_id]
@@ -320,7 +322,7 @@ def _remove_params(self, params: List[_ParamData]):
self._symbol_map.removeSymbol(p)
del self._pyomo_param_to_solver_param_map[p_id]
- def _update_variables(self, variables: List[_GeneralVarData]):
+ def _update_variables(self, variables: List[VarData]):
aml = wntr.sim.aml.aml
for var in variables:
v_id = id(var)
diff --git a/pyomo/contrib/appsi/tests/test_fbbt.py b/pyomo/contrib/appsi/tests/test_fbbt.py
index a3f520e7bd6..97af611c572 100644
--- a/pyomo/contrib/appsi/tests/test_fbbt.py
+++ b/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)
diff --git a/pyomo/contrib/appsi/writers/lp_writer.py b/pyomo/contrib/appsi/writers/lp_writer.py
index 9984cb7465d..788dfde7892 100644
--- a/pyomo/contrib/appsi/writers/lp_writer.py
+++ b/pyomo/contrib/appsi/writers/lp_writer.py
@@ -10,12 +10,12 @@
# ___________________________________________________________________________
from typing import List
-from pyomo.core.base.param import _ParamData
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.objective import _GeneralObjectiveData
-from pyomo.core.base.sos import _SOSConstraintData
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.objective import ObjectiveData
+from pyomo.core.base.sos import SOSConstraintData
+from pyomo.core.base.block import BlockData
from pyomo.repn.standard_repn import generate_standard_repn
from pyomo.core.expr.numvalue import value
from pyomo.contrib.appsi.base import PersistentBase
@@ -77,7 +77,7 @@ def set_instance(self, model):
if self._objective is None:
self.set_objective(None)
- def _add_variables(self, variables: List[_GeneralVarData]):
+ def _add_variables(self, variables: List[VarData]):
cmodel.process_pyomo_vars(
self._expr_types,
variables,
@@ -91,7 +91,7 @@ def _add_variables(self, variables: List[_GeneralVarData]):
False,
)
- def _add_params(self, params: List[_ParamData]):
+ def _add_params(self, params: List[ParamData]):
cparams = cmodel.create_params(len(params))
for ndx, p in enumerate(params):
cp = cparams[ndx]
@@ -99,36 +99,36 @@ def _add_params(self, params: List[_ParamData]):
cp.value = p.value
self._pyomo_param_to_solver_param_map[id(p)] = cp
- def _add_constraints(self, cons: List[_GeneralConstraintData]):
+ def _add_constraints(self, cons: List[ConstraintData]):
cmodel.process_lp_constraints(cons, self)
- def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _add_sos_constraints(self, cons: List[SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError('LP writer does not yet support SOS constraints')
- def _remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def _remove_constraints(self, cons: List[ConstraintData]):
for c in cons:
cc = self._pyomo_con_to_solver_con_map.pop(c)
self._writer.remove_constraint(cc)
self._symbol_map.removeSymbol(c)
del self._solver_con_to_pyomo_con_map[cc]
- def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _remove_sos_constraints(self, cons: List[SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError('LP writer does not yet support SOS constraints')
- def _remove_variables(self, variables: List[_GeneralVarData]):
+ def _remove_variables(self, variables: List[VarData]):
for v in variables:
cvar = self._pyomo_var_to_solver_var_map.pop(id(v))
del self._solver_var_to_pyomo_var_map[cvar]
self._symbol_map.removeSymbol(v)
- def _remove_params(self, params: List[_ParamData]):
+ def _remove_params(self, params: List[ParamData]):
for p in params:
del self._pyomo_param_to_solver_param_map[id(p)]
self._symbol_map.removeSymbol(p)
- def _update_variables(self, variables: List[_GeneralVarData]):
+ def _update_variables(self, variables: List[VarData]):
cmodel.process_pyomo_vars(
self._expr_types,
variables,
@@ -147,7 +147,7 @@ def update_params(self):
cp = self._pyomo_param_to_solver_param_map[p_id]
cp.value = p.value
- def _set_objective(self, obj: _GeneralObjectiveData):
+ def _set_objective(self, obj: ObjectiveData):
cobj = cmodel.process_lp_objective(
self._expr_types,
obj,
@@ -167,7 +167,7 @@ def _set_objective(self, obj: _GeneralObjectiveData):
cobj.name = cname
self._writer.objective = cobj
- def write(self, model: _BlockData, filename: str, timer: HierarchicalTimer = None):
+ def write(self, model: BlockData, filename: str, timer: HierarchicalTimer = None):
if timer is None:
timer = HierarchicalTimer()
if model is not self._model:
diff --git a/pyomo/contrib/appsi/writers/nl_writer.py b/pyomo/contrib/appsi/writers/nl_writer.py
index bd24a86216a..27cdca004cb 100644
--- a/pyomo/contrib/appsi/writers/nl_writer.py
+++ b/pyomo/contrib/appsi/writers/nl_writer.py
@@ -10,12 +10,12 @@
# ___________________________________________________________________________
from typing import List
-from pyomo.core.base.param import _ParamData
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.objective import _GeneralObjectiveData
-from pyomo.core.base.sos import _SOSConstraintData
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.objective import ObjectiveData
+from pyomo.core.base.sos import SOSConstraintData
+from pyomo.core.base.block import BlockData
from pyomo.repn.standard_repn import generate_standard_repn
from pyomo.core.expr.numvalue import value
from pyomo.contrib.appsi.base import PersistentBase
@@ -78,7 +78,7 @@ def set_instance(self, model):
self.set_objective(None)
self._set_pyomo_amplfunc_env()
- def _add_variables(self, variables: List[_GeneralVarData]):
+ def _add_variables(self, variables: List[VarData]):
if self.config.symbolic_solver_labels:
set_name = True
symbol_map = self._symbol_map
@@ -100,7 +100,7 @@ def _add_variables(self, variables: List[_GeneralVarData]):
False,
)
- def _add_params(self, params: List[_ParamData]):
+ def _add_params(self, params: List[ParamData]):
cparams = cmodel.create_params(len(params))
for ndx, p in enumerate(params):
cp = cparams[ndx]
@@ -111,7 +111,7 @@ def _add_params(self, params: List[_ParamData]):
cp = cparams[ndx]
cp.name = self._symbol_map.getSymbol(p, self._param_labeler)
- def _add_constraints(self, cons: List[_GeneralConstraintData]):
+ def _add_constraints(self, cons: List[ConstraintData]):
cmodel.process_nl_constraints(
self._writer,
self._expr_types,
@@ -126,11 +126,11 @@ def _add_constraints(self, cons: List[_GeneralConstraintData]):
for c, cc in self._pyomo_con_to_solver_con_map.items():
cc.name = self._symbol_map.getSymbol(c, self._con_labeler)
- def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _add_sos_constraints(self, cons: List[SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError('NL writer does not support SOS constraints')
- def _remove_constraints(self, cons: List[_GeneralConstraintData]):
+ def _remove_constraints(self, cons: List[ConstraintData]):
if self.config.symbolic_solver_labels:
for c in cons:
self._symbol_map.removeSymbol(c)
@@ -140,11 +140,11 @@ def _remove_constraints(self, cons: List[_GeneralConstraintData]):
self._writer.remove_constraint(cc)
del self._solver_con_to_pyomo_con_map[cc]
- def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
+ def _remove_sos_constraints(self, cons: List[SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError('NL writer does not support SOS constraints')
- def _remove_variables(self, variables: List[_GeneralVarData]):
+ def _remove_variables(self, variables: List[VarData]):
if self.config.symbolic_solver_labels:
for v in variables:
self._symbol_map.removeSymbol(v)
@@ -153,7 +153,7 @@ def _remove_variables(self, variables: List[_GeneralVarData]):
cvar = self._pyomo_var_to_solver_var_map.pop(id(v))
del self._solver_var_to_pyomo_var_map[cvar]
- def _remove_params(self, params: List[_ParamData]):
+ def _remove_params(self, params: List[ParamData]):
if self.config.symbolic_solver_labels:
for p in params:
self._symbol_map.removeSymbol(p)
@@ -161,7 +161,7 @@ def _remove_params(self, params: List[_ParamData]):
for p in params:
del self._pyomo_param_to_solver_param_map[id(p)]
- def _update_variables(self, variables: List[_GeneralVarData]):
+ def _update_variables(self, variables: List[VarData]):
cmodel.process_pyomo_vars(
self._expr_types,
variables,
@@ -180,7 +180,7 @@ def update_params(self):
cp = self._pyomo_param_to_solver_param_map[p_id]
cp.value = p.value
- def _set_objective(self, obj: _GeneralObjectiveData):
+ def _set_objective(self, obj: ObjectiveData):
if obj is None:
const = cmodel.Constant(0)
lin_vars = list()
@@ -232,7 +232,7 @@ def _set_objective(self, obj: _GeneralObjectiveData):
cobj.sense = sense
self._writer.objective = cobj
- def write(self, model: _BlockData, filename: str, timer: HierarchicalTimer = None):
+ def write(self, model: BlockData, filename: str, timer: HierarchicalTimer = None):
if timer is None:
timer = HierarchicalTimer()
if model is not self._model:
diff --git a/pyomo/contrib/benders/benders_cuts.py b/pyomo/contrib/benders/benders_cuts.py
index cf96ba26164..0653be55986 100644
--- a/pyomo/contrib/benders/benders_cuts.py
+++ b/pyomo/contrib/benders/benders_cuts.py
@@ -9,7 +9,7 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-from pyomo.core.base.block import _BlockData, declare_custom_block
+from pyomo.core.base.block import BlockData, declare_custom_block
import pyomo.environ as pyo
from pyomo.solvers.plugins.solvers.persistent_solver import PersistentSolver
from pyomo.core.expr.visitor import identify_variables
@@ -166,13 +166,13 @@ def _setup_subproblem(b, root_vars, relax_subproblem_cons):
@declare_custom_block(name='BendersCutGenerator')
-class BendersCutGeneratorData(_BlockData):
+class BendersCutGeneratorData(BlockData):
def __init__(self, component):
if not mpi4py_available:
raise ImportError('BendersCutGenerator requires mpi4py.')
if not numpy_available:
raise ImportError('BendersCutGenerator requires numpy.')
- _BlockData.__init__(self, component)
+ BlockData.__init__(self, component)
self.num_subproblems_by_rank = 0 # np.zeros(self.comm.Get_size())
self.subproblems = list()
diff --git a/pyomo/contrib/community_detection/detection.py b/pyomo/contrib/community_detection/detection.py
index 5bf8187a243..db3bb8f5a20 100644
--- a/pyomo/contrib/community_detection/detection.py
+++ b/pyomo/contrib/community_detection/detection.py
@@ -31,7 +31,7 @@
Objective,
ConstraintList,
)
-from pyomo.core.base.objective import _GeneralObjectiveData
+from pyomo.core.base.objective import ObjectiveData
from pyomo.core.expr.visitor import replace_expressions, identify_variables
from pyomo.contrib.community_detection.community_graph import generate_model_graph
from pyomo.common.dependencies import networkx as nx
@@ -580,7 +580,7 @@ def visualize_model_graph(
pos = nx.spring_layout(model_graph)
# Define color_map
- color_map = plt.cm.get_cmap('viridis', len(numbered_community_map))
+ color_map = plt.get_cmap('viridis', len(numbered_community_map))
# Create the figure and draw the graph
fig = plt.figure()
@@ -750,7 +750,7 @@ def generate_structured_model(self):
# Check to see whether 'stored_constraint' is actually an objective (since constraints and objectives
# grouped together)
if self.with_objective and isinstance(
- stored_constraint, (_GeneralObjectiveData, Objective)
+ stored_constraint, (ObjectiveData, Objective)
):
# If the constraint is actually an objective, we add it to the block as an objective
new_objective = Objective(
diff --git a/pyomo/contrib/cp/__init__.py b/pyomo/contrib/cp/__init__.py
index ed45344fb95..d206fe95251 100644
--- a/pyomo/contrib/cp/__init__.py
+++ b/pyomo/contrib/cp/__init__.py
@@ -17,6 +17,19 @@
IntervalVarPresence,
)
from pyomo.contrib.cp.repn.docplex_writer import DocplexWriter, CPOptimizerSolver
+from pyomo.contrib.cp.sequence_var import SequenceVar
+from pyomo.contrib.cp.scheduling_expr.sequence_expressions import (
+ no_overlap,
+ first_in_sequence,
+ last_in_sequence,
+ before_in_sequence,
+ predecessor_to,
+)
+from pyomo.contrib.cp.scheduling_expr.scheduling_logic import (
+ alternative,
+ spans,
+ synchronize,
+)
from pyomo.contrib.cp.scheduling_expr.step_function_expressions import (
AlwaysIn,
Step,
diff --git a/pyomo/contrib/cp/interval_var.py b/pyomo/contrib/cp/interval_var.py
index 953b859ea20..dec5af74d9f 100644
--- a/pyomo/contrib/cp/interval_var.py
+++ b/pyomo/contrib/cp/interval_var.py
@@ -11,6 +11,7 @@
from pyomo.common.collections import ComponentSet
from pyomo.common.pyomo_typing import overload
+from pyomo.contrib.cp.scheduling_expr.scheduling_logic import SpanExpression
from pyomo.contrib.cp.scheduling_expr.precedence_expressions import (
BeforeExpression,
AtExpression,
@@ -18,12 +19,13 @@
from pyomo.core import Integers, value
from pyomo.core.base import Any, ScalarVar, ScalarBooleanVar
-from pyomo.core.base.block import _BlockData, Block
+from pyomo.core.base.block import BlockData, Block
from pyomo.core.base.component import ModelComponentFactory
from pyomo.core.base.global_set import UnindexedComponent_index
from pyomo.core.base.indexed_component import IndexedComponent, UnindexedComponent_set
from pyomo.core.base.initializer import BoundInitializer, Initializer
from pyomo.core.expr import GetItemExpression
+from pyomo.core.expr.logical_expr import _flattened
class IntervalVarTimePoint(ScalarVar):
@@ -49,7 +51,7 @@ class IntervalVarStartTime(IntervalVarTimePoint):
"""This class defines a single variable denoting a start time point
of an IntervalVar"""
- def __init__(self):
+ def __init__(self, *args, **kwd):
super().__init__(domain=Integers, ctype=IntervalVarStartTime)
@@ -57,7 +59,7 @@ class IntervalVarEndTime(IntervalVarTimePoint):
"""This class defines a single variable denoting an end time point
of an IntervalVar"""
- def __init__(self):
+ def __init__(self, *args, **kwd):
super().__init__(domain=Integers, ctype=IntervalVarEndTime)
@@ -67,7 +69,7 @@ class IntervalVarLength(ScalarVar):
__slots__ = ()
- def __init__(self):
+ def __init__(self, *args, **kwd):
super().__init__(domain=Integers, ctype=IntervalVarLength)
def get_associated_interval_var(self):
@@ -80,21 +82,23 @@ class IntervalVarPresence(ScalarBooleanVar):
__slots__ = ()
- def __init__(self):
+ def __init__(self, *args, **kwd):
+ # TODO: adding args and kwd above made Reference work, but we
+ # probably shouldn't just swallow them, right?
super().__init__(ctype=IntervalVarPresence)
def get_associated_interval_var(self):
return self.parent_block()
-class IntervalVarData(_BlockData):
+class IntervalVarData(BlockData):
"""This class defines the abstract interface for a single interval variable."""
# We will put our four variables on this, and everything else is off limits.
_Block_reserved_words = Any
def __init__(self, component=None):
- _BlockData.__init__(self, component)
+ BlockData.__init__(self, component)
with self._declare_reserved_components():
self.is_present = IntervalVarPresence()
@@ -122,6 +126,9 @@ def optional(self, val):
else:
self.is_present.fix(True)
+ def spans(self, *args):
+ return SpanExpression([self] + list(_flattened(args)))
+
@ModelComponentFactory.register("Interval variables for scheduling.")
class IntervalVar(Block):
diff --git a/pyomo/contrib/cp/repn/docplex_writer.py b/pyomo/contrib/cp/repn/docplex_writer.py
index 8356a1e752f..6a0eb7749a8 100644
--- a/pyomo/contrib/cp/repn/docplex_writer.py
+++ b/pyomo/contrib/cp/repn/docplex_writer.py
@@ -30,10 +30,27 @@
IntervalVarData,
IndexedIntervalVar,
)
+from pyomo.contrib.cp.sequence_var import (
+ SequenceVar,
+ ScalarSequenceVar,
+ SequenceVarData,
+)
+from pyomo.contrib.cp.scheduling_expr.scheduling_logic import (
+ AlternativeExpression,
+ SpanExpression,
+ SynchronizeExpression,
+)
from pyomo.contrib.cp.scheduling_expr.precedence_expressions import (
BeforeExpression,
AtExpression,
)
+from pyomo.contrib.cp.scheduling_expr.sequence_expressions import (
+ NoOverlapExpression,
+ FirstInSequenceExpression,
+ LastInSequenceExpression,
+ BeforeInSequenceExpression,
+ PredecessorToExpression,
+)
from pyomo.contrib.cp.scheduling_expr.step_function_expressions import (
AlwaysIn,
StepAt,
@@ -60,16 +77,17 @@
)
from pyomo.core.base.boolean_var import (
ScalarBooleanVar,
- _GeneralBooleanVarData,
+ BooleanVarData,
IndexedBooleanVar,
)
-from pyomo.core.base.expression import ScalarExpression, _GeneralExpressionData
-from pyomo.core.base.param import IndexedParam, ScalarParam, _ParamData
-from pyomo.core.base.var import ScalarVar, _GeneralVarData, IndexedVar
+from pyomo.core.base.expression import ScalarExpression, ExpressionData
+from pyomo.core.base.param import IndexedParam, ScalarParam, ParamData
+from pyomo.core.base.var import ScalarVar, VarData, IndexedVar
import pyomo.core.expr as EXPR
from pyomo.core.expr.visitor import StreamBasedExpressionVisitor, identify_variables
from pyomo.core.base import Set, RangeSet
from pyomo.core.base.set import SetProduct
+from pyomo.repn.util import ExitNodeDispatcher
from pyomo.opt import WriterFactory, SolverFactory, TerminationCondition, SolverResults
### FIXME: Remove the following as soon as non-active components no
@@ -449,6 +467,7 @@ def _create_docplex_interval_var(visitor, interval_var):
nm = interval_var.name if visitor.symbolic_solver_labels else None
cpx_interval_var = cp.interval_var(name=nm)
visitor.var_map[id(interval_var)] = cpx_interval_var
+ visitor.pyomo_to_docplex[interval_var] = cpx_interval_var
# Figure out if it exists
if interval_var.is_present.fixed and not interval_var.is_present.value:
@@ -491,6 +510,19 @@ def _create_docplex_interval_var(visitor, interval_var):
return cpx_interval_var
+def _create_docplex_sequence_var(visitor, sequence_var):
+ nm = sequence_var.name if visitor.symbolic_solver_labels else None
+
+ cpx_seq_var = cp.sequence_var(
+ name=nm,
+ vars=[
+ _get_docplex_interval_var(visitor, v) for v in sequence_var.interval_vars
+ ],
+ )
+ visitor.var_map[id(sequence_var)] = cpx_seq_var
+ return cpx_seq_var
+
+
def _get_docplex_interval_var(visitor, interval_var):
# We might already have the interval_var and just need to retrieve it
if id(interval_var) in visitor.var_map:
@@ -501,6 +533,25 @@ def _get_docplex_interval_var(visitor, interval_var):
return cpx_interval_var
+def _get_docplex_sequence_var(visitor, sequence_var):
+ if id(sequence_var) in visitor.var_map:
+ cpx_seq_var = visitor.var_map[id(sequence_var)]
+ else:
+ cpx_seq_var = _create_docplex_sequence_var(visitor, sequence_var)
+ visitor.cpx.add(cpx_seq_var)
+ return cpx_seq_var
+
+
+def _before_sequence_var(visitor, child):
+ _id = id(child)
+ if _id not in visitor.var_map:
+ cpx_seq_var = _get_docplex_sequence_var(visitor, child)
+ visitor.var_map[_id] = cpx_seq_var
+ visitor.pyomo_to_docplex[child] = cpx_seq_var
+
+ return False, (_GENERAL, visitor.var_map[_id])
+
+
def _before_interval_var(visitor, child):
_id = id(child)
if _id not in visitor.var_map:
@@ -564,22 +615,22 @@ def _before_interval_var_presence(visitor, child):
def _handle_step_at_node(visitor, node):
- return cp.step_at(node._time, node._height)
+ return False, (_GENERAL, cp.step_at(node._time, node._height))
def _handle_step_at_start_node(visitor, node):
cpx_var = _get_docplex_interval_var(visitor, node._time)
- return cp.step_at_start(cpx_var, node._height)
+ return False, (_GENERAL, cp.step_at_start(cpx_var, node._height))
def _handle_step_at_end_node(visitor, node):
cpx_var = _get_docplex_interval_var(visitor, node._time)
- return cp.step_at_end(cpx_var, node._height)
+ return False, (_GENERAL, cp.step_at_end(cpx_var, node._height))
def _handle_pulse_node(visitor, node):
cpx_var = _get_docplex_interval_var(visitor, node._interval_var)
- return cp.pulse(cpx_var, node._height)
+ return False, (_GENERAL, cp.pulse(cpx_var, node._height))
def _handle_negated_step_function_node(visitor, node):
@@ -590,9 +641,9 @@ def _handle_cumulative_function(visitor, node):
expr = 0
for arg in node.args:
if arg.__class__ is NegatedStepFunction:
- expr -= _handle_negated_step_function_node(visitor, arg)
+ expr -= _handle_negated_step_function_node(visitor, arg)[1][1]
else:
- expr += _step_function_handles[arg.__class__](visitor, arg)
+ expr += _step_function_handles[arg.__class__](visitor, arg)[1][1]
return False, (_GENERAL, expr)
@@ -658,7 +709,7 @@ def _handle_monomial_expr(visitor, node, arg1, arg2):
# simplifications (necessary in part for the unit tests)
if arg2[1].__class__ in EXPR.native_types:
return _GENERAL, arg1[1] * arg2[1]
- elif arg1[1] == 1:
+ elif arg1[1].__class__ in EXPR.native_types and arg1[1] == 1:
return arg2
return (_GENERAL, cp.times(_get_int_valued_expr(arg1), _get_int_valued_expr(arg2)))
@@ -910,48 +961,91 @@ def _handle_always_in_node(visitor, node, cumul_func, lb, ub, start, end):
)
+def _handle_no_overlap_expression_node(visitor, node, seq_var):
+ return _GENERAL, cp.no_overlap(seq_var[1])
+
+
+def _handle_first_in_sequence_expression_node(visitor, node, interval_var, seq_var):
+ return _GENERAL, cp.first(seq_var[1], interval_var[1])
+
+
+def _handle_last_in_sequence_expression_node(visitor, node, interval_var, seq_var):
+ return _GENERAL, cp.last(seq_var[1], interval_var[1])
+
+
+def _handle_before_in_sequence_expression_node(
+ visitor, node, before_var, after_var, seq_var
+):
+ return _GENERAL, cp.before(seq_var[1], before_var[1], after_var[1])
+
+
+def _handle_predecessor_to_expression_node(
+ visitor, node, before_var, after_var, seq_var
+):
+ return _GENERAL, cp.previous(seq_var[1], before_var[1], after_var[1])
+
+
+def _handle_span_expression_node(visitor, node, *args):
+ return _GENERAL, cp.span(args[0][1], [arg[1] for arg in args[1:]])
+
+
+def _handle_alternative_expression_node(visitor, node, *args):
+ return _GENERAL, cp.alternative(args[0][1], [arg[1] for arg in args[1:]])
+
+
+def _handle_synchronize_expression_node(visitor, node, *args):
+ return _GENERAL, cp.synchronize(args[0][1], [arg[1] for arg in args[1:]])
+
+
+_operator_handles = {
+ EXPR.GetItemExpression: _handle_getitem,
+ EXPR.GetAttrExpression: _handle_getattr,
+ EXPR.CallExpression: _handle_call,
+ EXPR.NegationExpression: _handle_negation_node,
+ EXPR.ProductExpression: _handle_product_node,
+ EXPR.DivisionExpression: _handle_division_node,
+ EXPR.PowExpression: _handle_pow_node,
+ EXPR.AbsExpression: _handle_abs_node,
+ EXPR.MonomialTermExpression: _handle_monomial_expr,
+ EXPR.SumExpression: _handle_sum_node,
+ EXPR.MinExpression: _handle_min_node,
+ EXPR.MaxExpression: _handle_max_node,
+ EXPR.NotExpression: _handle_not_node,
+ EXPR.EquivalenceExpression: _handle_equivalence_node,
+ EXPR.ImplicationExpression: _handle_implication_node,
+ EXPR.AndExpression: _handle_and_node,
+ EXPR.OrExpression: _handle_or_node,
+ EXPR.XorExpression: _handle_xor_node,
+ EXPR.ExactlyExpression: _handle_exactly_node,
+ EXPR.AtMostExpression: _handle_at_most_node,
+ EXPR.AtLeastExpression: _handle_at_least_node,
+ EXPR.AllDifferentExpression: _handle_all_diff_node,
+ EXPR.CountIfExpression: _handle_count_if_node,
+ EXPR.EqualityExpression: _handle_equality_node,
+ EXPR.NotEqualExpression: _handle_not_equal_node,
+ EXPR.InequalityExpression: _handle_inequality_node,
+ EXPR.RangedExpression: _handle_ranged_inequality_node,
+ BeforeExpression: _handle_before_expression_node,
+ AtExpression: _handle_at_expression_node,
+ AlwaysIn: _handle_always_in_node,
+ ExpressionData: _handle_named_expression_node,
+ ScalarExpression: _handle_named_expression_node,
+ NoOverlapExpression: _handle_no_overlap_expression_node,
+ FirstInSequenceExpression: _handle_first_in_sequence_expression_node,
+ LastInSequenceExpression: _handle_last_in_sequence_expression_node,
+ BeforeInSequenceExpression: _handle_before_in_sequence_expression_node,
+ PredecessorToExpression: _handle_predecessor_to_expression_node,
+ SpanExpression: _handle_span_expression_node,
+ AlternativeExpression: _handle_alternative_expression_node,
+ SynchronizeExpression: _handle_synchronize_expression_node,
+}
+
+
class LogicalToDoCplex(StreamBasedExpressionVisitor):
- _operator_handles = {
- EXPR.GetItemExpression: _handle_getitem,
- EXPR.Structural_GetItemExpression: _handle_getitem,
- EXPR.Numeric_GetItemExpression: _handle_getitem,
- EXPR.Boolean_GetItemExpression: _handle_getitem,
- EXPR.GetAttrExpression: _handle_getattr,
- EXPR.Structural_GetAttrExpression: _handle_getattr,
- EXPR.Numeric_GetAttrExpression: _handle_getattr,
- EXPR.Boolean_GetAttrExpression: _handle_getattr,
- EXPR.CallExpression: _handle_call,
- EXPR.NegationExpression: _handle_negation_node,
- EXPR.ProductExpression: _handle_product_node,
- EXPR.DivisionExpression: _handle_division_node,
- EXPR.PowExpression: _handle_pow_node,
- EXPR.AbsExpression: _handle_abs_node,
- EXPR.MonomialTermExpression: _handle_monomial_expr,
- EXPR.SumExpression: _handle_sum_node,
- EXPR.LinearExpression: _handle_sum_node,
- EXPR.MinExpression: _handle_min_node,
- EXPR.MaxExpression: _handle_max_node,
- EXPR.NotExpression: _handle_not_node,
- EXPR.EquivalenceExpression: _handle_equivalence_node,
- EXPR.ImplicationExpression: _handle_implication_node,
- EXPR.AndExpression: _handle_and_node,
- EXPR.OrExpression: _handle_or_node,
- EXPR.XorExpression: _handle_xor_node,
- EXPR.ExactlyExpression: _handle_exactly_node,
- EXPR.AtMostExpression: _handle_at_most_node,
- EXPR.AtLeastExpression: _handle_at_least_node,
- EXPR.AllDifferentExpression: _handle_all_diff_node,
- EXPR.CountIfExpression: _handle_count_if_node,
- EXPR.EqualityExpression: _handle_equality_node,
- EXPR.NotEqualExpression: _handle_not_equal_node,
- EXPR.InequalityExpression: _handle_inequality_node,
- EXPR.RangedExpression: _handle_ranged_inequality_node,
- BeforeExpression: _handle_before_expression_node,
- AtExpression: _handle_at_expression_node,
- AlwaysIn: _handle_always_in_node,
- _GeneralExpressionData: _handle_named_expression_node,
- ScalarExpression: _handle_named_expression_node,
- }
+ exit_node_dispatcher = ExitNodeDispatcher(_operator_handles)
+ # NOTE: Because of indirection, we can encounter indexed Params and Vars in
+ # expressions
+
_var_handles = {
IntervalVarStartTime: _before_interval_var_start_time,
IntervalVarEndTime: _before_interval_var_end_time,
@@ -960,17 +1054,19 @@ class LogicalToDoCplex(StreamBasedExpressionVisitor):
ScalarIntervalVar: _before_interval_var,
IntervalVarData: _before_interval_var,
IndexedIntervalVar: _before_indexed_interval_var,
+ ScalarSequenceVar: _before_sequence_var,
+ SequenceVarData: _before_sequence_var,
ScalarVar: _before_var,
- _GeneralVarData: _before_var,
+ VarData: _before_var,
IndexedVar: _before_indexed_var,
ScalarBooleanVar: _before_boolean_var,
- _GeneralBooleanVarData: _before_boolean_var,
+ BooleanVarData: _before_boolean_var,
IndexedBooleanVar: _before_indexed_boolean_var,
- _GeneralExpressionData: _before_named_expression,
+ ExpressionData: _before_named_expression,
ScalarExpression: _before_named_expression,
- IndexedParam: _before_indexed_param, # Because of indirection
+ IndexedParam: _before_indexed_param,
ScalarParam: _before_param,
- _ParamData: _before_param,
+ ParamData: _before_param,
}
def __init__(self, cpx_model, symbolic_solver_labels=False):
@@ -1004,7 +1100,7 @@ def beforeChild(self, node, child, child_idx):
return True, None
def exitNode(self, node, data):
- return self._operator_handles[node.__class__](self, node, *data)
+ return self.exit_node_dispatcher[node.__class__](self, node, *data)
finalizeResult = None
@@ -1016,6 +1112,9 @@ def collect_valid_components(model, active=True, sort=None, valid=set(), targets
unrecognized = {}
components = {k: [] for k in targets}
for obj in model.component_data_objects(active=True, descend_into=True, sort=sort):
+ # HACK around #3045
+ if not hasattr(obj, 'ctype'):
+ continue
ctype = obj.ctype
if ctype in components:
components[ctype].append(obj)
@@ -1066,7 +1165,13 @@ def write(self, model, **options):
RangeSet,
Port,
},
- targets={Objective, Constraint, LogicalConstraint, IntervalVar},
+ targets={
+ Objective,
+ Constraint,
+ LogicalConstraint,
+ IntervalVar,
+ SequenceVar,
+ },
)
if unknown:
raise ValueError(
@@ -1295,6 +1400,10 @@ def solve(self, model, **kwds):
)
else:
sol = sol.get_value()
+ if py_var.ctype is SequenceVar:
+ # They don't actually have values--the IntervalVars will get
+ # set.
+ continue
if py_var.ctype is IntervalVar:
if len(sol) == 0:
# The interval_var is absent
diff --git a/pyomo/contrib/cp/scheduling_expr/precedence_expressions.py b/pyomo/contrib/cp/scheduling_expr/precedence_expressions.py
index 1dec02bba23..675d9efb0a0 100644
--- a/pyomo/contrib/cp/scheduling_expr/precedence_expressions.py
+++ b/pyomo/contrib/cp/scheduling_expr/precedence_expressions.py
@@ -21,13 +21,13 @@ def delay(self):
return self._args_[2]
def _to_string_impl(self, values, relation):
- delay = int(values[2])
- if delay == 0:
+ delay = values[2]
+ if delay == '0':
first = values[0]
- elif delay > 0:
- first = "%s + %s" % (values[0], delay)
+ elif delay[0] in '-+':
+ first = "%s %s %s" % (values[0], delay[0], delay[1:])
else:
- first = "%s - %s" % (values[0], abs(delay))
+ first = "%s + %s" % (values[0], delay)
return "%s %s %s" % (first, relation, values[1])
diff --git a/pyomo/contrib/cp/scheduling_expr/scheduling_logic.py b/pyomo/contrib/cp/scheduling_expr/scheduling_logic.py
new file mode 100644
index 00000000000..e5695b57c5c
--- /dev/null
+++ b/pyomo/contrib/cp/scheduling_expr/scheduling_logic.py
@@ -0,0 +1,72 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+
+from pyomo.core.expr.logical_expr import NaryBooleanExpression, _flattened
+
+
+class SpanExpression(NaryBooleanExpression):
+ """
+ Expression over IntervalVars representing that the first arg spans all the
+ following args in the schedule. The first arg is absent if and only if all
+ the others are absent.
+
+ args:
+ args (tuple): Child nodes, of type IntervalVar
+ """
+
+ def _to_string(self, values, verbose, smap):
+ return "%s.spans(%s)" % (values[0], ", ".join(values[1:]))
+
+
+class AlternativeExpression(NaryBooleanExpression):
+ """
+ Expression over IntervalVars representing that if the first arg is present,
+ then exactly one of the following args must be present. The first arg is
+ absent if and only if all the others are absent.
+ """
+
+ # [ESJ 4/4/24]: docplex takes an optional 'cardinality' argument with this
+ # too--it generalized to "exactly n" of the intervals have to exist,
+ # basically. It would be nice to include this eventually, but this is
+ # probably fine for now.
+
+ def _to_string(self, values, verbose, smap):
+ return "alternative(%s, [%s])" % (values[0], ", ".join(values[1:]))
+
+
+class SynchronizeExpression(NaryBooleanExpression):
+ """
+ Expression over IntervalVars synchronizing the first argument with all of the
+ following arguments. That is, if the first argument is present, the remaining
+ arguments start and end at the same time as it.
+ """
+
+ def _to_string(self, values, verbose, smap):
+ return "synchronize(%s, [%s])" % (values[0], ", ".join(values[1:]))
+
+
+def spans(*args):
+ """Creates a new SpanExpression"""
+
+ return SpanExpression(list(_flattened(args)))
+
+
+def alternative(*args):
+ """Creates a new AlternativeExpression"""
+
+ return AlternativeExpression(list(_flattened(args)))
+
+
+def synchronize(*args):
+ """Creates a new SynchronizeExpression"""
+
+ return SynchronizeExpression(list(_flattened(args)))
diff --git a/pyomo/contrib/cp/scheduling_expr/sequence_expressions.py b/pyomo/contrib/cp/scheduling_expr/sequence_expressions.py
new file mode 100644
index 00000000000..3ba799074de
--- /dev/null
+++ b/pyomo/contrib/cp/scheduling_expr/sequence_expressions.py
@@ -0,0 +1,173 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.core.expr.logical_expr import BooleanExpression
+
+
+class NoOverlapExpression(BooleanExpression):
+ """
+ Expression representing that none of the IntervalVars in a SequenceVar overlap
+ (if they are scheduled)
+
+ args:
+ args (tuple): Child node of type SequenceVar
+ """
+
+ def nargs(self):
+ return 1
+
+ def _to_string(self, values, verbose, smap):
+ return "no_overlap(%s)" % values[0]
+
+
+class FirstInSequenceExpression(BooleanExpression):
+ """
+ Expression representing that the specified IntervalVar is the first in the
+ sequence specified by SequenceVar (if it is scheduled)
+
+ args:
+ args (tuple): Child nodes, the first of type IntervalVar, the second of type
+ SequenceVar
+ """
+
+ def nargs(self):
+ return 2
+
+ def _to_string(self, values, verbose, smap):
+ return "first_in(%s, %s)" % (values[0], values[1])
+
+
+class LastInSequenceExpression(BooleanExpression):
+ """
+ Expression representing that the specified IntervalVar is the last in the
+ sequence specified by SequenceVar (if it is scheduled)
+
+ args:
+ args (tuple): Child nodes, the first of type IntervalVar, the second of type
+ SequenceVar
+ """
+
+ def nargs(self):
+ return 2
+
+ def _to_string(self, values, verbose, smap):
+ return "last_in(%s, %s)" % (values[0], values[1])
+
+
+class BeforeInSequenceExpression(BooleanExpression):
+ """
+ Expression representing that one IntervalVar occurs before another in the
+ sequence specified by the given SequenceVar (if both are scheduled)
+
+ args:
+ args (tuple): Child nodes, the IntervalVar that must be before, the
+ IntervalVar that must be after, and the SequenceVar
+ """
+
+ def nargs(self):
+ return 3
+
+ def _to_string(self, values, verbose, smap):
+ return "before_in(%s, %s, %s)" % (values[0], values[1], values[2])
+
+
+class PredecessorToExpression(BooleanExpression):
+ """
+ Expression representing that one IntervalVar is a direct predecessor to another
+ in the sequence specified by the given SequenceVar (if both are scheduled)
+
+ args:
+ args (tuple): Child nodes, the predecessor IntervalVar, the successor
+ IntervalVar, and the SequenceVar
+ """
+
+ def nargs(self):
+ return 3
+
+ def _to_string(self, values, verbose, smap):
+ return "predecessor_to(%s, %s, %s)" % (values[0], values[1], values[2])
+
+
+def no_overlap(sequence_var):
+ """
+ Creates a new NoOverlapExpression
+
+ Requires that none of the scheduled intervals in the SequenceVar overlap each other
+
+ args:
+ sequence_var: A SequenceVar
+ """
+ return NoOverlapExpression((sequence_var,))
+
+
+def first_in_sequence(interval_var, sequence_var):
+ """
+ Creates a new FirstInSequenceExpression
+
+ Requires that 'interval_var' be the first in the sequence specified by
+ 'sequence_var' if it is scheduled
+
+ args:
+ interval_var (IntervalVar): The activity that should be scheduled first
+ if it is scheduled at all
+ sequence_var (SequenceVar): The sequence of activities
+ """
+ return FirstInSequenceExpression((interval_var, sequence_var))
+
+
+def last_in_sequence(interval_var, sequence_var):
+ """
+ Creates a new LastInSequenceExpression
+
+ Requires that 'interval_var' be the last in the sequence specified by
+ 'sequence_var' if it is scheduled
+
+ args:
+ interval_var (IntervalVar): The activity that should be scheduled last
+ if it is scheduled at all
+ sequence_var (SequenceVar): The sequence of activities
+ """
+
+ return LastInSequenceExpression((interval_var, sequence_var))
+
+
+def before_in_sequence(before_var, after_var, sequence_var):
+ """
+ Creates a new BeforeInSequenceExpression
+
+ Requires that 'before_var' be scheduled to start before 'after_var' in the
+ sequence specified bv 'sequence_var', if both are scheduled
+
+ args:
+ before_var (IntervalVar): The activity that should be scheduled earlier in
+ the sequence
+ after_var (IntervalVar): The activity that should be scheduled later in the
+ sequence
+ sequence_var (SequenceVar): The sequence of activities
+ """
+ return BeforeInSequenceExpression((before_var, after_var, sequence_var))
+
+
+def predecessor_to(before_var, after_var, sequence_var):
+ """
+ Creates a new PredecessorToExpression
+
+ Requires that 'before_var' be a direct predecessor to 'after_var' in the
+ sequence specified by 'sequence_var', if both are scheduled
+
+ args:
+ before_var (IntervalVar): The activity that should be scheduled as the
+ predecessor
+ after_var (IntervalVar): The activity that should be scheduled as the
+ successor
+ sequence_var (SequenceVar): The sequence of activities
+ """
+ return PredecessorToExpression((before_var, after_var, sequence_var))
diff --git a/pyomo/contrib/cp/scheduling_expr/step_function_expressions.py b/pyomo/contrib/cp/scheduling_expr/step_function_expressions.py
index b75306f72c9..129dff66b48 100644
--- a/pyomo/contrib/cp/scheduling_expr/step_function_expressions.py
+++ b/pyomo/contrib/cp/scheduling_expr/step_function_expressions.py
@@ -15,7 +15,6 @@
IntervalVarStartTime,
IntervalVarEndTime,
)
-from pyomo.core.base.component import Component
from pyomo.core.expr.base import ExpressionBase
from pyomo.core.expr.logical_expr import BooleanExpression
diff --git a/pyomo/contrib/cp/sequence_var.py b/pyomo/contrib/cp/sequence_var.py
new file mode 100644
index 00000000000..cb42f445dc3
--- /dev/null
+++ b/pyomo/contrib/cp/sequence_var.py
@@ -0,0 +1,151 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 logging
+
+from pyomo.common.log import is_debug_set
+from pyomo.common.modeling import NOTSET
+from pyomo.contrib.cp import IntervalVar
+from pyomo.core import ModelComponentFactory
+from pyomo.core.base.component import ActiveComponentData
+from pyomo.core.base.global_set import UnindexedComponent_index
+from pyomo.core.base.indexed_component import ActiveIndexedComponent
+from pyomo.core.base.initializer import Initializer
+
+import sys
+from weakref import ref as weakref_ref
+
+logger = logging.getLogger(__name__)
+
+
+class SequenceVarData(ActiveComponentData):
+ """This class defines the abstract interface for a single sequence variable."""
+
+ __slots__ = ('interval_vars',)
+
+ def __init__(self, component=None):
+ # in-lining ActiveComponentData and ComponentData constructors, as is
+ # traditional:
+ self._component = weakref_ref(component) if (component is not None) else None
+ self._index = NOTSET
+ self._active = True
+
+ # This thing is really just an ordered set of interval vars that we can
+ # write constraints over.
+ self.interval_vars = []
+
+ def set_value(self, expr):
+ # We'll demand expr be a list for now--it needs to be ordered so this
+ # doesn't seem like too much to ask
+ if not hasattr(expr, '__iter__'):
+ raise ValueError(
+ "'expr' for SequenceVar must be a list of IntervalVars. "
+ "Encountered type '%s' constructing '%s'" % (type(expr), self.name)
+ )
+ for v in expr:
+ if not hasattr(v, 'ctype') or v.ctype is not IntervalVar:
+ raise ValueError(
+ "The SequenceVar 'expr' argument must be a list of "
+ "IntervalVars. The 'expr' for SequenceVar '%s' included "
+ "an object of type '%s'" % (self.name, type(v))
+ )
+ self.interval_vars.append(v)
+
+
+@ModelComponentFactory.register("Sequences of IntervalVars")
+class SequenceVar(ActiveIndexedComponent):
+ _ComponentDataClass = SequenceVarData
+
+ def __new__(cls, *args, **kwds):
+ if cls != SequenceVar:
+ return super(SequenceVar, cls).__new__(cls)
+ if args == ():
+ return ScalarSequenceVar.__new__(ScalarSequenceVar)
+ else:
+ return IndexedSequenceVar.__new__(IndexedSequenceVar)
+
+ def __init__(self, *args, **kwargs):
+ self._init_rule = Initializer(kwargs.pop('rule', None))
+ self._init_expr = kwargs.pop('expr', None)
+ kwargs.setdefault('ctype', SequenceVar)
+ super(SequenceVar, self).__init__(*args, **kwargs)
+
+ if self._init_expr is not None and self._init_rule is not None:
+ raise ValueError(
+ "Cannot specify both rule= and expr= for SequenceVar %s" % (self.name,)
+ )
+
+ def _getitem_when_not_present(self, index):
+ if index is None and not self.is_indexed():
+ obj = self._data[index] = self
+ else:
+ obj = self._data[index] = self._ComponentDataClass(component=self)
+ parent = self.parent_block()
+ obj._index = index
+
+ if self._init_rule is not None:
+ obj.set_value(self._init_rule(parent, index))
+ if self._init_expr is not None:
+ obj.set_value(self._init_expr)
+
+ return obj
+
+ def construct(self, data=None):
+ """
+ Construct the SequenceVarData objects for this SequenceVar
+ """
+ if self._constructed:
+ return
+ self._constructed = True
+
+ if is_debug_set(logger):
+ logger.debug("Constructing SequenceVar %s" % self.name)
+
+ # Initialize index in case we hit the exception below
+ index = None
+ try:
+ if not self.is_indexed():
+ self._getitem_when_not_present(None)
+ if self._init_rule is not None:
+ for index in self.index_set():
+ self._getitem_when_not_present(index)
+ except Exception:
+ err = sys.exc_info()[1]
+ logger.error(
+ "Rule failed when initializing sequence variable for "
+ "SequenceVar %s with index %s:\n%s: %s"
+ % (self.name, str(index), type(err).__name__, err)
+ )
+ raise
+
+ def _pprint(self):
+ """Print component information."""
+ headers = [
+ ("Size", len(self)),
+ ("Index", self._index_set if self.is_indexed() else None),
+ ]
+ return (
+ headers,
+ self._data.items(),
+ ("IntervalVars",),
+ lambda k, v: ['[' + ', '.join(iv.name for iv in v.interval_vars) + ']'],
+ )
+
+
+class ScalarSequenceVar(SequenceVarData, SequenceVar):
+ def __init__(self, *args, **kwds):
+ SequenceVarData.__init__(self, component=self)
+ SequenceVar.__init__(self, *args, **kwds)
+ self._index = UnindexedComponent_index
+
+
+class IndexedSequenceVar(SequenceVar):
+ pass
diff --git a/pyomo/contrib/cp/tests/test_docplex_walker.py b/pyomo/contrib/cp/tests/test_docplex_walker.py
index 8e0e8c6955e..f7abb3d2b3c 100644
--- a/pyomo/contrib/cp/tests/test_docplex_walker.py
+++ b/pyomo/contrib/cp/tests/test_docplex_walker.py
@@ -11,12 +11,16 @@
import pyomo.common.unittest as unittest
-from pyomo.contrib.cp import IntervalVar
-from pyomo.contrib.cp.scheduling_expr.step_function_expressions import (
- AlwaysIn,
- Step,
- Pulse,
+from pyomo.contrib.cp import (
+ IntervalVar,
+ SequenceVar,
+ no_overlap,
+ first_in_sequence,
+ last_in_sequence,
+ alternative,
+ synchronize,
)
+from pyomo.contrib.cp.scheduling_expr.step_function_expressions import Step, Pulse
from pyomo.contrib.cp.repn.docplex_writer import docplex_available, LogicalToDoCplex
from pyomo.core.base.range import NumericRange
@@ -46,8 +50,6 @@
Integers,
inequality,
Expression,
- Reals,
- Set,
Param,
)
@@ -98,6 +100,10 @@ def test_write_addition(self):
expr[1].equals(cpx_x + cp.start_of(cpx_i) + cp.length_of(cpx_i2))
)
+ self.assertIs(visitor.pyomo_to_docplex[m.x], cpx_x)
+ self.assertIs(visitor.pyomo_to_docplex[m.i], cpx_i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], cpx_i2)
+
def test_write_subtraction(self):
m = self.get_model()
m.a.domain = Binary
@@ -113,6 +119,9 @@ def test_write_subtraction(self):
self.assertTrue(expr[1].equals(x + (-1 * a1)))
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertIs(visitor.pyomo_to_docplex[m.a[1]], a1)
+
def test_write_product(self):
m = self.get_model()
m.a.domain = PositiveIntegers
@@ -128,6 +137,9 @@ def test_write_product(self):
self.assertTrue(expr[1].equals(x * (a1 + 1)))
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertIs(visitor.pyomo_to_docplex[m.a[1]], a1)
+
def test_write_floating_point_division(self):
m = self.get_model()
m.a.domain = NonNegativeIntegers
@@ -143,6 +155,9 @@ def test_write_floating_point_division(self):
self.assertTrue(expr[1].equals(x / (a1 + 1)))
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertIs(visitor.pyomo_to_docplex[m.a[1]], a1)
+
def test_write_power_expression(self):
m = self.get_model()
m.c = Constraint(expr=m.x**2 <= 3)
@@ -154,6 +169,8 @@ def test_write_power_expression(self):
# .equals checks the equality of two expressions in docplex.
self.assertTrue(expr[1].equals(cpx_x**2))
+ self.assertIs(visitor.pyomo_to_docplex[m.x], cpx_x)
+
def test_write_absolute_value_expression(self):
m = self.get_model()
m.a.domain = NegativeIntegers
@@ -167,6 +184,8 @@ def test_write_absolute_value_expression(self):
self.assertTrue(expr[1].equals(cp.abs(a1) + 1))
+ self.assertIs(visitor.pyomo_to_docplex[m.a[1]], a1)
+
def test_write_min_expression(self):
m = self.get_model()
m.a.domain = NonPositiveIntegers
@@ -178,6 +197,7 @@ def test_write_min_expression(self):
for i in m.I:
self.assertIn(id(m.a[i]), visitor.var_map)
a[i] = visitor.var_map[id(m.a[i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[i]], a[i])
self.assertTrue(expr[1].equals(cp.min(a[i] for i in m.I)))
@@ -192,6 +212,7 @@ def test_write_max_expression(self):
for i in m.I:
self.assertIn(id(m.a[i]), visitor.var_map)
a[i] = visitor.var_map[id(m.a[i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[i]], a[i])
self.assertTrue(expr[1].equals(cp.max(a[i] for i in m.I)))
@@ -209,6 +230,35 @@ def test_expression_with_mutable_param(self):
self.assertTrue(expr[1].equals(4 * x))
+ def test_monomial_expressions(self):
+ m = ConcreteModel()
+ m.x = Var(domain=Integers, bounds=(1, 4))
+ m.p = Param(initialize=4, mutable=True)
+
+ visitor = self.get_visitor()
+
+ const_expr = 3 * m.x
+ nested_expr = (1 / m.p) * m.x
+ pow_expr = (m.p ** (0.5)) * m.x
+
+ e = m.x * 4
+ expr = visitor.walk_expression((e, e, 0))
+ self.assertIn(id(m.x), visitor.var_map)
+ x = visitor.var_map[id(m.x)]
+ self.assertTrue(expr[1].equals(4 * x))
+
+ e = 1.0 * m.x
+ expr = visitor.walk_expression((e, e, 0))
+ self.assertTrue(expr[1].equals(x))
+
+ e = (1 / m.p) * m.x
+ expr = visitor.walk_expression((e, e, 0))
+ self.assertTrue(expr[1].equals(cp.float_div(1, 4) * x))
+
+ e = (m.p ** (0.5)) * m.x
+ expr = visitor.walk_expression((e, e, 0))
+ self.assertTrue(expr[1].equals(cp.power(4, 0.5) * x))
+
@unittest.skipIf(not docplex_available, "docplex is not available")
class TestCPExpressionWalker_LogicalExpressions(CommonTest):
@@ -226,6 +276,14 @@ def test_write_logical_and(self):
self.assertTrue(expr[1].equals(cp.logical_and(b, b2b)))
+ # ESJ: This is ludicrous, but I don't know how to get the args of a CP
+ # expression, so testing that we were correct in the pyomo to docplex
+ # map by checking that we can build an expression that is the same as b
+ # (because b is actually "b == 1" since docplex doesn't believe in
+ # Booleans)
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+ self.assertTrue(b2b.equals(visitor.pyomo_to_docplex[m.b2['b']] == 1))
+
def test_write_logical_or(self):
m = self.get_model()
m.c = LogicalConstraint(expr=m.b.lor(m.i.is_present))
@@ -239,6 +297,9 @@ def test_write_logical_or(self):
self.assertTrue(expr[1].equals(cp.logical_or(b, cp.presence_of(i))))
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+
def test_write_xor(self):
m = self.get_model()
m.c = LogicalConstraint(expr=m.b.xor(m.i2[2].start_time >= 5))
@@ -256,6 +317,9 @@ def test_write_xor(self):
expr[1].equals(cp.count([b, cp.less_or_equal(5, cp.start_of(i22))], 1) == 1)
)
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+
def test_write_logical_not(self):
m = self.get_model()
m.c = LogicalConstraint(expr=~m.b2['a'])
@@ -267,6 +331,8 @@ def test_write_logical_not(self):
self.assertTrue(expr[1].equals(cp.logical_not(b2a)))
+ self.assertTrue(b2a.equals(visitor.pyomo_to_docplex[m.b2['a']] == 1))
+
def test_equivalence(self):
m = self.get_model()
m.c = LogicalConstraint(expr=equivalent(~m.b2['a'], m.b))
@@ -280,18 +346,8 @@ def test_equivalence(self):
self.assertTrue(expr[1].equals(cp.equal(cp.logical_not(b2a), b)))
- def test_implication(self):
- m = self.get_model()
- m.c = LogicalConstraint(expr=m.b2['a'].implies(~m.b))
- visitor = self.get_visitor()
- expr = visitor.walk_expression((m.c.expr, m.c, 0))
-
- self.assertIn(id(m.b), visitor.var_map)
- self.assertIn(id(m.b2['a']), visitor.var_map)
- b = visitor.var_map[id(m.b)]
- b2a = visitor.var_map[id(m.b2['a'])]
-
- self.assertTrue(expr[1].equals(cp.if_then(b2a, cp.logical_not(b))))
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+ self.assertTrue(b2a.equals(visitor.pyomo_to_docplex[m.b2['a']] == 1))
def test_equality(self):
m = self.get_model()
@@ -308,6 +364,9 @@ def test_equality(self):
self.assertTrue(expr[1].equals(cp.if_then(b, cp.equal(a3, 4))))
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+ self.assertIs(visitor.pyomo_to_docplex[m.a[3]], a3)
+
def test_inequality(self):
m = self.get_model()
m.a.domain = Integers
@@ -325,6 +384,10 @@ def test_inequality(self):
self.assertTrue(expr[1].equals(cp.if_then(b, cp.less_or_equal(a4, a3))))
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+ self.assertIs(visitor.pyomo_to_docplex[m.a[3]], a3)
+ self.assertIs(visitor.pyomo_to_docplex[m.a[4]], a4)
+
def test_ranged_inequality(self):
m = self.get_model()
m.a.domain = Integers
@@ -355,6 +418,10 @@ def test_not_equal(self):
self.assertTrue(expr[1].equals(cp.if_then(b, a3 != a4)))
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+ self.assertIs(visitor.pyomo_to_docplex[m.a[3]], a3)
+ self.assertIs(visitor.pyomo_to_docplex[m.a[4]], a4)
+
def test_exactly_expression(self):
m = self.get_model()
m.a.domain = Integers
@@ -367,6 +434,7 @@ def test_exactly_expression(self):
for i in m.I:
self.assertIn(id(m.a[i]), visitor.var_map)
a[i] = visitor.var_map[id(m.a[i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[i]], a[i])
self.assertTrue(
expr[1].equals(cp.equal(cp.count([a[i] == 4 for i in m.I], 1), 3))
@@ -384,6 +452,7 @@ def test_atleast_expression(self):
for i in m.I:
self.assertIn(id(m.a[i]), visitor.var_map)
a[i] = visitor.var_map[id(m.a[i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[i]], a[i])
self.assertTrue(
expr[1].equals(
@@ -403,6 +472,7 @@ def test_atmost_expression(self):
for i in m.I:
self.assertIn(id(m.a[i]), visitor.var_map)
a[i] = visitor.var_map[id(m.a[i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[i]], a[i])
self.assertTrue(
expr[1].equals(cp.less_or_equal(cp.count([a[i] == 4 for i in m.I], 1), 3))
@@ -421,6 +491,7 @@ def test_all_diff_expression(self):
for i in m.I:
self.assertIn(id(m.a[i]), visitor.var_map)
a[i] = visitor.var_map[id(m.a[i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[i]], a[i])
self.assertTrue(expr[1].equals(cp.all_diff(a[i] for i in m.I)))
@@ -437,6 +508,7 @@ def test_count_if_expression(self):
for i in m.I:
self.assertIn(id(m.a[i]), visitor.var_map)
a[i] = visitor.var_map[id(m.a[i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[i]], a[i])
self.assertTrue(expr[1].equals(cp.count((a[i] == i for i in m.I), 1) == 5))
@@ -455,6 +527,9 @@ def test_interval_var_is_present(self):
self.assertTrue(expr[1].equals(cp.if_then(cp.presence_of(i), a1 == 5)))
+ self.assertIs(visitor.pyomo_to_docplex[m.a[1]], a1)
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+
def test_interval_var_is_present_indirection(self):
m = self.get_model()
m.a.domain = Integers
@@ -488,6 +563,11 @@ def test_interval_var_is_present_indirection(self):
)
)
+ self.assertIs(visitor.pyomo_to_docplex[m.a[1]], a1)
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+
def test_is_present_indirection_and_length(self):
m = self.get_model()
m.y = Var(domain=Integers, bounds=[1, 2])
@@ -522,6 +602,10 @@ def test_is_present_indirection_and_length(self):
)
)
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+
def test_handle_getattr_lor(self):
m = self.get_model()
m.y = Var(domain=Integers, bounds=(1, 2))
@@ -553,6 +637,11 @@ def test_handle_getattr_lor(self):
)
)
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+
def test_handle_getattr_xor(self):
m = self.get_model()
m.y = Var(domain=Integers, bounds=(1, 2))
@@ -591,6 +680,11 @@ def test_handle_getattr_xor(self):
)
)
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+
def test_handle_getattr_equivalent_to(self):
m = self.get_model()
m.y = Var(domain=Integers, bounds=(1, 2))
@@ -622,6 +716,11 @@ def test_handle_getattr_equivalent_to(self):
)
)
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+
def test_logical_or_on_indirection(self):
m = ConcreteModel()
m.b = BooleanVar([2, 3, 4, 5])
@@ -651,6 +750,11 @@ def test_logical_or_on_indirection(self):
)
)
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertTrue(b3.equals(visitor.pyomo_to_docplex[m.b[3]] == 1))
+ self.assertTrue(b4.equals(visitor.pyomo_to_docplex[m.b[4]] == 1))
+ self.assertTrue(b5.equals(visitor.pyomo_to_docplex[m.b[5]] == 1))
+
def test_logical_xor_on_indirection(self):
m = ConcreteModel()
m.b = BooleanVar([2, 3, 4, 5])
@@ -685,6 +789,10 @@ def test_logical_xor_on_indirection(self):
)
)
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertTrue(b3.equals(visitor.pyomo_to_docplex[m.b[3]] == 1))
+ self.assertTrue(b5.equals(visitor.pyomo_to_docplex[m.b[5]] == 1))
+
def test_using_precedence_expr_as_boolean_expr(self):
m = self.get_model()
e = m.b.implies(m.i2[2].start_time.before(m.i2[1].start_time))
@@ -704,6 +812,10 @@ def test_using_precedence_expr_as_boolean_expr(self):
expr[1].equals(cp.if_then(b, cp.start_of(i22) + 0 <= cp.start_of(i21)))
)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+
def test_using_precedence_expr_as_boolean_expr_positive_delay(self):
m = self.get_model()
e = m.b.implies(m.i2[2].start_time.before(m.i2[1].start_time, delay=4))
@@ -723,6 +835,10 @@ def test_using_precedence_expr_as_boolean_expr_positive_delay(self):
expr[1].equals(cp.if_then(b, cp.start_of(i22) + 4 <= cp.start_of(i21)))
)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+
def test_using_precedence_expr_as_boolean_expr_negative_delay(self):
m = self.get_model()
e = m.b.implies(m.i2[2].start_time.at(m.i2[1].start_time, delay=-3))
@@ -742,6 +858,10 @@ def test_using_precedence_expr_as_boolean_expr_negative_delay(self):
expr[1].equals(cp.if_then(b, cp.start_of(i22) + (-3) == cp.start_of(i21)))
)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertTrue(b.equals(visitor.pyomo_to_docplex[m.b] == 1))
+
@unittest.skipIf(not docplex_available, "docplex is not available")
class TestCPExpressionWalker_IntervalVars(CommonTest):
@@ -755,6 +875,7 @@ def test_interval_var_fixed_presences_correct(self):
i = visitor.var_map[id(m.i)]
# Check that docplex knows it's optional
self.assertTrue(i.is_optional())
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
# Now fix it to absent
m.i.is_present.fix(False)
@@ -765,8 +886,10 @@ def test_interval_var_fixed_presences_correct(self):
self.assertIn(id(m.i2[1]), visitor.var_map)
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertIn(id(m.i), visitor.var_map)
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
# Check that we passed on the presence info to docplex
self.assertTrue(i.is_absent())
@@ -785,6 +908,7 @@ def test_interval_var_fixed_length(self):
self.assertIn(id(m.i), visitor.var_map)
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
self.assertTrue(i.is_optional())
self.assertEqual(i.get_length(), (4, 4))
@@ -802,12 +926,85 @@ def test_interval_var_fixed_start_and_end(self):
self.assertIn(id(m.i), visitor.var_map)
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
self.assertFalse(i.is_optional())
self.assertEqual(i.get_start(), (3, 3))
self.assertEqual(i.get_end(), (6, 6))
+@unittest.skipIf(not docplex_available, "docplex is not available")
+class TestCPExpressionWalker_SequenceVars(CommonTest):
+ def get_model(self):
+ m = super().get_model()
+ m.seq = SequenceVar(expr=[m.i, m.i2[1], m.i2[2]])
+
+ return m
+
+ def check_scalar_sequence_var(self, m, visitor):
+ self.assertIn(id(m.seq), visitor.var_map)
+ seq = visitor.var_map[id(m.seq)]
+ self.assertIs(visitor.pyomo_to_docplex[m.seq], seq)
+
+ i = visitor.var_map[id(m.i)]
+ i21 = visitor.var_map[id(m.i2[1])]
+ i22 = visitor.var_map[id(m.i2[2])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+
+ ivs = seq.get_interval_variables()
+ self.assertEqual(len(ivs), 3)
+ self.assertIs(ivs[0], i)
+ self.assertIs(ivs[1], i21)
+ self.assertIs(ivs[2], i22)
+
+ return seq, i, i21, i22
+
+ def test_scalar_sequence_var(self):
+ m = self.get_model()
+
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((m.seq, m.seq, 0))
+ self.check_scalar_sequence_var(m, visitor)
+
+ def test_no_overlap(self):
+ m = self.get_model()
+ e = no_overlap(m.seq)
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((e, e, 0))
+
+ seq, i, i21, i22 = self.check_scalar_sequence_var(m, visitor)
+ self.assertTrue(expr[1].equals(cp.no_overlap(seq)))
+
+ def test_first_in_sequence(self):
+ m = self.get_model()
+ e = first_in_sequence(m.i2[1], m.seq)
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((e, e, 0))
+
+ seq, i, i21, i22 = self.check_scalar_sequence_var(m, visitor)
+ self.assertTrue(expr[1].equals(cp.first(seq, i21)))
+
+ def test_before_in_sequence(self):
+ m = self.get_model()
+ e = last_in_sequence(m.i, m.seq)
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((e, e, 0))
+
+ seq, i, i21, i22 = self.check_scalar_sequence_var(m, visitor)
+ self.assertTrue(expr[1].equals(cp.last(seq, i)))
+
+ def test_last_in_sequence(self):
+ m = self.get_model()
+ e = last_in_sequence(m.i2[1], m.seq)
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((e, e, 0))
+
+ seq, i, i21, i22 = self.check_scalar_sequence_var(m, visitor)
+ self.assertTrue(expr[1].equals(cp.last(seq, i21)))
+
+
@unittest.skipIf(not docplex_available, "docplex is not available")
class TestCPExpressionWalker_PrecedenceExpressions(CommonTest):
def test_start_before_start(self):
@@ -821,6 +1018,8 @@ def test_start_before_start(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertTrue(expr[1].equals(cp.start_before_start(i, i21, 0)))
@@ -835,6 +1034,8 @@ def test_start_before_end(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertTrue(expr[1].equals(cp.start_before_end(i, i21, 3)))
@@ -849,6 +1050,8 @@ def test_end_before_start(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertTrue(expr[1].equals(cp.end_before_start(i, i21, -2)))
@@ -863,6 +1066,8 @@ def test_end_before_end(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertTrue(expr[1].equals(cp.end_before_end(i, i21, 6)))
@@ -877,6 +1082,8 @@ def test_start_at_start(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertTrue(expr[1].equals(cp.start_at_start(i, i21, 0)))
@@ -891,6 +1098,8 @@ def test_start_at_end(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertTrue(expr[1].equals(cp.start_at_end(i, i21, 3)))
@@ -905,6 +1114,8 @@ def test_end_at_start(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertTrue(expr[1].equals(cp.end_at_start(i, i21, -2)))
@@ -919,6 +1130,8 @@ def test_end_at_end(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
self.assertTrue(expr[1].equals(cp.end_at_end(i, i21, 6)))
@@ -943,6 +1156,10 @@ def test_indirection_before_constraint(self):
i21 = visitor.var_map[id(m.i2[1])]
i22 = visitor.var_map[id(m.i2[2])]
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
self.assertTrue(
expr[1].equals(
@@ -969,6 +1186,10 @@ def test_indirection_after_constraint(self):
i21 = visitor.var_map[id(m.i2[1])]
i22 = visitor.var_map[id(m.i2[2])]
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
self.assertTrue(
expr[1].equals(
@@ -996,6 +1217,10 @@ def test_indirection_at_constraint(self):
i21 = visitor.var_map[id(m.i2[1])]
i22 = visitor.var_map[id(m.i2[2])]
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
self.assertTrue(
expr[1].equals(
@@ -1023,6 +1248,10 @@ def test_before_indirection_constraint(self):
i21 = visitor.var_map[id(m.i2[1])]
i22 = visitor.var_map[id(m.i2[2])]
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
self.assertTrue(
expr[1].equals(
@@ -1048,6 +1277,10 @@ def test_after_indirection_constraint(self):
i21 = visitor.var_map[id(m.i2[1])]
i22 = visitor.var_map[id(m.i2[2])]
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
self.assertTrue(
expr[1].equals(
@@ -1073,6 +1306,10 @@ def test_at_indirection_constraint(self):
i21 = visitor.var_map[id(m.i2[1])]
i22 = visitor.var_map[id(m.i2[2])]
i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
self.assertTrue(
expr[1].equals(
@@ -1107,6 +1344,13 @@ def test_double_indirection_before_constraint(self):
i33 = visitor.var_map[id(m.i3[1, 3])]
i34 = visitor.var_map[id(m.i3[1, 4])]
i35 = visitor.var_map[id(m.i3[1, 5])]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 3]], i33)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 4]], i34)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 5]], i35)
self.assertTrue(
expr[1].equals(
@@ -1144,6 +1388,13 @@ def test_double_indirection_after_constraint(self):
i33 = visitor.var_map[id(m.i3[1, 3])]
i34 = visitor.var_map[id(m.i3[1, 4])]
i35 = visitor.var_map[id(m.i3[1, 5])]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 3]], i33)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 4]], i34)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 5]], i35)
self.assertTrue(
expr[1].equals(
@@ -1179,6 +1430,13 @@ def test_double_indirection_at_constraint(self):
i33 = visitor.var_map[id(m.i3[1, 3])]
i34 = visitor.var_map[id(m.i3[1, 4])]
i35 = visitor.var_map[id(m.i3[1, 5])]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 3]], i33)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 4]], i34)
+ self.assertIs(visitor.pyomo_to_docplex[m.i3[1, 5]], i35)
self.assertTrue(
expr[1].equals(
@@ -1226,10 +1484,91 @@ def param_rule(m, i):
self.assertIn(id(m.a), visitor.var_map)
x = visitor.var_map[id(m.x)]
a = visitor.var_map[id(m.a)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+ self.assertIs(visitor.pyomo_to_docplex[m.a], a)
self.assertTrue(expr[1].equals(cp.element([2, 4, 6], 0 + 1 * (x - 1) // 2) / a))
+@unittest.skipIf(not docplex_available, "docplex is not available")
+class TestCPExpressionWalker_HierarchicalScheduling(CommonTest):
+ def get_model(self):
+ m = ConcreteModel()
+
+ def start_rule(m, i):
+ return 2 * i
+
+ def length_rule(m, i):
+ return i
+
+ m.iv = IntervalVar(
+ [1, 2, 3], start=start_rule, length=length_rule, optional=True
+ )
+ m.whole_enchilada = IntervalVar()
+
+ return m
+
+ def test_spans(self):
+ m = self.get_model()
+ e = m.whole_enchilada.spans(m.iv[i] for i in [1, 2, 3])
+
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((e, e, 0))
+
+ self.assertIn(id(m.whole_enchilada), visitor.var_map)
+ whole_enchilada = visitor.var_map[id(m.whole_enchilada)]
+ self.assertIs(visitor.pyomo_to_docplex[m.whole_enchilada], whole_enchilada)
+
+ iv = {}
+ for i in [1, 2, 3]:
+ self.assertIn(id(m.iv[i]), visitor.var_map)
+ iv[i] = visitor.var_map[id(m.iv[i])]
+
+ self.assertTrue(
+ expr[1].equals(cp.span(whole_enchilada, [iv[i] for i in [1, 2, 3]]))
+ )
+
+ def test_alternative(self):
+ m = self.get_model()
+ e = alternative(m.whole_enchilada, [m.iv[i] for i in [1, 2, 3]])
+
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((e, e, 0))
+
+ self.assertIn(id(m.whole_enchilada), visitor.var_map)
+ whole_enchilada = visitor.var_map[id(m.whole_enchilada)]
+ self.assertIs(visitor.pyomo_to_docplex[m.whole_enchilada], whole_enchilada)
+
+ iv = {}
+ for i in [1, 2, 3]:
+ self.assertIn(id(m.iv[i]), visitor.var_map)
+ iv[i] = visitor.var_map[id(m.iv[i])]
+
+ self.assertTrue(
+ expr[1].equals(cp.alternative(whole_enchilada, [iv[i] for i in [1, 2, 3]]))
+ )
+
+ def test_synchronize(self):
+ m = self.get_model()
+ e = synchronize(m.whole_enchilada, [m.iv[i] for i in [1, 2, 3]])
+
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((e, e, 0))
+
+ self.assertIn(id(m.whole_enchilada), visitor.var_map)
+ whole_enchilada = visitor.var_map[id(m.whole_enchilada)]
+ self.assertIs(visitor.pyomo_to_docplex[m.whole_enchilada], whole_enchilada)
+
+ iv = {}
+ for i in [1, 2, 3]:
+ self.assertIn(id(m.iv[i]), visitor.var_map)
+ iv[i] = visitor.var_map[id(m.iv[i])]
+
+ self.assertTrue(
+ expr[1].equals(cp.synchronize(whole_enchilada, [iv[i] for i in [1, 2, 3]]))
+ )
+
+
@unittest.skipIf(not docplex_available, "docplex is not available")
class TestCPExpressionWalker_CumulFuncExpressions(CommonTest):
def test_always_in(self):
@@ -1251,6 +1590,9 @@ def test_always_in(self):
i = visitor.var_map[id(m.i)]
i21 = visitor.var_map[id(m.i2[1])]
i22 = visitor.var_map[id(m.i2[2])]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[1]], i21)
+ self.assertIs(visitor.pyomo_to_docplex[m.i2[2]], i22)
self.assertTrue(
expr[1].equals(
@@ -1266,6 +1608,24 @@ def test_always_in(self):
)
)
+ def test_always_in_single_pulse(self):
+ # This is a bit silly as you can tell whether or not it is feasible
+ # structurally, but there's no reason it couldn't happen.
+ m = self.get_model()
+ f = Pulse((m.i, 3))
+ m.c = LogicalConstraint(expr=f.within((0, 3), (0, 10)))
+ visitor = self.get_visitor()
+ expr = visitor.walk_expression((m.c.expr, m.c, 0))
+
+ self.assertIn(id(m.i), visitor.var_map)
+
+ i = visitor.var_map[id(m.i)]
+ self.assertIs(visitor.pyomo_to_docplex[m.i], i)
+
+ self.assertTrue(
+ expr[1].equals(cp.always_in(cp.pulse(i, 3), interval=(0, 10), min=0, max=3))
+ )
+
@unittest.skipIf(not docplex_available, "docplex is not available")
class TestCPExpressionWalker_NamedExpressions(CommonTest):
@@ -1279,6 +1639,7 @@ def test_named_expression(self):
self.assertIn(id(m.x), visitor.var_map)
x = visitor.var_map[id(m.x)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
self.assertTrue(expr[1].equals(x**2 + 7))
@@ -1292,6 +1653,7 @@ def test_repeated_named_expression(self):
self.assertIn(id(m.x), visitor.var_map)
x = visitor.var_map[id(m.x)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
self.assertTrue(expr[1].equals(x**2 + 7 + (-1) * (8 * (x**2 + 7))))
@@ -1322,6 +1684,7 @@ def test_fixed_integer_var(self):
self.assertIn(id(m.a[2]), visitor.var_map)
a2 = visitor.var_map[id(m.a[2])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[2]], a2)
self.assertTrue(expr[1].equals(3 + a2))
@@ -1336,6 +1699,7 @@ def test_fixed_boolean_var(self):
self.assertIn(id(m.b2['b']), visitor.var_map)
b2b = visitor.var_map[id(m.b2['b'])]
+ self.assertTrue(b2b.equals(visitor.pyomo_to_docplex[m.b2['b']] == 1))
self.assertTrue(expr[1].equals(cp.logical_or(False, cp.logical_and(True, b2b))))
@@ -1349,13 +1713,16 @@ def test_indirection_single_index(self):
self.assertIn(id(m.x), visitor.var_map)
x = visitor.var_map[id(m.x)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
a = []
# only need indices 6, 7, and 8 from a, since that's what x is capable
# of selecting.
for idx in [6, 7, 8]:
v = m.a[idx]
self.assertIn(id(v), visitor.var_map)
- a.append(visitor.var_map[id(v)])
+ cpx_v = visitor.var_map[id(v)]
+ self.assertIs(visitor.pyomo_to_docplex[v], cpx_v)
+ a.append(cpx_v)
# since x is between 6 and 8, we subtract 6 from it for it to be the
# right index
self.assertTrue(expr[1].equals(cp.element(a, 0 + 1 * (x - 6) // 1)))
@@ -1373,8 +1740,10 @@ def test_indirection_multi_index_second_constant(self):
for i in [6, 7, 8]:
self.assertIn(id(m.z[i, 3]), visitor.var_map)
z[i, 3] = visitor.var_map[id(m.z[i, 3])]
+ self.assertIs(visitor.pyomo_to_docplex[m.z[i, 3]], z[i, 3])
self.assertIn(id(m.x), visitor.var_map)
x = visitor.var_map[id(m.x)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
self.assertTrue(
expr[1].equals(
@@ -1395,8 +1764,11 @@ def test_indirection_multi_index_first_constant(self):
for i in [6, 7, 8]:
self.assertIn(id(m.z[3, i]), visitor.var_map)
z[3, i] = visitor.var_map[id(m.z[3, i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.z[3, i]], z[3, i])
+
self.assertIn(id(m.x), visitor.var_map)
x = visitor.var_map[id(m.x)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
self.assertTrue(
expr[1].equals(
@@ -1418,8 +1790,11 @@ def test_indirection_multi_index_neither_constant_same_var(self):
for j in [6, 7, 8]:
self.assertIn(id(m.z[i, j]), visitor.var_map)
z[i, j] = visitor.var_map[id(m.z[i, j])]
+ self.assertIs(visitor.pyomo_to_docplex[m.z[i, j]], z[i, j])
+
self.assertIn(id(m.x), visitor.var_map)
x = visitor.var_map[id(m.x)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
self.assertTrue(
expr[1].equals(
@@ -1443,12 +1818,17 @@ def test_indirection_multi_index_neither_constant_diff_vars(self):
z = {}
for i in [6, 7, 8]:
for j in [1, 3, 5]:
- self.assertIn(id(m.z[i, 3]), visitor.var_map)
+ self.assertIn(id(m.z[i, j]), visitor.var_map)
z[i, j] = visitor.var_map[id(m.z[i, j])]
+ self.assertIs(visitor.pyomo_to_docplex[m.z[i, j]], z[i, j])
+
self.assertIn(id(m.x), visitor.var_map)
x = visitor.var_map[id(m.x)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
+
self.assertIn(id(m.y), visitor.var_map)
y = visitor.var_map[id(m.y)]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
self.assertTrue(
expr[1].equals(
@@ -1473,10 +1853,14 @@ def test_indirection_expression_index(self):
for i in range(1, 8):
self.assertIn(id(m.a[i]), visitor.var_map)
a[i] = visitor.var_map[id(m.a[i])]
+ self.assertIs(visitor.pyomo_to_docplex[m.a[i]], a[i])
+
self.assertIn(id(m.x), visitor.var_map)
x = visitor.var_map[id(m.x)]
+ self.assertIs(visitor.pyomo_to_docplex[m.x], x)
self.assertIn(id(m.y), visitor.var_map)
y = visitor.var_map[id(m.y)]
+ self.assertIs(visitor.pyomo_to_docplex[m.y], y)
self.assertTrue(
expr[1].equals(
diff --git a/pyomo/contrib/cp/tests/test_docplex_writer.py b/pyomo/contrib/cp/tests/test_docplex_writer.py
index b5f30f24440..4f6039993c3 100644
--- a/pyomo/contrib/cp/tests/test_docplex_writer.py
+++ b/pyomo/contrib/cp/tests/test_docplex_writer.py
@@ -12,7 +12,16 @@
import pyomo.common.unittest as unittest
from pyomo.common.fileutils import Executable
-from pyomo.contrib.cp import IntervalVar, Pulse, Step, AlwaysIn
+from pyomo.contrib.cp import (
+ IntervalVar,
+ SequenceVar,
+ Pulse,
+ Step,
+ AlwaysIn,
+ first_in_sequence,
+ predecessor_to,
+ no_overlap,
+)
from pyomo.contrib.cp.repn.docplex_writer import LogicalToDoCplex
from pyomo.environ import (
all_different,
@@ -360,7 +369,6 @@ def test_matching_problem(self):
results.solver.termination_condition, TerminationCondition.optimal
)
self.assertEqual(value(m.obj), perfect)
- m.person_name.pprint()
self.assertEqual(value(m.person_name['P1']), 0)
self.assertEqual(value(m.person_name['P2']), 1)
self.assertEqual(value(m.person_name['P3']), 2)
@@ -392,3 +400,25 @@ def test_matching_problem(self):
results.solver.termination_condition, TerminationCondition.optimal
)
self.assertEqual(value(m.obj), perfect)
+
+ def test_scheduling_with_sequence_vars(self):
+ m = ConcreteModel()
+ m.Steps = Set(initialize=[1, 2, 3])
+
+ def length_rule(m, j):
+ return 2 * j
+
+ m.i = IntervalVar(m.Steps, start=(0, 12), end=(0, 12), length=length_rule)
+ m.seq = SequenceVar(expr=[m.i[j] for j in m.Steps])
+ m.first = LogicalConstraint(expr=first_in_sequence(m.i[1], m.seq))
+ m.seq_order1 = LogicalConstraint(expr=predecessor_to(m.i[1], m.i[2], m.seq))
+ m.seq_order2 = LogicalConstraint(expr=predecessor_to(m.i[2], m.i[3], m.seq))
+ m.no_ovlerpa = LogicalConstraint(expr=no_overlap(m.seq))
+
+ results = SolverFactory('cp_optimizer').solve(m)
+ self.assertEqual(
+ results.solver.termination_condition, TerminationCondition.feasible
+ )
+ self.assertEqual(value(m.i[1].start_time), 0)
+ self.assertEqual(value(m.i[2].start_time), 2)
+ self.assertEqual(value(m.i[3].start_time), 6)
diff --git a/pyomo/contrib/cp/tests/test_interval_var.py b/pyomo/contrib/cp/tests/test_interval_var.py
index 1645258d98a..e44ba00210d 100644
--- a/pyomo/contrib/cp/tests/test_interval_var.py
+++ b/pyomo/contrib/cp/tests/test_interval_var.py
@@ -17,7 +17,7 @@
IntervalVarPresence,
)
from pyomo.core.expr import GetItemExpression, GetAttrExpression
-from pyomo.environ import ConcreteModel, Integers, Set, value, Var
+from pyomo.environ import ConcreteModel, Integers, Reference, Set, value, Var
class TestScalarIntervalVar(unittest.TestCase):
@@ -217,5 +217,24 @@ def test_index_by_expr(self):
self.assertIs(thing2.args[0], thing1)
self.assertEqual(thing2.args[1], 'start_time')
- # TODO: But this is where it dies.
expr1 = m.act[m.i, 2].start_time.before(m.act[m.i**2, 1].end_time)
+
+ def test_reference(self):
+ m = ConcreteModel()
+ m.act = IntervalVar([1, 2], end=[0, 10], optional=True)
+
+ thing = Reference(m.act[:].is_present)
+ self.assertIs(thing[1], m.act[1].is_present)
+ self.assertIs(thing[2], m.act[2].is_present)
+
+ thing = Reference(m.act[:].start_time)
+ self.assertIs(thing[1], m.act[1].start_time)
+ self.assertIs(thing[2], m.act[2].start_time)
+
+ thing = Reference(m.act[:].end_time)
+ self.assertIs(thing[1], m.act[1].end_time)
+ self.assertIs(thing[2], m.act[2].end_time)
+
+ thing = Reference(m.act[:].length)
+ self.assertIs(thing[1], m.act[1].length)
+ self.assertIs(thing[2], m.act[2].length)
diff --git a/pyomo/contrib/cp/tests/test_precedence_constraints.py b/pyomo/contrib/cp/tests/test_precedence_constraints.py
index 0a84a4d1960..3faf054f241 100644
--- a/pyomo/contrib/cp/tests/test_precedence_constraints.py
+++ b/pyomo/contrib/cp/tests/test_precedence_constraints.py
@@ -15,7 +15,7 @@
BeforeExpression,
AtExpression,
)
-from pyomo.environ import ConcreteModel, LogicalConstraint
+from pyomo.environ import ConcreteModel, LogicalConstraint, Param
class TestPrecedenceRelationships(unittest.TestCase):
@@ -173,3 +173,17 @@ def test_end_after_end(self):
self.assertEqual(m.c.expr.delay, 0)
self.assertEqual(str(m.c.expr), "b.end_time <= a.end_time")
+
+ def test_end_before_start_param_delay(self):
+ m = self.get_model()
+ m.PrepTime = Param(initialize=5)
+ m.c = LogicalConstraint(
+ expr=m.a.end_time.before(m.b.start_time, delay=m.PrepTime)
+ )
+ self.assertIsInstance(m.c.expr, BeforeExpression)
+ self.assertEqual(len(m.c.expr.args), 3)
+ self.assertIs(m.c.expr.args[0], m.a.end_time)
+ self.assertIs(m.c.expr.args[1], m.b.start_time)
+ self.assertIs(m.c.expr.delay, m.PrepTime)
+
+ self.assertEqual(str(m.c.expr), "a.end_time + PrepTime <= b.start_time")
diff --git a/pyomo/contrib/cp/tests/test_sequence_expressions.py b/pyomo/contrib/cp/tests/test_sequence_expressions.py
new file mode 100644
index 00000000000..c7cf94f23d5
--- /dev/null
+++ b/pyomo/contrib/cp/tests/test_sequence_expressions.py
@@ -0,0 +1,175 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.unittest as unittest
+from pyomo.contrib.cp.interval_var import IntervalVar
+from pyomo.contrib.cp.scheduling_expr.scheduling_logic import (
+ AlternativeExpression,
+ SpanExpression,
+ SynchronizeExpression,
+ alternative,
+ spans,
+ synchronize,
+)
+from pyomo.contrib.cp.scheduling_expr.sequence_expressions import (
+ NoOverlapExpression,
+ FirstInSequenceExpression,
+ LastInSequenceExpression,
+ BeforeInSequenceExpression,
+ PredecessorToExpression,
+ no_overlap,
+ predecessor_to,
+ before_in_sequence,
+ first_in_sequence,
+ last_in_sequence,
+)
+from pyomo.contrib.cp.sequence_var import SequenceVar
+from pyomo.environ import ConcreteModel, LogicalConstraint, Set
+
+
+class TestSequenceVarExpressions(unittest.TestCase):
+ def get_model(self):
+ m = ConcreteModel()
+ m.S = Set(initialize=range(3))
+ m.i = IntervalVar(m.S, start=(0, 5))
+ m.seq = SequenceVar(expr=[m.i[j] for j in m.S])
+
+ return m
+
+ def test_no_overlap(self):
+ m = self.get_model()
+ m.c = LogicalConstraint(expr=no_overlap(m.seq))
+ e = m.c.expr
+
+ self.assertIsInstance(e, NoOverlapExpression)
+ self.assertEqual(e.nargs(), 1)
+ self.assertEqual(len(e.args), 1)
+ self.assertIs(e.args[0], m.seq)
+
+ self.assertEqual(str(e), "no_overlap(seq)")
+
+ def test_first_in_sequence(self):
+ m = self.get_model()
+ m.c = LogicalConstraint(expr=first_in_sequence(m.i[2], m.seq))
+ e = m.c.expr
+
+ self.assertIsInstance(e, FirstInSequenceExpression)
+ self.assertEqual(e.nargs(), 2)
+ self.assertEqual(len(e.args), 2)
+ self.assertIs(e.args[0], m.i[2])
+ self.assertIs(e.args[1], m.seq)
+
+ self.assertEqual(str(e), "first_in(i[2], seq)")
+
+ def test_last_in_sequence(self):
+ m = self.get_model()
+ m.c = LogicalConstraint(expr=last_in_sequence(m.i[0], m.seq))
+ e = m.c.expr
+
+ self.assertIsInstance(e, LastInSequenceExpression)
+ self.assertEqual(e.nargs(), 2)
+ self.assertEqual(len(e.args), 2)
+ self.assertIs(e.args[0], m.i[0])
+ self.assertIs(e.args[1], m.seq)
+
+ self.assertEqual(str(e), "last_in(i[0], seq)")
+
+ def test_before_in_sequence(self):
+ m = self.get_model()
+ m.c = LogicalConstraint(expr=before_in_sequence(m.i[1], m.i[0], m.seq))
+ e = m.c.expr
+
+ self.assertIsInstance(e, BeforeInSequenceExpression)
+ self.assertEqual(e.nargs(), 3)
+ self.assertEqual(len(e.args), 3)
+ self.assertIs(e.args[0], m.i[1])
+ self.assertIs(e.args[1], m.i[0])
+ self.assertIs(e.args[2], m.seq)
+
+ self.assertEqual(str(e), "before_in(i[1], i[0], seq)")
+
+ def test_predecessor_in_sequence(self):
+ m = self.get_model()
+ m.c = LogicalConstraint(expr=predecessor_to(m.i[0], m.i[1], m.seq))
+ e = m.c.expr
+
+ self.assertIsInstance(e, PredecessorToExpression)
+ self.assertEqual(e.nargs(), 3)
+ self.assertEqual(len(e.args), 3)
+ self.assertIs(e.args[0], m.i[0])
+ self.assertIs(e.args[1], m.i[1])
+ self.assertIs(e.args[2], m.seq)
+
+ self.assertEqual(str(e), "predecessor_to(i[0], i[1], seq)")
+
+
+class TestHierarchicalSchedulingExpressions(unittest.TestCase):
+ def make_model(self):
+ m = ConcreteModel()
+
+ def start_rule(m, i):
+ return 2 * i
+
+ def length_rule(m, i):
+ return i
+
+ m.iv = IntervalVar(
+ [1, 2, 3], start=start_rule, length=length_rule, optional=True
+ )
+ m.whole_enchilada = IntervalVar()
+
+ return m
+
+ def check_span_expression(self, m, e):
+ self.assertIsInstance(e, SpanExpression)
+ self.assertEqual(e.nargs(), 4)
+ self.assertEqual(len(e.args), 4)
+ self.assertIs(e.args[0], m.whole_enchilada)
+ for i in [1, 2, 3]:
+ self.assertIs(e.args[i], m.iv[i])
+
+ self.assertEqual(str(e), "whole_enchilada.spans(iv[1], iv[2], iv[3])")
+
+ def test_spans(self):
+ m = self.make_model()
+ e = spans(m.whole_enchilada, [m.iv[i] for i in [1, 2, 3]])
+ self.check_span_expression(m, e)
+
+ def test_spans_method(self):
+ m = self.make_model()
+ e = m.whole_enchilada.spans(m.iv[i] for i in [1, 2, 3])
+ self.check_span_expression(m, e)
+
+ def test_alternative(self):
+ m = self.make_model()
+ e = alternative(m.whole_enchilada, [m.iv[i] for i in [1, 2, 3]])
+
+ self.assertIsInstance(e, AlternativeExpression)
+ self.assertEqual(e.nargs(), 4)
+ self.assertEqual(len(e.args), 4)
+ self.assertIs(e.args[0], m.whole_enchilada)
+ for i in [1, 2, 3]:
+ self.assertIs(e.args[i], m.iv[i])
+
+ self.assertEqual(str(e), "alternative(whole_enchilada, [iv[1], iv[2], iv[3]])")
+
+ def test_synchronize(self):
+ m = self.make_model()
+ e = synchronize(m.whole_enchilada, [m.iv[i] for i in [1, 2, 3]])
+
+ self.assertIsInstance(e, SynchronizeExpression)
+ self.assertEqual(e.nargs(), 4)
+ self.assertEqual(len(e.args), 4)
+ self.assertIs(e.args[0], m.whole_enchilada)
+ for i in [1, 2, 3]:
+ self.assertIs(e.args[i], m.iv[i])
+
+ self.assertEqual(str(e), "synchronize(whole_enchilada, [iv[1], iv[2], iv[3]])")
diff --git a/pyomo/contrib/cp/tests/test_sequence_var.py b/pyomo/contrib/cp/tests/test_sequence_var.py
new file mode 100644
index 00000000000..c1e205c6326
--- /dev/null
+++ b/pyomo/contrib/cp/tests/test_sequence_var.py
@@ -0,0 +1,158 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from io import StringIO
+import pyomo.common.unittest as unittest
+from pyomo.contrib.cp.interval_var import IntervalVar
+from pyomo.contrib.cp.sequence_var import SequenceVar, IndexedSequenceVar
+from pyomo.environ import ConcreteModel, Set
+
+
+class TestScalarSequenceVar(unittest.TestCase):
+ def test_initialize_with_no_data(self):
+ m = ConcreteModel()
+ m.i = SequenceVar()
+
+ self.assertIsInstance(m.i, SequenceVar)
+ self.assertIsInstance(m.i.interval_vars, list)
+ self.assertEqual(len(m.i.interval_vars), 0)
+
+ m.iv1 = IntervalVar()
+ m.iv2 = IntervalVar()
+ m.i.set_value(expr=[m.iv1, m.iv2])
+
+ self.assertIsInstance(m.i.interval_vars, list)
+ self.assertEqual(len(m.i.interval_vars), 2)
+ self.assertIs(m.i.interval_vars[0], m.iv1)
+ self.assertIs(m.i.interval_vars[1], m.iv2)
+
+ def get_model(self):
+ m = ConcreteModel()
+ m.S = Set(initialize=range(3))
+ m.i = IntervalVar(m.S, start=(0, 5))
+ m.seq = SequenceVar(expr=[m.i[j] for j in m.S])
+
+ return m
+
+ def test_initialize_with_expr(self):
+ m = self.get_model()
+ self.assertEqual(len(m.seq.interval_vars), 3)
+ for j in m.S:
+ self.assertIs(m.seq.interval_vars[j], m.i[j])
+
+ def test_pprint(self):
+ m = self.get_model()
+ buf = StringIO()
+ m.seq.pprint(ostream=buf)
+ self.assertEqual(
+ buf.getvalue().strip(),
+ """
+seq : Size=1, Index=None
+ Key : IntervalVars
+ None : [i[0], i[1], i[2]]
+ """.strip(),
+ )
+
+ def test_interval_vars_not_a_list(self):
+ m = self.get_model()
+
+ with self.assertRaisesRegex(
+ ValueError,
+ "'expr' for SequenceVar must be a list of IntervalVars. "
+ "Encountered type '' constructing 'seq2'",
+ ):
+ m.seq2 = SequenceVar(expr=1)
+
+ def test_interval_vars_list_includes_things_that_are_not_interval_vars(self):
+ m = self.get_model()
+
+ with self.assertRaisesRegex(
+ ValueError,
+ "The SequenceVar 'expr' argument must be a list of "
+ "IntervalVars. The 'expr' for SequenceVar 'seq2' included "
+ "an object of type ''",
+ ):
+ m.seq2 = SequenceVar(expr=m.i)
+
+
+class TestIndexedSequenceVar(unittest.TestCase):
+ def test_initialize_with_not_data(self):
+ m = ConcreteModel()
+ m.i = SequenceVar([1, 2])
+
+ self.assertIsInstance(m.i, IndexedSequenceVar)
+ for j in [1, 2]:
+ self.assertIsInstance(m.i[j].interval_vars, list)
+ self.assertEqual(len(m.i[j].interval_vars), 0)
+
+ m.iv = IntervalVar()
+ m.iv2 = IntervalVar([0, 1])
+ m.i[2] = [m.iv] + [m.iv2[i] for i in [0, 1]]
+
+ self.assertEqual(len(m.i[2].interval_vars), 3)
+ self.assertEqual(len(m.i[1].interval_vars), 0)
+ self.assertIs(m.i[2].interval_vars[0], m.iv)
+ for i in [0, 1]:
+ self.assertIs(m.i[2].interval_vars[i + 1], m.iv2[i])
+
+ def make_model(self):
+ m = ConcreteModel()
+ m.alphabetic = Set(initialize=['a', 'b'])
+ m.numeric = Set(initialize=[1, 2])
+ m.i = IntervalVar(m.alphabetic, m.numeric)
+
+ def the_rule(m, j):
+ return [m.i[j, k] for k in m.numeric]
+
+ m.seq = SequenceVar(m.alphabetic, rule=the_rule)
+
+ return m
+
+ def test_initialize_with_rule(self):
+ m = self.make_model()
+
+ self.assertIsInstance(m.seq, IndexedSequenceVar)
+ self.assertEqual(len(m.seq), 2)
+ for j in m.alphabetic:
+ self.assertTrue(j in m.seq)
+ self.assertEqual(len(m.seq[j].interval_vars), 2)
+ for k in m.numeric:
+ self.assertIs(m.seq[j].interval_vars[k - 1], m.i[j, k])
+
+ def test_pprint(self):
+ m = self.make_model()
+ m.seq.pprint()
+
+ buf = StringIO()
+ m.seq.pprint(ostream=buf)
+ self.assertEqual(
+ buf.getvalue().strip(),
+ """
+seq : Size=2, Index=alphabetic
+ Key : IntervalVars
+ a : [i[a,1], i[a,2]]
+ b : [i[b,1], i[b,2]]""".strip(),
+ )
+
+ def test_multidimensional_index(self):
+ m = self.make_model()
+
+ @m.SequenceVar(m.alphabetic, m.numeric)
+ def s(m, i, j):
+ return [m.i[i, j]]
+
+ self.assertIsInstance(m.s, IndexedSequenceVar)
+ self.assertEqual(len(m.s), 4)
+ for i in m.alphabetic:
+ for j in m.numeric:
+ self.assertTrue((i, j) in m.s)
+ self.assertEqual(len(m.s[i, j].interval_vars), 1)
+ self.assertIs(m.s[i, j].interval_vars[0], m.i[i, j])
diff --git a/pyomo/contrib/cp/transform/logical_to_disjunctive_program.py b/pyomo/contrib/cp/transform/logical_to_disjunctive_program.py
index e318e621e88..7c5ef8d13c0 100644
--- a/pyomo/contrib/cp/transform/logical_to_disjunctive_program.py
+++ b/pyomo/contrib/cp/transform/logical_to_disjunctive_program.py
@@ -12,7 +12,6 @@
from pyomo.contrib.cp.transform.logical_to_disjunctive_walker import (
LogicalToDisjunctiveVisitor,
)
-from pyomo.common.collections import ComponentMap
from pyomo.common.modeling import unique_component_name
from pyomo.common.config import ConfigDict, ConfigValue
@@ -26,7 +25,7 @@
Transformation,
NonNegativeIntegers,
)
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.core.base import SortComponents
from pyomo.core.util import target_list
from pyomo.gdp import Disjunct, Disjunction
@@ -73,7 +72,7 @@ def _apply_to(self, model, **kwds):
transBlocks = {}
visitor = LogicalToDisjunctiveVisitor()
for t in targets:
- if t.ctype is Block or isinstance(t, _BlockData):
+ if t.ctype is Block or isinstance(t, BlockData):
self._transform_block(t, model, visitor, transBlocks)
elif t.ctype is LogicalConstraint:
if t.is_indexed():
diff --git a/pyomo/contrib/cp/transform/logical_to_disjunctive_walker.py b/pyomo/contrib/cp/transform/logical_to_disjunctive_walker.py
index d5f13e91535..09894b47090 100644
--- a/pyomo/contrib/cp/transform/logical_to_disjunctive_walker.py
+++ b/pyomo/contrib/cp/transform/logical_to_disjunctive_walker.py
@@ -9,14 +9,10 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-import collections
-
from pyomo.common.collections import ComponentMap
from pyomo.common.errors import MouseTrap
from pyomo.core.expr.expr_common import ExpressionType
from pyomo.core.expr.visitor import StreamBasedExpressionVisitor
-from pyomo.core.expr.numeric_expr import NumericExpression
-from pyomo.core.expr.relational_expr import RelationalExpression
import pyomo.core.expr as EXPR
from pyomo.core.base import (
Binary,
@@ -27,9 +23,9 @@
value,
)
import pyomo.core.base.boolean_var as BV
-from pyomo.core.base.expression import ScalarExpression, _GeneralExpressionData
-from pyomo.core.base.param import ScalarParam, _ParamData
-from pyomo.core.base.var import ScalarVar, _GeneralVarData
+from pyomo.core.base.expression import ScalarExpression, ExpressionData
+from pyomo.core.base.param import ScalarParam, ParamData
+from pyomo.core.base.var import ScalarVar, VarData
from pyomo.gdp.disjunct import AutoLinkedBooleanVar, Disjunct, Disjunction
@@ -209,15 +205,15 @@ def _dispatch_atmost(visitor, node, *args):
_before_child_dispatcher = {}
_before_child_dispatcher[BV.ScalarBooleanVar] = _dispatch_boolean_var
-_before_child_dispatcher[BV._GeneralBooleanVarData] = _dispatch_boolean_var
+_before_child_dispatcher[BV.BooleanVarData] = _dispatch_boolean_var
_before_child_dispatcher[AutoLinkedBooleanVar] = _dispatch_boolean_var
-_before_child_dispatcher[_ParamData] = _dispatch_param
+_before_child_dispatcher[ParamData] = _dispatch_param
_before_child_dispatcher[ScalarParam] = _dispatch_param
# for the moment, these are all just so we can get good error messages when we
# don't handle them:
_before_child_dispatcher[ScalarVar] = _dispatch_var
-_before_child_dispatcher[_GeneralVarData] = _dispatch_var
-_before_child_dispatcher[_GeneralExpressionData] = _dispatch_expression
+_before_child_dispatcher[VarData] = _dispatch_var
+_before_child_dispatcher[ExpressionData] = _dispatch_expression
_before_child_dispatcher[ScalarExpression] = _dispatch_expression
diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index d2ba2f277d6..a120add4200 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -38,6 +38,11 @@
from pyomo.contrib.sensitivity_toolbox.sens import get_dsdp
from pyomo.contrib.doe.scenario import ScenarioGenerator, FiniteDifferenceStep
from pyomo.contrib.doe.result import FisherResults, GridSearchResult
+import collections.abc
+
+import inspect
+
+from pyomo.common import DeveloperError
class CalculationMode(Enum):
@@ -68,6 +73,8 @@ def __init__(
prior_FIM=None,
discretize_model=None,
args=None,
+ logger_level=logging.INFO,
+ only_compute_fim_lower=True,
):
"""
This package enables model-based design of experiments analysis with Pyomo.
@@ -98,20 +105,48 @@ def __init__(
A user-specified ``function`` that discretizes the model. Only use with Pyomo.DAE, default=None
args:
Additional arguments for the create_model function.
+ logger_level:
+ Specify the level of the logger. Change to logging.DEBUG for all messages.
+ only_compute_fim_lower:
+ If True, only the lower triangle of the FIM is computed. Default is True.
"""
# parameters
+ if not isinstance(param_init, collections.abc.Mapping):
+ raise ValueError("param_init should be a dictionary.")
self.param = param_init
# design variable name
self.design_name = design_vars.variable_names
self.design_vars = design_vars
self.create_model = create_model
+
+ # check if create model function conforms to the original
+ # Pyomo.DoE interface
+ model_option_arg = (
+ "model_option" in inspect.getfullargspec(self.create_model).args
+ )
+ mod_arg = "mod" in inspect.getfullargspec(self.create_model).args
+ if model_option_arg and mod_arg:
+ self._original_create_model_interface = True
+ else:
+ self._original_create_model_interface = False
+
+ if args is None:
+ args = {}
self.args = args
# create the measurement information object
self.measurement_vars = measurement_vars
self.measure_name = self.measurement_vars.variable_names
+ if (
+ self.measurement_vars.variable_names is None
+ or not self.measurement_vars.variable_names
+ ):
+ raise ValueError(
+ "There are no measurement variables. Check for a modeling mistake."
+ )
+
# check if user-defined solver is given
if solver:
self.solver = solver
@@ -131,17 +166,19 @@ def __init__(
# if print statements
self.logger = logging.getLogger(__name__)
- self.logger.setLevel(level=logging.INFO)
+ self.logger.setLevel(level=logger_level)
+
+ self.only_compute_fim_lower = only_compute_fim_lower
def _check_inputs(self):
"""
Check if the prior FIM is N*N matrix, where N is the number of parameter
"""
- if type(self.prior_FIM) != type(None):
+ if self.prior_FIM is not None:
if np.shape(self.prior_FIM)[0] != np.shape(self.prior_FIM)[1]:
- raise ValueError('Found wrong prior information matrix shape.')
+ raise ValueError("Found wrong prior information matrix shape.")
elif np.shape(self.prior_FIM)[0] != len(self.param):
- raise ValueError('Found wrong prior information matrix shape.')
+ raise ValueError("Found wrong prior information matrix shape.")
def stochastic_program(
self,
@@ -226,6 +263,7 @@ def stochastic_program(
# FIM = Jacobian.T@Jacobian, the FIM is scaled by squared value the Jacobian is scaled
self.fim_scale_constant_value = self.scale_constant_value**2
+ # Start timer
sp_timer = TicTocTimer()
sp_timer.tic(msg=None)
@@ -236,14 +274,17 @@ def stochastic_program(
m, analysis_square = self._compute_stochastic_program(m, optimize_opt)
if self.optimize:
+ # If set to optimize, solve the optimization problem (with degrees of freedom)
analysis_optimize = self._optimize_stochastic_program(m)
dT = sp_timer.toc(msg=None)
- self.logger.info("elapsed time: %0.1f" % dT)
+ self.logger.info("elapsed time: %0.1f seconds" % dT)
+ # Return both square problem and optimization problem results
return analysis_square, analysis_optimize
else:
dT = sp_timer.toc(msg=None)
- self.logger.info("elapsed time: %0.1f" % dT)
+ self.logger.info("elapsed time: %0.1f seconds" % dT)
+ # Return only square problem results
return analysis_square
def _compute_stochastic_program(self, m, optimize_option):
@@ -314,6 +355,7 @@ def compute_FIM(
extract_single_model=None,
formula="central",
step=0.001,
+ only_compute_fim_lower=False,
):
"""
This function calculates the Fisher information matrix (FIM) using sensitivity information obtained
@@ -387,7 +429,7 @@ def compute_FIM(
FIM_analysis = self._direct_kaug()
dT = square_timer.toc(msg=None)
- self.logger.info("elapsed time: %0.1f" % dT)
+ self.logger.info("elapsed time: %0.1f seconds" % dT)
return FIM_analysis
@@ -396,7 +438,7 @@ def _sequential_finite(self, read_output, extract_single_model, store_output):
# if measurements are provided
if read_output:
- with open(read_output, 'rb') as f:
+ with open(read_output, "rb") as f:
output_record = pickle.load(f)
f.close()
jac = self._finite_calculation(output_record)
@@ -408,11 +450,21 @@ def _sequential_finite(self, read_output, extract_single_model, store_output):
# dict for storing model outputs
output_record = {}
+ # Deactivate any existing objective functions
+ for obj in mod.component_objects(pyo.Objective):
+ obj.deactivate()
+
+ # add zero (dummy/placeholder) objective function
+ mod.Obj = pyo.Objective(expr=0, sense=pyo.minimize)
+
# solve model
square_result = self._solve_doe(mod, fix=True)
+ # save model from optional post processing function
+ self._square_model_from_compute_FIM = mod
+
if extract_single_model:
- mod_name = store_output + '.csv'
+ mod_name = store_output + ".csv"
dataframe = extract_single_model(mod, square_result)
dataframe.to_csv(mod_name)
@@ -434,10 +486,10 @@ def _sequential_finite(self, read_output, extract_single_model, store_output):
output_record[s] = output_iter
- output_record['design'] = self.design_values
+ output_record["design"] = self.design_values
if store_output:
- f = open(store_output, 'wb')
+ f = open(store_output, "wb")
pickle.dump(output_record, f)
f.close()
@@ -472,13 +524,20 @@ def _sequential_finite(self, read_output, extract_single_model, store_output):
def _direct_kaug(self):
# create model
- mod = self.create_model(model_option=ModelOptionLib.parmest)
+ if self._original_create_model_interface:
+ mod = self.create_model(model_option=ModelOptionLib.parmest, **self.args)
+ else:
+ mod = self.create_model(**self.args)
# discretize if needed
- if self.discretize_model:
+ if self.discretize_model is not None:
mod = self.discretize_model(mod, block=False)
- # add objective function
+ # Deactivate any existing objective functions
+ for obj in mod.component_objects(pyo.Objective):
+ obj.deactivate()
+
+ # add zero (dummy/placeholder) objective function
mod.Obj = pyo.Objective(expr=0, sense=pyo.minimize)
# set ub and lb to parameters
@@ -493,6 +552,10 @@ def _direct_kaug(self):
# call k_aug get_dsdp function
square_result = self._solve_doe(mod, fix=True)
+
+ # save model from optional post processing function
+ self._square_model_from_compute_FIM = mod
+
dsdp_re, col = get_dsdp(
mod, list(self.param.keys()), self.param, tee=self.tee_opt
)
@@ -515,7 +578,7 @@ def _direct_kaug(self):
dsdp_extract.append(dsdp_array[kaug_no])
except:
# k_aug does not provide value for fixed variables
- self.logger.debug('The variable is fixed: %s', mname)
+ self.logger.debug("The variable is fixed: %s", mname)
# produce the sensitivity for fixed variables
zero_sens = np.zeros(len(self.param))
# for fixed variables, the sensitivity are a zero vector
@@ -581,29 +644,93 @@ def _create_block(self):
self.eps_abs = self.scenario_data.eps_abs
self.scena_gen = scena_gen
- # Create a global model
- mod = pyo.ConcreteModel()
+ # Determine if create_model takes theta as an optional input
+ pass_theta_to_initialize = (
+ "theta" in inspect.getfullargspec(self.create_model).args
+ )
+
+ # Allow user to self-define complex design variables
+ if self._original_create_model_interface:
+
+ # Create a global model
+ mod = pyo.ConcreteModel()
+
+ if pass_theta_to_initialize:
+ # Add model on block with theta values
+ self.create_model(
+ mod=mod,
+ model_option=ModelOptionLib.stage1,
+ theta=self.param,
+ **self.args,
+ )
+ else:
+ # Add model on block without theta values
+ self.create_model(
+ mod=mod, model_option=ModelOptionLib.stage1, **self.args
+ )
+
+ else:
+ # Create a global model
+ mod = self.create_model(**self.args)
# Set for block/scenarios
mod.scenario = pyo.Set(initialize=self.scenario_data.scenario_indices)
- # Allow user to self-define complex design variables
- self.create_model(mod=mod, model_option=ModelOptionLib.stage1)
+ # Fix parameter values in the copy of the stage1 model (if they exist)
+ for par in self.param:
+ cuid = pyo.ComponentUID(par)
+ var = cuid.find_component_on(mod)
+ if var is not None:
+ # Fix the parameter value
+ # Otherwise, the parameter does not exist on the stage 1 model
+ var.fix(self.param[par])
def block_build(b, s):
# create block scenarios
- self.create_model(mod=b, model_option=ModelOptionLib.stage2)
+ # idea: check if create_model takes theta as an optional input, if so, pass parameter values to create_model
+
+ if self._original_create_model_interface:
+ if pass_theta_to_initialize:
+ # Grab the values of theta for this scenario/block
+ theta_initialize = self.scenario_data.scenario[s]
+ # Add model on block with theta values
+ self.create_model(
+ mod=b,
+ model_option=ModelOptionLib.stage2,
+ theta=theta_initialize,
+ **self.args,
+ )
+ else:
+ # Otherwise add model on block without theta values
+ self.create_model(
+ mod=b, model_option=ModelOptionLib.stage2, **self.args
+ )
+
+ # save block in a temporary variable
+ mod_ = b
+ else:
+ # Add model on block
+ if pass_theta_to_initialize:
+ # Grab the values of theta for this scenario/block
+ theta_initialize = self.scenario_data.scenario[s]
+ mod_ = self.create_model(theta=theta_initialize, **self.args)
+ else:
+ mod_ = self.create_model(**self.args)
# fix parameter values to perturbed values
for par in self.param:
cuid = pyo.ComponentUID(par)
- var = cuid.find_component_on(b)
+ var = cuid.find_component_on(mod_)
var.fix(self.scenario_data.scenario[s][par])
+ if not self._original_create_model_interface:
+ # for the "new"/"slim" interface, we need to add the block to the model
+ return mod_
+
mod.block = pyo.Block(mod.scenario, rule=block_build)
# discretize the model
- if self.discretize_model:
+ if self.discretize_model is not None:
mod = self.discretize_model(mod)
# force design variables in blocks to be equal to global design values
@@ -618,6 +745,13 @@ def fix1(mod, s):
con_name = "con" + name
mod.add_component(con_name, pyo.Constraint(mod.scenario, expr=fix1))
+ # Add user-defined design variable bounds
+ cuid = pyo.ComponentUID(name)
+ design_var_global = cuid.find_component_on(mod)
+ # Set the lower and upper bounds of the design variables
+ design_var_global.setlb(self.design_vars.lower_bounds[name])
+ design_var_global.setub(self.design_vars.upper_bounds[name])
+
return mod
def _finite_calculation(self, output_record):
@@ -693,6 +827,7 @@ def run_grid_search(
store_optimality_as_csv=None,
formula="central",
step=0.001,
+ post_processing_function=None,
):
"""
Enumerate through full grid search for any number of design variables;
@@ -734,6 +869,10 @@ def run_grid_search(
This option is only used for CalculationMode.sequential_finite.
step:
Sensitivity perturbation step size, a fraction between [0,1]. default is 0.001
+ post_processing_function:
+ An optional function that executes after each solve of the grid search.
+ The function should take one input: the Pyomo model. This could be a plotting function.
+ Default is None.
Returns
-------
@@ -772,20 +911,31 @@ def run_grid_search(
# generate the design variable dictionary needed for running compute_FIM
# first copy value from design_values
design_iter = self.design_vars.variable_names_value.copy()
+
+ # convert to a list and cache
+ list_design_set_iter = list(design_set_iter)
+
# update the controlled value of certain time points for certain design variables
for i, names in enumerate(design_dimension_names):
- # if the element is a list, all design variables in this list share the same values
- if type(names) is list or type(names) is tuple:
+ if isinstance(names, str):
+ # if 'names' is simply a string, copy the new value
+ design_iter[names] = list_design_set_iter[i]
+ elif isinstance(names, collections.abc.Sequence):
+ # if the element is a list, all design variables in this list share the same values
for n in names:
- design_iter[n] = list(design_set_iter)[i]
+ design_iter[n] = list_design_set_iter[i]
else:
- design_iter[names] = list(design_set_iter)[i]
+ # otherwise just copy the value
+ # design_iter[names] = list(design_set_iter)[i]
+ raise NotImplementedError(
+ "You should not see this error message. Please report it to the Pyomo.DoE developers."
+ )
self.design_vars.variable_names_value = design_iter
iter_timer = TicTocTimer()
- self.logger.info('=======Iteration Number: %s =====', count + 1)
+ self.logger.info("=======Iteration Number: %s =====", count + 1)
self.logger.debug(
- 'Design variable values of this iteration: %s', design_iter
+ "Design variable values of this iteration: %s", design_iter
)
iter_timer.tic(msg=None)
# generate store name
@@ -794,7 +944,7 @@ def run_grid_search(
else:
store_output_name = store_name + str(count)
- if read_name:
+ if read_name is not None:
read_input_name = read_name + str(count)
else:
read_input_name = None
@@ -821,23 +971,31 @@ def run_grid_search(
time_set.append(iter_t)
# give run information at each iteration
- self.logger.info('This is run %s out of %s.', count, total_count)
- self.logger.info('The code has run %s seconds.', sum(time_set))
+ self.logger.info("This is run %s out of %s.", count, total_count)
self.logger.info(
- 'Estimated remaining time: %s seconds',
- (sum(time_set) / (count + 1) * (total_count - count - 1)),
+ "The code has run %s seconds.", round(sum(time_set), 2)
)
+ self.logger.info(
+ "Estimated remaining time: %s seconds",
+ round(
+ sum(time_set) / (count) * (total_count - count), 2
+ ), # need to check this math... it gives a negative number for the final count
+ )
+
+ if post_processing_function is not None:
+ # Call the post processing function
+ post_processing_function(self._square_model_from_compute_FIM)
# the combined result object are organized as a dictionary, keys are a tuple of the design variable values, values are a result object
result_combine[tuple(design_set_iter)] = result_iter
except:
self.logger.warning(
- ':::::::::::Warning: Cannot converge this run.::::::::::::'
+ ":::::::::::Warning: Cannot converge this run.::::::::::::"
)
count += 1
failed_count += 1
- self.logger.warning('failed count:', failed_count)
+ self.logger.warning("failed count:", failed_count)
result_combine[tuple(design_set_iter)] = None
# For user's access
@@ -851,7 +1009,7 @@ def run_grid_search(
store_optimality_name=store_optimality_as_csv,
)
- self.logger.info('Overall wall clock time [s]: %s', sum(time_set))
+ self.logger.info("Overall wall clock time [s]: %s", sum(time_set))
return figure_draw_object
@@ -867,6 +1025,18 @@ def _create_doe_model(self, no_obj=True):
-------
model: the DOE model
"""
+
+ # Developer recommendation: use the Cholesky decomposition for D-optimality
+ # The explicit formula is available for benchmarking purposes and is NOT recommended
+ if (
+ self.only_compute_fim_lower
+ and self.objective_option == ObjectiveLib.det
+ and not self.Cholesky_option
+ ):
+ raise ValueError(
+ "Cannot compute determinant with explicit formula if only_compute_fim_lower is True."
+ )
+
model = self._create_block()
# variables for jacobian and FIM
@@ -879,20 +1049,46 @@ def identity_matrix(m, i, j):
else:
return 0
+ ### Initialize the Jacobian if provided by the user
+
+ # If the user provides an initial Jacobian, convert it to a dictionary
+ if self.jac_initial is not None:
+ dict_jac_initialize = {}
+ for i, bu in enumerate(model.regression_parameters):
+ for j, un in enumerate(model.measured_variables):
+ if isinstance(self.jac_initial, dict):
+ # Jacobian is a dictionary of arrays or lists where the key is the regression parameter name
+ dict_jac_initialize[(bu, un)] = self.jac_initial[bu][j]
+ elif isinstance(self.jac_initial, np.ndarray):
+ # Jacobian is a numpy array, rows are regression parameters, columns are measured variables
+ dict_jac_initialize[(bu, un)] = self.jac_initial[i][j]
+
+ # Initialize the Jacobian matrix
+ def initialize_jac(m, i, j):
+ # If provided by the user, use the values now stored in the dictionary
+ if self.jac_initial is not None:
+ return dict_jac_initialize[(i, j)]
+ # Otherwise initialize to 0.1 (which is an arbitrary non-zero value)
+ else:
+ return 0.1
+
model.sensitivity_jacobian = pyo.Var(
- model.regression_parameters, model.measured_variables, initialize=0.1
+ model.regression_parameters,
+ model.measured_variables,
+ initialize=initialize_jac,
)
- if self.fim_initial:
- dict_fim_initialize = {}
- for i, bu in enumerate(model.regression_parameters):
- for j, un in enumerate(model.regression_parameters):
- dict_fim_initialize[(bu, un)] = self.fim_initial[i][j]
+ if self.fim_initial is not None:
+ dict_fim_initialize = {
+ (bu, un): self.fim_initial[i][j]
+ for i, bu in enumerate(model.regression_parameters)
+ for j, un in enumerate(model.regression_parameters)
+ }
def initialize_fim(m, j, d):
return dict_fim_initialize[(j, d)]
- if self.fim_initial:
+ if self.fim_initial is not None:
model.fim = pyo.Var(
model.regression_parameters,
model.regression_parameters,
@@ -905,22 +1101,24 @@ def initialize_fim(m, j, d):
initialize=identity_matrix,
)
- # move the L matrix initial point to a dictionary
- if type(self.L_initial) != type(None):
- dict_cho = {}
- for i, bu in enumerate(model.regression_parameters):
- for j, un in enumerate(model.regression_parameters):
- dict_cho[(bu, un)] = self.L_initial[i][j]
+ # if cholesky, define L elements as variables
+ if self.Cholesky_option and self.objective_option == ObjectiveLib.det:
- # use the L dictionary to initialize L matrix
- def init_cho(m, i, j):
- return dict_cho[(i, j)]
+ # move the L matrix initial point to a dictionary
+ if self.L_initial is not None:
+ dict_cho = {
+ (bu, un): self.L_initial[i][j]
+ for i, bu in enumerate(model.regression_parameters)
+ for j, un in enumerate(model.regression_parameters)
+ }
+
+ # use the L dictionary to initialize L matrix
+ def init_cho(m, i, j):
+ return dict_cho[(i, j)]
- # if cholesky, define L elements as variables
- if self.Cholesky_option:
# Define elements of Cholesky decomposition matrix as Pyomo variables and either
# Initialize with L in L_initial
- if type(self.L_initial) != type(None):
+ if self.L_initial is not None:
model.L_ele = pyo.Var(
model.regression_parameters,
model.regression_parameters,
@@ -971,10 +1169,11 @@ def jacobian_rule(m, p, n):
# A constraint to calculate elements in Hessian matrix
# transfer prior FIM to be Expressions
- fim_initial_dict = {}
- for i, bu in enumerate(model.regression_parameters):
- for j, un in enumerate(model.regression_parameters):
- fim_initial_dict[(bu, un)] = self.prior_FIM[i][j]
+ fim_initial_dict = {
+ (bu, un): self.prior_FIM[i][j]
+ for i, bu in enumerate(model.regression_parameters)
+ for j, un in enumerate(model.regression_parameters)
+ }
def read_prior(m, i, j):
return fim_initial_dict[(i, j)]
@@ -983,23 +1182,31 @@ def read_prior(m, i, j):
model.regression_parameters, model.regression_parameters, rule=read_prior
)
+ # The off-diagonal elements are symmetric, thus only half of the elements need to be calculated
def fim_rule(m, p, q):
"""
m: Pyomo model
p: parameter
q: parameter
"""
- return (
- m.fim[p, q]
- == sum(
- 1
- / self.measurement_vars.variance[n]
- * m.sensitivity_jacobian[p, n]
- * m.sensitivity_jacobian[q, n]
- for n in model.measured_variables
+
+ if p > q:
+ if self.only_compute_fim_lower:
+ return pyo.Constraint.Skip
+ else:
+ return m.fim[p, q] == m.fim[q, p]
+ else:
+ return (
+ m.fim[p, q]
+ == sum(
+ 1
+ / self.measurement_vars.variance[n]
+ * m.sensitivity_jacobian[p, n]
+ * m.sensitivity_jacobian[q, n]
+ for n in model.measured_variables
+ )
+ + m.priorFIM[p, q] * self.fim_scale_constant_value
)
- + m.priorFIM[p, q] * self.fim_scale_constant_value
- )
model.jacobian_constraint = pyo.Constraint(
model.regression_parameters, model.measured_variables, rule=jacobian_rule
@@ -1008,9 +1215,55 @@ def fim_rule(m, p, q):
model.regression_parameters, model.regression_parameters, rule=fim_rule
)
+ if self.only_compute_fim_lower:
+ # Fix the upper half of the FIM matrix elements to be 0.0.
+ # This eliminates extra variables and ensures the expected number of
+ # degrees of freedom in the optimization problem.
+ for p in model.regression_parameters:
+ for q in model.regression_parameters:
+ if p > q:
+ model.fim[p, q].fix(0.0)
+
return model
def _add_objective(self, m):
+
+ small_number = 1e-10
+
+ # Assemble the FIM matrix. This is helpful for initialization!
+ #
+ # Suggestion from JS: "It might be more efficient to form the NP array in one shot
+ # (from a list or using fromiter), and then reshaping to the 2-D matrix"
+ #
+ fim = np.zeros((len(self.param), len(self.param)))
+ for i, bu in enumerate(m.regression_parameters):
+ for j, un in enumerate(m.regression_parameters):
+ # Copy value from Pyomo model into numpy array
+ fim[i][j] = m.fim[bu, un].value
+
+ # Set lower bound to ensure diagonal elements are (almost) non-negative
+ # if i == j:
+ # m.fim[bu, un].setlb(-small_number)
+
+ ### Initialize the Cholesky decomposition matrix
+ if self.Cholesky_option and self.objective_option == ObjectiveLib.det:
+
+ # Calculate the eigenvalues of the FIM matrix
+ eig = np.linalg.eigvals(fim)
+
+ # If the smallest eigenvalue is (practically) negative, add a diagonal matrix to make it positive definite
+ small_number = 1e-10
+ if min(eig) < small_number:
+ fim = fim + np.eye(len(self.param)) * (small_number - min(eig))
+
+ # Compute the Cholesky decomposition of the FIM matrix
+ L = np.linalg.cholesky(fim)
+
+ # Initialize the Cholesky matrix
+ for i, c in enumerate(m.regression_parameters):
+ for j, d in enumerate(m.regression_parameters):
+ m.L_ele[c, d].value = L[i, j]
+
def cholesky_imp(m, c, d):
"""
Calculate Cholesky L matrix using algebraic constraints
@@ -1034,7 +1287,7 @@ def trace_calc(m):
def det_general(m):
r"""Calculate determinant. Can be applied to FIM of any size.
- det(A) = sum_{\sigma \in \S_n} (sgn(\sigma) * \Prod_{i=1}^n a_{i,\sigma_i})
+ det(A) = \sum_{\sigma in \S_n} (sgn(\sigma) * \Prod_{i=1}^n a_{i,\sigma_i})
Use permutation() to get permutations, sgn() to get signature
"""
r_list = list(range(len(m.regression_parameters)))
@@ -1064,24 +1317,36 @@ def det_general(m):
)
return m.det == det_perm
- if self.Cholesky_option:
+ if self.Cholesky_option and self.objective_option == ObjectiveLib.det:
m.cholesky_cons = pyo.Constraint(
m.regression_parameters, m.regression_parameters, rule=cholesky_imp
)
m.Obj = pyo.Objective(
- expr=2 * sum(pyo.log(m.L_ele[j, j]) for j in m.regression_parameters),
+ expr=2 * sum(pyo.log10(m.L_ele[j, j]) for j in m.regression_parameters),
sense=pyo.maximize,
)
- # if not cholesky but determinant, calculating det and evaluate the OBJ with det
+
elif self.objective_option == ObjectiveLib.det:
+ # if not cholesky but determinant, calculating det and evaluate the OBJ with det
+ m.det = pyo.Var(initialize=np.linalg.det(fim), bounds=(small_number, None))
m.det_rule = pyo.Constraint(rule=det_general)
- m.Obj = pyo.Objective(expr=pyo.log(m.det), sense=pyo.maximize)
- # if not determinant or cholesky, calculating the OBJ with trace
+ m.Obj = pyo.Objective(expr=pyo.log10(m.det), sense=pyo.maximize)
+
elif self.objective_option == ObjectiveLib.trace:
+ # if not determinant or cholesky, calculating the OBJ with trace
+ m.trace = pyo.Var(initialize=np.trace(fim), bounds=(small_number, None))
m.trace_rule = pyo.Constraint(rule=trace_calc)
- m.Obj = pyo.Objective(expr=pyo.log(m.trace), sense=pyo.maximize)
+ m.Obj = pyo.Objective(expr=pyo.log10(m.trace), sense=pyo.maximize)
+ # m.Obj = pyo.Objective(expr=m.trace, sense=pyo.maximize)
+
elif self.objective_option == ObjectiveLib.zero:
+ # add dummy objective function
m.Obj = pyo.Objective(expr=0)
+ else:
+ # something went wrong!
+ raise DeveloperError(
+ "Objective option not recognized. Please contact the developers as you should not see this error."
+ )
return m
@@ -1101,30 +1366,36 @@ def _fix_design(self, m, design_val, fix_opt=True, optimize_option=None):
m: model
"""
for name in self.design_name:
+ # Loop over design variables
+ # Get Pyomo variable object
cuid = pyo.ComponentUID(name)
var = cuid.find_component_on(m)
if fix_opt:
+ # If fix_opt is True, fix the design variable
var.fix(design_val[name])
else:
+ # Otherwise check optimize_option
if optimize_option is None:
+ # If optimize_option is None, unfix all design variables
var.unfix()
else:
+ # Otherwise, unfix only the design variables listed in optimize_option with value True
if optimize_option[name]:
var.unfix()
return m
def _get_default_ipopt_solver(self):
"""Default solver"""
- solver = SolverFactory('ipopt')
- solver.options['linear_solver'] = 'ma57'
- solver.options['halt_on_ampl_error'] = 'yes'
- solver.options['max_iter'] = 3000
+ solver = SolverFactory("ipopt")
+ solver.options["linear_solver"] = "ma57"
+ solver.options["halt_on_ampl_error"] = "yes"
+ solver.options["max_iter"] = 3000
return solver
def _solve_doe(self, m, fix=False, opt_option=None):
"""Solve DOE model.
If it's a square problem, fix design variable and solve.
- Else, fix design variable and solve square problem firstly, then unfix them and solve the optimization problem
+ Else, fix design variable and solve square problem first, then unfix them and solve the optimization problem
Parameters
----------
@@ -1138,7 +1409,10 @@ def _solve_doe(self, m, fix=False, opt_option=None):
-------
solver_results: solver results
"""
- ### Solve square problem
+ # if fix = False, solve the optimization problem
+ # if fix = True, solve the square problem
+
+ # either fix or unfix the design variables
mod = self._fix_design(
m, self.design_values, fix_opt=fix, optimize_option=opt_option
)
diff --git a/pyomo/contrib/doe/examples/fim_doe_tutorial.ipynb b/pyomo/contrib/doe/examples/fim_doe_tutorial.ipynb
index 12d5a610db4..36ec42fbe49 100644
--- a/pyomo/contrib/doe/examples/fim_doe_tutorial.ipynb
+++ b/pyomo/contrib/doe/examples/fim_doe_tutorial.ipynb
@@ -87,6 +87,7 @@
"if \"google.colab\" in sys.modules:\n",
" !wget \"https://raw.githubusercontent.com/IDAES/idaes-pse/main/scripts/colab_helper.py\"\n",
" import colab_helper\n",
+ "\n",
" colab_helper.install_idaes()\n",
" colab_helper.install_ipopt()\n",
"\n",
diff --git a/pyomo/contrib/doe/examples/reactor_design.py b/pyomo/contrib/doe/examples/reactor_design.py
new file mode 100644
index 00000000000..67d6ff02fd2
--- /dev/null
+++ b/pyomo/contrib/doe/examples/reactor_design.py
@@ -0,0 +1,236 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+#
+# Pyomo.DoE was produced under the Department of Energy Carbon Capture Simulation
+# Initiative (CCSI), and is copyright (c) 2022 by the software owners:
+# TRIAD National Security, LLC., Lawrence Livermore National Security, LLC.,
+# Lawrence Berkeley National Laboratory, Pacific Northwest National Laboratory,
+# Battelle Memorial Institute, University of Notre Dame,
+# The University of Pittsburgh, The University of Texas at Austin,
+# University of Toledo, West Virginia University, et al. All rights reserved.
+#
+# NOTICE. This Software was developed under funding from the
+# U.S. Department of Energy and the U.S. Government consequently retains
+# certain rights. As such, the U.S. Government has been granted for itself
+# and others acting on its behalf a paid-up, nonexclusive, irrevocable,
+# worldwide license in the Software to reproduce, distribute copies to the
+# public, prepare derivative works, and perform publicly and display
+# publicly, and to permit other to do so.
+# ___________________________________________________________________________
+
+# from pyomo.contrib.parmest.examples.reactor_design import reactor_design_model
+# if we refactor to use the same create_model function as parmest,
+# we can just import instead of redefining the model
+
+import pyomo.environ as pyo
+from pyomo.dae import ContinuousSet, DerivativeVar
+from pyomo.contrib.doe import (
+ ModelOptionLib,
+ DesignOfExperiments,
+ MeasurementVariables,
+ DesignVariables,
+)
+from pyomo.common.dependencies import numpy as np
+
+
+def create_model_legacy(mod=None, model_option=None):
+ model_option = ModelOptionLib(model_option)
+
+ model = mod
+
+ if model_option == ModelOptionLib.parmest:
+ model = pyo.ConcreteModel()
+ return_m = True
+ elif model_option == ModelOptionLib.stage1 or model_option == ModelOptionLib.stage2:
+ if model is None:
+ raise ValueError(
+ "If model option is stage1 or stage2, a created model needs to be provided."
+ )
+ return_m = False
+ else:
+ raise ValueError(
+ "model_option needs to be defined as parmest, stage1, or stage2."
+ )
+
+ model = _create_model_details(model)
+
+ if return_m:
+ return model
+
+
+def create_model():
+ model = pyo.ConcreteModel()
+ return _create_model_details(model)
+
+
+def _create_model_details(model):
+
+ # Rate constants
+ model.k1 = pyo.Var(initialize=5.0 / 6.0, within=pyo.PositiveReals) # min^-1
+ model.k2 = pyo.Var(initialize=5.0 / 3.0, within=pyo.PositiveReals) # min^-1
+ model.k3 = pyo.Var(
+ initialize=1.0 / 6000.0, within=pyo.PositiveReals
+ ) # m^3/(gmol min)
+
+ # Inlet concentration of A, gmol/m^3
+ model.caf = pyo.Var(initialize=10000, within=pyo.PositiveReals)
+
+ # Space velocity (flowrate/volume)
+ model.sv = pyo.Var(initialize=1.0, within=pyo.PositiveReals)
+
+ # Outlet concentration of each component
+ model.ca = pyo.Var(initialize=5000.0, within=pyo.PositiveReals)
+ model.cb = pyo.Var(initialize=2000.0, within=pyo.PositiveReals)
+ model.cc = pyo.Var(initialize=2000.0, within=pyo.PositiveReals)
+ model.cd = pyo.Var(initialize=1000.0, within=pyo.PositiveReals)
+
+ # Constraints
+ model.ca_bal = pyo.Constraint(
+ expr=(
+ 0
+ == model.sv * model.caf
+ - model.sv * model.ca
+ - model.k1 * model.ca
+ - 2.0 * model.k3 * model.ca**2.0
+ )
+ )
+
+ model.cb_bal = pyo.Constraint(
+ expr=(0 == -model.sv * model.cb + model.k1 * model.ca - model.k2 * model.cb)
+ )
+
+ model.cc_bal = pyo.Constraint(
+ expr=(0 == -model.sv * model.cc + model.k2 * model.cb)
+ )
+
+ model.cd_bal = pyo.Constraint(
+ expr=(0 == -model.sv * model.cd + model.k3 * model.ca**2.0)
+ )
+
+ return model
+
+
+def main(legacy_create_model_interface=False):
+
+ # measurement object
+ measurements = MeasurementVariables()
+ measurements.add_variables("ca", indices=None, time_index_position=None)
+ measurements.add_variables("cb", indices=None, time_index_position=None)
+ measurements.add_variables("cc", indices=None, time_index_position=None)
+ measurements.add_variables("cd", indices=None, time_index_position=None)
+
+ # design object
+ exp_design = DesignVariables()
+ exp_design.add_variables(
+ "sv",
+ indices=None,
+ time_index_position=None,
+ values=1.0,
+ lower_bounds=0.1,
+ upper_bounds=10.0,
+ )
+ exp_design.add_variables(
+ "caf",
+ indices=None,
+ time_index_position=None,
+ values=10000,
+ lower_bounds=5000,
+ upper_bounds=15000,
+ )
+
+ theta_values = {"k1": 5.0 / 6.0, "k2": 5.0 / 3.0, "k3": 1.0 / 6000.0}
+
+ if legacy_create_model_interface:
+ create_model_ = create_model_legacy
+ else:
+ create_model_ = create_model
+
+ doe1 = DesignOfExperiments(
+ theta_values, exp_design, measurements, create_model_, prior_FIM=None
+ )
+
+ result = doe1.compute_FIM(
+ mode="sequential_finite", # calculation mode
+ scale_nominal_param_value=True, # scale nominal parameter value
+ formula="central", # formula for finite difference
+ )
+
+ # doe1.model.pprint()
+
+ result.result_analysis()
+
+ # print("FIM =\n",result.FIM)
+ # print("jac =\n",result.jaco_information)
+ # print("log10 Trace of FIM: ", np.log10(result.trace))
+ # print("log10 Determinant of FIM: ", np.log10(result.det))
+
+ # test result
+ expected_log10_trace = 6.815
+ log10_trace = np.log10(result.trace)
+ relative_error_trace = abs(log10_trace - 6.815)
+ assert relative_error_trace < 0.01, (
+ "log10(tr(FIM)) regression test failed, answer "
+ + str(round(log10_trace, 3))
+ + " does not match expected answer of "
+ + str(expected_log10_trace)
+ )
+
+ expected_log10_det = 18.719
+ log10_det = np.log10(result.det)
+ relative_error_det = abs(log10_det - 18.719)
+ assert relative_error_det < 0.01, (
+ "log10(det(FIM)) regression test failed, answer "
+ + str(round(log10_det, 3))
+ + " does not match expected answer of "
+ + str(expected_log10_det)
+ )
+
+ doe2 = DesignOfExperiments(
+ theta_values, exp_design, measurements, create_model_, prior_FIM=None
+ )
+
+ square_result2, optimize_result2 = doe2.stochastic_program(
+ if_optimize=True,
+ if_Cholesky=True,
+ scale_nominal_param_value=True,
+ objective_option="det",
+ jac_initial=result.jaco_information.copy(),
+ step=0.1,
+ )
+
+ optimize_result2.result_analysis()
+ log_det = np.log10(optimize_result2.det)
+ print("log(det) = ", round(log_det, 3))
+ log_det_expected = 19.266
+ assert abs(log_det - log_det_expected) < 0.01, "log(det) regression test failed"
+
+ doe3 = DesignOfExperiments(
+ theta_values, exp_design, measurements, create_model_, prior_FIM=None
+ )
+
+ square_result3, optimize_result3 = doe3.stochastic_program(
+ if_optimize=True,
+ scale_nominal_param_value=True,
+ objective_option="trace",
+ jac_initial=result.jaco_information.copy(),
+ step=0.1,
+ )
+
+ optimize_result3.result_analysis()
+ log_trace = np.log10(optimize_result3.trace)
+ log_trace_expected = 7.509
+ print("log(trace) = ", round(log_trace, 3))
+ assert (
+ abs(log_trace - log_trace_expected) < 0.01
+ ), "log(trace) regression test failed"
+
+
+if __name__ == "__main__":
+ main(legacy_create_model_interface=False)
diff --git a/pyomo/contrib/doe/measurements.py b/pyomo/contrib/doe/measurements.py
index 5a3c44a76e4..31a9dc19dbb 100644
--- a/pyomo/contrib/doe/measurements.py
+++ b/pyomo/contrib/doe/measurements.py
@@ -26,6 +26,8 @@
# ___________________________________________________________________________
import itertools
+import collections.abc
+from pyomo.common.numeric_types import native_numeric_types
class VariablesWithIndices:
@@ -93,18 +95,22 @@ def add_variables(
upper_bounds,
)
- if values:
+ if values is not None:
+ # if a scalar (int or float) is given, set it as the value for all variables
+ if type(values) in native_numeric_types:
+ values = [values] * len(added_names)
# this dictionary keys are special set, values are its value
self.variable_names_value.update(zip(added_names, values))
- # if a scalar (int or float) is given, set it as the lower bound for all variables
- if lower_bounds:
- if type(lower_bounds) in [int, float]:
+ if lower_bounds is not None:
+ # if a scalar (int or float) is given, set it as the lower bound for all variables
+ if type(lower_bounds) in native_numeric_types:
lower_bounds = [lower_bounds] * len(added_names)
self.lower_bounds.update(zip(added_names, lower_bounds))
- if upper_bounds:
- if type(upper_bounds) in [int, float]:
+ if upper_bounds is not None:
+ # if a scalar (int or float) is given, set it as the upper bound for all variables
+ if type(upper_bounds) in native_numeric_types:
upper_bounds = [upper_bounds] * len(added_names)
self.upper_bounds.update(zip(added_names, upper_bounds))
@@ -127,7 +133,7 @@ def _generate_variable_names_with_indices(
"""
# first combine all indices into a list
all_index_list = [] # contains all index lists
- if indices:
+ if indices is not None:
for index_pointer in indices:
all_index_list.append(indices[index_pointer])
@@ -141,8 +147,14 @@ def _generate_variable_names_with_indices(
added_names = []
# iterate over index combinations ["CA", 1], ["CA", 2], ..., ["CC", 2], ["CC", 3]
for index_instance in all_variable_indices:
- var_name_index_string = var_name + "["
+ var_name_index_string = var_name
+ #
+ # Suggestion from JS: "Can you re-use name_repr and index_repr from pyomo.core.base.component_namer here?"
+ #
for i, idx in enumerate(index_instance):
+ # if i is the first index, open the []
+ if i == 0:
+ var_name_index_string += "["
# use repr() is different from using str()
# with repr(), "CA" is "CA", with str(), "CA" is CA. The first is not valid in our interface.
var_name_index_string += str(idx)
@@ -171,28 +183,45 @@ def _check_valid_input(
"""
Check if the measurement information provided are valid to use.
"""
- assert type(var_name) is str, "var_name should be a string."
+ if not isinstance(var_name, str):
+ raise TypeError("Variable name must be a string.")
- if time_index_position not in indices:
+ # debugging note: what is an integer versus a list versus a dictionary here?
+ # check if time_index_position is in indices
+ if (
+ indices is not None # ensure not None
+ and time_index_position is not None # ensure not None
+ and time_index_position
+ not in indices.keys() # ensure time_index_position is in indices
+ ):
raise ValueError("time index cannot be found in indices.")
- # if given a list, check if bounds have the same length with flattened variable
- if values and len(values) != len_indices:
+ # if given a list, check if values have the same length with flattened variable
+ if (
+ values is not None # ensure not None
+ and not type(values)
+ in native_numeric_types # skip this test if scalar (int or float)
+ and len(values) != len_indices
+ ):
raise ValueError("Values is of different length with indices.")
if (
- lower_bounds
- and type(lower_bounds) == list
- and len(lower_bounds) != len_indices
+ lower_bounds is not None # ensure not None
+ and not type(lower_bounds)
+ in native_numeric_types # skip this test if scalar (int or float)
+ and isinstance(lower_bounds, collections.abc.Sequence) # ensure list-like
+ and len(lower_bounds) != len_indices # ensure same length
):
- raise ValueError("Lowerbounds is of different length with indices.")
+ raise ValueError("Lowerbounds have a different length with indices.")
if (
- upper_bounds
- and type(upper_bounds) == list
- and len(upper_bounds) != len_indices
+ upper_bounds is not None # ensure not None
+ and not type(upper_bounds)
+ in native_numeric_types # skip this test if scalar (int or float)
+ and isinstance(upper_bounds, collections.abc.Sequence) # ensure list-like
+ and len(upper_bounds) != len_indices # ensure same length
):
- raise ValueError("Upperbounds is of different length with indices.")
+ raise ValueError("Upperbounds have a different length with indices.")
class MeasurementVariables(VariablesWithIndices):
diff --git a/pyomo/contrib/doe/result.py b/pyomo/contrib/doe/result.py
index 1593214c30a..f7145ae2a46 100644
--- a/pyomo/contrib/doe/result.py
+++ b/pyomo/contrib/doe/result.py
@@ -123,9 +123,9 @@ def result_analysis(self, result=None):
if self.prior_FIM is not None:
try:
fim = fim + self.prior_FIM
- self.logger.info('Existed information has been added.')
+ self.logger.info("Existed information has been added.")
except:
- raise ValueError('Check the shape of prior FIM.')
+ raise ValueError("Check the shape of prior FIM.")
if np.linalg.cond(fim) > self.max_condition_number:
self.logger.info(
@@ -133,7 +133,7 @@ def result_analysis(self, result=None):
np.linalg.cond(fim),
)
self.logger.info(
- 'A condition number bigger than %s is considered near singular.',
+ "A condition number bigger than %s is considered near singular.",
self.max_condition_number,
)
@@ -239,10 +239,10 @@ def _print_FIM_info(self, FIM):
self.eig_vecs = np.linalg.eig(FIM)[1]
self.logger.info(
- 'FIM: %s; \n Trace: %s; \n Determinant: %s;', self.FIM, self.trace, self.det
+ "FIM: %s; \n Trace: %s; \n Determinant: %s;", self.FIM, self.trace, self.det
)
self.logger.info(
- 'Condition number: %s; \n Min eigenvalue: %s.', self.cond, self.min_eig
+ "Condition number: %s; \n Min eigenvalue: %s.", self.cond, self.min_eig
)
def _solution_info(self, m, dv_set):
@@ -268,11 +268,11 @@ def _solution_info(self, m, dv_set):
# When scaled with constant values, the effect of the scaling factors are removed here
# For determinant, the scaling factor to determinant is scaling factor ** (Dim of FIM)
# For trace, the scaling factor to trace is the scaling factor.
- if self.obj == 'det':
+ if self.obj == "det":
self.obj_det = np.exp(value(m.obj)) / (self.fim_scale_constant_value) ** (
len(self.parameter_names)
)
- elif self.obj == 'trace':
+ elif self.obj == "trace":
self.obj_trace = np.exp(value(m.obj)) / (self.fim_scale_constant_value)
design_variable_names = list(dv_set.keys())
@@ -314,11 +314,11 @@ def _get_solver_info(self):
if (self.result.solver.status == SolverStatus.ok) and (
self.result.solver.termination_condition == TerminationCondition.optimal
):
- self.status = 'converged'
+ self.status = "converged"
elif (
self.result.solver.termination_condition == TerminationCondition.infeasible
):
- self.status = 'infeasible'
+ self.status = "infeasible"
else:
self.status = self.result.solver.status
@@ -399,10 +399,10 @@ def extract_criteria(self):
column_names.append(i)
# Each design criteria has a column to store values
- column_names.append('A')
- column_names.append('D')
- column_names.append('E')
- column_names.append('ME')
+ column_names.append("A")
+ column_names.append("D")
+ column_names.append("E")
+ column_names.append("ME")
# generate the dataframe
store_all_results = np.asarray(store_all_results)
self.store_all_results_dataframe = pd.DataFrame(
@@ -458,7 +458,7 @@ def figure_drawing(
self.design_names
):
raise ValueError(
- 'Error: All dimensions except for those the figures are drawn by should be fixed.'
+ "Error: All dimensions except for those the figures are drawn by should be fixed."
)
if len(self.sensitivity_dimension) not in [1, 2]:
@@ -467,15 +467,15 @@ def figure_drawing(
# generate a combination of logic sentences to filter the results of the DOF needed.
# an example filter: (self.store_all_results_dataframe["CA0"]==5).
if len(self.fixed_design_names) != 0:
- filter = ''
+ filter = ""
for i in range(len(self.fixed_design_names)):
- filter += '(self.store_all_results_dataframe['
+ filter += "(self.store_all_results_dataframe["
filter += str(self.fixed_design_names[i])
- filter += ']=='
+ filter += "]=="
filter += str(self.fixed_design_values[i])
- filter += ')'
+ filter += ")"
if i != (len(self.fixed_design_names) - 1):
- filter += '&'
+ filter += "&"
# extract results with other dimensions fixed
figure_result_data = self.store_all_results_dataframe.loc[eval(filter)]
# if there is no other fixed dimensions
@@ -526,78 +526,78 @@ def _curve1D(
# decide if the results are log scaled
if log_scale:
- y_range_A = np.log10(self.figure_result_data['A'].values.tolist())
- y_range_D = np.log10(self.figure_result_data['D'].values.tolist())
- y_range_E = np.log10(self.figure_result_data['E'].values.tolist())
- y_range_ME = np.log10(self.figure_result_data['ME'].values.tolist())
+ y_range_A = np.log10(self.figure_result_data["A"].values.tolist())
+ y_range_D = np.log10(self.figure_result_data["D"].values.tolist())
+ y_range_E = np.log10(self.figure_result_data["E"].values.tolist())
+ y_range_ME = np.log10(self.figure_result_data["ME"].values.tolist())
else:
- y_range_A = self.figure_result_data['A'].values.tolist()
- y_range_D = self.figure_result_data['D'].values.tolist()
- y_range_E = self.figure_result_data['E'].values.tolist()
- y_range_ME = self.figure_result_data['ME'].values.tolist()
+ y_range_A = self.figure_result_data["A"].values.tolist()
+ y_range_D = self.figure_result_data["D"].values.tolist()
+ y_range_E = self.figure_result_data["E"].values.tolist()
+ y_range_ME = self.figure_result_data["ME"].values.tolist()
# Draw A-optimality
fig = plt.pyplot.figure()
- plt.pyplot.rc('axes', titlesize=font_axes)
- plt.pyplot.rc('axes', labelsize=font_axes)
- plt.pyplot.rc('xtick', labelsize=font_tick)
- plt.pyplot.rc('ytick', labelsize=font_tick)
+ plt.pyplot.rc("axes", titlesize=font_axes)
+ plt.pyplot.rc("axes", labelsize=font_axes)
+ plt.pyplot.rc("xtick", labelsize=font_tick)
+ plt.pyplot.rc("ytick", labelsize=font_tick)
ax = fig.add_subplot(111)
- params = {'mathtext.default': 'regular'}
+ params = {"mathtext.default": "regular"}
# plt.rcParams.update(params)
ax.plot(x_range, y_range_A)
ax.scatter(x_range, y_range_A)
- ax.set_ylabel('$log_{10}$ Trace')
+ ax.set_ylabel("$log_{10}$ Trace")
ax.set_xlabel(xlabel_text)
- plt.pyplot.title(title_text + ' - A optimality')
+ plt.pyplot.title(title_text + ": A-optimality")
plt.pyplot.show()
# Draw D-optimality
fig = plt.pyplot.figure()
- plt.pyplot.rc('axes', titlesize=font_axes)
- plt.pyplot.rc('axes', labelsize=font_axes)
- plt.pyplot.rc('xtick', labelsize=font_tick)
- plt.pyplot.rc('ytick', labelsize=font_tick)
+ plt.pyplot.rc("axes", titlesize=font_axes)
+ plt.pyplot.rc("axes", labelsize=font_axes)
+ plt.pyplot.rc("xtick", labelsize=font_tick)
+ plt.pyplot.rc("ytick", labelsize=font_tick)
ax = fig.add_subplot(111)
- params = {'mathtext.default': 'regular'}
+ params = {"mathtext.default": "regular"}
# plt.rcParams.update(params)
ax.plot(x_range, y_range_D)
ax.scatter(x_range, y_range_D)
- ax.set_ylabel('$log_{10}$ Determinant')
+ ax.set_ylabel("$log_{10}$ Determinant")
ax.set_xlabel(xlabel_text)
- plt.pyplot.title(title_text + ' - D optimality')
+ plt.pyplot.title(title_text + ": D-optimality")
plt.pyplot.show()
# Draw E-optimality
fig = plt.pyplot.figure()
- plt.pyplot.rc('axes', titlesize=font_axes)
- plt.pyplot.rc('axes', labelsize=font_axes)
- plt.pyplot.rc('xtick', labelsize=font_tick)
- plt.pyplot.rc('ytick', labelsize=font_tick)
+ plt.pyplot.rc("axes", titlesize=font_axes)
+ plt.pyplot.rc("axes", labelsize=font_axes)
+ plt.pyplot.rc("xtick", labelsize=font_tick)
+ plt.pyplot.rc("ytick", labelsize=font_tick)
ax = fig.add_subplot(111)
- params = {'mathtext.default': 'regular'}
+ params = {"mathtext.default": "regular"}
# plt.rcParams.update(params)
ax.plot(x_range, y_range_E)
ax.scatter(x_range, y_range_E)
- ax.set_ylabel('$log_{10}$ Minimal eigenvalue')
+ ax.set_ylabel("$log_{10}$ Minimal eigenvalue")
ax.set_xlabel(xlabel_text)
- plt.pyplot.title(title_text + ' - E optimality')
+ plt.pyplot.title(title_text + ": E-optimality")
plt.pyplot.show()
# Draw Modified E-optimality
fig = plt.pyplot.figure()
- plt.pyplot.rc('axes', titlesize=font_axes)
- plt.pyplot.rc('axes', labelsize=font_axes)
- plt.pyplot.rc('xtick', labelsize=font_tick)
- plt.pyplot.rc('ytick', labelsize=font_tick)
+ plt.pyplot.rc("axes", titlesize=font_axes)
+ plt.pyplot.rc("axes", labelsize=font_axes)
+ plt.pyplot.rc("xtick", labelsize=font_tick)
+ plt.pyplot.rc("ytick", labelsize=font_tick)
ax = fig.add_subplot(111)
- params = {'mathtext.default': 'regular'}
+ params = {"mathtext.default": "regular"}
# plt.rcParams.update(params)
ax.plot(x_range, y_range_ME)
ax.scatter(x_range, y_range_ME)
- ax.set_ylabel('$log_{10}$ Condition number')
+ ax.set_ylabel("$log_{10}$ Condition number")
ax.set_xlabel(xlabel_text)
- plt.pyplot.title(title_text + ' - Modified E optimality')
+ plt.pyplot.title(title_text + ": Modified E-optimality")
plt.pyplot.show()
def _heatmap(
@@ -641,10 +641,10 @@ def _heatmap(
y_range = sensitivity_dict[self.sensitivity_dimension[1]]
# extract the design criteria values
- A_range = self.figure_result_data['A'].values.tolist()
- D_range = self.figure_result_data['D'].values.tolist()
- E_range = self.figure_result_data['E'].values.tolist()
- ME_range = self.figure_result_data['ME'].values.tolist()
+ A_range = self.figure_result_data["A"].values.tolist()
+ D_range = self.figure_result_data["D"].values.tolist()
+ E_range = self.figure_result_data["E"].values.tolist()
+ ME_range = self.figure_result_data["ME"].values.tolist()
# reshape the design criteria values for heatmaps
cri_a = np.asarray(A_range).reshape(len(x_range), len(y_range))
@@ -675,12 +675,12 @@ def _heatmap(
# A-optimality
fig = plt.pyplot.figure()
- plt.pyplot.rc('axes', titlesize=font_axes)
- plt.pyplot.rc('axes', labelsize=font_axes)
- plt.pyplot.rc('xtick', labelsize=font_tick)
- plt.pyplot.rc('ytick', labelsize=font_tick)
+ plt.pyplot.rc("axes", titlesize=font_axes)
+ plt.pyplot.rc("axes", labelsize=font_axes)
+ plt.pyplot.rc("xtick", labelsize=font_tick)
+ plt.pyplot.rc("ytick", labelsize=font_tick)
ax = fig.add_subplot(111)
- params = {'mathtext.default': 'regular'}
+ params = {"mathtext.default": "regular"}
plt.pyplot.rcParams.update(params)
ax.set_yticks(range(len(yLabel)))
ax.set_yticklabels(yLabel)
@@ -690,18 +690,18 @@ def _heatmap(
ax.set_xlabel(xlabel_text)
im = ax.imshow(hes_a.T, cmap=plt.pyplot.cm.hot_r)
ba = plt.pyplot.colorbar(im)
- ba.set_label('log10(trace(FIM))')
- plt.pyplot.title(title_text + ' - A optimality')
+ ba.set_label("log10(trace(FIM))")
+ plt.pyplot.title(title_text + ": A-optimality")
plt.pyplot.show()
# D-optimality
fig = plt.pyplot.figure()
- plt.pyplot.rc('axes', titlesize=font_axes)
- plt.pyplot.rc('axes', labelsize=font_axes)
- plt.pyplot.rc('xtick', labelsize=font_tick)
- plt.pyplot.rc('ytick', labelsize=font_tick)
+ plt.pyplot.rc("axes", titlesize=font_axes)
+ plt.pyplot.rc("axes", labelsize=font_axes)
+ plt.pyplot.rc("xtick", labelsize=font_tick)
+ plt.pyplot.rc("ytick", labelsize=font_tick)
ax = fig.add_subplot(111)
- params = {'mathtext.default': 'regular'}
+ params = {"mathtext.default": "regular"}
plt.pyplot.rcParams.update(params)
ax.set_yticks(range(len(yLabel)))
ax.set_yticklabels(yLabel)
@@ -711,18 +711,18 @@ def _heatmap(
ax.set_xlabel(xlabel_text)
im = ax.imshow(hes_d.T, cmap=plt.pyplot.cm.hot_r)
ba = plt.pyplot.colorbar(im)
- ba.set_label('log10(det(FIM))')
- plt.pyplot.title(title_text + ' - D optimality')
+ ba.set_label("log10(det(FIM))")
+ plt.pyplot.title(title_text + ": D-optimality")
plt.pyplot.show()
# E-optimality
fig = plt.pyplot.figure()
- plt.pyplot.rc('axes', titlesize=font_axes)
- plt.pyplot.rc('axes', labelsize=font_axes)
- plt.pyplot.rc('xtick', labelsize=font_tick)
- plt.pyplot.rc('ytick', labelsize=font_tick)
+ plt.pyplot.rc("axes", titlesize=font_axes)
+ plt.pyplot.rc("axes", labelsize=font_axes)
+ plt.pyplot.rc("xtick", labelsize=font_tick)
+ plt.pyplot.rc("ytick", labelsize=font_tick)
ax = fig.add_subplot(111)
- params = {'mathtext.default': 'regular'}
+ params = {"mathtext.default": "regular"}
plt.pyplot.rcParams.update(params)
ax.set_yticks(range(len(yLabel)))
ax.set_yticklabels(yLabel)
@@ -732,18 +732,18 @@ def _heatmap(
ax.set_xlabel(xlabel_text)
im = ax.imshow(hes_e.T, cmap=plt.pyplot.cm.hot_r)
ba = plt.pyplot.colorbar(im)
- ba.set_label('log10(minimal eig(FIM))')
- plt.pyplot.title(title_text + ' - E optimality')
+ ba.set_label("log10(minimal eig(FIM))")
+ plt.pyplot.title(title_text + ": E-optimality")
plt.pyplot.show()
# modified E-optimality
fig = plt.pyplot.figure()
- plt.pyplot.rc('axes', titlesize=font_axes)
- plt.pyplot.rc('axes', labelsize=font_axes)
- plt.pyplot.rc('xtick', labelsize=font_tick)
- plt.pyplot.rc('ytick', labelsize=font_tick)
+ plt.pyplot.rc("axes", titlesize=font_axes)
+ plt.pyplot.rc("axes", labelsize=font_axes)
+ plt.pyplot.rc("xtick", labelsize=font_tick)
+ plt.pyplot.rc("ytick", labelsize=font_tick)
ax = fig.add_subplot(111)
- params = {'mathtext.default': 'regular'}
+ params = {"mathtext.default": "regular"}
plt.pyplot.rcParams.update(params)
ax.set_yticks(range(len(yLabel)))
ax.set_yticklabels(yLabel)
@@ -753,6 +753,6 @@ def _heatmap(
ax.set_xlabel(xlabel_text)
im = ax.imshow(hes_e2.T, cmap=plt.pyplot.cm.hot_r)
ba = plt.pyplot.colorbar(im)
- ba.set_label('log10(cond(FIM))')
- plt.pyplot.title(title_text + ' - Modified E-optimality')
+ ba.set_label("log10(cond(FIM))")
+ plt.pyplot.title(title_text + ": Modified E-optimality")
plt.pyplot.show()
diff --git a/pyomo/contrib/doe/scenario.py b/pyomo/contrib/doe/scenario.py
index 6c6f5ef7d1b..b44ce1ab4d3 100644
--- a/pyomo/contrib/doe/scenario.py
+++ b/pyomo/contrib/doe/scenario.py
@@ -150,5 +150,5 @@ def generate_scenario(self):
# store scenario
if self.store:
- with open('scenario_simultaneous.pickle', 'wb') as f:
+ with open("scenario_simultaneous.pickle", "wb") as f:
pickle.dump(self.scenario_data, f)
diff --git a/pyomo/contrib/doe/tests/test_example.py b/pyomo/contrib/doe/tests/test_example.py
index b59014a8110..e4ffbe89142 100644
--- a/pyomo/contrib/doe/tests/test_example.py
+++ b/pyomo/contrib/doe/tests/test_example.py
@@ -38,10 +38,10 @@
from pyomo.opt import SolverFactory
-ipopt_available = SolverFactory('ipopt').available()
+ipopt_available = SolverFactory("ipopt").available()
-class TestReactorExample(unittest.TestCase):
+class TestReactorExamples(unittest.TestCase):
@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
@unittest.skipIf(not scipy_available, "scipy is not available")
@unittest.skipIf(not numpy_available, "Numpy is not available")
@@ -65,6 +65,22 @@ def test_reactor_grid_search(self):
reactor_grid_search.main()
+ @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+ @unittest.skipIf(not pandas_available, "pandas is not available")
+ @unittest.skipIf(not numpy_available, "Numpy is not available")
+ def test_reactor_design_slim_create_model_interface(self):
+ from pyomo.contrib.doe.examples import reactor_design
+
+ reactor_design.main(legacy_create_model_interface=False)
+
+ @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+ @unittest.skipIf(not pandas_available, "pandas is not available")
+ @unittest.skipIf(not numpy_available, "Numpy is not available")
+ def test_reactor_design_legacy_create_model_interface(self):
+ from pyomo.contrib.doe.examples import reactor_design
+
+ reactor_design.main(legacy_create_model_interface=True)
+
if __name__ == "__main__":
unittest.main()
diff --git a/pyomo/contrib/doe/tests/test_fim_doe.py b/pyomo/contrib/doe/tests/test_fim_doe.py
index 31d250f0d10..d9a8d60fdb4 100644
--- a/pyomo/contrib/doe/tests/test_fim_doe.py
+++ b/pyomo/contrib/doe/tests/test_fim_doe.py
@@ -38,16 +38,124 @@
class TestMeasurementError(unittest.TestCase):
- def test(self):
- t_control = [0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1]
- variable_name = "C"
- indices = {0: ['CA', 'CB', 'CC'], 1: t_control}
- # measurement object
- measurements = MeasurementVariables()
+
+ def test_with_time_plus_one_extra_index(self):
+ """This tests confirms the typical usage with a time index plus one extra index.
+
+ This test should execute without throwing any errors.
+
+ """
+
+ MeasurementVariables().add_variables(
+ "C", indices={0: ["A", "B", "C"], 1: [0, 0.5, 1.0]}, time_index_position=1
+ )
+
+ def test_with_time_plus_two_extra_indices(self):
+ """This tests confirms the typical usage with a time index plus two extra indices.
+
+ This test should execute without throwing any errors.
+
+ """
+
+ MeasurementVariables().add_variables(
+ "C",
+ indices={
+ 0: ["A", "B", "C"], # species
+ 1: [0, 0.5, 1.0], # time
+ 2: [1, 2, 3],
+ }, # position
+ time_index_position=1,
+ )
+
+ def test_time_index_position_out_of_bounds(self):
+ """This test confirms that an error is thrown when the time index position is out of bounds."""
+
# if time index is not in indices, an value error is thrown.
with self.assertRaises(ValueError):
- measurements.add_variables(
- variable_name, indices=indices, time_index_position=2
+ MeasurementVariables().add_variables(
+ "C",
+ indices={0: ["CA", "CB", "CC"], 1: [0, 0.5, 1.0]}, # species # time
+ time_index_position=2, # this is out of bounds
+ )
+
+ def test_single_measurement_variable(self):
+ """This test confirms we can specify a single measurement variable without
+ specifying the indices.
+
+ The test should execute with no errors.
+ """
+ measurements = MeasurementVariables()
+ measurements.add_variables("HelloWorld", indices=None, time_index_position=None)
+
+ def test_without_time_index(self):
+ """This test confirms we can add a measurement variable without specifying the time index.
+
+ The test should execute with no errors.
+
+ """
+
+ MeasurementVariables().add_variables(
+ "C",
+ indices={0: ["CA", "CB", "CC"]}, # species as only index
+ time_index_position=None, # no time index
+ )
+
+ def test_only_time_index(self):
+ """This test confirms we can add a measurement variable without specifying the variable name.
+
+ The test should execute with no errors.
+
+ """
+
+ MeasurementVariables().add_variables(
+ "HelloWorld", # name of the variable
+ indices={0: [0, 0.5, 1.0]},
+ time_index_position=0,
+ )
+
+ def test_with_no_measurement_name(self):
+ """This test confirms that an error is thrown when None is used as the measurement name."""
+
+ with self.assertRaises(TypeError):
+ MeasurementVariables().add_variables(
+ None, indices={0: [0, 0.5, 1.0]}, time_index_position=0
+ )
+
+ def test_with_non_string_measurement_name(self):
+ """This test confirms that an error is thrown when a non-string is used as the measurement name."""
+
+ with self.assertRaises(TypeError):
+ MeasurementVariables().add_variables(
+ 1, indices={0: [0, 0.5, 1.0]}, time_index_position=0
+ )
+
+ def test_non_integer_index_keys(self):
+ """This test confirms that strings can be used as keys for specifying the indices.
+
+ Warning: it is possible this usage breaks something else in Pyomo.DoE.
+ There may be an implicit assumption that the order of the keys must match the order
+ of the indices in the Pyomo model.
+
+ """
+
+ MeasurementVariables().add_variables(
+ "C",
+ indices={"species": ["CA", "CB", "CC"], "time": [0, 0.5, 1.0]},
+ time_index_position="time",
+ )
+
+ def test_no_measurements(self):
+ """This test confirms that an error is thrown when the user forgets to add any measurements.
+
+ It's okay to have no decision variables. With no measurement variables, the FIM is the zero matrix.
+ This (no measurements) is a common user mistake.
+ """
+
+ with self.assertRaises(ValueError):
+ decisions = DesignVariables()
+ measurements = MeasurementVariables()
+ DesignOfExperiments(
+ {}, decisions, measurements, create_model, disc_for_measure
)
@@ -58,7 +166,7 @@ def test(self):
exp_design = DesignVariables()
# add T as design variable
- var_T = 'T'
+ var_T = "T"
indices_T = {0: t_control}
exp1_T = [470, 300, 300, 300, 300, 300, 300, 300, 300]
@@ -94,7 +202,7 @@ def test(self):
t_control = [0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1]
# measurement object
variable_name = "C"
- indices = {0: ['CA', 'CB', 'CC'], 1: t_control}
+ indices = {0: ["CA", "CB", "CC"], 1: t_control}
measurements = MeasurementVariables()
measurements.add_variables(
@@ -105,7 +213,7 @@ def test(self):
exp_design = DesignVariables()
# add CAO as design variable
- var_C = 'CA0'
+ var_C = "CA0"
indices_C = {0: [0]}
exp1_C = [5]
exp_design.add_variables(
@@ -118,7 +226,7 @@ def test(self):
)
# add T as design variable
- var_T = 'T'
+ var_T = "T"
indices_T = {0: t_control}
exp1_T = [470, 300, 300, 300, 300, 300, 300, 300, 300]
@@ -165,7 +273,7 @@ def test_setup(self):
# add variable C
variable_name = "C"
- indices = {0: ['CA', 'CB', 'CC'], 1: t_control}
+ indices = {0: ["CA", "CB", "CC"], 1: t_control}
measurements.add_variables(
variable_name, indices=indices, time_index_position=1
)
@@ -178,36 +286,36 @@ def test_setup(self):
)
# check variable names
- self.assertEqual(measurements.variable_names[0], 'C[CA,0]')
- self.assertEqual(measurements.variable_names[1], 'C[CA,0.125]')
- self.assertEqual(measurements.variable_names[-1], 'T[5,0.8]')
- self.assertEqual(measurements.variable_names[-2], 'T[5,0.6]')
- self.assertEqual(measurements.variance['T[5,0.4]'], 10)
- self.assertEqual(measurements.variance['T[5,0.6]'], 10)
- self.assertEqual(measurements.variance['T[5,0.4]'], 10)
- self.assertEqual(measurements.variance['T[5,0.6]'], 10)
+ self.assertEqual(measurements.variable_names[0], "C[CA,0]")
+ self.assertEqual(measurements.variable_names[1], "C[CA,0.125]")
+ self.assertEqual(measurements.variable_names[-1], "T[5,0.8]")
+ self.assertEqual(measurements.variable_names[-2], "T[5,0.6]")
+ self.assertEqual(measurements.variance["T[5,0.4]"], 10)
+ self.assertEqual(measurements.variance["T[5,0.6]"], 10)
+ self.assertEqual(measurements.variance["T[5,0.4]"], 10)
+ self.assertEqual(measurements.variance["T[5,0.6]"], 10)
### specify function
var_names = [
- 'C[CA,0]',
- 'C[CA,0.125]',
- 'C[CA,0.875]',
- 'C[CA,1]',
- 'C[CB,0]',
- 'C[CB,0.125]',
- 'C[CB,0.25]',
- 'C[CB,0.375]',
- 'C[CC,0]',
- 'C[CC,0.125]',
- 'C[CC,0.25]',
- 'C[CC,0.375]',
+ "C[CA,0]",
+ "C[CA,0.125]",
+ "C[CA,0.875]",
+ "C[CA,1]",
+ "C[CB,0]",
+ "C[CB,0.125]",
+ "C[CB,0.25]",
+ "C[CB,0.375]",
+ "C[CC,0]",
+ "C[CC,0.125]",
+ "C[CC,0.25]",
+ "C[CC,0.375]",
]
measurements2 = MeasurementVariables()
measurements2.set_variable_name_list(var_names)
- self.assertEqual(measurements2.variable_names[1], 'C[CA,0.125]')
- self.assertEqual(measurements2.variable_names[-1], 'C[CC,0.375]')
+ self.assertEqual(measurements2.variable_names[1], "C[CA,0.125]")
+ self.assertEqual(measurements2.variable_names[-1], "C[CC,0.375]")
### check_subset function
self.assertTrue(measurements.check_subset(measurements2))
@@ -223,7 +331,7 @@ def test_setup(self):
exp_design = DesignVariables()
# add CAO as design variable
- var_C = 'CA0'
+ var_C = "CA0"
indices_C = {0: [0]}
exp1_C = [5]
exp_design.add_variables(
@@ -236,7 +344,7 @@ def test_setup(self):
)
# add T as design variable
- var_T = 'T'
+ var_T = "T"
indices_T = {0: t_control}
exp1_T = [470, 300, 300, 300, 300, 300, 300, 300, 300]
@@ -252,31 +360,31 @@ def test_setup(self):
self.assertEqual(
exp_design.variable_names,
[
- 'CA0[0]',
- 'T[0]',
- 'T[0.125]',
- 'T[0.25]',
- 'T[0.375]',
- 'T[0.5]',
- 'T[0.625]',
- 'T[0.75]',
- 'T[0.875]',
- 'T[1]',
+ "CA0[0]",
+ "T[0]",
+ "T[0.125]",
+ "T[0.25]",
+ "T[0.375]",
+ "T[0.5]",
+ "T[0.625]",
+ "T[0.75]",
+ "T[0.875]",
+ "T[1]",
],
)
- self.assertEqual(exp_design.variable_names_value['CA0[0]'], 5)
- self.assertEqual(exp_design.variable_names_value['T[0]'], 470)
- self.assertEqual(exp_design.upper_bounds['CA0[0]'], 5)
- self.assertEqual(exp_design.upper_bounds['T[0]'], 700)
- self.assertEqual(exp_design.lower_bounds['CA0[0]'], 1)
- self.assertEqual(exp_design.lower_bounds['T[0]'], 300)
+ self.assertEqual(exp_design.variable_names_value["CA0[0]"], 5)
+ self.assertEqual(exp_design.variable_names_value["T[0]"], 470)
+ self.assertEqual(exp_design.upper_bounds["CA0[0]"], 5)
+ self.assertEqual(exp_design.upper_bounds["T[0]"], 700)
+ self.assertEqual(exp_design.lower_bounds["CA0[0]"], 1)
+ self.assertEqual(exp_design.lower_bounds["T[0]"], 300)
design_names = exp_design.variable_names
exp1 = [4, 600, 300, 300, 300, 300, 300, 300, 300, 300]
exp1_design_dict = dict(zip(design_names, exp1))
exp_design.update_values(exp1_design_dict)
- self.assertEqual(exp_design.variable_names_value['CA0[0]'], 4)
- self.assertEqual(exp_design.variable_names_value['T[0]'], 600)
+ self.assertEqual(exp_design.variable_names_value["CA0[0]"], 4)
+ self.assertEqual(exp_design.variable_names_value["T[0]"], 600)
class TestParameter(unittest.TestCase):
@@ -284,19 +392,19 @@ class TestParameter(unittest.TestCase):
def test_setup(self):
# set up parameter class
- param_dict = {'A1': 84.79, 'A2': 371.72, 'E1': 7.78, 'E2': 15.05}
+ param_dict = {"A1": 84.79, "A2": 371.72, "E1": 7.78, "E2": 15.05}
scenario_gene = ScenarioGenerator(param_dict, formula="central", step=0.1)
parameter_set = scenario_gene.ScenarioData
- self.assertAlmostEqual(parameter_set.eps_abs['A1'], 16.9582, places=1)
- self.assertAlmostEqual(parameter_set.eps_abs['E1'], 1.5554, places=1)
- self.assertEqual(parameter_set.scena_num['A2'], [2, 3])
- self.assertEqual(parameter_set.scena_num['E1'], [4, 5])
- self.assertAlmostEqual(parameter_set.scenario[0]['A1'], 93.2699, places=1)
- self.assertAlmostEqual(parameter_set.scenario[2]['A2'], 408.8895, places=1)
- self.assertAlmostEqual(parameter_set.scenario[-1]['E2'], 13.54, places=1)
- self.assertAlmostEqual(parameter_set.scenario[-2]['E2'], 16.55, places=1)
+ self.assertAlmostEqual(parameter_set.eps_abs["A1"], 16.9582, places=1)
+ self.assertAlmostEqual(parameter_set.eps_abs["E1"], 1.5554, places=1)
+ self.assertEqual(parameter_set.scena_num["A2"], [2, 3])
+ self.assertEqual(parameter_set.scena_num["E1"], [4, 5])
+ self.assertAlmostEqual(parameter_set.scenario[0]["A1"], 93.2699, places=1)
+ self.assertAlmostEqual(parameter_set.scenario[2]["A2"], 408.8895, places=1)
+ self.assertAlmostEqual(parameter_set.scenario[-1]["E2"], 13.54, places=1)
+ self.assertAlmostEqual(parameter_set.scenario[-2]["E2"], 16.55, places=1)
class TestVariablesWithIndices(unittest.TestCase):
@@ -307,7 +415,7 @@ def test_setup(self):
t_control = [0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1]
### add_element function
# add CAO as design variable
- var_C = 'CA0'
+ var_C = "CA0"
indices_C = {0: [0]}
exp1_C = [5]
special.add_variables(
@@ -320,7 +428,7 @@ def test_setup(self):
)
# add T as design variable
- var_T = 'T'
+ var_T = "T"
indices_T = {0: t_control}
exp1_T = [470, 300, 300, 300, 300, 300, 300, 300, 300]
@@ -336,25 +444,25 @@ def test_setup(self):
self.assertEqual(
special.variable_names,
[
- 'CA0[0]',
- 'T[0]',
- 'T[0.125]',
- 'T[0.25]',
- 'T[0.375]',
- 'T[0.5]',
- 'T[0.625]',
- 'T[0.75]',
- 'T[0.875]',
- 'T[1]',
+ "CA0[0]",
+ "T[0]",
+ "T[0.125]",
+ "T[0.25]",
+ "T[0.375]",
+ "T[0.5]",
+ "T[0.625]",
+ "T[0.75]",
+ "T[0.875]",
+ "T[1]",
],
)
- self.assertEqual(special.variable_names_value['CA0[0]'], 5)
- self.assertEqual(special.variable_names_value['T[0]'], 470)
- self.assertEqual(special.upper_bounds['CA0[0]'], 5)
- self.assertEqual(special.upper_bounds['T[0]'], 700)
- self.assertEqual(special.lower_bounds['CA0[0]'], 1)
- self.assertEqual(special.lower_bounds['T[0]'], 300)
+ self.assertEqual(special.variable_names_value["CA0[0]"], 5)
+ self.assertEqual(special.variable_names_value["T[0]"], 470)
+ self.assertEqual(special.upper_bounds["CA0[0]"], 5)
+ self.assertEqual(special.upper_bounds["T[0]"], 700)
+ self.assertEqual(special.lower_bounds["CA0[0]"], 1)
+ self.assertEqual(special.lower_bounds["T[0]"], 300)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/pyomo/contrib/doe/tests/test_reactor_example.py b/pyomo/contrib/doe/tests/test_reactor_example.py
index daf2ee89194..19fb4e61820 100644
--- a/pyomo/contrib/doe/tests/test_reactor_example.py
+++ b/pyomo/contrib/doe/tests/test_reactor_example.py
@@ -34,13 +34,12 @@
from pyomo.contrib.doe.examples.reactor_kinetics import create_model, disc_for_measure
from pyomo.opt import SolverFactory
-ipopt_available = SolverFactory('ipopt').available()
+ipopt_available = SolverFactory("ipopt").available()
-class Test_example_options(unittest.TestCase):
- """Test the three options in the kinetics example."""
-
- def test_setUP(self):
+class Test_Reaction_Kinetics_Example(unittest.TestCase):
+ def test_reaction_kinetics_create_model(self):
+ """Test the three options in the kinetics example."""
# parmest option
mod = create_model(model_option="parmest")
@@ -56,25 +55,125 @@ def test_setUP(self):
create_model(model_option="stage2")
with self.assertRaises(ValueError):
- create_model(model_option="NotDefine")
+ create_model(model_option="NotDefined")
+
+ @unittest.skipIf(not ipopt_available, "The 'ipopt' solver is not available")
+ @unittest.skipIf(not numpy_available, "Numpy is not available")
+ @unittest.skipIf(not pandas_available, "Pandas is not available")
+ def test_kinetics_example_sequential_finite_then_optimize(self):
+ """Test the kinetics example with sequential_finite mode and then optimization"""
+ doe_object = self.specify_reaction_kinetics()
+
+ # Test FIM calculation at nominal values
+ sensi_opt = "sequential_finite"
+ result = doe_object.compute_FIM(
+ mode=sensi_opt, scale_nominal_param_value=True, formula="central"
+ )
+ result.result_analysis()
+ self.assertAlmostEqual(np.log10(result.trace), 2.7885, places=2)
+ self.assertAlmostEqual(np.log10(result.det), 2.8218, places=2)
+ self.assertAlmostEqual(np.log10(result.min_eig), -1.0123, places=2)
+
+ ### check subset feature
+ sub_name = "C"
+ sub_indices = {0: ["CB", "CC"], 1: [0.125, 0.25, 0.5, 0.75, 0.875]}
+
+ measure_subset = MeasurementVariables()
+ measure_subset.add_variables(
+ sub_name, indices=sub_indices, time_index_position=1
+ )
+ sub_result = result.subset(measure_subset)
+ sub_result.result_analysis()
+
+ self.assertAlmostEqual(np.log10(sub_result.trace), 2.5535, places=2)
+ self.assertAlmostEqual(np.log10(sub_result.det), 1.3464, places=2)
+ self.assertAlmostEqual(np.log10(sub_result.min_eig), -1.5386, places=2)
+
+ ### Test stochastic_program mode
+ # Prior information (scaled FIM with T=500 and T=300 experiments)
+ prior = np.asarray(
+ [
+ [28.67892806, 5.41249739, -81.73674601, -24.02377324],
+ [5.41249739, 26.40935036, -12.41816477, -139.23992532],
+ [-81.73674601, -12.41816477, 240.46276004, 58.76422806],
+ [-24.02377324, -139.23992532, 58.76422806, 767.25584508],
+ ]
+ )
+ doe_object2 = self.specify_reaction_kinetics(prior=prior)
+ square_result, optimize_result = doe_object2.stochastic_program(
+ if_optimize=True,
+ if_Cholesky=True,
+ scale_nominal_param_value=True,
+ objective_option="det",
+ L_initial=np.linalg.cholesky(prior),
+ jac_initial=result.jaco_information.copy(),
+ tee_opt=True,
+ )
-class Test_doe_object(unittest.TestCase):
- """Test the kinetics example with both the sequential_finite mode and the direct_kaug mode"""
+ optimize_result.result_analysis()
+ ## 2024-May-26: changing this to test the objective instead of the optimal solution
+ ## It's possible the objective is flat and the optimal solution is not unique
+ # self.assertAlmostEqual(value(optimize_result.model.CA0[0]), 5.0, places=2)
+ # self.assertAlmostEqual(value(optimize_result.model.T[0.5]), 300, places=2)
+ self.assertAlmostEqual(np.log10(optimize_result.det), 5.744, places=2)
+
+ square_result, optimize_result = doe_object2.stochastic_program(
+ if_optimize=True,
+ scale_nominal_param_value=True,
+ objective_option="trace",
+ jac_initial=result.jaco_information.copy(),
+ tee_opt=True,
+ )
+
+ optimize_result.result_analysis()
+ ## 2024-May-26: changing this to test the objective instead of the optimal solution
+ ## It's possible the objective is flat and the optimal solution is not unique
+ # self.assertAlmostEqual(value(optimize_result.model.CA0[0]), 5.0, places=2)
+ # self.assertAlmostEqual(value(optimize_result.model.T[0.5]), 300, places=2)
+ self.assertAlmostEqual(np.log10(optimize_result.trace), 3.340, places=2)
@unittest.skipIf(not ipopt_available, "The 'ipopt' solver is not available")
@unittest.skipIf(not numpy_available, "Numpy is not available")
@unittest.skipIf(not pandas_available, "Pandas is not available")
- def test_setUP(self):
+ def test_kinetics_example_direct_k_aug(self):
+ doe_object = self.specify_reaction_kinetics()
+
+ # Test FIM calculation at nominal values
+ sensi_opt = "direct_kaug"
+ result = doe_object.compute_FIM(
+ mode=sensi_opt, scale_nominal_param_value=True, formula="central"
+ )
+ result.result_analysis()
+ self.assertAlmostEqual(np.log10(result.trace), 2.789, places=2)
+ self.assertAlmostEqual(np.log10(result.det), 2.8247, places=2)
+ self.assertAlmostEqual(np.log10(result.min_eig), -1.0112, places=2)
+
+ ### check subset feature
+ sub_name = "C"
+ sub_indices = {0: ["CB", "CC"], 1: [0.125, 0.25, 0.5, 0.75, 0.875]}
+
+ measure_subset = MeasurementVariables()
+ measure_subset.add_variables(
+ sub_name, indices=sub_indices, time_index_position=1
+ )
+ sub_result = result.subset(measure_subset)
+ sub_result.result_analysis()
+
+ self.assertAlmostEqual(np.log10(sub_result.trace), 2.5535, places=2)
+ self.assertAlmostEqual(np.log10(sub_result.det), 1.3464, places=2)
+ self.assertAlmostEqual(np.log10(sub_result.min_eig), -1.5386, places=2)
+
+ def specify_reaction_kinetics(self, prior=None):
### Define inputs
# Control time set [h]
t_control = [0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1]
# Define parameter nominal value
- parameter_dict = {'A1': 84.79, 'A2': 371.72, 'E1': 7.78, 'E2': 15.05}
+ parameter_dict = {"A1": 84.79, "A2": 371.72, "E1": 7.78, "E2": 15.05}
# measurement object
variable_name = "C"
- indices = {0: ['CA', 'CB', 'CC'], 1: t_control}
+ indices = {0: ["CA", "CB", "CC"], 1: t_control}
measurements = MeasurementVariables()
measurements.add_variables(
@@ -85,7 +184,7 @@ def test_setUP(self):
exp_design = DesignVariables()
# add CAO as design variable
- var_C = 'CA0'
+ var_C = "CA0"
indices_C = {0: [0]}
exp1_C = [5]
exp_design.add_variables(
@@ -98,7 +197,7 @@ def test_setUP(self):
)
# add T as design variable
- var_T = 'T'
+ var_T = "T"
indices_T = {0: t_control}
exp1_T = [470, 300, 300, 300, 300, 300, 300, 300, 300]
@@ -111,9 +210,6 @@ def test_setUP(self):
upper_bounds=700,
)
- ### Test sequential_finite mode
- sensi_opt = "sequential_finite"
-
design_names = exp_design.variable_names
exp1 = [5, 570, 300, 300, 300, 300, 300, 300, 300, 300]
exp1_design_dict = dict(zip(design_names, exp1))
@@ -126,95 +222,11 @@ def test_setUP(self):
measurements,
create_model,
discretize_model=disc_for_measure,
- )
-
- result = doe_object.compute_FIM(
- mode=sensi_opt, scale_nominal_param_value=True, formula="central"
- )
-
- result.result_analysis()
-
- self.assertAlmostEqual(np.log10(result.trace), 2.7885, places=2)
- self.assertAlmostEqual(np.log10(result.det), 2.8218, places=2)
- self.assertAlmostEqual(np.log10(result.min_eig), -1.0123, places=2)
-
- ### check subset feature
- sub_name = "C"
- sub_indices = {0: ["CB", "CC"], 1: [0.125, 0.25, 0.5, 0.75, 0.875]}
-
- measure_subset = MeasurementVariables()
- measure_subset.add_variables(
- sub_name, indices=sub_indices, time_index_position=1
- )
- sub_result = result.subset(measure_subset)
- sub_result.result_analysis()
-
- self.assertAlmostEqual(np.log10(sub_result.trace), 2.5535, places=2)
- self.assertAlmostEqual(np.log10(sub_result.det), 1.3464, places=2)
- self.assertAlmostEqual(np.log10(sub_result.min_eig), -1.5386, places=2)
-
- ### Test direct_kaug mode
- sensi_opt = "direct_kaug"
- # Define a new experiment
-
- exp1 = [5, 570, 400, 300, 300, 300, 300, 300, 300, 300]
- exp1_design_dict = dict(zip(design_names, exp1))
- exp_design.update_values(exp1_design_dict)
-
- doe_object = DesignOfExperiments(
- parameter_dict,
- exp_design,
- measurements,
- create_model,
- discretize_model=disc_for_measure,
- )
-
- result = doe_object.compute_FIM(
- mode=sensi_opt, scale_nominal_param_value=True, formula="central"
- )
-
- result.result_analysis()
-
- self.assertAlmostEqual(np.log10(result.trace), 2.7211, places=2)
- self.assertAlmostEqual(np.log10(result.det), 2.0845, places=2)
- self.assertAlmostEqual(np.log10(result.min_eig), -1.3510, places=2)
-
- ### Test stochastic_program mode
-
- exp1 = [5, 570, 300, 300, 300, 300, 300, 300, 300, 300]
- exp1_design_dict = dict(zip(design_names, exp1))
- exp_design.update_values(exp1_design_dict)
-
- # add a prior information (scaled FIM with T=500 and T=300 experiments)
- prior = np.asarray(
- [
- [28.67892806, 5.41249739, -81.73674601, -24.02377324],
- [5.41249739, 26.40935036, -12.41816477, -139.23992532],
- [-81.73674601, -12.41816477, 240.46276004, 58.76422806],
- [-24.02377324, -139.23992532, 58.76422806, 767.25584508],
- ]
- )
-
- doe_object2 = DesignOfExperiments(
- parameter_dict,
- exp_design,
- measurements,
- create_model,
prior_FIM=prior,
- discretize_model=disc_for_measure,
- )
-
- square_result, optimize_result = doe_object2.stochastic_program(
- if_optimize=True,
- if_Cholesky=True,
- scale_nominal_param_value=True,
- objective_option="det",
- L_initial=np.linalg.cholesky(prior),
)
- self.assertAlmostEqual(value(optimize_result.model.CA0[0]), 5.0, places=2)
- self.assertAlmostEqual(value(optimize_result.model.T[0.5]), 300, places=2)
+ return doe_object
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/pyomo/contrib/fbbt/fbbt.py b/pyomo/contrib/fbbt/fbbt.py
index bde33b3caa0..1507c4a3cc5 100644
--- a/pyomo/contrib/fbbt/fbbt.py
+++ b/pyomo/contrib/fbbt/fbbt.py
@@ -24,9 +24,10 @@
import math
from pyomo.core.base.block import Block
from pyomo.core.base.constraint import Constraint
+from pyomo.core.base.expression import ExpressionData, ScalarExpression
+from pyomo.core.base.objective import ObjectiveData, ScalarObjective
from pyomo.core.base.var import Var
from pyomo.gdp import Disjunct
-from pyomo.core.base.expression import _GeneralExpressionData, ScalarExpression
import logging
from pyomo.common.errors import InfeasibleConstraintException, PyomoException
from pyomo.common.config import (
@@ -333,15 +334,15 @@ def _prop_bnds_leaf_to_root_UnaryFunctionExpression(visitor, node, arg):
_unary_leaf_to_root_map[node.getname()](visitor, node, arg)
-def _prop_bnds_leaf_to_root_GeneralExpression(visitor, node, expr):
+def _prop_bnds_leaf_to_root_NamedExpression(visitor, node, expr):
"""
Propagate bounds from children to parent
Parameters
----------
visitor: _FBBTVisitorLeafToRoot
- node: pyomo.core.base.expression._GeneralExpressionData
- expr: GeneralExpression arg
+ node: pyomo.core.base.expression.NamedExpressionData
+ expr: NamedExpressionData arg
"""
bnds_dict = visitor.bnds_dict
if node in bnds_dict:
@@ -366,8 +367,10 @@ def _prop_bnds_leaf_to_root_GeneralExpression(visitor, node, expr):
numeric_expr.UnaryFunctionExpression: _prop_bnds_leaf_to_root_UnaryFunctionExpression,
numeric_expr.LinearExpression: _prop_bnds_leaf_to_root_SumExpression,
numeric_expr.AbsExpression: _prop_bnds_leaf_to_root_abs,
- _GeneralExpressionData: _prop_bnds_leaf_to_root_GeneralExpression,
- ScalarExpression: _prop_bnds_leaf_to_root_GeneralExpression,
+ ExpressionData: _prop_bnds_leaf_to_root_NamedExpression,
+ ScalarExpression: _prop_bnds_leaf_to_root_NamedExpression,
+ ObjectiveData: _prop_bnds_leaf_to_root_NamedExpression,
+ ScalarObjective: _prop_bnds_leaf_to_root_NamedExpression,
},
)
@@ -898,13 +901,13 @@ def _prop_bnds_root_to_leaf_UnaryFunctionExpression(node, bnds_dict, feasibility
)
-def _prop_bnds_root_to_leaf_GeneralExpression(node, bnds_dict, feasibility_tol):
+def _prop_bnds_root_to_leaf_NamedExpression(node, bnds_dict, feasibility_tol):
"""
Propagate bounds from parent to children.
Parameters
----------
- node: pyomo.core.base.expression._GeneralExpressionData
+ node: pyomo.core.base.expression.NamedExpressionData
bnds_dict: ComponentMap
feasibility_tol: float
If the bounds computed on the body of a constraint violate the bounds of the constraint by more than
@@ -945,12 +948,10 @@ def _prop_bnds_root_to_leaf_GeneralExpression(node, bnds_dict, feasibility_tol):
)
_prop_bnds_root_to_leaf_map[numeric_expr.AbsExpression] = _prop_bnds_root_to_leaf_abs
-_prop_bnds_root_to_leaf_map[_GeneralExpressionData] = (
- _prop_bnds_root_to_leaf_GeneralExpression
-)
-_prop_bnds_root_to_leaf_map[ScalarExpression] = (
- _prop_bnds_root_to_leaf_GeneralExpression
-)
+_prop_bnds_root_to_leaf_map[ExpressionData] = _prop_bnds_root_to_leaf_NamedExpression
+_prop_bnds_root_to_leaf_map[ScalarExpression] = _prop_bnds_root_to_leaf_NamedExpression
+_prop_bnds_root_to_leaf_map[ObjectiveData] = _prop_bnds_root_to_leaf_NamedExpression
+_prop_bnds_root_to_leaf_map[ScalarObjective] = _prop_bnds_root_to_leaf_NamedExpression
def _check_and_reset_bounds(var, lb, ub):
diff --git a/pyomo/contrib/fme/fourier_motzkin_elimination.py b/pyomo/contrib/fme/fourier_motzkin_elimination.py
index a1b5d744cf4..4636450c58e 100644
--- a/pyomo/contrib/fme/fourier_motzkin_elimination.py
+++ b/pyomo/contrib/fme/fourier_motzkin_elimination.py
@@ -23,7 +23,7 @@
value,
ConstraintList,
)
-from pyomo.core.base import TransformationFactory, _VarData
+from pyomo.core.base import TransformationFactory, VarData
from pyomo.core.plugins.transform.hierarchy import Transformation
from pyomo.common.config import ConfigBlock, ConfigValue, NonNegativeFloat
from pyomo.common.modeling import unique_component_name
@@ -58,7 +58,7 @@ def _check_var_bounds_filter(constraint):
def vars_to_eliminate_list(x):
- if isinstance(x, (Var, _VarData)):
+ if isinstance(x, (Var, VarData)):
if not x.is_indexed():
return ComponentSet([x])
ans = ComponentSet()
diff --git a/pyomo/contrib/fme/tests/test_fourier_motzkin_elimination.py b/pyomo/contrib/fme/tests/test_fourier_motzkin_elimination.py
index 3c01acab531..dc721488f74 100644
--- a/pyomo/contrib/fme/tests/test_fourier_motzkin_elimination.py
+++ b/pyomo/contrib/fme/tests/test_fourier_motzkin_elimination.py
@@ -435,7 +435,7 @@ def check_hull_projected_constraints(self, m, constraints, indices):
self.assertIs(body.linear_vars[2], m.startup.binary_indicator_var)
self.assertEqual(body.linear_coefs[2], 2)
- # 1 <= time1_disjuncts[0].ind_var + time_1.disjuncts[1].ind_var
+ # 1 <= time1_disjuncts[0].ind_var + time1_disjuncts[1].ind_var
cons = constraints[indices[7]]
self.assertEqual(cons.lower, 1)
self.assertIsNone(cons.upper)
@@ -548,12 +548,12 @@ def test_project_disaggregated_vars(self):
# we of course get tremendous amounts of garbage, but we make sure that
# what should be here is:
self.check_hull_projected_constraints(
- m, constraints, [23, 19, 8, 10, 54, 67, 35, 3, 4, 1, 2]
+ m, constraints, [16, 12, 69, 71, 47, 60, 28, 1, 2, 3, 4]
)
# and when we filter, it's still there.
constraints = filtered._pyomo_contrib_fme_transformation.projected_constraints
self.check_hull_projected_constraints(
- filtered, constraints, [10, 8, 5, 6, 15, 19, 11, 3, 4, 1, 2]
+ filtered, constraints, [8, 6, 20, 21, 13, 17, 9, 1, 2, 3, 4]
)
@unittest.skipIf(not 'glpk' in solvers, 'glpk not available')
@@ -570,7 +570,7 @@ def test_post_processing(self):
# They should be the same as the above, but now these are *all* the
# constraints
self.check_hull_projected_constraints(
- m, constraints, [10, 8, 5, 6, 15, 19, 11, 3, 4, 1, 2]
+ m, constraints, [8, 6, 20, 21, 13, 17, 9, 1, 2, 3, 4]
)
# and check that we didn't change the model
diff --git a/pyomo/contrib/gdp_bounds/info.py b/pyomo/contrib/gdp_bounds/info.py
index 6f39af5908d..e65df2bfab0 100644
--- a/pyomo/contrib/gdp_bounds/info.py
+++ b/pyomo/contrib/gdp_bounds/info.py
@@ -35,10 +35,10 @@ def disjunctive_bound(var, scope):
"""Compute the disjunctive bounds for a variable in a given scope.
Args:
- var (_VarData): Variable for which to compute bound
+ var (VarData): Variable for which to compute bound
scope (Component): The scope in which to compute the bound. If not a
- _DisjunctData, it will walk up the tree and use the scope of the
- most immediate enclosing _DisjunctData.
+ DisjunctData, it will walk up the tree and use the scope of the
+ most immediate enclosing DisjunctData.
Returns:
numeric: the tighter of either the disjunctive lower bound, the
diff --git a/pyomo/contrib/gdpopt/branch_and_bound.py b/pyomo/contrib/gdpopt/branch_and_bound.py
index 918f3d459a0..36b81c881be 100644
--- a/pyomo/contrib/gdpopt/branch_and_bound.py
+++ b/pyomo/contrib/gdpopt/branch_and_bound.py
@@ -230,12 +230,12 @@ def _solve_gdp(self, model, config):
no_feasible_soln = float('inf')
self.LB = (
node_data.obj_lb
- if solve_data.objective_sense == minimize
+ if self.objective_sense == minimize
else -no_feasible_soln
)
self.UB = (
no_feasible_soln
- if solve_data.objective_sense == minimize
+ if self.objective_sense == minimize
else -node_data.obj_lb
)
config.logger.info(
diff --git a/pyomo/contrib/gdpopt/tests/test_LBB.py b/pyomo/contrib/gdpopt/tests/test_LBB.py
index 273327b02a4..8a553398fa6 100644
--- a/pyomo/contrib/gdpopt/tests/test_LBB.py
+++ b/pyomo/contrib/gdpopt/tests/test_LBB.py
@@ -59,6 +59,7 @@ def test_infeasible_GDP(self):
self.assertIsNone(m.d.disjuncts[0].indicator_var.value)
self.assertIsNone(m.d.disjuncts[1].indicator_var.value)
+ @unittest.skipUnless(z3_available, "Z3 SAT solver is not available")
def test_infeasible_GDP_check_sat(self):
"""Test for infeasible GDP with check_sat option True."""
m = ConcreteModel()
diff --git a/pyomo/contrib/gdpopt/tests/test_gdpopt.py b/pyomo/contrib/gdpopt/tests/test_gdpopt.py
index 005df56ced5..873bafabc76 100644
--- a/pyomo/contrib/gdpopt/tests/test_gdpopt.py
+++ b/pyomo/contrib/gdpopt/tests/test_gdpopt.py
@@ -22,7 +22,6 @@
from pyomo.common.collections import Bunch
from pyomo.common.config import ConfigDict, ConfigValue
from pyomo.common.fileutils import import_file, PYOMO_ROOT_DIR
-from pyomo.contrib.appsi.solvers.gurobi import Gurobi
from pyomo.contrib.gdpopt.create_oa_subproblems import (
add_util_block,
add_disjunct_list,
@@ -767,6 +766,9 @@ def test_time_limit(self):
results.solver.termination_condition, TerminationCondition.maxTimeLimit
)
+ @unittest.skipUnless(
+ license_available, "No BARON license--8PP logical problem exceeds demo size"
+ )
def test_LOA_8PP_logical_default_init(self):
"""Test logic-based outer approximation with 8PP."""
exfile = import_file(join(exdir, 'eight_process', 'eight_proc_logical.py'))
@@ -870,6 +872,9 @@ def test_LOA_8PP_maxBinary(self):
)
ct.check_8PP_solution(self, eight_process, results)
+ @unittest.skipUnless(
+ license_available, "No BARON license--8PP logical problem exceeds demo size"
+ )
def test_LOA_8PP_logical_maxBinary(self):
"""Test logic-based OA with max_binary initialization."""
exfile = import_file(join(exdir, 'eight_process', 'eight_proc_logical.py'))
@@ -1050,7 +1055,11 @@ def assert_correct_disjuncts_active(
self.assertTrue(fabs(value(eight_process.profit.expr) - 68) <= 1e-2)
- @unittest.skipUnless(Gurobi().available(), "APPSI Gurobi solver is not available")
+ @unittest.skipUnless(
+ SolverFactory('appsi_gurobi').available(exception_flag=False)
+ and SolverFactory('appsi_gurobi').license_is_valid(),
+ "Legacy APPSI Gurobi solver is not available",
+ )
def test_auto_persistent_solver(self):
exfile = import_file(join(exdir, 'eight_process', 'eight_proc_model.py'))
m = exfile.build_eight_process_flowsheet()
@@ -1126,6 +1135,9 @@ def test_RIC_8PP_default_init(self):
)
ct.check_8PP_solution(self, eight_process, results)
+ @unittest.skipUnless(
+ license_available, "No BARON license--8PP logical problem exceeds demo size"
+ )
def test_RIC_8PP_logical_default_init(self):
"""Test logic-based outer approximation with 8PP."""
exfile = import_file(join(exdir, 'eight_process', 'eight_proc_logical.py'))
diff --git a/pyomo/contrib/gdpopt/util.py b/pyomo/contrib/gdpopt/util.py
index 2cb70f0ea60..babe0245d57 100644
--- a/pyomo/contrib/gdpopt/util.py
+++ b/pyomo/contrib/gdpopt/util.py
@@ -553,6 +553,13 @@ def _add_bigm_constraint_to_transformed_model(m, constraint, block):
# making a Reference to the ComponentData so that it will look like an
# indexed component for now. If I redesign bigm at some point, then this
# could be prettier.
- bigm._transform_constraint(Reference(constraint), parent_disjunct, None, [], [])
+ bigm._transform_constraint(
+ Reference(constraint),
+ parent_disjunct,
+ None,
+ [],
+ [],
+ 1 - parent_disjunct.binary_indicator_var,
+ )
# Now get rid of it because this is a class attribute!
del bigm._config
diff --git a/pyomo/contrib/iis/__init__.py b/pyomo/contrib/iis/__init__.py
index e8d6a7ac2c3..961ac576d42 100644
--- a/pyomo/contrib/iis/__init__.py
+++ b/pyomo/contrib/iis/__init__.py
@@ -10,3 +10,4 @@
# ___________________________________________________________________________
from pyomo.contrib.iis.iis import write_iis
+from pyomo.contrib.iis.mis import compute_infeasibility_explanation
diff --git a/pyomo/contrib/iis/mis.py b/pyomo/contrib/iis/mis.py
new file mode 100644
index 00000000000..6b6cca8e29c
--- /dev/null
+++ b/pyomo/contrib/iis/mis.py
@@ -0,0 +1,377 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+"""
+WaterTAP Copyright (c) 2020-2023, The Regents of the University of California, through Lawrence Berkeley National Laboratory, Oak Ridge National Laboratory, National Renewable Energy Laboratory, and National Energy Technology Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy). All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+ Neither the name of the University of California, Lawrence Berkeley National Laboratory, Oak Ridge National Laboratory, National Renewable Energy Laboratory, National Energy Technology Laboratory, U.S. Dept. of Energy nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+You are under no obligation whatsoever to provide any bug fixes, patches, or upgrades to the features, functionality or performance of the source code ("Enhancements") to anyone; however, if you choose to make your Enhancements available either publicly, or directly to Lawrence Berkeley National Laboratory, without imposing a separate written license agreement for such Enhancements, then you hereby grant the following license: a non-exclusive, royalty-free perpetual license to install, use, modify, prepare derivative works, incorporate into other computer software, distribute, and sublicense such enhancements or derivative works thereof, in binary and source code form.
+"""
+"""
+Minimal Intractable System (MIS) finder
+Originally written by Ben Knueven as part of the WaterTAP project:
+ https://github.com/watertap-org/watertap
+That's why this file has the watertap copyright notice.
+
+copied by DLW 18Feb2024 and edited
+
+See: https://www.sce.carleton.ca/faculty/chinneck/docs/CPAIOR07InfeasibilityTutorial.pdf
+"""
+
+import logging
+import pyomo.environ as pyo
+
+from pyomo.core.plugins.transform.add_slack_vars import AddSlackVariables
+
+from pyomo.core.plugins.transform.hierarchy import IsomorphicTransformation
+
+from pyomo.common.modeling import unique_component_name
+from pyomo.common.collections import ComponentMap, ComponentSet
+
+from pyomo.opt import WriterFactory
+
+logger = logging.getLogger("pyomo.contrib.iis")
+logger.setLevel(logging.INFO)
+
+
+class _VariableBoundsAsConstraints(IsomorphicTransformation):
+ """Replace all variables bounds and domain information with constraints.
+
+ Leaves fixed Vars untouched (for now)
+ """
+
+ def _apply_to(self, instance, **kwds):
+
+ bound_constr_block_name = unique_component_name(instance, "_variable_bounds")
+ instance.add_component(bound_constr_block_name, pyo.Block())
+ bound_constr_block = instance.component(bound_constr_block_name)
+
+ for v in instance.component_data_objects(pyo.Var, descend_into=True):
+ if v.fixed:
+ continue
+ lb, ub = v.bounds
+ if lb is None and ub is None:
+ continue
+ var_name = v.getname(fully_qualified=True)
+ if lb is not None:
+ con_name = "lb_for_" + var_name
+ con = pyo.Constraint(expr=(lb, v, None))
+ bound_constr_block.add_component(con_name, con)
+ if ub is not None:
+ con_name = "ub_for_" + var_name
+ con = pyo.Constraint(expr=(None, v, ub))
+ bound_constr_block.add_component(con_name, con)
+
+ # now we deactivate the variable bounds / domain
+ v.domain = pyo.Reals
+ v.setlb(None)
+ v.setub(None)
+
+
+def compute_infeasibility_explanation(
+ model, solver, tee=False, tolerance=1e-8, logger=logger
+):
+ """
+ This function attempts to determine why a given model is infeasible. It deploys
+ two main algorithms:
+
+ 1. Successfully relaxes the constraints of the problem, and reports to the user
+ some sets of constraints and variable bounds, which when relaxed, creates a
+ feasible model.
+ 2. Uses the information collected from (1) to attempt to compute a Minimal
+ Infeasible System (MIS), which is a set of constraints and variable bounds
+ which appear to be in conflict with each other. It is minimal in the sense
+ that removing any single constraint or variable bound would result in a
+ feasible subsystem.
+
+ Args
+ ----
+ model: A pyomo block
+ solver: A pyomo solver object or a string for SolverFactory
+ tee (optional): Display intermediate solves conducted (False)
+ tolerance (optional): The feasibility tolerance to use when declaring a
+ constraint feasible (1e-08)
+ logger:logging.Logger
+ A logger for messages. Uses pyomo.contrib.mis logger by default.
+
+ """
+ # Suggested enhancement: It might be useful to return sets of names for each set of relaxed components, as well as the final minimal infeasible system
+
+ # hold the original harmless
+ modified_model = model.clone()
+
+ if solver is None:
+ raise ValueError("A solver must be supplied")
+ elif isinstance(solver, str):
+ solver = pyo.SolverFactory(solver)
+ else:
+ # assume we have a solver
+ assert solver.available()
+
+ # first, cache the values we get
+ _value_cache = ComponentMap()
+ for v in model.component_data_objects(pyo.Var, descend_into=True):
+ _value_cache[v] = v.value
+
+ # finding proper reference
+ if model.parent_block() is None:
+ common_name = ""
+ else:
+ common_name = model.name + "."
+
+ _modified_model_var_to_original_model_var = ComponentMap()
+ _modified_model_value_cache = ComponentMap()
+
+ for v in model.component_data_objects(pyo.Var, descend_into=True):
+ modified_model_var = modified_model.find_component(v.name[len(common_name) :])
+
+ _modified_model_var_to_original_model_var[modified_model_var] = v
+ _modified_model_value_cache[modified_model_var] = _value_cache[v]
+ modified_model_var.set_value(_value_cache[v], skip_validation=True)
+
+ # TODO: For WT / IDAES models, we should probably be more
+ # selective in *what* we elasticize. E.g., it probably
+ # does not make sense to elasticize property calculations
+ # and maybe certain other equality constraints calculating
+ # values. Maybe we shouldn't elasticize *any* equality
+ # constraints.
+ # For example, elasticizing the calculation of mass fraction
+ # makes absolutely no sense and will just be noise for the
+ # modeler to sift through. We could try to sort the constraints
+ # such that we look for those with linear coefficients `1` on
+ # some term and leave those be.
+ # Alternatively, we could apply this tool to a version of the
+ # model that has as many as possible of these constraints
+ # "substituted out".
+ # move the variable bounds to the constraints
+ _VariableBoundsAsConstraints().apply_to(modified_model)
+
+ AddSlackVariables().apply_to(modified_model)
+ slack_block = modified_model._core_add_slack_variables
+
+ for v in slack_block.component_data_objects(pyo.Var):
+ v.fix(0)
+ # start with variable bounds -- these are the easiest to interpret
+ for c in modified_model._variable_bounds.component_data_objects(
+ pyo.Constraint, descend_into=True
+ ):
+ plus = slack_block.component(f"_slack_plus_{c.name}")
+ minus = slack_block.component(f"_slack_minus_{c.name}")
+ assert not (plus is None and minus is None)
+ if plus is not None:
+ plus.unfix()
+ if minus is not None:
+ minus.unfix()
+
+ # TODO: Elasticizing too much at once seems to cause Ipopt trouble.
+ # After an initial sweep, we should just fix one elastic variable
+ # and put everything else on a stack of "constraints to elasticize".
+ # We elasticize one constraint at a time and fix one constraint at a time.
+ # After fixing an elastic variable, we elasticize a single constraint it
+ # appears in and put the remaining constraints on the stack. If the resulting problem
+ # is feasible, we keep going "down the tree". If the resulting problem is
+ # infeasible or cannot be solved, we elasticize a single constraint from
+ # the top of the stack.
+ # The algorithm stops when the stack is empty and the subproblem is infeasible.
+ # Along the way, any time the current problem is infeasible we can check to
+ # see if the current set of constraints in the filter is as a collection of
+ # infeasible constraints -- to terminate early.
+ # However, while more stable, this is much more computationally intensive.
+ # So, we leave the implementation simpler for now and consider this as
+ # a potential extension if this tool sometimes cannot report a good answer.
+ # Phase 1 -- build the initial set of constraints, or prove feasibility
+ msg = ""
+ fixed_slacks = ComponentSet()
+ elastic_filter = ComponentSet()
+
+ def _constraint_loop(relaxed_things, msg):
+ if msg == "":
+ msg += f"Model {model.name} may be infeasible. A feasible solution was found with only the following {relaxed_things} relaxed:\n"
+ else:
+ msg += f"Another feasible solution was found with only the following {relaxed_things} relaxed:\n"
+ while True:
+
+ def _constraint_generator():
+ elastic_filter_size_initial = len(elastic_filter)
+ for v in slack_block.component_data_objects(pyo.Var):
+ if v.value > tolerance:
+ constr = _get_constraint(modified_model, v)
+ yield constr, v.value
+ v.fix(0)
+ fixed_slacks.add(v)
+ elastic_filter.add(constr)
+ if len(elastic_filter) == elastic_filter_size_initial:
+ raise Exception(f"Found model {model.name} to be feasible!")
+
+ msg = _get_results_with_value(_constraint_generator(), msg)
+ for var, val in _modified_model_value_cache.items():
+ var.set_value(val, skip_validation=True)
+ results = solver.solve(modified_model, tee=tee)
+ if pyo.check_optimal_termination(results):
+ msg += f"Another feasible solution was found with only the following {relaxed_things} relaxed:\n"
+ else:
+ break
+ return msg
+
+ results = solver.solve(modified_model, tee=tee)
+ if pyo.check_optimal_termination(results):
+ msg = _constraint_loop("variable bounds", msg)
+
+ # next, try relaxing the inequality constraints
+ for v in slack_block.component_data_objects(pyo.Var):
+ c = _get_constraint(modified_model, v)
+ if c.equality:
+ # equality constraint
+ continue
+ if v not in fixed_slacks:
+ v.unfix()
+
+ results = solver.solve(modified_model, tee=tee)
+ if pyo.check_optimal_termination(results):
+ msg = _constraint_loop("inequality constraints and/or variable bounds", msg)
+
+ for v in slack_block.component_data_objects(pyo.Var):
+ if v not in fixed_slacks:
+ v.unfix()
+
+ results = solver.solve(modified_model, tee=tee)
+ if pyo.check_optimal_termination(results):
+ msg = _constraint_loop(
+ "inequality constraints, equality constraints, and/or variable bounds", msg
+ )
+
+ if len(elastic_filter) == 0:
+ # load the feasible solution into the original model
+ for modified_model_var, v in _modified_model_var_to_original_model_var.items():
+ v.set_value(modified_model_var.value, skip_validation=True)
+ results = solver.solve(model, tee=tee)
+ if pyo.check_optimal_termination(results):
+ logger.info(f"A feasible solution was found!")
+ else:
+ logger.info(
+ f"Could not find a feasible solution with violated constraints or bounds. This model is likely unstable"
+ )
+
+ # Phase 2 -- deletion filter
+ # remove slacks by fixing them to 0
+ for v in slack_block.component_data_objects(pyo.Var):
+ v.fix(0)
+ for o in modified_model.component_data_objects(pyo.Objective, descend_into=True):
+ o.deactivate()
+
+ # mark all constraints not in the filter as inactive
+ for c in modified_model.component_data_objects(pyo.Constraint):
+ if c in elastic_filter:
+ continue
+ else:
+ c.deactivate()
+
+ try:
+ results = solver.solve(modified_model, tee=tee)
+ except:
+ results = None
+
+ if pyo.check_optimal_termination(results):
+ msg += "Could not determine Minimal Intractable System\n"
+ else:
+ deletion_filter = []
+ guards = []
+ for constr in elastic_filter:
+ constr.deactivate()
+ for var, val in _modified_model_value_cache.items():
+ var.set_value(val, skip_validation=True)
+ math_failure = False
+ try:
+ results = solver.solve(modified_model, tee=tee)
+ except:
+ math_failure = True
+
+ if math_failure:
+ constr.activate()
+ guards.append(constr)
+ elif pyo.check_optimal_termination(results):
+ constr.activate()
+ deletion_filter.append(constr)
+ else: # still infeasible without this constraint
+ pass
+
+ msg += "Computed Minimal Intractable System (MIS)!\n"
+ msg += "Constraints / bounds in MIS:\n"
+ msg = _get_results(deletion_filter, msg)
+ msg += "Constraints / bounds in guards for stability:"
+ msg = _get_results(guards, msg)
+
+ logger.info(msg)
+
+
+def _get_results_with_value(constr_value_generator, msg=None):
+ # note that "lb_for_" and "ub_for_" are 7 characters long
+ if msg is None:
+ msg = ""
+ for c, value in constr_value_generator:
+ c_name = c.name
+ if "_variable_bounds" in c_name:
+ name = c.local_name
+ if "lb" in name:
+ msg += f"\tlb of var {name[7:]} by {value}\n"
+ elif "ub" in name:
+ msg += f"\tub of var {name[7:]} by {value}\n"
+ else:
+ raise RuntimeError("unrecognized var name")
+ else:
+ msg += f"\tconstraint: {c_name} by {value}\n"
+ return msg
+
+
+def _get_results(constr_generator, msg=None):
+ # note that "lb_for_" and "ub_for_" are 7 characters long
+ if msg is None:
+ msg = ""
+ for c in constr_generator:
+ c_name = c.name
+ if "_variable_bounds" in c_name:
+ name = c.local_name
+ if "lb" in name:
+ msg += f"\tlb of var {name[7:]}\n"
+ elif "ub" in name:
+ msg += f"\tub of var {name[7:]}\n"
+ else:
+ raise RuntimeError("unrecognized var name")
+ else:
+ msg += f"\tconstraint: {c_name}\n"
+ return msg
+
+
+def _get_constraint(modified_model, v):
+ if "_slack_plus_" in v.name:
+ constr = modified_model.find_component(v.local_name[len("_slack_plus_") :])
+ if constr is None:
+ raise RuntimeError(
+ f"Bad constraint name {v.local_name[len('_slack_plus_'):]}"
+ )
+ return constr
+ elif "_slack_minus_" in v.name:
+ constr = modified_model.find_component(v.local_name[len("_slack_minus_") :])
+ if constr is None:
+ raise RuntimeError(
+ f"Bad constraint name {v.local_name[len('_slack_minus_'):]}"
+ )
+ return constr
+ else:
+ raise RuntimeError(f"Bad var name {v.name}")
diff --git a/pyomo/contrib/iis/tests/test_mis.py b/pyomo/contrib/iis/tests/test_mis.py
new file mode 100644
index 00000000000..bbdb2367016
--- /dev/null
+++ b/pyomo/contrib/iis/tests/test_mis.py
@@ -0,0 +1,125 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.unittest as unittest
+import pyomo.environ as pyo
+import pyomo.contrib.iis.mis as mis
+from pyomo.contrib.iis.mis import _get_constraint
+from pyomo.common.tempfiles import TempfileManager
+
+import logging
+import os
+
+
+def _get_infeasible_model():
+ m = pyo.ConcreteModel("trivial4test")
+ m.x = pyo.Var(within=pyo.Binary)
+ m.y = pyo.Var(within=pyo.NonNegativeReals)
+
+ m.c1 = pyo.Constraint(expr=m.y <= 100.0 * m.x)
+ m.c2 = pyo.Constraint(expr=m.y <= -100.0 * m.x)
+ m.c3 = pyo.Constraint(expr=m.x >= 0.5)
+
+ m.o = pyo.Objective(expr=-m.y)
+
+ return m
+
+
+def _get_feasible_model():
+ m = pyo.ConcreteModel("Trivial Feasible Quad")
+ m.x = pyo.Var([1, 2], bounds=(0, 1))
+ m.y = pyo.Var(bounds=(0, 1))
+ m.c = pyo.Constraint(expr=m.x[1] * m.x[2] >= -1)
+ m.d = pyo.Constraint(expr=m.x[1] + m.y >= 1)
+
+ return m
+
+
+class TestMIS(unittest.TestCase):
+ @unittest.skipUnless(
+ pyo.SolverFactory("ipopt").available(exception_flag=False),
+ "ipopt not available",
+ )
+ def test_write_mis_ipopt(self):
+ _test_mis("ipopt")
+
+ def test__get_constraint_errors(self):
+ # A not-completely-cynical way to get the coverage up.
+ m = _get_infeasible_model() # not modified
+ fct = _get_constraint
+
+ m.foo_slack_plus_ = pyo.Var()
+ self.assertRaises(RuntimeError, fct, m, m.foo_slack_plus_)
+ m.foo_slack_minus_ = pyo.Var()
+ self.assertRaises(RuntimeError, fct, m, m.foo_slack_minus_)
+ m.foo_bar = pyo.Var()
+ self.assertRaises(RuntimeError, fct, m, m.foo_bar)
+
+ def test_feasible_model(self):
+ m = _get_feasible_model()
+ opt = pyo.SolverFactory("ipopt")
+ self.assertRaises(Exception, mis.compute_infeasibility_explanation, m, opt)
+
+
+def _check_output(file_name):
+ # pretty simple check for now
+ with open(file_name, "r+") as file1:
+ lines = file1.readlines()
+ trigger = "Constraints / bounds in MIS:"
+ nugget = "lb of var y"
+ live = False # (long i)
+ found_nugget = False
+ for line in lines:
+ if trigger in line:
+ live = True
+ if live:
+ if nugget in line:
+ found_nugget = True
+ if not found_nugget:
+ raise RuntimeError(f"Did not find '{nugget}' after '{trigger}' in output")
+ else:
+ pass
+
+
+def _test_mis(solver_name):
+ m = _get_infeasible_model()
+ opt = pyo.SolverFactory(solver_name)
+
+ # This test seems to fail on Windows as it unlinks the tempfile, so live with it
+ # On a Windows machine, we will not use a temp dir and just try to delete the log file
+ if os.name == "nt":
+ file_name = f"_test_mis_{solver_name}.log"
+ logger = logging.getLogger(f"test_mis_{solver_name}")
+ logger.setLevel(logging.INFO)
+ fh = logging.FileHandler(file_name)
+ fh.setLevel(logging.DEBUG)
+ logger.addHandler(fh)
+
+ mis.compute_infeasibility_explanation(m, opt, logger=logger)
+ _check_output(file_name)
+ # os.remove(file_name) cannot remove it on Windows. Still in use.
+
+ else: # not windows
+ with TempfileManager.new_context() as tmpmgr:
+ tmp_path = tmpmgr.mkdtemp()
+ file_name = os.path.join(tmp_path, f"_test_mis_{solver_name}.log")
+ logger = logging.getLogger(f"test_mis_{solver_name}")
+ logger.setLevel(logging.INFO)
+ fh = logging.FileHandler(file_name)
+ fh.setLevel(logging.DEBUG)
+ logger.addHandler(fh)
+
+ mis.compute_infeasibility_explanation(m, opt, logger=logger)
+ _check_output(file_name)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/pyomo/contrib/iis/tests/trivial_mis.py b/pyomo/contrib/iis/tests/trivial_mis.py
new file mode 100644
index 00000000000..4cf0dd7a357
--- /dev/null
+++ b/pyomo/contrib/iis/tests/trivial_mis.py
@@ -0,0 +1,24 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.environ as pyo
+
+m = pyo.ConcreteModel("Trivial Quad")
+m.x = pyo.Var([1, 2], bounds=(0, 1))
+m.y = pyo.Var(bounds=(0, 1))
+m.c = pyo.Constraint(expr=m.x[1] * m.x[2] == -1)
+m.d = pyo.Constraint(expr=m.x[1] + m.y >= 1)
+
+from pyomo.contrib.iis.mis import compute_infeasibility_explanation
+
+# Note: this particular little problem is quadratic
+# As of 18Feb2024 DLW is not sure the explanation code works with solvers other than ipopt
+ipopt = pyo.SolverFactory("ipopt")
+compute_infeasibility_explanation(m, solver=ipopt)
diff --git a/pyomo/contrib/incidence_analysis/config.py b/pyomo/contrib/incidence_analysis/config.py
index 128273b4dec..9fac48c8a26 100644
--- a/pyomo/contrib/incidence_analysis/config.py
+++ b/pyomo/contrib/incidence_analysis/config.py
@@ -36,6 +36,13 @@ class IncidenceMethod(enum.Enum):
"""Use ``pyomo.repn.plugins.nl_writer.AMPLRepnVisitor``"""
+class IncidenceOrder(enum.Enum):
+
+ dulmage_mendelsohn_upper = 0
+
+ dulmage_mendelsohn_lower = 1
+
+
_include_fixed = ConfigValue(
default=False,
domain=bool,
@@ -123,7 +130,6 @@ def get_config_from_kwds(**kwds):
and kwds.get("_ampl_repn_visitor", None) is None
):
subexpression_cache = {}
- subexpression_order = []
external_functions = {}
var_map = {}
used_named_expressions = set()
@@ -136,7 +142,6 @@ def get_config_from_kwds(**kwds):
amplvisitor = AMPLRepnVisitor(
text_nl_template,
subexpression_cache,
- subexpression_order,
external_functions,
var_map,
used_named_expressions,
diff --git a/pyomo/contrib/incidence_analysis/incidence.py b/pyomo/contrib/incidence_analysis/incidence.py
index 96cbf77c47d..030ee2b0f79 100644
--- a/pyomo/contrib/incidence_analysis/incidence.py
+++ b/pyomo/contrib/incidence_analysis/incidence.py
@@ -83,6 +83,17 @@ def _get_incident_via_standard_repn(
def _get_incident_via_ampl_repn(expr, linear_only, visitor):
+ def _nonlinear_var_id_collector(idlist):
+ for _id in idlist:
+ if _id in visitor.subexpression_cache:
+ info = visitor.subexpression_cache[_id][1]
+ if info.nonlinear:
+ yield from _nonlinear_var_id_collector(info.nonlinear[1])
+ if info.linear:
+ yield from _nonlinear_var_id_collector(info.linear)
+ else:
+ yield _id
+
var_map = visitor.var_map
orig_activevisitor = AMPLRepn.ActiveVisitor
AMPLRepn.ActiveVisitor = visitor
@@ -91,13 +102,13 @@ def _get_incident_via_ampl_repn(expr, linear_only, visitor):
finally:
AMPLRepn.ActiveVisitor = orig_activevisitor
- nonlinear_var_ids = [] if repn.nonlinear is None else repn.nonlinear[1]
nonlinear_var_id_set = set()
unique_nonlinear_var_ids = []
- for v_id in nonlinear_var_ids:
- if v_id not in nonlinear_var_id_set:
- nonlinear_var_id_set.add(v_id)
- unique_nonlinear_var_ids.append(v_id)
+ if repn.nonlinear:
+ for v_id in _nonlinear_var_id_collector(repn.nonlinear[1]):
+ if v_id not in nonlinear_var_id_set:
+ nonlinear_var_id_set.add(v_id)
+ unique_nonlinear_var_ids.append(v_id)
nonlinear_vars = [var_map[v_id] for v_id in unique_nonlinear_var_ids]
linear_only_vars = [
diff --git a/pyomo/contrib/incidence_analysis/interface.py b/pyomo/contrib/incidence_analysis/interface.py
index 50cb84daaf5..73d9722eb7e 100644
--- a/pyomo/contrib/incidence_analysis/interface.py
+++ b/pyomo/contrib/incidence_analysis/interface.py
@@ -15,7 +15,7 @@
import enum
import textwrap
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.core.base.var import Var
from pyomo.core.base.constraint import Constraint
from pyomo.core.base.objective import Objective
@@ -28,7 +28,7 @@
scipy as sp,
plotly,
)
-from pyomo.common.deprecation import deprecated
+from pyomo.common.deprecation import deprecated, deprecation_warning
from pyomo.contrib.incidence_analysis.config import get_config_from_kwds
from pyomo.contrib.incidence_analysis.matching import maximum_matching
from pyomo.contrib.incidence_analysis.connected import get_independent_submatrices
@@ -279,7 +279,7 @@ def __init__(self, model=None, active=True, include_inequality=True, **kwds):
self._incidence_graph = None
self._variables = None
self._constraints = None
- elif isinstance(model, _BlockData):
+ elif isinstance(model, BlockData):
self._constraints = [
con
for con in model.component_data_objects(Constraint, active=active)
@@ -348,7 +348,7 @@ def __init__(self, model=None, active=True, include_inequality=True, **kwds):
else:
raise TypeError(
"Unsupported type for incidence graph. Expected PyomoNLP"
- " or _BlockData but got %s." % type(model)
+ " or BlockData but got %s." % type(model)
)
@property
@@ -453,11 +453,29 @@ def _validate_input(self, variables, constraints):
raise ValueError("Neither variables nor a model have been provided.")
else:
variables = self.variables
+ elif self._incidence_graph is not None:
+ # If variables were provided and an incidence graph is cached,
+ # make sure the provided variables exist in the graph.
+ for var in variables:
+ if var not in self._var_index_map:
+ raise KeyError(
+ f"Variable {var} does not exist in the cached"
+ " incidence graph."
+ )
if constraints is None:
if self._incidence_graph is None:
raise ValueError("Neither constraints nor a model have been provided.")
else:
constraints = self.constraints
+ elif self._incidence_graph is not None:
+ # If constraints were provided and an incidence graph is cached,
+ # make sure the provided constraints exist in the graph.
+ for con in constraints:
+ if con not in self._con_index_map:
+ raise KeyError(
+ f"Constraint {con} does not exist in the cached"
+ " incidence graph."
+ )
_check_unindexed(variables + constraints)
return variables, constraints
@@ -854,7 +872,7 @@ def dulmage_mendelsohn(self, variables=None, constraints=None):
# Hopefully this does not get too confusing...
return var_partition, con_partition
- def remove_nodes(self, nodes, constraints=None):
+ def remove_nodes(self, variables=None, constraints=None):
"""Removes the specified variables and constraints (columns and
rows) from the cached incidence matrix.
@@ -866,35 +884,76 @@ def remove_nodes(self, nodes, constraints=None):
Parameters
----------
- nodes: list
- VarData or ConData objects whose columns or rows will be
- removed from the incidence matrix.
+ variables: list
+ VarData objects whose nodes will be removed from the incidence graph
constraints: list
- VarData or ConData objects whose columns or rows will be
- removed from the incidence matrix.
+ ConData objects whose nodes will be removed from the incidence graph
+
+ .. note::
+
+ **Deprecation in Pyomo v6.7.2**
+
+ The pre-6.7.2 implementation of ``remove_nodes`` allowed variables and
+ constraints to remove to be specified in a single list. This made
+ error checking difficult, and indeed, if invalid components were
+ provided, we carried on silently instead of throwing an error or
+ warning. As part of a fix to raise an error if an invalid component
+ (one that is not part of the incidence graph) is provided, we now require
+ variables and constraints to be specified separately.
"""
if constraints is None:
constraints = []
+ if variables is None:
+ variables = []
if self._incidence_graph is None:
raise RuntimeError(
"Attempting to remove variables and constraints from cached "
"incidence matrix,\nbut no incidence matrix has been cached."
)
- to_exclude = ComponentSet(nodes)
- to_exclude.update(constraints)
- vars_to_include = [v for v in self.variables if v not in to_exclude]
- cons_to_include = [c for c in self.constraints if c not in to_exclude]
+
+ vars_to_validate = []
+ cons_to_validate = []
+ depr_msg = (
+ "In IncidenceGraphInterface.remove_nodes, passing variables and"
+ " constraints in the same list is deprecated. Please separate your"
+ " variables and constraints and pass them in the order variables,"
+ " constraints."
+ )
+ if any(var in self._con_index_map for var in variables) or any(
+ con in self._var_index_map for con in constraints
+ ):
+ deprecation_warning(depr_msg, version="6.7.2")
+ # If we received variables/constraints in the same list, sort them.
+ # Any unrecognized objects will be caught by _validate_input.
+ for var in variables:
+ if var in self._con_index_map:
+ cons_to_validate.append(var)
+ else:
+ vars_to_validate.append(var)
+ for con in constraints:
+ if con in self._var_index_map:
+ vars_to_validate.append(con)
+ else:
+ cons_to_validate.append(con)
+
+ variables, constraints = self._validate_input(
+ vars_to_validate, cons_to_validate
+ )
+ v_exclude = ComponentSet(variables)
+ c_exclude = ComponentSet(constraints)
+ vars_to_include = [v for v in self.variables if v not in v_exclude]
+ cons_to_include = [c for c in self.constraints if c not in c_exclude]
incidence_graph = self._extract_subgraph(vars_to_include, cons_to_include)
# update attributes
self._variables = vars_to_include
self._constraints = cons_to_include
self._incidence_graph = incidence_graph
self._var_index_map = ComponentMap(
- (var, i) for i, var in enumerate(self.variables)
+ (var, i) for i, var in enumerate(vars_to_include)
)
self._con_index_map = ComponentMap(
- (con, i) for i, con in enumerate(self._constraints)
+ (con, i) for i, con in enumerate(cons_to_include)
)
def plot(self, variables=None, constraints=None, title=None, show=True):
diff --git a/pyomo/contrib/incidence_analysis/scc_solver.py b/pyomo/contrib/incidence_analysis/scc_solver.py
index 835e07c7c02..378647c190c 100644
--- a/pyomo/contrib/incidence_analysis/scc_solver.py
+++ b/pyomo/contrib/incidence_analysis/scc_solver.py
@@ -18,15 +18,16 @@
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
+ """Yield in order ``BlockData`` that each contain the variables and
constraints of a single diagonal block in a block lower triangularization
of the incidence matrix of constraints and variables
@@ -41,13 +42,16 @@ 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
------
- Tuple of ``_BlockData``, list-of-variables
+ Tuple of ``BlockData``, list-of-variables
Blocks containing the variables and constraints of every strongly
connected component, in a topological order. The variables are the
"input variables" for that block.
@@ -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
diff --git a/pyomo/contrib/incidence_analysis/tests/test_interface.py b/pyomo/contrib/incidence_analysis/tests/test_interface.py
index 4b77d60d8ba..9957e78168b 100644
--- a/pyomo/contrib/incidence_analysis/tests/test_interface.py
+++ b/pyomo/contrib/incidence_analysis/tests/test_interface.py
@@ -634,17 +634,15 @@ def test_exception(self):
nlp = PyomoNLP(model)
igraph = IncidenceGraphInterface(nlp)
- with self.assertRaises(RuntimeError) as exc:
+ with self.assertRaisesRegex(KeyError, "does not exist"):
variables = [model.P]
constraints = [model.ideal_gas]
igraph.maximum_matching(variables, constraints)
- self.assertIn("must be unindexed", str(exc.exception))
- with self.assertRaises(RuntimeError) as exc:
+ with self.assertRaisesRegex(KeyError, "does not exist"):
variables = [model.P]
constraints = [model.ideal_gas]
igraph.block_triangularize(variables, constraints)
- self.assertIn("must be unindexed", str(exc.exception))
@unittest.skipUnless(networkx_available, "networkx is not available.")
@@ -885,17 +883,15 @@ def test_exception(self):
model = make_gas_expansion_model()
igraph = IncidenceGraphInterface(model)
- with self.assertRaises(RuntimeError) as exc:
+ with self.assertRaisesRegex(KeyError, "does not exist"):
variables = [model.P]
constraints = [model.ideal_gas]
igraph.maximum_matching(variables, constraints)
- self.assertIn("must be unindexed", str(exc.exception))
- with self.assertRaises(RuntimeError) as exc:
+ with self.assertRaisesRegex(KeyError, "does not exist"):
variables = [model.P]
constraints = [model.ideal_gas]
igraph.block_triangularize(variables, constraints)
- self.assertIn("must be unindexed", str(exc.exception))
@unittest.skipUnless(scipy_available, "scipy is not available.")
def test_remove(self):
@@ -923,7 +919,7 @@ def test_remove(self):
# Say we know that these variables and constraints should
# be matched...
vars_to_remove = [model.F[0], model.F[2]]
- cons_to_remove = (model.mbal[1], model.mbal[2])
+ cons_to_remove = [model.mbal[1], model.mbal[2]]
igraph.remove_nodes(vars_to_remove, cons_to_remove)
variable_set = ComponentSet(igraph.variables)
self.assertNotIn(model.F[0], variable_set)
@@ -1309,7 +1305,7 @@ def test_remove(self):
# matrix.
vars_to_remove = [m.flow_comp[1]]
cons_to_remove = [m.flow_eqn[1]]
- igraph.remove_nodes(vars_to_remove + cons_to_remove)
+ igraph.remove_nodes(vars_to_remove, cons_to_remove)
var_dmp, con_dmp = igraph.dulmage_mendelsohn()
var_con_set = ComponentSet(igraph.variables + igraph.constraints)
underconstrained_set = ComponentSet(
@@ -1460,6 +1456,42 @@ def test_remove_no_matrix(self):
with self.assertRaisesRegex(RuntimeError, "no incidence matrix"):
igraph.remove_nodes([m.v1])
+ def test_remove_bad_node(self):
+ m = pyo.ConcreteModel()
+ m.x = pyo.Var([1, 2, 3])
+ m.eq = pyo.Constraint(pyo.PositiveIntegers)
+ m.eq[1] = m.x[1] * m.x[2] == m.x[3]
+ m.eq[2] = m.x[1] + 2 * m.x[2] == 3 * m.x[3]
+ igraph = IncidenceGraphInterface(m)
+ with self.assertRaisesRegex(KeyError, "does not exist"):
+ # Suppose we think something like this should work. We should get
+ # an error, and not silently do nothing.
+ igraph.remove_nodes([m.x], [m.eq[1]])
+
+ with self.assertRaisesRegex(KeyError, "does not exist"):
+ igraph.remove_nodes(None, [m.eq])
+
+ with self.assertRaisesRegex(KeyError, "does not exist"):
+ igraph.remove_nodes([[m.x[1], m.x[2]], [m.eq[1]]])
+
+ def test_remove_varcon_samelist_deprecated(self):
+ m = pyo.ConcreteModel()
+ m.x = pyo.Var([1, 2, 3])
+ m.eq = pyo.Constraint(pyo.PositiveIntegers)
+ m.eq[1] = m.x[1] * m.x[2] == m.x[3]
+ m.eq[2] = m.x[1] + 2 * m.x[2] == 3 * m.x[3]
+
+ igraph = IncidenceGraphInterface(m)
+ # This raises a deprecation warning. When the deprecated functionality
+ # is removed, this will fail, and this test should be updated accordingly.
+ igraph.remove_nodes([m.eq[1], m.x[1]])
+ self.assertEqual(len(igraph.variables), 2)
+ self.assertEqual(len(igraph.constraints), 1)
+
+ igraph.remove_nodes([], [m.eq[2], m.x[2]])
+ self.assertEqual(len(igraph.variables), 1)
+ self.assertEqual(len(igraph.constraints), 0)
+
@unittest.skipUnless(networkx_available, "networkx is not available.")
@unittest.skipUnless(scipy_available, "scipy is not available.")
@@ -1840,7 +1872,7 @@ def test_var_elim(self):
for adj_con in igraph.get_adjacent_to(m.x[1]):
for adj_var in igraph.get_adjacent_to(m.eq4):
igraph.add_edge(adj_var, adj_con)
- igraph.remove_nodes([m.x[1], m.eq4])
+ igraph.remove_nodes([m.x[1]], [m.eq4])
assert ComponentSet(igraph.variables) == ComponentSet([m.x[2], m.x[3], m.x[4]])
assert ComponentSet(igraph.constraints) == ComponentSet([m.eq1, m.eq2, m.eq3])
@@ -1888,7 +1920,7 @@ def test_block_data_obj(self):
self.assertEqual(len(var_dmp.unmatched), 1)
self.assertEqual(len(con_dmp.unmatched), 1)
- msg = "Unsupported type.*_BlockData"
+ msg = "Unsupported type.*BlockData"
with self.assertRaisesRegex(TypeError, msg):
igraph = IncidenceGraphInterface(m.block)
diff --git a/pyomo/contrib/incidence_analysis/tests/test_visualize.py b/pyomo/contrib/incidence_analysis/tests/test_visualize.py
new file mode 100644
index 00000000000..7c5538b671f
--- /dev/null
+++ b/pyomo/contrib/incidence_analysis/tests/test_visualize.py
@@ -0,0 +1,47 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.unittest as unittest
+from pyomo.common.dependencies import (
+ matplotlib,
+ matplotlib_available,
+ scipy_available,
+ networkx_available,
+)
+from pyomo.contrib.incidence_analysis.visualize import spy_dulmage_mendelsohn
+from pyomo.contrib.incidence_analysis.tests.models_for_testing import (
+ make_gas_expansion_model,
+ make_dynamic_model,
+ make_degenerate_solid_phase_model,
+)
+
+
+@unittest.skipUnless(matplotlib_available, "Matplotlib is not available")
+@unittest.skipUnless(scipy_available, "SciPy is not available")
+@unittest.skipUnless(networkx_available, "NetworkX is not available")
+class TestSpy(unittest.TestCase):
+ def test_spy_dulmage_mendelsohn(self):
+ models = [
+ make_gas_expansion_model(),
+ make_dynamic_model(),
+ make_degenerate_solid_phase_model(),
+ ]
+ for m in models:
+ fig, ax = spy_dulmage_mendelsohn(m)
+ # Note that this is a weak test. We just test that we can call the
+ # plot method, it doesn't raise an error, and gives us back the
+ # types we expect. We don't attempt to validate the resulting plot.
+ self.assertTrue(isinstance(fig, matplotlib.pyplot.Figure))
+ self.assertTrue(isinstance(ax, matplotlib.pyplot.Axes))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/pyomo/contrib/incidence_analysis/visualize.py b/pyomo/contrib/incidence_analysis/visualize.py
new file mode 100644
index 00000000000..af1bdbbb918
--- /dev/null
+++ b/pyomo/contrib/incidence_analysis/visualize.py
@@ -0,0 +1,219 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+"""Module for visualizing results of incidence graph or matrix analysis
+
+"""
+from pyomo.contrib.incidence_analysis.config import IncidenceOrder
+from pyomo.contrib.incidence_analysis.interface import (
+ IncidenceGraphInterface,
+ get_structural_incidence_matrix,
+)
+from pyomo.common.dependencies import matplotlib
+
+
+def _partition_variables_and_constraints(
+ model, order=IncidenceOrder.dulmage_mendelsohn_upper, **kwds
+):
+ """Partition variables and constraints in an incidence graph"""
+ igraph = IncidenceGraphInterface(model, **kwds)
+ vdmp, cdmp = igraph.dulmage_mendelsohn()
+
+ ucv = vdmp.unmatched + vdmp.underconstrained
+ ucc = cdmp.underconstrained
+
+ ocv = vdmp.overconstrained
+ occ = cdmp.overconstrained + cdmp.unmatched
+
+ ucvblocks, uccblocks = igraph.get_connected_components(
+ variables=ucv, constraints=ucc
+ )
+ ocvblocks, occblocks = igraph.get_connected_components(
+ variables=ocv, constraints=occ
+ )
+ wcvblocks, wccblocks = igraph.block_triangularize(
+ variables=vdmp.square, constraints=cdmp.square
+ )
+ # By default, we block-*lower* triangularize. By default, however, we want
+ # the Dulmage-Mendelsohn decomposition to be block-*upper* triangular.
+ wcvblocks.reverse()
+ wccblocks.reverse()
+ vpartition = [ucvblocks, wcvblocks, ocvblocks]
+ cpartition = [uccblocks, wccblocks, occblocks]
+
+ if order == IncidenceOrder.dulmage_mendelsohn_lower:
+ # If a block-lower triangular matrix was requested, we need to reverse
+ # both the inner and outer partitions
+ vpartition.reverse()
+ cpartition.reverse()
+ for vb in vpartition:
+ vb.reverse()
+ for cb in cpartition:
+ cb.reverse()
+
+ return vpartition, cpartition
+
+
+def _get_rectangle_around_coords(ij1, ij2, linewidth=2, linestyle="-"):
+ i1, j1 = ij1
+ i2, j2 = ij2
+ buffer = 0.5
+ ll_corner = (min(i1, i2) - buffer, min(j1, j2) - buffer)
+ width = abs(i1 - i2) + 2 * buffer
+ height = abs(j1 - j2) + 2 * buffer
+ rect = matplotlib.patches.Rectangle(
+ ll_corner,
+ width,
+ height,
+ clip_on=False,
+ fill=False,
+ edgecolor="orange",
+ linewidth=linewidth,
+ linestyle=linestyle,
+ )
+ return rect
+
+
+def spy_dulmage_mendelsohn(
+ model,
+ *,
+ incidence_kwds=None,
+ order=IncidenceOrder.dulmage_mendelsohn_upper,
+ highlight_coarse=True,
+ highlight_fine=True,
+ skip_wellconstrained=False,
+ ax=None,
+ linewidth=2,
+ spy_kwds=None,
+):
+ """Plot sparsity structure in Dulmage-Mendelsohn order on Matplotlib axes
+
+ This is a wrapper around the Matplotlib ``Axes.spy`` method for plotting
+ an incidence matrix in Dulmage-Mendelsohn order, with coarse and/or fine
+ partitions highlighted. The coarse partition refers to the under-constrained,
+ over-constrained, and well-constrained subsystems, while the fine partition
+ refers to block diagonal or block triangular partitions of the former
+ subsystems.
+
+ Parameters
+ ----------
+
+ model: ``ConcreteModel``
+ Input model to plot sparsity structure of
+
+ incidence_kwds: dict, optional
+ Config options for ``IncidenceGraphInterface``
+
+ order: ``IncidenceOrder``, optional
+ Order in which to plot sparsity structure. Default is
+ ``IncidenceOrder.dulmage_mendelsohn_upper`` for a block-upper triangular
+ matrix. Set to ``IncidenceOrder.dulmage_mendelsohn_lower`` for a
+ block-lower triangular matrix.
+
+ highlight_coarse: bool, optional
+ Whether to draw a rectangle around the coarse partition. Default True
+
+ highlight_fine: bool, optional
+ Whether to draw a rectangle around the fine partition. Default True
+
+ skip_wellconstrained: bool, optional
+ Whether to skip highlighting the well-constrained subsystem of the
+ coarse partition. Default False
+
+ ax: ``matplotlib.pyplot.Axes``, optional
+ Axes object on which to plot. If not provided, new figure
+ and axes are created.
+
+ linewidth: int, optional
+ Line width of for rectangle used to highlight. Default 2
+
+ spy_kwds: dict, optional
+ Keyword arguments for ``Axes.spy``
+
+ Returns
+ -------
+
+ fig: ``matplotlib.pyplot.Figure`` or ``None``
+ Figure on which the sparsity structure is plotted. ``None`` if axes
+ are provided
+
+ ax: ``matplotlib.pyplot.Axes``
+ Axes on which the sparsity structure is plotted
+
+ """
+ plt = matplotlib.pyplot
+ if incidence_kwds is None:
+ incidence_kwds = {}
+ if spy_kwds is None:
+ spy_kwds = {}
+
+ vpart, cpart = _partition_variables_and_constraints(model, order=order)
+ vpart_fine = sum(vpart, [])
+ cpart_fine = sum(cpart, [])
+ vorder = sum(vpart_fine, [])
+ corder = sum(cpart_fine, [])
+
+ imat = get_structural_incidence_matrix(vorder, corder)
+ nvar = len(vorder)
+ ncon = len(corder)
+
+ if ax is None:
+ fig, ax = plt.subplots()
+ else:
+ fig = None
+
+ markersize = spy_kwds.pop("markersize", None)
+ if markersize is None:
+ # At 10000 vars/cons, we want markersize=0.2
+ # At 20 vars/cons, we want markersize=10
+ # We assume we want a linear relationship between 1/nvar
+ # and the markersize.
+ markersize = (10.0 - 0.2) / (1 / 20 - 1 / 10000) * (
+ 1 / max(nvar, ncon) - 1 / 10000
+ ) + 0.2
+
+ ax.spy(imat, markersize=markersize, **spy_kwds)
+ ax.tick_params(length=0)
+ if highlight_coarse:
+ start = (0, 0)
+ for i, (vblocks, cblocks) in enumerate(zip(vpart, cpart)):
+ # Get the total number of variables/constraints in this part
+ # of the coarse partition
+ nv = sum(len(vb) for vb in vblocks)
+ nc = sum(len(cb) for cb in cblocks)
+ stop = (start[0] + nv - 1, start[1] + nc - 1)
+ if not (i == 1 and skip_wellconstrained) and nv > 0 and nc > 0:
+ # Regardless of whether we are plotting in upper or lower
+ # triangular order, the well-constrained subsystem is at
+ # position 1
+ #
+ # The get-rectangle function doesn't look good if we give it
+ # an "empty region" to box.
+ ax.add_patch(
+ _get_rectangle_around_coords(start, stop, linewidth=linewidth)
+ )
+ start = (stop[0] + 1, stop[1] + 1)
+
+ if highlight_fine:
+ # Use dashed lines to distinguish inner from outer partitions
+ # if we are highlighting both
+ linestyle = "--" if highlight_coarse else "-"
+ start = (0, 0)
+ for vb, cb in zip(vpart_fine, cpart_fine):
+ stop = (start[0] + len(vb) - 1, start[1] + len(cb) - 1)
+ # Note that the subset's we're boxing here can't be empty.
+ ax.add_patch(
+ _get_rectangle_around_coords(
+ start, stop, linestyle=linestyle, linewidth=linewidth
+ )
+ )
+ start = (stop[0] + 1, stop[1] + 1)
+
+ return fig, ax
diff --git a/pyomo/contrib/latex_printer/__init__.py b/pyomo/contrib/latex_printer/__init__.py
index c434b53dfe1..02eaa636a36 100644
--- a/pyomo/contrib/latex_printer/__init__.py
+++ b/pyomo/contrib/latex_printer/__init__.py
@@ -9,22 +9,11 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-# ___________________________________________________________________________
-#
-# Pyomo: Python Optimization Modeling Objects
-# Copyright (c) 2008-2023
-# 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.
-# ___________________________________________________________________________
-
# Recommended just to build all of the appropriate things
import pyomo.environ
# Remove one layer of .latex_printer
-# import statemnt is now:
+# import statement is now:
# from pyomo.contrib.latex_printer import latex_printer
try:
from pyomo.contrib.latex_printer.latex_printer import latex_printer
diff --git a/pyomo/contrib/latex_printer/latex_printer.py b/pyomo/contrib/latex_printer/latex_printer.py
index 110df7cd5ca..cf286472a66 100644
--- a/pyomo/contrib/latex_printer/latex_printer.py
+++ b/pyomo/contrib/latex_printer/latex_printer.py
@@ -9,17 +9,6 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-# ___________________________________________________________________________
-#
-# Pyomo: Python Optimization Modeling Objects
-# Copyright (c) 2008-2023
-# 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 math
import copy
import re
@@ -45,8 +34,8 @@
from pyomo.core.expr.visitor import identify_components
from pyomo.core.expr.base import ExpressionBase
-from pyomo.core.base.expression import ScalarExpression, _GeneralExpressionData
-from pyomo.core.base.objective import ScalarObjective, _GeneralObjectiveData
+from pyomo.core.base.expression import ScalarExpression, ExpressionData
+from pyomo.core.base.objective import ScalarObjective, ObjectiveData
import pyomo.core.kernel as kernel
from pyomo.core.expr.template_expr import (
GetItemExpression,
@@ -58,9 +47,9 @@
resolve_template,
templatize_rule,
)
-from pyomo.core.base.var import ScalarVar, _GeneralVarData, IndexedVar
-from pyomo.core.base.param import _ParamData, ScalarParam, IndexedParam
-from pyomo.core.base.set import _SetData
+from pyomo.core.base.var import ScalarVar, VarData, IndexedVar
+from pyomo.core.base.param import ParamData, ScalarParam, IndexedParam
+from pyomo.core.base.set import SetData, SetOperator
from pyomo.core.base.constraint import ScalarConstraint, IndexedConstraint
from pyomo.common.collections.component_map import ComponentMap
from pyomo.common.collections.component_set import ComponentSet
@@ -75,7 +64,7 @@
from pyomo.core.base.external import _PythonCallbackFunctionID
from pyomo.core.base.enums import SortComponents
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.repn.util import ExprType
@@ -90,6 +79,40 @@
from pyomo.common.dependencies import numpy as np, numpy_available
+set_operator_map = {
+ '|': r' \cup ',
+ '&': r' \cap ',
+ '*': r' \times ',
+ '-': r' \setminus ',
+ '^': r' \triangle ',
+}
+
+latex_reals = r'\mathds{R}'
+latex_integers = r'\mathds{Z}'
+
+domainMap = {
+ 'Reals': latex_reals,
+ 'PositiveReals': latex_reals + '_{> 0}',
+ 'NonPositiveReals': latex_reals + '_{\\leq 0}',
+ 'NegativeReals': latex_reals + '_{< 0}',
+ 'NonNegativeReals': latex_reals + '_{\\geq 0}',
+ 'Integers': latex_integers,
+ 'PositiveIntegers': latex_integers + '_{> 0}',
+ 'NonPositiveIntegers': latex_integers + '_{\\leq 0}',
+ 'NegativeIntegers': latex_integers + '_{< 0}',
+ 'NonNegativeIntegers': latex_integers + '_{\\geq 0}',
+ 'Boolean': '\\left\\{ \\text{True} , \\text{False} \\right \\}',
+ 'Binary': '\\left\\{ 0 , 1 \\right \\}',
+ # 'Any': None,
+ # 'AnyWithNone': None,
+ 'EmptySet': '\\varnothing',
+ 'UnitInterval': latex_reals,
+ 'PercentFraction': latex_reals,
+ # 'RealInterval' : None ,
+ # 'IntegerInterval' : None ,
+}
+
+
def decoder(num, base):
if int(num) != abs(num):
# Requiring an integer is nice, but not strictly necessary;
@@ -286,14 +309,15 @@ def handle_functionID_node(visitor, node, *args):
def handle_indexTemplate_node(visitor, node, *args):
- if node._set in ComponentSet(visitor.setMap.keys()):
+ if node._set in visitor.setMap:
# already detected set, do nothing
pass
else:
- visitor.setMap[node._set] = 'SET%d' % (len(visitor.setMap.keys()) + 1)
+ visitor.setMap[node._set] = 'SET%d' % (len(visitor.setMap) + 1)
- return '__I_PLACEHOLDER_8675309_GROUP_%s_%s__' % (
+ return '__I_PLACEHOLDER_8675309_GROUP_%s_%s_%s__' % (
node._group,
+ node._id,
visitor.setMap[node._set],
)
@@ -315,8 +339,9 @@ def handle_numericGetItemExpression_node(visitor, node, *args):
def handle_templateSumExpression_node(visitor, node, *args):
pstr = ''
for i in range(0, len(node._iters)):
- pstr += '\\sum_{__S_PLACEHOLDER_8675309_GROUP_%s_%s__} ' % (
+ pstr += '\\sum_{__S_PLACEHOLDER_8675309_GROUP_%s_%s_%s__} ' % (
node._iters[i][0]._group,
+ ','.join(str(it._id) for it in node._iters[i]),
visitor.setMap[node._iters[i][0]._set],
)
@@ -374,12 +399,12 @@ def __init__(self):
EqualityExpression: handle_equality_node,
InequalityExpression: handle_inequality_node,
RangedExpression: handle_ranged_inequality_node,
- _GeneralExpressionData: handle_named_expression_node,
+ ExpressionData: handle_named_expression_node,
ScalarExpression: handle_named_expression_node,
kernel.expression.expression: handle_named_expression_node,
kernel.expression.noclone: handle_named_expression_node,
- _GeneralObjectiveData: handle_named_expression_node,
- _GeneralVarData: handle_var_node,
+ ObjectiveData: handle_named_expression_node,
+ VarData: handle_var_node,
ScalarObjective: handle_named_expression_node,
kernel.objective.objective: handle_named_expression_node,
ExternalFunctionExpression: handle_external_function_node,
@@ -392,7 +417,7 @@ def __init__(self):
Numeric_GetItemExpression: handle_numericGetItemExpression_node,
TemplateSumExpression: handle_templateSumExpression_node,
ScalarParam: handle_param_node,
- _ParamData: handle_param_node,
+ ParamData: handle_param_node,
IndexedParam: handle_param_node,
NPV_Numeric_GetItemExpression: handle_numericGetItemExpression_node,
IndexedBlock: handle_indexedBlock_node,
@@ -416,28 +441,6 @@ def exitNode(self, node, data):
def analyze_variable(vr):
- domainMap = {
- 'Reals': '\\mathds{R}',
- 'PositiveReals': '\\mathds{R}_{> 0}',
- 'NonPositiveReals': '\\mathds{R}_{\\leq 0}',
- 'NegativeReals': '\\mathds{R}_{< 0}',
- 'NonNegativeReals': '\\mathds{R}_{\\geq 0}',
- 'Integers': '\\mathds{Z}',
- 'PositiveIntegers': '\\mathds{Z}_{> 0}',
- 'NonPositiveIntegers': '\\mathds{Z}_{\\leq 0}',
- 'NegativeIntegers': '\\mathds{Z}_{< 0}',
- 'NonNegativeIntegers': '\\mathds{Z}_{\\geq 0}',
- 'Boolean': '\\left\\{ \\text{True} , \\text{False} \\right \\}',
- 'Binary': '\\left\\{ 0 , 1 \\right \\}',
- # 'Any': None,
- # 'AnyWithNone': None,
- 'EmptySet': '\\varnothing',
- 'UnitInterval': '\\mathds{R}',
- 'PercentFraction': '\\mathds{R}',
- # 'RealInterval' : None ,
- # 'IntegerInterval' : None ,
- }
-
domainName = vr.domain.name
varBounds = vr.bounds
lowerBoundValue = varBounds[0]
@@ -584,7 +587,7 @@ def latex_printer(
Parameters
----------
- pyomo_component: _BlockData or Model or Objective or Constraint or Expression
+ pyomo_component: BlockData or Model or Objective or Constraint or Expression
The Pyomo component to be printed
latex_component_map: pyomo.common.collections.component_map.ComponentMap
@@ -627,15 +630,15 @@ def latex_printer(
# Cody's backdoor because he got outvoted
if latex_component_map is not None:
- if 'use_short_descriptors' in list(latex_component_map.keys()):
+ if 'use_short_descriptors' in latex_component_map:
if latex_component_map['use_short_descriptors'] == False:
use_short_descriptors = False
if latex_component_map is None:
latex_component_map = ComponentMap()
- existing_components = ComponentSet([])
+ existing_components = ComponentSet()
else:
- existing_components = ComponentSet(list(latex_component_map.keys()))
+ existing_components = ComponentSet(latex_component_map)
isSingle = False
@@ -671,7 +674,7 @@ def latex_printer(
use_equation_environment = True
isSingle = True
- elif isinstance(pyomo_component, _BlockData):
+ elif isinstance(pyomo_component, BlockData):
objectives = [
obj
for obj in pyomo_component.component_data_objects(
@@ -702,10 +705,8 @@ def latex_printer(
if isSingle:
temp_comp, temp_indexes = templatize_fcn(pyomo_component)
variableList = []
- for v in identify_components(
- temp_comp, [ScalarVar, _GeneralVarData, IndexedVar]
- ):
- if isinstance(v, _GeneralVarData):
+ for v in identify_components(temp_comp, [ScalarVar, VarData, IndexedVar]):
+ if isinstance(v, VarData):
v_write = v.parent_component()
if v_write not in ComponentSet(variableList):
variableList.append(v_write)
@@ -714,10 +715,8 @@ def latex_printer(
variableList.append(v)
parameterList = []
- for p in identify_components(
- temp_comp, [ScalarParam, _ParamData, IndexedParam]
- ):
- if isinstance(p, _ParamData):
+ for p in identify_components(temp_comp, [ScalarParam, ParamData, IndexedParam]):
+ if isinstance(p, ParamData):
p_write = p.parent_component()
if p_write not in ComponentSet(parameterList):
parameterList.append(p_write)
@@ -782,12 +781,12 @@ def latex_printer(
for vr in variableList:
vrIdx += 1
if isinstance(vr, ScalarVar):
- variableMap[vr] = 'x_' + str(vrIdx)
+ variableMap[vr] = 'x_' + str(vrIdx) + '_'
elif isinstance(vr, IndexedVar):
- variableMap[vr] = 'x_' + str(vrIdx)
+ variableMap[vr] = 'x_' + str(vrIdx) + '_'
for sd in vr.index_set().data():
vrIdx += 1
- variableMap[vr[sd]] = 'x_' + str(vrIdx)
+ variableMap[vr[sd]] = 'x_' + str(vrIdx) + '_'
else:
raise DeveloperError(
'Variable is not a variable. Should not happen. Contact developers'
@@ -799,12 +798,12 @@ def latex_printer(
for vr in parameterList:
pmIdx += 1
if isinstance(vr, ScalarParam):
- parameterMap[vr] = 'p_' + str(pmIdx)
+ parameterMap[vr] = 'p_' + str(pmIdx) + '_'
elif isinstance(vr, IndexedParam):
- parameterMap[vr] = 'p_' + str(pmIdx)
+ parameterMap[vr] = 'p_' + str(pmIdx) + '_'
for sd in vr.index_set().data():
pmIdx += 1
- parameterMap[vr[sd]] = 'p_' + str(pmIdx)
+ parameterMap[vr[sd]] = 'p_' + str(pmIdx) + '_'
else:
raise DeveloperError(
'Parameter is not a parameter. Should not happen. Contact developers'
@@ -915,24 +914,33 @@ def latex_printer(
# setMap = visitor.setMap
# Multiple constraints are generated using a set
if len(indices) > 0:
- if indices[0]._set in ComponentSet(visitor.setMap.keys()):
- # already detected set, do nothing
- pass
- else:
- visitor.setMap[indices[0]._set] = 'SET%d' % (
- len(visitor.setMap.keys()) + 1
+ conLine += ' \\qquad \\forall'
+
+ _bygroups = {}
+ for idx in indices:
+ _bygroups.setdefault(idx._group, []).append(idx)
+ for _group, idxs in _bygroups.items():
+ if idxs[0]._set in visitor.setMap:
+ # already detected set, do nothing
+ pass
+ else:
+ visitor.setMap[idxs[0]._set] = 'SET%d' % (
+ len(visitor.setMap) + 1
+ )
+
+ idxTag = ','.join(
+ '__I_PLACEHOLDER_8675309_GROUP_%s_%s_%s__'
+ % (idx._group, idx._id, visitor.setMap[idx._set])
+ for idx in idxs
)
- idxTag = '__I_PLACEHOLDER_8675309_GROUP_%s_%s__' % (
- indices[0]._group,
- visitor.setMap[indices[0]._set],
- )
- setTag = '__S_PLACEHOLDER_8675309_GROUP_%s_%s__' % (
- indices[0]._group,
- visitor.setMap[indices[0]._set],
- )
+ setTag = '__S_PLACEHOLDER_8675309_GROUP_%s_%s_%s__' % (
+ indices[0]._group,
+ ','.join(str(it._id) for it in idxs),
+ visitor.setMap[indices[0]._set],
+ )
- conLine += ' \\qquad \\forall %s \\in %s ' % (idxTag, setTag)
+ conLine += ' %s \\in %s ' % (idxTag, setTag)
pstr += conLine
# Add labels as needed
@@ -1059,15 +1067,22 @@ def latex_printer(
setMap = visitor.setMap
setMap_inverse = {vl: ky for ky, vl in setMap.items()}
+ def generate_set_name(st, lcm):
+ if st in lcm:
+ return lcm[st][0]
+ if st.parent_block().component(st.name) is st:
+ return st.name.replace('_', r'\_')
+ if isinstance(st, SetOperator):
+ return set_operator_map[st._operator.strip()].join(
+ generate_set_name(s, lcm) for s in st.subsets(False)
+ )
+ else:
+ return str(st).replace('_', r'\_').replace('{', r'\{').replace('}', r'\}')
+
# Handling the iterator indices
defaultSetLatexNames = ComponentMap()
- for ky, vl in setMap.items():
- st = ky
- defaultSetLatexNames[st] = st.name.replace('_', '\\_')
- if st in ComponentSet(latex_component_map.keys()):
- defaultSetLatexNames[st] = latex_component_map[st][
- 0
- ] # .replace('_', '\\_')
+ for ky in setMap:
+ defaultSetLatexNames[ky] = generate_set_name(ky, latex_component_map)
latexLines = pstr.split('\n')
for jj in range(0, len(latexLines)):
@@ -1081,8 +1096,8 @@ def latex_printer(
for word in splitLatex:
if "PLACEHOLDER_8675309_GROUP_" in word:
ifo = word.split("PLACEHOLDER_8675309_GROUP_")[1]
- gpNum, stName = ifo.split('_')
- if gpNum not in groupMap.keys():
+ gpNum, idNum, stName = ifo.split('_')
+ if gpNum not in groupMap:
groupMap[gpNum] = [stName]
if stName not in ComponentSet(uniqueSets):
uniqueSets.append(stName)
@@ -1099,10 +1114,7 @@ def latex_printer(
ix = int(ky[3:]) - 1
setInfo[ky]['setObject'] = setMap_inverse[ky] # setList[ix]
setInfo[ky]['setRegEx'] = (
- r'__S_PLACEHOLDER_8675309_GROUP_([0-9*])_%s__' % (ky)
- )
- setInfo[ky]['sumSetRegEx'] = (
- r'sum_{__S_PLACEHOLDER_8675309_GROUP_([0-9*])_%s__}' % (ky)
+ r'__S_PLACEHOLDER_8675309_GROUP_([0-9]+)_([0-9,]+)_%s__' % (ky,)
)
# setInfo[ky]['idxRegEx'] = r'__I_PLACEHOLDER_8675309_GROUP_[0-9*]_%s__'%(ky)
@@ -1127,27 +1139,41 @@ def latex_printer(
ed = stData[-1]
replacement = (
- r'sum_{ __I_PLACEHOLDER_8675309_GROUP_\1_%s__ = %d }^{%d}'
+ r'sum_{ __I_PLACEHOLDER_8675309_GROUP_\1_\2_%s__ = %d }^{%d}'
% (ky, bgn, ed)
)
- ln = re.sub(setInfo[ky]['sumSetRegEx'], replacement, ln)
+ ln = re.sub(
+ 'sum_{' + setInfo[ky]['setRegEx'] + '}', replacement, ln
+ )
else:
# if the set is not continuous or the flag has not been set
- replacement = (
- r'sum_{ __I_PLACEHOLDER_8675309_GROUP_\1_%s__ \\in __S_PLACEHOLDER_8675309_GROUP_\1_%s__ }'
- % (ky, ky)
- )
- ln = re.sub(setInfo[ky]['sumSetRegEx'], replacement, ln)
+ for _grp, _id in re.findall(
+ 'sum_{' + setInfo[ky]['setRegEx'] + '}', ln
+ ):
+ set_placeholder = '__S_PLACEHOLDER_8675309_GROUP_%s_%s_%s__' % (
+ _grp,
+ _id,
+ ky,
+ )
+ i_placeholder = ','.join(
+ '__I_PLACEHOLDER_8675309_GROUP_%s_%s_%s__' % (_grp, _, ky)
+ for _ in _id.split(',')
+ )
+ replacement = r'sum_{ %s \in %s }' % (
+ i_placeholder,
+ set_placeholder,
+ )
+ ln = ln.replace('sum_{' + set_placeholder + '}', replacement)
replacement = repr(defaultSetLatexNames[setInfo[ky]['setObject']])[1:-1]
ln = re.sub(setInfo[ky]['setRegEx'], replacement, ln)
# groupNumbers = re.findall(r'__I_PLACEHOLDER_8675309_GROUP_([0-9*])_SET[0-9]*__',ln)
setNumbers = re.findall(
- r'__I_PLACEHOLDER_8675309_GROUP_[0-9*]_SET([0-9]*)__', ln
+ r'__I_PLACEHOLDER_8675309_GROUP_[0-9]+_[0-9]+_SET([0-9]+)__', ln
)
- groupSetPairs = re.findall(
- r'__I_PLACEHOLDER_8675309_GROUP_([0-9*])_SET([0-9]*)__', ln
+ groupIdSetTuples = re.findall(
+ r'__I_PLACEHOLDER_8675309_GROUP_([0-9]+)_([0-9]+)_SET([0-9]+)__', ln
)
groupInfo = {}
@@ -1157,43 +1183,44 @@ def latex_printer(
'indices': [],
}
- for gp in groupSetPairs:
- if gp[0] not in groupInfo['SET' + gp[1]]['indices']:
- groupInfo['SET' + gp[1]]['indices'].append(gp[0])
+ for _gp, _id, _set in groupIdSetTuples:
+ if (_gp, _id) not in groupInfo['SET' + _set]['indices']:
+ groupInfo['SET' + _set]['indices'].append((_gp, _id))
+
+ def get_index_names(st, lcm):
+ if st in lcm:
+ return lcm[st][1]
+ elif isinstance(st, SetOperator):
+ return sum(
+ (get_index_names(s, lcm) for s in st.subsets(False)), start=[]
+ )
+ elif st.dimen is not None:
+ return [None] * st.dimen
+ else:
+ return [Ellipsis]
indexCounter = 0
for ky, vl in groupInfo.items():
- if vl['setObject'] in ComponentSet(latex_component_map.keys()):
- indexNames = latex_component_map[vl['setObject']][1]
- if len(indexNames) != 0:
- if len(indexNames) < len(vl['indices']):
- raise ValueError(
- 'Insufficient number of indices provided to the overwrite dictionary for set %s'
- % (vl['setObject'].name)
- )
- for i in range(0, len(vl['indices'])):
- ln = ln.replace(
- '__I_PLACEHOLDER_8675309_GROUP_%s_%s__'
- % (vl['indices'][i], ky),
- indexNames[i],
- )
- else:
- for i in range(0, len(vl['indices'])):
- ln = ln.replace(
- '__I_PLACEHOLDER_8675309_GROUP_%s_%s__'
- % (vl['indices'][i], ky),
- alphabetStringGenerator(indexCounter),
- )
- indexCounter += 1
- else:
- for i in range(0, len(vl['indices'])):
- ln = ln.replace(
- '__I_PLACEHOLDER_8675309_GROUP_%s_%s__'
- % (vl['indices'][i], ky),
- alphabetStringGenerator(indexCounter),
+ indexNames = get_index_names(vl['setObject'], latex_component_map)
+ nonNone = list(filter(None, indexNames))
+ if nonNone:
+ if len(nonNone) < len(vl['indices']):
+ raise ValueError(
+ 'Insufficient number of indices provided to the '
+ 'overwrite dictionary for set %s (expected %s, but got %s)'
+ % (vl['setObject'].name, len(vl['indices']), indexNames)
)
+ else:
+ indexNames = []
+ for i in vl['indices']:
+ indexNames.append(alphabetStringGenerator(indexCounter))
indexCounter += 1
-
+ for i in range(0, len(vl['indices'])):
+ ln = ln.replace(
+ '__I_PLACEHOLDER_8675309_GROUP_%s_%s_%s__'
+ % (*vl['indices'][i], ky),
+ indexNames[i],
+ )
latexLines[jj] = ln
pstr = '\n'.join(latexLines)
@@ -1236,25 +1263,25 @@ def latex_printer(
)
for ky, vl in new_variableMap.items():
- if ky not in ComponentSet(latex_component_map.keys()):
+ if ky not in latex_component_map:
latex_component_map[ky] = vl
for ky, vl in new_parameterMap.items():
- if ky not in ComponentSet(latex_component_map.keys()):
+ if ky not in latex_component_map:
latex_component_map[ky] = vl
rep_dict = {}
- for ky in ComponentSet(list(reversed(list(latex_component_map.keys())))):
- if isinstance(ky, (pyo.Var, _GeneralVarData)):
+ for ky in reversed(list(latex_component_map)):
+ if isinstance(ky, (pyo.Var, VarData)):
overwrite_value = latex_component_map[ky]
if ky not in existing_components:
overwrite_value = overwrite_value.replace('_', '\\_')
rep_dict[variableMap[ky]] = overwrite_value
- elif isinstance(ky, (pyo.Param, _ParamData)):
+ elif isinstance(ky, (pyo.Param, ParamData)):
overwrite_value = latex_component_map[ky]
if ky not in existing_components:
overwrite_value = overwrite_value.replace('_', '\\_')
rep_dict[parameterMap[ky]] = overwrite_value
- elif isinstance(ky, _SetData):
+ elif isinstance(ky, SetData):
# already handled
pass
elif isinstance(ky, (float, int)):
diff --git a/pyomo/contrib/latex_printer/tests/test_latex_printer.py b/pyomo/contrib/latex_printer/tests/test_latex_printer.py
index 2d7dd69dba8..b0ada97a5fe 100644
--- a/pyomo/contrib/latex_printer/tests/test_latex_printer.py
+++ b/pyomo/contrib/latex_printer/tests/test_latex_printer.py
@@ -9,25 +9,16 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-# ___________________________________________________________________________
-#
-# Pyomo: Python Optimization Modeling Objects
-# Copyright (c) 2008-2023
-# 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 io
+from textwrap import dedent
+
import pyomo.common.unittest as unittest
-from pyomo.contrib.latex_printer import latex_printer
+import pyomo.core.tests.examples.pmedian_concrete as pmedian_concrete
import pyomo.environ as pyo
-from textwrap import dedent
+
+from pyomo.contrib.latex_printer import latex_printer
from pyomo.common.tempfiles import TempfileManager
from pyomo.common.collections.component_map import ComponentMap
-
from pyomo.environ import (
Reals,
PositiveReals,
@@ -797,6 +788,50 @@ def ruleMaker_2(m, i):
self.assertEqual('\n' + pstr + '\n', bstr)
+ def test_latexPrinter_pmedian_verbose(self):
+ m = pmedian_concrete.create_model()
+ self.assertEqual(
+ latex_printer(m).strip(),
+ r"""
+\begin{align}
+ & \min
+ & & \sum_{ i \in Locations } \sum_{ j \in Customers } cost_{i,j} serve\_customer\_from\_location_{i,j} & \label{obj:M1_obj} \\
+ & \text{s.t.}
+ & & \sum_{ i \in Locations } serve\_customer\_from\_location_{i,j} = 1 & \qquad \forall j \in Customers \label{con:M1_single_x} \\
+ &&& serve\_customer\_from\_location_{i,j} \leq select\_location_{i} & \qquad \forall i,j \in Locations \times Customers \label{con:M1_bound_y} \\
+ &&& \sum_{ i \in Locations } select\_location_{i} = P & \label{con:M1_num_facilities} \\
+ & \text{w.b.}
+ & & 0.0 \leq serve\_customer\_from\_location \leq 1.0 & \qquad \in \mathds{R} \label{con:M1_serve_customer_from_location_bound} \\
+ &&& select\_location & \qquad \in \left\{ 0 , 1 \right \} \label{con:M1_select_location_bound}
+\end{align}
+ """.strip(),
+ )
+
+ def test_latexPrinter_pmedian_concise(self):
+ m = pmedian_concrete.create_model()
+ lcm = ComponentMap()
+ lcm[m.Locations] = ['L', ['n']]
+ lcm[m.Customers] = ['C', ['m']]
+ lcm[m.cost] = 'd'
+ lcm[m.serve_customer_from_location] = 'x'
+ lcm[m.select_location] = 'y'
+ self.assertEqual(
+ latex_printer(m, latex_component_map=lcm).strip(),
+ r"""
+\begin{align}
+ & \min
+ & & \sum_{ n \in L } \sum_{ m \in C } d_{n,m} x_{n,m} & \label{obj:M1_obj} \\
+ & \text{s.t.}
+ & & \sum_{ n \in L } x_{n,m} = 1 & \qquad \forall m \in C \label{con:M1_single_x} \\
+ &&& x_{n,m} \leq y_{n} & \qquad \forall n,m \in L \times C \label{con:M1_bound_y} \\
+ &&& \sum_{ n \in L } y_{n} = P & \label{con:M1_num_facilities} \\
+ & \text{w.b.}
+ & & 0.0 \leq x \leq 1.0 & \qquad \in \mathds{R} \label{con:M1_x_bound} \\
+ &&& y & \qquad \in \left\{ 0 , 1 \right \} \label{con:M1_y_bound}
+\end{align}
+ """.strip(),
+ )
+
if __name__ == '__main__':
unittest.main()
diff --git a/pyomo/contrib/mcpp/pyomo_mcpp.py b/pyomo/contrib/mcpp/pyomo_mcpp.py
index 35e883f98da..0ef0237681b 100644
--- a/pyomo/contrib/mcpp/pyomo_mcpp.py
+++ b/pyomo/contrib/mcpp/pyomo_mcpp.py
@@ -20,7 +20,7 @@
from pyomo.common.fileutils import Library
from pyomo.core import value, Expression
from pyomo.core.base.block import SubclassOf
-from pyomo.core.base.expression import _ExpressionData
+from pyomo.core.base.expression import NamedExpressionData
from pyomo.core.expr.numvalue import nonpyomo_leaf_types
from pyomo.core.expr.numeric_expr import (
AbsExpression,
@@ -307,7 +307,9 @@ def exitNode(self, node, data):
ans = self.mcpp.newConstant(node)
elif not node.is_expression_type():
ans = self.register_num(node)
- elif type(node) in SubclassOf(Expression) or isinstance(node, _ExpressionData):
+ elif type(node) in SubclassOf(Expression) or isinstance(
+ node, NamedExpressionData
+ ):
ans = data[0]
else:
raise RuntimeError("Unhandled expression type: %s" % (type(node)))
diff --git a/pyomo/contrib/mindtpy/algorithm_base_class.py b/pyomo/contrib/mindtpy/algorithm_base_class.py
index 785a89d8982..e015fc89e09 100644
--- a/pyomo/contrib/mindtpy/algorithm_base_class.py
+++ b/pyomo/contrib/mindtpy/algorithm_base_class.py
@@ -27,13 +27,7 @@
from operator import itemgetter
from pyomo.common.errors import DeveloperError
from pyomo.solvers.plugins.solvers.gurobi_direct import gurobipy
-from pyomo.opt import (
- SolverFactory,
- SolverResults,
- ProblemSense,
- SolutionStatus,
- SolverStatus,
-)
+from pyomo.opt import SolverFactory, SolverResults, SolutionStatus, SolverStatus
from pyomo.core import (
minimize,
maximize,
@@ -152,7 +146,9 @@ def __init__(self, **kwds):
# Store the OA cuts generated in the mip_start_process.
self.mip_start_lazy_oa_cuts = []
# Whether to load solutions in solve() function
- self.load_solutions = True
+ self.mip_load_solutions = True
+ self.nlp_load_solutions = True
+ self.regularization_mip_load_solutions = True
# Support use as a context manager under current solver API
def __enter__(self):
@@ -302,7 +298,7 @@ def model_is_valid(self):
results = self.mip_opt.solve(
self.original_model,
tee=config.mip_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.mip_load_solutions,
**config.mip_solver_args,
)
if len(results.solution) > 0:
@@ -633,9 +629,7 @@ def process_objective(self, update_var_con_list=True):
raise ValueError('Model has multiple active objectives.')
else:
main_obj = active_objectives[0]
- self.results.problem.sense = (
- ProblemSense.minimize if main_obj.sense == 1 else ProblemSense.maximize
- )
+ self.results.problem.sense = main_obj.sense
self.objective_sense = main_obj.sense
# Move the objective to the constraints if it is nonlinear or move_objective is True.
@@ -846,7 +840,7 @@ def init_rNLP(self, add_oa_cuts=True):
results = self.nlp_opt.solve(
self.rnlp,
tee=config.nlp_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.nlp_load_solutions,
**nlp_args,
)
if len(results.solution) > 0:
@@ -868,7 +862,7 @@ def init_rNLP(self, add_oa_cuts=True):
results = self.nlp_opt.solve(
self.rnlp,
tee=config.nlp_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.nlp_load_solutions,
**nlp_args,
)
if len(results.solution) > 0:
@@ -999,7 +993,10 @@ def init_max_binaries(self):
mip_args = dict(config.mip_solver_args)
update_solver_timelimit(self.mip_opt, config.mip_solver, self.timing, config)
results = self.mip_opt.solve(
- m, tee=config.mip_solver_tee, load_solutions=self.load_solutions, **mip_args
+ m,
+ tee=config.mip_solver_tee,
+ load_solutions=self.mip_load_solutions,
+ **mip_args,
)
if len(results.solution) > 0:
m.solutions.load_from(results)
@@ -1119,7 +1116,7 @@ def solve_subproblem(self):
results = self.nlp_opt.solve(
self.fixed_nlp,
tee=config.nlp_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.nlp_load_solutions,
**nlp_args,
)
if len(results.solution) > 0:
@@ -1387,12 +1384,20 @@ def solve_feasibility_subproblem(self):
update_solver_timelimit(
self.feasibility_nlp_opt, config.nlp_solver, self.timing, config
)
- TransformationFactory('contrib.deactivate_trivial_constraints').apply_to(
- feas_subproblem,
- tmp=True,
- ignore_infeasible=False,
- tolerance=config.constraint_tolerance,
- )
+ try:
+ TransformationFactory('contrib.deactivate_trivial_constraints').apply_to(
+ self.fixed_nlp,
+ tmp=True,
+ ignore_infeasible=False,
+ tolerance=config.constraint_tolerance,
+ )
+ except InfeasibleConstraintException as e:
+ config.logger.error(
+ str(e) + '\nInfeasibility detected in deactivate_trivial_constraints.'
+ )
+ results = SolverResults()
+ results.solver.termination_condition = tc.infeasible
+ return self.fixed_nlp, results
with SuppressInfeasibleWarning():
try:
with time_code(self.timing, 'feasibility subproblem'):
@@ -1578,7 +1583,7 @@ def fix_dual_bound(self, last_iter_cuts):
main_mip_results = self.mip_opt.solve(
self.mip,
tee=config.mip_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.mip_load_solutions,
**mip_args,
)
if len(main_mip_results.solution) > 0:
@@ -1666,7 +1671,7 @@ def solve_main(self):
main_mip_results = self.mip_opt.solve(
self.mip,
tee=config.mip_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.mip_load_solutions,
**mip_args,
)
# update_attributes should be before load_from(main_mip_results), since load_from(main_mip_results) may fail.
@@ -1727,7 +1732,7 @@ def solve_fp_main(self):
main_mip_results = self.mip_opt.solve(
self.mip,
tee=config.mip_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.mip_load_solutions,
**mip_args,
)
# update_attributes should be before load_from(main_mip_results), since load_from(main_mip_results) may fail.
@@ -1770,7 +1775,7 @@ def solve_regularization_main(self):
main_mip_results = self.regularization_mip_opt.solve(
self.mip,
tee=config.mip_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.regularization_mip_load_solutions,
**dict(config.mip_solver_args),
)
if len(main_mip_results.solution) > 0:
@@ -1986,7 +1991,7 @@ def handle_main_unbounded(self, main_mip):
main_mip_results = self.mip_opt.solve(
main_mip,
tee=config.mip_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.mip_load_solutions,
**config.mip_solver_args,
)
if len(main_mip_results.solution) > 0:
@@ -2269,6 +2274,11 @@ def check_subsolver_validity(self):
raise ValueError(self.config.mip_solver + ' is not available.')
if not self.mip_opt.license_is_valid():
raise ValueError(self.config.mip_solver + ' is not licensed.')
+ if self.config.mip_solver == "appsi_highs":
+ if self.mip_opt.version() < (1, 7, 0):
+ raise ValueError(
+ "MindtPy requires the use of HIGHS version 1.7.0 or higher for full compatibility."
+ )
if not self.nlp_opt.available():
raise ValueError(self.config.nlp_solver + ' is not available.')
if not self.nlp_opt.license_is_valid():
@@ -2316,15 +2326,15 @@ def check_config(self):
config.mip_solver = 'cplex_persistent'
# related to https://github.com/Pyomo/pyomo/issues/2363
+ if 'appsi' in config.mip_solver:
+ self.mip_load_solutions = False
+ if 'appsi' in config.nlp_solver:
+ self.nlp_load_solutions = False
if (
- 'appsi' in config.mip_solver
- or 'appsi' in config.nlp_solver
- or (
- config.mip_regularization_solver is not None
- and 'appsi' in config.mip_regularization_solver
- )
+ config.mip_regularization_solver is not None
+ and 'appsi' in config.mip_regularization_solver
):
- self.load_solutions = False
+ self.regularization_mip_load_solutions = False
################################################################################################################################
# Feasibility Pump
@@ -2392,7 +2402,7 @@ def solve_fp_subproblem(self):
results = self.nlp_opt.solve(
fp_nlp,
tee=config.nlp_solver_tee,
- load_solutions=self.load_solutions,
+ load_solutions=self.nlp_load_solutions,
**nlp_args,
)
if len(results.solution) > 0:
@@ -2957,6 +2967,10 @@ def MindtPy_iteration_loop(self):
skip_fixed=False,
)
if self.curr_int_sol not in set(self.integer_list):
+ # Call the NLP pre-solve callback
+ with time_code(self.timing, 'Call before subproblem solve'):
+ config.call_before_subproblem_solve(self.fixed_nlp)
+
fixed_nlp, fixed_nlp_result = self.solve_subproblem()
self.handle_nlp_subproblem_tc(fixed_nlp, fixed_nlp_result)
@@ -2968,6 +2982,10 @@ def MindtPy_iteration_loop(self):
# Solve NLP subproblem
# The constraint linearization happens in the handlers
if not config.solution_pool:
+ # Call the NLP pre-solve callback
+ with time_code(self.timing, 'Call before subproblem solve'):
+ config.call_before_subproblem_solve(self.fixed_nlp)
+
fixed_nlp, fixed_nlp_result = self.solve_subproblem()
self.handle_nlp_subproblem_tc(fixed_nlp, fixed_nlp_result)
@@ -3000,6 +3018,11 @@ def MindtPy_iteration_loop(self):
continue
else:
self.integer_list.append(self.curr_int_sol)
+
+ # Call the NLP pre-solve callback
+ with time_code(self.timing, 'Call before subproblem solve'):
+ config.call_before_subproblem_solve(self.fixed_nlp)
+
fixed_nlp, fixed_nlp_result = self.solve_subproblem()
self.handle_nlp_subproblem_tc(fixed_nlp, fixed_nlp_result)
diff --git a/pyomo/contrib/mindtpy/config_options.py b/pyomo/contrib/mindtpy/config_options.py
index ba2b74cdfe0..5d265e72cf6 100644
--- a/pyomo/contrib/mindtpy/config_options.py
+++ b/pyomo/contrib/mindtpy/config_options.py
@@ -323,6 +323,15 @@ def _add_common_configs(CONFIG):
doc='Callback hook after a solution of the main problem.',
),
)
+ CONFIG.declare(
+ 'call_before_subproblem_solve',
+ ConfigValue(
+ default=_DoNothing(),
+ domain=None,
+ description='Function to be executed before every subproblem',
+ doc='Callback hook before a solution of the nonlinear subproblem.',
+ ),
+ )
CONFIG.declare(
'call_after_subproblem_solve',
ConfigValue(
@@ -549,7 +558,7 @@ def _add_subsolver_configs(CONFIG):
'cplex_persistent',
'appsi_cplex',
'appsi_gurobi',
- # 'appsi_highs', TODO: feasibility pump now fails with appsi_highs #2951
+ 'appsi_highs',
]
),
description='MIP subsolver name',
@@ -631,7 +640,7 @@ def _add_subsolver_configs(CONFIG):
'cplex_persistent',
'appsi_cplex',
'appsi_gurobi',
- # 'appsi_highs',
+ 'appsi_highs',
]
),
description='MIP subsolver for regularization problem',
diff --git a/pyomo/contrib/mindtpy/single_tree.py b/pyomo/contrib/mindtpy/single_tree.py
index 05ba6bbee86..6b501ef874d 100644
--- a/pyomo/contrib/mindtpy/single_tree.py
+++ b/pyomo/contrib/mindtpy/single_tree.py
@@ -773,6 +773,9 @@ def __call__(self):
mindtpy_solver.integer_list.append(mindtpy_solver.curr_int_sol)
# solve subproblem
+ # Call the NLP pre-solve callback
+ with time_code(mindtpy_solver.timing, 'Call before subproblem solve'):
+ config.call_before_subproblem_solve(mindtpy_solver.fixed_nlp)
# The constraint linearization happens in the handlers
fixed_nlp, fixed_nlp_result = mindtpy_solver.solve_subproblem()
# add oa cuts
@@ -919,6 +922,9 @@ def LazyOACallback_gurobi(cb_m, cb_opt, cb_where, mindtpy_solver, config):
cut_ind = len(mindtpy_solver.mip.MindtPy_utils.cuts.oa_cuts)
# solve subproblem
+ # Call the NLP pre-solve callback
+ with time_code(mindtpy_solver.timing, 'Call before subproblem solve'):
+ config.call_before_subproblem_solve(mindtpy_solver.fixed_nlp)
# The constraint linearization happens in the handlers
fixed_nlp, fixed_nlp_result = mindtpy_solver.solve_subproblem()
diff --git a/pyomo/contrib/mindtpy/tests/test_mindtpy.py b/pyomo/contrib/mindtpy/tests/test_mindtpy.py
index 37969276d55..618967be00f 100644
--- a/pyomo/contrib/mindtpy/tests/test_mindtpy.py
+++ b/pyomo/contrib/mindtpy/tests/test_mindtpy.py
@@ -56,7 +56,12 @@
QCP_model._generate_model()
extreme_model_list = [LP_model.model, QCP_model.model]
-required_solvers = ('ipopt', 'glpk')
+if SolverFactory('appsi_highs').available(exception_flag=False) and SolverFactory(
+ 'appsi_highs'
+).version() >= (1, 7, 0):
+ required_solvers = ('ipopt', 'appsi_highs')
+else:
+ required_solvers = ('ipopt', 'glpk')
if all(SolverFactory(s).available(exception_flag=False) for s in required_solvers):
subsolvers_available = True
else:
@@ -101,6 +106,30 @@ def test_OA_rNLP(self):
)
self.check_optimal_solution(model)
+ def test_OA_callback(self):
+ """Test the outer approximation decomposition algorithm."""
+ with SolverFactory('mindtpy') as opt:
+
+ def callback(model):
+ model.Y[1].value = 0
+ model.Y[2].value = 0
+ model.Y[3].value = 0
+
+ model = SimpleMINLP2()
+ # The callback function will make the OA method cycling.
+ results = opt.solve(
+ model,
+ strategy='OA',
+ init_strategy='rNLP',
+ mip_solver=required_solvers[1],
+ nlp_solver=required_solvers[0],
+ call_before_subproblem_solve=callback,
+ )
+ self.assertIs(
+ results.solver.termination_condition, TerminationCondition.feasible
+ )
+ self.assertAlmostEqual(value(results.problem.lower_bound), 5, places=1)
+
def test_OA_extreme_model(self):
"""Test the outer approximation decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
diff --git a/pyomo/contrib/mindtpy/tests/test_mindtpy_ECP.py b/pyomo/contrib/mindtpy/tests/test_mindtpy_ECP.py
index 24679047793..dda0f74147e 100644
--- a/pyomo/contrib/mindtpy/tests/test_mindtpy_ECP.py
+++ b/pyomo/contrib/mindtpy/tests/test_mindtpy_ECP.py
@@ -23,7 +23,13 @@
from pyomo.environ import SolverFactory, value
from pyomo.opt import TerminationCondition
-required_solvers = ('ipopt', 'glpk')
+if SolverFactory('appsi_highs').available(exception_flag=False) and SolverFactory(
+ 'appsi_highs'
+).version() >= (1, 7, 0):
+ required_solvers = ('ipopt', 'appsi_highs')
+else:
+ required_solvers = ('ipopt', 'glpk')
+
if all(SolverFactory(s).available(exception_flag=False) for s in required_solvers):
subsolvers_available = True
else:
diff --git a/pyomo/contrib/mindtpy/tests/test_mindtpy_feas_pump.py b/pyomo/contrib/mindtpy/tests/test_mindtpy_feas_pump.py
index cbc906851bf..0baa361910e 100644
--- a/pyomo/contrib/mindtpy/tests/test_mindtpy_feas_pump.py
+++ b/pyomo/contrib/mindtpy/tests/test_mindtpy_feas_pump.py
@@ -28,8 +28,13 @@
from pyomo.contrib.mindtpy.tests.feasibility_pump1 import FeasPump1
from pyomo.contrib.mindtpy.tests.feasibility_pump2 import FeasPump2
-required_solvers = ('ipopt', 'glpk')
-# TODO: 'appsi_highs' will fail here.
+if SolverFactory('appsi_highs').available(exception_flag=False) and SolverFactory(
+ 'appsi_highs'
+).version() >= (1, 7, 0):
+ required_solvers = ('ipopt', 'appsi_highs')
+else:
+ required_solvers = ('ipopt', 'glpk')
+
if all(SolverFactory(s).available(exception_flag=False) for s in required_solvers):
subsolvers_available = True
else:
diff --git a/pyomo/contrib/mindtpy/tests/test_mindtpy_grey_box.py b/pyomo/contrib/mindtpy/tests/test_mindtpy_grey_box.py
index d50a41ad000..e01558d48ef 100644
--- a/pyomo/contrib/mindtpy/tests/test_mindtpy_grey_box.py
+++ b/pyomo/contrib/mindtpy/tests/test_mindtpy_grey_box.py
@@ -18,7 +18,14 @@
from pyomo.contrib.mindtpy.tests.MINLP_simple import SimpleMINLP as SimpleMINLP
model_list = [SimpleMINLP(grey_box=True)]
-required_solvers = ('cyipopt', 'glpk')
+
+if SolverFactory('appsi_highs').available(exception_flag=False) and SolverFactory(
+ 'appsi_highs'
+).version() >= (1, 7, 0):
+ required_solvers = ('cyipopt', 'appsi_highs')
+else:
+ required_solvers = ('cyipopt', 'glpk')
+
if all(SolverFactory(s).available(exception_flag=False) for s in required_solvers):
subsolvers_available = True
else:
diff --git a/pyomo/contrib/mindtpy/util.py b/pyomo/contrib/mindtpy/util.py
index 1543497838f..7345af8a3e2 100644
--- a/pyomo/contrib/mindtpy/util.py
+++ b/pyomo/contrib/mindtpy/util.py
@@ -29,7 +29,6 @@
from pyomo.contrib.mcpp.pyomo_mcpp import mcpp_available, McCormick
from pyomo.contrib.fbbt.fbbt import compute_bounds_on_expr
import pyomo.core.expr as EXPR
-from pyomo.opt import ProblemSense
from pyomo.contrib.gdpopt.util import get_main_elapsed_time, time_code
from pyomo.util.model_size import build_model_size_report
from pyomo.common.dependencies import attempt_import
diff --git a/pyomo/contrib/mpc/README.md b/pyomo/contrib/mpc/README.md
new file mode 100644
index 00000000000..7e03163f703
--- /dev/null
+++ b/pyomo/contrib/mpc/README.md
@@ -0,0 +1,34 @@
+# Pyomo MPC
+
+Pyomo MPC is an extension for developing model predictive control simulations
+using Pyomo models. Please see the
+[documentation](https://pyomo.readthedocs.io/en/stable/contributed_packages/mpc/index.html)
+for more detailed information.
+
+Pyomo MPC helps with, among other things, the following use cases:
+- Transferring values between different points in time in a dynamic model
+(e.g. to initialize a dynamic model to its initial conditions)
+- Extracting or loading disturbances and inputs from or to models, and storing
+these in model-agnostic, easily JSON-serializable data structures
+- Constructing common modeling components, such as weighted-least-squares
+tracking objective functions, piecewise-constant input constraints, or
+terminal region constraints.
+
+## Citation
+
+If you use Pyomo MPC in your research, please cite the following paper, which
+discusses the motivation for the Pyomo MPC data structures and the underlying
+Pyomo features that make them possible.
+```bibtex
+@article{parker2023mpc,
+title = {Model predictive control simulations with block-hierarchical differential-algebraic process models},
+journal = {Journal of Process Control},
+volume = {132},
+pages = {103113},
+year = {2023},
+issn = {0959-1524},
+doi = {https://doi.org/10.1016/j.jprocont.2023.103113},
+url = {https://www.sciencedirect.com/science/article/pii/S0959152423002007},
+author = {Robert B. Parker and Bethany L. Nicholson and John D. Siirola and Lorenz T. Biegler},
+}
+```
diff --git a/pyomo/contrib/mpc/data/get_cuid.py b/pyomo/contrib/mpc/data/get_cuid.py
index 03659d6153f..ef0df7ea679 100644
--- a/pyomo/contrib/mpc/data/get_cuid.py
+++ b/pyomo/contrib/mpc/data/get_cuid.py
@@ -16,14 +16,13 @@
def get_indexed_cuid(var, sets=None, dereference=None, context=None):
- """
- Attempts to convert the provided "var" object into a CUID with
- with wildcards.
+ """Attempt to convert the provided "var" object into a CUID with wildcards
Arguments
---------
var:
- Object to process
+ Object to process. May be a VarData, IndexedVar (reference or otherwise),
+ ComponentUID, slice, or string.
sets: Tuple of sets
Sets to use if slicing a vardata object
dereference: None or int
@@ -32,6 +31,11 @@ def get_indexed_cuid(var, sets=None, dereference=None, context=None):
context: Block
Block with respect to which slices and CUIDs will be generated
+ Returns
+ -------
+ ``ComponentUID``
+ ComponentUID corresponding to the provided ``var`` and sets
+
"""
# TODO: Does this function have a good name?
# Should this function be generalized beyond a single indexing set?
diff --git a/pyomo/contrib/parmest/examples/reaction_kinetics/simple_reaction_parmest_example.py b/pyomo/contrib/parmest/examples/reaction_kinetics/simple_reaction_parmest_example.py
index 7dfe0829262..5c8a0219946 100644
--- a/pyomo/contrib/parmest/examples/reaction_kinetics/simple_reaction_parmest_example.py
+++ b/pyomo/contrib/parmest/examples/reaction_kinetics/simple_reaction_parmest_example.py
@@ -18,6 +18,7 @@
Code provided by Paul Akula.
'''
+import pyomo.environ as pyo
from pyomo.environ import (
ConcreteModel,
Param,
@@ -32,6 +33,7 @@
value,
)
import pyomo.contrib.parmest.parmest as parmest
+from pyomo.contrib.parmest.experiment import Experiment
def simple_reaction_model(data):
@@ -72,7 +74,62 @@ def total_cost_rule(m):
return model
+# For this experiment class, data is dictionary
+class SimpleReactionExperiment(Experiment):
+
+ def __init__(self, data):
+ self.data = data
+ self.model = None
+
+ def create_model(self):
+ self.model = simple_reaction_model(self.data)
+
+ def label_model(self):
+
+ m = self.model
+
+ m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs.update(
+ [(m.x1, self.data['x1']), (m.x2, self.data['x2']), (m.y, self.data['y'])]
+ )
+
+ return m
+
+ def get_labeled_model(self):
+ self.create_model()
+ m = self.label_model()
+
+ return m
+
+
+# k[2] fixed
+class SimpleReactionExperimentK2Fixed(SimpleReactionExperiment):
+
+ def label_model(self):
+
+ m = super().label_model()
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update((k, pyo.ComponentUID(k)) for k in [m.k[1]])
+
+ return m
+
+
+# k[2] variable
+class SimpleReactionExperimentK2Variable(SimpleReactionExperiment):
+
+ def label_model(self):
+
+ m = super().label_model()
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update((k, pyo.ComponentUID(k)) for k in [m.k[1], m.k[2]])
+
+ return m
+
+
def main():
+
# Data from Table 5.2 in Y. Bard, "Nonlinear Parameter Estimation", (pg. 124)
data = [
{'experiment': 1, 'x1': 0.1, 'x2': 100, 'y': 0.98},
@@ -92,21 +149,34 @@ def main():
{'experiment': 15, 'x1': 0.1, 'x2': 300, 'y': 0.006},
]
+ # Create an experiment list with k[2] fixed
+ exp_list = []
+ for i in range(len(data)):
+ exp_list.append(SimpleReactionExperimentK2Fixed(data[i]))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
# =======================================================================
# Parameter estimation without covariance estimate
# Only estimate the parameter k[1]. The parameter k[2] will remain fixed
# at its initial value
- theta_names = ['k[1]']
- pest = parmest.Estimator(simple_reaction_model, data, theta_names)
+
+ pest = parmest.Estimator(exp_list)
obj, theta = pest.theta_est()
print(obj)
print(theta)
print()
+ # Create an experiment list with k[2] variable
+ exp_list = []
+ for i in range(len(data)):
+ exp_list.append(SimpleReactionExperimentK2Variable(data[i]))
+
# =======================================================================
# Estimate both k1 and k2 and compute the covariance matrix
- theta_names = ['k']
- pest = parmest.Estimator(simple_reaction_model, data, theta_names)
+ pest = parmest.Estimator(exp_list)
n = 15 # total number of data points used in the objective (y in 15 scenarios)
obj, theta, cov = pest.theta_est(calc_cov=True, cov_n=n)
print(obj)
diff --git a/pyomo/contrib/parmest/examples/reactor_design/bootstrap_example.py b/pyomo/contrib/parmest/examples/reactor_design/bootstrap_example.py
index 1a4dc75e083..598fef32b60 100644
--- a/pyomo/contrib/parmest/examples/reactor_design/bootstrap_example.py
+++ b/pyomo/contrib/parmest/examples/reactor_design/bootstrap_example.py
@@ -13,31 +13,27 @@
from os.path import join, abspath, dirname
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
+ ReactorDesignExperiment,
)
def main():
- # Vars to estimate
- theta_names = ["k1", "k2", "k3"]
- # Data
+ # Read in data
file_dirname = dirname(abspath(str(__file__)))
file_name = abspath(join(file_dirname, "reactor_data.csv"))
data = pd.read_csv(file_name)
- # Sum of squared error function
- def SSE(model, data):
- expr = (
- (float(data.iloc[0]["ca"]) - model.ca) ** 2
- + (float(data.iloc[0]["cb"]) - model.cb) ** 2
- + (float(data.iloc[0]["cc"]) - model.cc) ** 2
- + (float(data.iloc[0]["cd"]) - model.cd) ** 2
- )
- return expr
-
- # Create an instance of the parmest estimator
- pest = parmest.Estimator(reactor_design_model, data, theta_names, SSE)
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(ReactorDesignExperiment(data, i))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
+ pest = parmest.Estimator(exp_list, obj_function='SSE')
# Parameter estimation
obj, theta = pest.theta_est()
diff --git a/pyomo/contrib/parmest/examples/reactor_design/confidence_region_example.py b/pyomo/contrib/parmest/examples/reactor_design/confidence_region_example.py
new file mode 100644
index 00000000000..73129baf5cb
--- /dev/null
+++ b/pyomo/contrib/parmest/examples/reactor_design/confidence_region_example.py
@@ -0,0 +1,51 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pandas as pd
+from os.path import join, abspath, dirname
+import pyomo.contrib.parmest.parmest as parmest
+from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
+ ReactorDesignExperiment,
+)
+
+
+def main():
+
+ # Read in data
+ file_dirname = dirname(abspath(str(__file__)))
+ file_name = abspath(join(file_dirname, "reactor_data.csv"))
+ data = pd.read_csv(file_name)
+
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(ReactorDesignExperiment(data, i))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
+ pest = parmest.Estimator(exp_list, obj_function='SSE')
+
+ # Parameter estimation
+ obj, theta = pest.theta_est()
+
+ # Bootstrapping
+ bootstrap_theta = pest.theta_est_bootstrap(10)
+ print(bootstrap_theta)
+
+ # Confidence region test
+ CR = pest.confidence_region_test(bootstrap_theta, "MVN", [0.5, 0.75, 1.0])
+ print(CR)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/pyomo/contrib/parmest/examples/reactor_design/datarec_example.py b/pyomo/contrib/parmest/examples/reactor_design/datarec_example.py
index e995502d4ae..be08e727be9 100644
--- a/pyomo/contrib/parmest/examples/reactor_design/datarec_example.py
+++ b/pyomo/contrib/parmest/examples/reactor_design/datarec_example.py
@@ -9,24 +9,90 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
+import pyomo.environ as pyo
from pyomo.common.dependencies import numpy as np, pandas as pd
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
reactor_design_model,
+ ReactorDesignExperiment,
)
np.random.seed(1234)
-def reactor_design_model_for_datarec(data):
- # Unfix inlet concentration for data rec
- model = reactor_design_model(data)
- model.caf.fixed = False
+class ReactorDesignExperimentDataRec(ReactorDesignExperiment):
- return model
+ def __init__(self, data, data_std, experiment_number):
+
+ super().__init__(data, experiment_number)
+ self.data_std = data_std
+
+ def create_model(self):
+
+ self.model = m = reactor_design_model()
+ m.caf.fixed = False
+
+ return m
+
+ def label_model(self):
+
+ m = self.model
+
+ # experiment outputs
+ m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs.update(
+ [
+ (m.ca, self.data_i['ca']),
+ (m.cb, self.data_i['cb']),
+ (m.cc, self.data_i['cc']),
+ (m.cd, self.data_i['cd']),
+ ]
+ )
+
+ # experiment standard deviations
+ m.experiment_outputs_std = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs_std.update(
+ [
+ (m.ca, self.data_std['ca']),
+ (m.cb, self.data_std['cb']),
+ (m.cc, self.data_std['cc']),
+ (m.cd, self.data_std['cd']),
+ ]
+ )
+
+ # no unknowns (theta names)
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+
+ return m
+
+
+class ReactorDesignExperimentPostDataRec(ReactorDesignExperiment):
+
+ def __init__(self, data, data_std, experiment_number):
+
+ super().__init__(data, experiment_number)
+ self.data_std = data_std
+
+ def label_model(self):
+
+ m = super().label_model()
+
+ # add experiment standard deviations
+ m.experiment_outputs_std = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs_std.update(
+ [
+ (m.ca, self.data_std['ca']),
+ (m.cb, self.data_std['cb']),
+ (m.cc, self.data_std['cc']),
+ (m.cd, self.data_std['cd']),
+ ]
+ )
+
+ return m
def generate_data():
+
### Generate data based on real sv, caf, ca, cb, cc, and cd
sv_real = 1.05
caf_real = 10000
@@ -53,24 +119,26 @@ def generate_data():
def main():
+
# Generate data
data = generate_data()
data_std = data.std()
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(ReactorDesignExperimentDataRec(data, data_std, i))
+
# Define sum of squared error objective function for data rec
- def SSE(model, data):
- expr = (
- ((float(data.iloc[0]["ca"]) - model.ca) / float(data_std["ca"])) ** 2
- + ((float(data.iloc[0]["cb"]) - model.cb) / float(data_std["cb"])) ** 2
- + ((float(data.iloc[0]["cc"]) - model.cc) / float(data_std["cc"])) ** 2
- + ((float(data.iloc[0]["cd"]) - model.cd) / float(data_std["cd"])) ** 2
+ def SSE_with_std(model):
+ expr = sum(
+ ((y - y_hat) / model.experiment_outputs_std[y]) ** 2
+ for y, y_hat in model.experiment_outputs.items()
)
return expr
### Data reconciliation
- theta_names = [] # no variables to estimate, use initialized values
-
- pest = parmest.Estimator(reactor_design_model_for_datarec, data, theta_names, SSE)
+ pest = parmest.Estimator(exp_list, obj_function=SSE_with_std)
obj, theta, data_rec = pest.theta_est(return_values=["ca", "cb", "cc", "cd", "caf"])
print(obj)
@@ -83,10 +151,14 @@ def SSE(model, data):
)
### Parameter estimation using reconciled data
- theta_names = ["k1", "k2", "k3"]
data_rec["sv"] = data["sv"]
- pest = parmest.Estimator(reactor_design_model, data_rec, theta_names, SSE)
+ # make a new list of experiments using reconciled data
+ exp_list = []
+ for i in range(data_rec.shape[0]):
+ exp_list.append(ReactorDesignExperimentPostDataRec(data_rec, data_std, i))
+
+ pest = parmest.Estimator(exp_list, obj_function=SSE_with_std)
obj, theta = pest.theta_est()
print(obj)
print(theta)
diff --git a/pyomo/contrib/parmest/examples/reactor_design/leaveNout_example.py b/pyomo/contrib/parmest/examples/reactor_design/leaveNout_example.py
index 8cac82e3879..9560981ca5c 100644
--- a/pyomo/contrib/parmest/examples/reactor_design/leaveNout_example.py
+++ b/pyomo/contrib/parmest/examples/reactor_design/leaveNout_example.py
@@ -13,15 +13,13 @@
from os.path import join, abspath, dirname
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
+ ReactorDesignExperiment,
)
def main():
- # Vars to estimate
- theta_names = ["k1", "k2", "k3"]
- # Data
+ # Read in data
file_dirname = dirname(abspath(str(__file__)))
file_name = abspath(join(file_dirname, "reactor_data.csv"))
data = pd.read_csv(file_name)
@@ -33,18 +31,16 @@ def main():
df_sample = data.sample(N, replace=True).reset_index(drop=True)
data = df_sample + df_rand.dot(df_std) / 10
- # Sum of squared error function
- def SSE(model, data):
- expr = (
- (float(data.iloc[0]["ca"]) - model.ca) ** 2
- + (float(data.iloc[0]["cb"]) - model.cb) ** 2
- + (float(data.iloc[0]["cc"]) - model.cc) ** 2
- + (float(data.iloc[0]["cd"]) - model.cd) ** 2
- )
- return expr
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(ReactorDesignExperiment(data, i))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
- # Create an instance of the parmest estimator
- pest = parmest.Estimator(reactor_design_model, data, theta_names, SSE)
+ pest = parmest.Estimator(exp_list, obj_function='SSE')
# Parameter estimation
obj, theta = pest.theta_est()
diff --git a/pyomo/contrib/parmest/examples/reactor_design/likelihood_ratio_example.py b/pyomo/contrib/parmest/examples/reactor_design/likelihood_ratio_example.py
index 0d5665123b4..c2bff254077 100644
--- a/pyomo/contrib/parmest/examples/reactor_design/likelihood_ratio_example.py
+++ b/pyomo/contrib/parmest/examples/reactor_design/likelihood_ratio_example.py
@@ -14,31 +14,27 @@
from os.path import join, abspath, dirname
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
+ ReactorDesignExperiment,
)
def main():
- # Vars to estimate
- theta_names = ["k1", "k2", "k3"]
- # Data
+ # Read in data
file_dirname = dirname(abspath(str(__file__)))
file_name = abspath(join(file_dirname, "reactor_data.csv"))
data = pd.read_csv(file_name)
- # Sum of squared error function
- def SSE(model, data):
- expr = (
- (float(data.iloc[0]["ca"]) - model.ca) ** 2
- + (float(data.iloc[0]["cb"]) - model.cb) ** 2
- + (float(data.iloc[0]["cc"]) - model.cc) ** 2
- + (float(data.iloc[0]["cd"]) - model.cd) ** 2
- )
- return expr
-
- # Create an instance of the parmest estimator
- pest = parmest.Estimator(reactor_design_model, data, theta_names, SSE)
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(ReactorDesignExperiment(data, i))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
+ pest = parmest.Estimator(exp_list, obj_function='SSE')
# Parameter estimation
obj, theta = pest.theta_est()
diff --git a/pyomo/contrib/parmest/examples/reactor_design/multisensor_data_example.py b/pyomo/contrib/parmest/examples/reactor_design/multisensor_data_example.py
index cf77f46f08a..208981a784a 100644
--- a/pyomo/contrib/parmest/examples/reactor_design/multisensor_data_example.py
+++ b/pyomo/contrib/parmest/examples/reactor_design/multisensor_data_example.py
@@ -11,37 +11,81 @@
from pyomo.common.dependencies import pandas as pd
from os.path import join, abspath, dirname
+import pyomo.environ as pyo
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
+ ReactorDesignExperiment,
)
+class MultisensorReactorDesignExperiment(ReactorDesignExperiment):
+
+ def finalize_model(self):
+
+ m = self.model
+
+ # Experiment inputs values
+ m.sv = self.data_i['sv']
+ m.caf = self.data_i['caf']
+
+ # Experiment output values
+ m.ca = (self.data_i['ca1'] + self.data_i['ca2'] + self.data_i['ca3']) * (1 / 3)
+ m.cb = self.data_i['cb']
+ m.cc = (self.data_i['cc1'] + self.data_i['cc2']) * (1 / 2)
+ m.cd = self.data_i['cd']
+
+ return m
+
+ def label_model(self):
+
+ m = self.model
+
+ m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs.update(
+ [
+ (m.ca, [self.data_i['ca1'], self.data_i['ca2'], self.data_i['ca3']]),
+ (m.cb, [self.data_i['cb']]),
+ (m.cc, [self.data_i['cc1'], self.data_i['cc2']]),
+ (m.cd, [self.data_i['cd']]),
+ ]
+ )
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update(
+ (k, pyo.ComponentUID(k)) for k in [m.k1, m.k2, m.k3]
+ )
+
+ return m
+
+
def main():
# Parameter estimation using multisensor data
- # Vars to estimate
- theta_names = ["k1", "k2", "k3"]
-
- # Data, includes multiple sensors for ca and cc
+ # Read in data
file_dirname = dirname(abspath(str(__file__)))
file_name = abspath(join(file_dirname, "reactor_data_multisensor.csv"))
data = pd.read_csv(file_name)
- # Sum of squared error function
- def SSE_multisensor(model, data):
- expr = (
- ((float(data.iloc[0]["ca1"]) - model.ca) ** 2) * (1 / 3)
- + ((float(data.iloc[0]["ca2"]) - model.ca) ** 2) * (1 / 3)
- + ((float(data.iloc[0]["ca3"]) - model.ca) ** 2) * (1 / 3)
- + (float(data.iloc[0]["cb"]) - model.cb) ** 2
- + ((float(data.iloc[0]["cc1"]) - model.cc) ** 2) * (1 / 2)
- + ((float(data.iloc[0]["cc2"]) - model.cc) ** 2) * (1 / 2)
- + (float(data.iloc[0]["cd"]) - model.cd) ** 2
- )
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(MultisensorReactorDesignExperiment(data, i))
+
+ # Define sum of squared error
+ def SSE_multisensor(model):
+ expr = 0
+ for y, y_hat in model.experiment_outputs.items():
+ num_outputs = len(y_hat)
+ for i in range(num_outputs):
+ expr += ((y - y_hat[i]) ** 2) * (1 / num_outputs)
return expr
- pest = parmest.Estimator(reactor_design_model, data, theta_names, SSE_multisensor)
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+ # print(SSE_multisensor(exp0_model))
+
+ pest = parmest.Estimator(exp_list, obj_function=SSE_multisensor)
obj, theta = pest.theta_est()
print(obj)
print(theta)
diff --git a/pyomo/contrib/parmest/examples/reactor_design/parameter_estimation_example.py b/pyomo/contrib/parmest/examples/reactor_design/parameter_estimation_example.py
index c53d9ef36dc..a84a3fde5e7 100644
--- a/pyomo/contrib/parmest/examples/reactor_design/parameter_estimation_example.py
+++ b/pyomo/contrib/parmest/examples/reactor_design/parameter_estimation_example.py
@@ -13,46 +13,29 @@
from os.path import join, abspath, dirname
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
+ ReactorDesignExperiment,
)
def main():
- # Vars to estimate
- theta_names = ["k1", "k2", "k3"]
- # Data
+ # Read in data
file_dirname = dirname(abspath(str(__file__)))
file_name = abspath(join(file_dirname, "reactor_data.csv"))
data = pd.read_csv(file_name)
- # Sum of squared error function
- def SSE(model, data):
- expr = (
- (float(data.iloc[0]["ca"]) - model.ca) ** 2
- + (float(data.iloc[0]["cb"]) - model.cb) ** 2
- + (float(data.iloc[0]["cc"]) - model.cc) ** 2
- + (float(data.iloc[0]["cd"]) - model.cd) ** 2
- )
- return expr
-
- # Create an instance of the parmest estimator
- pest = parmest.Estimator(reactor_design_model, data, theta_names, SSE)
-
- # Parameter estimation
- obj, theta = pest.theta_est()
-
- # Assert statements compare parameter estimation (theta) to an expected value
- k1_expected = 5.0 / 6.0
- k2_expected = 5.0 / 3.0
- k3_expected = 1.0 / 6000.0
- relative_error = abs(theta["k1"] - k1_expected) / k1_expected
- assert relative_error < 0.05
- relative_error = abs(theta["k2"] - k2_expected) / k2_expected
- assert relative_error < 0.05
- relative_error = abs(theta["k3"] - k3_expected) / k3_expected
- assert relative_error < 0.05
-
-
-if __name__ == "__main__":
- main()
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(ReactorDesignExperiment(data, i))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
+ pest = parmest.Estimator(exp_list, obj_function='SSE')
+
+ # Parameter estimation with covariance
+ obj, theta, cov = pest.theta_est(calc_cov=True, cov_n=17)
+ print(obj)
+ print(theta)
diff --git a/pyomo/contrib/parmest/examples/reactor_design/reactor_design.py b/pyomo/contrib/parmest/examples/reactor_design/reactor_design.py
index 65046d76a05..a396c1ea721 100644
--- a/pyomo/contrib/parmest/examples/reactor_design/reactor_design.py
+++ b/pyomo/contrib/parmest/examples/reactor_design/reactor_design.py
@@ -12,57 +12,46 @@
Continuously stirred tank reactor model, based on
pyomo/examples/doc/pyomobook/nonlinear-ch/react_design/ReactorDesign.py
"""
+
from pyomo.common.dependencies import pandas as pd
-from pyomo.environ import (
- ConcreteModel,
- Param,
- Var,
- PositiveReals,
- Objective,
- Constraint,
- maximize,
- SolverFactory,
-)
-
-
-def reactor_design_model(data):
+import pyomo.environ as pyo
+import pyomo.contrib.parmest.parmest as parmest
+from pyomo.contrib.parmest.experiment import Experiment
+
+
+def reactor_design_model():
+
# Create the concrete model
- model = ConcreteModel()
+ model = pyo.ConcreteModel()
# Rate constants
- model.k1 = Param(initialize=5.0 / 6.0, within=PositiveReals, mutable=True) # min^-1
- model.k2 = Param(initialize=5.0 / 3.0, within=PositiveReals, mutable=True) # min^-1
- model.k3 = Param(
- initialize=1.0 / 6000.0, within=PositiveReals, mutable=True
+ model.k1 = pyo.Param(
+ initialize=5.0 / 6.0, within=pyo.PositiveReals, mutable=True
+ ) # min^-1
+ model.k2 = pyo.Param(
+ initialize=5.0 / 3.0, within=pyo.PositiveReals, mutable=True
+ ) # min^-1
+ model.k3 = pyo.Param(
+ initialize=1.0 / 6000.0, within=pyo.PositiveReals, mutable=True
) # m^3/(gmol min)
# Inlet concentration of A, gmol/m^3
- if isinstance(data, dict) or isinstance(data, pd.Series):
- model.caf = Param(initialize=float(data["caf"]), within=PositiveReals)
- elif isinstance(data, pd.DataFrame):
- model.caf = Param(initialize=float(data.iloc[0]["caf"]), within=PositiveReals)
- else:
- raise ValueError("Unrecognized data type.")
+ model.caf = pyo.Param(initialize=10000, within=pyo.PositiveReals, mutable=True)
# Space velocity (flowrate/volume)
- if isinstance(data, dict) or isinstance(data, pd.Series):
- model.sv = Param(initialize=float(data["sv"]), within=PositiveReals)
- elif isinstance(data, pd.DataFrame):
- model.sv = Param(initialize=float(data.iloc[0]["sv"]), within=PositiveReals)
- else:
- raise ValueError("Unrecognized data type.")
+ model.sv = pyo.Param(initialize=1.0, within=pyo.PositiveReals, mutable=True)
# Outlet concentration of each component
- model.ca = Var(initialize=5000.0, within=PositiveReals)
- model.cb = Var(initialize=2000.0, within=PositiveReals)
- model.cc = Var(initialize=2000.0, within=PositiveReals)
- model.cd = Var(initialize=1000.0, within=PositiveReals)
+ model.ca = pyo.Var(initialize=5000.0, within=pyo.PositiveReals)
+ model.cb = pyo.Var(initialize=2000.0, within=pyo.PositiveReals)
+ model.cc = pyo.Var(initialize=2000.0, within=pyo.PositiveReals)
+ model.cd = pyo.Var(initialize=1000.0, within=pyo.PositiveReals)
# Objective
- model.obj = Objective(expr=model.cb, sense=maximize)
+ model.obj = pyo.Objective(expr=model.cb, sense=pyo.maximize)
# Constraints
- model.ca_bal = Constraint(
+ model.ca_bal = pyo.Constraint(
expr=(
0
== model.sv * model.caf
@@ -72,28 +61,96 @@ def reactor_design_model(data):
)
)
- model.cb_bal = Constraint(
+ model.cb_bal = pyo.Constraint(
expr=(0 == -model.sv * model.cb + model.k1 * model.ca - model.k2 * model.cb)
)
- model.cc_bal = Constraint(expr=(0 == -model.sv * model.cc + model.k2 * model.cb))
+ model.cc_bal = pyo.Constraint(
+ expr=(0 == -model.sv * model.cc + model.k2 * model.cb)
+ )
- model.cd_bal = Constraint(
+ model.cd_bal = pyo.Constraint(
expr=(0 == -model.sv * model.cd + model.k3 * model.ca**2.0)
)
return model
+class ReactorDesignExperiment(Experiment):
+
+ def __init__(self, data, experiment_number):
+ self.data = data
+ self.experiment_number = experiment_number
+ self.data_i = data.loc[experiment_number, :]
+ self.model = None
+
+ def create_model(self):
+ self.model = m = reactor_design_model()
+ return m
+
+ def finalize_model(self):
+ m = self.model
+
+ # Experiment inputs values
+ m.sv = self.data_i['sv']
+ m.caf = self.data_i['caf']
+
+ # Experiment output values
+ m.ca = self.data_i['ca']
+ m.cb = self.data_i['cb']
+ m.cc = self.data_i['cc']
+ m.cd = self.data_i['cd']
+
+ return m
+
+ def label_model(self):
+ m = self.model
+
+ m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs.update(
+ [
+ (m.ca, self.data_i['ca']),
+ (m.cb, self.data_i['cb']),
+ (m.cc, self.data_i['cc']),
+ (m.cd, self.data_i['cd']),
+ ]
+ )
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update(
+ (k, pyo.ComponentUID(k)) for k in [m.k1, m.k2, m.k3]
+ )
+
+ return m
+
+ def get_labeled_model(self):
+ m = self.create_model()
+ m = self.finalize_model()
+ m = self.label_model()
+
+ return m
+
+
def main():
+
# For a range of sv values, return ca, cb, cc, and cd
results = []
sv_values = [1.0 + v * 0.05 for v in range(1, 20)]
caf = 10000
for sv in sv_values:
- model = reactor_design_model(pd.DataFrame(data={"caf": [caf], "sv": [sv]}))
- solver = SolverFactory("ipopt")
+
+ # make model
+ model = reactor_design_model()
+
+ # add caf, sv
+ model.caf = caf
+ model.sv = sv
+
+ # solve model
+ solver = pyo.SolverFactory("ipopt")
solver.solve(model)
+
+ # save results
results.append([sv, caf, model.ca(), model.cb(), model.cc(), model.cd()])
results = pd.DataFrame(results, columns=["sv", "caf", "ca", "cb", "cc", "cd"])
diff --git a/pyomo/contrib/parmest/examples/reactor_design/timeseries_data_example.py b/pyomo/contrib/parmest/examples/reactor_design/timeseries_data_example.py
index b0b213752cb..4eb191afd6d 100644
--- a/pyomo/contrib/parmest/examples/reactor_design/timeseries_data_example.py
+++ b/pyomo/contrib/parmest/examples/reactor_design/timeseries_data_example.py
@@ -14,38 +14,64 @@
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
+ ReactorDesignExperiment,
)
-def main():
- # Parameter estimation using timeseries data
+class TimeSeriesReactorDesignExperiment(ReactorDesignExperiment):
+
+ def __init__(self, data, experiment_number):
+ self.data = data
+ self.experiment_number = experiment_number
+ data_i = data.loc[data['experiment'] == experiment_number, :]
+ self.data_i = data_i.reset_index()
+ self.model = None
+
+ def finalize_model(self):
+ m = self.model
+
+ # Experiment inputs values
+ m.sv = self.data_i['sv'].mean()
+ m.caf = self.data_i['caf'].mean()
+
+ # Experiment output values
+ m.ca = self.data_i['ca'][0]
+ m.cb = self.data_i['cb'][0]
+ m.cc = self.data_i['cc'][0]
+ m.cd = self.data_i['cd'][0]
+
+ return m
- # Vars to estimate
- theta_names = ['k1', 'k2', 'k3']
+
+def main():
+ # Parameter estimation using timeseries data, grouped by experiment number
# Data, includes multiple sensors for ca and cc
file_dirname = dirname(abspath(str(__file__)))
file_name = abspath(join(file_dirname, 'reactor_data_timeseries.csv'))
data = pd.read_csv(file_name)
- # Group time series data into experiments, return the mean value for sv and caf
- # Returns a list of dictionaries
- data_ts = parmest.group_data(data, 'experiment', ['sv', 'caf'])
+ # Create an experiment list
+ exp_list = []
+ for i in data['experiment'].unique():
+ exp_list.append(TimeSeriesReactorDesignExperiment(data, i))
+
+ def SSE_timeseries(model):
- def SSE_timeseries(model, data):
expr = 0
- for val in data['ca']:
- expr = expr + ((float(val) - model.ca) ** 2) * (1 / len(data['ca']))
- for val in data['cb']:
- expr = expr + ((float(val) - model.cb) ** 2) * (1 / len(data['cb']))
- for val in data['cc']:
- expr = expr + ((float(val) - model.cc) ** 2) * (1 / len(data['cc']))
- for val in data['cd']:
- expr = expr + ((float(val) - model.cd) ** 2) * (1 / len(data['cd']))
+ for y, y_hat in model.experiment_outputs.items():
+ num_time_points = len(y_hat)
+ for i in range(num_time_points):
+ expr += ((y - y_hat[i]) ** 2) * (1 / num_time_points)
+
return expr
- pest = parmest.Estimator(reactor_design_model, data_ts, theta_names, SSE_timeseries)
+ # View one model & SSE
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+ # print(SSE_timeseries(exp0_model))
+
+ pest = parmest.Estimator(exp_list, obj_function=SSE_timeseries)
obj, theta = pest.theta_est()
print(obj)
print(theta)
diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/bootstrap_example.py b/pyomo/contrib/parmest/examples/rooney_biegler/bootstrap_example.py
index 49fed17c5b2..944a01ac95e 100644
--- a/pyomo/contrib/parmest/examples/rooney_biegler/bootstrap_example.py
+++ b/pyomo/contrib/parmest/examples/rooney_biegler/bootstrap_example.py
@@ -12,13 +12,11 @@
from pyomo.common.dependencies import pandas as pd
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import (
- rooney_biegler_model,
+ RooneyBieglerExperiment,
)
def main():
- # Vars to estimate
- theta_names = ['asymptote', 'rate_constant']
# Data
data = pd.DataFrame(
@@ -27,14 +25,24 @@ def main():
)
# Sum of squared error function
- def SSE(model, data):
- expr = sum(
- (data.y[i] - model.response_function[data.hour[i]]) ** 2 for i in data.index
- )
+ def SSE(model):
+ expr = (
+ model.experiment_outputs[model.y]
+ - model.response_function[model.experiment_outputs[model.hour]]
+ ) ** 2
return expr
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(RooneyBieglerExperiment(data.loc[i, :]))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
# Create an instance of the parmest estimator
- pest = parmest.Estimator(rooney_biegler_model, data, theta_names, SSE)
+ pest = parmest.Estimator(exp_list, obj_function=SSE)
# Parameter estimation
obj, theta = pest.theta_est()
diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/likelihood_ratio_example.py b/pyomo/contrib/parmest/examples/rooney_biegler/likelihood_ratio_example.py
index a87beeb4d39..54343993286 100644
--- a/pyomo/contrib/parmest/examples/rooney_biegler/likelihood_ratio_example.py
+++ b/pyomo/contrib/parmest/examples/rooney_biegler/likelihood_ratio_example.py
@@ -13,13 +13,11 @@
from itertools import product
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import (
- rooney_biegler_model,
+ RooneyBieglerExperiment,
)
def main():
- # Vars to estimate
- theta_names = ['asymptote', 'rate_constant']
# Data
data = pd.DataFrame(
@@ -28,14 +26,24 @@ def main():
)
# Sum of squared error function
- def SSE(model, data):
- expr = sum(
- (data.y[i] - model.response_function[data.hour[i]]) ** 2 for i in data.index
- )
+ def SSE(model):
+ expr = (
+ model.experiment_outputs[model.y]
+ - model.response_function[model.experiment_outputs[model.hour]]
+ ) ** 2
return expr
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(RooneyBieglerExperiment(data.loc[i, :]))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
# Create an instance of the parmest estimator
- pest = parmest.Estimator(rooney_biegler_model, data, theta_names, SSE)
+ pest = parmest.Estimator(exp_list, obj_function=SSE)
# Parameter estimation
obj, theta = pest.theta_est()
diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/parameter_estimation_example.py b/pyomo/contrib/parmest/examples/rooney_biegler/parameter_estimation_example.py
index d11f0738ab4..3c9a93100bb 100644
--- a/pyomo/contrib/parmest/examples/rooney_biegler/parameter_estimation_example.py
+++ b/pyomo/contrib/parmest/examples/rooney_biegler/parameter_estimation_example.py
@@ -12,13 +12,11 @@
from pyomo.common.dependencies import pandas as pd
import pyomo.contrib.parmest.parmest as parmest
from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import (
- rooney_biegler_model,
+ RooneyBieglerExperiment,
)
def main():
- # Vars to estimate
- theta_names = ['asymptote', 'rate_constant']
# Data
data = pd.DataFrame(
@@ -27,14 +25,24 @@ def main():
)
# Sum of squared error function
- def SSE(model, data):
- expr = sum(
- (data.y[i] - model.response_function[data.hour[i]]) ** 2 for i in data.index
- )
+ def SSE(model):
+ expr = (
+ model.experiment_outputs[model.y]
+ - model.response_function[model.experiment_outputs[model.hour]]
+ ) ** 2
return expr
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(RooneyBieglerExperiment(data.loc[i, :]))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
# Create an instance of the parmest estimator
- pest = parmest.Estimator(rooney_biegler_model, data, theta_names, SSE)
+ pest = parmest.Estimator(exp_list, obj_function=SSE)
# Parameter estimation and covariance
n = 6 # total number of data points used in the objective (y in 6 scenarios)
diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler.py b/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler.py
index 724578b419f..9625ab32ea3 100644
--- a/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler.py
+++ b/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler.py
@@ -17,6 +17,7 @@
from pyomo.common.dependencies import pandas as pd
import pyomo.environ as pyo
+from pyomo.contrib.parmest.experiment import Experiment
def rooney_biegler_model(data):
@@ -25,6 +26,9 @@ def rooney_biegler_model(data):
model.asymptote = pyo.Var(initialize=15)
model.rate_constant = pyo.Var(initialize=0.5)
+ model.hour = pyo.Param(within=pyo.PositiveReals, mutable=True)
+ model.y = pyo.Param(within=pyo.PositiveReals, mutable=True)
+
def response_rule(m, h):
expr = m.asymptote * (1 - pyo.exp(-m.rate_constant * h))
return expr
@@ -41,6 +45,47 @@ def SSE_rule(m):
return model
+class RooneyBieglerExperiment(Experiment):
+
+ def __init__(self, data):
+ self.data = data
+ self.model = None
+
+ def create_model(self):
+ # rooney_biegler_model expects a dataframe
+ data_df = self.data.to_frame().transpose()
+ self.model = rooney_biegler_model(data_df)
+
+ def label_model(self):
+
+ m = self.model
+
+ m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs.update(
+ [(m.hour, self.data['hour']), (m.y, self.data['y'])]
+ )
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update(
+ (k, pyo.ComponentUID(k)) for k in [m.asymptote, m.rate_constant]
+ )
+
+ def finalize_model(self):
+
+ m = self.model
+
+ # Experiment output values
+ m.hour = self.data['hour']
+ m.y = self.data['y']
+
+ def get_labeled_model(self):
+ self.create_model()
+ self.label_model()
+ self.finalize_model()
+
+ return self.model
+
+
def main():
# These were taken from Table A1.4 in Bates and Watts (1988).
data = pd.DataFrame(
diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler_with_constraint.py b/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler_with_constraint.py
index 0c0de4dc6d8..dd82b50cf7a 100644
--- a/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler_with_constraint.py
+++ b/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler_with_constraint.py
@@ -17,6 +17,7 @@
from pyomo.common.dependencies import pandas as pd
import pyomo.environ as pyo
+from pyomo.contrib.parmest.experiment import Experiment
def rooney_biegler_model_with_constraint(data):
@@ -24,6 +25,10 @@ def rooney_biegler_model_with_constraint(data):
model.asymptote = pyo.Var(initialize=15)
model.rate_constant = pyo.Var(initialize=0.5)
+
+ model.hour = pyo.Param(within=pyo.PositiveReals, mutable=True)
+ model.y = pyo.Param(within=pyo.PositiveReals, mutable=True)
+
model.response_function = pyo.Var(data.hour, initialize=0.0)
# changed from expression to constraint
@@ -44,6 +49,47 @@ def SSE_rule(m):
return model
+class RooneyBieglerExperiment(Experiment):
+
+ def __init__(self, data):
+ self.data = data
+ self.model = None
+
+ def create_model(self):
+ # rooney_biegler_model_with_constraint expects a dataframe
+ data_df = self.data.to_frame().transpose()
+ self.model = rooney_biegler_model_with_constraint(data_df)
+
+ def label_model(self):
+
+ m = self.model
+
+ m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs.update(
+ [(m.hour, self.data['hour']), (m.y, self.data['y'])]
+ )
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update(
+ (k, pyo.ComponentUID(k)) for k in [m.asymptote, m.rate_constant]
+ )
+
+ def finalize_model(self):
+
+ m = self.model
+
+ # Experiment output values
+ m.hour = self.data['hour']
+ m.y = self.data['y']
+
+ def get_labeled_model(self):
+ self.create_model()
+ self.label_model()
+ self.finalize_model()
+
+ return self.model
+
+
def main():
# These were taken from Table A1.4 in Bates and Watts (1988).
data = pd.DataFrame(
diff --git a/pyomo/contrib/parmest/examples/semibatch/parameter_estimation_example.py b/pyomo/contrib/parmest/examples/semibatch/parameter_estimation_example.py
index c95d9084dc5..7eafdd2b9c3 100644
--- a/pyomo/contrib/parmest/examples/semibatch/parameter_estimation_example.py
+++ b/pyomo/contrib/parmest/examples/semibatch/parameter_estimation_example.py
@@ -12,12 +12,10 @@
import json
from os.path import join, abspath, dirname
import pyomo.contrib.parmest.parmest as parmest
-from pyomo.contrib.parmest.examples.semibatch.semibatch import generate_model
+from pyomo.contrib.parmest.examples.semibatch.semibatch import SemiBatchExperiment
def main():
- # Vars to estimate
- theta_names = ['k1', 'k2', 'E1', 'E2']
# Data, list of dictionaries
data = []
@@ -28,10 +26,19 @@ def main():
d = json.load(infile)
data.append(d)
+ # Create an experiment list
+ exp_list = []
+ for i in range(len(data)):
+ exp_list.append(SemiBatchExperiment(data[i]))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
# Note, the model already includes a 'SecondStageCost' expression
# for sum of squared error that will be used in parameter estimation
- pest = parmest.Estimator(generate_model, data, theta_names)
+ pest = parmest.Estimator(exp_list)
obj, theta = pest.theta_est()
print(obj)
diff --git a/pyomo/contrib/parmest/examples/semibatch/scenario_example.py b/pyomo/contrib/parmest/examples/semibatch/scenario_example.py
index 853a3770bb7..697cb9ac7a5 100644
--- a/pyomo/contrib/parmest/examples/semibatch/scenario_example.py
+++ b/pyomo/contrib/parmest/examples/semibatch/scenario_example.py
@@ -12,13 +12,11 @@
import json
from os.path import join, abspath, dirname
import pyomo.contrib.parmest.parmest as parmest
-from pyomo.contrib.parmest.examples.semibatch.semibatch import generate_model
+from pyomo.contrib.parmest.examples.semibatch.semibatch import SemiBatchExperiment
import pyomo.contrib.parmest.scenariocreator as sc
def main():
- # Vars to estimate in parmest
- theta_names = ['k1', 'k2', 'E1', 'E2']
# Data: list of dictionaries
data = []
@@ -29,7 +27,16 @@ def main():
d = json.load(infile)
data.append(d)
- pest = parmest.Estimator(generate_model, data, theta_names)
+ # Create an experiment list
+ exp_list = []
+ for i in range(len(data)):
+ exp_list.append(SemiBatchExperiment(data[i]))
+
+ # View one model
+ # exp0_model = exp_list[0].get_labeled_model()
+ # exp0_model.pprint()
+
+ pest = parmest.Estimator(exp_list)
scenmaker = sc.ScenarioCreator(pest, "ipopt")
diff --git a/pyomo/contrib/parmest/examples/semibatch/semibatch.py b/pyomo/contrib/parmest/examples/semibatch/semibatch.py
index 462e5554142..b506d41d072 100644
--- a/pyomo/contrib/parmest/examples/semibatch/semibatch.py
+++ b/pyomo/contrib/parmest/examples/semibatch/semibatch.py
@@ -29,8 +29,11 @@
SolverFactory,
exp,
minimize,
+ Suffix,
+ ComponentUID,
)
from pyomo.dae import ContinuousSet, DerivativeVar
+from pyomo.contrib.parmest.experiment import Experiment
def generate_model(data):
@@ -268,6 +271,35 @@ def total_cost_rule(model):
return m
+class SemiBatchExperiment(Experiment):
+
+ def __init__(self, data):
+ self.data = data
+ self.model = None
+
+ def create_model(self):
+ self.model = generate_model(self.data)
+
+ def label_model(self):
+
+ m = self.model
+
+ m.unknown_parameters = Suffix(direction=Suffix.LOCAL)
+ m.unknown_parameters.update(
+ (k, ComponentUID(k)) for k in [m.k1, m.k2, m.E1, m.E2]
+ )
+
+ def finalize_model(self):
+ pass
+
+ def get_labeled_model(self):
+ self.create_model()
+ self.label_model()
+ self.finalize_model()
+
+ return self.model
+
+
def main():
# Data loaded from files
file_dirname = dirname(abspath(str(__file__)))
diff --git a/pyomo/contrib/parmest/experiment.py b/pyomo/contrib/parmest/experiment.py
new file mode 100644
index 00000000000..4f797d6c89c
--- /dev/null
+++ b/pyomo/contrib/parmest/experiment.py
@@ -0,0 +1,31 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+
+class Experiment:
+ """
+ The experiment class is a template for making experiment lists
+ to pass to parmest.
+
+ An experiment is a Pyomo model "m" which is labeled
+ with additional suffixes:
+ * m.experiment_outputs which defines experiment outputs
+ * m.unknown_parameters which defines parameters to estimate
+
+ The experiment class has one required method:
+ * get_labeled_model() which returns the labeled Pyomo model
+ """
+
+ def __init__(self, model=None):
+ self.model = model
+
+ def get_labeled_model(self):
+ return self.model
diff --git a/pyomo/contrib/parmest/parmest.py b/pyomo/contrib/parmest/parmest.py
index 44c256f2019..41e7792570b 100644
--- a/pyomo/contrib/parmest/parmest.py
+++ b/pyomo/contrib/parmest/parmest.py
@@ -11,9 +11,9 @@
#### Using mpi-sppy instead of PySP; May 2020
#### Adding option for "local" EF starting Sept 2020
#### Wrapping mpi-sppy functionality and local option Jan 2021, Feb 2021
+#### Redesign with Experiment class Dec 2023
# TODO: move use_mpisppy to a Pyomo configuration option
-#
# False implies always use the EF that is local to parmest
use_mpisppy = True # Use it if we can but use local if not.
if use_mpisppy:
@@ -42,7 +42,9 @@
import logging
import types
import json
+from collections.abc import Callable
from itertools import combinations
+from functools import singledispatchmethod
from pyomo.common.dependencies import (
attempt_import,
@@ -63,6 +65,9 @@
import pyomo.contrib.parmest.graphics as graphics
from pyomo.dae import ContinuousSet
+from pyomo.common.deprecation import deprecated
+from pyomo.common.deprecation import deprecation_warning
+
parmest_available = numpy_available & pandas_available & scipy_available
inverse_reduced_hessian, inverse_reduced_hessian_available = attempt_import(
@@ -209,12 +214,12 @@ def _experiment_instance_creation_callback(
thetavals = outer_cb_data["ThetaVals"]
# dlw august 2018: see mea code for more general theta
- for vstr in thetavals:
- theta_cuid = ComponentUID(vstr)
+ for name, val in thetavals.items():
+ theta_cuid = ComponentUID(name)
theta_object = theta_cuid.find_component_on(instance)
- if thetavals[vstr] is not None:
+ if val is not None:
# print("Fixing",vstr,"at",str(thetavals[vstr]))
- theta_object.fix(thetavals[vstr])
+ theta_object.fix(val)
else:
# print("Freeing",vstr)
theta_object.unfix()
@@ -222,93 +227,1215 @@ def _experiment_instance_creation_callback(
return instance
-# =============================================
-def _treemaker(scenlist):
+def SSE(model):
+ """
+ Sum of squared error between `experiment_output` model and data values
+ """
+ expr = sum((y - y_hat) ** 2 for y, y_hat in model.experiment_outputs.items())
+ return expr
+
+
+class Estimator(object):
"""
- Makes a scenario tree (avoids dependence on daps)
+ Parameter estimation class
Parameters
----------
- scenlist (list of `int`): experiment (i.e. scenario) numbers
-
- Returns
- -------
- a `ConcreteModel` that is the scenario tree
+ experiment_list: list of Experiments
+ A list of experiment objects which creates one labeled model for
+ each experiment
+ obj_function: string or function (optional)
+ Built in objective (currently only "SSE") or custom function used to
+ formulate parameter estimation objective.
+ If no function is specified, the model is used
+ "as is" and should be defined with a "FirstStageCost" and
+ "SecondStageCost" expression that are used to build an objective.
+ Default is None.
+ tee: bool, optional
+ If True, print the solver output to the screen. Default is False.
+ diagnostic_mode: bool, optional
+ If True, print diagnostics from the solver. Default is False.
+ solver_options: dict, optional
+ Provides options to the solver (also the name of an attribute).
+ Default is None.
"""
- num_scenarios = len(scenlist)
- m = scenario_tree.tree_structure_model.CreateAbstractScenarioTreeModel()
- m = m.create_instance()
- m.Stages.add('Stage1')
- m.Stages.add('Stage2')
- m.Nodes.add('RootNode')
- for i in scenlist:
- m.Nodes.add('LeafNode_Experiment' + str(i))
- m.Scenarios.add('Experiment' + str(i))
- m.NodeStage['RootNode'] = 'Stage1'
- m.ConditionalProbability['RootNode'] = 1.0
- for node in m.Nodes:
- if node != 'RootNode':
- m.NodeStage[node] = 'Stage2'
- m.Children['RootNode'].add(node)
- m.Children[node].clear()
- m.ConditionalProbability[node] = 1.0 / num_scenarios
- m.ScenarioLeafNode[node.replace('LeafNode_', '')] = node
-
- return m
+ # The singledispatchmethod decorator is used here as a deprecation
+ # shim to be able to support the now deprecated Estimator interface
+ # which had a different number of arguments. When the deprecated API
+ # is removed this decorator and the _deprecated_init method below
+ # can be removed
+ @singledispatchmethod
+ def __init__(
+ self,
+ experiment_list,
+ obj_function=None,
+ tee=False,
+ diagnostic_mode=False,
+ solver_options=None,
+ ):
+ # check that we have a (non-empty) list of experiments
+ assert isinstance(experiment_list, list)
+ self.exp_list = experiment_list
-def group_data(data, groupby_column_name, use_mean=None):
- """
- Group data by scenario
+ # check that an experiment has experiment_outputs and unknown_parameters
+ model = self.exp_list[0].get_labeled_model()
+ try:
+ outputs = [k.name for k, v in model.experiment_outputs.items()]
+ except:
+ RuntimeError(
+ 'Experiment list model does not have suffix ' + '"experiment_outputs".'
+ )
+ try:
+ params = [k.name for k, v in model.unknown_parameters.items()]
+ except:
+ RuntimeError(
+ 'Experiment list model does not have suffix ' + '"unknown_parameters".'
+ )
- Parameters
- ----------
- data: DataFrame
- Data
- groupby_column_name: strings
- Name of data column which contains scenario numbers
- use_mean: list of column names or None, optional
- Name of data columns which should be reduced to a single value per
- scenario by taking the mean
+ # populate keyword argument options
+ self.obj_function = obj_function
+ self.tee = tee
+ self.diagnostic_mode = diagnostic_mode
+ self.solver_options = solver_options
- Returns
- ----------
- grouped_data: list of dictionaries
- Grouped data
- """
- if use_mean is None:
- use_mean_list = []
- else:
- use_mean_list = use_mean
+ # TODO: delete this when the deprecated interface is removed
+ self.pest_deprecated = None
+
+ # TODO This might not be needed here.
+ # We could collect the union (or intersect?) of thetas when the models are built
+ theta_names = []
+ for experiment in self.exp_list:
+ model = experiment.get_labeled_model()
+ theta_names.extend([k.name for k, v in model.unknown_parameters.items()])
+ self.estimator_theta_names = list(set(theta_names))
+
+ self._second_stage_cost_exp = "SecondStageCost"
+ # boolean to indicate if model is initialized using a square solve
+ self.model_initialized = False
+
+ # The deprecated Estimator constructor
+ # This works by checking the type of the first argument passed to
+ # the class constructor. If it matches the old interface (i.e. is
+ # callable) then this _deprecated_init method is called and the
+ # deprecation warning is displayed.
+ @__init__.register(Callable)
+ def _deprecated_init(
+ self,
+ model_function,
+ data,
+ theta_names,
+ obj_function=None,
+ tee=False,
+ diagnostic_mode=False,
+ solver_options=None,
+ ):
+
+ deprecation_warning(
+ "You're using the deprecated parmest interface (model_function, "
+ "data, theta_names). This interface will be removed in a future release, "
+ "please update to the new parmest interface using experiment lists.",
+ version='6.7.2',
+ )
+ self.pest_deprecated = _DeprecatedEstimator(
+ model_function,
+ data,
+ theta_names,
+ obj_function,
+ tee,
+ diagnostic_mode,
+ solver_options,
+ )
+
+ def _return_theta_names(self):
+ """
+ Return list of fitted model parameter names
+ """
+ # check for deprecated inputs
+ if self.pest_deprecated:
+
+ # if fitted model parameter names differ from theta_names
+ # created when Estimator object is created
+ if hasattr(self, 'theta_names_updated'):
+ return self.pest_deprecated.theta_names_updated
- grouped_data = []
- for exp_num, group in data.groupby(data[groupby_column_name]):
- d = {}
- for col in group.columns:
- if col in use_mean_list:
- d[col] = group[col].mean()
else:
- d[col] = list(group[col])
- grouped_data.append(d)
- return grouped_data
+ # default theta_names, created when Estimator object is created
+ return self.pest_deprecated.theta_names
+ else:
-class _SecondStageCostExpr(object):
- """
- Class to pass objective expression into the Pyomo model
- """
+ # if fitted model parameter names differ from theta_names
+ # created when Estimator object is created
+ if hasattr(self, 'theta_names_updated'):
+ return self.theta_names_updated
- def __init__(self, ssc_function, data):
- self._ssc_function = ssc_function
- self._data = data
+ else:
- def __call__(self, model):
- return self._ssc_function(model, self._data)
+ # default theta_names, created when Estimator object is created
+ return self.estimator_theta_names
+ def _expand_indexed_unknowns(self, model_temp):
+ """
+ Expand indexed variables to get full list of thetas
+ """
-class Estimator(object):
+ model_theta_list = []
+ for c in model_temp.unknown_parameters.keys():
+ if c.is_indexed():
+ for _, ci in c.items():
+ model_theta_list.append(ci.name)
+ else:
+ model_theta_list.append(c.name)
+
+ return model_theta_list
+
+ def _create_parmest_model(self, experiment_number):
+ """
+ Modify the Pyomo model for parameter estimation
+ """
+
+ model = self.exp_list[experiment_number].get_labeled_model()
+
+ if len(model.unknown_parameters) == 0:
+ model.parmest_dummy_var = pyo.Var(initialize=1.0)
+
+ # Add objective function (optional)
+ if self.obj_function:
+
+ # Check for component naming conflicts
+ reserved_names = [
+ 'Total_Cost_Objective',
+ 'FirstStageCost',
+ 'SecondStageCost',
+ ]
+ for n in reserved_names:
+ if model.component(n) or hasattr(model, n):
+ raise RuntimeError(
+ f"Parmest will not override the existing model component named {n}"
+ )
+
+ # Deactivate any existing objective functions
+ for obj in model.component_objects(pyo.Objective):
+ obj.deactivate()
+
+ # TODO, this needs to be turned into an enum class of options that still support
+ # custom functions
+ if self.obj_function == 'SSE':
+ second_stage_rule = SSE
+ else:
+ # A custom function uses model.experiment_outputs as data
+ second_stage_rule = self.obj_function
+
+ model.FirstStageCost = pyo.Expression(expr=0)
+ model.SecondStageCost = pyo.Expression(rule=second_stage_rule)
+
+ def TotalCost_rule(model):
+ return model.FirstStageCost + model.SecondStageCost
+
+ model.Total_Cost_Objective = pyo.Objective(
+ rule=TotalCost_rule, sense=pyo.minimize
+ )
+
+ # Convert theta Params to Vars, and unfix theta Vars
+ theta_names = [k.name for k, v in model.unknown_parameters.items()]
+ parmest_model = utils.convert_params_to_vars(model, theta_names, fix_vars=False)
+
+ return parmest_model
+
+ def _instance_creation_callback(self, experiment_number=None, cb_data=None):
+ model = self._create_parmest_model(experiment_number)
+ return model
+
+ def _Q_opt(
+ self,
+ ThetaVals=None,
+ solver="ef_ipopt",
+ return_values=[],
+ bootlist=None,
+ calc_cov=False,
+ cov_n=None,
+ ):
+ """
+ Set up all thetas as first stage Vars, return resulting theta
+ values as well as the objective function value.
+
+ """
+ if solver == "k_aug":
+ raise RuntimeError("k_aug no longer supported.")
+
+ # (Bootstrap scenarios will use indirection through the bootlist)
+ if bootlist is None:
+ scenario_numbers = list(range(len(self.exp_list)))
+ scen_names = ["Scenario{}".format(i) for i in scenario_numbers]
+ else:
+ scen_names = ["Scenario{}".format(i) for i in range(len(bootlist))]
+
+ # tree_model.CallbackModule = None
+ outer_cb_data = dict()
+ outer_cb_data["callback"] = self._instance_creation_callback
+ if ThetaVals is not None:
+ outer_cb_data["ThetaVals"] = ThetaVals
+ if bootlist is not None:
+ outer_cb_data["BootList"] = bootlist
+ outer_cb_data["cb_data"] = None # None is OK
+ outer_cb_data["theta_names"] = self.estimator_theta_names
+
+ options = {"solver": "ipopt"}
+ scenario_creator_options = {"cb_data": outer_cb_data}
+ if use_mpisppy:
+ ef = sputils.create_EF(
+ scen_names,
+ _experiment_instance_creation_callback,
+ EF_name="_Q_opt",
+ suppress_warnings=True,
+ scenario_creator_kwargs=scenario_creator_options,
+ )
+ else:
+ ef = local_ef.create_EF(
+ scen_names,
+ _experiment_instance_creation_callback,
+ EF_name="_Q_opt",
+ suppress_warnings=True,
+ scenario_creator_kwargs=scenario_creator_options,
+ )
+ self.ef_instance = ef
+
+ # Solve the extensive form with ipopt
+ if solver == "ef_ipopt":
+ if not calc_cov:
+ # Do not calculate the reduced hessian
+
+ solver = SolverFactory('ipopt')
+ if self.solver_options is not None:
+ for key in self.solver_options:
+ solver.options[key] = self.solver_options[key]
+
+ solve_result = solver.solve(self.ef_instance, tee=self.tee)
+
+ # The import error will be raised when we attempt to use
+ # inv_reduced_hessian_barrier below.
+ #
+ # elif not asl_available:
+ # raise ImportError("parmest requires ASL to calculate the "
+ # "covariance matrix with solver 'ipopt'")
+ else:
+ # parmest makes the fitted parameters stage 1 variables
+ ind_vars = []
+ for ndname, Var, solval in ef_nonants(ef):
+ ind_vars.append(Var)
+ # calculate the reduced hessian
+ (solve_result, inv_red_hes) = (
+ inverse_reduced_hessian.inv_reduced_hessian_barrier(
+ self.ef_instance,
+ independent_variables=ind_vars,
+ solver_options=self.solver_options,
+ tee=self.tee,
+ )
+ )
+
+ if self.diagnostic_mode:
+ print(
+ ' Solver termination condition = ',
+ str(solve_result.solver.termination_condition),
+ )
+
+ # assume all first stage are thetas...
+ thetavals = {}
+ for ndname, Var, solval in ef_nonants(ef):
+ # process the name
+ # the scenarios are blocks, so strip the scenario name
+ vname = Var.name[Var.name.find(".") + 1 :]
+ thetavals[vname] = solval
+
+ objval = pyo.value(ef.EF_Obj)
+
+ if calc_cov:
+ # Calculate the covariance matrix
+
+ # Number of data points considered
+ n = cov_n
+
+ # Extract number of fitted parameters
+ l = len(thetavals)
+
+ # Assumption: Objective value is sum of squared errors
+ sse = objval
+
+ '''Calculate covariance assuming experimental observation errors are
+ independent and follow a Gaussian
+ distribution with constant variance.
+
+ The formula used in parmest was verified against equations (7-5-15) and
+ (7-5-16) in "Nonlinear Parameter Estimation", Y. Bard, 1974.
+
+ This formula is also applicable if the objective is scaled by a constant;
+ the constant cancels out. (was scaled by 1/n because it computes an
+ expected value.)
+ '''
+ cov = 2 * sse / (n - l) * inv_red_hes
+ cov = pd.DataFrame(
+ cov, index=thetavals.keys(), columns=thetavals.keys()
+ )
+
+ thetavals = pd.Series(thetavals)
+
+ if len(return_values) > 0:
+ var_values = []
+ if len(scen_names) > 1: # multiple scenarios
+ block_objects = self.ef_instance.component_objects(
+ Block, descend_into=False
+ )
+ else: # single scenario
+ block_objects = [self.ef_instance]
+ for exp_i in block_objects:
+ vals = {}
+ for var in return_values:
+ exp_i_var = exp_i.find_component(str(var))
+ if (
+ exp_i_var is None
+ ): # we might have a block such as _mpisppy_data
+ continue
+ # if value to return is ContinuousSet
+ if type(exp_i_var) == ContinuousSet:
+ temp = list(exp_i_var)
+ else:
+ temp = [pyo.value(_) for _ in exp_i_var.values()]
+ if len(temp) == 1:
+ vals[var] = temp[0]
+ else:
+ vals[var] = temp
+ if len(vals) > 0:
+ var_values.append(vals)
+ var_values = pd.DataFrame(var_values)
+ if calc_cov:
+ return objval, thetavals, var_values, cov
+ else:
+ return objval, thetavals, var_values
+
+ if calc_cov:
+ return objval, thetavals, cov
+ else:
+ return objval, thetavals
+
+ else:
+ raise RuntimeError("Unknown solver in Q_Opt=" + solver)
+
+ def _Q_at_theta(self, thetavals, initialize_parmest_model=False):
+ """
+ Return the objective function value with fixed theta values.
+
+ Parameters
+ ----------
+ thetavals: dict
+ A dictionary of theta values.
+
+ initialize_parmest_model: boolean
+ If True: Solve square problem instance, build extensive form of the model for
+ parameter estimation, and set flag model_initialized to True. Default is False.
+
+ Returns
+ -------
+ objectiveval: float
+ The objective function value.
+ thetavals: dict
+ A dictionary of all values for theta that were input.
+ solvertermination: Pyomo TerminationCondition
+ Tries to return the "worst" solver status across the scenarios.
+ pyo.TerminationCondition.optimal is the best and
+ pyo.TerminationCondition.infeasible is the worst.
+ """
+
+ optimizer = pyo.SolverFactory('ipopt')
+
+ if len(thetavals) > 0:
+ dummy_cb = {
+ "callback": self._instance_creation_callback,
+ "ThetaVals": thetavals,
+ "theta_names": self._return_theta_names(),
+ "cb_data": None,
+ }
+ else:
+ dummy_cb = {
+ "callback": self._instance_creation_callback,
+ "theta_names": self._return_theta_names(),
+ "cb_data": None,
+ }
+
+ if self.diagnostic_mode:
+ if len(thetavals) > 0:
+ print(' Compute objective at theta = ', str(thetavals))
+ else:
+ print(' Compute objective at initial theta')
+
+ # start block of code to deal with models with no constraints
+ # (ipopt will crash or complain on such problems without special care)
+ instance = _experiment_instance_creation_callback("FOO0", None, dummy_cb)
+ try: # deal with special problems so Ipopt will not crash
+ first = next(instance.component_objects(pyo.Constraint, active=True))
+ active_constraints = True
+ except:
+ active_constraints = False
+ # end block of code to deal with models with no constraints
+
+ WorstStatus = pyo.TerminationCondition.optimal
+ totobj = 0
+ scenario_numbers = list(range(len(self.exp_list)))
+ if initialize_parmest_model:
+ # create dictionary to store pyomo model instances (scenarios)
+ scen_dict = dict()
+
+ for snum in scenario_numbers:
+ sname = "scenario_NODE" + str(snum)
+ instance = _experiment_instance_creation_callback(sname, None, dummy_cb)
+ model_theta_names = self._expand_indexed_unknowns(instance)
+
+ if initialize_parmest_model:
+ # list to store fitted parameter names that will be unfixed
+ # after initialization
+ theta_init_vals = []
+ # use appropriate theta_names member
+ theta_ref = model_theta_names
+
+ for i, theta in enumerate(theta_ref):
+ # Use parser in ComponentUID to locate the component
+ var_cuid = ComponentUID(theta)
+ var_validate = var_cuid.find_component_on(instance)
+ if var_validate is None:
+ logger.warning(
+ "theta_name %s was not found on the model", (theta)
+ )
+ else:
+ try:
+ if len(thetavals) == 0:
+ var_validate.fix()
+ else:
+ var_validate.fix(thetavals[theta])
+ theta_init_vals.append(var_validate)
+ except:
+ logger.warning(
+ 'Unable to fix model parameter value for %s (not a Pyomo model Var)',
+ (theta),
+ )
+
+ if active_constraints:
+ if self.diagnostic_mode:
+ print(' Experiment = ', snum)
+ print(' First solve with special diagnostics wrapper')
+ (status_obj, solved, iters, time, regu) = (
+ utils.ipopt_solve_with_stats(
+ instance, optimizer, max_iter=500, max_cpu_time=120
+ )
+ )
+ print(
+ " status_obj, solved, iters, time, regularization_stat = ",
+ str(status_obj),
+ str(solved),
+ str(iters),
+ str(time),
+ str(regu),
+ )
+
+ results = optimizer.solve(instance)
+ if self.diagnostic_mode:
+ print(
+ 'standard solve solver termination condition=',
+ str(results.solver.termination_condition),
+ )
+
+ if (
+ results.solver.termination_condition
+ != pyo.TerminationCondition.optimal
+ ):
+ # DLW: Aug2018: not distinguishing "middlish" conditions
+ if WorstStatus != pyo.TerminationCondition.infeasible:
+ WorstStatus = results.solver.termination_condition
+ if initialize_parmest_model:
+ if self.diagnostic_mode:
+ print(
+ "Scenario {:d} infeasible with initialized parameter values".format(
+ snum
+ )
+ )
+ else:
+ if initialize_parmest_model:
+ if self.diagnostic_mode:
+ print(
+ "Scenario {:d} initialization successful with initial parameter values".format(
+ snum
+ )
+ )
+ if initialize_parmest_model:
+ # unfix parameters after initialization
+ for theta in theta_init_vals:
+ theta.unfix()
+ scen_dict[sname] = instance
+ else:
+ if initialize_parmest_model:
+ # unfix parameters after initialization
+ for theta in theta_init_vals:
+ theta.unfix()
+ scen_dict[sname] = instance
+
+ objobject = getattr(instance, self._second_stage_cost_exp)
+ objval = pyo.value(objobject)
+ totobj += objval
+
+ retval = totobj / len(scenario_numbers) # -1??
+ if initialize_parmest_model and not hasattr(self, 'ef_instance'):
+ # create extensive form of the model using scenario dictionary
+ if len(scen_dict) > 0:
+ for scen in scen_dict.values():
+ scen._mpisppy_probability = 1 / len(scen_dict)
+
+ if use_mpisppy:
+ EF_instance = sputils._create_EF_from_scen_dict(
+ scen_dict,
+ EF_name="_Q_at_theta",
+ # suppress_warnings=True
+ )
+ else:
+ EF_instance = local_ef._create_EF_from_scen_dict(
+ scen_dict, EF_name="_Q_at_theta", nonant_for_fixed_vars=True
+ )
+
+ self.ef_instance = EF_instance
+ # set self.model_initialized flag to True to skip extensive form model
+ # creation using theta_est()
+ self.model_initialized = True
+
+ # return initialized theta values
+ if len(thetavals) == 0:
+ # use appropriate theta_names member
+ theta_ref = self._return_theta_names()
+ for i, theta in enumerate(theta_ref):
+ thetavals[theta] = theta_init_vals[i]()
+
+ return retval, thetavals, WorstStatus
+
+ def _get_sample_list(self, samplesize, num_samples, replacement=True):
+ samplelist = list()
+
+ scenario_numbers = list(range(len(self.exp_list)))
+
+ if num_samples is None:
+ # This could get very large
+ for i, l in enumerate(combinations(scenario_numbers, samplesize)):
+ samplelist.append((i, np.sort(l)))
+ else:
+ for i in range(num_samples):
+ attempts = 0
+ unique_samples = 0 # check for duplicates in each sample
+ duplicate = False # check for duplicates between samples
+ while (unique_samples <= len(self._return_theta_names())) and (
+ not duplicate
+ ):
+ sample = np.random.choice(
+ scenario_numbers, samplesize, replace=replacement
+ )
+ sample = np.sort(sample).tolist()
+ unique_samples = len(np.unique(sample))
+ if sample in samplelist:
+ duplicate = True
+
+ attempts += 1
+ if attempts > num_samples: # arbitrary timeout limit
+ raise RuntimeError(
+ """Internal error: timeout constructing
+ a sample, the dim of theta may be too
+ close to the samplesize"""
+ )
+
+ samplelist.append((i, sample))
+
+ return samplelist
+
+ def theta_est(
+ self, solver="ef_ipopt", return_values=[], calc_cov=False, cov_n=None
+ ):
+ """
+ Parameter estimation using all scenarios in the data
+
+ Parameters
+ ----------
+ solver: string, optional
+ Currently only "ef_ipopt" is supported. Default is "ef_ipopt".
+ return_values: list, optional
+ List of Variable names, used to return values from the model for data reconciliation
+ calc_cov: boolean, optional
+ If True, calculate and return the covariance matrix (only for "ef_ipopt" solver).
+ Default is False.
+ cov_n: int, optional
+ If calc_cov=True, then the user needs to supply the number of datapoints
+ that are used in the objective function.
+
+ Returns
+ -------
+ objectiveval: float
+ The objective function value
+ thetavals: pd.Series
+ Estimated values for theta
+ variable values: pd.DataFrame
+ Variable values for each variable name in return_values (only for solver='ef_ipopt')
+ cov: pd.DataFrame
+ Covariance matrix of the fitted parameters (only for solver='ef_ipopt')
+ """
+
+ # check if we are using deprecated parmest
+ if self.pest_deprecated is not None:
+ return self.pest_deprecated.theta_est(
+ solver=solver,
+ return_values=return_values,
+ calc_cov=calc_cov,
+ cov_n=cov_n,
+ )
+
+ assert isinstance(solver, str)
+ assert isinstance(return_values, list)
+ assert isinstance(calc_cov, bool)
+ if calc_cov:
+ num_unknowns = max(
+ [
+ len(experiment.get_labeled_model().unknown_parameters)
+ for experiment in self.exp_list
+ ]
+ )
+ assert isinstance(cov_n, int), (
+ "The number of datapoints that are used in the objective function is "
+ "required to calculate the covariance matrix"
+ )
+ assert (
+ cov_n > num_unknowns
+ ), "The number of datapoints must be greater than the number of parameters to estimate"
+
+ return self._Q_opt(
+ solver=solver,
+ return_values=return_values,
+ bootlist=None,
+ calc_cov=calc_cov,
+ cov_n=cov_n,
+ )
+
+ def theta_est_bootstrap(
+ self,
+ bootstrap_samples,
+ samplesize=None,
+ replacement=True,
+ seed=None,
+ return_samples=False,
+ ):
+ """
+ Parameter estimation using bootstrap resampling of the data
+
+ Parameters
+ ----------
+ bootstrap_samples: int
+ Number of bootstrap samples to draw from the data
+ samplesize: int or None, optional
+ Size of each bootstrap sample. If samplesize=None, samplesize will be
+ set to the number of samples in the data
+ replacement: bool, optional
+ Sample with or without replacement. Default is True.
+ seed: int or None, optional
+ Random seed
+ return_samples: bool, optional
+ Return a list of sample numbers used in each bootstrap estimation.
+ Default is False.
+
+ Returns
+ -------
+ bootstrap_theta: pd.DataFrame
+ Theta values for each sample and (if return_samples = True)
+ the sample numbers used in each estimation
+ """
+
+ # check if we are using deprecated parmest
+ if self.pest_deprecated is not None:
+ return self.pest_deprecated.theta_est_bootstrap(
+ bootstrap_samples,
+ samplesize=samplesize,
+ replacement=replacement,
+ seed=seed,
+ return_samples=return_samples,
+ )
+
+ assert isinstance(bootstrap_samples, int)
+ assert isinstance(samplesize, (type(None), int))
+ assert isinstance(replacement, bool)
+ assert isinstance(seed, (type(None), int))
+ assert isinstance(return_samples, bool)
+
+ if samplesize is None:
+ samplesize = len(self.exp_list)
+
+ if seed is not None:
+ np.random.seed(seed)
+
+ global_list = self._get_sample_list(samplesize, bootstrap_samples, replacement)
+
+ task_mgr = utils.ParallelTaskManager(bootstrap_samples)
+ local_list = task_mgr.global_to_local_data(global_list)
+
+ bootstrap_theta = list()
+ for idx, sample in local_list:
+ objval, thetavals = self._Q_opt(bootlist=list(sample))
+ thetavals['samples'] = sample
+ bootstrap_theta.append(thetavals)
+
+ global_bootstrap_theta = task_mgr.allgather_global_data(bootstrap_theta)
+ bootstrap_theta = pd.DataFrame(global_bootstrap_theta)
+
+ if not return_samples:
+ del bootstrap_theta['samples']
+
+ return bootstrap_theta
+
+ def theta_est_leaveNout(
+ self, lNo, lNo_samples=None, seed=None, return_samples=False
+ ):
+ """
+ Parameter estimation where N data points are left out of each sample
+
+ Parameters
+ ----------
+ lNo: int
+ Number of data points to leave out for parameter estimation
+ lNo_samples: int
+ Number of leave-N-out samples. If lNo_samples=None, the maximum
+ number of combinations will be used
+ seed: int or None, optional
+ Random seed
+ return_samples: bool, optional
+ Return a list of sample numbers that were left out. Default is False.
+
+ Returns
+ -------
+ lNo_theta: pd.DataFrame
+ Theta values for each sample and (if return_samples = True)
+ the sample numbers left out of each estimation
+ """
+
+ # check if we are using deprecated parmest
+ if self.pest_deprecated is not None:
+ return self.pest_deprecated.theta_est_leaveNout(
+ lNo, lNo_samples=lNo_samples, seed=seed, return_samples=return_samples
+ )
+
+ assert isinstance(lNo, int)
+ assert isinstance(lNo_samples, (type(None), int))
+ assert isinstance(seed, (type(None), int))
+ assert isinstance(return_samples, bool)
+
+ samplesize = len(self.exp_list) - lNo
+
+ if seed is not None:
+ np.random.seed(seed)
+
+ global_list = self._get_sample_list(samplesize, lNo_samples, replacement=False)
+
+ task_mgr = utils.ParallelTaskManager(len(global_list))
+ local_list = task_mgr.global_to_local_data(global_list)
+
+ lNo_theta = list()
+ for idx, sample in local_list:
+ objval, thetavals = self._Q_opt(bootlist=list(sample))
+ lNo_s = list(set(range(len(self.exp_list))) - set(sample))
+ thetavals['lNo'] = np.sort(lNo_s)
+ lNo_theta.append(thetavals)
+
+ global_bootstrap_theta = task_mgr.allgather_global_data(lNo_theta)
+ lNo_theta = pd.DataFrame(global_bootstrap_theta)
+
+ if not return_samples:
+ del lNo_theta['lNo']
+
+ return lNo_theta
+
+ def leaveNout_bootstrap_test(
+ self, lNo, lNo_samples, bootstrap_samples, distribution, alphas, seed=None
+ ):
+ """
+ Leave-N-out bootstrap test to compare theta values where N data points are
+ left out to a bootstrap analysis using the remaining data,
+ results indicate if theta is within a confidence region
+ determined by the bootstrap analysis
+
+ Parameters
+ ----------
+ lNo: int
+ Number of data points to leave out for parameter estimation
+ lNo_samples: int
+ Leave-N-out sample size. If lNo_samples=None, the maximum number
+ of combinations will be used
+ bootstrap_samples: int:
+ Bootstrap sample size
+ distribution: string
+ Statistical distribution used to define a confidence region,
+ options = 'MVN' for multivariate_normal, 'KDE' for gaussian_kde,
+ and 'Rect' for rectangular.
+ alphas: list
+ List of alpha values used to determine if theta values are inside
+ or outside the region.
+ seed: int or None, optional
+ Random seed
+
+ Returns
+ -------
+ List of tuples with one entry per lNo_sample:
+
+ * The first item in each tuple is the list of N samples that are left
+ out.
+ * The second item in each tuple is a DataFrame of theta estimated using
+ the N samples.
+ * The third item in each tuple is a DataFrame containing results from
+ the bootstrap analysis using the remaining samples.
+
+ For each DataFrame a column is added for each value of alpha which
+ indicates if the theta estimate is in (True) or out (False) of the
+ alpha region for a given distribution (based on the bootstrap results)
+ """
+
+ # check if we are using deprecated parmest
+ if self.pest_deprecated is not None:
+ return self.pest_deprecated.leaveNout_bootstrap_test(
+ lNo, lNo_samples, bootstrap_samples, distribution, alphas, seed=seed
+ )
+
+ assert isinstance(lNo, int)
+ assert isinstance(lNo_samples, (type(None), int))
+ assert isinstance(bootstrap_samples, int)
+ assert distribution in ['Rect', 'MVN', 'KDE']
+ assert isinstance(alphas, list)
+ assert isinstance(seed, (type(None), int))
+
+ if seed is not None:
+ np.random.seed(seed)
+
+ global_list = self._get_sample_list(lNo, lNo_samples, replacement=False)
+
+ results = []
+ for idx, sample in global_list:
+
+ obj, theta = self.theta_est()
+
+ bootstrap_theta = self.theta_est_bootstrap(bootstrap_samples)
+
+ training, test = self.confidence_region_test(
+ bootstrap_theta,
+ distribution=distribution,
+ alphas=alphas,
+ test_theta_values=theta,
+ )
+
+ results.append((sample, test, training))
+
+ return results
+
+ def objective_at_theta(self, theta_values=None, initialize_parmest_model=False):
+ """
+ Objective value for each theta
+
+ Parameters
+ ----------
+ theta_values: pd.DataFrame, columns=theta_names
+ Values of theta used to compute the objective
+
+ initialize_parmest_model: boolean
+ If True: Solve square problem instance, build extensive form
+ of the model for parameter estimation, and set flag
+ model_initialized to True. Default is False.
+
+
+ Returns
+ -------
+ obj_at_theta: pd.DataFrame
+ Objective value for each theta (infeasible solutions are
+ omitted).
+ """
+
+ # check if we are using deprecated parmest
+ if self.pest_deprecated is not None:
+ return self.pest_deprecated.objective_at_theta(
+ theta_values=theta_values,
+ initialize_parmest_model=initialize_parmest_model,
+ )
+
+ if len(self.estimator_theta_names) == 0:
+ pass # skip assertion if model has no fitted parameters
+ else:
+ # create a local instance of the pyomo model to access model variables and parameters
+ model_temp = self._create_parmest_model(0)
+ model_theta_list = self._expand_indexed_unknowns(model_temp)
+
+ # if self.estimator_theta_names is not the same as temp model_theta_list,
+ # create self.theta_names_updated
+ if set(self.estimator_theta_names) == set(model_theta_list) and len(
+ self.estimator_theta_names
+ ) == len(set(model_theta_list)):
+ pass
+ else:
+ self.theta_names_updated = model_theta_list
+
+ if theta_values is None:
+ all_thetas = {} # dictionary to store fitted variables
+ # use appropriate theta names member
+ theta_names = model_theta_list
+ else:
+ assert isinstance(theta_values, pd.DataFrame)
+ # for parallel code we need to use lists and dicts in the loop
+ theta_names = theta_values.columns
+ # # check if theta_names are in model
+ for theta in list(theta_names):
+ theta_temp = theta.replace("'", "") # cleaning quotes from theta_names
+ assert theta_temp in [
+ t.replace("'", "") for t in model_theta_list
+ ], "Theta name {} in 'theta_values' not in 'theta_names' {}".format(
+ theta_temp, model_theta_list
+ )
+
+ assert len(list(theta_names)) == len(model_theta_list)
+
+ all_thetas = theta_values.to_dict('records')
+
+ if all_thetas:
+ task_mgr = utils.ParallelTaskManager(len(all_thetas))
+ local_thetas = task_mgr.global_to_local_data(all_thetas)
+ else:
+ if initialize_parmest_model:
+ task_mgr = utils.ParallelTaskManager(
+ 1
+ ) # initialization performed using just 1 set of theta values
+ # walk over the mesh, return objective function
+ all_obj = list()
+ if len(all_thetas) > 0:
+ for Theta in local_thetas:
+ obj, thetvals, worststatus = self._Q_at_theta(
+ Theta, initialize_parmest_model=initialize_parmest_model
+ )
+ if worststatus != pyo.TerminationCondition.infeasible:
+ all_obj.append(list(Theta.values()) + [obj])
+ # DLW, Aug2018: should we also store the worst solver status?
+ else:
+ obj, thetvals, worststatus = self._Q_at_theta(
+ thetavals={}, initialize_parmest_model=initialize_parmest_model
+ )
+ if worststatus != pyo.TerminationCondition.infeasible:
+ all_obj.append(list(thetvals.values()) + [obj])
+
+ global_all_obj = task_mgr.allgather_global_data(all_obj)
+ dfcols = list(theta_names) + ['obj']
+ obj_at_theta = pd.DataFrame(data=global_all_obj, columns=dfcols)
+ return obj_at_theta
+
+ def likelihood_ratio_test(
+ self, obj_at_theta, obj_value, alphas, return_thresholds=False
+ ):
+ r"""
+ Likelihood ratio test to identify theta values within a confidence
+ region using the :math:`\chi^2` distribution
+
+ Parameters
+ ----------
+ obj_at_theta: pd.DataFrame, columns = theta_names + 'obj'
+ Objective values for each theta value (returned by
+ objective_at_theta)
+ obj_value: int or float
+ Objective value from parameter estimation using all data
+ alphas: list
+ List of alpha values to use in the chi2 test
+ return_thresholds: bool, optional
+ Return the threshold value for each alpha. Default is False.
+
+ Returns
+ -------
+ LR: pd.DataFrame
+ Objective values for each theta value along with True or False for
+ each alpha
+ thresholds: pd.Series
+ If return_threshold = True, the thresholds are also returned.
+ """
+
+ # check if we are using deprecated parmest
+ if self.pest_deprecated is not None:
+ return self.pest_deprecated.likelihood_ratio_test(
+ obj_at_theta, obj_value, alphas, return_thresholds=return_thresholds
+ )
+
+ assert isinstance(obj_at_theta, pd.DataFrame)
+ assert isinstance(obj_value, (int, float))
+ assert isinstance(alphas, list)
+ assert isinstance(return_thresholds, bool)
+
+ LR = obj_at_theta.copy()
+ S = len(self.exp_list)
+ thresholds = {}
+ for a in alphas:
+ chi2_val = scipy.stats.chi2.ppf(a, 2)
+ thresholds[a] = obj_value * ((chi2_val / (S - 2)) + 1)
+ LR[a] = LR['obj'] < thresholds[a]
+
+ thresholds = pd.Series(thresholds)
+
+ if return_thresholds:
+ return LR, thresholds
+ else:
+ return LR
+
+ def confidence_region_test(
+ self, theta_values, distribution, alphas, test_theta_values=None
+ ):
+ """
+ Confidence region test to determine if theta values are within a
+ rectangular, multivariate normal, or Gaussian kernel density distribution
+ for a range of alpha values
+
+ Parameters
+ ----------
+ theta_values: pd.DataFrame, columns = theta_names
+ Theta values used to generate a confidence region
+ (generally returned by theta_est_bootstrap)
+ distribution: string
+ Statistical distribution used to define a confidence region,
+ options = 'MVN' for multivariate_normal, 'KDE' for gaussian_kde,
+ and 'Rect' for rectangular.
+ alphas: list
+ List of alpha values used to determine if theta values are inside
+ or outside the region.
+ test_theta_values: pd.Series or pd.DataFrame, keys/columns = theta_names, optional
+ Additional theta values that are compared to the confidence region
+ to determine if they are inside or outside.
+
+ Returns
+ -------
+ training_results: pd.DataFrame
+ Theta value used to generate the confidence region along with True
+ (inside) or False (outside) for each alpha
+ test_results: pd.DataFrame
+ If test_theta_values is not None, returns test theta value along
+ with True (inside) or False (outside) for each alpha
+ """
+
+ # check if we are using deprecated parmest
+ if self.pest_deprecated is not None:
+ return self.pest_deprecated.confidence_region_test(
+ theta_values, distribution, alphas, test_theta_values=test_theta_values
+ )
+
+ assert isinstance(theta_values, pd.DataFrame)
+ assert distribution in ['Rect', 'MVN', 'KDE']
+ assert isinstance(alphas, list)
+ assert isinstance(
+ test_theta_values, (type(None), dict, pd.Series, pd.DataFrame)
+ )
+
+ if isinstance(test_theta_values, (dict, pd.Series)):
+ test_theta_values = pd.Series(test_theta_values).to_frame().transpose()
+
+ training_results = theta_values.copy()
+
+ if test_theta_values is not None:
+ test_result = test_theta_values.copy()
+
+ for a in alphas:
+ if distribution == 'Rect':
+ lb, ub = graphics.fit_rect_dist(theta_values, a)
+ training_results[a] = (theta_values > lb).all(axis=1) & (
+ theta_values < ub
+ ).all(axis=1)
+
+ if test_theta_values is not None:
+ # use upper and lower bound from the training set
+ test_result[a] = (test_theta_values > lb).all(axis=1) & (
+ test_theta_values < ub
+ ).all(axis=1)
+
+ elif distribution == 'MVN':
+ dist = graphics.fit_mvn_dist(theta_values)
+ Z = dist.pdf(theta_values)
+ score = scipy.stats.scoreatpercentile(Z, (1 - a) * 100)
+ training_results[a] = Z >= score
+
+ if test_theta_values is not None:
+ # use score from the training set
+ Z = dist.pdf(test_theta_values)
+ test_result[a] = Z >= score
+
+ elif distribution == 'KDE':
+ dist = graphics.fit_kde_dist(theta_values)
+ Z = dist.pdf(theta_values.transpose())
+ score = scipy.stats.scoreatpercentile(Z, (1 - a) * 100)
+ training_results[a] = Z >= score
+
+ if test_theta_values is not None:
+ # use score from the training set
+ Z = dist.pdf(test_theta_values.transpose())
+ test_result[a] = Z >= score
+
+ if test_theta_values is not None:
+ return training_results, test_result
+ else:
+ return training_results
+
+
+################################
+# deprecated functions/classes #
+################################
+
+
+@deprecated(version='6.7.2')
+def group_data(data, groupby_column_name, use_mean=None):
+ """
+ Group data by scenario
+
+ Parameters
+ ----------
+ data: DataFrame
+ Data
+ groupby_column_name: strings
+ Name of data column which contains scenario numbers
+ use_mean: list of column names or None, optional
+ Name of data columns which should be reduced to a single value per
+ scenario by taking the mean
+
+ Returns
+ ----------
+ grouped_data: list of dictionaries
+ Grouped data
+ """
+ if use_mean is None:
+ use_mean_list = []
+ else:
+ use_mean_list = use_mean
+
+ grouped_data = []
+ for exp_num, group in data.groupby(data[groupby_column_name]):
+ d = {}
+ for col in group.columns:
+ if col in use_mean_list:
+ d[col] = group[col].mean()
+ else:
+ d[col] = list(group[col])
+ grouped_data.append(d)
+
+ return grouped_data
+
+
+class _DeprecatedSecondStageCostExpr(object):
+ """
+ Class to pass objective expression into the Pyomo model
+ """
+
+ def __init__(self, ssc_function, data):
+ self._ssc_function = ssc_function
+ self._data = data
+
+ def __call__(self, model):
+ return self._ssc_function(model, self._data)
+
+
+class _DeprecatedEstimator(object):
"""
Parameter estimation class
@@ -418,7 +1545,7 @@ def _create_parmest_model(self, data):
)
model.FirstStageCost = pyo.Expression(expr=0)
model.SecondStageCost = pyo.Expression(
- rule=_SecondStageCostExpr(self.obj_function, data)
+ rule=_DeprecatedSecondStageCostExpr(self.obj_function, data)
)
def TotalCost_rule(model):
diff --git a/pyomo/contrib/parmest/scenariocreator.py b/pyomo/contrib/parmest/scenariocreator.py
index b599e5952d2..e887dd2e8be 100644
--- a/pyomo/contrib/parmest/scenariocreator.py
+++ b/pyomo/contrib/parmest/scenariocreator.py
@@ -14,6 +14,10 @@
import pyomo.environ as pyo
+import logging
+
+logger = logging.getLogger(__name__)
+
class ScenarioSet(object):
"""
@@ -119,6 +123,7 @@ class ScenarioCreator(object):
"""
def __init__(self, pest, solvername):
+
self.pest = pest
self.solvername = solvername
@@ -133,23 +138,32 @@ def ScenariosFromExperiments(self, addtoSet):
assert isinstance(addtoSet, ScenarioSet)
- scenario_numbers = list(range(len(self.pest.callback_data)))
+ if self.pest.pest_deprecated is not None:
+ scenario_numbers = list(range(len(self.pest.pest_deprecated.callback_data)))
+ else:
+ scenario_numbers = list(range(len(self.pest.exp_list)))
prob = 1.0 / len(scenario_numbers)
for exp_num in scenario_numbers:
##print("Experiment number=", exp_num)
- model = self.pest._instance_creation_callback(
- exp_num, self.pest.callback_data
- )
+ if self.pest.pest_deprecated is not None:
+ model = self.pest.pest_deprecated._instance_creation_callback(
+ exp_num, self.pest.pest_deprecated.callback_data
+ )
+ else:
+ model = self.pest._instance_creation_callback(exp_num)
opt = pyo.SolverFactory(self.solvername)
results = opt.solve(model) # solves and updates model
## pyo.check_termination_optimal(results)
- ThetaVals = dict()
- for theta in self.pest.theta_names:
- tvar = eval('model.' + theta)
- tval = pyo.value(tvar)
- ##print(" theta, tval=", tvar, tval)
- ThetaVals[theta] = tval
+ if self.pest.pest_deprecated is not None:
+ ThetaVals = {
+ theta: pyo.value(model.find_component(theta))
+ for theta in self.pest.pest_deprecated.theta_names
+ }
+ else:
+ ThetaVals = {
+ k.name: pyo.value(k) for k in model.unknown_parameters.keys()
+ }
addtoSet.addone(ParmestScen("ExpScen" + str(exp_num), ThetaVals, prob))
def ScenariosFromBootstrap(self, addtoSet, numtomake, seed=None):
@@ -162,5 +176,10 @@ def ScenariosFromBootstrap(self, addtoSet, numtomake, seed=None):
assert isinstance(addtoSet, ScenarioSet)
- bootstrap_thetas = self.pest.theta_est_bootstrap(numtomake, seed=seed)
+ if self.pest.pest_deprecated is not None:
+ bootstrap_thetas = self.pest.pest_deprecated.theta_est_bootstrap(
+ numtomake, seed=seed
+ )
+ else:
+ bootstrap_thetas = self.pest.theta_est_bootstrap(numtomake, seed=seed)
addtoSet.append_bootstrap(bootstrap_thetas)
diff --git a/pyomo/contrib/parmest/tests/test_examples.py b/pyomo/contrib/parmest/tests/test_examples.py
index 59a3e0adde2..dca05026e80 100644
--- a/pyomo/contrib/parmest/tests/test_examples.py
+++ b/pyomo/contrib/parmest/tests/test_examples.py
@@ -181,7 +181,10 @@ def test_multisensor_data_example(self):
multisensor_data_example.main()
- @unittest.skipUnless(matplotlib_available, "test requires matplotlib")
+ @unittest.skipUnless(
+ matplotlib_available and seaborn_available,
+ "test requires matplotlib and seaborn",
+ )
def test_datarec_example(self):
from pyomo.contrib.parmest.examples.reactor_design import datarec_example
diff --git a/pyomo/contrib/parmest/tests/test_parmest.py b/pyomo/contrib/parmest/tests/test_parmest.py
index 31e083a5f33..65e2e4a3b06 100644
--- a/pyomo/contrib/parmest/tests/test_parmest.py
+++ b/pyomo/contrib/parmest/tests/test_parmest.py
@@ -33,6 +33,7 @@
import pyomo.contrib.parmest.parmest as parmest
import pyomo.contrib.parmest.graphics as graphics
import pyomo.contrib.parmest as parmestbase
+from pyomo.contrib.parmest.experiment import Experiment
import pyomo.environ as pyo
import pyomo.dae as dae
@@ -55,8 +56,1019 @@
class TestRooneyBiegler(unittest.TestCase):
def setUp(self):
from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import (
- rooney_biegler_model,
+ RooneyBieglerExperiment,
+ )
+
+ # Note, the data used in this test has been corrected to use
+ # data.loc[5,'hour'] = 7 (instead of 6)
+ data = pd.DataFrame(
+ data=[[1, 8.3], [2, 10.3], [3, 19.0], [4, 16.0], [5, 15.6], [7, 19.8]],
+ columns=["hour", "y"],
+ )
+
+ # Sum of squared error function
+ def SSE(model):
+ expr = (
+ model.experiment_outputs[model.y]
+ - model.response_function[model.experiment_outputs[model.hour]]
+ ) ** 2
+ return expr
+
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(RooneyBieglerExperiment(data.loc[i, :]))
+
+ # Create an instance of the parmest estimator
+ pest = parmest.Estimator(exp_list, obj_function=SSE)
+
+ solver_options = {"tol": 1e-8}
+
+ self.data = data
+ self.pest = parmest.Estimator(
+ exp_list, obj_function=SSE, solver_options=solver_options, tee=True
+ )
+
+ def test_theta_est(self):
+ objval, thetavals = self.pest.theta_est()
+
+ self.assertAlmostEqual(objval, 4.3317112, places=2)
+ self.assertAlmostEqual(
+ thetavals["asymptote"], 19.1426, places=2
+ ) # 19.1426 from the paper
+ self.assertAlmostEqual(
+ thetavals["rate_constant"], 0.5311, places=2
+ ) # 0.5311 from the paper
+
+ @unittest.skipIf(
+ not graphics.imports_available, "parmest.graphics imports are unavailable"
+ )
+ def test_bootstrap(self):
+ objval, thetavals = self.pest.theta_est()
+
+ num_bootstraps = 10
+ theta_est = self.pest.theta_est_bootstrap(num_bootstraps, return_samples=True)
+
+ num_samples = theta_est["samples"].apply(len)
+ self.assertEqual(len(theta_est.index), 10)
+ self.assertTrue(num_samples.equals(pd.Series([6] * 10)))
+
+ del theta_est["samples"]
+
+ # apply confidence region test
+ CR = self.pest.confidence_region_test(theta_est, "MVN", [0.5, 0.75, 1.0])
+
+ self.assertTrue(set(CR.columns) >= set([0.5, 0.75, 1.0]))
+ self.assertEqual(CR[0.5].sum(), 5)
+ self.assertEqual(CR[0.75].sum(), 7)
+ self.assertEqual(CR[1.0].sum(), 10) # all true
+
+ graphics.pairwise_plot(theta_est)
+ graphics.pairwise_plot(theta_est, thetavals)
+ graphics.pairwise_plot(theta_est, thetavals, 0.8, ["MVN", "KDE", "Rect"])
+
+ @unittest.skipIf(
+ not graphics.imports_available, "parmest.graphics imports are unavailable"
+ )
+ def test_likelihood_ratio(self):
+ objval, thetavals = self.pest.theta_est()
+
+ asym = np.arange(10, 30, 2)
+ rate = np.arange(0, 1.5, 0.25)
+ theta_vals = pd.DataFrame(
+ list(product(asym, rate)), columns=['asymptote', 'rate_constant']
+ )
+ obj_at_theta = self.pest.objective_at_theta(theta_vals)
+
+ LR = self.pest.likelihood_ratio_test(obj_at_theta, objval, [0.8, 0.9, 1.0])
+
+ self.assertTrue(set(LR.columns) >= set([0.8, 0.9, 1.0]))
+ self.assertEqual(LR[0.8].sum(), 6)
+ self.assertEqual(LR[0.9].sum(), 10)
+ self.assertEqual(LR[1.0].sum(), 60) # all true
+
+ graphics.pairwise_plot(LR, thetavals, 0.8)
+
+ def test_leaveNout(self):
+ lNo_theta = self.pest.theta_est_leaveNout(1)
+ self.assertTrue(lNo_theta.shape == (6, 2))
+
+ results = self.pest.leaveNout_bootstrap_test(
+ 1, None, 3, "Rect", [0.5, 1.0], seed=5436
+ )
+ self.assertEqual(len(results), 6) # 6 lNo samples
+ i = 1
+ samples = results[i][0] # list of N samples that are left out
+ lno_theta = results[i][1]
+ bootstrap_theta = results[i][2]
+ self.assertTrue(samples == [1]) # sample 1 was left out
+ self.assertEqual(lno_theta.shape[0], 1) # lno estimate for sample 1
+ self.assertTrue(set(lno_theta.columns) >= set([0.5, 1.0]))
+ self.assertEqual(lno_theta[1.0].sum(), 1) # all true
+ self.assertEqual(bootstrap_theta.shape[0], 3) # bootstrap for sample 1
+ self.assertEqual(bootstrap_theta[1.0].sum(), 3) # all true
+
+ def test_diagnostic_mode(self):
+ self.pest.diagnostic_mode = True
+
+ objval, thetavals = self.pest.theta_est()
+
+ asym = np.arange(10, 30, 2)
+ rate = np.arange(0, 1.5, 0.25)
+ theta_vals = pd.DataFrame(
+ list(product(asym, rate)), columns=['asymptote', 'rate_constant']
+ )
+
+ obj_at_theta = self.pest.objective_at_theta(theta_vals)
+
+ self.pest.diagnostic_mode = False
+
+ @unittest.skip("Presently having trouble with mpiexec on appveyor")
+ def test_parallel_parmest(self):
+ """use mpiexec and mpi4py"""
+ p = str(parmestbase.__path__)
+ l = p.find("'")
+ r = p.find("'", l + 1)
+ parmestpath = p[l + 1 : r]
+ rbpath = (
+ parmestpath
+ + os.sep
+ + "examples"
+ + os.sep
+ + "rooney_biegler"
+ + os.sep
+ + "rooney_biegler_parmest.py"
+ )
+ rbpath = os.path.abspath(rbpath) # paranoia strikes deep...
+ rlist = ["mpiexec", "--allow-run-as-root", "-n", "2", sys.executable, rbpath]
+ if sys.version_info >= (3, 5):
+ ret = subprocess.run(rlist)
+ retcode = ret.returncode
+ else:
+ retcode = subprocess.call(rlist)
+ self.assertEqual(retcode, 0)
+
+ @unittest.skip("Most folks don't have k_aug installed")
+ def test_theta_k_aug_for_Hessian(self):
+ # this will fail if k_aug is not installed
+ objval, thetavals, Hessian = self.pest.theta_est(solver="k_aug")
+ self.assertAlmostEqual(objval, 4.4675, places=2)
+
+ @unittest.skipIf(not pynumero_ASL_available, "pynumero ASL is not available")
+ @unittest.skipIf(
+ not parmest.inverse_reduced_hessian_available,
+ "Cannot test covariance matrix: required ASL dependency is missing",
+ )
+ def test_theta_est_cov(self):
+ objval, thetavals, cov = self.pest.theta_est(calc_cov=True, cov_n=6)
+
+ self.assertAlmostEqual(objval, 4.3317112, places=2)
+ self.assertAlmostEqual(
+ thetavals["asymptote"], 19.1426, places=2
+ ) # 19.1426 from the paper
+ self.assertAlmostEqual(
+ thetavals["rate_constant"], 0.5311, places=2
+ ) # 0.5311 from the paper
+
+ # Covariance matrix
+ self.assertAlmostEqual(
+ cov["asymptote"]["asymptote"], 6.30579403, places=2
+ ) # 6.22864 from paper
+ self.assertAlmostEqual(
+ cov["asymptote"]["rate_constant"], -0.4395341, places=2
+ ) # -0.4322 from paper
+ self.assertAlmostEqual(
+ cov["rate_constant"]["asymptote"], -0.4395341, places=2
+ ) # -0.4322 from paper
+ self.assertAlmostEqual(
+ cov["rate_constant"]["rate_constant"], 0.04124, places=2
+ ) # 0.04124 from paper
+
+ """ Why does the covariance matrix from parmest not match the paper? Parmest is
+ calculating the exact reduced Hessian. The paper (Rooney and Bielger, 2001) likely
+ employed the first order approximation common for nonlinear regression. The paper
+ values were verified with Scipy, which uses the same first order approximation.
+ The formula used in parmest was verified against equations (7-5-15) and (7-5-16) in
+ "Nonlinear Parameter Estimation", Y. Bard, 1974.
+ """
+
+ def test_cov_scipy_least_squares_comparison(self):
+ """
+ Scipy results differ in the 3rd decimal place from the paper. It is possible
+ the paper used an alternative finite difference approximation for the Jacobian.
+ """
+
+ def model(theta, t):
+ """
+ Model to be fitted y = model(theta, t)
+ Arguments:
+ theta: vector of fitted parameters
+ t: independent variable [hours]
+
+ Returns:
+ y: model predictions [need to check paper for units]
+ """
+ asymptote = theta[0]
+ rate_constant = theta[1]
+
+ return asymptote * (1 - np.exp(-rate_constant * t))
+
+ def residual(theta, t, y):
+ """
+ Calculate residuals
+ Arguments:
+ theta: vector of fitted parameters
+ t: independent variable [hours]
+ y: dependent variable [?]
+ """
+ return y - model(theta, t)
+
+ # define data
+ t = self.data["hour"].to_numpy()
+ y = self.data["y"].to_numpy()
+
+ # define initial guess
+ theta_guess = np.array([15, 0.5])
+
+ ## solve with optimize.least_squares
+ sol = scipy.optimize.least_squares(
+ residual, theta_guess, method="trf", args=(t, y), verbose=2
+ )
+ theta_hat = sol.x
+
+ self.assertAlmostEqual(
+ theta_hat[0], 19.1426, places=2
+ ) # 19.1426 from the paper
+ self.assertAlmostEqual(theta_hat[1], 0.5311, places=2) # 0.5311 from the paper
+
+ # calculate residuals
+ r = residual(theta_hat, t, y)
+
+ # calculate variance of the residuals
+ # -2 because there are 2 fitted parameters
+ sigre = np.matmul(r.T, r / (len(y) - 2))
+
+ # approximate covariance
+ # Need to divide by 2 because optimize.least_squares scaled the objective by 1/2
+ cov = sigre * np.linalg.inv(np.matmul(sol.jac.T, sol.jac))
+
+ self.assertAlmostEqual(cov[0, 0], 6.22864, places=2) # 6.22864 from paper
+ self.assertAlmostEqual(cov[0, 1], -0.4322, places=2) # -0.4322 from paper
+ self.assertAlmostEqual(cov[1, 0], -0.4322, places=2) # -0.4322 from paper
+ self.assertAlmostEqual(cov[1, 1], 0.04124, places=2) # 0.04124 from paper
+
+ def test_cov_scipy_curve_fit_comparison(self):
+ """
+ Scipy results differ in the 3rd decimal place from the paper. It is possible
+ the paper used an alternative finite difference approximation for the Jacobian.
+ """
+
+ ## solve with optimize.curve_fit
+ def model(t, asymptote, rate_constant):
+ return asymptote * (1 - np.exp(-rate_constant * t))
+
+ # define data
+ t = self.data["hour"].to_numpy()
+ y = self.data["y"].to_numpy()
+
+ # define initial guess
+ theta_guess = np.array([15, 0.5])
+
+ theta_hat, cov = scipy.optimize.curve_fit(model, t, y, p0=theta_guess)
+
+ self.assertAlmostEqual(
+ theta_hat[0], 19.1426, places=2
+ ) # 19.1426 from the paper
+ self.assertAlmostEqual(theta_hat[1], 0.5311, places=2) # 0.5311 from the paper
+
+ self.assertAlmostEqual(cov[0, 0], 6.22864, places=2) # 6.22864 from paper
+ self.assertAlmostEqual(cov[0, 1], -0.4322, places=2) # -0.4322 from paper
+ self.assertAlmostEqual(cov[1, 0], -0.4322, places=2) # -0.4322 from paper
+ self.assertAlmostEqual(cov[1, 1], 0.04124, places=2) # 0.04124 from paper
+
+
+@unittest.skipIf(
+ not parmest.parmest_available,
+ "Cannot test parmest: required dependencies are missing",
+)
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+class TestModelVariants(unittest.TestCase):
+
+ def setUp(self):
+ from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import (
+ RooneyBieglerExperiment,
+ )
+
+ self.data = pd.DataFrame(
+ data=[[1, 8.3], [2, 10.3], [3, 19.0], [4, 16.0], [5, 15.6], [7, 19.8]],
+ columns=["hour", "y"],
+ )
+
+ def rooney_biegler_params(data):
+ model = pyo.ConcreteModel()
+
+ model.asymptote = pyo.Param(initialize=15, mutable=True)
+ model.rate_constant = pyo.Param(initialize=0.5, mutable=True)
+
+ model.hour = pyo.Param(within=pyo.PositiveReals, mutable=True)
+ model.y = pyo.Param(within=pyo.PositiveReals, mutable=True)
+
+ def response_rule(m, h):
+ expr = m.asymptote * (1 - pyo.exp(-m.rate_constant * h))
+ return expr
+
+ model.response_function = pyo.Expression(data.hour, rule=response_rule)
+
+ return model
+
+ class RooneyBieglerExperimentParams(RooneyBieglerExperiment):
+
+ def create_model(self):
+ data_df = self.data.to_frame().transpose()
+ self.model = rooney_biegler_params(data_df)
+
+ rooney_biegler_params_exp_list = []
+ for i in range(self.data.shape[0]):
+ rooney_biegler_params_exp_list.append(
+ RooneyBieglerExperimentParams(self.data.loc[i, :])
+ )
+
+ def rooney_biegler_indexed_params(data):
+ model = pyo.ConcreteModel()
+
+ model.param_names = pyo.Set(initialize=["asymptote", "rate_constant"])
+ model.theta = pyo.Param(
+ model.param_names,
+ initialize={"asymptote": 15, "rate_constant": 0.5},
+ mutable=True,
+ )
+
+ model.hour = pyo.Param(within=pyo.PositiveReals, mutable=True)
+ model.y = pyo.Param(within=pyo.PositiveReals, mutable=True)
+
+ def response_rule(m, h):
+ expr = m.theta["asymptote"] * (
+ 1 - pyo.exp(-m.theta["rate_constant"] * h)
+ )
+ return expr
+
+ model.response_function = pyo.Expression(data.hour, rule=response_rule)
+
+ return model
+
+ class RooneyBieglerExperimentIndexedParams(RooneyBieglerExperiment):
+
+ def create_model(self):
+ data_df = self.data.to_frame().transpose()
+ self.model = rooney_biegler_indexed_params(data_df)
+
+ def label_model(self):
+
+ m = self.model
+
+ m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs.update(
+ [(m.hour, self.data["hour"]), (m.y, self.data["y"])]
+ )
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update((k, pyo.ComponentUID(k)) for k in [m.theta])
+
+ rooney_biegler_indexed_params_exp_list = []
+ for i in range(self.data.shape[0]):
+ rooney_biegler_indexed_params_exp_list.append(
+ RooneyBieglerExperimentIndexedParams(self.data.loc[i, :])
+ )
+
+ def rooney_biegler_vars(data):
+ model = pyo.ConcreteModel()
+
+ model.asymptote = pyo.Var(initialize=15)
+ model.rate_constant = pyo.Var(initialize=0.5)
+ model.asymptote.fixed = True # parmest will unfix theta variables
+ model.rate_constant.fixed = True
+
+ model.hour = pyo.Param(within=pyo.PositiveReals, mutable=True)
+ model.y = pyo.Param(within=pyo.PositiveReals, mutable=True)
+
+ def response_rule(m, h):
+ expr = m.asymptote * (1 - pyo.exp(-m.rate_constant * h))
+ return expr
+
+ model.response_function = pyo.Expression(data.hour, rule=response_rule)
+
+ return model
+
+ class RooneyBieglerExperimentVars(RooneyBieglerExperiment):
+
+ def create_model(self):
+ data_df = self.data.to_frame().transpose()
+ self.model = rooney_biegler_vars(data_df)
+
+ rooney_biegler_vars_exp_list = []
+ for i in range(self.data.shape[0]):
+ rooney_biegler_vars_exp_list.append(
+ RooneyBieglerExperimentVars(self.data.loc[i, :])
+ )
+
+ def rooney_biegler_indexed_vars(data):
+ model = pyo.ConcreteModel()
+
+ model.var_names = pyo.Set(initialize=["asymptote", "rate_constant"])
+ model.theta = pyo.Var(
+ model.var_names, initialize={"asymptote": 15, "rate_constant": 0.5}
+ )
+ model.theta["asymptote"].fixed = (
+ True # parmest will unfix theta variables, even when they are indexed
+ )
+ model.theta["rate_constant"].fixed = True
+
+ model.hour = pyo.Param(within=pyo.PositiveReals, mutable=True)
+ model.y = pyo.Param(within=pyo.PositiveReals, mutable=True)
+
+ def response_rule(m, h):
+ expr = m.theta["asymptote"] * (
+ 1 - pyo.exp(-m.theta["rate_constant"] * h)
+ )
+ return expr
+
+ model.response_function = pyo.Expression(data.hour, rule=response_rule)
+
+ return model
+
+ class RooneyBieglerExperimentIndexedVars(RooneyBieglerExperiment):
+
+ def create_model(self):
+ data_df = self.data.to_frame().transpose()
+ self.model = rooney_biegler_indexed_vars(data_df)
+
+ def label_model(self):
+
+ m = self.model
+
+ m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.experiment_outputs.update(
+ [(m.hour, self.data["hour"]), (m.y, self.data["y"])]
+ )
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update((k, pyo.ComponentUID(k)) for k in [m.theta])
+
+ rooney_biegler_indexed_vars_exp_list = []
+ for i in range(self.data.shape[0]):
+ rooney_biegler_indexed_vars_exp_list.append(
+ RooneyBieglerExperimentIndexedVars(self.data.loc[i, :])
+ )
+
+ # Sum of squared error function
+ def SSE(model):
+ expr = (
+ model.experiment_outputs[model.y]
+ - model.response_function[model.experiment_outputs[model.hour]]
+ ) ** 2
+ return expr
+
+ self.objective_function = SSE
+
+ theta_vals = pd.DataFrame([20, 1], index=["asymptote", "rate_constant"]).T
+ theta_vals_index = pd.DataFrame(
+ [20, 1], index=["theta['asymptote']", "theta['rate_constant']"]
+ ).T
+
+ self.input = {
+ "param": {
+ "exp_list": rooney_biegler_params_exp_list,
+ "theta_names": ["asymptote", "rate_constant"],
+ "theta_vals": theta_vals,
+ },
+ "param_index": {
+ "exp_list": rooney_biegler_indexed_params_exp_list,
+ "theta_names": ["theta"],
+ "theta_vals": theta_vals_index,
+ },
+ "vars": {
+ "exp_list": rooney_biegler_vars_exp_list,
+ "theta_names": ["asymptote", "rate_constant"],
+ "theta_vals": theta_vals,
+ },
+ "vars_index": {
+ "exp_list": rooney_biegler_indexed_vars_exp_list,
+ "theta_names": ["theta"],
+ "theta_vals": theta_vals_index,
+ },
+ "vars_quoted_index": {
+ "exp_list": rooney_biegler_indexed_vars_exp_list,
+ "theta_names": ["theta['asymptote']", "theta['rate_constant']"],
+ "theta_vals": theta_vals_index,
+ },
+ "vars_str_index": {
+ "exp_list": rooney_biegler_indexed_vars_exp_list,
+ "theta_names": ["theta[asymptote]", "theta[rate_constant]"],
+ "theta_vals": theta_vals_index,
+ },
+ }
+
+ @unittest.skipIf(not pynumero_ASL_available, "pynumero ASL is not available")
+ @unittest.skipIf(
+ not parmest.inverse_reduced_hessian_available,
+ "Cannot test covariance matrix: required ASL dependency is missing",
+ )
+ def check_rooney_biegler_results(self, objval, cov):
+
+ # get indices in covariance matrix
+ cov_cols = cov.columns.to_list()
+ asymptote_index = [idx for idx, s in enumerate(cov_cols) if "asymptote" in s][0]
+ rate_constant_index = [
+ idx for idx, s in enumerate(cov_cols) if "rate_constant" in s
+ ][0]
+
+ self.assertAlmostEqual(objval, 4.3317112, places=2)
+ self.assertAlmostEqual(
+ cov.iloc[asymptote_index, asymptote_index], 6.30579403, places=2
+ ) # 6.22864 from paper
+ self.assertAlmostEqual(
+ cov.iloc[asymptote_index, rate_constant_index], -0.4395341, places=2
+ ) # -0.4322 from paper
+ self.assertAlmostEqual(
+ cov.iloc[rate_constant_index, asymptote_index], -0.4395341, places=2
+ ) # -0.4322 from paper
+ self.assertAlmostEqual(
+ cov.iloc[rate_constant_index, rate_constant_index], 0.04193591, places=2
+ ) # 0.04124 from paper
+
+ def test_parmest_basics(self):
+
+ for model_type, parmest_input in self.input.items():
+ pest = parmest.Estimator(
+ parmest_input["exp_list"], obj_function=self.objective_function
+ )
+
+ objval, thetavals, cov = pest.theta_est(calc_cov=True, cov_n=6)
+ self.check_rooney_biegler_results(objval, cov)
+
+ obj_at_theta = pest.objective_at_theta(parmest_input["theta_vals"])
+ self.assertAlmostEqual(obj_at_theta["obj"][0], 16.531953, places=2)
+
+ def test_parmest_basics_with_initialize_parmest_model_option(self):
+
+ for model_type, parmest_input in self.input.items():
+ pest = parmest.Estimator(
+ parmest_input["exp_list"], obj_function=self.objective_function
+ )
+
+ objval, thetavals, cov = pest.theta_est(calc_cov=True, cov_n=6)
+ self.check_rooney_biegler_results(objval, cov)
+
+ obj_at_theta = pest.objective_at_theta(
+ parmest_input["theta_vals"], initialize_parmest_model=True
+ )
+
+ self.assertAlmostEqual(obj_at_theta["obj"][0], 16.531953, places=2)
+
+ def test_parmest_basics_with_square_problem_solve(self):
+
+ for model_type, parmest_input in self.input.items():
+ pest = parmest.Estimator(
+ parmest_input["exp_list"], obj_function=self.objective_function
+ )
+
+ obj_at_theta = pest.objective_at_theta(
+ parmest_input["theta_vals"], initialize_parmest_model=True
+ )
+
+ objval, thetavals, cov = pest.theta_est(calc_cov=True, cov_n=6)
+ self.check_rooney_biegler_results(objval, cov)
+
+ self.assertAlmostEqual(obj_at_theta["obj"][0], 16.531953, places=2)
+
+ def test_parmest_basics_with_square_problem_solve_no_theta_vals(self):
+
+ for model_type, parmest_input in self.input.items():
+
+ pest = parmest.Estimator(
+ parmest_input["exp_list"], obj_function=self.objective_function
+ )
+
+ obj_at_theta = pest.objective_at_theta(initialize_parmest_model=True)
+
+ objval, thetavals, cov = pest.theta_est(calc_cov=True, cov_n=6)
+ self.check_rooney_biegler_results(objval, cov)
+
+
+@unittest.skipIf(
+ not parmest.parmest_available,
+ "Cannot test parmest: required dependencies are missing",
+)
+@unittest.skipIf(not ipopt_available, "The 'ipopt' solver is not available")
+class TestReactorDesign(unittest.TestCase):
+ def setUp(self):
+ from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
+ ReactorDesignExperiment,
+ )
+
+ # Data from the design
+ data = pd.DataFrame(
+ data=[
+ [1.05, 10000, 3458.4, 1060.8, 1683.9, 1898.5],
+ [1.10, 10000, 3535.1, 1064.8, 1613.3, 1893.4],
+ [1.15, 10000, 3609.1, 1067.8, 1547.5, 1887.8],
+ [1.20, 10000, 3680.7, 1070.0, 1486.1, 1881.6],
+ [1.25, 10000, 3750.0, 1071.4, 1428.6, 1875.0],
+ [1.30, 10000, 3817.1, 1072.2, 1374.6, 1868.0],
+ [1.35, 10000, 3882.2, 1072.4, 1324.0, 1860.7],
+ [1.40, 10000, 3945.4, 1072.1, 1276.3, 1853.1],
+ [1.45, 10000, 4006.7, 1071.3, 1231.4, 1845.3],
+ [1.50, 10000, 4066.4, 1070.1, 1189.0, 1837.3],
+ [1.55, 10000, 4124.4, 1068.5, 1148.9, 1829.1],
+ [1.60, 10000, 4180.9, 1066.5, 1111.0, 1820.8],
+ [1.65, 10000, 4235.9, 1064.3, 1075.0, 1812.4],
+ [1.70, 10000, 4289.5, 1061.8, 1040.9, 1803.9],
+ [1.75, 10000, 4341.8, 1059.0, 1008.5, 1795.3],
+ [1.80, 10000, 4392.8, 1056.0, 977.7, 1786.7],
+ [1.85, 10000, 4442.6, 1052.8, 948.4, 1778.1],
+ [1.90, 10000, 4491.3, 1049.4, 920.5, 1769.4],
+ [1.95, 10000, 4538.8, 1045.8, 893.9, 1760.8],
+ ],
+ columns=["sv", "caf", "ca", "cb", "cc", "cd"],
+ )
+
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(ReactorDesignExperiment(data, i))
+
+ solver_options = {"max_iter": 6000}
+
+ self.pest = parmest.Estimator(
+ exp_list, obj_function="SSE", solver_options=solver_options
+ )
+
+ def test_theta_est(self):
+ # used in data reconciliation
+ objval, thetavals = self.pest.theta_est()
+
+ self.assertAlmostEqual(thetavals["k1"], 5.0 / 6.0, places=4)
+ self.assertAlmostEqual(thetavals["k2"], 5.0 / 3.0, places=4)
+ self.assertAlmostEqual(thetavals["k3"], 1.0 / 6000.0, places=7)
+
+ def test_return_values(self):
+ objval, thetavals, data_rec = self.pest.theta_est(
+ return_values=["ca", "cb", "cc", "cd", "caf"]
+ )
+ self.assertAlmostEqual(data_rec["cc"].loc[18], 893.84924, places=3)
+
+
+@unittest.skipIf(
+ not parmest.parmest_available,
+ "Cannot test parmest: required dependencies are missing",
+)
+@unittest.skipIf(not ipopt_available, "The 'ipopt' solver is not available")
+class TestReactorDesign_DAE(unittest.TestCase):
+ # Based on a reactor example in `Chemical Reactor Analysis and Design Fundamentals`,
+ # https://sites.engineering.ucsb.edu/~jbraw/chemreacfun/
+ # https://sites.engineering.ucsb.edu/~jbraw/chemreacfun/fig-html/appendix/fig-A-10.html
+
+ def setUp(self):
+ def ABC_model(data):
+ ca_meas = data["ca"]
+ cb_meas = data["cb"]
+ cc_meas = data["cc"]
+
+ if isinstance(data, pd.DataFrame):
+ meas_t = data.index # time index
+ else: # dictionary
+ meas_t = list(ca_meas.keys()) # nested dictionary
+
+ ca0 = 1.0
+ cb0 = 0.0
+ cc0 = 0.0
+
+ m = pyo.ConcreteModel()
+
+ m.k1 = pyo.Var(initialize=0.5, bounds=(1e-4, 10))
+ m.k2 = pyo.Var(initialize=3.0, bounds=(1e-4, 10))
+
+ m.time = dae.ContinuousSet(bounds=(0.0, 5.0), initialize=meas_t)
+
+ # initialization and bounds
+ m.ca = pyo.Var(m.time, initialize=ca0, bounds=(-1e-3, ca0 + 1e-3))
+ m.cb = pyo.Var(m.time, initialize=cb0, bounds=(-1e-3, ca0 + 1e-3))
+ m.cc = pyo.Var(m.time, initialize=cc0, bounds=(-1e-3, ca0 + 1e-3))
+
+ m.dca = dae.DerivativeVar(m.ca, wrt=m.time)
+ m.dcb = dae.DerivativeVar(m.cb, wrt=m.time)
+ m.dcc = dae.DerivativeVar(m.cc, wrt=m.time)
+
+ def _dcarate(m, t):
+ if t == 0:
+ return pyo.Constraint.Skip
+ else:
+ return m.dca[t] == -m.k1 * m.ca[t]
+
+ m.dcarate = pyo.Constraint(m.time, rule=_dcarate)
+
+ def _dcbrate(m, t):
+ if t == 0:
+ return pyo.Constraint.Skip
+ else:
+ return m.dcb[t] == m.k1 * m.ca[t] - m.k2 * m.cb[t]
+
+ m.dcbrate = pyo.Constraint(m.time, rule=_dcbrate)
+
+ def _dccrate(m, t):
+ if t == 0:
+ return pyo.Constraint.Skip
+ else:
+ return m.dcc[t] == m.k2 * m.cb[t]
+
+ m.dccrate = pyo.Constraint(m.time, rule=_dccrate)
+
+ def ComputeFirstStageCost_rule(m):
+ return 0
+
+ m.FirstStageCost = pyo.Expression(rule=ComputeFirstStageCost_rule)
+
+ def ComputeSecondStageCost_rule(m):
+ return sum(
+ (m.ca[t] - ca_meas[t]) ** 2
+ + (m.cb[t] - cb_meas[t]) ** 2
+ + (m.cc[t] - cc_meas[t]) ** 2
+ for t in meas_t
+ )
+
+ m.SecondStageCost = pyo.Expression(rule=ComputeSecondStageCost_rule)
+
+ def total_cost_rule(model):
+ return model.FirstStageCost + model.SecondStageCost
+
+ m.Total_Cost_Objective = pyo.Objective(
+ rule=total_cost_rule, sense=pyo.minimize
+ )
+
+ disc = pyo.TransformationFactory("dae.collocation")
+ disc.apply_to(m, nfe=20, ncp=2)
+
+ return m
+
+ class ReactorDesignExperimentDAE(Experiment):
+
+ def __init__(self, data):
+
+ self.data = data
+ self.model = None
+
+ def create_model(self):
+ self.model = ABC_model(self.data)
+
+ def label_model(self):
+
+ m = self.model
+
+ m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+ m.unknown_parameters.update(
+ (k, pyo.ComponentUID(k)) for k in [m.k1, m.k2]
+ )
+
+ def get_labeled_model(self):
+ self.create_model()
+ self.label_model()
+
+ return self.model
+
+ # This example tests data formatted in 3 ways
+ # Each format holds 1 scenario
+ # 1. dataframe with time index
+ # 2. nested dictionary {ca: {t, val pairs}, ... }
+ data = [
+ [0.000, 0.957, -0.031, -0.015],
+ [0.263, 0.557, 0.330, 0.044],
+ [0.526, 0.342, 0.512, 0.156],
+ [0.789, 0.224, 0.499, 0.310],
+ [1.053, 0.123, 0.428, 0.454],
+ [1.316, 0.079, 0.396, 0.556],
+ [1.579, 0.035, 0.303, 0.651],
+ [1.842, 0.029, 0.287, 0.658],
+ [2.105, 0.025, 0.221, 0.750],
+ [2.368, 0.017, 0.148, 0.854],
+ [2.632, -0.002, 0.182, 0.845],
+ [2.895, 0.009, 0.116, 0.893],
+ [3.158, -0.023, 0.079, 0.942],
+ [3.421, 0.006, 0.078, 0.899],
+ [3.684, 0.016, 0.059, 0.942],
+ [3.947, 0.014, 0.036, 0.991],
+ [4.211, -0.009, 0.014, 0.988],
+ [4.474, -0.030, 0.036, 0.941],
+ [4.737, 0.004, 0.036, 0.971],
+ [5.000, -0.024, 0.028, 0.985],
+ ]
+ data = pd.DataFrame(data, columns=["t", "ca", "cb", "cc"])
+ data_df = data.set_index("t")
+ data_dict = {
+ "ca": {k: v for (k, v) in zip(data.t, data.ca)},
+ "cb": {k: v for (k, v) in zip(data.t, data.cb)},
+ "cc": {k: v for (k, v) in zip(data.t, data.cc)},
+ }
+
+ # Create an experiment list
+ exp_list_df = [ReactorDesignExperimentDAE(data_df)]
+ exp_list_dict = [ReactorDesignExperimentDAE(data_dict)]
+
+ self.pest_df = parmest.Estimator(exp_list_df)
+ self.pest_dict = parmest.Estimator(exp_list_dict)
+
+ # Estimator object with multiple scenarios
+ exp_list_df_multiple = [
+ ReactorDesignExperimentDAE(data_df),
+ ReactorDesignExperimentDAE(data_df),
+ ]
+ exp_list_dict_multiple = [
+ ReactorDesignExperimentDAE(data_dict),
+ ReactorDesignExperimentDAE(data_dict),
+ ]
+
+ self.pest_df_multiple = parmest.Estimator(exp_list_df_multiple)
+ self.pest_dict_multiple = parmest.Estimator(exp_list_dict_multiple)
+
+ # Create an instance of the model
+ self.m_df = ABC_model(data_df)
+ self.m_dict = ABC_model(data_dict)
+
+ def test_dataformats(self):
+ obj1, theta1 = self.pest_df.theta_est()
+ obj2, theta2 = self.pest_dict.theta_est()
+
+ self.assertAlmostEqual(obj1, obj2, places=6)
+ self.assertAlmostEqual(theta1["k1"], theta2["k1"], places=6)
+ self.assertAlmostEqual(theta1["k2"], theta2["k2"], places=6)
+
+ def test_return_continuous_set(self):
+ """
+ test if ContinuousSet elements are returned correctly from theta_est()
+ """
+ obj1, theta1, return_vals1 = self.pest_df.theta_est(return_values=["time"])
+ obj2, theta2, return_vals2 = self.pest_dict.theta_est(return_values=["time"])
+ self.assertAlmostEqual(return_vals1["time"].loc[0][18], 2.368, places=3)
+ self.assertAlmostEqual(return_vals2["time"].loc[0][18], 2.368, places=3)
+
+ def test_return_continuous_set_multiple_datasets(self):
+ """
+ test if ContinuousSet elements are returned correctly from theta_est()
+ """
+ obj1, theta1, return_vals1 = self.pest_df_multiple.theta_est(
+ return_values=["time"]
+ )
+ obj2, theta2, return_vals2 = self.pest_dict_multiple.theta_est(
+ return_values=["time"]
+ )
+ self.assertAlmostEqual(return_vals1["time"].loc[1][18], 2.368, places=3)
+ self.assertAlmostEqual(return_vals2["time"].loc[1][18], 2.368, places=3)
+
+ def test_covariance(self):
+ from pyomo.contrib.interior_point.inverse_reduced_hessian import (
+ inv_reduced_hessian_barrier,
+ )
+
+ # Number of datapoints.
+ # 3 data components (ca, cb, cc), 20 timesteps, 1 scenario = 60
+ # In this example, this is the number of data points in data_df, but that's
+ # only because the data is indexed by time and contains no additional information.
+ n = 60
+
+ # Compute covariance using parmest
+ obj, theta, cov = self.pest_df.theta_est(calc_cov=True, cov_n=n)
+
+ # Compute covariance using interior_point
+ vars_list = [self.m_df.k1, self.m_df.k2]
+ solve_result, inv_red_hes = inv_reduced_hessian_barrier(
+ self.m_df, independent_variables=vars_list, tee=True
+ )
+ l = len(vars_list)
+ cov_interior_point = 2 * obj / (n - l) * inv_red_hes
+ cov_interior_point = pd.DataFrame(
+ cov_interior_point, ["k1", "k2"], ["k1", "k2"]
+ )
+
+ cov_diff = (cov - cov_interior_point).abs().sum().sum()
+
+ self.assertTrue(cov.loc["k1", "k1"] > 0)
+ self.assertTrue(cov.loc["k2", "k2"] > 0)
+ self.assertAlmostEqual(cov_diff, 0, places=6)
+
+
+@unittest.skipIf(
+ not parmest.parmest_available,
+ "Cannot test parmest: required dependencies are missing",
+)
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+class TestSquareInitialization_RooneyBiegler(unittest.TestCase):
+ def setUp(self):
+ from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler_with_constraint import (
+ RooneyBieglerExperiment,
+ )
+
+ # Note, the data used in this test has been corrected to use data.loc[5,'hour'] = 7 (instead of 6)
+ data = pd.DataFrame(
+ data=[[1, 8.3], [2, 10.3], [3, 19.0], [4, 16.0], [5, 15.6], [7, 19.8]],
+ columns=["hour", "y"],
+ )
+
+ # Sum of squared error function
+ def SSE(model):
+ expr = (
+ model.experiment_outputs[model.y]
+ - model.response_function[model.experiment_outputs[model.hour]]
+ ) ** 2
+ return expr
+
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(RooneyBieglerExperiment(data.loc[i, :]))
+
+ solver_options = {"tol": 1e-8}
+
+ self.data = data
+ self.pest = parmest.Estimator(
+ exp_list, obj_function=SSE, solver_options=solver_options, tee=True
+ )
+
+ def test_theta_est_with_square_initialization(self):
+ obj_init = self.pest.objective_at_theta(initialize_parmest_model=True)
+ objval, thetavals = self.pest.theta_est()
+
+ self.assertAlmostEqual(objval, 4.3317112, places=2)
+ self.assertAlmostEqual(
+ thetavals["asymptote"], 19.1426, places=2
+ ) # 19.1426 from the paper
+ self.assertAlmostEqual(
+ thetavals["rate_constant"], 0.5311, places=2
+ ) # 0.5311 from the paper
+
+ def test_theta_est_with_square_initialization_and_custom_init_theta(self):
+ theta_vals_init = pd.DataFrame(
+ data=[[19.0, 0.5]], columns=["asymptote", "rate_constant"]
+ )
+ obj_init = self.pest.objective_at_theta(
+ theta_values=theta_vals_init, initialize_parmest_model=True
)
+ objval, thetavals = self.pest.theta_est()
+ self.assertAlmostEqual(objval, 4.3317112, places=2)
+ self.assertAlmostEqual(
+ thetavals["asymptote"], 19.1426, places=2
+ ) # 19.1426 from the paper
+ self.assertAlmostEqual(
+ thetavals["rate_constant"], 0.5311, places=2
+ ) # 0.5311 from the paper
+
+ def test_theta_est_with_square_initialization_diagnostic_mode_true(self):
+ self.pest.diagnostic_mode = True
+ obj_init = self.pest.objective_at_theta(initialize_parmest_model=True)
+ objval, thetavals = self.pest.theta_est()
+
+ self.assertAlmostEqual(objval, 4.3317112, places=2)
+ self.assertAlmostEqual(
+ thetavals["asymptote"], 19.1426, places=2
+ ) # 19.1426 from the paper
+ self.assertAlmostEqual(
+ thetavals["rate_constant"], 0.5311, places=2
+ ) # 0.5311 from the paper
+
+ self.pest.diagnostic_mode = False
+
+
+###########################
+# tests for deprecated UI #
+###########################
+
+
+@unittest.skipIf(
+ not parmest.parmest_available,
+ "Cannot test parmest: required dependencies are missing",
+)
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+class TestRooneyBieglerDeprecated(unittest.TestCase):
+ def setUp(self):
+
+ def rooney_biegler_model(data):
+ model = pyo.ConcreteModel()
+
+ model.asymptote = pyo.Var(initialize=15)
+ model.rate_constant = pyo.Var(initialize=0.5)
+
+ def response_rule(m, h):
+ expr = m.asymptote * (1 - pyo.exp(-m.rate_constant * h))
+ return expr
+
+ model.response_function = pyo.Expression(data.hour, rule=response_rule)
+
+ def SSE_rule(m):
+ return sum(
+ (data.y[i] - m.response_function[data.hour[i]]) ** 2
+ for i in data.index
+ )
+
+ model.SSE = pyo.Objective(rule=SSE_rule, sense=pyo.minimize)
+
+ return model
# Note, the data used in this test has been corrected to use data.loc[5,'hour'] = 7 (instead of 6)
data = pd.DataFrame(
@@ -132,7 +1144,7 @@ def test_likelihood_ratio(self):
asym = np.arange(10, 30, 2)
rate = np.arange(0, 1.5, 0.25)
theta_vals = pd.DataFrame(
- list(product(asym, rate)), columns=self.pest.theta_names
+ list(product(asym, rate)), columns=self.pest._return_theta_names()
)
obj_at_theta = self.pest.objective_at_theta(theta_vals)
@@ -173,7 +1185,7 @@ def test_diagnostic_mode(self):
asym = np.arange(10, 30, 2)
rate = np.arange(0, 1.5, 0.25)
theta_vals = pd.DataFrame(
- list(product(asym, rate)), columns=self.pest.theta_names
+ list(product(asym, rate)), columns=self.pest._return_theta_names()
)
obj_at_theta = self.pest.objective_at_theta(theta_vals)
@@ -347,7 +1359,7 @@ def model(t, asymptote, rate_constant):
"Cannot test parmest: required dependencies are missing",
)
@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
-class TestModelVariants(unittest.TestCase):
+class TestModelVariantsDeprecated(unittest.TestCase):
def setUp(self):
self.data = pd.DataFrame(
data=[[1, 8.3], [2, 10.3], [3, 19.0], [4, 16.0], [5, 15.6], [7, 19.8]],
@@ -601,11 +1613,84 @@ def test_parmest_basics_with_square_problem_solve_no_theta_vals(self):
"Cannot test parmest: required dependencies are missing",
)
@unittest.skipIf(not ipopt_available, "The 'ipopt' solver is not available")
-class TestReactorDesign(unittest.TestCase):
+class TestReactorDesignDeprecated(unittest.TestCase):
def setUp(self):
- from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
- )
+
+ def reactor_design_model(data):
+ # Create the concrete model
+ model = pyo.ConcreteModel()
+
+ # Rate constants
+ model.k1 = pyo.Param(
+ initialize=5.0 / 6.0, within=pyo.PositiveReals, mutable=True
+ ) # min^-1
+ model.k2 = pyo.Param(
+ initialize=5.0 / 3.0, within=pyo.PositiveReals, mutable=True
+ ) # min^-1
+ model.k3 = pyo.Param(
+ initialize=1.0 / 6000.0, within=pyo.PositiveReals, mutable=True
+ ) # m^3/(gmol min)
+
+ # Inlet concentration of A, gmol/m^3
+ if isinstance(data, dict) or isinstance(data, pd.Series):
+ model.caf = pyo.Param(
+ initialize=float(data["caf"]), within=pyo.PositiveReals
+ )
+ elif isinstance(data, pd.DataFrame):
+ model.caf = pyo.Param(
+ initialize=float(data.iloc[0]["caf"]), within=pyo.PositiveReals
+ )
+ else:
+ raise ValueError("Unrecognized data type.")
+
+ # Space velocity (flowrate/volume)
+ if isinstance(data, dict) or isinstance(data, pd.Series):
+ model.sv = pyo.Param(
+ initialize=float(data["sv"]), within=pyo.PositiveReals
+ )
+ elif isinstance(data, pd.DataFrame):
+ model.sv = pyo.Param(
+ initialize=float(data.iloc[0]["sv"]), within=pyo.PositiveReals
+ )
+ else:
+ raise ValueError("Unrecognized data type.")
+
+ # Outlet concentration of each component
+ model.ca = pyo.Var(initialize=5000.0, within=pyo.PositiveReals)
+ model.cb = pyo.Var(initialize=2000.0, within=pyo.PositiveReals)
+ model.cc = pyo.Var(initialize=2000.0, within=pyo.PositiveReals)
+ model.cd = pyo.Var(initialize=1000.0, within=pyo.PositiveReals)
+
+ # Objective
+ model.obj = pyo.Objective(expr=model.cb, sense=pyo.maximize)
+
+ # Constraints
+ model.ca_bal = pyo.Constraint(
+ expr=(
+ 0
+ == model.sv * model.caf
+ - model.sv * model.ca
+ - model.k1 * model.ca
+ - 2.0 * model.k3 * model.ca**2.0
+ )
+ )
+
+ model.cb_bal = pyo.Constraint(
+ expr=(
+ 0
+ == -model.sv * model.cb + model.k1 * model.ca - model.k2 * model.cb
+ )
+ )
+
+ model.cc_bal = pyo.Constraint(
+ expr=(0 == -model.sv * model.cc + model.k2 * model.cb)
+ )
+
+ model.cd_bal = pyo.Constraint(
+ expr=(0 == -model.sv * model.cd + model.k3 * model.ca**2.0)
+ )
+
+ return model
# Data from the design
data = pd.DataFrame(
@@ -670,7 +1755,7 @@ def test_return_values(self):
"Cannot test parmest: required dependencies are missing",
)
@unittest.skipIf(not ipopt_available, "The 'ipopt' solver is not available")
-class TestReactorDesign_DAE(unittest.TestCase):
+class TestReactorDesign_DAE_Deprecated(unittest.TestCase):
# Based on a reactor example in `Chemical Reactor Analysis and Design Fundamentals`,
# https://sites.engineering.ucsb.edu/~jbraw/chemreacfun/
# https://sites.engineering.ucsb.edu/~jbraw/chemreacfun/fig-html/appendix/fig-A-10.html
@@ -875,11 +1960,35 @@ def test_covariance(self):
"Cannot test parmest: required dependencies are missing",
)
@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
-class TestSquareInitialization_RooneyBiegler(unittest.TestCase):
+class TestSquareInitialization_RooneyBiegler_Deprecated(unittest.TestCase):
def setUp(self):
- from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler_with_constraint import (
- rooney_biegler_model_with_constraint,
- )
+
+ def rooney_biegler_model_with_constraint(data):
+ model = pyo.ConcreteModel()
+
+ model.asymptote = pyo.Var(initialize=15)
+ model.rate_constant = pyo.Var(initialize=0.5)
+ model.response_function = pyo.Var(data.hour, initialize=0.0)
+
+ # changed from expression to constraint
+ def response_rule(m, h):
+ return m.response_function[h] == m.asymptote * (
+ 1 - pyo.exp(-m.rate_constant * h)
+ )
+
+ model.response_function_constraint = pyo.Constraint(
+ data.hour, rule=response_rule
+ )
+
+ def SSE_rule(m):
+ return sum(
+ (data.y[i] - m.response_function[data.hour[i]]) ** 2
+ for i in data.index
+ )
+
+ model.SSE = pyo.Objective(rule=SSE_rule, sense=pyo.minimize)
+
+ return model
# Note, the data used in this test has been corrected to use data.loc[5,'hour'] = 7 (instead of 6)
data = pd.DataFrame(
diff --git a/pyomo/contrib/parmest/tests/test_scenariocreator.py b/pyomo/contrib/parmest/tests/test_scenariocreator.py
index 7db7d0ed5db..af755e34b67 100644
--- a/pyomo/contrib/parmest/tests/test_scenariocreator.py
+++ b/pyomo/contrib/parmest/tests/test_scenariocreator.py
@@ -37,7 +37,7 @@
class TestScenarioReactorDesign(unittest.TestCase):
def setUp(self):
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
+ ReactorDesignExperiment,
)
# Data from the design
@@ -66,6 +66,193 @@ def setUp(self):
columns=["sv", "caf", "ca", "cb", "cc", "cd"],
)
+ # Create an experiment list
+ exp_list = []
+ for i in range(data.shape[0]):
+ exp_list.append(ReactorDesignExperiment(data, i))
+
+ self.pest = parmest.Estimator(exp_list, obj_function='SSE')
+
+ def test_scen_from_exps(self):
+ scenmaker = sc.ScenarioCreator(self.pest, "ipopt")
+ experimentscens = sc.ScenarioSet("Experiments")
+ scenmaker.ScenariosFromExperiments(experimentscens)
+ experimentscens.write_csv("delme_exp_csv.csv")
+ df = pd.read_csv("delme_exp_csv.csv")
+ os.remove("delme_exp_csv.csv")
+ # March '20: all reactor_design experiments have the same theta values!
+ k1val = df.loc[5].at["k1"]
+ self.assertAlmostEqual(k1val, 5.0 / 6.0, places=2)
+ tval = experimentscens.ScenarioNumber(0).ThetaVals["k1"]
+ self.assertAlmostEqual(tval, 5.0 / 6.0, places=2)
+
+ @unittest.skipIf(not uuid_available, "The uuid module is not available")
+ def test_no_csv_if_empty(self):
+ # low level test of scenario sets
+ # verify that nothing is written, but no errors with empty set
+
+ emptyset = sc.ScenarioSet("empty")
+ tfile = uuid.uuid4().hex + ".csv"
+ emptyset.write_csv(tfile)
+ self.assertFalse(
+ os.path.exists(tfile), "ScenarioSet wrote csv in spite of empty set"
+ )
+
+
+@unittest.skipIf(
+ not parmest.parmest_available,
+ "Cannot test parmest: required dependencies are missing",
+)
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+class TestScenarioSemibatch(unittest.TestCase):
+ def setUp(self):
+ import pyomo.contrib.parmest.examples.semibatch.semibatch as sb
+ import json
+
+ self.fbase = os.path.join(testdir, "..", "examples", "semibatch")
+ # Data, list of dictionaries
+ data = []
+ for exp_num in range(10):
+ fname = "exp" + str(exp_num + 1) + ".out"
+ fullname = os.path.join(self.fbase, fname)
+ with open(fullname, "r") as infile:
+ d = json.load(infile)
+ data.append(d)
+
+ # Note, the model already includes a 'SecondStageCost' expression
+ # for the sum of squared error that will be used in parameter estimation
+
+ # Create an experiment list
+ exp_list = []
+ for i in range(len(data)):
+ exp_list.append(sb.SemiBatchExperiment(data[i]))
+
+ self.pest = parmest.Estimator(exp_list)
+
+ def test_semibatch_bootstrap(self):
+ scenmaker = sc.ScenarioCreator(self.pest, "ipopt")
+ bootscens = sc.ScenarioSet("Bootstrap")
+ numtomake = 2
+ scenmaker.ScenariosFromBootstrap(bootscens, numtomake, seed=1134)
+ tval = bootscens.ScenarioNumber(0).ThetaVals["k1"]
+ self.assertAlmostEqual(tval, 20.64, places=1)
+
+
+###########################
+# tests for deprecated UI #
+###########################
+
+
+@unittest.skipIf(
+ not parmest.parmest_available,
+ "Cannot test parmest: required dependencies are missing",
+)
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+class TestScenarioReactorDesignDeprecated(unittest.TestCase):
+ def setUp(self):
+
+ def reactor_design_model(data):
+ # Create the concrete model
+ model = pyo.ConcreteModel()
+
+ # Rate constants
+ model.k1 = pyo.Param(
+ initialize=5.0 / 6.0, within=pyo.PositiveReals, mutable=True
+ ) # min^-1
+ model.k2 = pyo.Param(
+ initialize=5.0 / 3.0, within=pyo.PositiveReals, mutable=True
+ ) # min^-1
+ model.k3 = pyo.Param(
+ initialize=1.0 / 6000.0, within=pyo.PositiveReals, mutable=True
+ ) # m^3/(gmol min)
+
+ # Inlet concentration of A, gmol/m^3
+ if isinstance(data, dict) or isinstance(data, pd.Series):
+ model.caf = pyo.Param(
+ initialize=float(data["caf"]), within=pyo.PositiveReals
+ )
+ elif isinstance(data, pd.DataFrame):
+ model.caf = pyo.Param(
+ initialize=float(data.iloc[0]["caf"]), within=pyo.PositiveReals
+ )
+ else:
+ raise ValueError("Unrecognized data type.")
+
+ # Space velocity (flowrate/volume)
+ if isinstance(data, dict) or isinstance(data, pd.Series):
+ model.sv = pyo.Param(
+ initialize=float(data["sv"]), within=pyo.PositiveReals
+ )
+ elif isinstance(data, pd.DataFrame):
+ model.sv = pyo.Param(
+ initialize=float(data.iloc[0]["sv"]), within=pyo.PositiveReals
+ )
+ else:
+ raise ValueError("Unrecognized data type.")
+
+ # Outlet concentration of each component
+ model.ca = pyo.Var(initialize=5000.0, within=pyo.PositiveReals)
+ model.cb = pyo.Var(initialize=2000.0, within=pyo.PositiveReals)
+ model.cc = pyo.Var(initialize=2000.0, within=pyo.PositiveReals)
+ model.cd = pyo.Var(initialize=1000.0, within=pyo.PositiveReals)
+
+ # Objective
+ model.obj = pyo.Objective(expr=model.cb, sense=pyo.maximize)
+
+ # Constraints
+ model.ca_bal = pyo.Constraint(
+ expr=(
+ 0
+ == model.sv * model.caf
+ - model.sv * model.ca
+ - model.k1 * model.ca
+ - 2.0 * model.k3 * model.ca**2.0
+ )
+ )
+
+ model.cb_bal = pyo.Constraint(
+ expr=(
+ 0
+ == -model.sv * model.cb + model.k1 * model.ca - model.k2 * model.cb
+ )
+ )
+
+ model.cc_bal = pyo.Constraint(
+ expr=(0 == -model.sv * model.cc + model.k2 * model.cb)
+ )
+
+ model.cd_bal = pyo.Constraint(
+ expr=(0 == -model.sv * model.cd + model.k3 * model.ca**2.0)
+ )
+
+ return model
+
+ # Data from the design
+ data = pd.DataFrame(
+ data=[
+ [1.05, 10000, 3458.4, 1060.8, 1683.9, 1898.5],
+ [1.10, 10000, 3535.1, 1064.8, 1613.3, 1893.4],
+ [1.15, 10000, 3609.1, 1067.8, 1547.5, 1887.8],
+ [1.20, 10000, 3680.7, 1070.0, 1486.1, 1881.6],
+ [1.25, 10000, 3750.0, 1071.4, 1428.6, 1875.0],
+ [1.30, 10000, 3817.1, 1072.2, 1374.6, 1868.0],
+ [1.35, 10000, 3882.2, 1072.4, 1324.0, 1860.7],
+ [1.40, 10000, 3945.4, 1072.1, 1276.3, 1853.1],
+ [1.45, 10000, 4006.7, 1071.3, 1231.4, 1845.3],
+ [1.50, 10000, 4066.4, 1070.1, 1189.0, 1837.3],
+ [1.55, 10000, 4124.4, 1068.5, 1148.9, 1829.1],
+ [1.60, 10000, 4180.9, 1066.5, 1111.0, 1820.8],
+ [1.65, 10000, 4235.9, 1064.3, 1075.0, 1812.4],
+ [1.70, 10000, 4289.5, 1061.8, 1040.9, 1803.9],
+ [1.75, 10000, 4341.8, 1059.0, 1008.5, 1795.3],
+ [1.80, 10000, 4392.8, 1056.0, 977.7, 1786.7],
+ [1.85, 10000, 4442.6, 1052.8, 948.4, 1778.1],
+ [1.90, 10000, 4491.3, 1049.4, 920.5, 1769.4],
+ [1.95, 10000, 4538.8, 1045.8, 893.9, 1760.8],
+ ],
+ columns=["sv", "caf", "ca", "cb", "cc", "cd"],
+ )
+
theta_names = ["k1", "k2", "k3"]
def SSE(model, data):
@@ -110,10 +297,267 @@ def test_no_csv_if_empty(self):
"Cannot test parmest: required dependencies are missing",
)
@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
-class TestScenarioSemibatch(unittest.TestCase):
+class TestScenarioSemibatchDeprecated(unittest.TestCase):
def setUp(self):
- import pyomo.contrib.parmest.examples.semibatch.semibatch as sb
+
import json
+ from pyomo.environ import (
+ ConcreteModel,
+ Set,
+ Param,
+ Var,
+ Constraint,
+ ConstraintList,
+ Expression,
+ Objective,
+ TransformationFactory,
+ SolverFactory,
+ exp,
+ minimize,
+ )
+ from pyomo.dae import ContinuousSet, DerivativeVar
+
+ def generate_model(data):
+ # if data is a file name, then load file first
+ if isinstance(data, str):
+ file_name = data
+ try:
+ with open(file_name, "r") as infile:
+ data = json.load(infile)
+ except:
+ raise RuntimeError(f"Could not read {file_name} as json")
+
+ # unpack and fix the data
+ cameastemp = data["Ca_meas"]
+ cbmeastemp = data["Cb_meas"]
+ ccmeastemp = data["Cc_meas"]
+ trmeastemp = data["Tr_meas"]
+
+ cameas = {}
+ cbmeas = {}
+ ccmeas = {}
+ trmeas = {}
+ for i in cameastemp.keys():
+ cameas[float(i)] = cameastemp[i]
+ cbmeas[float(i)] = cbmeastemp[i]
+ ccmeas[float(i)] = ccmeastemp[i]
+ trmeas[float(i)] = trmeastemp[i]
+
+ m = ConcreteModel()
+
+ #
+ # Measurement Data
+ #
+ m.measT = Set(initialize=sorted(cameas.keys()))
+ m.Ca_meas = Param(m.measT, initialize=cameas)
+ m.Cb_meas = Param(m.measT, initialize=cbmeas)
+ m.Cc_meas = Param(m.measT, initialize=ccmeas)
+ m.Tr_meas = Param(m.measT, initialize=trmeas)
+
+ #
+ # Parameters for semi-batch reactor model
+ #
+ m.R = Param(initialize=8.314) # kJ/kmol/K
+ m.Mwa = Param(initialize=50.0) # kg/kmol
+ m.rhor = Param(initialize=1000.0) # kg/m^3
+ m.cpr = Param(initialize=3.9) # kJ/kg/K
+ m.Tf = Param(initialize=300) # K
+ m.deltaH1 = Param(initialize=-40000.0) # kJ/kmol
+ m.deltaH2 = Param(initialize=-50000.0) # kJ/kmol
+ m.alphaj = Param(initialize=0.8) # kJ/s/m^2/K
+ m.alphac = Param(initialize=0.7) # kJ/s/m^2/K
+ m.Aj = Param(initialize=5.0) # m^2
+ m.Ac = Param(initialize=3.0) # m^2
+ m.Vj = Param(initialize=0.9) # m^3
+ m.Vc = Param(initialize=0.07) # m^3
+ m.rhow = Param(initialize=700.0) # kg/m^3
+ m.cpw = Param(initialize=3.1) # kJ/kg/K
+ m.Ca0 = Param(initialize=data["Ca0"]) # kmol/m^3)
+ m.Cb0 = Param(initialize=data["Cb0"]) # kmol/m^3)
+ m.Cc0 = Param(initialize=data["Cc0"]) # kmol/m^3)
+ m.Tr0 = Param(initialize=300.0) # K
+ m.Vr0 = Param(initialize=1.0) # m^3
+
+ m.time = ContinuousSet(
+ bounds=(0, 21600), initialize=m.measT
+ ) # Time in seconds
+
+ #
+ # Control Inputs
+ #
+ def _initTc(m, t):
+ if t < 10800:
+ return data["Tc1"]
+ else:
+ return data["Tc2"]
+
+ m.Tc = Param(
+ m.time, initialize=_initTc, default=_initTc
+ ) # bounds= (288,432) Cooling coil temp, control input
+
+ def _initFa(m, t):
+ if t < 10800:
+ return data["Fa1"]
+ else:
+ return data["Fa2"]
+
+ m.Fa = Param(
+ m.time, initialize=_initFa, default=_initFa
+ ) # bounds=(0,0.05) Inlet flow rate, control input
+
+ #
+ # Parameters being estimated
+ #
+ m.k1 = Var(initialize=14, bounds=(2, 100)) # 1/s Actual: 15.01
+ m.k2 = Var(initialize=90, bounds=(2, 150)) # 1/s Actual: 85.01
+ m.E1 = Var(
+ initialize=27000.0, bounds=(25000, 40000)
+ ) # kJ/kmol Actual: 30000
+ m.E2 = Var(
+ initialize=45000.0, bounds=(35000, 50000)
+ ) # kJ/kmol Actual: 40000
+ # m.E1.fix(30000)
+ # m.E2.fix(40000)
+
+ #
+ # Time dependent variables
+ #
+ m.Ca = Var(m.time, initialize=m.Ca0, bounds=(0, 25))
+ m.Cb = Var(m.time, initialize=m.Cb0, bounds=(0, 25))
+ m.Cc = Var(m.time, initialize=m.Cc0, bounds=(0, 25))
+ m.Vr = Var(m.time, initialize=m.Vr0)
+ m.Tr = Var(m.time, initialize=m.Tr0)
+ m.Tj = Var(
+ m.time, initialize=310.0, bounds=(288, None)
+ ) # Cooling jacket temp, follows coil temp until failure
+
+ #
+ # Derivatives in the model
+ #
+ m.dCa = DerivativeVar(m.Ca)
+ m.dCb = DerivativeVar(m.Cb)
+ m.dCc = DerivativeVar(m.Cc)
+ m.dVr = DerivativeVar(m.Vr)
+ m.dTr = DerivativeVar(m.Tr)
+
+ #
+ # Differential Equations in the model
+ #
+
+ def _dCacon(m, t):
+ if t == 0:
+ return Constraint.Skip
+ return (
+ m.dCa[t]
+ == m.Fa[t] / m.Vr[t] - m.k1 * exp(-m.E1 / (m.R * m.Tr[t])) * m.Ca[t]
+ )
+
+ m.dCacon = Constraint(m.time, rule=_dCacon)
+
+ def _dCbcon(m, t):
+ if t == 0:
+ return Constraint.Skip
+ return (
+ m.dCb[t]
+ == m.k1 * exp(-m.E1 / (m.R * m.Tr[t])) * m.Ca[t]
+ - m.k2 * exp(-m.E2 / (m.R * m.Tr[t])) * m.Cb[t]
+ )
+
+ m.dCbcon = Constraint(m.time, rule=_dCbcon)
+
+ def _dCccon(m, t):
+ if t == 0:
+ return Constraint.Skip
+ return m.dCc[t] == m.k2 * exp(-m.E2 / (m.R * m.Tr[t])) * m.Cb[t]
+
+ m.dCccon = Constraint(m.time, rule=_dCccon)
+
+ def _dVrcon(m, t):
+ if t == 0:
+ return Constraint.Skip
+ return m.dVr[t] == m.Fa[t] * m.Mwa / m.rhor
+
+ m.dVrcon = Constraint(m.time, rule=_dVrcon)
+
+ def _dTrcon(m, t):
+ if t == 0:
+ return Constraint.Skip
+ return m.rhor * m.cpr * m.dTr[t] == m.Fa[t] * m.Mwa * m.cpr / m.Vr[
+ t
+ ] * (m.Tf - m.Tr[t]) - m.k1 * exp(-m.E1 / (m.R * m.Tr[t])) * m.Ca[
+ t
+ ] * m.deltaH1 - m.k2 * exp(
+ -m.E2 / (m.R * m.Tr[t])
+ ) * m.Cb[
+ t
+ ] * m.deltaH2 + m.alphaj * m.Aj / m.Vr0 * (
+ m.Tj[t] - m.Tr[t]
+ ) + m.alphac * m.Ac / m.Vr0 * (
+ m.Tc[t] - m.Tr[t]
+ )
+
+ m.dTrcon = Constraint(m.time, rule=_dTrcon)
+
+ def _singlecooling(m, t):
+ return m.Tc[t] == m.Tj[t]
+
+ m.singlecooling = Constraint(m.time, rule=_singlecooling)
+
+ # Initial Conditions
+ def _initcon(m):
+ yield m.Ca[m.time.first()] == m.Ca0
+ yield m.Cb[m.time.first()] == m.Cb0
+ yield m.Cc[m.time.first()] == m.Cc0
+ yield m.Vr[m.time.first()] == m.Vr0
+ yield m.Tr[m.time.first()] == m.Tr0
+
+ m.initcon = ConstraintList(rule=_initcon)
+
+ #
+ # Stage-specific cost computations
+ #
+ def ComputeFirstStageCost_rule(model):
+ return 0
+
+ m.FirstStageCost = Expression(rule=ComputeFirstStageCost_rule)
+
+ def AllMeasurements(m):
+ return sum(
+ (m.Ca[t] - m.Ca_meas[t]) ** 2
+ + (m.Cb[t] - m.Cb_meas[t]) ** 2
+ + (m.Cc[t] - m.Cc_meas[t]) ** 2
+ + 0.01 * (m.Tr[t] - m.Tr_meas[t]) ** 2
+ for t in m.measT
+ )
+
+ def MissingMeasurements(m):
+ if data["experiment"] == 1:
+ return sum(
+ (m.Ca[t] - m.Ca_meas[t]) ** 2
+ + (m.Cb[t] - m.Cb_meas[t]) ** 2
+ + (m.Cc[t] - m.Cc_meas[t]) ** 2
+ + (m.Tr[t] - m.Tr_meas[t]) ** 2
+ for t in m.measT
+ )
+ elif data["experiment"] == 2:
+ return sum((m.Tr[t] - m.Tr_meas[t]) ** 2 for t in m.measT)
+ else:
+ return sum(
+ (m.Cb[t] - m.Cb_meas[t]) ** 2 + (m.Tr[t] - m.Tr_meas[t]) ** 2
+ for t in m.measT
+ )
+
+ m.SecondStageCost = Expression(rule=MissingMeasurements)
+
+ def total_cost_rule(model):
+ return model.FirstStageCost + model.SecondStageCost
+
+ m.Total_Cost_Objective = Objective(rule=total_cost_rule, sense=minimize)
+
+ # Discretize model
+ disc = TransformationFactory("dae.collocation")
+ disc.apply_to(m, nfe=20, ncp=4)
+ return m
# Vars to estimate in parmest
theta_names = ["k1", "k2", "E1", "E2"]
@@ -131,7 +575,7 @@ def setUp(self):
# Note, the model already includes a 'SecondStageCost' expression
# for the sum of squared error that will be used in parameter estimation
- self.pest = parmest.Estimator(sb.generate_model, data, theta_names)
+ self.pest = parmest.Estimator(generate_model, data, theta_names)
def test_semibatch_bootstrap(self):
scenmaker = sc.ScenarioCreator(self.pest, "ipopt")
diff --git a/pyomo/contrib/parmest/tests/test_utils.py b/pyomo/contrib/parmest/tests/test_utils.py
index e75cc9d3bcd..d5e66ab58d5 100644
--- a/pyomo/contrib/parmest/tests/test_utils.py
+++ b/pyomo/contrib/parmest/tests/test_utils.py
@@ -25,18 +25,12 @@
)
@unittest.skipIf(not ipopt_available, "The 'ipopt' solver is not available")
class TestUtils(unittest.TestCase):
- @classmethod
- def setUpClass(self):
- pass
- @classmethod
- def tearDownClass(self):
- pass
-
- @unittest.pytest.mark.expensive
def test_convert_param_to_var(self):
+ # TODO: Check that this works for different structured models (indexed, blocks, etc)
+
from pyomo.contrib.parmest.examples.reactor_design.reactor_design import (
- reactor_design_model,
+ ReactorDesignExperiment,
)
data = pd.DataFrame(
@@ -48,20 +42,23 @@ def test_convert_param_to_var(self):
columns=["sv", "caf", "ca", "cb", "cc", "cd"],
)
- theta_names = ["k1", "k2", "k3"]
-
- instance = reactor_design_model(data.loc[0])
- solver = pyo.SolverFactory("ipopt")
- solver.solve(instance)
+ # make model
+ exp = ReactorDesignExperiment(data, 0)
+ instance = exp.get_labeled_model()
- instance_vars = parmest.utils.convert_params_to_vars(
+ theta_names = ['k1', 'k2', 'k3']
+ m_vars = parmest.utils.convert_params_to_vars(
instance, theta_names, fix_vars=True
)
- solver.solve(instance_vars)
- assert instance.k1() == instance_vars.k1()
- assert instance.k2() == instance_vars.k2()
- assert instance.k3() == instance_vars.k3()
+ for v in theta_names:
+ self.assertTrue(hasattr(m_vars, v))
+ c = m_vars.find_component(v)
+ self.assertIsInstance(c, pyo.Var)
+ self.assertTrue(c.fixed)
+ c_old = instance.find_component(v)
+ self.assertEqual(pyo.value(c), pyo.value(c_old))
+ self.assertTrue(c in m_vars.unknown_parameters)
if __name__ == "__main__":
diff --git a/pyomo/contrib/parmest/utils/model_utils.py b/pyomo/contrib/parmest/utils/model_utils.py
index 77491f74b02..7778ebcc9f1 100644
--- a/pyomo/contrib/parmest/utils/model_utils.py
+++ b/pyomo/contrib/parmest/utils/model_utils.py
@@ -15,6 +15,7 @@
from pyomo.core.expr import replace_expressions, identify_mutable_parameters
from pyomo.core.base.var import IndexedVar
from pyomo.core.base.param import IndexedParam
+from pyomo.common.collections import ComponentMap
from pyomo.environ import ComponentUID
@@ -49,6 +50,7 @@ def convert_params_to_vars(model, param_names=None, fix_vars=False):
# Convert Params to Vars, unfix Vars, and create a substitution map
substitution_map = {}
+ comp_map = ComponentMap()
for i, param_name in enumerate(param_names):
# Leverage the parser in ComponentUID to locate the component.
theta_cuid = ComponentUID(param_name)
@@ -65,6 +67,7 @@ def convert_params_to_vars(model, param_names=None, fix_vars=False):
theta_var_cuid = ComponentUID(theta_object.name)
theta_var_object = theta_var_cuid.find_component_on(model)
substitution_map[id(theta_object)] = theta_var_object
+ comp_map[theta_object] = theta_var_object
# Indexed Param
elif isinstance(theta_object, IndexedParam):
@@ -90,6 +93,7 @@ def convert_params_to_vars(model, param_names=None, fix_vars=False):
# Update substitution map (map each indexed param to indexed var)
theta_var_cuid = ComponentUID(theta_object.name)
theta_var_object = theta_var_cuid.find_component_on(model)
+ comp_map[theta_object] = theta_var_object
var_theta_objects = []
for theta_obj in theta_var_object:
theta_cuid = ComponentUID(
@@ -101,6 +105,7 @@ def convert_params_to_vars(model, param_names=None, fix_vars=False):
param_theta_objects, var_theta_objects
):
substitution_map[id(param_theta_obj)] = var_theta_obj
+ comp_map[param_theta_obj] = var_theta_obj
# Var or Indexed Var
elif isinstance(theta_object, IndexedVar) or theta_object.is_variable_type():
@@ -182,6 +187,15 @@ def convert_params_to_vars(model, param_names=None, fix_vars=False):
model.del_component(obj)
model.add_component(obj.name, pyo.Objective(rule=expr, sense=obj.sense))
+ # Convert Params to Vars in Suffixes
+ for s in model.component_objects(pyo.Suffix):
+ current_keys = list(s.keys())
+ for c in current_keys:
+ if c in comp_map:
+ s[comp_map[c]] = s.pop(c)
+
+ assert len(current_keys) == len(s.keys())
+
# print('--- Updated Model ---')
# model.pprint()
# solver = pyo.SolverFactory('ipopt')
diff --git a/pyomo/contrib/parmest/utils/scenario_tree.py b/pyomo/contrib/parmest/utils/scenario_tree.py
index e71f51877b5..f245e053cad 100644
--- a/pyomo/contrib/parmest/utils/scenario_tree.py
+++ b/pyomo/contrib/parmest/utils/scenario_tree.py
@@ -25,7 +25,7 @@
def build_vardatalist(self, model, varlist=None):
"""
- Convert a list of pyomo variables to a list of ScalarVar and _GeneralVarData. If varlist is none, builds a
+ Convert a list of pyomo variables to a list of ScalarVar and VarData. If varlist is none, builds a
list of all variables in the model. The new list is stored in the vars_to_tighten attribute. By CD Laird
Parameters
diff --git a/pyomo/contrib/piecewise/__init__.py b/pyomo/contrib/piecewise/__init__.py
index 37873c83b3b..b23200b3f7d 100644
--- a/pyomo/contrib/piecewise/__init__.py
+++ b/pyomo/contrib/piecewise/__init__.py
@@ -33,3 +33,9 @@
from pyomo.contrib.piecewise.transform.convex_combination import (
ConvexCombinationTransformation,
)
+from pyomo.contrib.piecewise.transform.nested_inner_repn import (
+ NestedInnerRepresentationGDPTransformation,
+)
+from pyomo.contrib.piecewise.transform.disaggregated_logarithmic import (
+ DisaggregatedLogarithmicMIPTransformation,
+)
diff --git a/pyomo/contrib/piecewise/piecewise_linear_function.py b/pyomo/contrib/piecewise/piecewise_linear_function.py
index 66ca02ad125..e92edacc756 100644
--- a/pyomo/contrib/piecewise/piecewise_linear_function.py
+++ b/pyomo/contrib/piecewise/piecewise_linear_function.py
@@ -20,7 +20,7 @@
PiecewiseLinearExpression,
)
from pyomo.core import Any, NonNegativeIntegers, value, Var
-from pyomo.core.base.block import _BlockData, Block
+from pyomo.core.base.block import BlockData, Block
from pyomo.core.base.component import ModelComponentFactory
from pyomo.core.base.expression import Expression
from pyomo.core.base.global_set import UnindexedComponent_index
@@ -36,11 +36,11 @@
logger = logging.getLogger(__name__)
-class PiecewiseLinearFunctionData(_BlockData):
+class PiecewiseLinearFunctionData(BlockData):
_Block_reserved_words = Any
def __init__(self, component=None):
- _BlockData.__init__(self, component)
+ BlockData.__init__(self, component)
with self._declare_reserved_components():
self._expressions = Expression(NonNegativeIntegers)
diff --git a/pyomo/contrib/piecewise/tests/common_inner_repn_tests.py b/pyomo/contrib/piecewise/tests/common_inner_repn_tests.py
new file mode 100644
index 00000000000..e0b8e878be3
--- /dev/null
+++ b/pyomo/contrib/piecewise/tests/common_inner_repn_tests.py
@@ -0,0 +1,80 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.core import Var
+from pyomo.core.base import Constraint
+from pyomo.core.expr.compare import assertExpressionsEqual
+
+# This file contains check methods shared between GDP inner representation-based
+# transformations. Currently, those are the inner_representation_gdp and
+# nested_inner_repn_gdp transformations, since each have disjuncts with the
+# same structure.
+
+
+# Check one disjunct from the log model for proper contents
+def check_log_disjunct(test, d, pts, f, substitute_var, x):
+ test.assertEqual(len(d.component_map(Constraint)), 3)
+ # lambdas and indicator_var
+ test.assertEqual(len(d.component_map(Var)), 2)
+ test.assertIsInstance(d.lambdas, Var)
+ test.assertEqual(len(d.lambdas), 2)
+ for lamb in d.lambdas.values():
+ test.assertEqual(lamb.lb, 0)
+ test.assertEqual(lamb.ub, 1)
+ test.assertIsInstance(d.convex_combo, Constraint)
+ assertExpressionsEqual(test, d.convex_combo.expr, d.lambdas[0] + d.lambdas[1] == 1)
+ test.assertIsInstance(d.set_substitute, Constraint)
+ assertExpressionsEqual(
+ test, d.set_substitute.expr, substitute_var == f(x), places=7
+ )
+ test.assertIsInstance(d.linear_combo, Constraint)
+ test.assertEqual(len(d.linear_combo), 1)
+ assertExpressionsEqual(
+ test, d.linear_combo[0].expr, x == pts[0] * d.lambdas[0] + pts[1] * d.lambdas[1]
+ )
+
+
+# Check one disjunct from the paraboloid model for proper contents.
+def check_paraboloid_disjunct(test, d, pts, f, substitute_var, x1, x2):
+ test.assertEqual(len(d.component_map(Constraint)), 3)
+ # lambdas and indicator_var
+ test.assertEqual(len(d.component_map(Var)), 2)
+ test.assertIsInstance(d.lambdas, Var)
+ test.assertEqual(len(d.lambdas), 3)
+ for lamb in d.lambdas.values():
+ test.assertEqual(lamb.lb, 0)
+ test.assertEqual(lamb.ub, 1)
+ test.assertIsInstance(d.convex_combo, Constraint)
+ assertExpressionsEqual(
+ test, d.convex_combo.expr, d.lambdas[0] + d.lambdas[1] + d.lambdas[2] == 1
+ )
+ test.assertIsInstance(d.set_substitute, Constraint)
+ assertExpressionsEqual(
+ test, d.set_substitute.expr, substitute_var == f(x1, x2), places=7
+ )
+ test.assertIsInstance(d.linear_combo, Constraint)
+ test.assertEqual(len(d.linear_combo), 2)
+ assertExpressionsEqual(
+ test,
+ d.linear_combo[0].expr,
+ x1
+ == pts[0][0] * d.lambdas[0]
+ + pts[1][0] * d.lambdas[1]
+ + pts[2][0] * d.lambdas[2],
+ )
+ assertExpressionsEqual(
+ test,
+ d.linear_combo[1].expr,
+ x2
+ == pts[0][1] * d.lambdas[0]
+ + pts[1][1] * d.lambdas[1]
+ + pts[2][1] * d.lambdas[2],
+ )
diff --git a/pyomo/contrib/piecewise/tests/test_disaggregated_logarithmic.py b/pyomo/contrib/piecewise/tests/test_disaggregated_logarithmic.py
new file mode 100644
index 00000000000..f848c610e9d
--- /dev/null
+++ b/pyomo/contrib/piecewise/tests/test_disaggregated_logarithmic.py
@@ -0,0 +1,275 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.unittest as unittest
+from pyomo.contrib.piecewise.tests import models
+import pyomo.contrib.piecewise.tests.common_tests as ct
+from pyomo.core.base import TransformationFactory
+from pyomo.environ import SolverFactory, Var, Constraint
+from pyomo.core.expr.compare import assertExpressionsEqual
+
+
+class TestTransformPiecewiseModelToNestedInnerRepnMIP(unittest.TestCase):
+ def check_pw_log(self, m):
+ z = m.pw_log.get_transformation_var(m.log_expr)
+ self.assertIsInstance(z, Var)
+ # Now we can use those Vars to check on what the transformation created
+ log_block = z.parent_block()
+
+ # We should have three Vars, two of which are indexed, and five
+ # Constraints, three of which are indexed
+
+ self.assertEqual(len(log_block.component_map(Var)), 3)
+ self.assertEqual(len(log_block.component_map(Constraint)), 5)
+
+ # Constants
+ simplex_count = 3
+ log_simplex_count = 2
+ simplex_point_count = 2
+
+ # Substitute var
+ self.assertIsInstance(log_block.substitute_var, Var)
+ self.assertIs(m.obj.expr.expr, log_block.substitute_var)
+ # Binaries
+ self.assertIsInstance(log_block.binaries, Var)
+ self.assertEqual(len(log_block.binaries), log_simplex_count)
+ # Lambdas
+ self.assertIsInstance(log_block.lambdas, Var)
+ self.assertEqual(len(log_block.lambdas), simplex_count * simplex_point_count)
+ for l in log_block.lambdas.values():
+ self.assertEqual(l.lb, 0)
+ self.assertEqual(l.ub, 1)
+
+ # Convex combo constraint
+ self.assertIsInstance(log_block.convex_combo, Constraint)
+ assertExpressionsEqual(
+ self,
+ log_block.convex_combo.expr,
+ log_block.lambdas[0, 0]
+ + log_block.lambdas[0, 1]
+ + log_block.lambdas[1, 0]
+ + log_block.lambdas[1, 1]
+ + log_block.lambdas[2, 0]
+ + log_block.lambdas[2, 1]
+ == 1,
+ )
+
+ # Set substitute constraint
+ self.assertIsInstance(log_block.set_substitute, Constraint)
+ assertExpressionsEqual(
+ self,
+ log_block.set_substitute.expr,
+ log_block.substitute_var
+ == log_block.lambdas[0, 0] * m.f1(1)
+ + log_block.lambdas[1, 0] * m.f2(3)
+ + log_block.lambdas[2, 0] * m.f3(6)
+ + log_block.lambdas[0, 1] * m.f1(3)
+ + log_block.lambdas[1, 1] * m.f2(6)
+ + log_block.lambdas[2, 1] * m.f3(10),
+ places=7,
+ )
+
+ # x constraint
+ self.assertIsInstance(log_block.x_constraint, Constraint)
+ # one-dimensional case, so there is only one x variable here
+ self.assertEqual(len(log_block.x_constraint), 1)
+ assertExpressionsEqual(
+ self,
+ log_block.x_constraint[0].expr,
+ m.x
+ == 1 * log_block.lambdas[0, 0]
+ + 3 * log_block.lambdas[0, 1]
+ + 3 * log_block.lambdas[1, 0]
+ + 6 * log_block.lambdas[1, 1]
+ + 6 * log_block.lambdas[2, 0]
+ + 10 * log_block.lambdas[2, 1],
+ )
+
+ # simplex choice 1 constraint enables lambdas when binaries are on
+ self.assertEqual(len(log_block.simplex_choice_1), log_simplex_count)
+ assertExpressionsEqual(
+ self,
+ log_block.simplex_choice_1[0].expr,
+ log_block.lambdas[2, 0] + log_block.lambdas[2, 1] <= log_block.binaries[0],
+ )
+ assertExpressionsEqual(
+ self,
+ log_block.simplex_choice_1[1].expr,
+ log_block.lambdas[1, 0] + log_block.lambdas[1, 1] <= log_block.binaries[1],
+ )
+ # simplex choice 2 constraint enables lambdas when binaries are off
+ self.assertEqual(len(log_block.simplex_choice_2), log_simplex_count)
+ assertExpressionsEqual(
+ self,
+ log_block.simplex_choice_2[0].expr,
+ log_block.lambdas[0, 0]
+ + log_block.lambdas[0, 1]
+ + log_block.lambdas[1, 0]
+ + log_block.lambdas[1, 1]
+ <= 1 - log_block.binaries[0],
+ )
+ assertExpressionsEqual(
+ self,
+ log_block.simplex_choice_2[1].expr,
+ log_block.lambdas[0, 0]
+ + log_block.lambdas[0, 1]
+ + log_block.lambdas[2, 0]
+ + log_block.lambdas[2, 1]
+ <= 1 - log_block.binaries[1],
+ )
+
+ def check_pw_paraboloid(self, m):
+ # This is a little larger, but at least test that the right numbers of
+ # everything are created
+ z = m.pw_paraboloid.get_transformation_var(m.paraboloid_expr)
+ self.assertIsInstance(z, Var)
+ paraboloid_block = z.parent_block()
+
+ self.assertEqual(len(paraboloid_block.component_map(Var)), 3)
+ self.assertEqual(len(paraboloid_block.component_map(Constraint)), 5)
+
+ # Constants
+ simplex_count = 4
+ log_simplex_count = 2
+ simplex_point_count = 3
+
+ # Substitute var
+ self.assertIsInstance(paraboloid_block.substitute_var, Var)
+ # Binaries
+ self.assertIsInstance(paraboloid_block.binaries, Var)
+ self.assertEqual(len(paraboloid_block.binaries), log_simplex_count)
+ # Lambdas
+ self.assertIsInstance(paraboloid_block.lambdas, Var)
+ self.assertEqual(
+ len(paraboloid_block.lambdas), simplex_count * simplex_point_count
+ )
+ for l in paraboloid_block.lambdas.values():
+ self.assertEqual(l.lb, 0)
+ self.assertEqual(l.ub, 1)
+
+ # Convex combo constraint
+ self.assertIsInstance(paraboloid_block.convex_combo, Constraint)
+ assertExpressionsEqual(
+ self,
+ paraboloid_block.convex_combo.expr,
+ paraboloid_block.lambdas[0, 0]
+ + paraboloid_block.lambdas[0, 1]
+ + paraboloid_block.lambdas[0, 2]
+ + paraboloid_block.lambdas[1, 0]
+ + paraboloid_block.lambdas[1, 1]
+ + paraboloid_block.lambdas[1, 2]
+ + paraboloid_block.lambdas[2, 0]
+ + paraboloid_block.lambdas[2, 1]
+ + paraboloid_block.lambdas[2, 2]
+ + paraboloid_block.lambdas[3, 0]
+ + paraboloid_block.lambdas[3, 1]
+ + paraboloid_block.lambdas[3, 2]
+ == 1,
+ )
+
+ # Set substitute constraint
+ self.assertIsInstance(paraboloid_block.set_substitute, Constraint)
+ assertExpressionsEqual(
+ self,
+ paraboloid_block.set_substitute.expr,
+ paraboloid_block.substitute_var
+ == paraboloid_block.lambdas[0, 0] * m.g1(0, 1)
+ + paraboloid_block.lambdas[1, 0] * m.g1(0, 1)
+ + paraboloid_block.lambdas[2, 0] * m.g2(3, 4)
+ + paraboloid_block.lambdas[3, 0] * m.g2(0, 7)
+ + paraboloid_block.lambdas[0, 1] * m.g1(0, 4)
+ + paraboloid_block.lambdas[1, 1] * m.g1(3, 4)
+ + paraboloid_block.lambdas[2, 1] * m.g2(3, 7)
+ + paraboloid_block.lambdas[3, 1] * m.g2(0, 4)
+ + paraboloid_block.lambdas[0, 2] * m.g1(3, 4)
+ + paraboloid_block.lambdas[1, 2] * m.g1(3, 1)
+ + paraboloid_block.lambdas[2, 2] * m.g2(0, 7)
+ + paraboloid_block.lambdas[3, 2] * m.g2(3, 4),
+ places=7,
+ )
+
+ # x constraint
+ self.assertIsInstance(paraboloid_block.x_constraint, Constraint)
+ # Here we have two x variables
+ self.assertEqual(len(paraboloid_block.x_constraint), 2)
+ assertExpressionsEqual(
+ self,
+ paraboloid_block.x_constraint[0].expr,
+ m.x1
+ == 0 * paraboloid_block.lambdas[0, 0]
+ + 0 * paraboloid_block.lambdas[0, 1]
+ + 3 * paraboloid_block.lambdas[0, 2]
+ + 0 * paraboloid_block.lambdas[1, 0]
+ + 3 * paraboloid_block.lambdas[1, 1]
+ + 3 * paraboloid_block.lambdas[1, 2]
+ + 3 * paraboloid_block.lambdas[2, 0]
+ + 3 * paraboloid_block.lambdas[2, 1]
+ + 0 * paraboloid_block.lambdas[2, 2]
+ + 0 * paraboloid_block.lambdas[3, 0]
+ + 0 * paraboloid_block.lambdas[3, 1]
+ + 3 * paraboloid_block.lambdas[3, 2],
+ )
+ assertExpressionsEqual(
+ self,
+ paraboloid_block.x_constraint[1].expr,
+ m.x2
+ == 1 * paraboloid_block.lambdas[0, 0]
+ + 4 * paraboloid_block.lambdas[0, 1]
+ + 4 * paraboloid_block.lambdas[0, 2]
+ + 1 * paraboloid_block.lambdas[1, 0]
+ + 4 * paraboloid_block.lambdas[1, 1]
+ + 1 * paraboloid_block.lambdas[1, 2]
+ + 4 * paraboloid_block.lambdas[2, 0]
+ + 7 * paraboloid_block.lambdas[2, 1]
+ + 7 * paraboloid_block.lambdas[2, 2]
+ + 7 * paraboloid_block.lambdas[3, 0]
+ + 4 * paraboloid_block.lambdas[3, 1]
+ + 4 * paraboloid_block.lambdas[3, 2],
+ )
+
+ # The choices will get long, so let's just assert we have enough
+ self.assertEqual(len(paraboloid_block.simplex_choice_1), log_simplex_count)
+ self.assertEqual(len(paraboloid_block.simplex_choice_2), log_simplex_count)
+
+ # Test methods using the common_tests.py code.
+ def test_transformation_do_not_descend(self):
+ ct.check_transformation_do_not_descend(
+ self, 'contrib.piecewise.disaggregated_logarithmic'
+ )
+
+ def test_transformation_PiecewiseLinearFunction_targets(self):
+ ct.check_transformation_PiecewiseLinearFunction_targets(
+ self, 'contrib.piecewise.disaggregated_logarithmic'
+ )
+
+ def test_descend_into_expressions(self):
+ ct.check_descend_into_expressions(
+ self, 'contrib.piecewise.disaggregated_logarithmic'
+ )
+
+ def test_descend_into_expressions_constraint_target(self):
+ ct.check_descend_into_expressions_constraint_target(
+ self, 'contrib.piecewise.disaggregated_logarithmic'
+ )
+
+ def test_descend_into_expressions_objective_target(self):
+ ct.check_descend_into_expressions_objective_target(
+ self, 'contrib.piecewise.disaggregated_logarithmic'
+ )
+
+ # Check solution of the log(x) model
+ @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
+ @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')
+ def test_solve_log_model(self):
+ m = models.make_log_x_model()
+ TransformationFactory("contrib.piecewise.disaggregated_logarithmic").apply_to(m)
+ SolverFactory("gurobi").solve(m)
+ ct.check_log_x_model_soln(self, m)
diff --git a/pyomo/contrib/piecewise/tests/test_inner_repn_gdp.py b/pyomo/contrib/piecewise/tests/test_inner_repn_gdp.py
index 27fe43e54d5..e7505bb92d3 100644
--- a/pyomo/contrib/piecewise/tests/test_inner_repn_gdp.py
+++ b/pyomo/contrib/piecewise/tests/test_inner_repn_gdp.py
@@ -12,6 +12,7 @@
import pyomo.common.unittest as unittest
from pyomo.contrib.piecewise.tests import models
import pyomo.contrib.piecewise.tests.common_tests as ct
+import pyomo.contrib.piecewise.tests.common_inner_repn_tests as inner_repn_tests
from pyomo.core.base import TransformationFactory
from pyomo.core.expr.compare import (
assertExpressionsEqual,
@@ -22,67 +23,6 @@
class TestTransformPiecewiseModelToInnerRepnGDP(unittest.TestCase):
- def check_log_disjunct(self, d, pts, f, substitute_var, x):
- self.assertEqual(len(d.component_map(Constraint)), 3)
- # lambdas and indicator_var
- self.assertEqual(len(d.component_map(Var)), 2)
- self.assertIsInstance(d.lambdas, Var)
- self.assertEqual(len(d.lambdas), 2)
- for lamb in d.lambdas.values():
- self.assertEqual(lamb.lb, 0)
- self.assertEqual(lamb.ub, 1)
- self.assertIsInstance(d.convex_combo, Constraint)
- assertExpressionsEqual(
- self, d.convex_combo.expr, d.lambdas[0] + d.lambdas[1] == 1
- )
- self.assertIsInstance(d.set_substitute, Constraint)
- assertExpressionsEqual(
- self, d.set_substitute.expr, substitute_var == f(x), places=7
- )
- self.assertIsInstance(d.linear_combo, Constraint)
- self.assertEqual(len(d.linear_combo), 1)
- assertExpressionsEqual(
- self,
- d.linear_combo[0].expr,
- x == pts[0] * d.lambdas[0] + pts[1] * d.lambdas[1],
- )
-
- def check_paraboloid_disjunct(self, d, pts, f, substitute_var, x1, x2):
- self.assertEqual(len(d.component_map(Constraint)), 3)
- # lambdas and indicator_var
- self.assertEqual(len(d.component_map(Var)), 2)
- self.assertIsInstance(d.lambdas, Var)
- self.assertEqual(len(d.lambdas), 3)
- for lamb in d.lambdas.values():
- self.assertEqual(lamb.lb, 0)
- self.assertEqual(lamb.ub, 1)
- self.assertIsInstance(d.convex_combo, Constraint)
- assertExpressionsEqual(
- self, d.convex_combo.expr, d.lambdas[0] + d.lambdas[1] + d.lambdas[2] == 1
- )
- self.assertIsInstance(d.set_substitute, Constraint)
- assertExpressionsEqual(
- self, d.set_substitute.expr, substitute_var == f(x1, x2), places=7
- )
- self.assertIsInstance(d.linear_combo, Constraint)
- self.assertEqual(len(d.linear_combo), 2)
- assertExpressionsEqual(
- self,
- d.linear_combo[0].expr,
- x1
- == pts[0][0] * d.lambdas[0]
- + pts[1][0] * d.lambdas[1]
- + pts[2][0] * d.lambdas[2],
- )
- assertExpressionsEqual(
- self,
- d.linear_combo[1].expr,
- x2
- == pts[0][1] * d.lambdas[0]
- + pts[1][1] * d.lambdas[1]
- + pts[2][1] * d.lambdas[2],
- )
-
def check_pw_log(self, m):
##
# Check the transformation of the approximation of log(x)
@@ -101,7 +41,9 @@ def check_pw_log(self, m):
log_block.disjuncts[2]: ((6, 10), m.f3),
}
for d, (pts, f) in disjuncts_dict.items():
- self.check_log_disjunct(d, pts, f, log_block.substitute_var, m.x)
+ inner_repn_tests.check_log_disjunct(
+ self, d, pts, f, log_block.substitute_var, m.x
+ )
# Check the Disjunction
self.assertIsInstance(log_block.pick_a_piece, Disjunction)
@@ -129,8 +71,8 @@ def check_pw_paraboloid(self, m):
paraboloid_block.disjuncts[3]: ([(0, 7), (0, 4), (3, 4)], m.g2),
}
for d, (pts, f) in disjuncts_dict.items():
- self.check_paraboloid_disjunct(
- d, pts, f, paraboloid_block.substitute_var, m.x1, m.x2
+ inner_repn_tests.check_paraboloid_disjunct(
+ self, d, pts, f, paraboloid_block.substitute_var, m.x1, m.x2
)
# Check the Disjunction
diff --git a/pyomo/contrib/piecewise/tests/test_nested_inner_repn_gdp.py b/pyomo/contrib/piecewise/tests/test_nested_inner_repn_gdp.py
new file mode 100644
index 00000000000..2024f014f55
--- /dev/null
+++ b/pyomo/contrib/piecewise/tests/test_nested_inner_repn_gdp.py
@@ -0,0 +1,135 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.unittest as unittest
+from pyomo.contrib.piecewise.tests import models
+import pyomo.contrib.piecewise.tests.common_tests as ct
+import pyomo.contrib.piecewise.tests.common_inner_repn_tests as inner_repn_tests
+from pyomo.core.base import TransformationFactory
+from pyomo.environ import SolverFactory, Var, Constraint
+from pyomo.gdp import Disjunction, Disjunct
+from pyomo.core.expr.compare import assertExpressionsEqual
+
+
+# Test the nested inner repn gdp model using the common_tests code
+class TestTransformPiecewiseModelToNestedInnerRepnGDP(unittest.TestCase):
+ # Check the structure of the log PWLF Block
+ def check_pw_log(self, m):
+ z = m.pw_log.get_transformation_var(m.log_expr)
+ self.assertIsInstance(z, Var)
+ # Now we can use those Vars to check on what the transformation created
+ log_block = z.parent_block()
+
+ # Not using ct.check_trans_block_structure() because these are slightly
+ # different
+ # Two top-level disjuncts
+ self.assertEqual(len(log_block.component_map(Disjunct)), 2)
+ # One disjunction
+ self.assertEqual(len(log_block.component_map(Disjunction)), 1)
+ # The 'z' var (that we will substitute in for the function being
+ # approximated) is here:
+ self.assertEqual(len(log_block.component_map(Var)), 1)
+ self.assertIsInstance(log_block.substitute_var, Var)
+
+ # Check the tree structure, which should be heavier on the right
+ # Parent disjunction
+ self.assertIsInstance(log_block.disj, Disjunction)
+ self.assertEqual(len(log_block.disj.disjuncts), 2)
+
+ # Left disjunct with constraints
+ self.assertIsInstance(log_block.d_l, Disjunct)
+ inner_repn_tests.check_log_disjunct(
+ self, log_block.d_l, (1, 3), m.f1, log_block.substitute_var, m.x
+ )
+
+ # Right disjunct with disjunction
+ self.assertIsInstance(log_block.d_r, Disjunct)
+ self.assertIsInstance(log_block.d_r.inner_disjunction_r, Disjunction)
+ self.assertEqual(len(log_block.d_r.inner_disjunction_r.disjuncts), 2)
+
+ # Left and right child disjuncts with constraints
+ self.assertIsInstance(log_block.d_r.d_l, Disjunct)
+ inner_repn_tests.check_log_disjunct(
+ self, log_block.d_r.d_l, (3, 6), m.f2, log_block.substitute_var, m.x
+ )
+ self.assertIsInstance(log_block.d_r.d_r, Disjunct)
+ inner_repn_tests.check_log_disjunct(
+ self, log_block.d_r.d_r, (6, 10), m.f3, log_block.substitute_var, m.x
+ )
+
+ # Check that this also became the objective
+ self.assertIs(m.obj.expr.expr, log_block.substitute_var)
+
+ # Check the structure of the paraboloid PWLF block
+ def check_pw_paraboloid(self, m):
+ z = m.pw_paraboloid.get_transformation_var(m.paraboloid_expr)
+ self.assertIsInstance(z, Var)
+ paraboloid_block = z.parent_block()
+
+ # Two top-level disjuncts
+ self.assertEqual(len(paraboloid_block.component_map(Disjunct)), 2)
+ # One disjunction
+ self.assertEqual(len(paraboloid_block.component_map(Disjunction)), 1)
+ # The 'z' var (that we will substitute in for the function being
+ # approximated) is here:
+ self.assertEqual(len(paraboloid_block.component_map(Var)), 1)
+ self.assertIsInstance(paraboloid_block.substitute_var, Var)
+
+ # This one should have an even tree with four leaf disjuncts
+ disjuncts_dict = {
+ paraboloid_block.d_l.d_l: ([(0, 1), (0, 4), (3, 4)], m.g1),
+ paraboloid_block.d_l.d_r: ([(0, 1), (3, 4), (3, 1)], m.g1),
+ paraboloid_block.d_r.d_l: ([(3, 4), (3, 7), (0, 7)], m.g2),
+ paraboloid_block.d_r.d_r: ([(0, 7), (0, 4), (3, 4)], m.g2),
+ }
+ for d, (pts, f) in disjuncts_dict.items():
+ inner_repn_tests.check_paraboloid_disjunct(
+ self, d, pts, f, paraboloid_block.substitute_var, m.x1, m.x2
+ )
+
+ # And check the substitute Var is in the objective now.
+ self.assertIs(m.indexed_c[0].body.args[0].expr, paraboloid_block.substitute_var)
+
+ # Test methods using the common_tests.py code. Copied in from test_inner_repn_gdp.py.
+ def test_transformation_do_not_descend(self):
+ ct.check_transformation_do_not_descend(
+ self, 'contrib.piecewise.nested_inner_repn_gdp'
+ )
+
+ def test_transformation_PiecewiseLinearFunction_targets(self):
+ ct.check_transformation_PiecewiseLinearFunction_targets(
+ self, 'contrib.piecewise.nested_inner_repn_gdp'
+ )
+
+ def test_descend_into_expressions(self):
+ ct.check_descend_into_expressions(
+ self, 'contrib.piecewise.nested_inner_repn_gdp'
+ )
+
+ def test_descend_into_expressions_constraint_target(self):
+ ct.check_descend_into_expressions_constraint_target(
+ self, 'contrib.piecewise.nested_inner_repn_gdp'
+ )
+
+ def test_descend_into_expressions_objective_target(self):
+ ct.check_descend_into_expressions_objective_target(
+ self, 'contrib.piecewise.nested_inner_repn_gdp'
+ )
+
+ # Check the solution of the log(x) model
+ @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
+ @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')
+ def test_solve_log_model(self):
+ m = models.make_log_x_model()
+ TransformationFactory("contrib.piecewise.nested_inner_repn_gdp").apply_to(m)
+ TransformationFactory("gdp.bigm").apply_to(m)
+ SolverFactory("gurobi").solve(m)
+ ct.check_log_x_model_soln(self, m)
diff --git a/pyomo/contrib/piecewise/transform/disaggregated_logarithmic.py b/pyomo/contrib/piecewise/transform/disaggregated_logarithmic.py
new file mode 100644
index 00000000000..d582cdcfff5
--- /dev/null
+++ b/pyomo/contrib/piecewise/transform/disaggregated_logarithmic.py
@@ -0,0 +1,202 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.contrib.piecewise.transform.piecewise_linear_transformation_base import (
+ PiecewiseLinearTransformationBase,
+)
+from pyomo.core import Constraint, Binary, Var, RangeSet, Set
+from pyomo.core.base import TransformationFactory
+from pyomo.common.errors import DeveloperError
+from math import ceil, log2
+
+
+@TransformationFactory.register(
+ "contrib.piecewise.disaggregated_logarithmic",
+ doc="""
+ Represent a piecewise linear function "logarithmically" by using a MIP with
+ log_2(|P|) binary decision variables. This is a direct-to-MIP transformation;
+ GDP is not used.
+ """,
+)
+class DisaggregatedLogarithmicMIPTransformation(PiecewiseLinearTransformationBase):
+ """
+ Represent a piecewise linear function "logarithmically" by using a MIP with
+ log_2(|P|) binary decision variables, following the "disaggregated logarithmic"
+ method from [1]. This is a direct-to-MIP transformation; GDP is not used.
+ This method of logarithmically formulating the piecewise linear function
+ imposes no restrictions on the family of polytopes, but we assume we have
+ simplices in this code.
+
+ References
+ ----------
+ [1] J.P. Vielma, S. Ahmed, and G. Nemhauser, "Mixed-integer models
+ for nonseparable piecewise-linear optimization: unifying framework
+ and extensions," Operations Research, vol. 58, no. 2, pp. 305-315,
+ 2010.
+ """
+
+ CONFIG = PiecewiseLinearTransformationBase.CONFIG()
+ _transformation_name = "pw_linear_disaggregated_log"
+
+ # Implement to use PiecewiseLinearTransformationBase. This function returns the Var
+ # that replaces the transformed piecewise linear expr
+ def _transform_pw_linear_expr(self, pw_expr, pw_linear_func, transformation_block):
+ # Get a new Block for our transformation in transformation_block.transformed_functions,
+ # which is a Block(Any). This is where we will put our new components.
+ transBlock = transformation_block.transformed_functions[
+ len(transformation_block.transformed_functions)
+ ]
+
+ # Dimensionality of the PWLF
+ dimension = pw_expr.nargs()
+ transBlock.dimension_indices = RangeSet(0, dimension - 1)
+
+ # Substitute Var that will hold the value of the PWLE
+ substitute_var = transBlock.substitute_var = Var()
+ pw_linear_func.map_transformation_var(pw_expr, substitute_var)
+
+ # Bounds for the substitute_var that we will widen
+ substitute_var_lb = float("inf")
+ substitute_var_ub = -float("inf")
+
+ # Simplices are tuples of indices of points. Give them their own indices, too
+ simplices = pw_linear_func._simplices
+ num_simplices = len(simplices)
+ transBlock.simplex_indices = RangeSet(0, num_simplices - 1)
+ # Assumption: the simplices are really full-dimensional simplices and all have the
+ # same number of points, which is dimension + 1
+ transBlock.simplex_point_indices = RangeSet(0, dimension)
+
+ # Enumeration of simplices: map from simplex number to simplex object
+ idx_to_simplex = {k: v for k, v in zip(transBlock.simplex_indices, simplices)}
+
+ # List of tuples of simplex indices with their linear function
+ simplex_indices_and_lin_funcs = list(
+ zip(transBlock.simplex_indices, pw_linear_func._linear_functions)
+ )
+
+ # We don't seem to get a convenient opportunity later, so let's just widen
+ # the bounds here. All we need to do is go through the corners of each simplex.
+ for P, linear_func in simplex_indices_and_lin_funcs:
+ for v in transBlock.simplex_point_indices:
+ val = linear_func(*pw_linear_func._points[idx_to_simplex[P][v]])
+ if val < substitute_var_lb:
+ substitute_var_lb = val
+ if val > substitute_var_ub:
+ substitute_var_ub = val
+ transBlock.substitute_var.setlb(substitute_var_lb)
+ transBlock.substitute_var.setub(substitute_var_ub)
+
+ log_dimension = ceil(log2(num_simplices))
+ transBlock.log_simplex_indices = RangeSet(0, log_dimension - 1)
+ transBlock.binaries = Var(transBlock.log_simplex_indices, domain=Binary)
+
+ # Injective function B: \mathcal{P} -> {0,1}^ceil(log_2(|P|)) used to identify simplices
+ # (really just polytopes are required) with binary vectors. Any injective function
+ # is enough here.
+ B = {}
+ for i in transBlock.simplex_indices:
+ # map index(P) -> corresponding vector in {0, 1}^n
+ B[i] = self._get_binary_vector(i, log_dimension)
+
+ # Build up P_0 and P_plus ahead of time.
+
+ # {P \in \mathcal{P} | B(P)_l = 0}
+ def P_0_init(m, l):
+ return [p for p in transBlock.simplex_indices if B[p][l] == 0]
+
+ transBlock.P_0 = Set(transBlock.log_simplex_indices, initialize=P_0_init)
+
+ # {P \in \mathcal{P} | B(P)_l = 1}
+ def P_plus_init(m, l):
+ return [p for p in transBlock.simplex_indices if B[p][l] == 1]
+
+ transBlock.P_plus = Set(transBlock.log_simplex_indices, initialize=P_plus_init)
+
+ # The lambda variables \lambda_{P,v} are indexed by the simplex and the point in it
+ transBlock.lambdas = Var(
+ transBlock.simplex_indices, transBlock.simplex_point_indices, bounds=(0, 1)
+ )
+
+ # Numbered citations are from Vielma et al 2010, Mixed-Integer Models
+ # for Nonseparable Piecewise-Linear Optimization
+
+ # Sum of all lambdas is one (6b)
+ transBlock.convex_combo = Constraint(
+ expr=sum(
+ transBlock.lambdas[P, v]
+ for P in transBlock.simplex_indices
+ for v in transBlock.simplex_point_indices
+ )
+ == 1
+ )
+
+ # The branching rules, establishing using the binaries that only one simplex's lambda
+ # coefficients may be nonzero
+ # Enabling lambdas when binaries are on
+ @transBlock.Constraint(transBlock.log_simplex_indices) # (6c.1)
+ def simplex_choice_1(b, l):
+ return (
+ sum(
+ transBlock.lambdas[P, v]
+ for P in transBlock.P_plus[l]
+ for v in transBlock.simplex_point_indices
+ )
+ <= transBlock.binaries[l]
+ )
+
+ # Disabling lambdas when binaries are on
+ @transBlock.Constraint(transBlock.log_simplex_indices) # (6c.2)
+ def simplex_choice_2(b, l):
+ return (
+ sum(
+ transBlock.lambdas[P, v]
+ for P in transBlock.P_0[l]
+ for v in transBlock.simplex_point_indices
+ )
+ <= 1 - transBlock.binaries[l]
+ )
+
+ # for i, (simplex, pwlf) in enumerate(choices):
+ # x_i = sum(lambda_P,v v_i, P in polytopes, v in V(P))
+ @transBlock.Constraint(transBlock.dimension_indices) # (6a.1)
+ def x_constraint(b, i):
+ return pw_expr.args[i] == sum(
+ transBlock.lambdas[P, v]
+ * pw_linear_func._points[idx_to_simplex[P][v]][i]
+ for P in transBlock.simplex_indices
+ for v in transBlock.simplex_point_indices
+ )
+
+ # Make the substitute Var equal the PWLE (6a.2)
+ transBlock.set_substitute = Constraint(
+ expr=substitute_var
+ == sum(
+ transBlock.lambdas[P, v]
+ * linear_func(*pw_linear_func._points[idx_to_simplex[P][v]])
+ for v in transBlock.simplex_point_indices
+ for (P, linear_func) in simplex_indices_and_lin_funcs
+ )
+ )
+
+ return substitute_var
+
+ # Not a Gray code, just a regular binary representation
+ # TODO test the Gray codes too
+ # note: Must have num != 0 and ceil(log2(num)) > length to be valid
+ def _get_binary_vector(self, num, length):
+ ans = []
+ for i in range(length):
+ ans.append(num & 1)
+ num >>= 1
+ assert not num
+ ans.reverse()
+ return tuple(ans)
diff --git a/pyomo/contrib/piecewise/transform/inner_representation_gdp.py b/pyomo/contrib/piecewise/transform/inner_representation_gdp.py
index f0be2d98825..e4818c1cbb9 100644
--- a/pyomo/contrib/piecewise/transform/inner_representation_gdp.py
+++ b/pyomo/contrib/piecewise/transform/inner_representation_gdp.py
@@ -10,8 +10,8 @@
# ___________________________________________________________________________
from pyomo.contrib.fbbt.fbbt import compute_bounds_on_expr
-from pyomo.contrib.piecewise.transform.piecewise_to_gdp_transformation import (
- PiecewiseLinearToGDP,
+from pyomo.contrib.piecewise.transform.piecewise_linear_transformation_base import (
+ PiecewiseLinearTransformationBase,
)
from pyomo.core import Constraint, NonNegativeIntegers, Suffix, Var
from pyomo.core.base import TransformationFactory
@@ -25,7 +25,7 @@
"simplices that are the domains of the linear "
"functions.",
)
-class InnerRepresentationGDPTransformation(PiecewiseLinearToGDP):
+class InnerRepresentationGDPTransformation(PiecewiseLinearTransformationBase):
"""
Convert a model involving piecewise linear expressions into a GDP by
representing the piecewise linear functions as Disjunctions where the
@@ -49,7 +49,7 @@ class InnerRepresentationGDPTransformation(PiecewiseLinearToGDP):
this mode, targets must be Blocks, Constraints, and/or Objectives.
"""
- CONFIG = PiecewiseLinearToGDP.CONFIG()
+ CONFIG = PiecewiseLinearTransformationBase.CONFIG()
_transformation_name = 'pw_linear_inner_repn'
def _transform_pw_linear_expr(self, pw_expr, pw_linear_func, transformation_block):
diff --git a/pyomo/contrib/piecewise/transform/nested_inner_repn.py b/pyomo/contrib/piecewise/transform/nested_inner_repn.py
new file mode 100644
index 00000000000..dbbd8c73bad
--- /dev/null
+++ b/pyomo/contrib/piecewise/transform/nested_inner_repn.py
@@ -0,0 +1,209 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.contrib.fbbt.fbbt import compute_bounds_on_expr
+from pyomo.contrib.piecewise.transform.piecewise_linear_transformation_base import (
+ PiecewiseLinearTransformationBase,
+)
+from pyomo.core import Constraint, NonNegativeIntegers, Suffix, Var
+from pyomo.core.base import TransformationFactory
+from pyomo.gdp import Disjunction
+from pyomo.common.errors import DeveloperError
+
+
+@TransformationFactory.register(
+ "contrib.piecewise.nested_inner_repn_gdp",
+ doc="""
+ Represent a piecewise linear function by using a nested GDP to determine
+ which polytope a point is in, then representing it as a convex combination
+ of extreme points, with multipliers "local" to that particular polytope,
+ i.e., not shared with neighbors. This formulation has linearly many Boolean
+ variables, though up to variable substitution, it has logarithmically many.
+ """,
+)
+class NestedInnerRepresentationGDPTransformation(PiecewiseLinearTransformationBase):
+ """
+ Represent a piecewise linear function by using a nested GDP to determine
+ which polytope a point is in, then representing it as a convex combination
+ of extreme points, with multipliers "local" to that particular polytope,
+ i.e., not shared with neighbors. This method of formulating the piecewise
+ linear function imposes no restrictions on the family of polytopes. Note
+ that this is NOT a logarithmic formulation - it has linearly many Boolean
+ variables. However, it is inspired by the disaggregated logarithmic
+ formulation of [1]. Up to variable substitution, the amount of Boolean
+ variables is logarithmic, as in [1].
+
+ References
+ ----------
+ [1] J.P. Vielma, S. Ahmed, and G. Nemhauser, "Mixed-integer models
+ for nonseparable piecewise-linear optimization: unifying framework
+ and extensions," Operations Research, vol. 58, no. 2, pp. 305-315,
+ 2010.
+ """
+
+ CONFIG = PiecewiseLinearTransformationBase.CONFIG()
+ _transformation_name = "pw_linear_nested_inner_repn"
+
+ # Implement to use PiecewiseLinearTransformationBase. This function returns the Var
+ # that replaces the transformed piecewise linear expr
+ def _transform_pw_linear_expr(self, pw_expr, pw_linear_func, transformation_block):
+ # Get a new Block() in transformation_block.transformed_functions, which
+ # is a Block(Any)
+ transBlock = transformation_block.transformed_functions[
+ len(transformation_block.transformed_functions)
+ ]
+
+ substitute_var = transBlock.substitute_var = Var()
+ pw_linear_func.map_transformation_var(pw_expr, substitute_var)
+ transBlock.substitute_var_lb = float("inf")
+ transBlock.substitute_var_ub = -float("inf")
+
+ choices = list(zip(pw_linear_func._simplices, pw_linear_func._linear_functions))
+
+ # If there was only one choice, don't bother making a disjunction, just
+ # use the linear function directly (but still use the substitute_var for
+ # consistency).
+ if len(choices) == 1:
+ (_, linear_func) = choices[0] # simplex isn't important in this case
+ linear_func_expr = linear_func(*pw_expr.args)
+ transBlock.set_substitute = Constraint(
+ expr=substitute_var == linear_func_expr
+ )
+ (transBlock.substitute_var_lb, transBlock.substitute_var_ub) = (
+ compute_bounds_on_expr(linear_func_expr)
+ )
+ else:
+ # Add the disjunction
+ transBlock.disj = self._get_disjunction(
+ choices, transBlock, pw_expr, pw_linear_func, transBlock
+ )
+
+ # Set bounds as determined when setting up the disjunction
+ if transBlock.substitute_var_lb < float("inf"):
+ transBlock.substitute_var.setlb(transBlock.substitute_var_lb)
+ if transBlock.substitute_var_ub > -float("inf"):
+ transBlock.substitute_var.setub(transBlock.substitute_var_ub)
+
+ return substitute_var
+
+ # Recursively form the Disjunctions and Disjuncts. This shouldn't blow up
+ # the stack, since the whole point is that we'll only go logarithmically
+ # many calls deep.
+ def _get_disjunction(
+ self, choices, parent_block, pw_expr, pw_linear_func, root_block
+ ):
+ size = len(choices)
+
+ # Our base cases will be 3 and 2, since it would be silly to construct
+ # a Disjunction containing only one Disjunct. We can ensure that size
+ # is never 1 unless it was only passed a single choice from the start,
+ # which we can handle before calling.
+ if size > 3:
+ half = size // 2 # (integer divide)
+ # This tree will be slightly heavier on the right side
+ choices_l = choices[:half]
+ choices_r = choices[half:]
+
+ @parent_block.Disjunct()
+ def d_l(b):
+ b.inner_disjunction_l = self._get_disjunction(
+ choices_l, b, pw_expr, pw_linear_func, root_block
+ )
+
+ @parent_block.Disjunct()
+ def d_r(b):
+ b.inner_disjunction_r = self._get_disjunction(
+ choices_r, b, pw_expr, pw_linear_func, root_block
+ )
+
+ return Disjunction(expr=[parent_block.d_l, parent_block.d_r])
+ elif size == 3:
+ # Let's stay heavier on the right side for consistency. So the left
+ # Disjunct will be the one to contain constraints, rather than a
+ # Disjunction
+ @parent_block.Disjunct()
+ def d_l(b):
+ simplex, linear_func = choices[0]
+ self._set_disjunct_block_constraints(
+ b, simplex, linear_func, pw_expr, pw_linear_func, root_block
+ )
+
+ @parent_block.Disjunct()
+ def d_r(b):
+ b.inner_disjunction_r = self._get_disjunction(
+ choices[1:], b, pw_expr, pw_linear_func, root_block
+ )
+
+ return Disjunction(expr=[parent_block.d_l, parent_block.d_r])
+ elif size == 2:
+ # In this case both sides are regular Disjuncts
+ @parent_block.Disjunct()
+ def d_l(b):
+ simplex, linear_func = choices[0]
+ self._set_disjunct_block_constraints(
+ b, simplex, linear_func, pw_expr, pw_linear_func, root_block
+ )
+
+ @parent_block.Disjunct()
+ def d_r(b):
+ simplex, linear_func = choices[1]
+ self._set_disjunct_block_constraints(
+ b, simplex, linear_func, pw_expr, pw_linear_func, root_block
+ )
+
+ return Disjunction(expr=[parent_block.d_l, parent_block.d_r])
+ else:
+ raise DeveloperError(
+ "Unreachable: 1 or 0 choices were passed to "
+ "_get_disjunction in nested_inner_repn.py."
+ )
+
+ def _set_disjunct_block_constraints(
+ self, b, simplex, linear_func, pw_expr, pw_linear_func, root_block
+ ):
+ # Define the lambdas sparsely like in the normal inner repn,
+ # only the first few will participate in constraints
+ b.lambdas = Var(NonNegativeIntegers, dense=False, bounds=(0, 1))
+
+ # Get the extreme points to add up
+ extreme_pts = []
+ for idx in simplex:
+ extreme_pts.append(pw_linear_func._points[idx])
+
+ # Constrain sum(lambda_i) = 1
+ b.convex_combo = Constraint(
+ expr=sum(b.lambdas[i] for i in range(len(extreme_pts))) == 1
+ )
+ linear_func_expr = linear_func(*pw_expr.args)
+
+ # Make the substitute Var equal the PWLE
+ b.set_substitute = Constraint(
+ expr=root_block.substitute_var == linear_func_expr
+ )
+
+ # Widen the variable bounds to those of this linear func expression
+ (lb, ub) = compute_bounds_on_expr(linear_func_expr)
+ if lb is not None and lb < root_block.substitute_var_lb:
+ root_block.substitute_var_lb = lb
+ if ub is not None and ub > root_block.substitute_var_ub:
+ root_block.substitute_var_ub = ub
+
+ # Constrain x = \sum \lambda_i v_i
+ @b.Constraint(range(pw_expr.nargs())) # dimension
+ def linear_combo(d, i):
+ return pw_expr.args[i] == sum(
+ d.lambdas[j] * pt[i] for j, pt in enumerate(extreme_pts)
+ )
+
+ # Mark the lambdas as local in order to prevent disagreggating multiple
+ # times in the hull transformation
+ b.LocalVars = Suffix(direction=Suffix.LOCAL)
+ b.LocalVars[b] = [v for v in b.lambdas.values()]
diff --git a/pyomo/contrib/piecewise/transform/outer_representation_gdp.py b/pyomo/contrib/piecewise/transform/outer_representation_gdp.py
index 7c81619430a..6c26772fe6a 100644
--- a/pyomo/contrib/piecewise/transform/outer_representation_gdp.py
+++ b/pyomo/contrib/piecewise/transform/outer_representation_gdp.py
@@ -12,8 +12,8 @@
import pyomo.common.dependencies.numpy as np
from pyomo.common.dependencies.scipy import spatial
from pyomo.contrib.fbbt.fbbt import compute_bounds_on_expr
-from pyomo.contrib.piecewise.transform.piecewise_to_gdp_transformation import (
- PiecewiseLinearToGDP,
+from pyomo.contrib.piecewise.transform.piecewise_linear_transformation_base import (
+ PiecewiseLinearTransformationBase,
)
from pyomo.core import Constraint, NonNegativeIntegers, Suffix, Var
from pyomo.core.base import TransformationFactory
@@ -27,7 +27,7 @@
"the simplices that are the domains of the "
"linear functions.",
)
-class OuterRepresentationGDPTransformation(PiecewiseLinearToGDP):
+class OuterRepresentationGDPTransformation(PiecewiseLinearTransformationBase):
"""
Convert a model involving piecewise linear expressions into a GDP by
representing the piecewise linear functions as Disjunctions where the
@@ -49,7 +49,7 @@ class OuterRepresentationGDPTransformation(PiecewiseLinearToGDP):
this mode, targets must be Blocks, Constraints, and/or Objectives.
"""
- CONFIG = PiecewiseLinearToGDP.CONFIG()
+ CONFIG = PiecewiseLinearTransformationBase.CONFIG()
_transformation_name = 'pw_linear_outer_repn'
def _transform_pw_linear_expr(self, pw_expr, pw_linear_func, transformation_block):
diff --git a/pyomo/contrib/piecewise/transform/piecewise_to_gdp_transformation.py b/pyomo/contrib/piecewise/transform/piecewise_linear_transformation_base.py
similarity index 98%
rename from pyomo/contrib/piecewise/transform/piecewise_to_gdp_transformation.py
rename to pyomo/contrib/piecewise/transform/piecewise_linear_transformation_base.py
index 2e056c47a15..7e96891bbc4 100644
--- a/pyomo/contrib/piecewise/transform/piecewise_to_gdp_transformation.py
+++ b/pyomo/contrib/piecewise/transform/piecewise_linear_transformation_base.py
@@ -33,14 +33,14 @@
Any,
)
from pyomo.core.base import Transformation
-from pyomo.core.base.block import _BlockData, Block
+from pyomo.core.base.block import Block
from pyomo.core.util import target_list
from pyomo.gdp import Disjunct, Disjunction
from pyomo.gdp.util import is_child_of
from pyomo.network import Port
-class PiecewiseLinearToGDP(Transformation):
+class PiecewiseLinearTransformationBase(Transformation):
"""
Base class for transformations of piecewise-linear models to GDPs
"""
@@ -147,7 +147,7 @@ def _apply_to_impl(self, instance, **kwds):
self._transform_piecewise_linear_function(
t, config.descend_into_expressions
)
- elif t.ctype is Block or isinstance(t, _BlockData):
+ elif issubclass(t.ctype, Block):
self._transform_block(t, config.descend_into_expressions)
elif t.ctype is Constraint:
if not config.descend_into_expressions:
diff --git a/pyomo/contrib/piecewise/transform/reduced_inner_representation_gdp.py b/pyomo/contrib/piecewise/transform/reduced_inner_representation_gdp.py
index 5c7dfa895ab..a19507a93fd 100644
--- a/pyomo/contrib/piecewise/transform/reduced_inner_representation_gdp.py
+++ b/pyomo/contrib/piecewise/transform/reduced_inner_representation_gdp.py
@@ -10,8 +10,8 @@
# ___________________________________________________________________________
from pyomo.contrib.fbbt.fbbt import compute_bounds_on_expr
-from pyomo.contrib.piecewise.transform.piecewise_to_gdp_transformation import (
- PiecewiseLinearToGDP,
+from pyomo.contrib.piecewise.transform.piecewise_linear_transformation_base import (
+ PiecewiseLinearTransformationBase,
)
from pyomo.core import Constraint, NonNegativeIntegers, Var
from pyomo.core.base import TransformationFactory
@@ -25,7 +25,7 @@
"simplices that are the domains of the linear "
"functions.",
)
-class ReducedInnerRepresentationGDPTransformation(PiecewiseLinearToGDP):
+class ReducedInnerRepresentationGDPTransformation(PiecewiseLinearTransformationBase):
"""
Convert a model involving piecewise linear expressions into a GDP by
representing the piecewise linear functions as Disjunctions where the
@@ -51,7 +51,7 @@ class ReducedInnerRepresentationGDPTransformation(PiecewiseLinearToGDP):
this mode, targets must be Blocks, Constraints, and/or Objectives.
"""
- CONFIG = PiecewiseLinearToGDP.CONFIG()
+ CONFIG = PiecewiseLinearTransformationBase.CONFIG()
_transformation_name = 'pw_linear_reduced_inner_repn'
def _transform_pw_linear_expr(self, pw_expr, pw_linear_func, transformation_block):
diff --git a/pyomo/contrib/preprocessing/plugins/var_aggregator.py b/pyomo/contrib/preprocessing/plugins/var_aggregator.py
index d862f167fd7..3430d29de3a 100644
--- a/pyomo/contrib/preprocessing/plugins/var_aggregator.py
+++ b/pyomo/contrib/preprocessing/plugins/var_aggregator.py
@@ -13,7 +13,14 @@
from pyomo.common.collections import ComponentMap, ComponentSet
-from pyomo.core.base import Block, Constraint, VarList, Objective, TransformationFactory
+from pyomo.core.base import (
+ Block,
+ Constraint,
+ VarList,
+ Objective,
+ Reals,
+ TransformationFactory,
+)
from pyomo.core.expr import ExpressionReplacementVisitor
from pyomo.core.expr.numvalue import value
from pyomo.core.plugins.transform.hierarchy import IsomorphicTransformation
@@ -248,6 +255,12 @@ def _apply_to(self, model, detect_fixed_vars=True):
# the variables in its equality set.
z_agg.setlb(max_if_not_None(v.lb for v in eq_set if v.has_lb()))
z_agg.setub(min_if_not_None(v.ub for v in eq_set if v.has_ub()))
+ # Set the domain of the aggregate variable to the intersection of
+ # the domains of the variables in its equality set
+ domain = Reals
+ for v in eq_set:
+ domain = domain & v.domain
+ z_agg.domain = domain
# Set the fixed status of the aggregate var
fixed_vars = [v for v in eq_set if v.fixed]
diff --git a/pyomo/contrib/preprocessing/tests/test_var_aggregator.py b/pyomo/contrib/preprocessing/tests/test_var_aggregator.py
index 6f6d02f2180..b0b672b76b0 100644
--- a/pyomo/contrib/preprocessing/tests/test_var_aggregator.py
+++ b/pyomo/contrib/preprocessing/tests/test_var_aggregator.py
@@ -19,12 +19,16 @@
max_if_not_None,
min_if_not_None,
)
+from pyomo.core.expr.compare import assertExpressionsEqual
from pyomo.environ import (
+ Binary,
ConcreteModel,
Constraint,
ConstraintList,
+ maximize,
Objective,
RangeSet,
+ Reals,
SolverFactory,
TransformationFactory,
Var,
@@ -210,6 +214,36 @@ def test_var_update(self):
self.assertEqual(m.x.value, 0)
self.assertEqual(m.y.value, 0)
+ def test_binary_inequality(self):
+ m = ConcreteModel()
+ m.x = Var(domain=Binary)
+ m.y = Var(domain=Binary)
+ m.c = Constraint(expr=m.x == m.y)
+ m.o = Objective(expr=0.5 * m.x + m.y, sense=maximize)
+ TransformationFactory('contrib.aggregate_vars').apply_to(m)
+ var_to_z = m._var_aggregator_info.var_to_z
+ z = var_to_z[m.x]
+ self.assertIs(var_to_z[m.y], z)
+ self.assertEqual(z.domain, Binary)
+ self.assertEqual(z.lb, 0)
+ self.assertEqual(z.ub, 1)
+ assertExpressionsEqual(self, m.o.expr, 0.5 * z + z)
+
+ def test_equality_different_domains(self):
+ m = ConcreteModel()
+ m.x = Var(domain=Reals, bounds=(1, 2))
+ m.y = Var(domain=Binary)
+ m.c = Constraint(expr=m.x == m.y)
+ m.o = Objective(expr=0.5 * m.x + m.y, sense=maximize)
+ TransformationFactory('contrib.aggregate_vars').apply_to(m)
+ var_to_z = m._var_aggregator_info.var_to_z
+ z = var_to_z[m.x]
+ self.assertIs(var_to_z[m.y], z)
+ self.assertEqual(z.lb, 1)
+ self.assertEqual(z.ub, 1)
+ self.assertEqual(z.domain, Binary)
+ assertExpressionsEqual(self, m.o.expr, 0.5 * z + z)
+
if __name__ == '__main__':
unittest.main()
diff --git a/pyomo/contrib/pynumero/README.md b/pyomo/contrib/pynumero/README.md
index 0d165dbc39c..f881e400d51 100644
--- a/pyomo/contrib/pynumero/README.md
+++ b/pyomo/contrib/pynumero/README.md
@@ -71,3 +71,75 @@ Prerequisites
- cmake
- a C/C++ compiler
- MA57 library or COIN-HSL Full
+
+Code organization
+=================
+
+PyNumero was initially designed around three core components: linear solver
+interfaces, an interface for function and derivative callbacks, and block
+vector and matrix classes. Since then, it has incorporated additional
+functionality in an ad-hoc manner. The original "core functionality" of
+PyNumero, as well as the solver interfaces accessible through
+`SolverFactory`, should be considered stable and will only change after
+appropriate deprecation warnings. Other functionality should be considered
+experimental and subject to change without warning.
+
+The following is a rough overview of PyNumero, by directory:
+
+`linalg`
+--------
+
+Python interfaces to linear solvers. This is core functionality.
+
+`interfaces`
+------------
+
+- Classes that define and implement an API for function and derivative callbacks
+required by nonlinear optimization solvers, e.g. `nlp.py` and `pyomo_nlp.py`
+- Various wrappers around these NLP classes to support "hybrid" implementations,
+e.g. `PyomoNLPWithGreyBoxBlocks`
+- The `ExternalGreyBoxBlock` Pyomo modeling component and
+`ExternalGreyBoxModel` API
+- The `ExternalPyomoModel` implementation of `ExternalGreyBoxModel`, which allows
+definition of an external grey box via an implicit function
+- The `CyIpoptNLP` class, which wraps an object implementing the NLP API in
+the interface required by CyIpopt
+
+Of the above, only `PyomoNLP` and the `NLP` base class should be considered core
+functionality.
+
+`src`
+-----
+
+C++ interfaces to ASL, MA27, and MA57. The ASL and MA27 interfaces are
+core functionality.
+
+`sparse`
+--------
+
+Block vector and block matrix classes, including MPI variations.
+These are core functionality.
+
+`algorithms`
+------------
+
+Originally intended to hold various useful algorithms implemented
+on NLP objects rather than Pyomo models. Any files added here should
+be considered experimental.
+
+`algorithms/solvers`
+--------------------
+
+Interfaces to Python solvers using the NLP API defined in `interfaces`.
+Only the solvers accessible through `SolverFactory`, e.g. `PyomoCyIpoptSolver`
+and `PyomoFsolveSolver`, should be considered core functionality.
+The supported way to access these solvers is via `SolverFactory`. *The locations
+of the underlying solver objects are subject to change without warning.*
+
+`examples`
+----------
+
+The examples demonstrated in `nlp_interface.py`, `nlp_interface_2.py1`,
+`feasibility.py`, `mumps_example.py`, `sensitivity.py`, `sqp.py`,
+`parallel_matvec.py`, and `parallel_vector_ops.py` are stable. All other
+examples should be considered experimental.
diff --git a/pyomo/contrib/pynumero/algorithms/solvers/cyipopt_solver.py b/pyomo/contrib/pynumero/algorithms/solvers/cyipopt_solver.py
index 8f9f677c06d..e93dafe225b 100644
--- a/pyomo/contrib/pynumero/algorithms/solvers/cyipopt_solver.py
+++ b/pyomo/contrib/pynumero/algorithms/solvers/cyipopt_solver.py
@@ -24,6 +24,8 @@
from pyomo.common.deprecation import relocated_module_attribute
from pyomo.common.dependencies import attempt_import, numpy as np, numpy_available
from pyomo.common.tee import redirect_fd, TeeStream
+from pyomo.common.modeling import unique_component_name
+from pyomo.core.base.objective import Objective
# Because pynumero.interfaces requires numpy, we will leverage deferred
# imports here so that the solver can be registered even when numpy is
@@ -63,7 +65,7 @@
from pyomo.common.config import ConfigBlock, ConfigValue
from pyomo.common.timing import TicTocTimer
from pyomo.core.base import Block, Objective, minimize
-from pyomo.opt import SolverStatus, SolverResults, TerminationCondition, ProblemSense
+from pyomo.opt import SolverStatus, SolverResults, TerminationCondition
from pyomo.opt.results.solution import Solution
logger = logging.getLogger(__name__)
@@ -318,7 +320,13 @@ def license_is_valid(self):
return True
def version(self):
- return tuple(int(_) for _ in cyipopt.__version__.split("."))
+ def _int(x):
+ try:
+ return int(x)
+ except:
+ return x
+
+ return tuple(_int(_) for _ in cyipopt_interface.cyipopt.__version__.split("."))
def solve(self, model, **kwds):
config = self.config(kwds, preserve_implicit=True)
@@ -333,11 +341,22 @@ def solve(self, model, **kwds):
grey_box_blocks = list(
model.component_data_objects(egb.ExternalGreyBoxBlock, active=True)
)
- if grey_box_blocks:
- # nlp = pyomo_nlp.PyomoGreyBoxNLP(model)
- nlp = pyomo_grey_box.PyomoNLPWithGreyBoxBlocks(model)
- else:
- nlp = pyomo_nlp.PyomoNLP(model)
+ # if there is no objective, add one temporarily so we can construct an NLP
+ objectives = list(model.component_data_objects(Objective, active=True))
+ if not objectives:
+ objname = unique_component_name(model, "_obj")
+ objective = model.add_component(objname, Objective(expr=0.0))
+ try:
+ if grey_box_blocks:
+ # nlp = pyomo_nlp.PyomoGreyBoxNLP(model)
+ nlp = pyomo_grey_box.PyomoNLPWithGreyBoxBlocks(model)
+ else:
+ nlp = pyomo_nlp.PyomoNLP(model)
+ finally:
+ # We only need the objective to construct the NLP, so we delete
+ # it from the model ASAP
+ if not objectives:
+ model.del_component(objective)
problem = cyipopt_interface.CyIpoptNLP(
nlp,
@@ -429,11 +448,10 @@ def solve(self, model, **kwds):
results.problem.name = model.name
obj = next(model.component_data_objects(Objective, active=True))
+ results.problem.sense = obj.sense
if obj.sense == minimize:
- results.problem.sense = ProblemSense.minimize
results.problem.upper_bound = info["obj_val"]
else:
- results.problem.sense = ProblemSense.maximize
results.problem.lower_bound = info["obj_val"]
results.problem.number_of_objectives = 1
results.problem.number_of_constraints = ng
diff --git a/pyomo/contrib/pynumero/algorithms/solvers/pyomo_ext_cyipopt.py b/pyomo/contrib/pynumero/algorithms/solvers/pyomo_ext_cyipopt.py
index 16c5a19a5c6..7f43f6ac7c0 100644
--- a/pyomo/contrib/pynumero/algorithms/solvers/pyomo_ext_cyipopt.py
+++ b/pyomo/contrib/pynumero/algorithms/solvers/pyomo_ext_cyipopt.py
@@ -16,7 +16,7 @@
from pyomo.contrib.pynumero.interfaces.pyomo_nlp import PyomoNLP
from pyomo.contrib.pynumero.sparse.block_vector import BlockVector
from pyomo.environ import Var, Constraint, value
-from pyomo.core.base.var import _VarData
+from pyomo.core.base.var import VarData
from pyomo.common.modeling import unique_component_name
"""
@@ -109,12 +109,12 @@ def __init__(
An instance of a derived class (from ExternalInputOutputModel) that provides
the methods to compute the outputs and the derivatives.
- inputs : list of Pyomo variables (_VarData)
+ inputs : list of Pyomo variables (VarData)
The Pyomo model needs to have variables to represent the inputs to the
external model. This is the list of those input variables in the order
that corresponds to the input_values vector provided in the set_inputs call.
- outputs : list of Pyomo variables (_VarData)
+ outputs : list of Pyomo variables (VarData)
The Pyomo model needs to have variables to represent the outputs from the
external model. This is the list of those output variables in the order
that corresponds to the numpy array returned from the evaluate_outputs call.
@@ -130,7 +130,7 @@ def __init__(
# verify that the inputs and outputs were passed correctly
self._inputs = [v for v in inputs]
for v in self._inputs:
- if not isinstance(v, _VarData):
+ if not isinstance(v, VarData):
raise RuntimeError(
'Argument inputs passed to PyomoExternalCyIpoptProblem must be'
' a list of VarData objects. Note: if you have an indexed variable, pass'
@@ -139,7 +139,7 @@ def __init__(
self._outputs = [v for v in outputs]
for v in self._outputs:
- if not isinstance(v, _VarData):
+ if not isinstance(v, VarData):
raise RuntimeError(
'Argument outputs passed to PyomoExternalCyIpoptProblem must be'
' a list of VarData objects. Note: if you have an indexed variable, pass'
diff --git a/pyomo/contrib/pynumero/algorithms/solvers/tests/test_cyipopt_solver.py b/pyomo/contrib/pynumero/algorithms/solvers/tests/test_cyipopt_solver.py
index efbec128762..783a14861ac 100644
--- a/pyomo/contrib/pynumero/algorithms/solvers/tests/test_cyipopt_solver.py
+++ b/pyomo/contrib/pynumero/algorithms/solvers/tests/test_cyipopt_solver.py
@@ -321,6 +321,16 @@ def test_hs071_evalerror_old_cyipopt(self):
with self.assertRaisesRegex(PyNumeroEvaluationError, msg):
res = solver.solve(m, tee=True)
+ def test_solve_without_objective(self):
+ m = create_model1()
+ m.o.deactivate()
+ m.x[2].fix(0.0)
+ m.x[3].fix(4.0)
+ solver = pyo.SolverFactory("cyipopt")
+ res = solver.solve(m, tee=True)
+ pyo.assert_optimal_termination(res)
+ self.assertAlmostEqual(m.x[1].value, 9.0)
+
def test_infeasibility_callback(self):
model = create_model1()
intermediate_cb = InfeasibilityCallback(
@@ -344,7 +354,3 @@ def test_infeasibility_callback(self):
# fd = _teeStream.STDOUT.fileno()
# with redirect_fd(fd=1, output=fd, synchronize=False):
# solver.solve(model, tee=True)
-
-
-if __name__ == "__main__":
- TestCyIpoptSolver().test_infeasibility_callback()
diff --git a/pyomo/contrib/pynumero/dependencies.py b/pyomo/contrib/pynumero/dependencies.py
index 9e2088ffa0a..d323bd43e84 100644
--- a/pyomo/contrib/pynumero/dependencies.py
+++ b/pyomo/contrib/pynumero/dependencies.py
@@ -17,7 +17,7 @@
'numpy',
'Pynumero requires the optional Pyomo dependency "numpy"',
minimum_version='1.13.0',
- defer_check=False,
+ defer_import=False,
)
if not numpy_available:
diff --git a/pyomo/contrib/pynumero/examples/tests/test_cyipopt_examples.py b/pyomo/contrib/pynumero/examples/tests/test_cyipopt_examples.py
index 1f45f26d43b..2df43c1e797 100644
--- a/pyomo/contrib/pynumero/examples/tests/test_cyipopt_examples.py
+++ b/pyomo/contrib/pynumero/examples/tests/test_cyipopt_examples.py
@@ -35,7 +35,7 @@
'One of the tests below requires a recent version of pandas for'
' comparing with a tolerance.',
minimum_version='1.1.0',
- defer_check=False,
+ defer_import=False,
)
from pyomo.contrib.pynumero.asl import AmplInterface
@@ -44,11 +44,13 @@
raise unittest.SkipTest("Pynumero needs the ASL extension to run CyIpopt tests")
import pyomo.contrib.pynumero.algorithms.solvers.cyipopt_solver as cyipopt_solver
+from pyomo.contrib.pynumero.interfaces.cyipopt_interface import cyipopt_available
-if not cyipopt_solver.cyipopt_available:
+if not cyipopt_available:
raise unittest.SkipTest("PyNumero needs CyIpopt installed to run CyIpopt tests")
import cyipopt as cyipopt_core
+
example_dir = os.path.join(this_file_dir(), '..')
@@ -266,6 +268,11 @@ def test_cyipopt_functor(self):
s = df['ca_bal']
self.assertAlmostEqual(s.iloc[6], 0, places=3)
+ @unittest.skipIf(
+ cyipopt_solver.PyomoCyIpoptSolver().version() == (1, 4, 0),
+ "Terminating Ipopt through a user callback is broken in CyIpopt 1.4.0 "
+ "(see mechmotum/cyipopt#249)",
+ )
def test_cyipopt_callback_halt(self):
ex = import_file(
os.path.join(example_dir, 'callback', 'cyipopt_callback_halt.py')
diff --git a/pyomo/contrib/pynumero/interfaces/external_grey_box.py b/pyomo/contrib/pynumero/interfaces/external_grey_box.py
index 7e42f161bee..68e652575cc 100644
--- a/pyomo/contrib/pynumero/interfaces/external_grey_box.py
+++ b/pyomo/contrib/pynumero/interfaces/external_grey_box.py
@@ -18,7 +18,7 @@
from pyomo.common.log import is_debug_set
from pyomo.common.timing import ConstructionTimer
from pyomo.core.base import Var, Set, Constraint, value
-from pyomo.core.base.block import _BlockData, Block, declare_custom_block
+from pyomo.core.base.block import BlockData, Block, declare_custom_block
from pyomo.core.base.global_set import UnindexedComponent_index
from pyomo.core.base.initializer import Initializer
from pyomo.core.base.set import UnindexedComponent_set
@@ -316,7 +316,7 @@ def evaluate_jacobian_outputs(self):
#
-class ExternalGreyBoxBlockData(_BlockData):
+class ExternalGreyBoxBlockData(BlockData):
def set_external_model(self, external_grey_box_model, inputs=None, outputs=None):
"""
Parameters
@@ -424,7 +424,7 @@ class ScalarExternalGreyBoxBlock(ExternalGreyBoxBlockData, ExternalGreyBoxBlock)
def __init__(self, *args, **kwds):
ExternalGreyBoxBlockData.__init__(self, component=self)
ExternalGreyBoxBlock.__init__(self, *args, **kwds)
- # The above inherit from Block and _BlockData, so it's not until here
+ # The above inherit from Block and BlockData, so it's not until here
# that we know it's scalar. So we set the index accordingly.
self._index = UnindexedComponent_index
diff --git a/pyomo/contrib/pynumero/interfaces/pyomo_nlp.py b/pyomo/contrib/pynumero/interfaces/pyomo_nlp.py
index 51edd09311a..e12d0cf568b 100644
--- a/pyomo/contrib/pynumero/interfaces/pyomo_nlp.py
+++ b/pyomo/contrib/pynumero/interfaces/pyomo_nlp.py
@@ -22,6 +22,7 @@
import pyomo.core.base as pyo
from pyomo.common.collections import ComponentMap
from pyomo.common.env import CtypesEnviron
+from pyomo.solvers.amplfunc_merge import amplfunc_merge
from ..sparse.block_matrix import BlockMatrix
from pyomo.contrib.pynumero.interfaces.ampl_nlp import AslNLP
from pyomo.contrib.pynumero.interfaces.nlp import NLP
@@ -92,15 +93,8 @@ def __init__(self, pyomo_model, nl_file_options=None):
# The NL writer advertises the external function libraries
# through the PYOMO_AMPLFUNC environment variable; merge it
# with any preexisting AMPLFUNC definitions
- amplfunc = "\n".join(
- filter(
- None,
- (
- os.environ.get('AMPLFUNC', None),
- os.environ.get('PYOMO_AMPLFUNC', None),
- ),
- )
- )
+ amplfunc = amplfunc_merge(os.environ)
+
with CtypesEnviron(AMPLFUNC=amplfunc):
super(PyomoNLP, self).__init__(nl_file)
diff --git a/pyomo/contrib/pynumero/intrinsic.py b/pyomo/contrib/pynumero/intrinsic.py
index 84675cc4c02..34054e7ffa2 100644
--- a/pyomo/contrib/pynumero/intrinsic.py
+++ b/pyomo/contrib/pynumero/intrinsic.py
@@ -11,9 +11,7 @@
from pyomo.common.dependencies import numpy as np, attempt_import
-block_vector = attempt_import(
- 'pyomo.contrib.pynumero.sparse.block_vector', defer_check=True
-)[0]
+block_vector = attempt_import('pyomo.contrib.pynumero.sparse.block_vector')[0]
def norm(x, ord=None):
diff --git a/pyomo/contrib/pyros/CHANGELOG.txt b/pyomo/contrib/pyros/CHANGELOG.txt
index 7d4678f0ba3..52cd7a6db47 100644
--- a/pyomo/contrib/pyros/CHANGELOG.txt
+++ b/pyomo/contrib/pyros/CHANGELOG.txt
@@ -2,6 +2,24 @@
PyROS CHANGELOG
===============
+-------------------------------------------------------------------------------
+PyROS 1.2.11 17 Mar 2024
+-------------------------------------------------------------------------------
+- Standardize calls to subordinate solvers across all PyROS subproblem types
+- Account for user-specified subsolver time limits when automatically
+ adjusting subsolver time limits
+- Add support for automatic adjustment of SCIP subsolver time limit
+- Move start point of main PyROS solver timer to just before argument
+ validation begins
+
+
+-------------------------------------------------------------------------------
+PyROS 1.2.10 07 Feb 2024
+-------------------------------------------------------------------------------
+- Update argument resolution and validation routines of `PyROS.solve()`
+- Use methods of `common.config` for docstring of `PyROS.solve()`
+
+
-------------------------------------------------------------------------------
PyROS 1.2.9 15 Dec 2023
-------------------------------------------------------------------------------
@@ -14,6 +32,7 @@ PyROS 1.2.9 15 Dec 2023
- Refactor DR polishing routine; initialize auxiliary variables
to values they are meant to represent
+
-------------------------------------------------------------------------------
PyROS 1.2.8 12 Oct 2023
-------------------------------------------------------------------------------
diff --git a/pyomo/contrib/pyros/config.py b/pyomo/contrib/pyros/config.py
new file mode 100644
index 00000000000..c02dcd7ed0f
--- /dev/null
+++ b/pyomo/contrib/pyros/config.py
@@ -0,0 +1,879 @@
+"""
+Interfaces for managing PyROS solver options.
+"""
+
+from collections.abc import Iterable
+import logging
+
+from pyomo.common.collections import ComponentSet
+from pyomo.common.config import (
+ ConfigDict,
+ ConfigValue,
+ In,
+ IsInstance,
+ NonNegativeFloat,
+ InEnum,
+ Path,
+)
+from pyomo.common.errors import ApplicationError, PyomoException
+from pyomo.core.base import Var, VarData
+from pyomo.core.base.param import Param, ParamData
+from pyomo.opt import SolverFactory
+from pyomo.contrib.pyros.util import ObjectiveType, setup_pyros_logger
+from pyomo.contrib.pyros.uncertainty_sets import UncertaintySet
+
+
+default_pyros_solver_logger = setup_pyros_logger()
+
+
+def logger_domain(obj):
+ """
+ Domain validator for logger-type arguments.
+
+ This admits any object of type ``logging.Logger``,
+ or which can be cast to ``logging.Logger``.
+ """
+ if isinstance(obj, logging.Logger):
+ return obj
+ else:
+ return logging.getLogger(obj)
+
+
+logger_domain.domain_name = "None, str or logging.Logger"
+
+
+def positive_int_or_minus_one(obj):
+ """
+ Domain validator for objects castable to a strictly
+ positive int or -1.
+ """
+ ans = int(obj)
+ if ans != float(obj) or (ans <= 0 and ans != -1):
+ raise ValueError(f"Expected positive int or -1, but received value {obj!r}")
+ return ans
+
+
+positive_int_or_minus_one.domain_name = "positive int or -1"
+
+
+def mutable_param_validator(param_obj):
+ """
+ Check that Param-like object has attribute `mutable=True`.
+
+ Parameters
+ ----------
+ param_obj : Param or ParamData
+ Param-like object of interest.
+
+ Raises
+ ------
+ ValueError
+ If lengths of the param object and the accompanying
+ index set do not match. This may occur if some entry
+ of the Param is not initialized.
+ ValueError
+ If attribute `mutable` is of value False.
+ """
+ if len(param_obj) != len(param_obj.index_set()):
+ raise ValueError(
+ f"Length of Param component object with "
+ f"name {param_obj.name!r} is {len(param_obj)}, "
+ "and does not match that of its index set, "
+ f"which is of length {len(param_obj.index_set())}. "
+ "Check that all entries of the component object "
+ "have been initialized."
+ )
+ if not param_obj.mutable:
+ raise ValueError(f"Param object with name {param_obj.name!r} is immutable.")
+
+
+class InputDataStandardizer(object):
+ """
+ Standardizer for objects castable to a list of Pyomo
+ component types.
+
+ Parameters
+ ----------
+ ctype : type
+ Pyomo component type, such as Component, Var or Param.
+ cdatatype : type
+ Corresponding Pyomo component data type, such as
+ ComponentData, VarData, or ParamData.
+ ctype_validator : callable, optional
+ Validator function for objects of type `ctype`.
+ cdatatype_validator : callable, optional
+ Validator function for objects of type `cdatatype`.
+ allow_repeats : bool, optional
+ True to allow duplicate component data entries in final
+ list to which argument is cast, False otherwise.
+
+ Attributes
+ ----------
+ ctype
+ cdatatype
+ ctype_validator
+ cdatatype_validator
+ allow_repeats
+ """
+
+ def __init__(
+ self,
+ ctype,
+ cdatatype,
+ ctype_validator=None,
+ cdatatype_validator=None,
+ allow_repeats=False,
+ ):
+ """Initialize self (see class docstring)."""
+ self.ctype = ctype
+ self.cdatatype = cdatatype
+ self.ctype_validator = ctype_validator
+ self.cdatatype_validator = cdatatype_validator
+ self.allow_repeats = allow_repeats
+
+ def standardize_ctype_obj(self, obj):
+ """
+ Standardize object of type ``self.ctype`` to list
+ of objects of type ``self.cdatatype``.
+ """
+ if self.ctype_validator is not None:
+ self.ctype_validator(obj)
+ return list(obj.values())
+
+ def standardize_cdatatype_obj(self, obj):
+ """
+ Standardize object of type ``self.cdatatype`` to
+ ``[obj]``.
+ """
+ if self.cdatatype_validator is not None:
+ self.cdatatype_validator(obj)
+ return [obj]
+
+ def __call__(self, obj, from_iterable=None, allow_repeats=None):
+ """
+ Cast object to a flat list of Pyomo component data type
+ entries.
+
+ Parameters
+ ----------
+ obj : object
+ Object to be cast.
+ from_iterable : Iterable or None, optional
+ Iterable from which `obj` obtained, if any.
+ allow_repeats : bool or None, optional
+ True if list can contain repeated entries,
+ False otherwise.
+
+ Raises
+ ------
+ TypeError
+ If all entries in the resulting list
+ are not of type ``self.cdatatype``.
+ ValueError
+ If the resulting list contains duplicate entries.
+ """
+ if allow_repeats is None:
+ allow_repeats = self.allow_repeats
+
+ if isinstance(obj, self.ctype):
+ ans = self.standardize_ctype_obj(obj)
+ elif isinstance(obj, self.cdatatype):
+ ans = self.standardize_cdatatype_obj(obj)
+ elif isinstance(obj, Iterable) and not isinstance(obj, str):
+ ans = []
+ for item in obj:
+ ans.extend(self.__call__(item, from_iterable=obj))
+ else:
+ from_iterable_qual = (
+ f" (entry of iterable {from_iterable})"
+ if from_iterable is not None
+ else ""
+ )
+ raise TypeError(
+ f"Input object {obj!r}{from_iterable_qual} "
+ "is not of valid component type "
+ f"{self.ctype.__name__} or component data type "
+ f"{self.cdatatype.__name__}."
+ )
+
+ # check for duplicates if desired
+ if not allow_repeats and len(ans) != len(ComponentSet(ans)):
+ comp_name_list = [comp.name for comp in ans]
+ raise ValueError(
+ f"Standardized component list {comp_name_list} "
+ f"derived from input {obj} "
+ "contains duplicate entries."
+ )
+
+ return ans
+
+ def domain_name(self):
+ """Return str briefly describing domain encompassed by self."""
+ return (
+ f"{self.cdatatype.__name__}, {self.ctype.__name__}, "
+ f"or Iterable of {self.cdatatype.__name__}/{self.ctype.__name__}"
+ )
+
+
+class SolverNotResolvable(PyomoException):
+ """
+ Exception type for failure to cast an object to a Pyomo solver.
+ """
+
+
+class SolverResolvable(object):
+ """
+ Callable for casting an object (such as a str)
+ to a Pyomo solver.
+
+ Parameters
+ ----------
+ require_available : bool, optional
+ True if `available()` method of a standardized solver
+ object obtained through `self` must return `True`,
+ False otherwise.
+ solver_desc : str, optional
+ Descriptor for the solver obtained through `self`,
+ such as 'local solver'
+ or 'global solver'. This argument is used
+ for constructing error/exception messages.
+
+ Attributes
+ ----------
+ require_available
+ solver_desc
+ """
+
+ def __init__(self, require_available=True, solver_desc="solver"):
+ """Initialize self (see class docstring)."""
+ self.require_available = require_available
+ self.solver_desc = solver_desc
+
+ @staticmethod
+ def is_solver_type(obj):
+ """
+ Return True if object is considered a Pyomo solver,
+ False otherwise.
+
+ An object is considered a Pyomo solver provided that
+ it has callable attributes named 'solve' and
+ 'available'.
+ """
+ return callable(getattr(obj, "solve", None)) and callable(
+ getattr(obj, "available", None)
+ )
+
+ def __call__(self, obj, require_available=None, solver_desc=None):
+ """
+ Cast object to a Pyomo solver.
+
+ If `obj` is a string, then ``SolverFactory(obj.lower())``
+ is returned. If `obj` is a Pyomo solver type, then
+ `obj` is returned.
+
+ Parameters
+ ----------
+ obj : object
+ Object to be cast to Pyomo solver type.
+ require_available : bool or None, optional
+ True if `available()` method of the resolved solver
+ object must return True, False otherwise.
+ If `None` is passed, then ``self.require_available``
+ is used.
+ solver_desc : str or None, optional
+ Brief description of the solver, such as 'local solver'
+ or 'backup global solver'. This argument is used
+ for constructing error/exception messages.
+ If `None` is passed, then ``self.solver_desc``
+ is used.
+
+ Returns
+ -------
+ Solver
+ Pyomo solver.
+
+ Raises
+ ------
+ SolverNotResolvable
+ If `obj` cannot be cast to a Pyomo solver because
+ it is neither a str nor a Pyomo solver type.
+ ApplicationError
+ In event that solver is not available, the
+ method `available(exception_flag=True)` of the
+ solver to which `obj` is cast should raise an
+ exception of this type. The present method
+ will also emit a more detailed error message
+ through the default PyROS logger.
+ """
+ # resort to defaults if necessary
+ if require_available is None:
+ require_available = self.require_available
+ if solver_desc is None:
+ solver_desc = self.solver_desc
+
+ # perform casting
+ if isinstance(obj, str):
+ solver = SolverFactory(obj.lower())
+ elif self.is_solver_type(obj):
+ solver = obj
+ else:
+ raise SolverNotResolvable(
+ f"Cannot cast object `{obj!r}` to a Pyomo optimizer for use as "
+ f"{solver_desc}, as the object is neither a str nor a "
+ f"Pyomo Solver type (got type {type(obj).__name__})."
+ )
+
+ # availability check, if so desired
+ if require_available:
+ try:
+ solver.available(exception_flag=True)
+ except ApplicationError:
+ default_pyros_solver_logger.exception(
+ f"Output of `available()` method for {solver_desc} "
+ f"with repr {solver!r} resolved from object {obj} "
+ "is not `True`. "
+ "Check solver and any required dependencies "
+ "have been set up properly."
+ )
+ raise
+
+ return solver
+
+ def domain_name(self):
+ """Return str briefly describing domain encompassed by self."""
+ return "str or Solver"
+
+
+class SolverIterable(object):
+ """
+ Callable for casting an iterable (such as a list of strs)
+ to a list of Pyomo solvers.
+
+ Parameters
+ ----------
+ require_available : bool, optional
+ True if `available()` method of a standardized solver
+ object obtained through `self` must return `True`,
+ False otherwise.
+ filter_by_availability : bool, optional
+ True to remove standardized solvers for which `available()`
+ does not return True, False otherwise.
+ solver_desc : str, optional
+ Descriptor for the solver obtained through `self`,
+ such as 'backup local solver'
+ or 'backup global solver'.
+ """
+
+ def __init__(
+ self, require_available=True, filter_by_availability=True, solver_desc="solver"
+ ):
+ """Initialize self (see class docstring)."""
+ self.require_available = require_available
+ self.filter_by_availability = filter_by_availability
+ self.solver_desc = solver_desc
+
+ def __call__(
+ self, obj, require_available=None, filter_by_availability=None, solver_desc=None
+ ):
+ """
+ Cast iterable object to a list of Pyomo solver objects.
+
+ Parameters
+ ----------
+ obj : str, Solver, or Iterable of str/Solver
+ Object of interest.
+ require_available : bool or None, optional
+ True if `available()` method of each solver
+ object must return True, False otherwise.
+ If `None` is passed, then ``self.require_available``
+ is used.
+ solver_desc : str or None, optional
+ Descriptor for the solver, such as 'backup local solver'
+ or 'backup global solver'. This argument is used
+ for constructing error/exception messages.
+ If `None` is passed, then ``self.solver_desc``
+ is used.
+
+ Returns
+ -------
+ solvers : list of solver type
+ List of solver objects to which obj is cast.
+
+ Raises
+ ------
+ TypeError
+ If `obj` is a str.
+ """
+ if require_available is None:
+ require_available = self.require_available
+ if filter_by_availability is None:
+ filter_by_availability = self.filter_by_availability
+ if solver_desc is None:
+ solver_desc = self.solver_desc
+
+ solver_resolve_func = SolverResolvable()
+
+ if isinstance(obj, str) or solver_resolve_func.is_solver_type(obj):
+ # single solver resolvable is cast to singleton list.
+ # perform explicit check for str, otherwise this method
+ # would attempt to resolve each character.
+ obj_as_list = [obj]
+ else:
+ obj_as_list = list(obj)
+
+ solvers = []
+ for idx, val in enumerate(obj_as_list):
+ solver_desc_str = f"{solver_desc} " f"(index {idx})"
+ opt = solver_resolve_func(
+ obj=val,
+ require_available=require_available,
+ solver_desc=solver_desc_str,
+ )
+ if filter_by_availability and not opt.available(exception_flag=False):
+ default_pyros_solver_logger.warning(
+ f"Output of `available()` method for solver object {opt} "
+ f"resolved from object {val} of sequence {obj_as_list} "
+ f"to be used as {self.solver_desc} "
+ "is not `True`. "
+ "Removing from list of standardized solvers."
+ )
+ else:
+ solvers.append(opt)
+
+ return solvers
+
+ def domain_name(self):
+ """Return str briefly describing domain encompassed by self."""
+ return "str, solver type, or Iterable of str/solver type"
+
+
+def pyros_config():
+ CONFIG = ConfigDict('PyROS')
+
+ # ================================================
+ # === Options common to all solvers
+ # ================================================
+ CONFIG.declare(
+ 'time_limit',
+ ConfigValue(
+ default=None,
+ domain=NonNegativeFloat,
+ doc=(
+ """
+ Wall time limit for the execution of the PyROS solver
+ in seconds (including time spent by subsolvers).
+ If `None` is provided, then no time limit is enforced.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ 'keepfiles',
+ ConfigValue(
+ default=False,
+ domain=bool,
+ description=(
+ """
+ Export subproblems with a non-acceptable termination status
+ for debugging purposes.
+ If True is provided, then the argument
+ `subproblem_file_directory` must also be specified.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ 'tee',
+ ConfigValue(
+ default=False,
+ domain=bool,
+ description="Output subordinate solver logs for all subproblems.",
+ ),
+ )
+ CONFIG.declare(
+ 'load_solution',
+ ConfigValue(
+ default=True,
+ domain=bool,
+ description=(
+ """
+ Load final solution(s) found by PyROS to the deterministic
+ model provided.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ 'symbolic_solver_labels',
+ ConfigValue(
+ default=False,
+ domain=bool,
+ description=(
+ """
+ True to ensure the component names given to the
+ subordinate solvers for every subproblem reflect
+ the names of the corresponding Pyomo modeling components,
+ False otherwise.
+ """
+ ),
+ ),
+ )
+
+ # ================================================
+ # === Required User Inputs
+ # ================================================
+ CONFIG.declare(
+ "first_stage_variables",
+ ConfigValue(
+ default=[],
+ domain=InputDataStandardizer(Var, VarData, allow_repeats=False),
+ description="First-stage (or design) variables.",
+ visibility=1,
+ ),
+ )
+ CONFIG.declare(
+ "second_stage_variables",
+ ConfigValue(
+ default=[],
+ domain=InputDataStandardizer(Var, VarData, allow_repeats=False),
+ description="Second-stage (or control) variables.",
+ visibility=1,
+ ),
+ )
+ CONFIG.declare(
+ "uncertain_params",
+ ConfigValue(
+ default=[],
+ domain=InputDataStandardizer(
+ ctype=Param,
+ cdatatype=ParamData,
+ ctype_validator=mutable_param_validator,
+ allow_repeats=False,
+ ),
+ description=(
+ """
+ Uncertain model parameters.
+ The `mutable` attribute for all uncertain parameter
+ objects should be set to True.
+ """
+ ),
+ visibility=1,
+ ),
+ )
+ CONFIG.declare(
+ "uncertainty_set",
+ ConfigValue(
+ default=None,
+ domain=IsInstance(UncertaintySet),
+ description=(
+ """
+ Uncertainty set against which the
+ final solution(s) returned by PyROS should be certified
+ to be robust.
+ """
+ ),
+ visibility=1,
+ ),
+ )
+ CONFIG.declare(
+ "local_solver",
+ ConfigValue(
+ default=None,
+ domain=SolverResolvable(solver_desc="local solver", require_available=True),
+ description="Subordinate local NLP solver.",
+ visibility=1,
+ ),
+ )
+ CONFIG.declare(
+ "global_solver",
+ ConfigValue(
+ default=None,
+ domain=SolverResolvable(
+ solver_desc="global solver", require_available=True
+ ),
+ description="Subordinate global NLP solver.",
+ visibility=1,
+ ),
+ )
+ # ================================================
+ # === Optional User Inputs
+ # ================================================
+ CONFIG.declare(
+ "objective_focus",
+ ConfigValue(
+ default=ObjectiveType.nominal,
+ domain=InEnum(ObjectiveType),
+ description=(
+ """
+ Choice of objective focus to optimize in the master problems.
+ Choices are: `ObjectiveType.worst_case`,
+ `ObjectiveType.nominal`.
+ """
+ ),
+ doc=(
+ """
+ Objective focus for the master problems:
+
+ - `ObjectiveType.nominal`:
+ Optimize the objective function subject to the nominal
+ uncertain parameter realization.
+ - `ObjectiveType.worst_case`:
+ Optimize the objective function subject to the worst-case
+ uncertain parameter realization.
+
+ By default, `ObjectiveType.nominal` is chosen.
+
+ A worst-case objective focus is required for certification
+ of robust optimality of the final solution(s) returned
+ by PyROS.
+ If a nominal objective focus is chosen, then only robust
+ feasibility is guaranteed.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "nominal_uncertain_param_vals",
+ ConfigValue(
+ default=[],
+ domain=list,
+ doc=(
+ """
+ Nominal uncertain parameter realization.
+ Entries should be provided in an order consistent with the
+ entries of the argument `uncertain_params`.
+ If an empty list is provided, then the values of the `Param`
+ objects specified through `uncertain_params` are chosen.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "decision_rule_order",
+ ConfigValue(
+ default=0,
+ domain=In([0, 1, 2]),
+ description=(
+ """
+ Order (or degree) of the polynomial decision rule functions
+ used for approximating the adjustability of the second stage
+ variables with respect to the uncertain parameters.
+ """
+ ),
+ doc=(
+ """
+ Order (or degree) of the polynomial decision rule functions
+ for approximating the adjustability of the second stage
+ variables with respect to the uncertain parameters.
+
+ Choices are:
+
+ - 0: static recourse
+ - 1: affine recourse
+ - 2: quadratic recourse
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "solve_master_globally",
+ ConfigValue(
+ default=False,
+ domain=bool,
+ doc=(
+ """
+ True to solve all master problems with the subordinate
+ global solver, False to solve all master problems with
+ the subordinate local solver.
+ Along with a worst-case objective focus
+ (see argument `objective_focus`),
+ solving the master problems to global optimality is required
+ for certification
+ of robust optimality of the final solution(s) returned
+ by PyROS. Otherwise, only robust feasibility is guaranteed.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "max_iter",
+ ConfigValue(
+ default=-1,
+ domain=positive_int_or_minus_one,
+ description=(
+ """
+ Iteration limit. If -1 is provided, then no iteration
+ limit is enforced.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "robust_feasibility_tolerance",
+ ConfigValue(
+ default=1e-4,
+ domain=NonNegativeFloat,
+ description=(
+ """
+ Relative tolerance for assessing maximal inequality
+ constraint violations during the GRCS separation step.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "separation_priority_order",
+ ConfigValue(
+ default={},
+ domain=dict,
+ doc=(
+ """
+ Mapping from model inequality constraint names
+ to positive integers specifying the priorities
+ of their corresponding separation subproblems.
+ A higher integer value indicates a higher priority.
+ Constraints not referenced in the `dict` assume
+ a priority of 0.
+ Separation subproblems are solved in order of decreasing
+ priority.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "progress_logger",
+ ConfigValue(
+ default=default_pyros_solver_logger,
+ domain=logger_domain,
+ doc=(
+ """
+ Logger (or name thereof) used for reporting PyROS solver
+ progress. If `None` or a `str` is provided, then
+ ``progress_logger``
+ is cast to ``logging.getLogger(progress_logger)``.
+ In the default case, `progress_logger` is set to
+ a :class:`pyomo.contrib.pyros.util.PreformattedLogger`
+ object of level ``logging.INFO``.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "backup_local_solvers",
+ ConfigValue(
+ default=[],
+ domain=SolverIterable(
+ solver_desc="backup local solver",
+ require_available=False,
+ filter_by_availability=True,
+ ),
+ doc=(
+ """
+ Additional subordinate local NLP optimizers to invoke
+ in the event the primary local NLP optimizer fails
+ to solve a subproblem to an acceptable termination condition.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "backup_global_solvers",
+ ConfigValue(
+ default=[],
+ domain=SolverIterable(
+ solver_desc="backup global solver",
+ require_available=False,
+ filter_by_availability=True,
+ ),
+ doc=(
+ """
+ Additional subordinate global NLP optimizers to invoke
+ in the event the primary global NLP optimizer fails
+ to solve a subproblem to an acceptable termination condition.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "subproblem_file_directory",
+ ConfigValue(
+ default=None,
+ domain=Path(),
+ description=(
+ """
+ Directory to which to export subproblems not successfully
+ solved to an acceptable termination condition.
+ In the event ``keepfiles=True`` is specified, a str or
+ path-like referring to an existing directory must be
+ provided.
+ """
+ ),
+ ),
+ )
+
+ # ================================================
+ # === Advanced Options
+ # ================================================
+ CONFIG.declare(
+ "bypass_local_separation",
+ ConfigValue(
+ default=False,
+ domain=bool,
+ description=(
+ """
+ This is an advanced option.
+ Solve all separation subproblems with the subordinate global
+ solver(s) only.
+ This option is useful for expediting PyROS
+ in the event that the subordinate global optimizer(s) provided
+ can quickly solve separation subproblems to global optimality.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "bypass_global_separation",
+ ConfigValue(
+ default=False,
+ domain=bool,
+ doc=(
+ """
+ This is an advanced option.
+ Solve all separation subproblems with the subordinate local
+ solver(s) only.
+ If `True` is chosen, then robustness of the final solution(s)
+ returned by PyROS is not guaranteed, and a warning will
+ be issued at termination.
+ This option is useful for expediting PyROS
+ in the event that the subordinate global optimizer provided
+ cannot tractably solve separation subproblems to global
+ optimality.
+ """
+ ),
+ ),
+ )
+ CONFIG.declare(
+ "p_robustness",
+ ConfigValue(
+ default={},
+ domain=dict,
+ doc=(
+ """
+ This is an advanced option.
+ Add p-robustness constraints to all master subproblems.
+ If an empty dict is provided, then p-robustness constraints
+ are not added.
+ Otherwise, the dict must map a `str` of value ``'rho'``
+ to a non-negative `float`. PyROS automatically
+ specifies ``1 + p_robustness['rho']``
+ as an upper bound for the ratio of the
+ objective function value under any PyROS-sampled uncertain
+ parameter realization to the objective function under
+ the nominal parameter realization.
+ """
+ ),
+ visibility=1,
+ ),
+ )
+
+ return CONFIG
diff --git a/pyomo/contrib/pyros/master_problem_methods.py b/pyomo/contrib/pyros/master_problem_methods.py
index abf02809396..2af38c1d582 100644
--- a/pyomo/contrib/pyros/master_problem_methods.py
+++ b/pyomo/contrib/pyros/master_problem_methods.py
@@ -27,6 +27,7 @@
from pyomo.core.expr import value
from pyomo.core.base.set_types import NonNegativeIntegers, NonNegativeReals
from pyomo.contrib.pyros.util import (
+ call_solver,
selective_clone,
ObjectiveType,
pyrosTerminationCondition,
@@ -239,31 +240,18 @@ def solve_master_feasibility_problem(model_data, config):
else:
solver = config.local_solver
- timer = TicTocTimer()
- orig_setting, custom_setting_present = adjust_solver_time_settings(
- model_data.timing, solver, config
- )
- model_data.timing.start_timer("main.master_feasibility")
- timer.tic(msg=None)
- try:
- results = solver.solve(model, tee=config.tee, load_solutions=False)
- except ApplicationError:
- # account for possible external subsolver errors
- # (such as segmentation faults, function evaluation
- # errors, etc.)
- config.progress_logger.error(
+ results = call_solver(
+ model=model,
+ solver=solver,
+ config=config,
+ timing_obj=model_data.timing,
+ timer_name="main.master_feasibility",
+ err_msg=(
f"Optimizer {repr(solver)} encountered exception "
"attempting to solve master feasibility problem in iteration "
f"{model_data.iteration}."
- )
- raise
- else:
- setattr(results.solver, TIC_TOC_SOLVE_TIME_ATTR, timer.toc(msg=None))
- model_data.timing.stop_timer("main.master_feasibility")
- finally:
- revert_solver_max_time_adjustment(
- solver, orig_setting, custom_setting_present, config
- )
+ ),
+ )
feasible_terminations = {
tc.optimal,
@@ -398,10 +386,17 @@ def construct_dr_polishing_problem(model_data, config):
all_ub_cons.append(polishing_absolute_value_ub_cons)
# get monomials; ensure second-stage variable term excluded
+ #
+ # the dr_eq is a linear sum where the first term is the
+ # second-stage variable: the remainder of the terms will be
+ # either MonomialTermExpressions or bare VarData
dr_expr_terms = dr_eq.body.args[:-1]
for dr_eq_term in dr_expr_terms:
- dr_var_in_term = dr_eq_term.args[-1]
+ if dr_eq_term.is_expression_type():
+ dr_var_in_term = dr_eq_term.args[-1]
+ else:
+ dr_var_in_term = dr_eq_term
dr_var_in_term_idx = dr_var_in_term.index()
# get corresponding polishing variable
@@ -475,28 +470,18 @@ def minimize_dr_vars(model_data, config):
config.progress_logger.debug(f" Initial DR norm: {value(polishing_obj)}")
# === Solve the polishing model
- timer = TicTocTimer()
- orig_setting, custom_setting_present = adjust_solver_time_settings(
- model_data.timing, solver, config
- )
- model_data.timing.start_timer("main.dr_polishing")
- timer.tic(msg=None)
- try:
- results = solver.solve(polishing_model, tee=config.tee, load_solutions=False)
- except ApplicationError:
- config.progress_logger.error(
+ results = call_solver(
+ model=polishing_model,
+ solver=solver,
+ config=config,
+ timing_obj=model_data.timing,
+ timer_name="main.dr_polishing",
+ err_msg=(
f"Optimizer {repr(solver)} encountered an exception "
"attempting to solve decision rule polishing problem "
f"in iteration {model_data.iteration}"
- )
- raise
- else:
- setattr(results.solver, TIC_TOC_SOLVE_TIME_ATTR, timer.toc(msg=None))
- model_data.timing.stop_timer("main.dr_polishing")
- finally:
- revert_solver_max_time_adjustment(
- solver, orig_setting, custom_setting_present, config
- )
+ ),
+ )
# interested in the time and termination status for debugging
# purposes
@@ -719,7 +704,6 @@ def solver_call_master(model_data, config, solver, solve_data):
solve_mode = "global" if config.solve_master_globally else "local"
config.progress_logger.debug("Solving master problem")
- timer = TicTocTimer()
for idx, opt in enumerate(solvers):
if idx > 0:
config.progress_logger.warning(
@@ -727,35 +711,18 @@ def solver_call_master(model_data, config, solver, solve_data):
f"(solver {idx + 1} of {len(solvers)}) for "
f"master problem of iteration {model_data.iteration}."
)
- orig_setting, custom_setting_present = adjust_solver_time_settings(
- model_data.timing, opt, config
- )
- model_data.timing.start_timer("main.master")
- timer.tic(msg=None)
- try:
- results = opt.solve(
- nlp_model,
- tee=config.tee,
- load_solutions=False,
- symbolic_solver_labels=True,
- )
- except ApplicationError:
- # account for possible external subsolver errors
- # (such as segmentation faults, function evaluation
- # errors, etc.)
- config.progress_logger.error(
+ results = call_solver(
+ model=nlp_model,
+ solver=opt,
+ config=config,
+ timing_obj=model_data.timing,
+ timer_name="main.master",
+ err_msg=(
f"Optimizer {repr(opt)} ({idx + 1} of {len(solvers)}) "
"encountered exception attempting to "
f"solve master problem in iteration {model_data.iteration}"
- )
- raise
- else:
- setattr(results.solver, TIC_TOC_SOLVE_TIME_ATTR, timer.toc(msg=None))
- model_data.timing.stop_timer("main.master")
- finally:
- revert_solver_max_time_adjustment(
- solver, orig_setting, custom_setting_present, config
- )
+ ),
+ )
optimal_termination = check_optimal_termination(results)
infeasible = results.solver.termination_condition == tc.infeasible
diff --git a/pyomo/contrib/pyros/pyros.py b/pyomo/contrib/pyros/pyros.py
index 475eb424c0b..582233c4a56 100644
--- a/pyomo/contrib/pyros/pyros.py
+++ b/pyomo/contrib/pyros/pyros.py
@@ -11,29 +11,24 @@
# pyros.py: Generalized Robust Cutting-Set Algorithm for Pyomo
import logging
-from textwrap import indent, dedent, wrap
-from pyomo.common.collections import Bunch, ComponentSet
-from pyomo.common.config import ConfigDict, ConfigValue, In, NonNegativeFloat
+from pyomo.common.config import document_kwargs_from_configdict
from pyomo.core.base.block import Block
from pyomo.core.expr import value
-from pyomo.core.base.var import Var, _VarData
-from pyomo.core.base.param import Param, _ParamData
-from pyomo.core.base.objective import Objective, maximize
-from pyomo.contrib.pyros.util import a_logger, time_code, get_main_elapsed_time
+from pyomo.core.base.var import Var
+from pyomo.core.base.objective import Objective
+from pyomo.contrib.pyros.util import time_code
from pyomo.common.modeling import unique_component_name
from pyomo.opt import SolverFactory
+from pyomo.contrib.pyros.config import pyros_config, logger_domain
from pyomo.contrib.pyros.util import (
- model_is_valid,
recast_to_min_obj,
add_decision_rule_constraints,
add_decision_rule_variables,
load_final_solution,
pyrosTerminationCondition,
- ValidEnum,
ObjectiveType,
- validate_uncertainty_set,
identify_objective_functions,
- validate_kwarg_inputs,
+ validate_pyros_inputs,
transform_to_standard_form,
turn_bounds_to_constraints,
replace_uncertain_bounds_with_constraints,
@@ -43,13 +38,12 @@
)
from pyomo.contrib.pyros.solve_data import ROSolveResults
from pyomo.contrib.pyros.pyros_algorithm_methods import ROSolver_iterative_solve
-from pyomo.contrib.pyros.uncertainty_sets import uncertainty_sets
from pyomo.core.base import Constraint
from datetime import datetime
-__version__ = "1.2.9"
+__version__ = "1.2.11"
default_pyros_solver_logger = setup_pyros_logger()
@@ -85,590 +79,6 @@ def _get_pyomo_version_info():
return {"Pyomo version": pyomo_version, "Commit hash": commit_hash}
-def NonNegIntOrMinusOne(obj):
- '''
- if obj is a non-negative int, return the non-negative int
- if obj is -1, return -1
- else, error
- '''
- ans = int(obj)
- if ans != float(obj) or (ans < 0 and ans != -1):
- raise ValueError("Expected non-negative int, but received %s" % (obj,))
- return ans
-
-
-def PositiveIntOrMinusOne(obj):
- '''
- if obj is a positive int, return the int
- if obj is -1, return -1
- else, error
- '''
- ans = int(obj)
- if ans != float(obj) or (ans <= 0 and ans != -1):
- raise ValueError("Expected positive int, but received %s" % (obj,))
- return ans
-
-
-class SolverResolvable(object):
- def __call__(self, obj):
- '''
- if obj is a string, return the Solver object for that solver name
- if obj is a Solver object, return a copy of the Solver
- if obj is a list, and each element of list is solver resolvable, return list of solvers
- '''
- if isinstance(obj, str):
- return SolverFactory(obj.lower())
- elif callable(getattr(obj, "solve", None)):
- return obj
- elif isinstance(obj, list):
- return [self(o) for o in obj]
- else:
- raise ValueError(
- "Expected a Pyomo solver or string object, "
- "instead received {1}".format(obj.__class__.__name__)
- )
-
-
-class InputDataStandardizer(object):
- def __init__(self, ctype, cdatatype):
- self.ctype = ctype
- self.cdatatype = cdatatype
-
- def __call__(self, obj):
- if isinstance(obj, self.ctype):
- return list(obj.values())
- if isinstance(obj, self.cdatatype):
- return [obj]
- ans = []
- for item in obj:
- ans.extend(self.__call__(item))
- for _ in ans:
- assert isinstance(_, self.cdatatype)
- return ans
-
-
-class PyROSConfigValue(ConfigValue):
- """
- Subclass of ``common.collections.ConfigValue``,
- with a few attributes added to facilitate documentation
- of the PyROS solver.
- An instance of this class is used for storing and
- documenting an argument to the PyROS solver.
-
- Attributes
- ----------
- is_optional : bool
- Argument is optional.
- document_default : bool, optional
- Document the default value of the argument
- in any docstring generated from this instance,
- or a `ConfigDict` object containing this instance.
- dtype_spec_str : None or str, optional
- String documenting valid types for this argument.
- If `None` is provided, then this string is automatically
- determined based on the `domain` argument to the
- constructor.
-
- NOTES
- -----
- Cleaner way to access protected attributes
- (particularly _doc, _description) inherited from ConfigValue?
-
- """
-
- def __init__(
- self,
- default=None,
- domain=None,
- description=None,
- doc=None,
- visibility=0,
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ):
- """Initialize self (see class docstring)."""
-
- # initialize base class attributes
- super(self.__class__, self).__init__(
- default=default,
- domain=domain,
- description=description,
- doc=doc,
- visibility=visibility,
- )
-
- self.is_optional = is_optional
- self.document_default = document_default
-
- if dtype_spec_str is None:
- self.dtype_spec_str = self.domain_name()
- # except AttributeError:
- # self.dtype_spec_str = repr(self._domain)
- else:
- self.dtype_spec_str = dtype_spec_str
-
-
-def pyros_config():
- CONFIG = ConfigDict('PyROS')
-
- # ================================================
- # === Options common to all solvers
- # ================================================
- CONFIG.declare(
- 'time_limit',
- PyROSConfigValue(
- default=None,
- domain=NonNegativeFloat,
- doc=(
- """
- Wall time limit for the execution of the PyROS solver
- in seconds (including time spent by subsolvers).
- If `None` is provided, then no time limit is enforced.
- """
- ),
- is_optional=True,
- document_default=False,
- dtype_spec_str="None or NonNegativeFloat",
- ),
- )
- CONFIG.declare(
- 'keepfiles',
- PyROSConfigValue(
- default=False,
- domain=bool,
- description=(
- """
- Export subproblems with a non-acceptable termination status
- for debugging purposes.
- If True is provided, then the argument `subproblem_file_directory`
- must also be specified.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
- CONFIG.declare(
- 'tee',
- PyROSConfigValue(
- default=False,
- domain=bool,
- description="Output subordinate solver logs for all subproblems.",
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
- CONFIG.declare(
- 'load_solution',
- PyROSConfigValue(
- default=True,
- domain=bool,
- description=(
- """
- Load final solution(s) found by PyROS to the deterministic model
- provided.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
-
- # ================================================
- # === Required User Inputs
- # ================================================
- CONFIG.declare(
- "first_stage_variables",
- PyROSConfigValue(
- default=[],
- domain=InputDataStandardizer(Var, _VarData),
- description="First-stage (or design) variables.",
- is_optional=False,
- dtype_spec_str="list of Var",
- ),
- )
- CONFIG.declare(
- "second_stage_variables",
- PyROSConfigValue(
- default=[],
- domain=InputDataStandardizer(Var, _VarData),
- description="Second-stage (or control) variables.",
- is_optional=False,
- dtype_spec_str="list of Var",
- ),
- )
- CONFIG.declare(
- "uncertain_params",
- PyROSConfigValue(
- default=[],
- domain=InputDataStandardizer(Param, _ParamData),
- description=(
- """
- Uncertain model parameters.
- The `mutable` attribute for all uncertain parameter
- objects should be set to True.
- """
- ),
- is_optional=False,
- dtype_spec_str="list of Param",
- ),
- )
- CONFIG.declare(
- "uncertainty_set",
- PyROSConfigValue(
- default=None,
- domain=uncertainty_sets,
- description=(
- """
- Uncertainty set against which the
- final solution(s) returned by PyROS should be certified
- to be robust.
- """
- ),
- is_optional=False,
- dtype_spec_str="UncertaintySet",
- ),
- )
- CONFIG.declare(
- "local_solver",
- PyROSConfigValue(
- default=None,
- domain=SolverResolvable(),
- description="Subordinate local NLP solver.",
- is_optional=False,
- dtype_spec_str="Solver",
- ),
- )
- CONFIG.declare(
- "global_solver",
- PyROSConfigValue(
- default=None,
- domain=SolverResolvable(),
- description="Subordinate global NLP solver.",
- is_optional=False,
- dtype_spec_str="Solver",
- ),
- )
- # ================================================
- # === Optional User Inputs
- # ================================================
- CONFIG.declare(
- "objective_focus",
- PyROSConfigValue(
- default=ObjectiveType.nominal,
- domain=ValidEnum(ObjectiveType),
- description=(
- """
- Choice of objective focus to optimize in the master problems.
- Choices are: `ObjectiveType.worst_case`,
- `ObjectiveType.nominal`.
- """
- ),
- doc=(
- """
- Objective focus for the master problems:
-
- - `ObjectiveType.nominal`:
- Optimize the objective function subject to the nominal
- uncertain parameter realization.
- - `ObjectiveType.worst_case`:
- Optimize the objective function subject to the worst-case
- uncertain parameter realization.
-
- By default, `ObjectiveType.nominal` is chosen.
-
- A worst-case objective focus is required for certification
- of robust optimality of the final solution(s) returned
- by PyROS.
- If a nominal objective focus is chosen, then only robust
- feasibility is guaranteed.
- """
- ),
- is_optional=True,
- document_default=False,
- dtype_spec_str="ObjectiveType",
- ),
- )
- CONFIG.declare(
- "nominal_uncertain_param_vals",
- PyROSConfigValue(
- default=[],
- domain=list,
- doc=(
- """
- Nominal uncertain parameter realization.
- Entries should be provided in an order consistent with the
- entries of the argument `uncertain_params`.
- If an empty list is provided, then the values of the `Param`
- objects specified through `uncertain_params` are chosen.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str="list of float",
- ),
- )
- CONFIG.declare(
- "decision_rule_order",
- PyROSConfigValue(
- default=0,
- domain=In([0, 1, 2]),
- description=(
- """
- Order (or degree) of the polynomial decision rule functions used
- for approximating the adjustability of the second stage
- variables with respect to the uncertain parameters.
- """
- ),
- doc=(
- """
- Order (or degree) of the polynomial decision rule functions used
- for approximating the adjustability of the second stage
- variables with respect to the uncertain parameters.
-
- Choices are:
-
- - 0: static recourse
- - 1: affine recourse
- - 2: quadratic recourse
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
- CONFIG.declare(
- "solve_master_globally",
- PyROSConfigValue(
- default=False,
- domain=bool,
- doc=(
- """
- True to solve all master problems with the subordinate
- global solver, False to solve all master problems with
- the subordinate local solver.
- Along with a worst-case objective focus
- (see argument `objective_focus`),
- solving the master problems to global optimality is required
- for certification
- of robust optimality of the final solution(s) returned
- by PyROS. Otherwise, only robust feasibility is guaranteed.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
- CONFIG.declare(
- "max_iter",
- PyROSConfigValue(
- default=-1,
- domain=PositiveIntOrMinusOne,
- description=(
- """
- Iteration limit. If -1 is provided, then no iteration
- limit is enforced.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str="int",
- ),
- )
- CONFIG.declare(
- "robust_feasibility_tolerance",
- PyROSConfigValue(
- default=1e-4,
- domain=NonNegativeFloat,
- description=(
- """
- Relative tolerance for assessing maximal inequality
- constraint violations during the GRCS separation step.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
- CONFIG.declare(
- "separation_priority_order",
- PyROSConfigValue(
- default={},
- domain=dict,
- doc=(
- """
- Mapping from model inequality constraint names
- to positive integers specifying the priorities
- of their corresponding separation subproblems.
- A higher integer value indicates a higher priority.
- Constraints not referenced in the `dict` assume
- a priority of 0.
- Separation subproblems are solved in order of decreasing
- priority.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
- CONFIG.declare(
- "progress_logger",
- PyROSConfigValue(
- default=default_pyros_solver_logger,
- domain=a_logger,
- doc=(
- """
- Logger (or name thereof) used for reporting PyROS solver
- progress. If a `str` is specified, then ``progress_logger``
- is cast to ``logging.getLogger(progress_logger)``.
- In the default case, `progress_logger` is set to
- a :class:`pyomo.contrib.pyros.util.PreformattedLogger`
- object of level ``logging.INFO``.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str="str or logging.Logger",
- ),
- )
- CONFIG.declare(
- "backup_local_solvers",
- PyROSConfigValue(
- default=[],
- domain=SolverResolvable(),
- doc=(
- """
- Additional subordinate local NLP optimizers to invoke
- in the event the primary local NLP optimizer fails
- to solve a subproblem to an acceptable termination condition.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str="list of Solver",
- ),
- )
- CONFIG.declare(
- "backup_global_solvers",
- PyROSConfigValue(
- default=[],
- domain=SolverResolvable(),
- doc=(
- """
- Additional subordinate global NLP optimizers to invoke
- in the event the primary global NLP optimizer fails
- to solve a subproblem to an acceptable termination condition.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str="list of Solver",
- ),
- )
- CONFIG.declare(
- "subproblem_file_directory",
- PyROSConfigValue(
- default=None,
- domain=str,
- description=(
- """
- Directory to which to export subproblems not successfully
- solved to an acceptable termination condition.
- In the event ``keepfiles=True`` is specified, a str or
- path-like referring to an existing directory must be
- provided.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str="None, str, or path-like",
- ),
- )
-
- # ================================================
- # === Advanced Options
- # ================================================
- CONFIG.declare(
- "bypass_local_separation",
- PyROSConfigValue(
- default=False,
- domain=bool,
- description=(
- """
- This is an advanced option.
- Solve all separation subproblems with the subordinate global
- solver(s) only.
- This option is useful for expediting PyROS
- in the event that the subordinate global optimizer(s) provided
- can quickly solve separation subproblems to global optimality.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
- CONFIG.declare(
- "bypass_global_separation",
- PyROSConfigValue(
- default=False,
- domain=bool,
- doc=(
- """
- This is an advanced option.
- Solve all separation subproblems with the subordinate local
- solver(s) only.
- If `True` is chosen, then robustness of the final solution(s)
- returned by PyROS is not guaranteed, and a warning will
- be issued at termination.
- This option is useful for expediting PyROS
- in the event that the subordinate global optimizer provided
- cannot tractably solve separation subproblems to global
- optimality.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
- CONFIG.declare(
- "p_robustness",
- PyROSConfigValue(
- default={},
- domain=dict,
- doc=(
- """
- This is an advanced option.
- Add p-robustness constraints to all master subproblems.
- If an empty dict is provided, then p-robustness constraints
- are not added.
- Otherwise, the dict must map a `str` of value ``'rho'``
- to a non-negative `float`. PyROS automatically
- specifies ``1 + p_robustness['rho']``
- as an upper bound for the ratio of the
- objective function value under any PyROS-sampled uncertain
- parameter realization to the objective function under
- the nominal parameter realization.
- """
- ),
- is_optional=True,
- document_default=True,
- dtype_spec_str=None,
- ),
- )
-
- return CONFIG
-
-
@SolverFactory.register(
"pyros",
doc="Robust optimization (RO) solver implementing "
@@ -836,6 +246,46 @@ def _log_config(self, logger, config, exclude_options=None, **log_kwargs):
logger.log(msg=f" {key}={val!r}", **log_kwargs)
logger.log(msg="-" * self._LOG_LINE_LENGTH, **log_kwargs)
+ def _resolve_and_validate_pyros_args(self, model, **kwds):
+ """
+ Resolve and validate arguments to ``self.solve()``.
+
+ Parameters
+ ----------
+ model : ConcreteModel
+ Deterministic model object passed to ``self.solve()``.
+ **kwds : dict
+ All other arguments to ``self.solve()``.
+
+ Returns
+ -------
+ config : ConfigDict
+ Standardized arguments.
+
+ Note
+ ----
+ This method can be broken down into three steps:
+
+ 1. Cast arguments to ConfigDict. Argument-wise
+ validation is performed automatically.
+ Note that arguments specified directly take
+ precedence over arguments specified indirectly
+ through direct argument 'options'.
+ 2. Inter-argument validation.
+ """
+ config = self.CONFIG(kwds.pop("options", {}))
+ config = config(kwds)
+ state_vars = validate_pyros_inputs(model, config)
+
+ return config, state_vars
+
+ @document_kwargs_from_configdict(
+ config=CONFIG,
+ section="Keyword Arguments",
+ indent_spacing=4,
+ width=72,
+ visibility=0,
+ )
def solve(
self,
model,
@@ -853,21 +303,25 @@ def solve(
----------
model: ConcreteModel
The deterministic model.
- first_stage_variables: list of Var
+ first_stage_variables: VarData, Var, or iterable of VarData/Var
First-stage model variables (or design variables).
- second_stage_variables: list of Var
+ second_stage_variables: VarData, Var, or iterable of VarData/Var
Second-stage model variables (or control variables).
- uncertain_params: list of Param
+ uncertain_params: ParamData, Param, or iterable of ParamData/Param
Uncertain model parameters.
- The `mutable` attribute for every uncertain parameter
- objects must be set to True.
+ The `mutable` attribute for all uncertain parameter objects
+ must be set to True.
uncertainty_set: UncertaintySet
Uncertainty set against which the solution(s) returned
will be confirmed to be robust.
- local_solver: Solver
+ local_solver: str or solver type
Subordinate local NLP solver.
- global_solver: Solver
+ If a `str` is passed, then the `str` is cast to
+ ``SolverFactory(local_solver)``.
+ global_solver: str or solver type
Subordinate global NLP solver.
+ If a `str` is passed, then the `str` is cast to
+ ``SolverFactory(global_solver)``.
Returns
-------
@@ -875,56 +329,41 @@ def solve(
Summary of PyROS termination outcome.
"""
-
- # === Add the explicit arguments to the config
- config = self.CONFIG(kwds.pop('options', {}))
- config.first_stage_variables = first_stage_variables
- config.second_stage_variables = second_stage_variables
- config.uncertain_params = uncertain_params
- config.uncertainty_set = uncertainty_set
- config.local_solver = local_solver
- config.global_solver = global_solver
-
- dev_options = kwds.pop('dev_options', {})
- config.set_value(kwds)
- config.set_value(dev_options)
-
- model = model
-
- # === Validate kwarg inputs
- validate_kwarg_inputs(model, config)
-
- # === Validate ability of grcs RO solver to handle this model
- if not model_is_valid(model):
- raise AttributeError(
- "This model structure is not currently handled by the ROSolver."
- )
-
- # === Define nominal point if not specified
- if len(config.nominal_uncertain_param_vals) == 0:
- config.nominal_uncertain_param_vals = list(
- p.value for p in config.uncertain_params
- )
- elif len(config.nominal_uncertain_param_vals) != len(config.uncertain_params):
- raise AttributeError(
- "The nominal_uncertain_param_vals list must be the same length"
- "as the uncertain_params list"
- )
-
- # === Create data containers
model_data = ROSolveResults()
- model_data.timing = Bunch()
-
- # === Start timer, run the algorithm
model_data.timing = TimingData()
with time_code(
timing_data_obj=model_data.timing,
code_block_name="main",
is_main_timer=True,
):
- # output intro and disclaimer
- self._log_intro(logger=config.progress_logger, level=logging.INFO)
- self._log_disclaimer(logger=config.progress_logger, level=logging.INFO)
+ kwds.update(
+ dict(
+ first_stage_variables=first_stage_variables,
+ second_stage_variables=second_stage_variables,
+ uncertain_params=uncertain_params,
+ uncertainty_set=uncertainty_set,
+ local_solver=local_solver,
+ global_solver=global_solver,
+ )
+ )
+
+ # we want to log the intro and disclaimer in
+ # advance of assembling the config.
+ # this helps clarify to the user that any
+ # messages logged during assembly of the config
+ # were, in fact, logged after PyROS was initiated
+ progress_logger = logger_domain(
+ kwds.get(
+ "progress_logger",
+ kwds.get("options", dict()).get(
+ "progress_logger", default_pyros_solver_logger
+ ),
+ )
+ )
+ self._log_intro(logger=progress_logger, level=logging.INFO)
+ self._log_disclaimer(logger=progress_logger, level=logging.INFO)
+
+ config, state_vars = self._resolve_and_validate_pyros_args(model, **kwds)
self._log_config(
logger=config.progress_logger,
config=config,
@@ -940,15 +379,13 @@ def solve(
util = Block(concrete=True)
util.first_stage_variables = config.first_stage_variables
util.second_stage_variables = config.second_stage_variables
+ util.state_vars = state_vars
util.uncertain_params = config.uncertain_params
model_data.util_block = unique_component_name(model, 'util')
model.add_component(model_data.util_block, util)
# Note: model.component(model_data.util_block) is util
- # === Validate uncertainty set happens here, requires util block for Cardinality and FactorModel sets
- validate_uncertainty_set(config=config)
-
# === Leads to a logger warning here for inactive obj when cloning
model_data.original_model = model
# === For keeping track of variables after cloning
@@ -990,22 +427,10 @@ def solve(
# === Move bounds on control variables to explicit ineq constraints
wm_util = model_data.working_model
- # === Every non-fixed variable that is neither first-stage
- # nor second-stage is taken to be a state variable
- fsv = ComponentSet(model_data.working_model.util.first_stage_variables)
- ssv = ComponentSet(model_data.working_model.util.second_stage_variables)
- sv = ComponentSet()
- model_data.working_model.util.state_vars = []
- for v in model_data.working_model.component_data_objects(Var):
- if not v.fixed and v not in fsv | ssv | sv:
- model_data.working_model.util.state_vars.append(v)
- sv.add(v)
-
- # Bounds on second stage variables and state variables are separation objectives,
- # they are brought in this was as explicit constraints
+ # cast bounds on second-stage and state variables to
+ # explicit constraints for separation objectives
for c in model_data.working_model.util.second_stage_variables:
turn_bounds_to_constraints(c, wm_util, config)
-
for c in model_data.working_model.util.state_vars:
turn_bounds_to_constraints(c, wm_util, config)
@@ -1085,131 +510,3 @@ def solve(
config.progress_logger.info("=" * self._LOG_LINE_LENGTH)
return return_soln
-
-
-def _generate_filtered_docstring():
- """
- Add Numpy-style 'Keyword arguments' section to `PyROS.solve()`
- docstring.
- """
- cfg = PyROS.CONFIG()
-
- # mandatory args already documented
- exclude_args = [
- "first_stage_variables",
- "second_stage_variables",
- "uncertain_params",
- "uncertainty_set",
- "local_solver",
- "global_solver",
- ]
-
- indent_by = 8
- width = 72
- before = PyROS.solve.__doc__
- section_name = "Keyword Arguments"
-
- indent_str = ' ' * indent_by
- wrap_width = width - indent_by
- cfg = pyros_config()
-
- arg_docs = []
-
- def wrap_doc(doc, indent_by, width):
- """
- Wrap a string, accounting for paragraph
- breaks ('\n\n') and bullet points (paragraphs
- which, when dedented, are such that each line
- starts with '- ' or ' ').
- """
- paragraphs = doc.split("\n\n")
- wrapped_pars = []
- for par in paragraphs:
- lines = dedent(par).split("\n")
- has_bullets = all(
- line.startswith("- ") or line.startswith(" ")
- for line in lines
- if line != ""
- )
- if has_bullets:
- # obtain strings of each bullet point
- # (dedented, bullet dash and bullet indent removed)
- bullet_groups = []
- new_group = False
- group = ""
- for line in lines:
- new_group = line.startswith("- ")
- if new_group:
- bullet_groups.append(group)
- group = ""
- new_line = line[2:]
- group += f"{new_line}\n"
- if group != "":
- # ensure last bullet not skipped
- bullet_groups.append(group)
-
- # first entry is just ''; remove
- bullet_groups = bullet_groups[1:]
-
- # wrap each bullet point, then add bullet
- # and indents as necessary
- wrapped_groups = []
- for group in bullet_groups:
- wrapped_groups.append(
- "\n".join(
- f"{'- ' if idx == 0 else ' '}{line}"
- for idx, line in enumerate(
- wrap(group, width - 2 - indent_by)
- )
- )
- )
-
- # now combine bullets into single 'paragraph'
- wrapped_pars.append(
- indent("\n".join(wrapped_groups), prefix=' ' * indent_by)
- )
- else:
- wrapped_pars.append(
- indent(
- "\n".join(wrap(dedent(par), width=width - indent_by)),
- prefix=' ' * indent_by,
- )
- )
-
- return "\n\n".join(wrapped_pars)
-
- section_header = indent(f"{section_name}\n" + "-" * len(section_name), indent_str)
- for key, itm in cfg._data.items():
- if key in exclude_args:
- continue
- arg_name = key
- arg_dtype = itm.dtype_spec_str
-
- if itm.is_optional:
- if itm.document_default:
- optional_str = f", default={repr(itm._default)}"
- else:
- optional_str = ", optional"
- else:
- optional_str = ""
-
- arg_header = f"{indent_str}{arg_name} : {arg_dtype}{optional_str}"
-
- # dedented_doc_str = dedent(itm.doc).replace("\n", ' ').strip()
- if itm._doc is not None:
- raw_arg_desc = itm._doc
- else:
- raw_arg_desc = itm._description
-
- arg_description = wrap_doc(
- raw_arg_desc, width=wrap_width, indent_by=indent_by + 4
- )
-
- arg_docs.append(f"{arg_header}\n{arg_description}")
-
- kwargs_section_doc = "\n".join([section_header] + arg_docs)
-
- return f"{before}\n{kwargs_section_doc}\n"
-
-
-PyROS.solve.__doc__ = _generate_filtered_docstring()
diff --git a/pyomo/contrib/pyros/pyros_algorithm_methods.py b/pyomo/contrib/pyros/pyros_algorithm_methods.py
index 45b652447ff..cfb57b08c7f 100644
--- a/pyomo/contrib/pyros/pyros_algorithm_methods.py
+++ b/pyomo/contrib/pyros/pyros_algorithm_methods.py
@@ -26,8 +26,9 @@
)
from pyomo.contrib.pyros.util import get_main_elapsed_time, coefficient_matching
from pyomo.core.base import value
+from pyomo.core.expr import MonomialTermExpression
from pyomo.common.collections import ComponentSet, ComponentMap
-from pyomo.core.base.var import _VarData as VarData
+from pyomo.core.base.var import VarData as VarData
from itertools import chain
from pyomo.common.dependencies import numpy as np
@@ -69,14 +70,17 @@ def get_dr_var_to_scaled_expr_map(
ssv_dr_eq_zip = zip(second_stage_vars, decision_rule_eqns)
for ssv_idx, (ssv, dr_eq) in enumerate(ssv_dr_eq_zip):
for term in dr_eq.body.args:
- is_ssv_term = (
- isinstance(term.args[0], int)
- and term.args[0] == -1
- and isinstance(term.args[1], VarData)
- )
- if not is_ssv_term:
- dr_var = term.args[1]
- var_to_scaled_expr_map[dr_var] = term
+ if isinstance(term, MonomialTermExpression):
+ is_ssv_term = (
+ isinstance(term.args[0], int)
+ and term.args[0] == -1
+ and isinstance(term.args[1], VarData)
+ )
+ if not is_ssv_term:
+ dr_var = term.args[1]
+ var_to_scaled_expr_map[dr_var] = term
+ elif isinstance(term, VarData):
+ var_to_scaled_expr_map[term] = MonomialTermExpression((1, term))
return var_to_scaled_expr_map
@@ -805,7 +809,7 @@ def ROSolver_iterative_solve(model_data, config):
len(scaled_violations) == len(separation_model.util.performance_constraints)
and not separation_results.subsolver_error
and not separation_results.time_out
- )
+ ) or separation_results.all_discrete_scenarios_exhausted
iter_log_record = IterationLogRecord(
iteration=k,
diff --git a/pyomo/contrib/pyros/separation_problem_methods.py b/pyomo/contrib/pyros/separation_problem_methods.py
index 084b0442ae6..18d0925bab0 100644
--- a/pyomo/contrib/pyros/separation_problem_methods.py
+++ b/pyomo/contrib/pyros/separation_problem_methods.py
@@ -18,7 +18,6 @@
from pyomo.core.base import Var, Param
from pyomo.common.collections import ComponentSet, ComponentMap
from pyomo.common.dependencies import numpy as np
-from pyomo.contrib.pyros.util import ObjectiveType, get_time_from_solver
from pyomo.contrib.pyros.solve_data import (
DiscreteSeparationSolveCallResults,
SeparationSolveCallResults,
@@ -37,9 +36,11 @@
from pyomo.contrib.pyros.util import ABS_CON_CHECK_FEAS_TOL
from pyomo.common.timing import TicTocTimer
from pyomo.contrib.pyros.util import (
- TIC_TOC_SOLVE_TIME_ATTR,
adjust_solver_time_settings,
+ call_solver,
+ ObjectiveType,
revert_solver_max_time_adjustment,
+ TIC_TOC_SOLVE_TIME_ATTR,
)
import os
from copy import deepcopy
@@ -649,6 +650,7 @@ def perform_separation_loop(model_data, config, solve_globally):
solver_call_results=ComponentMap(),
solved_globally=solve_globally,
worst_case_perf_con=None,
+ all_discrete_scenarios_exhausted=True,
)
perf_con_to_maximize = sorted_priority_groups[
@@ -1069,6 +1071,7 @@ def solver_call_separation(
separation_obj.activate()
+ solve_mode_adverb = "globally" if solve_globally else "locally"
solve_call_results = SeparationSolveCallResults(
solved_globally=solve_globally,
time_out=False,
@@ -1076,7 +1079,6 @@ def solver_call_separation(
found_violation=False,
subsolver_error=False,
)
- timer = TicTocTimer()
for idx, opt in enumerate(solvers):
if idx > 0:
config.progress_logger.warning(
@@ -1085,37 +1087,19 @@ def solver_call_separation(
f"separation of performance constraint {con_name_repr} "
f"in iteration {model_data.iteration}."
)
- orig_setting, custom_setting_present = adjust_solver_time_settings(
- model_data.timing, opt, config
- )
- model_data.timing.start_timer(f"main.{solve_mode}_separation")
- timer.tic(msg=None)
- try:
- results = opt.solve(
- nlp_model,
- tee=config.tee,
- load_solutions=False,
- symbolic_solver_labels=True,
- )
- except ApplicationError:
- # account for possible external subsolver errors
- # (such as segmentation faults, function evaluation
- # errors, etc.)
- adverb = "globally" if solve_globally else "locally"
- config.progress_logger.error(
+ results = call_solver(
+ model=nlp_model,
+ solver=opt,
+ config=config,
+ timing_obj=model_data.timing,
+ timer_name=f"main.{solve_mode}_separation",
+ err_msg=(
f"Optimizer {repr(opt)} ({idx + 1} of {len(solvers)}) "
f"encountered exception attempting "
- f"to {adverb} solve separation problem for constraint "
+ f"to {solve_mode_adverb} solve separation problem for constraint "
f"{con_name_repr} in iteration {model_data.iteration}."
- )
- raise
- else:
- setattr(results.solver, TIC_TOC_SOLVE_TIME_ATTR, timer.toc(msg=None))
- model_data.timing.stop_timer(f"main.{solve_mode}_separation")
- finally:
- revert_solver_max_time_adjustment(
- opt, orig_setting, custom_setting_present, config
- )
+ ),
+ )
# record termination condition for this particular solver
solver_status_dict[str(opt)] = results.solver.termination_condition
diff --git a/pyomo/contrib/pyros/solve_data.py b/pyomo/contrib/pyros/solve_data.py
index bc6c071c9a3..73eee5202aa 100644
--- a/pyomo/contrib/pyros/solve_data.py
+++ b/pyomo/contrib/pyros/solve_data.py
@@ -347,16 +347,23 @@ class SeparationLoopResults:
solver_call_results : ComponentMap
Mapping from performance constraints to corresponding
``SeparationSolveCallResults`` objects.
- worst_case_perf_con : None or int, optional
+ worst_case_perf_con : None or Constraint
Performance constraint mapped to ``SeparationSolveCallResults``
object in `self` corresponding to maximally violating
separation problem solution.
+ all_discrete_scenarios_exhausted : bool, optional
+ For problems with discrete uncertainty sets,
+ True if all scenarios were explicitly accounted for in master
+ (which occurs if there have been
+ as many PyROS iterations as there are scenarios in the set)
+ False otherwise.
Attributes
----------
solver_call_results
solved_globally
worst_case_perf_con
+ all_discrete_scenarios_exhausted
found_violation
violating_param_realization
scaled_violations
@@ -365,11 +372,18 @@ class SeparationLoopResults:
time_out
"""
- def __init__(self, solved_globally, solver_call_results, worst_case_perf_con):
+ def __init__(
+ self,
+ solved_globally,
+ solver_call_results,
+ worst_case_perf_con,
+ all_discrete_scenarios_exhausted=False,
+ ):
"""Initialize self (see class docstring)."""
self.solver_call_results = solver_call_results
self.solved_globally = solved_globally
self.worst_case_perf_con = worst_case_perf_con
+ self.all_discrete_scenarios_exhausted = all_discrete_scenarios_exhausted
@property
def found_violation(self):
@@ -599,6 +613,17 @@ def get_violating_attr(self, attr_name):
"""
return getattr(self.main_loop_results, attr_name, None)
+ @property
+ def all_discrete_scenarios_exhausted(self):
+ """
+ bool : For problems where the uncertainty set is of type
+ DiscreteScenarioSet,
+ True if last master problem solved explicitly
+ accounts for all scenarios in the uncertainty set,
+ False otherwise.
+ """
+ return self.get_violating_attr("all_discrete_scenarios_exhausted")
+
@property
def worst_case_perf_con(self):
"""
diff --git a/pyomo/contrib/pyros/tests/test_config.py b/pyomo/contrib/pyros/tests/test_config.py
new file mode 100644
index 00000000000..166fbada4ff
--- /dev/null
+++ b/pyomo/contrib/pyros/tests/test_config.py
@@ -0,0 +1,620 @@
+"""
+Test objects for construction of PyROS ConfigDict.
+"""
+
+import logging
+import unittest
+
+from pyomo.core.base import ConcreteModel, Var, VarData
+from pyomo.common.log import LoggingIntercept
+from pyomo.common.errors import ApplicationError
+from pyomo.core.base.param import Param, ParamData
+from pyomo.contrib.pyros.config import (
+ InputDataStandardizer,
+ mutable_param_validator,
+ logger_domain,
+ SolverNotResolvable,
+ positive_int_or_minus_one,
+ pyros_config,
+ SolverIterable,
+ SolverResolvable,
+)
+from pyomo.contrib.pyros.util import ObjectiveType
+from pyomo.opt import SolverFactory, SolverResults
+from pyomo.contrib.pyros.uncertainty_sets import BoxSet
+from pyomo.common.dependencies import numpy_available
+
+
+class TestInputDataStandardizer(unittest.TestCase):
+ """
+ Test standardizer method for Pyomo component-type inputs.
+ """
+
+ def test_single_component_data(self):
+ """
+ Test standardizer works for single component
+ data-type entry.
+ """
+ mdl = ConcreteModel()
+ mdl.v = Var([0, 1])
+
+ standardizer_func = InputDataStandardizer(Var, VarData)
+
+ standardizer_input = mdl.v[0]
+ standardizer_output = standardizer_func(standardizer_input)
+
+ self.assertIsInstance(
+ standardizer_output,
+ list,
+ msg=(
+ "Standardized output should be of type list, "
+ f"but is of type {standardizer_output.__class__.__name__}."
+ ),
+ )
+ self.assertEqual(
+ len(standardizer_output),
+ 1,
+ msg="Length of standardizer output is not as expected.",
+ )
+ self.assertIs(
+ standardizer_output[0],
+ mdl.v[0],
+ msg=(
+ f"Entry {standardizer_output[0]} (id {id(standardizer_output[0])}) "
+ "is not identical to "
+ f"input component data object {mdl.v[0]} "
+ f"(id {id(mdl.v[0])})"
+ ),
+ )
+
+ def test_standardizer_indexed_component(self):
+ """
+ Test component standardizer works on indexed component.
+ """
+ mdl = ConcreteModel()
+ mdl.v = Var([0, 1])
+
+ standardizer_func = InputDataStandardizer(Var, VarData)
+
+ standardizer_input = mdl.v
+ standardizer_output = standardizer_func(standardizer_input)
+
+ self.assertIsInstance(
+ standardizer_output,
+ list,
+ msg=(
+ "Standardized output should be of type list, "
+ f"but is of type {standardizer_output.__class__.__name__}."
+ ),
+ )
+ self.assertEqual(
+ len(standardizer_output),
+ 2,
+ msg="Length of standardizer output is not as expected.",
+ )
+ enum_zip = enumerate(zip(standardizer_input.values(), standardizer_output))
+ for idx, (input, output) in enum_zip:
+ self.assertIs(
+ input,
+ output,
+ msg=(
+ f"Entry {input} (id {id(input)}) "
+ "is not identical to "
+ f"input component data object {output} "
+ f"(id {id(output)})"
+ ),
+ )
+
+ def test_standardizer_multiple_components(self):
+ """
+ Test standardizer works on sequence of components.
+ """
+ mdl = ConcreteModel()
+ mdl.v = Var([0, 1])
+ mdl.x = Var(["a", "b"])
+
+ standardizer_func = InputDataStandardizer(Var, VarData)
+
+ standardizer_input = [mdl.v[0], mdl.x]
+ standardizer_output = standardizer_func(standardizer_input)
+ expected_standardizer_output = [mdl.v[0], mdl.x["a"], mdl.x["b"]]
+
+ self.assertIsInstance(
+ standardizer_output,
+ list,
+ msg=(
+ "Standardized output should be of type list, "
+ f"but is of type {standardizer_output.__class__.__name__}."
+ ),
+ )
+ self.assertEqual(
+ len(standardizer_output),
+ len(expected_standardizer_output),
+ msg="Length of standardizer output is not as expected.",
+ )
+ enum_zip = enumerate(zip(expected_standardizer_output, standardizer_output))
+ for idx, (input, output) in enum_zip:
+ self.assertIs(
+ input,
+ output,
+ msg=(
+ f"Entry {input} (id {id(input)}) "
+ "is not identical to "
+ f"input component data object {output} "
+ f"(id {id(output)})"
+ ),
+ )
+
+ def test_standardizer_invalid_duplicates(self):
+ """
+ Test standardizer raises exception if input contains duplicates
+ and duplicates are not allowed.
+ """
+ mdl = ConcreteModel()
+ mdl.v = Var([0, 1])
+ mdl.x = Var(["a", "b"])
+
+ standardizer_func = InputDataStandardizer(Var, VarData, allow_repeats=False)
+
+ exc_str = r"Standardized.*list.*contains duplicate entries\."
+ with self.assertRaisesRegex(ValueError, exc_str):
+ standardizer_func([mdl.x, mdl.v, mdl.x])
+
+ def test_standardizer_invalid_type(self):
+ """
+ Test standardizer raises exception as expected
+ when input is of invalid type.
+ """
+ standardizer_func = InputDataStandardizer(Var, VarData)
+
+ exc_str = r"Input object .*is not of valid component type.*"
+ with self.assertRaisesRegex(TypeError, exc_str):
+ standardizer_func(2)
+
+ def test_standardizer_iterable_with_invalid_type(self):
+ """
+ Test standardizer raises exception as expected
+ when input is an iterable with entries of invalid type.
+ """
+ mdl = ConcreteModel()
+ mdl.v = Var([0, 1])
+ standardizer_func = InputDataStandardizer(Var, VarData)
+
+ exc_str = r"Input object .*entry of iterable.*is not of valid component type.*"
+ with self.assertRaisesRegex(TypeError, exc_str):
+ standardizer_func([mdl.v, 2])
+
+ def test_standardizer_invalid_str_passed(self):
+ """
+ Test standardizer raises exception as expected
+ when input is of invalid type str.
+ """
+ standardizer_func = InputDataStandardizer(Var, VarData)
+
+ exc_str = r"Input object .*is not of valid component type.*"
+ with self.assertRaisesRegex(TypeError, exc_str):
+ standardizer_func("abcd")
+
+ def test_standardizer_invalid_uninitialized_params(self):
+ """
+ Test standardizer raises exception when Param with
+ uninitialized entries passed.
+ """
+ standardizer_func = InputDataStandardizer(
+ ctype=Param, cdatatype=ParamData, ctype_validator=mutable_param_validator
+ )
+
+ mdl = ConcreteModel()
+ mdl.p = Param([0, 1])
+
+ exc_str = r"Length of .*does not match that of.*index set"
+ with self.assertRaisesRegex(ValueError, exc_str):
+ standardizer_func(mdl.p)
+
+ def test_standardizer_invalid_immutable_params(self):
+ """
+ Test standardizer raises exception when immutable
+ Param object(s) passed.
+ """
+ standardizer_func = InputDataStandardizer(
+ ctype=Param, cdatatype=ParamData, ctype_validator=mutable_param_validator
+ )
+
+ mdl = ConcreteModel()
+ mdl.p = Param([0, 1], initialize=1)
+
+ exc_str = r"Param object with name .*immutable"
+ with self.assertRaisesRegex(ValueError, exc_str):
+ standardizer_func(mdl.p)
+
+ def test_standardizer_valid_mutable_params(self):
+ """
+ Test Param-like standardizer works as expected for sequence
+ of valid mutable Param objects.
+ """
+ mdl = ConcreteModel()
+ mdl.p1 = Param([0, 1], initialize=0, mutable=True)
+ mdl.p2 = Param(["a", "b"], initialize=1, mutable=True)
+
+ standardizer_func = InputDataStandardizer(
+ ctype=Param, cdatatype=ParamData, ctype_validator=mutable_param_validator
+ )
+
+ standardizer_input = [mdl.p1[0], mdl.p2]
+ standardizer_output = standardizer_func(standardizer_input)
+ expected_standardizer_output = [mdl.p1[0], mdl.p2["a"], mdl.p2["b"]]
+
+ self.assertIsInstance(
+ standardizer_output,
+ list,
+ msg=(
+ "Standardized output should be of type list, "
+ f"but is of type {standardizer_output.__class__.__name__}."
+ ),
+ )
+ self.assertEqual(
+ len(standardizer_output),
+ len(expected_standardizer_output),
+ msg="Length of standardizer output is not as expected.",
+ )
+ enum_zip = enumerate(zip(expected_standardizer_output, standardizer_output))
+ for idx, (input, output) in enum_zip:
+ self.assertIs(
+ input,
+ output,
+ msg=(
+ f"Entry {input} (id {id(input)}) "
+ "is not identical to "
+ f"input component data object {output} "
+ f"(id {id(output)})"
+ ),
+ )
+
+
+AVAILABLE_SOLVER_TYPE_NAME = "available_pyros_test_solver"
+
+
+class AvailableSolver:
+ """
+ Perennially available placeholder solver.
+ """
+
+ def available(self, exception_flag=False):
+ """
+ Check solver available.
+ """
+ return True
+
+ def solve(self, model, **kwds):
+ """
+ Return SolverResults object with 'unknown' termination
+ condition. Model remains unchanged.
+ """
+ return SolverResults()
+
+
+class UnavailableSolver:
+ def available(self, exception_flag=True):
+ if exception_flag:
+ raise ApplicationError(f"Solver {self.__class__} not available")
+ return False
+
+ def solve(self, model, *args, **kwargs):
+ return SolverResults()
+
+
+class TestSolverResolvable(unittest.TestCase):
+ """
+ Test PyROS standardizer for solver-type objects.
+ """
+
+ def setUp(self):
+ SolverFactory.register(AVAILABLE_SOLVER_TYPE_NAME)(AvailableSolver)
+
+ def tearDown(self):
+ SolverFactory.unregister(AVAILABLE_SOLVER_TYPE_NAME)
+
+ def test_solver_resolvable_valid_str(self):
+ """
+ Test solver resolvable class is valid for string
+ type.
+ """
+ solver_str = AVAILABLE_SOLVER_TYPE_NAME
+ standardizer_func = SolverResolvable()
+ solver = standardizer_func(solver_str)
+ expected_solver_type = type(SolverFactory(solver_str))
+
+ self.assertIsInstance(
+ solver,
+ type(SolverFactory(solver_str)),
+ msg=(
+ "SolverResolvable object should be of type "
+ f"{expected_solver_type.__name__}, "
+ f"but got object of type {solver.__class__.__name__}."
+ ),
+ )
+
+ def test_solver_resolvable_valid_solver_type(self):
+ """
+ Test solver resolvable class is valid for string
+ type.
+ """
+ solver = SolverFactory(AVAILABLE_SOLVER_TYPE_NAME)
+ standardizer_func = SolverResolvable()
+ standardized_solver = standardizer_func(solver)
+
+ self.assertIs(
+ solver,
+ standardized_solver,
+ msg=(
+ f"Test solver {solver} and standardized solver "
+ f"{standardized_solver} are not identical."
+ ),
+ )
+
+ def test_solver_resolvable_invalid_type(self):
+ """
+ Test solver resolvable object raises expected
+ exception when invalid entry is provided.
+ """
+ invalid_object = 2
+ standardizer_func = SolverResolvable(solver_desc="local solver")
+
+ exc_str = (
+ r"Cannot cast object `2` to a Pyomo optimizer.*"
+ r"local solver.*got type int.*"
+ )
+ with self.assertRaisesRegex(SolverNotResolvable, exc_str):
+ standardizer_func(invalid_object)
+
+ def test_solver_resolvable_unavailable_solver(self):
+ """
+ Test solver standardizer fails in event solver is
+ unavailable.
+ """
+ unavailable_solver = UnavailableSolver()
+ standardizer_func = SolverResolvable(
+ solver_desc="local solver", require_available=True
+ )
+
+ exc_str = r"Solver.*UnavailableSolver.*not available"
+ with self.assertRaisesRegex(ApplicationError, exc_str):
+ with LoggingIntercept(level=logging.ERROR) as LOG:
+ standardizer_func(unavailable_solver)
+
+ error_msgs = LOG.getvalue()[:-1]
+ self.assertRegex(
+ error_msgs, r"Output of `available\(\)` method.*local solver.*"
+ )
+
+
+class TestSolverIterable(unittest.TestCase):
+ """
+ Test standardizer method for iterable of solvers,
+ used to validate `backup_local_solvers` and `backup_global_solvers`
+ arguments.
+ """
+
+ def setUp(self):
+ SolverFactory.register(AVAILABLE_SOLVER_TYPE_NAME)(AvailableSolver)
+
+ def tearDown(self):
+ SolverFactory.unregister(AVAILABLE_SOLVER_TYPE_NAME)
+
+ def test_solver_iterable_valid_list(self):
+ """
+ Test solver type standardizer works for list of valid
+ objects castable to solver.
+ """
+ solver_list = [
+ AVAILABLE_SOLVER_TYPE_NAME,
+ SolverFactory(AVAILABLE_SOLVER_TYPE_NAME),
+ ]
+ expected_solver_types = [AvailableSolver] * 2
+ standardizer_func = SolverIterable()
+
+ standardized_solver_list = standardizer_func(solver_list)
+
+ # check list of solver types returned
+ for idx, standardized_solver in enumerate(standardized_solver_list):
+ self.assertIsInstance(
+ standardized_solver,
+ expected_solver_types[idx],
+ msg=(
+ f"Standardized solver {standardized_solver} "
+ f"(index {idx}) expected to be of type "
+ f"{expected_solver_types[idx].__name__}, "
+ f"but is of type {standardized_solver.__class__.__name__}"
+ ),
+ )
+
+ # second entry of standardized solver list should be the same
+ # object as that of input list, since the input solver is a Pyomo
+ # solver type
+ self.assertIs(
+ standardized_solver_list[1],
+ solver_list[1],
+ msg=(
+ f"Test solver {solver_list[1]} and standardized solver "
+ f"{standardized_solver_list[1]} should be identical."
+ ),
+ )
+
+ def test_solver_iterable_valid_str(self):
+ """
+ Test SolverIterable raises exception when str passed.
+ """
+ solver_str = AVAILABLE_SOLVER_TYPE_NAME
+ standardizer_func = SolverIterable()
+
+ solver_list = standardizer_func(solver_str)
+ self.assertEqual(
+ len(solver_list), 1, "Standardized solver list is not of expected length"
+ )
+
+ def test_solver_iterable_unavailable_solver(self):
+ """
+ Test SolverIterable addresses unavailable solvers appropriately.
+ """
+ solvers = (AvailableSolver(), UnavailableSolver())
+
+ standardizer_func = SolverIterable(
+ require_available=True,
+ filter_by_availability=True,
+ solver_desc="example solver list",
+ )
+ exc_str = r"Solver.*UnavailableSolver.* not available"
+ with self.assertRaisesRegex(ApplicationError, exc_str):
+ standardizer_func(solvers)
+ with self.assertRaisesRegex(ApplicationError, exc_str):
+ standardizer_func(solvers, filter_by_availability=False)
+
+ standardized_solver_list = standardizer_func(
+ solvers, filter_by_availability=True, require_available=False
+ )
+ self.assertEqual(
+ len(standardized_solver_list),
+ 1,
+ msg=("Length of filtered standardized solver list not as " "expected."),
+ )
+ self.assertIs(
+ standardized_solver_list[0],
+ solvers[0],
+ msg="Entry of filtered standardized solver list not as expected.",
+ )
+
+ standardized_solver_list = standardizer_func(
+ solvers, filter_by_availability=False, require_available=False
+ )
+ self.assertEqual(
+ len(standardized_solver_list),
+ 2,
+ msg=("Length of filtered standardized solver list not as " "expected."),
+ )
+ self.assertEqual(
+ standardized_solver_list,
+ list(solvers),
+ msg="Entry of filtered standardized solver list not as expected.",
+ )
+
+ def test_solver_iterable_invalid_list(self):
+ """
+ Test SolverIterable raises exception if iterable contains
+ at least one invalid object.
+ """
+ invalid_object = [AVAILABLE_SOLVER_TYPE_NAME, 2]
+ standardizer_func = SolverIterable(solver_desc="backup solver")
+
+ exc_str = (
+ r"Cannot cast object `2` to a Pyomo optimizer.*"
+ r"backup solver.*index 1.*got type int.*"
+ )
+ with self.assertRaisesRegex(SolverNotResolvable, exc_str):
+ standardizer_func(invalid_object)
+
+
+class TestPyROSConfig(unittest.TestCase):
+ """
+ Test PyROS ConfigDict behaves as expected.
+ """
+
+ CONFIG = pyros_config()
+
+ def test_config_objective_focus(self):
+ """
+ Test config parses objective focus as expected.
+ """
+ config = self.CONFIG()
+
+ for obj_focus_name in ["nominal", "worst_case"]:
+ config.objective_focus = obj_focus_name
+ self.assertEqual(
+ config.objective_focus,
+ ObjectiveType[obj_focus_name],
+ msg="Objective focus not set as expected.",
+ )
+
+ for obj_focus in ObjectiveType:
+ config.objective_focus = obj_focus
+ self.assertEqual(
+ config.objective_focus,
+ obj_focus,
+ msg="Objective focus not set as expected.",
+ )
+
+ invalid_focus = "test_example"
+ exc_str = f".*{invalid_focus!r} is not a valid ObjectiveType"
+ with self.assertRaisesRegex(ValueError, exc_str):
+ config.objective_focus = invalid_focus
+
+
+class TestPositiveIntOrMinusOne(unittest.TestCase):
+ """
+ Test validator for -1 or positive int works as expected.
+ """
+
+ def test_positive_int_or_minus_one(self):
+ """
+ Test positive int or -1 validator works as expected.
+ """
+ standardizer_func = positive_int_or_minus_one
+ ans = standardizer_func(1.0)
+ self.assertEqual(
+ ans,
+ 1,
+ msg=f"{positive_int_or_minus_one.__name__} output value not as expected.",
+ )
+ self.assertIs(
+ type(ans),
+ int,
+ msg=f"{positive_int_or_minus_one.__name__} output type not as expected.",
+ )
+
+ ans = standardizer_func(-1.0)
+ self.assertEqual(
+ ans,
+ -1,
+ msg=f"{positive_int_or_minus_one.__name__} output value not as expected.",
+ )
+ self.assertIs(
+ type(ans),
+ int,
+ msg=f"{positive_int_or_minus_one.__name__} output type not as expected.",
+ )
+
+ exc_str = r"Expected positive int or -1, but received value.*"
+ with self.assertRaisesRegex(ValueError, exc_str):
+ standardizer_func(1.5)
+ with self.assertRaisesRegex(ValueError, exc_str):
+ standardizer_func(0)
+
+
+class TestLoggerDomain(unittest.TestCase):
+ """
+ Test logger type domain validator.
+ """
+
+ def test_logger_type(self):
+ """
+ Test logger type validator.
+ """
+ standardizer_func = logger_domain
+ mylogger = logging.getLogger("example")
+ self.assertIs(
+ standardizer_func(mylogger),
+ mylogger,
+ msg=f"{standardizer_func.__name__} output not as expected",
+ )
+ self.assertIs(
+ standardizer_func(mylogger.name),
+ mylogger,
+ msg=f"{standardizer_func.__name__} output not as expected",
+ )
+
+ exc_str = r"A logger name must be a string"
+ with self.assertRaisesRegex(Exception, exc_str):
+ standardizer_func(2)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/pyomo/contrib/pyros/tests/test_grcs.py b/pyomo/contrib/pyros/tests/test_grcs.py
index fc215f86a7c..f7efec4d6e7 100644
--- a/pyomo/contrib/pyros/tests/test_grcs.py
+++ b/pyomo/contrib/pyros/tests/test_grcs.py
@@ -19,6 +19,7 @@
from pyomo.common.collections import ComponentSet, ComponentMap
from pyomo.common.config import ConfigBlock, ConfigValue
from pyomo.core.base.set_types import NonNegativeIntegers
+from pyomo.core.base.var import VarData
from pyomo.core.expr import (
identify_variables,
identify_mutable_parameters,
@@ -29,7 +30,6 @@
selective_clone,
add_decision_rule_variables,
add_decision_rule_constraints,
- model_is_valid,
turn_bounds_to_constraints,
transform_to_standard_form,
ObjectiveType,
@@ -131,6 +131,9 @@
scip_license_is_valid = False
scip_version = (0, 0, 0)
+_ipopt = SolverFactory("ipopt")
+ipopt_available = _ipopt.available(exception_flag=False)
+
# @SolverFactory.register("time_delay_solver")
class TimeDelaySolver(object):
@@ -148,7 +151,7 @@ def __init__(self, calls_to_sleep, max_time, sub_solver):
self.num_calls = 0
self.options = Bunch()
- def available(self):
+ def available(self, exception_flag=True):
return True
def license_is_valid(self):
@@ -569,22 +572,30 @@ def test_dr_eqns_form_correct(self):
dr_polynomial_terms, indexed_dr_var.values(), dr_monomial_param_combos
)
for idx, (term, dr_var, param_combo) in enumerate(dr_polynomial_zip):
- # term should be a monomial expression of form
- # (uncertain parameter product) * (decision rule variable)
- # so length of expression object should be 2
- self.assertEqual(
- len(term.args),
- 2,
- msg=(
- f"Length of `args` attribute of term {str(term)} "
- f"of DR equation {dr_eq.name!r} is not as expected. "
- f"Args: {term.args}"
- ),
- )
+ # term should be either a monomial expression or scalar variable
+ if isinstance(term, MonomialTermExpression):
+ # should be of form (uncertain parameter product) *
+ # (decision rule variable) so length of expression
+ # object should be 2
+ self.assertEqual(
+ len(term.args),
+ 2,
+ msg=(
+ f"Length of `args` attribute of term {str(term)} "
+ f"of DR equation {dr_eq.name!r} is not as expected. "
+ f"Args: {term.args}"
+ ),
+ )
+
+ # check that uncertain parameters participating in
+ # the monomial are as expected
+ param_product_multiplicand = term.args[0]
+ dr_var_multiplicand = term.args[1]
+ else:
+ self.assertIsInstance(term, VarData)
+ param_product_multiplicand = 1
+ dr_var_multiplicand = term
- # check that uncertain parameters participating in
- # the monomial are as expected
- param_product_multiplicand = term.args[0]
if idx == 0:
# static DR term
param_combo_found_in_term = (param_product_multiplicand,)
@@ -610,7 +621,6 @@ def test_dr_eqns_form_correct(self):
# check that DR variable participating in the monomial
# is as expected
- dr_var_multiplicand = term.args[1]
self.assertIs(
dr_var_multiplicand,
dr_var,
@@ -621,21 +631,6 @@ def test_dr_eqns_form_correct(self):
)
-class testModelIsValid(unittest.TestCase):
- def test_model_is_valid_via_possible_inputs(self):
- m = ConcreteModel()
- m.x = Var()
- m.obj1 = Objective(expr=m.x**2)
- self.assertTrue(model_is_valid(m))
- m.obj2 = Objective(expr=m.x)
- self.assertFalse(model_is_valid(m))
- m.obj2.deactivate()
- self.assertTrue(model_is_valid(m))
- m.del_component("obj1")
- m.del_component("obj2")
- self.assertFalse(model_is_valid(m))
-
-
class testTurnBoundsToConstraints(unittest.TestCase):
def test_bounds_to_constraints(self):
m = ConcreteModel()
@@ -3560,10 +3555,7 @@ class behaves like a regular Python list.
# assigning to slices should work fine
all_sets[3:] = [BoxSet([[1, 1.5]]), BoxSet([[1, 3]])]
- @unittest.skipUnless(
- SolverFactory('ipopt').available(exception_flag=False),
- "Local NLP solver is not available.",
- )
+ @unittest.skipUnless(ipopt_available, "IPOPT is not available.")
def test_uncertainty_set_with_correct_params(self):
'''
Case in which the UncertaintySet is constructed using the uncertain_param objects from the model to
@@ -3602,10 +3594,7 @@ def test_uncertainty_set_with_correct_params(self):
" be the same uncertain param Var objects in the original model.",
)
- @unittest.skipUnless(
- SolverFactory('ipopt').available(exception_flag=False),
- "Local NLP solver is not available.",
- )
+ @unittest.skipUnless(ipopt_available, "IPOPT is not available.")
def test_uncertainty_set_with_incorrect_params(self):
'''
Case in which the set is constructed using uncertain_param objects which are Params instead of
@@ -3806,6 +3795,7 @@ def test_solve_master(self):
config.declare(
"progress_logger", ConfigValue(default=logging.getLogger(__name__))
)
+ config.declare("symbolic_solver_labels", ConfigValue(default=False))
with time_code(master_data.timing, "main", is_main_timer=True):
master_soln = solve_master(master_data, config)
@@ -4352,14 +4342,16 @@ def test_separation_terminate_time_limit(self):
)
@unittest.skipUnless(
- SolverFactory('gams').license_is_valid()
- and SolverFactory('baron').license_is_valid(),
- "Global NLP solver is not available and licensed.",
+ ipopt_available
+ and SolverFactory('gams').license_is_valid()
+ and SolverFactory('baron').license_is_valid()
+ and SolverFactory("scip").license_is_valid(),
+ "IPOPT not available or one of GAMS/BARON/SCIP not licensed",
)
- def test_gams_successful_time_limit(self):
+ def test_pyros_subsolver_time_limit_adjustment(self):
"""
- Test PyROS time limit status returned in event
- separation problem times out.
+ Check that PyROS does not ultimately alter state of
+ subordinate solver options due to time limit adjustments.
"""
m = ConcreteModel()
m.x1 = Var(initialize=0, bounds=(0, None))
@@ -4378,20 +4370,26 @@ def test_gams_successful_time_limit(self):
# Instantiate the PyROS solver
pyros_solver = SolverFactory("pyros")
- # Define subsolvers utilized in the algorithm
- # two GAMS solvers, one of which has reslim set
- # (overridden when invoked in PyROS)
+ # subordinate solvers to test.
+ # for testing, we pass each as the 'local' solver,
+ # and the BARON solver without custom options
+ # as the 'global' solver
+ baron_no_options = SolverFactory("baron")
local_subsolvers = [
SolverFactory("gams:conopt"),
SolverFactory("gams:conopt"),
SolverFactory("ipopt"),
+ SolverFactory("ipopt", options={"max_cpu_time": 300}),
+ SolverFactory("scip"),
+ SolverFactory("scip", options={"limits/time": 300}),
+ baron_no_options,
+ SolverFactory("baron", options={"MaxTime": 300}),
]
local_subsolvers[0].options["add_options"] = ["option reslim=100;"]
- global_subsolver = SolverFactory("baron")
- global_subsolver.options["MaxTime"] = 300
# Call the PyROS solver
for idx, opt in enumerate(local_subsolvers):
+ original_solver_options = opt.options.copy()
results = pyros_solver.solve(
model=m,
first_stage_variables=[m.x1, m.x2],
@@ -4399,68 +4397,25 @@ def test_gams_successful_time_limit(self):
uncertain_params=[m.u],
uncertainty_set=interval,
local_solver=opt,
- global_solver=global_subsolver,
+ global_solver=baron_no_options,
objective_focus=ObjectiveType.worst_case,
solve_master_globally=True,
time_limit=100,
)
-
self.assertEqual(
results.pyros_termination_condition,
pyrosTerminationCondition.robust_optimal,
msg=(
- f"Returned termination condition with local "
- "subsolver {idx + 1} of 2 is not robust_optimal."
+ "Returned termination condition with local "
+ f"subsolver {idx + 1} of 2 is not robust_optimal."
),
)
-
- # check first local subsolver settings
- # remain unchanged after PyROS exit
- self.assertEqual(
- len(list(local_subsolvers[0].options["add_options"])),
- 1,
- msg=(
- f"Local subsolver {local_subsolvers[0]} options 'add_options'"
- "were changed by PyROS"
- ),
- )
- self.assertEqual(
- local_subsolvers[0].options["add_options"][0],
- "option reslim=100;",
- msg=(
- f"Local subsolver {local_subsolvers[0]} setting "
- "'add_options' was modified "
- "by PyROS, but changes were not properly undone"
- ),
- )
-
- # check global subsolver settings unchanged
- self.assertEqual(
- len(list(global_subsolver.options.keys())),
- 1,
- msg=(f"Global subsolver {global_subsolver} options were changed by PyROS"),
- )
- self.assertEqual(
- global_subsolver.options["MaxTime"],
- 300,
- msg=(
- f"Global subsolver {global_subsolver} setting "
- "'MaxTime' was modified "
- "by PyROS, but changes were not properly undone"
- ),
- )
-
- # check other local subsolvers remain unchanged
- for slvr, key in zip(local_subsolvers[1:], ["add_options", "max_cpu_time"]):
- # no custom options were added to the `options`
- # attribute of the optimizer, so any attribute
- # of `options` should be `None`
- self.assertIs(
- getattr(slvr.options, key, None),
- None,
+ self.assertEqual(
+ opt.options,
+ original_solver_options,
msg=(
- f"Local subsolver {slvr} setting '{key}' was added "
- "by PyROS, but not reverted"
+ f"Options for subordinate solver {opt} were changed "
+ "by PyROS, and the changes wee not properly reverted."
),
)
@@ -5417,16 +5372,14 @@ def test_multiple_objs(self):
# check validation error raised due to multiple objectives
with self.assertRaisesRegex(
- AttributeError,
- "This model structure is not currently handled by the ROSolver.",
+ ValueError, r"Expected model with exactly 1 active objective.*has 3"
):
pyros_solver.solve(**solve_kwargs)
# check validation error raised due to multiple objectives
m.b.obj.deactivate()
with self.assertRaisesRegex(
- AttributeError,
- "This model structure is not currently handled by the ROSolver.",
+ ValueError, r"Expected model with exactly 1 active objective.*has 2"
):
pyros_solver.solve(**solve_kwargs)
@@ -6219,6 +6172,7 @@ def test_log_config(self):
" keepfiles=False\n"
" tee=False\n"
" load_solution=True\n"
+ " symbolic_solver_labels=False\n"
" objective_focus=\n"
" nominal_uncertain_param_vals=[0.5]\n"
" decision_rule_order=0\n"
@@ -6313,5 +6267,598 @@ def test_log_disclaimer(self):
)
+class UnavailableSolver:
+ def available(self, exception_flag=True):
+ if exception_flag:
+ raise ApplicationError(f"Solver {self.__class__} not available")
+ return False
+
+ def solve(self, model, *args, **kwargs):
+ return SolverResults()
+
+
+class TestPyROSUnavailableSubsolvers(unittest.TestCase):
+ """
+ Check that appropriate exceptionsa are raised if
+ PyROS is invoked with unavailable subsolvers.
+ """
+
+ def test_pyros_unavailable_subsolver(self):
+ """
+ Test PyROS raises expected error message when
+ unavailable subsolver is passed.
+ """
+ m = ConcreteModel()
+ m.p = Param(range(3), initialize=0, mutable=True)
+ m.z = Var([0, 1], initialize=0)
+ m.con = Constraint(expr=m.z[0] + m.z[1] >= m.p[0])
+ m.obj = Objective(expr=m.z[0] + m.z[1])
+
+ pyros_solver = SolverFactory("pyros")
+
+ exc_str = r".*Solver.*UnavailableSolver.*not available"
+ with self.assertRaisesRegex(ValueError, exc_str):
+ # note: ConfigDict interface raises ValueError
+ # once any exception is triggered,
+ # so we check for that instead of ApplicationError
+ with LoggingIntercept(level=logging.ERROR) as LOG:
+ pyros_solver.solve(
+ model=m,
+ first_stage_variables=[m.z[0]],
+ second_stage_variables=[m.z[1]],
+ uncertain_params=[m.p[0]],
+ uncertainty_set=BoxSet([[0, 1]]),
+ local_solver=SimpleTestSolver(),
+ global_solver=UnavailableSolver(),
+ )
+
+ error_msgs = LOG.getvalue()[:-1]
+ self.assertRegex(
+ error_msgs, r"Output of `available\(\)` method.*global solver.*"
+ )
+
+ @unittest.skipUnless(ipopt_available, "IPOPT is not available.")
+ def test_pyros_unavailable_backup_subsolver(self):
+ """
+ Test PyROS raises expected error message when
+ unavailable backup subsolver is passed.
+ """
+ m = ConcreteModel()
+ m.p = Param(range(3), initialize=0, mutable=True)
+ m.z = Var([0, 1], initialize=0)
+ m.con = Constraint(expr=m.z[0] + m.z[1] >= m.p[0])
+ m.obj = Objective(expr=m.z[0] + m.z[1])
+
+ pyros_solver = SolverFactory("pyros")
+
+ # note: ConfigDict interface raises ValueError
+ # once any exception is triggered,
+ # so we check for that instead of ApplicationError
+ with LoggingIntercept(level=logging.WARNING) as LOG:
+ pyros_solver.solve(
+ model=m,
+ first_stage_variables=[m.z[0]],
+ second_stage_variables=[m.z[1]],
+ uncertain_params=[m.p[0]],
+ uncertainty_set=BoxSet([[0, 1]]),
+ local_solver=SolverFactory("ipopt"),
+ global_solver=SolverFactory("ipopt"),
+ backup_global_solvers=[UnavailableSolver()],
+ bypass_global_separation=True,
+ )
+
+ error_msgs = LOG.getvalue()[:-1]
+ self.assertRegex(
+ error_msgs,
+ r"Output of `available\(\)` method.*backup global solver.*"
+ r"Removing from list.*",
+ )
+
+
+class TestPyROSResolveKwargs(unittest.TestCase):
+ """
+ Test PyROS resolves kwargs as expected.
+ """
+
+ @unittest.skipUnless(ipopt_available, "IPOPT is not available.")
+ @unittest.skipUnless(
+ baron_license_is_valid, "Global NLP solver is not available and licensed."
+ )
+ def test_pyros_kwargs_with_overlap(self):
+ """
+ Test PyROS works as expected when there is overlap between
+ keyword arguments passed explicitly and implicitly
+ through `options`.
+ """
+ # define model
+ m = ConcreteModel()
+ m.x1 = Var(initialize=0, bounds=(0, None))
+ m.x2 = Var(initialize=0, bounds=(0, None))
+ m.x3 = Var(initialize=0, bounds=(None, None))
+ m.u1 = Param(initialize=1.125, mutable=True)
+ m.u2 = Param(initialize=1, mutable=True)
+
+ m.con1 = Constraint(expr=m.x1 * m.u1 ** (0.5) - m.x2 * m.u1 <= 2)
+ m.con2 = Constraint(expr=m.x1**2 - m.x2**2 * m.u1 == m.x3)
+
+ m.obj = Objective(expr=(m.x1 - 4) ** 2 + (m.x2 - m.u2) ** 2)
+
+ # Define the uncertainty set
+ # we take the parameter `u2` to be 'fixed'
+ ellipsoid = AxisAlignedEllipsoidalSet(center=[1.125, 1], half_lengths=[1, 0])
+
+ # Instantiate the PyROS solver
+ pyros_solver = SolverFactory("pyros")
+
+ # Define subsolvers utilized in the algorithm
+ local_subsolver = SolverFactory('ipopt')
+ global_subsolver = SolverFactory("baron")
+
+ # Call the PyROS solver
+ results = pyros_solver.solve(
+ model=m,
+ first_stage_variables=[m.x1, m.x2],
+ second_stage_variables=[],
+ uncertain_params=[m.u1, m.u2],
+ uncertainty_set=ellipsoid,
+ local_solver=local_subsolver,
+ global_solver=global_subsolver,
+ bypass_local_separation=True,
+ solve_master_globally=True,
+ options={
+ "objective_focus": ObjectiveType.worst_case,
+ "solve_master_globally": False,
+ "max_iter": 1,
+ "time_limit": 1000,
+ },
+ )
+
+ # check termination status as expected
+ self.assertEqual(
+ results.pyros_termination_condition,
+ pyrosTerminationCondition.max_iter,
+ msg="Termination condition not as expected",
+ )
+ self.assertEqual(
+ results.iterations, 1, msg="Number of iterations not as expected"
+ )
+
+ # check config resolved as expected
+ config = results.config
+ self.assertEqual(
+ config.bypass_local_separation,
+ True,
+ msg="Resolved value of kwarg `bypass_local_separation` not as expected.",
+ )
+ self.assertEqual(
+ config.solve_master_globally,
+ True,
+ msg="Resolved value of kwarg `solve_master_globally` not as expected.",
+ )
+ self.assertEqual(
+ config.max_iter,
+ 1,
+ msg="Resolved value of kwarg `max_iter` not as expected.",
+ )
+ self.assertEqual(
+ config.objective_focus,
+ ObjectiveType.worst_case,
+ msg="Resolved value of kwarg `objective_focus` not as expected.",
+ )
+ self.assertEqual(
+ config.time_limit,
+ 1e3,
+ msg="Resolved value of kwarg `time_limit` not as expected.",
+ )
+
+
+class SimpleTestSolver:
+ """
+ Simple test solver class with no actual solve()
+ functionality. Written to test unrelated aspects
+ of PyROS functionality.
+ """
+
+ def available(self, exception_flag=False):
+ """
+ Check solver available.
+ """
+ return True
+
+ def solve(self, model, **kwds):
+ """
+ Return SolverResults object with 'unknown' termination
+ condition. Model remains unchanged.
+ """
+ res = SolverResults()
+ res.solver.termination_condition = TerminationCondition.unknown
+
+ return res
+
+
+class TestPyROSSolverAdvancedValidation(unittest.TestCase):
+ """
+ Test PyROS solver returns expected exception messages
+ when arguments are invalid.
+ """
+
+ def build_simple_test_model(self):
+ """
+ Build simple valid test model.
+ """
+ m = ConcreteModel(name="test_model")
+
+ m.x1 = Var(initialize=0, bounds=(0, None))
+ m.x2 = Var(initialize=0, bounds=(0, None))
+ m.u = Param(initialize=1.125, mutable=True)
+
+ m.con1 = Constraint(expr=m.x1 * m.u ** (0.5) - m.x2 * m.u <= 2)
+
+ m.obj = Objective(expr=(m.x1 - 4) ** 2 + (m.x2 - 1) ** 2)
+
+ return m
+
+ def test_pyros_invalid_model_type(self):
+ """
+ Test PyROS fails if model is not of correct class.
+ """
+ mdl = self.build_simple_test_model()
+
+ local_solver = SimpleTestSolver()
+ global_solver = SimpleTestSolver()
+
+ pyros = SolverFactory("pyros")
+
+ exc_str = "Model should be of type.*but is of type.*"
+ with self.assertRaisesRegex(TypeError, exc_str):
+ pyros.solve(
+ model=2,
+ first_stage_variables=[mdl.x1],
+ second_stage_variables=[mdl.x2],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ )
+
+ def test_pyros_multiple_objectives(self):
+ """
+ Test PyROS raises exception if input model has multiple
+ objectives.
+ """
+ mdl = self.build_simple_test_model()
+ mdl.obj2 = Objective(expr=(mdl.x1 + mdl.x2))
+
+ local_solver = SimpleTestSolver()
+ global_solver = SimpleTestSolver()
+
+ pyros = SolverFactory("pyros")
+
+ exc_str = "Expected model with exactly 1 active.*but.*has 2"
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=[mdl.x1],
+ second_stage_variables=[mdl.x2],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ )
+
+ def test_pyros_empty_dof_vars(self):
+ """
+ Test PyROS solver raises exception raised if there are no
+ first-stage variables or second-stage variables.
+ """
+ # build model
+ mdl = self.build_simple_test_model()
+
+ # prepare solvers
+ pyros = SolverFactory("pyros")
+ local_solver = SimpleTestSolver()
+ global_solver = SimpleTestSolver()
+
+ # perform checks
+ exc_str = (
+ "Arguments `first_stage_variables` and "
+ "`second_stage_variables` are both empty lists."
+ )
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=[],
+ second_stage_variables=[],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ )
+
+ def test_pyros_overlap_dof_vars(self):
+ """
+ Test PyROS solver raises exception raised if there are Vars
+ passed as both first-stage and second-stage.
+ """
+ # build model
+ mdl = self.build_simple_test_model()
+
+ # prepare solvers
+ pyros = SolverFactory("pyros")
+ local_solver = SimpleTestSolver()
+ global_solver = SimpleTestSolver()
+
+ # perform checks
+ exc_str = (
+ "Arguments `first_stage_variables` and `second_stage_variables` "
+ "contain at least one common Var object."
+ )
+ with LoggingIntercept(level=logging.ERROR) as LOG:
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=[mdl.x1],
+ second_stage_variables=[mdl.x1, mdl.x2],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ )
+
+ # check logger output is as expected
+ log_msgs = LOG.getvalue().split("\n")[:-1]
+ self.assertEqual(
+ len(log_msgs), 3, "Error message does not contain expected number of lines."
+ )
+ self.assertRegex(
+ text=log_msgs[0],
+ expected_regex=(
+ "The following Vars were found in both `first_stage_variables`"
+ "and `second_stage_variables`.*"
+ ),
+ )
+ self.assertRegex(text=log_msgs[1], expected_regex=" 'x1'")
+ self.assertRegex(
+ text=log_msgs[2],
+ expected_regex="Ensure no Vars are included in both arguments.",
+ )
+
+ def test_pyros_vars_not_in_model(self):
+ """
+ Test PyROS appropriately raises exception if there are
+ variables not included in active model objective
+ or constraints which are not descended from model.
+ """
+ # set up model
+ mdl = self.build_simple_test_model()
+ mdl.name = "model1"
+ mdl2 = self.build_simple_test_model()
+ mdl2.name = "model2"
+
+ # set up solvers
+ local_solver = SimpleTestSolver()
+ global_solver = SimpleTestSolver()
+ pyros = SolverFactory("pyros")
+
+ mdl.bad_con = Constraint(expr=mdl2.x1 + mdl2.x2 >= 1)
+
+ desc_dof_map = [
+ ("first-stage", [mdl2.x1], [], 2),
+ ("second-stage", [], [mdl2.x2], 2),
+ ("state", [mdl.x1], [], 3),
+ ]
+
+ # now perform checks
+ for vardesc, first_stage_vars, second_stage_vars, numlines in desc_dof_map:
+ with LoggingIntercept(level=logging.ERROR) as LOG:
+ exc_str = (
+ "Found entries of "
+ f"{vardesc} variables not descended from.*model.*"
+ )
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=first_stage_vars,
+ second_stage_variables=second_stage_vars,
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ )
+
+ log_msgs = LOG.getvalue().split("\n")[:-1]
+
+ # check detailed log message is as expected
+ self.assertEqual(
+ len(log_msgs),
+ numlines,
+ "Error-level log message does not contain expected number of lines.",
+ )
+ self.assertRegex(
+ text=log_msgs[0],
+ expected_regex=(
+ f"The following {vardesc} variables"
+ ".*not descended from.*model with name 'model1'"
+ ),
+ )
+
+ def test_pyros_non_continuous_vars(self):
+ """
+ Test PyROS raises exception if model contains
+ non-continuous variables.
+ """
+ # build model; make one variable discrete
+ mdl = self.build_simple_test_model()
+ mdl.x2.domain = NonNegativeIntegers
+
+ # prepare solvers
+ pyros = SolverFactory("pyros")
+ local_solver = SimpleTestSolver()
+ global_solver = SimpleTestSolver()
+
+ # perform checks
+ exc_str = "Model with name 'test_model' contains non-continuous Vars."
+ with LoggingIntercept(level=logging.ERROR) as LOG:
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=[mdl.x1],
+ second_stage_variables=[mdl.x2],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ )
+
+ # check logger output is as expected
+ log_msgs = LOG.getvalue().split("\n")[:-1]
+ self.assertEqual(
+ len(log_msgs), 3, "Error message does not contain expected number of lines."
+ )
+ self.assertRegex(
+ text=log_msgs[0],
+ expected_regex=(
+ "The following Vars of model with name 'test_model' "
+ "are non-continuous:"
+ ),
+ )
+ self.assertRegex(text=log_msgs[1], expected_regex=" 'x2'")
+ self.assertRegex(
+ text=log_msgs[2],
+ expected_regex=(
+ "Ensure all model variables passed to " "PyROS solver are continuous."
+ ),
+ )
+
+ def test_pyros_uncertainty_dimension_mismatch(self):
+ """
+ Test PyROS solver raises exception if uncertainty
+ set dimension does not match the number
+ of uncertain parameters.
+ """
+ # build model
+ mdl = self.build_simple_test_model()
+
+ # prepare solvers
+ pyros = SolverFactory("pyros")
+ local_solver = SimpleTestSolver()
+ global_solver = SimpleTestSolver()
+
+ # perform checks
+ exc_str = (
+ r"Length of argument `uncertain_params` does not match dimension "
+ r"of argument `uncertainty_set` \(1 != 2\)."
+ )
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=[mdl.x1],
+ second_stage_variables=[mdl.x2],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2], [0, 1]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ )
+
+ @unittest.skipUnless(ipopt_available, "IPOPT is not available.")
+ def test_pyros_nominal_point_not_in_set(self):
+ """
+ Test PyROS raises exception if nominal point is not in the
+ uncertainty set.
+
+ NOTE: need executable solvers to solve set bounding problems
+ for validity checks.
+ """
+ # build model
+ mdl = self.build_simple_test_model()
+
+ # prepare solvers
+ pyros = SolverFactory("pyros")
+ local_solver = SolverFactory("ipopt")
+ global_solver = SolverFactory("ipopt")
+
+ # perform checks
+ exc_str = (
+ r"Nominal uncertain parameter realization \[0\] "
+ "is not a point in the uncertainty set.*"
+ )
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=[mdl.x1],
+ second_stage_variables=[mdl.x2],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ nominal_uncertain_param_vals=[0],
+ )
+
+ @unittest.skipUnless(ipopt_available, "IPOPT is not available.")
+ def test_pyros_nominal_point_len_mismatch(self):
+ """
+ Test PyROS raises exception if there is mismatch between length
+ of nominal uncertain parameter specification and number
+ of uncertain parameters.
+ """
+ # build model
+ mdl = self.build_simple_test_model()
+
+ # prepare solvers
+ pyros = SolverFactory("pyros")
+ local_solver = SolverFactory("ipopt")
+ global_solver = SolverFactory("ipopt")
+
+ # perform checks
+ exc_str = (
+ r"Lengths of arguments `uncertain_params` "
+ r"and `nominal_uncertain_param_vals` "
+ r"do not match \(1 != 2\)."
+ )
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=[mdl.x1],
+ second_stage_variables=[mdl.x2],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ nominal_uncertain_param_vals=[0, 1],
+ )
+
+ @unittest.skipUnless(ipopt_available, "IPOPT is not available.")
+ def test_pyros_invalid_bypass_separation(self):
+ """
+ Test PyROS raises exception if both local and
+ global separation are set to be bypassed.
+ """
+ # build model
+ mdl = self.build_simple_test_model()
+
+ # prepare solvers
+ pyros = SolverFactory("pyros")
+ local_solver = SolverFactory("ipopt")
+ global_solver = SolverFactory("ipopt")
+
+ # perform checks
+ exc_str = (
+ r"Arguments `bypass_local_separation` and `bypass_global_separation` "
+ r"cannot both be True."
+ )
+ with self.assertRaisesRegex(ValueError, exc_str):
+ pyros.solve(
+ model=mdl,
+ first_stage_variables=[mdl.x1],
+ second_stage_variables=[mdl.x2],
+ uncertain_params=[mdl.u],
+ uncertainty_set=BoxSet([[1 / 4, 2]]),
+ local_solver=local_solver,
+ global_solver=global_solver,
+ bypass_local_separation=True,
+ bypass_global_separation=True,
+ )
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/pyomo/contrib/pyros/uncertainty_sets.py b/pyomo/contrib/pyros/uncertainty_sets.py
index 17b51be709b..028a9f38da1 100644
--- a/pyomo/contrib/pyros/uncertainty_sets.py
+++ b/pyomo/contrib/pyros/uncertainty_sets.py
@@ -283,14 +283,6 @@ def generate_shape_str(shape, required_shape):
)
-def uncertainty_sets(obj):
- if not isinstance(obj, UncertaintySet):
- raise ValueError(
- "Expected an UncertaintySet object, instead received %s" % (obj,)
- )
- return obj
-
-
def column(matrix, i):
# Get column i of a given multi-dimensional list
return [row[i] for row in matrix]
diff --git a/pyomo/contrib/pyros/util.py b/pyomo/contrib/pyros/util.py
index 97fa42c32e9..3b0187af7dd 100644
--- a/pyomo/contrib/pyros/util.py
+++ b/pyomo/contrib/pyros/util.py
@@ -16,7 +16,9 @@
import copy
from enum import Enum, auto
from pyomo.common.collections import ComponentSet, ComponentMap
+from pyomo.common.errors import ApplicationError
from pyomo.common.modeling import unique_component_name
+from pyomo.common.timing import TicTocTimer
from pyomo.core.base import (
Constraint,
Var,
@@ -230,15 +232,15 @@ def get_main_elapsed_time(timing_data_obj):
def adjust_solver_time_settings(timing_data_obj, solver, config):
"""
- Adjust solver max time setting based on current PyROS elapsed
- time.
+ Adjust maximum time allowed for subordinate solver, based
+ on total PyROS solver elapsed time up to this point.
Parameters
----------
timing_data_obj : Bunch
PyROS timekeeper.
solver : solver type
- Solver for which to adjust the max time setting.
+ Subordinate solver for which to adjust the max time setting.
config : ConfigDict
PyROS solver config.
@@ -260,26 +262,37 @@ def adjust_solver_time_settings(timing_data_obj, solver, config):
----
(1) Adjustment only supported for GAMS, BARON, and IPOPT
interfaces. This routine can be generalized to other solvers
- after a generic interface to the time limit setting
+ after a generic Pyomo interface to the time limit setting
is introduced.
- (2) For IPOPT, and probably also BARON, the CPU time limit
- rather than the wallclock time limit, is adjusted, as
- no interface to wallclock limit available.
- For this reason, extra 30s is added to time remaining
- for subsolver time limit.
- (The extra 30s is large enough to ensure solver
- elapsed time is not beneath elapsed time - user time limit,
- but not so large as to overshoot the user-specified time limit
- by an inordinate margin.)
+ (2) For IPOPT and BARON, the CPU time limit,
+ rather than the wallclock time limit, may be adjusted,
+ as there may be no means by which to specify the wall time
+ limit explicitly.
+ (3) For GAMS, we adjust the time limit through the GAMS Reslim
+ option. However, this may be overridden by any user
+ specifications included in a GAMS optfile, which may be
+ difficult to track down.
+ (4) To ensure the time limit is specified to a strictly
+ positive value, the time limit is adjusted to a value of
+ at least 1 second.
"""
+ # in case there is no time remaining: we set time limit
+ # to a minimum of 1s, as some solvers require a strictly
+ # positive time limit
+ time_limit_buffer = 1
+
if config.time_limit is not None:
time_remaining = config.time_limit - get_main_elapsed_time(timing_data_obj)
if isinstance(solver, type(SolverFactory("gams", solver_io="shell"))):
original_max_time_setting = solver.options["add_options"]
custom_setting_present = "add_options" in solver.options
- # adjust GAMS solver time
- reslim_str = f"option reslim={max(30, 30 + time_remaining)};"
+ # note: our time limit will be overridden by any
+ # time limits specified by the user through a
+ # GAMS optfile, but tracking down the optfile
+ # and/or the GAMS subsolver specific option
+ # is more difficult
+ reslim_str = "option reslim=" f"{max(time_limit_buffer, time_remaining)};"
if isinstance(solver.options["add_options"], list):
solver.options["add_options"].append(reslim_str)
else:
@@ -289,7 +302,16 @@ def adjust_solver_time_settings(timing_data_obj, solver, config):
if isinstance(solver, SolverFactory.get_class("baron")):
options_key = "MaxTime"
elif isinstance(solver, SolverFactory.get_class("ipopt")):
- options_key = "max_cpu_time"
+ options_key = (
+ # IPOPT 3.14.0+ added support for specifying
+ # wall time limit explicitly; this is preferred
+ # over CPU time limit
+ "max_wall_time"
+ if solver.version() >= (3, 14, 0, 0)
+ else "max_cpu_time"
+ )
+ elif isinstance(solver, SolverFactory.get_class("scip")):
+ options_key = "limits/time"
else:
options_key = None
@@ -297,8 +319,19 @@ def adjust_solver_time_settings(timing_data_obj, solver, config):
custom_setting_present = options_key in solver.options
original_max_time_setting = solver.options[options_key]
- # ensure positive value assigned to avoid application error
- solver.options[options_key] = max(30, 30 + time_remaining)
+ # account for elapsed time remaining and
+ # original time limit setting.
+ # if no original time limit is set, then we assume
+ # there is no time limit, rather than tracking
+ # down the solver-specific default
+ orig_max_time = (
+ float("inf")
+ if original_max_time_setting is None
+ else original_max_time_setting
+ )
+ solver.options[options_key] = min(
+ max(time_limit_buffer, time_remaining), orig_max_time
+ )
else:
custom_setting_present = False
original_max_time_setting = None
@@ -345,6 +378,8 @@ def revert_solver_max_time_adjustment(
options_key = "MaxTime"
elif isinstance(solver, SolverFactory.get_class("ipopt")):
options_key = "max_cpu_time"
+ elif isinstance(solver, SolverFactory.get_class("scip")):
+ options_key = "limits/time"
else:
options_key = None
@@ -359,12 +394,7 @@ def revert_solver_max_time_adjustment(
if isinstance(solver, type(SolverFactory("gams", solver_io="shell"))):
solver.options[options_key].pop()
else:
- # remove the max time specification introduced.
- # All lines are needed here to completely remove the option
- # from access through getattr and dictionary reference.
delattr(solver.options, options_key)
- if options_key in solver.options.keys():
- del solver.options[options_key]
class PreformattedLogger(logging.Logger):
@@ -445,51 +475,6 @@ def setup_pyros_logger(name=DEFAULT_LOGGER_NAME):
return logger
-def a_logger(str_or_logger):
- """
- Standardize a string or logger object to a logger object.
-
- Parameters
- ----------
- str_or_logger : str or logging.Logger
- String or logger object to normalize.
-
- Returns
- -------
- logging.Logger
- If `str_or_logger` is of type `logging.Logger`,then
- `str_or_logger` is returned.
- Otherwise, ``logging.getLogger(str_or_logger)``
- is returned. In the event `str_or_logger` is
- the name of the default PyROS logger, the logger level
- is set to `logging.INFO`, and a `PreformattedLogger`
- instance is returned in lieu of a standard `Logger`
- instance.
- """
- if isinstance(str_or_logger, logging.Logger):
- return logging.getLogger(str_or_logger.name)
- else:
- return logging.getLogger(str_or_logger)
-
-
-def ValidEnum(enum_class):
- '''
- Python 3 dependent format string
- '''
-
- def fcn(obj):
- if obj not in enum_class:
- raise ValueError(
- "Expected an {0} object, "
- "instead received {1}".format(
- enum_class.__name__, obj.__class__.__name__
- )
- )
- return obj
-
- return fcn
-
-
class pyrosTerminationCondition(Enum):
"""Enumeration of all possible PyROS termination conditions."""
@@ -568,14 +553,6 @@ def recast_to_min_obj(model, obj):
obj.sense = minimize
-def model_is_valid(model):
- """
- Assess whether model is valid on basis of the number of active
- Objectives. A valid model must contain exactly one active Objective.
- """
- return len(list(model.component_data_objects(Objective, active=True))) == 1
-
-
def turn_bounds_to_constraints(variable, model, config=None):
'''
Turn the variable in question's "bounds" into direct inequality constraints on the model.
@@ -659,41 +636,6 @@ def get_time_from_solver(results):
return float("nan") if solve_time is None else solve_time
-def validate_uncertainty_set(config):
- '''
- Confirm expression output from uncertainty set function references all q in q.
- Typecheck the uncertainty_set.q is Params referenced inside of m.
- Give warning that the nominal point (default value in the model) is not in the specified uncertainty set.
- :param config: solver config
- '''
- # === Check that q in UncertaintySet object constraint expression is referencing q in model.uncertain_params
- uncertain_params = config.uncertain_params
-
- # === Non-zero number of uncertain parameters
- if len(uncertain_params) == 0:
- raise AttributeError(
- "Must provide uncertain params, uncertain_params list length is 0."
- )
- # === No duplicate parameters
- if len(uncertain_params) != len(ComponentSet(uncertain_params)):
- raise AttributeError("No duplicates allowed for uncertain param objects.")
- # === Ensure nominal point is in the set
- if not config.uncertainty_set.point_in_set(
- point=config.nominal_uncertain_param_vals
- ):
- raise AttributeError(
- "Nominal point for uncertain parameters must be in the uncertainty set."
- )
- # === Check set validity via boundedness and non-emptiness
- if not config.uncertainty_set.is_valid(config=config):
- raise AttributeError(
- "Invalid uncertainty set detected. Check the uncertainty set object to "
- "ensure non-emptiness and boundedness."
- )
-
- return
-
-
def add_bounds_for_uncertain_parameters(model, config):
'''
This function solves a set of optimization problems to determine bounds on the uncertain parameters
@@ -873,98 +815,345 @@ def replace_uncertain_bounds_with_constraints(model, uncertain_params):
v.setlb(None)
-def validate_kwarg_inputs(model, config):
- '''
- Confirm kwarg inputs satisfy PyROS requirements.
- :param model: the deterministic model
- :param config: the config for this PyROS instance
- :return:
- '''
-
- # === Check if model is ConcreteModel object
- if not isinstance(model, ConcreteModel):
- raise ValueError("Model passed to PyROS solver must be a ConcreteModel object.")
+def check_components_descended_from_model(model, components, components_name, config):
+ """
+ Check all members in a provided sequence of Pyomo component
+ objects are descended from a given ConcreteModel object.
- first_stage_variables = config.first_stage_variables
- second_stage_variables = config.second_stage_variables
- uncertain_params = config.uncertain_params
+ Parameters
+ ----------
+ model : ConcreteModel
+ Model from which components should all be descended.
+ components : Iterable of Component
+ Components of interest.
+ components_name : str
+ Brief description or name for the sequence of components.
+ Used for constructing error messages.
+ config : ConfigDict
+ PyROS solver options.
- if not config.first_stage_variables and not config.second_stage_variables:
- # Must have non-zero DOF
+ Raises
+ ------
+ ValueError
+ If at least one entry of `components` is not descended
+ from `model`.
+ """
+ components_not_in_model = [comp for comp in components if comp.model() is not model]
+ if components_not_in_model:
+ comp_names_str = "\n ".join(
+ f"{comp.name!r}, from model with name {comp.model().name!r}"
+ for comp in components_not_in_model
+ )
+ config.progress_logger.error(
+ f"The following {components_name} "
+ "are not descended from the "
+ f"input deterministic model with name {model.name!r}:\n "
+ f"{comp_names_str}"
+ )
raise ValueError(
- "first_stage_variables and "
- "second_stage_variables cannot both be empty lists."
+ f"Found entries of {components_name} "
+ "not descended from input model. "
+ "Check logger output messages."
)
- if ComponentSet(first_stage_variables) != ComponentSet(
- config.first_stage_variables
- ):
+
+def get_state_vars(blk, first_stage_variables, second_stage_variables):
+ """
+ Get state variables of a modeling block.
+
+ The state variables with respect to `blk` are the unfixed
+ `VarData` objects participating in the active objective
+ or constraints descended from `blk` which are not
+ first-stage variables or second-stage variables.
+
+ Parameters
+ ----------
+ blk : ScalarBlock
+ Block of interest.
+ first_stage_variables : Iterable of VarData
+ First-stage variables.
+ second_stage_variables : Iterable of VarData
+ Second-stage variables.
+
+ Yields
+ ------
+ VarData
+ State variable.
+ """
+ dof_var_set = ComponentSet(first_stage_variables) | ComponentSet(
+ second_stage_variables
+ )
+ for var in get_vars_from_component(blk, (Objective, Constraint)):
+ is_state_var = not var.fixed and var not in dof_var_set
+ if is_state_var:
+ yield var
+
+
+def check_variables_continuous(model, vars, config):
+ """
+ Check that all DOF and state variables of the model
+ are continuous.
+
+ Parameters
+ ----------
+ model : ConcreteModel
+ Input deterministic model.
+ config : ConfigDict
+ PyROS solver options.
+
+ Raises
+ ------
+ ValueError
+ If at least one variable is found to not be continuous.
+
+ Note
+ ----
+ A variable is considered continuous if the `is_continuous()`
+ method returns True.
+ """
+ non_continuous_vars = [var for var in vars if not var.is_continuous()]
+ if non_continuous_vars:
+ non_continuous_vars_str = "\n ".join(
+ f"{var.name!r}" for var in non_continuous_vars
+ )
+ config.progress_logger.error(
+ f"The following Vars of model with name {model.name!r} "
+ f"are non-continuous:\n {non_continuous_vars_str}\n"
+ "Ensure all model variables passed to PyROS solver are continuous."
+ )
raise ValueError(
- "All elements in first_stage_variables must be Var members of the model object."
+ f"Model with name {model.name!r} contains non-continuous Vars."
)
- if ComponentSet(second_stage_variables) != ComponentSet(
- config.second_stage_variables
- ):
+
+def validate_model(model, config):
+ """
+ Validate deterministic model passed to PyROS solver.
+
+ Parameters
+ ----------
+ model : ConcreteModel
+ Deterministic model. Should have only one active Objective.
+ config : ConfigDict
+ PyROS solver options.
+
+ Returns
+ -------
+ ComponentSet
+ The variables participating in the active Objective
+ and Constraint expressions of `model`.
+
+ Raises
+ ------
+ TypeError
+ If model is not of type ConcreteModel.
+ ValueError
+ If model does not have exactly one active Objective
+ component.
+ """
+ # note: only support ConcreteModel. no support for Blocks
+ if not isinstance(model, ConcreteModel):
+ raise TypeError(
+ f"Model should be of type {ConcreteModel.__name__}, "
+ f"but is of type {type(model).__name__}."
+ )
+
+ # active objectives check
+ active_objs_list = list(
+ model.component_data_objects(Objective, active=True, descend_into=True)
+ )
+ if len(active_objs_list) != 1:
raise ValueError(
- "All elements in second_stage_variables must be Var members of the model object."
+ "Expected model with exactly 1 active objective, but "
+ f"model provided has {len(active_objs_list)}."
)
- if any(
- v in ComponentSet(second_stage_variables)
- for v in ComponentSet(first_stage_variables)
- ):
+
+def validate_variable_partitioning(model, config):
+ """
+ Check that partitioning of the first-stage variables,
+ second-stage variables, and uncertain parameters
+ is valid.
+
+ Parameters
+ ----------
+ model : ConcreteModel
+ Input deterministic model.
+ config : ConfigDict
+ PyROS solver options.
+
+ Returns
+ -------
+ list of VarData
+ State variables of the model.
+
+ Raises
+ ------
+ ValueError
+ If first-stage variables and second-stage variables
+ overlap, or there are no first-stage variables
+ and no second-stage variables.
+ """
+ # at least one DOF required
+ if not config.first_stage_variables and not config.second_stage_variables:
raise ValueError(
- "No common elements allowed between first_stage_variables and second_stage_variables."
+ "Arguments `first_stage_variables` and "
+ "`second_stage_variables` are both empty lists."
)
- if ComponentSet(uncertain_params) != ComponentSet(config.uncertain_params):
+ # ensure no overlap between DOF var sets
+ overlapping_vars = ComponentSet(config.first_stage_variables) & ComponentSet(
+ config.second_stage_variables
+ )
+ if overlapping_vars:
+ overlapping_var_list = "\n ".join(f"{var.name!r}" for var in overlapping_vars)
+ config.progress_logger.error(
+ "The following Vars were found in both `first_stage_variables`"
+ f"and `second_stage_variables`:\n {overlapping_var_list}"
+ "\nEnsure no Vars are included in both arguments."
+ )
raise ValueError(
- "uncertain_params must be mutable Param members of the model object."
+ "Arguments `first_stage_variables` and `second_stage_variables` "
+ "contain at least one common Var object."
)
- if not config.uncertainty_set:
+ state_vars = list(
+ get_state_vars(
+ model,
+ first_stage_variables=config.first_stage_variables,
+ second_stage_variables=config.second_stage_variables,
+ )
+ )
+ var_type_list_map = {
+ "first-stage variables": config.first_stage_variables,
+ "second-stage variables": config.second_stage_variables,
+ "state variables": state_vars,
+ }
+ for desc, vars in var_type_list_map.items():
+ check_components_descended_from_model(
+ model=model, components=vars, components_name=desc, config=config
+ )
+
+ all_vars = config.first_stage_variables + config.second_stage_variables + state_vars
+ check_variables_continuous(model, all_vars, config)
+
+ return state_vars
+
+
+def validate_uncertainty_specification(model, config):
+ """
+ Validate specification of uncertain parameters and uncertainty
+ set.
+
+ Parameters
+ ----------
+ model : ConcreteModel
+ Input deterministic model.
+ config : ConfigDict
+ PyROS solver options.
+
+ Raises
+ ------
+ ValueError
+ If at least one of the following holds:
+
+ - dimension of uncertainty set does not equal number of
+ uncertain parameters
+ - uncertainty set `is_valid()` method does not return
+ true.
+ - nominal parameter realization is not in the uncertainty set.
+ """
+ check_components_descended_from_model(
+ model=model,
+ components=config.uncertain_params,
+ components_name="uncertain parameters",
+ config=config,
+ )
+
+ if len(config.uncertain_params) != config.uncertainty_set.dim:
raise ValueError(
- "An UncertaintySet object must be provided to the PyROS solver."
+ "Length of argument `uncertain_params` does not match dimension "
+ "of argument `uncertainty_set` "
+ f"({len(config.uncertain_params)} != {config.uncertainty_set.dim})."
)
- non_mutable_params = []
- for p in config.uncertain_params:
- if not (
- not p.is_constant() and p.is_fixed() and not p.is_potentially_variable()
- ):
- non_mutable_params.append(p)
- if non_mutable_params:
- raise ValueError(
- "Param objects which are uncertain must have attribute mutable=True. "
- "Offending Params: %s" % [p.name for p in non_mutable_params]
- )
+ # validate uncertainty set
+ if not config.uncertainty_set.is_valid(config=config):
+ raise ValueError(
+ f"Uncertainty set {config.uncertainty_set} is invalid, "
+ "as it is either empty or unbounded."
+ )
- # === Solvers provided check
- if not config.local_solver or not config.global_solver:
+ # fill-in nominal point as necessary, if not provided.
+ # otherwise, check length matches uncertainty dimension
+ if not config.nominal_uncertain_param_vals:
+ config.nominal_uncertain_param_vals = [
+ value(param, exception=True) for param in config.uncertain_params
+ ]
+ elif len(config.nominal_uncertain_param_vals) != len(config.uncertain_params):
raise ValueError(
- "User must designate both a local and global optimization solver via the local_solver"
- " and global_solver options."
+ "Lengths of arguments `uncertain_params` and "
+ "`nominal_uncertain_param_vals` "
+ "do not match "
+ f"({len(config.uncertain_params)} != "
+ f"{len(config.nominal_uncertain_param_vals)})."
)
- if config.bypass_local_separation and config.bypass_global_separation:
+ # uncertainty set should contain nominal point
+ nominal_point_in_set = config.uncertainty_set.point_in_set(
+ point=config.nominal_uncertain_param_vals
+ )
+ if not nominal_point_in_set:
raise ValueError(
- "User cannot simultaneously enable options "
- "'bypass_local_separation' and "
- "'bypass_global_separation'."
+ "Nominal uncertain parameter realization "
+ f"{config.nominal_uncertain_param_vals} "
+ "is not a point in the uncertainty set "
+ f"{config.uncertainty_set!r}."
)
- # === Degrees of freedom provided check
- if len(config.first_stage_variables) + len(config.second_stage_variables) == 0:
+
+def validate_separation_problem_options(model, config):
+ """
+ Validate separation problem arguments to the PyROS solver.
+
+ Parameters
+ ----------
+ model : ConcreteModel
+ Input deterministic model.
+ config : ConfigDict
+ PyROS solver options.
+
+ Raises
+ ------
+ ValueError
+ If options `bypass_local_separation` and
+ `bypass_global_separation` are set to False.
+ """
+ if config.bypass_local_separation and config.bypass_global_separation:
raise ValueError(
- "User must designate at least one first- and/or second-stage variable."
+ "Arguments `bypass_local_separation` "
+ "and `bypass_global_separation` "
+ "cannot both be True."
)
- # === Uncertain params provided check
- if len(config.uncertain_params) == 0:
- raise ValueError("User must designate at least one uncertain parameter.")
- return
+def validate_pyros_inputs(model, config):
+ """
+ Perform advanced validation of PyROS solver arguments.
+
+ Parameters
+ ----------
+ model : ConcreteModel
+ Input deterministic model.
+ config : ConfigDict
+ PyROS solver options.
+ """
+ validate_model(model, config)
+ state_vars = validate_variable_partitioning(model, config)
+ validate_uncertainty_specification(model, config)
+ validate_separation_problem_options(model, config)
+
+ return state_vars
def substitute_ssv_in_dr_constraints(model, constraint):
@@ -1572,6 +1761,80 @@ def process_termination_condition_master_problem(config, results):
)
+def call_solver(model, solver, config, timing_obj, timer_name, err_msg):
+ """
+ Solve a model with a given optimizer, keeping track of
+ wall time requirements.
+
+ Parameters
+ ----------
+ model : ConcreteModel
+ Model of interest.
+ solver : Pyomo solver type
+ Subordinate optimizer.
+ config : ConfigDict
+ PyROS solver settings.
+ timing_obj : TimingData
+ PyROS solver timing data object.
+ timer_name : str
+ Name of sub timer under the hierarchical timer contained in
+ ``timing_obj`` to start/stop for keeping track of solve
+ time requirements.
+ err_msg : str
+ Message to log through ``config.progress_logger.exception()``
+ in event an ApplicationError is raised while attempting to
+ solve the model.
+
+ Returns
+ -------
+ SolverResults
+ Solve results. Note that ``results.solver`` contains
+ an additional attribute, named after
+ ``TIC_TOC_SOLVE_TIME_ATTR``, of which the value is set to the
+ recorded solver wall time.
+
+ Raises
+ ------
+ ApplicationError
+ If ApplicationError is raised by the solver.
+ In this case, `err_msg` is logged through
+ ``config.progress_logger.exception()`` before
+ the exception is raised.
+ """
+ tt_timer = TicTocTimer()
+
+ orig_setting, custom_setting_present = adjust_solver_time_settings(
+ timing_obj, solver, config
+ )
+ timing_obj.start_timer(timer_name)
+ tt_timer.tic(msg=None)
+
+ try:
+ results = solver.solve(
+ model,
+ tee=config.tee,
+ load_solutions=False,
+ symbolic_solver_labels=config.symbolic_solver_labels,
+ )
+ except ApplicationError:
+ # account for possible external subsolver errors
+ # (such as segmentation faults, function evaluation
+ # errors, etc.)
+ config.progress_logger.error(err_msg)
+ raise
+ else:
+ setattr(
+ results.solver, TIC_TOC_SOLVE_TIME_ATTR, tt_timer.toc(msg=None, delta=True)
+ )
+ finally:
+ timing_obj.stop_timer(timer_name)
+ revert_solver_max_time_adjustment(
+ solver, orig_setting, custom_setting_present, config
+ )
+
+ return results
+
+
class IterationLogRecord:
"""
PyROS solver iteration log record.
diff --git a/pyomo/contrib/simplification/__init__.py b/pyomo/contrib/simplification/__init__.py
new file mode 100644
index 00000000000..c6111ddcb89
--- /dev/null
+++ b/pyomo/contrib/simplification/__init__.py
@@ -0,0 +1,12 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from .simplify import Simplifier
diff --git a/pyomo/contrib/simplification/build.py b/pyomo/contrib/simplification/build.py
new file mode 100644
index 00000000000..b4bec63088a
--- /dev/null
+++ b/pyomo/contrib/simplification/build.py
@@ -0,0 +1,209 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 glob
+import logging
+import os
+import shutil
+import sys
+import subprocess
+
+from pyomo.common.download import FileDownloader
+from pyomo.common.envvar import PYOMO_CONFIG_DIR
+from pyomo.common.fileutils import find_library, this_file_dir
+from pyomo.common.tempfiles import TempfileManager
+
+logger = logging.getLogger(__name__ if __name__ != '__main__' else 'pyomo')
+
+
+def build_ginac_library(parallel=None, argv=None, env=None):
+ sys.stdout.write("\n**** Building GiNaC library ****\n")
+
+ configure_cmd = [
+ os.path.join('.', 'configure'),
+ '--prefix=' + PYOMO_CONFIG_DIR,
+ '--disable-static',
+ ]
+ make_cmd = ['make']
+ if parallel:
+ make_cmd.append(f'-j{parallel}')
+ install_cmd = ['make', 'install']
+
+ env = dict(os.environ)
+ pcdir = os.path.join(PYOMO_CONFIG_DIR, 'lib', 'pkgconfig')
+ if 'PKG_CONFIG_PATH' in env:
+ pcdir += os.pathsep + env['PKG_CONFIG_PATH']
+ env['PKG_CONFIG_PATH'] = pcdir
+
+ with TempfileManager.new_context() as tempfile:
+ tmpdir = tempfile.mkdtemp()
+
+ downloader = FileDownloader()
+ if argv:
+ downloader.parse_args(argv)
+
+ url = 'https://www.ginac.de/CLN/cln-1.3.7.tar.bz2'
+ cln_dir = os.path.join(tmpdir, 'cln')
+ downloader.set_destination_filename(cln_dir)
+ logger.info(
+ "Fetching CLN from %s and installing it to %s"
+ % (url, downloader.destination())
+ )
+ downloader.get_tar_archive(url, dirOffset=1)
+ assert subprocess.run(configure_cmd, cwd=cln_dir, env=env).returncode == 0
+ logger.info("\nBuilding CLN\n")
+ assert subprocess.run(make_cmd, cwd=cln_dir, env=env).returncode == 0
+ assert subprocess.run(install_cmd, cwd=cln_dir, env=env).returncode == 0
+
+ url = 'https://www.ginac.de/ginac-1.8.7.tar.bz2'
+ ginac_dir = os.path.join(tmpdir, 'ginac')
+ downloader.set_destination_filename(ginac_dir)
+ logger.info(
+ "Fetching GiNaC from %s and installing it to %s"
+ % (url, downloader.destination())
+ )
+ downloader.get_tar_archive(url, dirOffset=1)
+ assert subprocess.run(configure_cmd, cwd=ginac_dir, env=env).returncode == 0
+ logger.info("\nBuilding GiNaC\n")
+ assert subprocess.run(make_cmd, cwd=ginac_dir, env=env).returncode == 0
+ assert subprocess.run(install_cmd, cwd=ginac_dir, env=env).returncode == 0
+ print("Installed GiNaC to %s" % (ginac_dir,))
+
+
+def _find_include(libdir, incpaths):
+ rel_path = ('include',) + incpaths
+ while 1:
+ basedir = os.path.dirname(libdir)
+ if not basedir or basedir == libdir:
+ return None
+ if os.path.exists(os.path.join(basedir, *rel_path)):
+ return os.path.join(basedir, *(rel_path[: -len(incpaths)]))
+ libdir = basedir
+
+
+def build_ginac_interface(parallel=None, args=None):
+ from distutils.dist import Distribution
+ from pybind11.setup_helpers import Pybind11Extension, build_ext
+ from pyomo.common.cmake_builder import handleReadonly
+
+ sys.stdout.write("\n**** Building GiNaC interface ****\n")
+
+ if args is None:
+ args = []
+ sources = [
+ os.path.join(this_file_dir(), 'ginac', 'src', fname)
+ for fname in ['ginac_interface.cpp']
+ ]
+
+ ginac_lib = find_library('ginac')
+ if not ginac_lib:
+ raise RuntimeError(
+ 'could not find the GiNaC library; please make sure either to install '
+ 'the library and development headers system-wide, or include the '
+ 'path to the library in the LD_LIBRARY_PATH environment variable'
+ )
+ ginac_lib_dir = os.path.dirname(ginac_lib)
+ ginac_include_dir = _find_include(ginac_lib_dir, ('ginac', 'ginac.h'))
+ if not ginac_include_dir:
+ raise RuntimeError('could not find GiNaC include directory')
+
+ cln_lib = find_library('cln')
+ if not cln_lib:
+ raise RuntimeError(
+ 'could not find the CLN library; please make sure either to install '
+ 'the library and development headers system-wide, or include the '
+ 'path to the library in the LD_LIBRARY_PATH environment variable'
+ )
+ cln_lib_dir = os.path.dirname(cln_lib)
+ cln_include_dir = _find_include(cln_lib_dir, ('cln', 'cln.h'))
+ if not cln_include_dir:
+ raise RuntimeError('could not find CLN include directory')
+
+ extra_args = ['-std=c++11']
+ ext = Pybind11Extension(
+ 'ginac_interface',
+ sources=sources,
+ language='c++',
+ include_dirs=[cln_include_dir, ginac_include_dir],
+ library_dirs=[cln_lib_dir, ginac_lib_dir],
+ libraries=['cln', 'ginac'],
+ extra_compile_args=extra_args,
+ )
+
+ class ginacBuildExt(build_ext):
+ def run(self):
+ basedir = os.path.abspath(os.path.curdir)
+ with TempfileManager.new_context() as tempfile:
+ if self.inplace:
+ tmpdir = os.path.join(this_file_dir(), 'ginac')
+ else:
+ tmpdir = os.path.abspath(tempfile.mkdtemp())
+ sys.stdout.write("Building in '%s'\n" % tmpdir)
+ os.chdir(tmpdir)
+ super(ginacBuildExt, self).run()
+ if not self.inplace:
+ library = glob.glob("build/*/ginac_interface.*")[0]
+ target = os.path.join(
+ PYOMO_CONFIG_DIR,
+ 'lib',
+ 'python%s.%s' % sys.version_info[:2],
+ 'site-packages',
+ '.',
+ )
+ if not os.path.exists(target):
+ os.makedirs(target)
+ sys.stdout.write(f"Installing {library} in {target}\n")
+ shutil.copy(library, target)
+
+ package_config = {
+ 'name': 'ginac_interface',
+ 'packages': [],
+ 'ext_modules': [ext],
+ 'cmdclass': {"build_ext": ginacBuildExt},
+ }
+
+ dist = Distribution(package_config)
+ dist.script_args = ['build_ext'] + args
+ dist.parse_command_line()
+ dist.run_command('build_ext')
+
+
+class GiNaCInterfaceBuilder(object):
+ def __call__(self, parallel):
+ return build_ginac_interface(parallel)
+
+ def skip(self):
+ return not find_library('ginac')
+
+
+if __name__ == '__main__':
+ import argparse
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ "-j",
+ dest='parallel',
+ type=int,
+ default=None,
+ help="Enable parallel build with PARALLEL cores",
+ )
+ parser.add_argument(
+ "--build-deps",
+ dest='build_deps',
+ action='store_true',
+ default=False,
+ help="Download and build the CLN/GiNaC libraries",
+ )
+ options, argv = parser.parse_known_args(sys.argv)
+ logging.getLogger('pyomo').setLevel(logging.INFO)
+ if options.build_deps:
+ build_ginac_library(options.parallel, [])
+ build_ginac_interface(options.parallel, argv[1:])
diff --git a/pyomo/contrib/simplification/ginac/__init__.py b/pyomo/contrib/simplification/ginac/__init__.py
new file mode 100644
index 00000000000..6896bec12c4
--- /dev/null
+++ b/pyomo/contrib/simplification/ginac/__init__.py
@@ -0,0 +1,52 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.common.dependencies import attempt_import as _attempt_import
+
+
+def _importer():
+ import os
+ import sys
+ from ctypes import cdll
+ from pyomo.common.envvar import PYOMO_CONFIG_DIR
+ from pyomo.common.fileutils import find_library
+
+ try:
+ pyomo_config_dir = os.path.join(
+ PYOMO_CONFIG_DIR,
+ 'lib',
+ 'python%s.%s' % sys.version_info[:2],
+ 'site-packages',
+ )
+ sys.path.insert(0, pyomo_config_dir)
+ # GiNaC needs 2 libraries that are generally dynamically linked
+ # to the interface library. If we built those ourselves, then
+ # the libraries will be PYOMO_CONFIG_DIR/lib ... but that
+ # directory is very likely to NOT be on the library search path
+ # when the Python interpreter was started. We will manually
+ # look for those two libraries, and if we find them, load them
+ # into this process (so the interface can find them)
+ for lib in ('cln', 'ginac'):
+ fname = find_library(lib)
+ if fname is not None:
+ cdll.LoadLibrary(fname)
+
+ import ginac_interface
+ except ImportError:
+ from . import ginac_interface
+ finally:
+ assert sys.path[0] == pyomo_config_dir
+ sys.path.pop(0)
+
+ return ginac_interface
+
+
+interface, interface_available = _attempt_import('ginac_interface', importer=_importer)
diff --git a/pyomo/contrib/simplification/ginac/src/ginac_interface.cpp b/pyomo/contrib/simplification/ginac/src/ginac_interface.cpp
new file mode 100644
index 00000000000..9b05baf71ca
--- /dev/null
+++ b/pyomo/contrib/simplification/ginac/src/ginac_interface.cpp
@@ -0,0 +1,332 @@
+// ___________________________________________________________________________
+//
+// Pyomo: Python Optimization Modeling Objects
+// Copyright (c) 2008-2024
+// 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.
+// ___________________________________________________________________________
+
+#include "ginac_interface.hpp"
+
+
+bool is_integer(double x) {
+ return std::floor(x) == x;
+}
+
+
+ex ginac_expr_from_pyomo_node(
+ py::handle expr,
+ std::unordered_map &leaf_map,
+ std::unordered_map &ginac_pyomo_map,
+ PyomoExprTypes &expr_types,
+ bool symbolic_solver_labels
+ ) {
+ ex res;
+ ExprType tmp_type =
+ expr_types.expr_type_map[py::type::of(expr)].cast();
+
+ switch (tmp_type) {
+ case py_float: {
+ double val = expr.cast();
+ if (is_integer(val)) {
+ res = numeric((long) val);
+ }
+ else {
+ res = numeric(val);
+ }
+ break;
+ }
+ case var: {
+ long expr_id = expr_types.id(expr).cast();
+ if (leaf_map.count(expr_id) == 0) {
+ std::string vname;
+ if (symbolic_solver_labels) {
+ vname = expr.attr("name").cast();
+ }
+ else {
+ vname = "x" + std::to_string(expr_id);
+ }
+ py::object lb = expr.attr("lb");
+ if (lb.is_none() || lb.cast() < 0) {
+ leaf_map[expr_id] = realsymbol(vname);
+ }
+ else {
+ leaf_map[expr_id] = possymbol(vname);
+ }
+ ginac_pyomo_map[leaf_map[expr_id]] = expr.cast();
+ }
+ res = leaf_map[expr_id];
+ break;
+ }
+ case param: {
+ long expr_id = expr_types.id(expr).cast();
+ if (leaf_map.count(expr_id) == 0) {
+ std::string pname;
+ if (symbolic_solver_labels) {
+ pname = expr.attr("name").cast();
+ }
+ else {
+ pname = "p" + std::to_string(expr_id);
+ }
+ leaf_map[expr_id] = realsymbol(pname);
+ ginac_pyomo_map[leaf_map[expr_id]] = expr.cast();
+ }
+ res = leaf_map[expr_id];
+ break;
+ }
+ case product: {
+ py::list pyomo_args = expr.attr("args");
+ res = ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels) * ginac_expr_from_pyomo_node(pyomo_args[1], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels);
+ break;
+ }
+ case sum: {
+ py::list pyomo_args = expr.attr("args");
+ for (py::handle arg : pyomo_args) {
+ res += ginac_expr_from_pyomo_node(arg, leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels);
+ }
+ break;
+ }
+ case negation: {
+ py::list pyomo_args = expr.attr("args");
+ res = - ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels);
+ break;
+ }
+ case external_func: {
+ long expr_id = expr_types.id(expr).cast();
+ if (leaf_map.count(expr_id) == 0) {
+ leaf_map[expr_id] = realsymbol("f" + std::to_string(expr_id));
+ ginac_pyomo_map[leaf_map[expr_id]] = expr.cast();
+ }
+ res = leaf_map[expr_id];
+ break;
+ }
+ case ExprType::power: {
+ py::list pyomo_args = expr.attr("args");
+ res = pow(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels), ginac_expr_from_pyomo_node(pyomo_args[1], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ break;
+ }
+ case division: {
+ py::list pyomo_args = expr.attr("args");
+ res = ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels) / ginac_expr_from_pyomo_node(pyomo_args[1], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels);
+ break;
+ }
+ case unary_func: {
+ std::string function_name = expr.attr("getname")().cast();
+ py::list pyomo_args = expr.attr("args");
+ if (function_name == "exp")
+ res = exp(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else if (function_name == "log")
+ res = log(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else if (function_name == "sin")
+ res = sin(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else if (function_name == "cos")
+ res = cos(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else if (function_name == "tan")
+ res = tan(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else if (function_name == "asin")
+ res = asin(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else if (function_name == "acos")
+ res = acos(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else if (function_name == "atan")
+ res = atan(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else if (function_name == "sqrt")
+ res = sqrt(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ else
+ throw py::value_error("Unrecognized expression type: " + function_name);
+ break;
+ }
+ case linear: {
+ py::list pyomo_args = expr.attr("args");
+ for (py::handle arg : pyomo_args) {
+ res += ginac_expr_from_pyomo_node(arg, leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels);
+ }
+ break;
+ }
+ case named_expr: {
+ res = ginac_expr_from_pyomo_node(expr.attr("expr"), leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels);
+ break;
+ }
+ case numeric_constant: {
+ res = numeric(expr.attr("value").cast());
+ break;
+ }
+ case pyomo_unit: {
+ res = numeric(1.0);
+ break;
+ }
+ case unary_abs: {
+ py::list pyomo_args = expr.attr("args");
+ res = abs(ginac_expr_from_pyomo_node(pyomo_args[0], leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels));
+ break;
+ }
+ default: {
+ throw py::value_error("Unrecognized expression type: " +
+ expr_types.builtins.attr("str")(py::type::of(expr))
+ .cast());
+ break;
+ }
+ }
+ return res;
+}
+
+ex pyomo_expr_to_ginac_expr(
+ py::handle expr,
+ std::unordered_map &leaf_map,
+ std::unordered_map &ginac_pyomo_map,
+ PyomoExprTypes &expr_types,
+ bool symbolic_solver_labels
+ ) {
+ ex res = ginac_expr_from_pyomo_node(expr, leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels);
+ return res;
+ }
+
+ex pyomo_to_ginac(py::handle expr, PyomoExprTypes &expr_types) {
+ std::unordered_map leaf_map;
+ std::unordered_map ginac_pyomo_map;
+ ex res = ginac_expr_from_pyomo_node(expr, leaf_map, ginac_pyomo_map, expr_types, true);
+ return res;
+}
+
+
+class GinacToPyomoVisitor
+: public visitor,
+ public symbol::visitor,
+ public numeric::visitor,
+ public add::visitor,
+ public mul::visitor,
+ public GiNaC::power::visitor,
+ public function::visitor,
+ public basic::visitor
+{
+ public:
+ std::unordered_map *leaf_map;
+ std::unordered_map node_map;
+ PyomoExprTypes *expr_types;
+
+ GinacToPyomoVisitor(std::unordered_map *_leaf_map, PyomoExprTypes *_expr_types) : leaf_map(_leaf_map), expr_types(_expr_types) {}
+ ~GinacToPyomoVisitor() = default;
+
+ void visit(const symbol& e) {
+ node_map[e] = leaf_map->at(e);
+ }
+
+ void visit(const numeric& e) {
+ double val = e.to_double();
+ node_map[e] = expr_types->NumericConstant(py::cast(val));
+ }
+
+ void visit(const add& e) {
+ size_t n = e.nops();
+ py::object pe = node_map[e.op(0)];
+ for (unsigned long ndx=1; ndx < n; ++ndx) {
+ pe = pe.attr("__add__")(node_map[e.op(ndx)]);
+ }
+ node_map[e] = pe;
+ }
+
+ void visit(const mul& e) {
+ size_t n = e.nops();
+ py::object pe = node_map[e.op(0)];
+ for (unsigned long ndx=1; ndx < n; ++ndx) {
+ pe = pe.attr("__mul__")(node_map[e.op(ndx)]);
+ }
+ node_map[e] = pe;
+ }
+
+ void visit(const GiNaC::power& e) {
+ py::object arg1 = node_map[e.op(0)];
+ py::object arg2 = node_map[e.op(1)];
+ py::object pe = arg1.attr("__pow__")(arg2);
+ node_map[e] = pe;
+ }
+
+ void visit(const function& e) {
+ py::object arg = node_map[e.op(0)];
+ std::string func_type = e.get_name();
+ py::object pe;
+ if (func_type == "exp") {
+ pe = expr_types->exp(arg);
+ }
+ else if (func_type == "log") {
+ pe = expr_types->log(arg);
+ }
+ else if (func_type == "sin") {
+ pe = expr_types->sin(arg);
+ }
+ else if (func_type == "cos") {
+ pe = expr_types->cos(arg);
+ }
+ else if (func_type == "tan") {
+ pe = expr_types->tan(arg);
+ }
+ else if (func_type == "asin") {
+ pe = expr_types->asin(arg);
+ }
+ else if (func_type == "acos") {
+ pe = expr_types->acos(arg);
+ }
+ else if (func_type == "atan") {
+ pe = expr_types->atan(arg);
+ }
+ else if (func_type == "sqrt") {
+ pe = expr_types->sqrt(arg);
+ }
+ else {
+ throw py::value_error("unrecognized unary function: " + func_type);
+ }
+ node_map[e] = pe;
+ }
+
+ void visit(const basic& e) {
+ throw py::value_error("unrecognized ginac expression type");
+ }
+};
+
+
+ex GinacInterface::to_ginac(py::handle expr) {
+ return pyomo_expr_to_ginac_expr(expr, leaf_map, ginac_pyomo_map, expr_types, symbolic_solver_labels);
+}
+
+py::object GinacInterface::from_ginac(ex &ge) {
+ GinacToPyomoVisitor v(&ginac_pyomo_map, &expr_types);
+ ge.traverse_postorder(v);
+ return v.node_map[ge];
+}
+
+PYBIND11_MODULE(ginac_interface, m) {
+ m.def("pyomo_to_ginac", &pyomo_to_ginac);
+ py::class_(m, "PyomoExprTypes", py::module_local())
+ .def(py::init<>());
+ py::class_(m, "ginac_expression")
+ .def("expand", [](ex &ge) {
+ return ge.expand();
+ })
+ .def("normal", &ex::normal)
+ .def("__str__", [](ex &ge) {
+ std::ostringstream stream;
+ stream << ge;
+ return stream.str();
+ });
+ py::class_(m, "GinacInterface")
+ .def(py::init())
+ .def("to_ginac", &GinacInterface::to_ginac)
+ .def("from_ginac", &GinacInterface::from_ginac);
+ py::enum_(m, "ExprType", py::module_local())
+ .value("py_float", ExprType::py_float)
+ .value("var", ExprType::var)
+ .value("param", ExprType::param)
+ .value("product", ExprType::product)
+ .value("sum", ExprType::sum)
+ .value("negation", ExprType::negation)
+ .value("external_func", ExprType::external_func)
+ .value("power", ExprType::power)
+ .value("division", ExprType::division)
+ .value("unary_func", ExprType::unary_func)
+ .value("linear", ExprType::linear)
+ .value("named_expr", ExprType::named_expr)
+ .value("numeric_constant", ExprType::numeric_constant)
+ .export_values();
+}
diff --git a/pyomo/contrib/simplification/ginac/src/ginac_interface.hpp b/pyomo/contrib/simplification/ginac/src/ginac_interface.hpp
new file mode 100644
index 00000000000..bc5b0d7b6fc
--- /dev/null
+++ b/pyomo/contrib/simplification/ginac/src/ginac_interface.hpp
@@ -0,0 +1,190 @@
+#pragma once
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#define PYBIND11_DETAILED_ERROR_MESSAGES
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+using namespace GiNaC;
+
+enum ExprType {
+ py_float = 0,
+ var = 1,
+ param = 2,
+ product = 3,
+ sum = 4,
+ negation = 5,
+ external_func = 6,
+ power = 7,
+ division = 8,
+ unary_func = 9,
+ linear = 10,
+ named_expr = 11,
+ numeric_constant = 12,
+ pyomo_unit = 13,
+ unary_abs = 14
+};
+
+class PyomoExprTypes {
+public:
+ PyomoExprTypes() {
+ expr_type_map[int_] = py_float;
+ expr_type_map[float_] = py_float;
+ expr_type_map[np_int16] = py_float;
+ expr_type_map[np_int32] = py_float;
+ expr_type_map[np_int64] = py_float;
+ expr_type_map[np_longlong] = py_float;
+ expr_type_map[np_uint16] = py_float;
+ expr_type_map[np_uint32] = py_float;
+ expr_type_map[np_uint64] = py_float;
+ expr_type_map[np_ulonglong] = py_float;
+ expr_type_map[np_float16] = py_float;
+ expr_type_map[np_float32] = py_float;
+ expr_type_map[np_float64] = py_float;
+ expr_type_map[ScalarVar] = var;
+ expr_type_map[_GeneralVarData] = var;
+ expr_type_map[AutoLinkedBinaryVar] = var;
+ expr_type_map[ScalarParam] = param;
+ expr_type_map[_ParamData] = param;
+ expr_type_map[MonomialTermExpression] = product;
+ expr_type_map[ProductExpression] = product;
+ expr_type_map[NPV_ProductExpression] = product;
+ expr_type_map[SumExpression] = sum;
+ expr_type_map[NPV_SumExpression] = sum;
+ expr_type_map[NegationExpression] = negation;
+ expr_type_map[NPV_NegationExpression] = negation;
+ expr_type_map[ExternalFunctionExpression] = external_func;
+ expr_type_map[NPV_ExternalFunctionExpression] = external_func;
+ expr_type_map[PowExpression] = ExprType::power;
+ expr_type_map[NPV_PowExpression] = ExprType::power;
+ expr_type_map[DivisionExpression] = division;
+ expr_type_map[NPV_DivisionExpression] = division;
+ expr_type_map[UnaryFunctionExpression] = unary_func;
+ expr_type_map[NPV_UnaryFunctionExpression] = unary_func;
+ expr_type_map[LinearExpression] = linear;
+ expr_type_map[_GeneralExpressionData] = named_expr;
+ expr_type_map[ScalarExpression] = named_expr;
+ expr_type_map[Integral] = named_expr;
+ expr_type_map[ScalarIntegral] = named_expr;
+ expr_type_map[NumericConstant] = numeric_constant;
+ expr_type_map[_PyomoUnit] = pyomo_unit;
+ expr_type_map[AbsExpression] = unary_abs;
+ expr_type_map[NPV_AbsExpression] = unary_abs;
+ }
+ ~PyomoExprTypes() = default;
+ py::int_ ione = 1;
+ py::float_ fone = 1.0;
+ py::type int_ = py::type::of(ione);
+ py::type float_ = py::type::of(fone);
+ py::object np = py::module_::import("numpy");
+ py::type np_int16 = np.attr("int16");
+ py::type np_int32 = np.attr("int32");
+ py::type np_int64 = np.attr("int64");
+ py::type np_longlong = np.attr("longlong");
+ py::type np_uint16 = np.attr("uint16");
+ py::type np_uint32 = np.attr("uint32");
+ py::type np_uint64 = np.attr("uint64");
+ py::type np_ulonglong = np.attr("ulonglong");
+ py::type np_float16 = np.attr("float16");
+ py::type np_float32 = np.attr("float32");
+ py::type np_float64 = np.attr("float64");
+ py::object ScalarParam =
+ py::module_::import("pyomo.core.base.param").attr("ScalarParam");
+ py::object _ParamData =
+ py::module_::import("pyomo.core.base.param").attr("_ParamData");
+ py::object ScalarVar =
+ py::module_::import("pyomo.core.base.var").attr("ScalarVar");
+ py::object _GeneralVarData =
+ py::module_::import("pyomo.core.base.var").attr("_GeneralVarData");
+ py::object AutoLinkedBinaryVar =
+ py::module_::import("pyomo.gdp.disjunct").attr("AutoLinkedBinaryVar");
+ py::object numeric_expr = py::module_::import("pyomo.core.expr.numeric_expr");
+ py::object NegationExpression = numeric_expr.attr("NegationExpression");
+ py::object NPV_NegationExpression =
+ numeric_expr.attr("NPV_NegationExpression");
+ py::object ExternalFunctionExpression =
+ numeric_expr.attr("ExternalFunctionExpression");
+ py::object NPV_ExternalFunctionExpression =
+ numeric_expr.attr("NPV_ExternalFunctionExpression");
+ py::object PowExpression = numeric_expr.attr("PowExpression");
+ py::object NPV_PowExpression = numeric_expr.attr("NPV_PowExpression");
+ py::object ProductExpression = numeric_expr.attr("ProductExpression");
+ py::object NPV_ProductExpression = numeric_expr.attr("NPV_ProductExpression");
+ py::object MonomialTermExpression =
+ numeric_expr.attr("MonomialTermExpression");
+ py::object DivisionExpression = numeric_expr.attr("DivisionExpression");
+ py::object NPV_DivisionExpression =
+ numeric_expr.attr("NPV_DivisionExpression");
+ py::object SumExpression = numeric_expr.attr("SumExpression");
+ py::object NPV_SumExpression = numeric_expr.attr("NPV_SumExpression");
+ py::object UnaryFunctionExpression =
+ numeric_expr.attr("UnaryFunctionExpression");
+ py::object AbsExpression = numeric_expr.attr("AbsExpression");
+ py::object NPV_AbsExpression = numeric_expr.attr("NPV_AbsExpression");
+ py::object NPV_UnaryFunctionExpression =
+ numeric_expr.attr("NPV_UnaryFunctionExpression");
+ py::object LinearExpression = numeric_expr.attr("LinearExpression");
+ py::object NumericConstant =
+ py::module_::import("pyomo.core.expr.numvalue").attr("NumericConstant");
+ py::object expr_module = py::module_::import("pyomo.core.base.expression");
+ py::object _GeneralExpressionData =
+ expr_module.attr("_GeneralExpressionData");
+ py::object ScalarExpression = expr_module.attr("ScalarExpression");
+ py::object ScalarIntegral =
+ py::module_::import("pyomo.dae.integral").attr("ScalarIntegral");
+ py::object Integral =
+ py::module_::import("pyomo.dae.integral").attr("Integral");
+ py::object _PyomoUnit =
+ py::module_::import("pyomo.core.base.units_container").attr("_PyomoUnit");
+ py::object exp = numeric_expr.attr("exp");
+ py::object log = numeric_expr.attr("log");
+ py::object sin = numeric_expr.attr("sin");
+ py::object cos = numeric_expr.attr("cos");
+ py::object tan = numeric_expr.attr("tan");
+ py::object asin = numeric_expr.attr("asin");
+ py::object acos = numeric_expr.attr("acos");
+ py::object atan = numeric_expr.attr("atan");
+ py::object sqrt = numeric_expr.attr("sqrt");
+ py::object builtins = py::module_::import("builtins");
+ py::object id = builtins.attr("id");
+ py::object len = builtins.attr("len");
+ py::dict expr_type_map;
+};
+
+ex pyomo_to_ginac(py::handle expr, PyomoExprTypes &expr_types);
+
+
+class GinacInterface {
+ public:
+ std::unordered_map leaf_map;
+ std::unordered_map ginac_pyomo_map;
+ PyomoExprTypes expr_types;
+ bool symbolic_solver_labels = false;
+
+ GinacInterface() = default;
+ GinacInterface(bool _symbolic_solver_labels) : symbolic_solver_labels(_symbolic_solver_labels) {}
+ ~GinacInterface() = default;
+
+ ex to_ginac(py::handle expr);
+ py::object from_ginac(ex &ginac_expr);
+};
diff --git a/pyomo/contrib/simplification/plugins.py b/pyomo/contrib/simplification/plugins.py
new file mode 100644
index 00000000000..6b08f7be4d7
--- /dev/null
+++ b/pyomo/contrib/simplification/plugins.py
@@ -0,0 +1,17 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.common.extensions import ExtensionBuilderFactory
+from .build import GiNaCInterfaceBuilder
+
+
+def load():
+ ExtensionBuilderFactory.register('ginac')(GiNaCInterfaceBuilder)
diff --git a/pyomo/contrib/simplification/simplify.py b/pyomo/contrib/simplification/simplify.py
new file mode 100644
index 00000000000..874b5b1e801
--- /dev/null
+++ b/pyomo/contrib/simplification/simplify.py
@@ -0,0 +1,75 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 logging
+import warnings
+
+from pyomo.common.enums import NamedIntEnum
+from pyomo.core.expr.sympy_tools import sympy2pyomo_expression, sympyify_expression
+from pyomo.core.expr.numeric_expr import NumericExpression
+from pyomo.core.expr.numvalue import value, is_constant
+
+from pyomo.contrib.simplification.ginac import (
+ interface as ginac_interface,
+ interface_available as ginac_available,
+)
+
+
+def simplify_with_sympy(expr: NumericExpression):
+ if is_constant(expr):
+ return value(expr)
+ object_map, sympy_expr = sympyify_expression(expr, keep_mutable_parameters=True)
+ new_expr = sympy2pyomo_expression(sympy_expr.simplify(), object_map)
+ if is_constant(new_expr):
+ new_expr = value(new_expr)
+ return new_expr
+
+
+def simplify_with_ginac(expr: NumericExpression, ginac_interface):
+ if is_constant(expr):
+ return value(expr)
+ ginac_expr = ginac_interface.to_ginac(expr)
+ return ginac_interface.from_ginac(ginac_expr.normal())
+
+
+class Simplifier(object):
+ class Mode(NamedIntEnum):
+ auto = 0
+ sympy = 1
+ ginac = 2
+
+ def __init__(
+ self, suppress_no_ginac_warnings: bool = False, mode: Mode = Mode.auto
+ ) -> None:
+ if mode == Simplifier.Mode.auto:
+ if ginac_available:
+ mode = Simplifier.Mode.ginac
+ else:
+ if not suppress_no_ginac_warnings:
+ msg = (
+ "GiNaC does not seem to be available. Using SymPy. "
+ + "Note that the GiNaC interface is significantly faster."
+ )
+ logging.getLogger(__name__).warning(msg)
+ warnings.warn(msg)
+ mode = Simplifier.Mode.sympy
+
+ if mode == Simplifier.Mode.ginac:
+ self.gi = ginac_interface.GinacInterface(False)
+ self.simplify = self._simplify_with_ginac
+ else:
+ self.simplify = self._simplify_with_sympy
+
+ def _simplify_with_ginac(self, expr: NumericExpression):
+ return simplify_with_ginac(expr, self.gi)
+
+ def _simplify_with_sympy(self, expr: NumericExpression):
+ return simplify_with_sympy(expr)
diff --git a/pyomo/contrib/simplification/tests/__init__.py b/pyomo/contrib/simplification/tests/__init__.py
new file mode 100644
index 00000000000..a4a626013c4
--- /dev/null
+++ b/pyomo/contrib/simplification/tests/__init__.py
@@ -0,0 +1,10 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
diff --git a/pyomo/contrib/simplification/tests/test_simplification.py b/pyomo/contrib/simplification/tests/test_simplification.py
new file mode 100644
index 00000000000..1ff9f5a3cc4
--- /dev/null
+++ b/pyomo/contrib/simplification/tests/test_simplification.py
@@ -0,0 +1,123 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.common import unittest
+from pyomo.common.fileutils import this_file_dir
+from pyomo.contrib.simplification import Simplifier
+from pyomo.contrib.simplification.simplify import ginac_available
+from pyomo.core.expr.compare import assertExpressionsEqual, compare_expressions
+from pyomo.core.expr.calculus.diff_with_pyomo import reverse_sd
+from pyomo.core.expr.sympy_tools import sympy_available
+
+import pyomo.environ as pe
+
+
+class SimplificationMixin:
+ def compare_against_possible_results(self, got, expected_list):
+ success = False
+ for exp in expected_list:
+ if compare_expressions(got, exp):
+ success = True
+ break
+ self.assertTrue(success)
+
+ def test_simplify(self):
+ m = pe.ConcreteModel()
+ x = m.x = pe.Var(bounds=(0, None))
+ e = x * pe.log(x)
+ der1 = reverse_sd(e)[x]
+ der2 = reverse_sd(der1)[x]
+ der2_simp = self.simp.simplify(der2)
+ expected = x**-1.0
+ assertExpressionsEqual(self, expected, der2_simp)
+
+ def test_mul(self):
+ m = pe.ConcreteModel()
+ x = m.x = pe.Var()
+ e = 2 * x
+ e2 = self.simp.simplify(e)
+ expected = 2.0 * x
+ assertExpressionsEqual(self, expected, e2)
+
+ def test_sum(self):
+ m = pe.ConcreteModel()
+ x = m.x = pe.Var()
+ e = 2 + x
+ e2 = self.simp.simplify(e)
+ self.compare_against_possible_results(e2, [2.0 + x, x + 2.0])
+
+ def test_neg(self):
+ m = pe.ConcreteModel()
+ x = m.x = pe.Var()
+ e = -pe.log(x)
+ e2 = self.simp.simplify(e)
+ self.compare_against_possible_results(
+ e2, [(-1.0) * pe.log(x), pe.log(x) * (-1.0), -pe.log(x)]
+ )
+
+ def test_pow(self):
+ m = pe.ConcreteModel()
+ x = m.x = pe.Var()
+ e = x**2.0
+ e2 = self.simp.simplify(e)
+ assertExpressionsEqual(self, e, e2)
+
+ def test_div(self):
+ m = pe.ConcreteModel()
+ x = m.x = pe.Var()
+ y = m.y = pe.Var()
+ e = x / y + y / x - x / y
+ e2 = self.simp.simplify(e)
+ self.compare_against_possible_results(
+ e2, [y / x, y * (1.0 / x), y * x**-1.0, x**-1.0 * y]
+ )
+
+ def test_unary(self):
+ m = pe.ConcreteModel()
+ x = m.x = pe.Var()
+ func_list = [pe.log, pe.sin, pe.cos, pe.tan, pe.asin, pe.acos, pe.atan]
+ for func in func_list:
+ e = func(x)
+ e2 = self.simp.simplify(e)
+ assertExpressionsEqual(self, e, e2)
+
+ def test_param(self):
+ m = pe.ConcreteModel()
+ x = m.x = pe.Var()
+ p = m.p = pe.Param(mutable=True)
+ e1 = p * x**2 + p * x + p * x**2
+ e2 = self.simp.simplify(e1)
+ self.compare_against_possible_results(
+ e2,
+ [
+ p * x**2.0 * 2.0 + p * x,
+ p * x + p * x**2.0 * 2.0,
+ 2.0 * p * x**2.0 + p * x,
+ p * x + 2.0 * p * x**2.0,
+ x**2.0 * p * 2.0 + p * x,
+ p * x + x**2.0 * p * 2.0,
+ p * x * (1 + 2 * x),
+ ],
+ )
+
+
+@unittest.skipUnless(sympy_available, 'sympy is not available')
+class TestSimplificationSympy(unittest.TestCase, SimplificationMixin):
+ def setUp(self):
+ self.simp = Simplifier(mode=Simplifier.Mode.sympy)
+
+
+@unittest.pytest.mark.default
+@unittest.pytest.mark.builders
+@unittest.skipUnless(ginac_available, 'GiNaC is not available')
+class TestSimplificationGiNaC(unittest.TestCase, SimplificationMixin):
+ def setUp(self):
+ self.simp = Simplifier(mode=Simplifier.Mode.ginac)
diff --git a/pyomo/contrib/solver/__init__.py b/pyomo/contrib/solver/__init__.py
new file mode 100644
index 00000000000..a4a626013c4
--- /dev/null
+++ b/pyomo/contrib/solver/__init__.py
@@ -0,0 +1,10 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
diff --git a/pyomo/contrib/solver/base.py b/pyomo/contrib/solver/base.py
new file mode 100644
index 00000000000..98bf3836004
--- /dev/null
+++ b/pyomo/contrib/solver/base.py
@@ -0,0 +1,638 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 abc
+import enum
+from typing import Sequence, Dict, Optional, Mapping, NoReturn, List, Tuple
+import os
+
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.block import BlockData
+from pyomo.core.base.objective import Objective, ObjectiveData
+from pyomo.common.config import document_kwargs_from_configdict, ConfigValue
+from pyomo.common.errors import ApplicationError
+from pyomo.common.deprecation import deprecation_warning
+from pyomo.common.modeling import NOTSET
+from pyomo.opt.results.results_ import SolverResults as LegacySolverResults
+from pyomo.opt.results.solution import Solution as LegacySolution
+from pyomo.core.kernel.objective import minimize
+from pyomo.core.base import SymbolMap
+from pyomo.core.base.label import NumericLabeler
+from pyomo.core.staleflag import StaleFlagManager
+from pyomo.contrib.solver.config import SolverConfig, PersistentSolverConfig
+from pyomo.contrib.solver.util import get_objective
+from pyomo.contrib.solver.results import (
+ Results,
+ legacy_solver_status_map,
+ legacy_termination_condition_map,
+ legacy_solution_status_map,
+)
+
+
+class SolverBase(abc.ABC):
+ """
+ This base class defines the methods required for all solvers:
+ - available: Determines whether the solver is able to be run,
+ combining both whether it can be found on the system and if the license is valid.
+ - solve: The main method of every solver
+ - version: The version of the solver
+ - is_persistent: Set to false for all non-persistent solvers.
+
+ Additionally, solvers should have a :attr:`config` attribute that
+ inherits from one of :class:`SolverConfig`,
+ :class:`BranchAndBoundConfig`,
+ :class:`PersistentSolverConfig`, or
+ :class:`PersistentBranchAndBoundConfig`.
+ """
+
+ CONFIG = SolverConfig()
+
+ def __init__(self, **kwds) -> None:
+ # We allow the user and/or developer to name the solver something else,
+ # if they really desire.
+ # Otherwise it defaults to the name defined when the solver was registered
+ # in the SolverFactory or the class name (all lowercase), whichever is
+ # applicable
+ if "name" in kwds:
+ self.name = kwds.pop('name')
+ elif not hasattr(self, 'name'):
+ self.name = type(self).__name__.lower()
+ self.config = self.CONFIG(value=kwds)
+
+ #
+ # Support "with" statements. Forgetting to call deactivate
+ # on Plugins is a common source of memory leaks
+ #
+ def __enter__(self):
+ return self
+
+ def __exit__(self, t, v, traceback):
+ """Exit statement - enables `with` statements."""
+
+ class Availability(enum.IntEnum):
+ """
+ Class to capture different statuses in which a solver can exist in
+ order to record its availability for use.
+ """
+
+ FullLicense = 2
+ LimitedLicense = 1
+ NotFound = 0
+ BadVersion = -1
+ BadLicense = -2
+ NeedsCompiledExtension = -3
+
+ def __bool__(self):
+ return self._value_ > 0
+
+ def __format__(self, format_spec):
+ # We want general formatting of this Enum to return the
+ # formatted string value and not the int (which is the
+ # default implementation from IntEnum)
+ return format(self.name, format_spec)
+
+ def __str__(self):
+ # Note: Python 3.11 changed the core enums so that the
+ # "mixin" type for standard enums overrides the behavior
+ # specified in __format__. We will override str() here to
+ # preserve the previous behavior
+ return self.name
+
+ @document_kwargs_from_configdict(CONFIG)
+ @abc.abstractmethod
+ def solve(self, model: BlockData, **kwargs) -> Results:
+ """
+ Solve a Pyomo model.
+
+ Parameters
+ ----------
+ model: BlockData
+ The Pyomo model to be solved
+ **kwargs
+ Additional keyword arguments (including solver_options - passthrough
+ options; delivered directly to the solver (with no validation))
+
+ Returns
+ -------
+ results: :class:`Results`
+ A results object
+ """
+
+ @abc.abstractmethod
+ def available(self) -> bool:
+ """Test if the solver is available on this system.
+
+ Nominally, this will return True if the solver interface is
+ valid and can be used to solve problems and False if it cannot.
+
+ Note that for licensed solvers there are a number of "levels" of
+ available: depending on the license, the solver may be available
+ with limitations on problem size or runtime (e.g., 'demo'
+ vs. 'community' vs. 'full'). In these cases, the solver may
+ return a subclass of enum.IntEnum, with members that resolve to
+ True if the solver is available (possibly with limitations).
+ The Enum may also have multiple members that all resolve to
+ False indicating the reason why the interface is not available
+ (not found, bad license, unsupported version, etc).
+
+ Returns
+ -------
+ available: SolverBase.Availability
+ An enum that indicates "how available" the solver is.
+ Note that the enum can be cast to bool, which will
+ be True if the solver is runable at all and False
+ otherwise.
+ """
+
+ @abc.abstractmethod
+ def version(self) -> Tuple:
+ """
+ Returns
+ -------
+ version: tuple
+ A tuple representing the version
+ """
+
+ def is_persistent(self) -> bool:
+ """
+ Returns
+ -------
+ is_persistent: bool
+ True if the solver is a persistent solver.
+ """
+ return False
+
+
+class PersistentSolverBase(SolverBase):
+ """
+ Base class upon which persistent solvers can be built. This inherits the
+ methods from the solver base class and adds those methods that are necessary
+ for persistent solvers.
+
+ Example usage can be seen in the Gurobi interface.
+ """
+
+ @document_kwargs_from_configdict(PersistentSolverConfig())
+ @abc.abstractmethod
+ def solve(self, model: BlockData, **kwargs) -> Results:
+ super().solve(model, kwargs)
+
+ def is_persistent(self):
+ """
+ Returns
+ -------
+ is_persistent: bool
+ True if the solver is a persistent solver.
+ """
+ return True
+
+ def _load_vars(self, vars_to_load: Optional[Sequence[VarData]] = None) -> NoReturn:
+ """
+ Load the solution of the primal variables into the value attribute of the variables.
+
+ Parameters
+ ----------
+ vars_to_load: list
+ A list of the variables whose solution should be loaded. If vars_to_load is None, then the solution
+ to all primal variables will be loaded.
+ """
+ for v, val in self._get_primals(vars_to_load=vars_to_load).items():
+ v.set_value(val, skip_validation=True)
+ StaleFlagManager.mark_all_as_stale(delayed=True)
+
+ @abc.abstractmethod
+ def _get_primals(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ """
+ Get mapping of variables to primals.
+
+ Parameters
+ ----------
+ vars_to_load : Optional[Sequence[VarData]], optional
+ Which vars to be populated into the map. The default is None.
+
+ Returns
+ -------
+ Mapping[VarData, float]
+ A map of variables to primals.
+ """
+ raise NotImplementedError(
+ f'{type(self)} does not support the get_primals method'
+ )
+
+ def _get_duals(
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
+ """
+ Declare sign convention in docstring here.
+
+ Parameters
+ ----------
+ cons_to_load: list
+ A list of the constraints whose duals should be loaded. If cons_to_load is None, then the duals for all
+ constraints will be loaded.
+
+ Returns
+ -------
+ duals: dict
+ Maps constraints to dual values
+ """
+ raise NotImplementedError(f'{type(self)} does not support the get_duals method')
+
+ def _get_reduced_costs(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ """
+ Parameters
+ ----------
+ vars_to_load: list
+ A list of the variables whose reduced cost should be loaded. If vars_to_load is None, then all reduced costs
+ will be loaded.
+
+ Returns
+ -------
+ reduced_costs: ComponentMap
+ Maps variable to reduced cost
+ """
+ raise NotImplementedError(
+ f'{type(self)} does not support the get_reduced_costs method'
+ )
+
+ @abc.abstractmethod
+ def set_instance(self, model):
+ """
+ Set an instance of the model
+ """
+
+ @abc.abstractmethod
+ def set_objective(self, obj: ObjectiveData):
+ """
+ Set current objective for the model
+ """
+
+ @abc.abstractmethod
+ def add_variables(self, variables: List[VarData]):
+ """
+ Add variables to the model
+ """
+
+ @abc.abstractmethod
+ def add_parameters(self, params: List[ParamData]):
+ """
+ Add parameters to the model
+ """
+
+ @abc.abstractmethod
+ def add_constraints(self, cons: List[ConstraintData]):
+ """
+ Add constraints to the model
+ """
+
+ @abc.abstractmethod
+ def add_block(self, block: BlockData):
+ """
+ Add a block to the model
+ """
+
+ @abc.abstractmethod
+ def remove_variables(self, variables: List[VarData]):
+ """
+ Remove variables from the model
+ """
+
+ @abc.abstractmethod
+ def remove_parameters(self, params: List[ParamData]):
+ """
+ Remove parameters from the model
+ """
+
+ @abc.abstractmethod
+ def remove_constraints(self, cons: List[ConstraintData]):
+ """
+ Remove constraints from the model
+ """
+
+ @abc.abstractmethod
+ def remove_block(self, block: BlockData):
+ """
+ Remove a block from the model
+ """
+
+ @abc.abstractmethod
+ def update_variables(self, variables: List[VarData]):
+ """
+ Update variables on the model
+ """
+
+ @abc.abstractmethod
+ def update_parameters(self):
+ """
+ Update parameters on the model
+ """
+
+
+class LegacySolverWrapper:
+ """
+ Class to map the new solver interface features into the legacy solver
+ interface. Necessary for backwards compatibility.
+ """
+
+ def __init__(self, **kwargs):
+ if 'solver_io' in kwargs:
+ raise NotImplementedError('Still working on this')
+ # There is no reason for a user to be trying to mix both old
+ # and new options. That is silly. So we will yell at them.
+ self.options = kwargs.pop('options', None)
+ if 'solver_options' in kwargs:
+ if self.options is not None:
+ raise ValueError(
+ "Both 'options' and 'solver_options' were requested. "
+ "Please use one or the other, not both."
+ )
+ self.options = kwargs.pop('solver_options')
+ super().__init__(**kwargs)
+
+ #
+ # Support "with" statements
+ #
+ def __enter__(self):
+ return self
+
+ def __exit__(self, t, v, traceback):
+ """Exit statement - enables `with` statements."""
+
+ def _map_config(
+ self,
+ tee=NOTSET,
+ load_solutions=NOTSET,
+ symbolic_solver_labels=NOTSET,
+ timelimit=NOTSET,
+ report_timing=NOTSET,
+ raise_exception_on_nonoptimal_result=NOTSET,
+ solver_io=NOTSET,
+ suffixes=NOTSET,
+ logfile=NOTSET,
+ keepfiles=NOTSET,
+ solnfile=NOTSET,
+ options=NOTSET,
+ solver_options=NOTSET,
+ writer_config=NOTSET,
+ ):
+ """Map between legacy and new interface configuration options"""
+ self.config = self.config()
+ if 'report_timing' not in self.config:
+ self.config.declare(
+ 'report_timing', ConfigValue(domain=bool, default=False)
+ )
+ if tee is not NOTSET:
+ self.config.tee = tee
+ if load_solutions is not NOTSET:
+ self.config.load_solutions = load_solutions
+ if symbolic_solver_labels is not NOTSET:
+ self.config.symbolic_solver_labels = symbolic_solver_labels
+ if timelimit is not NOTSET:
+ self.config.time_limit = timelimit
+ if report_timing is not NOTSET:
+ self.config.report_timing = report_timing
+ if self.options is not None:
+ self.config.solver_options.set_value(self.options)
+ if (options is not NOTSET) and (solver_options is not NOTSET):
+ # There is no reason for a user to be trying to mix both old
+ # and new options. That is silly. So we will yell at them.
+ # Example that would raise an error:
+ # solver.solve(model, options={'foo' : 'bar'}, solver_options={'foo' : 'not_bar'})
+ raise ValueError(
+ "Both 'options' and 'solver_options' were requested. "
+ "Please use one or the other, not both."
+ )
+ elif options is not NOTSET:
+ # This block is trying to mimic the existing logic in the legacy
+ # interface that allows users to pass initialized options to
+ # the solver object and override them in the solve call.
+ self.config.solver_options.set_value(options)
+ elif solver_options is not NOTSET:
+ self.config.solver_options.set_value(solver_options)
+ if writer_config is not NOTSET:
+ self.config.writer_config.set_value(writer_config)
+ # This is a new flag in the interface. To preserve backwards compatibility,
+ # its default is set to "False"
+ if raise_exception_on_nonoptimal_result is not NOTSET:
+ self.config.raise_exception_on_nonoptimal_result = (
+ raise_exception_on_nonoptimal_result
+ )
+ if solver_io is not NOTSET and solver_io is not None:
+ raise NotImplementedError('Still working on this')
+ if suffixes is not NOTSET and suffixes is not None:
+ raise NotImplementedError('Still working on this')
+ if logfile is not NOTSET and logfile is not None:
+ raise NotImplementedError('Still working on this')
+ if keepfiles or 'keepfiles' in self.config:
+ cwd = os.getcwd()
+ deprecation_warning(
+ "`keepfiles` has been deprecated in the new solver interface. "
+ "Use `working_dir` instead to designate a directory in which files "
+ f"should be generated and saved. Setting `working_dir` to `{cwd}`.",
+ version='6.7.1',
+ )
+ self.config.working_dir = cwd
+ # I believe this currently does nothing; however, it is unclear what
+ # our desired behavior is for this.
+ if solnfile is not NOTSET:
+ if 'filename' in self.config:
+ filename = os.path.splitext(solnfile)[0]
+ self.config.filename = filename
+
+ def _map_results(self, model, results):
+ """Map between legacy and new Results objects"""
+ legacy_results = LegacySolverResults()
+ legacy_soln = LegacySolution()
+ legacy_results.solver.status = legacy_solver_status_map[
+ results.termination_condition
+ ]
+ legacy_results.solver.termination_condition = legacy_termination_condition_map[
+ results.termination_condition
+ ]
+ legacy_soln.status = legacy_solution_status_map[results.solution_status]
+ legacy_results.solver.termination_message = str(results.termination_condition)
+ legacy_results.problem.number_of_constraints = float('nan')
+ legacy_results.problem.number_of_variables = float('nan')
+ number_of_objectives = sum(
+ 1
+ for _ in model.component_data_objects(
+ Objective, active=True, descend_into=True
+ )
+ )
+ legacy_results.problem.number_of_objectives = number_of_objectives
+ if number_of_objectives == 1:
+ obj = get_objective(model)
+ legacy_results.problem.sense = obj.sense
+
+ if obj.sense == minimize:
+ legacy_results.problem.lower_bound = results.objective_bound
+ legacy_results.problem.upper_bound = results.incumbent_objective
+ else:
+ legacy_results.problem.upper_bound = results.objective_bound
+ legacy_results.problem.lower_bound = results.incumbent_objective
+ if (
+ results.incumbent_objective is not None
+ and results.objective_bound is not None
+ ):
+ legacy_soln.gap = abs(results.incumbent_objective - results.objective_bound)
+ else:
+ legacy_soln.gap = None
+ return legacy_results, legacy_soln
+
+ def _solution_handler(
+ self, load_solutions, model, results, legacy_results, legacy_soln
+ ):
+ """Method to handle the preferred action for the solution"""
+ symbol_map = SymbolMap()
+ symbol_map.default_labeler = NumericLabeler('x')
+ if not hasattr(model, 'solutions'):
+ # This logic gets around Issue #2130 in which
+ # solutions is not an attribute on Blocks
+ from pyomo.core.base.PyomoModel import ModelSolutions
+
+ setattr(model, 'solutions', ModelSolutions(model))
+ model.solutions.add_symbol_map(symbol_map)
+ legacy_results._smap_id = id(symbol_map)
+ delete_legacy_soln = True
+ if load_solutions:
+ if hasattr(model, 'dual') and model.dual.import_enabled():
+ for c, val in results.solution_loader.get_duals().items():
+ model.dual[c] = val
+ if hasattr(model, 'rc') and model.rc.import_enabled():
+ for v, val in results.solution_loader.get_reduced_costs().items():
+ model.rc[v] = val
+ elif results.incumbent_objective is not None:
+ delete_legacy_soln = False
+ for v, val in results.solution_loader.get_primals().items():
+ legacy_soln.variable[symbol_map.getSymbol(v)] = {'Value': val}
+ if hasattr(model, 'dual') and model.dual.import_enabled():
+ for c, val in results.solution_loader.get_duals().items():
+ legacy_soln.constraint[symbol_map.getSymbol(c)] = {'Dual': val}
+ if hasattr(model, 'rc') and model.rc.import_enabled():
+ for v, val in results.solution_loader.get_reduced_costs().items():
+ legacy_soln.variable['Rc'] = val
+
+ legacy_results.solution.insert(legacy_soln)
+ # Timing info was not originally on the legacy results, but we want
+ # to make it accessible to folks who are utilizing the backwards
+ # compatible version.
+ legacy_results.timing_info = results.timing_info
+ if delete_legacy_soln:
+ legacy_results.solution.delete(0)
+ return legacy_results
+
+ def solve(
+ self,
+ model: BlockData,
+ tee: bool = False,
+ load_solutions: bool = True,
+ logfile: Optional[str] = None,
+ solnfile: Optional[str] = None,
+ timelimit: Optional[float] = None,
+ report_timing: bool = False,
+ solver_io: Optional[str] = None,
+ suffixes: Optional[Sequence] = None,
+ options: Optional[Dict] = None,
+ keepfiles: bool = False,
+ symbolic_solver_labels: bool = False,
+ # These are for forward-compatibility
+ raise_exception_on_nonoptimal_result: bool = False,
+ solver_options: Optional[Dict] = None,
+ writer_config: Optional[Dict] = None,
+ ):
+ """
+ Solve method: maps new solve method style to backwards compatible version.
+
+ Returns
+ -------
+ legacy_results
+ Legacy results object
+
+ """
+ original_config = self.config
+
+ map_args = (
+ 'tee',
+ 'load_solutions',
+ 'symbolic_solver_labels',
+ 'timelimit',
+ 'report_timing',
+ 'raise_exception_on_nonoptimal_result',
+ 'solver_io',
+ 'suffixes',
+ 'logfile',
+ 'keepfiles',
+ 'solnfile',
+ 'options',
+ 'solver_options',
+ 'writer_config',
+ )
+ loc = locals()
+ filtered_args = {k: loc[k] for k in map_args if loc.get(k, None) is not None}
+ self._map_config(**filtered_args)
+
+ results: Results = super().solve(model)
+ legacy_results, legacy_soln = self._map_results(model, results)
+ legacy_results = self._solution_handler(
+ load_solutions, model, results, legacy_results, legacy_soln
+ )
+
+ if self.config.report_timing:
+ print(results.timing_info.timer)
+
+ self.config = original_config
+
+ return legacy_results
+
+ def available(self, exception_flag=True):
+ """
+ Returns a bool determining whether the requested solver is available
+ on the system.
+ """
+ ans = super().available()
+ if exception_flag and not ans:
+ raise ApplicationError(
+ f'Solver "{self.name}" is not available. '
+ f'The returned status is: {ans}.'
+ )
+ return bool(ans)
+
+ def license_is_valid(self) -> bool:
+ """Test if the solver license is valid on this system.
+
+ Note that this method is included for compatibility with the
+ legacy SolverFactory interface. Unlicensed or open source
+ solvers will return True by definition. Licensed solvers will
+ return True if a valid license is found.
+
+ Returns
+ -------
+ available: bool
+ True if the solver license is valid. Otherwise, False.
+
+ """
+ return bool(self.available())
+
+ def config_block(self, init=False):
+ from pyomo.scripting.solve_config import default_config_block
+
+ return default_config_block(self, init)[0]
+
+ def set_options(self, options):
+ opts = {k: v for k, v in options.value().items() if v is not None}
+ if opts:
+ self._map_config(**opts)
diff --git a/pyomo/contrib/solver/config.py b/pyomo/contrib/solver/config.py
new file mode 100644
index 00000000000..e60219a74b5
--- /dev/null
+++ b/pyomo/contrib/solver/config.py
@@ -0,0 +1,406 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 io
+import logging
+import sys
+
+from collections.abc import Sequence
+from typing import Optional, List, TextIO
+
+from pyomo.common.config import (
+ ConfigDict,
+ ConfigValue,
+ NonNegativeFloat,
+ NonNegativeInt,
+ ADVANCED_OPTION,
+ Bool,
+ Path,
+)
+from pyomo.common.log import LogStream
+from pyomo.common.numeric_types import native_logical_types
+from pyomo.common.timing import HierarchicalTimer
+
+
+def TextIO_or_Logger(val):
+ ans = []
+ if not isinstance(val, Sequence):
+ val = [val]
+ for v in val:
+ if v.__class__ in native_logical_types:
+ if v:
+ ans.append(sys.stdout)
+ elif isinstance(v, io.TextIOBase):
+ ans.append(v)
+ elif isinstance(v, logging.Logger):
+ ans.append(LogStream(level=logging.INFO, logger=v))
+ else:
+ raise ValueError(
+ "Expected bool, TextIOBase, or Logger, but received {v.__class__}"
+ )
+ return ans
+
+
+class SolverConfig(ConfigDict):
+ """
+ Base config for all direct solver interfaces
+ """
+
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super().__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+
+ self.tee: List[TextIO] = self.declare(
+ 'tee',
+ ConfigValue(
+ domain=TextIO_or_Logger,
+ default=False,
+ description="""``tee`` accepts :py:class:`bool`,
+ :py:class:`io.TextIOBase`, or :py:class:`logging.Logger`
+ (or a list of these types). ``True`` is mapped to
+ ``sys.stdout``. The solver log will be printed to each of
+ these streams / destinations.""",
+ ),
+ )
+ self.working_dir: Optional[Path] = self.declare(
+ 'working_dir',
+ ConfigValue(
+ domain=Path(),
+ default=None,
+ description="The directory in which generated files should be saved. "
+ "This replaces the `keepfiles` option.",
+ ),
+ )
+ self.load_solutions: bool = self.declare(
+ 'load_solutions',
+ ConfigValue(
+ domain=Bool,
+ default=True,
+ description="If True, the values of the primal variables will be loaded into the model.",
+ ),
+ )
+ self.raise_exception_on_nonoptimal_result: bool = self.declare(
+ 'raise_exception_on_nonoptimal_result',
+ ConfigValue(
+ domain=Bool,
+ default=True,
+ description="If False, the `solve` method will continue processing "
+ "even if the returned result is nonoptimal.",
+ ),
+ )
+ self.symbolic_solver_labels: bool = self.declare(
+ 'symbolic_solver_labels',
+ ConfigValue(
+ domain=Bool,
+ default=False,
+ description="If True, the names given to the solver will reflect the names of the Pyomo components. "
+ "Cannot be changed after set_instance is called.",
+ ),
+ )
+ self.timer: Optional[HierarchicalTimer] = self.declare(
+ 'timer',
+ ConfigValue(
+ default=None,
+ description="A timer object for recording relevant process timing data.",
+ ),
+ )
+ self.threads: Optional[int] = self.declare(
+ 'threads',
+ ConfigValue(
+ domain=NonNegativeInt,
+ description="Number of threads to be used by a solver.",
+ default=None,
+ ),
+ )
+ self.time_limit: Optional[float] = self.declare(
+ 'time_limit',
+ ConfigValue(
+ domain=NonNegativeFloat,
+ description="Time limit applied to the solver (in seconds).",
+ ),
+ )
+ self.solver_options: ConfigDict = self.declare(
+ 'solver_options',
+ ConfigDict(implicit=True, description="Options to pass to the solver."),
+ )
+
+
+class BranchAndBoundConfig(SolverConfig):
+ """
+ Base config for all direct MIP solver interfaces
+
+ Attributes
+ ----------
+ rel_gap: float
+ The relative value of the gap in relation to the best bound
+ abs_gap: float
+ The absolute value of the difference between the incumbent and best bound
+ """
+
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super().__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+
+ self.rel_gap: Optional[float] = self.declare(
+ 'rel_gap',
+ ConfigValue(
+ domain=NonNegativeFloat,
+ description="Optional termination condition; the relative value of the "
+ "gap in relation to the best bound",
+ ),
+ )
+ self.abs_gap: Optional[float] = self.declare(
+ 'abs_gap',
+ ConfigValue(
+ domain=NonNegativeFloat,
+ description="Optional termination condition; the absolute value of the "
+ "difference between the incumbent and best bound",
+ ),
+ )
+
+
+class AutoUpdateConfig(ConfigDict):
+ """
+ This is necessary for persistent solvers.
+
+ Attributes
+ ----------
+ check_for_new_or_removed_constraints: bool
+ check_for_new_or_removed_vars: bool
+ check_for_new_or_removed_params: bool
+ check_for_new_objective: bool
+ update_constraints: bool
+ update_vars: bool
+ update_parameters: bool
+ update_named_expressions: bool
+ update_objective: bool
+ treat_fixed_vars_as_params: bool
+ """
+
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ if doc is None:
+ doc = 'Configuration options to detect changes in model between solves'
+ super().__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+
+ self.check_for_new_or_removed_constraints: bool = self.declare(
+ 'check_for_new_or_removed_constraints',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, new/old constraints will not be automatically detected on subsequent
+ solves. Use False only when manually updating the solver with opt.add_constraints()
+ and opt.remove_constraints() or when you are certain constraints are not being
+ added to/removed from the model.""",
+ ),
+ )
+ self.check_for_new_or_removed_vars: bool = self.declare(
+ 'check_for_new_or_removed_vars',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, new/old variables will not be automatically detected on subsequent
+ solves. Use False only when manually updating the solver with opt.add_variables() and
+ opt.remove_variables() or when you are certain variables are not being added to /
+ removed from the model.""",
+ ),
+ )
+ self.check_for_new_or_removed_params: bool = self.declare(
+ 'check_for_new_or_removed_params',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, new/old parameters will not be automatically detected on subsequent
+ solves. Use False only when manually updating the solver with opt.add_parameters() and
+ opt.remove_parameters() or when you are certain parameters are not being added to /
+ removed from the model.""",
+ ),
+ )
+ self.check_for_new_objective: bool = self.declare(
+ 'check_for_new_objective',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, new/old objectives will not be automatically detected on subsequent
+ solves. Use False only when manually updating the solver with opt.set_objective() or
+ when you are certain objectives are not being added to / removed from the model.""",
+ ),
+ )
+ self.update_constraints: bool = self.declare(
+ 'update_constraints',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, changes to existing constraints will not be automatically detected on
+ subsequent solves. This includes changes to the lower, body, and upper attributes of
+ constraints. Use False only when manually updating the solver with
+ opt.remove_constraints() and opt.add_constraints() or when you are certain constraints
+ are not being modified.""",
+ ),
+ )
+ self.update_vars: bool = self.declare(
+ 'update_vars',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, changes to existing variables will not be automatically detected on
+ subsequent solves. This includes changes to the lb, ub, domain, and fixed
+ attributes of variables. Use False only when manually updating the solver with
+ opt.update_variables() or when you are certain variables are not being modified.""",
+ ),
+ )
+ self.update_parameters: bool = self.declare(
+ 'update_parameters',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, changes to parameter values will not be automatically detected on
+ subsequent solves. Use False only when manually updating the solver with
+ opt.update_parameters() or when you are certain parameters are not being modified.""",
+ ),
+ )
+ self.update_named_expressions: bool = self.declare(
+ 'update_named_expressions',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, changes to Expressions will not be automatically detected on
+ subsequent solves. Use False only when manually updating the solver with
+ opt.remove_constraints() and opt.add_constraints() or when you are certain
+ Expressions are not being modified.""",
+ ),
+ )
+ self.update_objective: bool = self.declare(
+ 'update_objective',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ description="""
+ If False, changes to objectives will not be automatically detected on
+ subsequent solves. This includes the expr and sense attributes of objectives. Use
+ False only when manually updating the solver with opt.set_objective() or when you are
+ certain objectives are not being modified.""",
+ ),
+ )
+ self.treat_fixed_vars_as_params: bool = self.declare(
+ 'treat_fixed_vars_as_params',
+ ConfigValue(
+ domain=bool,
+ default=True,
+ visibility=ADVANCED_OPTION,
+ description="""
+ This is an advanced option that should only be used in special circumstances.
+ With the default setting of True, fixed variables will be treated like parameters.
+ This means that z == x*y will be linear if x or y is fixed and the constraint
+ can be written to an LP file. If the value of the fixed variable gets changed, we have
+ to completely reprocess all constraints using that variable. If
+ treat_fixed_vars_as_params is False, then constraints will be processed as if fixed
+ variables are not fixed, and the solver will be told the variable is fixed. This means
+ z == x*y could not be written to an LP file even if x and/or y is fixed. However,
+ updating the values of fixed variables is much faster this way.""",
+ ),
+ )
+
+
+class PersistentSolverConfig(SolverConfig):
+ """
+ Base config for all persistent solver interfaces
+ """
+
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super().__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+
+ self.auto_updates: AutoUpdateConfig = self.declare(
+ 'auto_updates', AutoUpdateConfig()
+ )
+
+
+class PersistentBranchAndBoundConfig(BranchAndBoundConfig):
+ """
+ Base config for all persistent MIP solver interfaces
+ """
+
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super().__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+
+ self.auto_updates: AutoUpdateConfig = self.declare(
+ 'auto_updates', AutoUpdateConfig()
+ )
diff --git a/pyomo/contrib/solver/factory.py b/pyomo/contrib/solver/factory.py
new file mode 100644
index 00000000000..d3ca1329af3
--- /dev/null
+++ b/pyomo/contrib/solver/factory.py
@@ -0,0 +1,41 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+
+from pyomo.opt.base.solvers import LegacySolverFactory
+from pyomo.common.factory import Factory
+from pyomo.contrib.solver.base import LegacySolverWrapper
+
+
+class SolverFactoryClass(Factory):
+ def register(self, name, legacy_name=None, doc=None):
+ if legacy_name is None:
+ legacy_name = name
+
+ def decorator(cls):
+ self._cls[name] = cls
+ self._doc[name] = doc
+
+ class LegacySolver(LegacySolverWrapper, cls):
+ pass
+
+ LegacySolverFactory.register(legacy_name, doc + " (new interface)")(
+ LegacySolver
+ )
+
+ # Preserve the preferred name, as registered in the Factory
+ cls.name = name
+ return cls
+
+ return decorator
+
+
+SolverFactory = SolverFactoryClass()
diff --git a/pyomo/contrib/solver/gurobi.py b/pyomo/contrib/solver/gurobi.py
new file mode 100644
index 00000000000..10d8120c8b3
--- /dev/null
+++ b/pyomo/contrib/solver/gurobi.py
@@ -0,0 +1,1505 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from collections.abc import Iterable
+import logging
+import math
+from typing import List, Optional
+from pyomo.common.collections import ComponentSet, ComponentMap, OrderedSet
+from pyomo.common.dependencies import attempt_import
+from pyomo.common.errors import PyomoException
+from pyomo.common.tee import capture_output, TeeStream
+from pyomo.common.timing import HierarchicalTimer
+from pyomo.common.shutdown import python_is_shutting_down
+from pyomo.common.config import ConfigValue
+from pyomo.core.kernel.objective import minimize, maximize
+from pyomo.core.base import SymbolMap, NumericLabeler, TextLabeler
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.sos import SOSConstraintData
+from pyomo.core.base.param import ParamData
+from pyomo.core.expr.numvalue import value, is_constant, is_fixed, native_numeric_types
+from pyomo.repn import generate_standard_repn
+from pyomo.core.expr.numeric_expr import NPV_MaxExpression, NPV_MinExpression
+from pyomo.contrib.solver.base import PersistentSolverBase
+from pyomo.contrib.solver.results import Results, TerminationCondition, SolutionStatus
+from pyomo.contrib.solver.config import PersistentBranchAndBoundConfig
+from pyomo.contrib.solver.persistent import PersistentSolverUtils
+from pyomo.contrib.solver.solution import PersistentSolutionLoader
+from pyomo.core.staleflag import StaleFlagManager
+import sys
+import datetime
+import io
+
+logger = logging.getLogger(__name__)
+
+
+def _import_gurobipy():
+ try:
+ import gurobipy
+ except ImportError:
+ Gurobi._available = Gurobi.Availability.NotFound
+ raise
+ if gurobipy.GRB.VERSION_MAJOR < 7:
+ Gurobi._available = Gurobi.Availability.BadVersion
+ raise ImportError('The APPSI Gurobi interface requires gurobipy>=7.0.0')
+ return gurobipy
+
+
+gurobipy, gurobipy_available = attempt_import('gurobipy', importer=_import_gurobipy)
+
+
+class DegreeError(PyomoException):
+ pass
+
+
+class GurobiConfig(PersistentBranchAndBoundConfig):
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super(GurobiConfig, self).__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+ self.use_mipstart: bool = self.declare(
+ 'use_mipstart',
+ ConfigValue(
+ default=False,
+ domain=bool,
+ description="If True, the values of the integer variables will be passed to Gurobi.",
+ ),
+ )
+
+
+class GurobiSolutionLoader(PersistentSolutionLoader):
+ def load_vars(self, vars_to_load=None, solution_number=0):
+ self._assert_solution_still_valid()
+ self._solver._load_vars(
+ vars_to_load=vars_to_load, solution_number=solution_number
+ )
+
+ def get_primals(self, vars_to_load=None, solution_number=0):
+ self._assert_solution_still_valid()
+ return self._solver._get_primals(
+ vars_to_load=vars_to_load, solution_number=solution_number
+ )
+
+
+class _MutableLowerBound(object):
+ def __init__(self, expr):
+ self.var = None
+ self.expr = expr
+
+ def update(self):
+ self.var.setAttr('lb', value(self.expr))
+
+
+class _MutableUpperBound(object):
+ def __init__(self, expr):
+ self.var = None
+ self.expr = expr
+
+ def update(self):
+ self.var.setAttr('ub', value(self.expr))
+
+
+class _MutableLinearCoefficient(object):
+ def __init__(self):
+ self.expr = None
+ self.var = None
+ self.con = None
+ self.gurobi_model = None
+
+ def update(self):
+ self.gurobi_model.chgCoeff(self.con, self.var, value(self.expr))
+
+
+class _MutableRangeConstant(object):
+ def __init__(self):
+ self.lhs_expr = None
+ self.rhs_expr = None
+ self.con = None
+ self.slack_name = None
+ self.gurobi_model = None
+
+ def update(self):
+ rhs_val = value(self.rhs_expr)
+ lhs_val = value(self.lhs_expr)
+ self.con.rhs = rhs_val
+ slack = self.gurobi_model.getVarByName(self.slack_name)
+ slack.ub = rhs_val - lhs_val
+
+
+class _MutableConstant(object):
+ def __init__(self):
+ self.expr = None
+ self.con = None
+
+ def update(self):
+ self.con.rhs = value(self.expr)
+
+
+class _MutableQuadraticConstraint(object):
+ def __init__(
+ self, gurobi_model, gurobi_con, constant, linear_coefs, quadratic_coefs
+ ):
+ self.con = gurobi_con
+ self.gurobi_model = gurobi_model
+ self.constant = constant
+ self.last_constant_value = value(self.constant.expr)
+ self.linear_coefs = linear_coefs
+ self.last_linear_coef_values = [value(i.expr) for i in self.linear_coefs]
+ self.quadratic_coefs = quadratic_coefs
+ self.last_quadratic_coef_values = [value(i.expr) for i in self.quadratic_coefs]
+
+ def get_updated_expression(self):
+ gurobi_expr = self.gurobi_model.getQCRow(self.con)
+ for ndx, coef in enumerate(self.linear_coefs):
+ current_coef_value = value(coef.expr)
+ incremental_coef_value = (
+ current_coef_value - self.last_linear_coef_values[ndx]
+ )
+ gurobi_expr += incremental_coef_value * coef.var
+ self.last_linear_coef_values[ndx] = current_coef_value
+ for ndx, coef in enumerate(self.quadratic_coefs):
+ current_coef_value = value(coef.expr)
+ incremental_coef_value = (
+ current_coef_value - self.last_quadratic_coef_values[ndx]
+ )
+ gurobi_expr += incremental_coef_value * coef.var1 * coef.var2
+ self.last_quadratic_coef_values[ndx] = current_coef_value
+ return gurobi_expr
+
+ def get_updated_rhs(self):
+ return value(self.constant.expr)
+
+
+class _MutableObjective(object):
+ def __init__(self, gurobi_model, constant, linear_coefs, quadratic_coefs):
+ self.gurobi_model = gurobi_model
+ self.constant = constant
+ self.linear_coefs = linear_coefs
+ self.quadratic_coefs = quadratic_coefs
+ self.last_quadratic_coef_values = [value(i.expr) for i in self.quadratic_coefs]
+
+ def get_updated_expression(self):
+ for ndx, coef in enumerate(self.linear_coefs):
+ coef.var.obj = value(coef.expr)
+ self.gurobi_model.ObjCon = value(self.constant.expr)
+
+ gurobi_expr = None
+ for ndx, coef in enumerate(self.quadratic_coefs):
+ if value(coef.expr) != self.last_quadratic_coef_values[ndx]:
+ if gurobi_expr is None:
+ self.gurobi_model.update()
+ gurobi_expr = self.gurobi_model.getObjective()
+ current_coef_value = value(coef.expr)
+ incremental_coef_value = (
+ current_coef_value - self.last_quadratic_coef_values[ndx]
+ )
+ gurobi_expr += incremental_coef_value * coef.var1 * coef.var2
+ self.last_quadratic_coef_values[ndx] = current_coef_value
+ return gurobi_expr
+
+
+class _MutableQuadraticCoefficient(object):
+ def __init__(self):
+ self.expr = None
+ self.var1 = None
+ self.var2 = None
+
+
+class Gurobi(PersistentSolverUtils, PersistentSolverBase):
+ """
+ Interface to Gurobi
+ """
+
+ CONFIG = GurobiConfig()
+
+ _available = None
+ _num_instances = 0
+
+ def __init__(self, **kwds):
+ PersistentSolverUtils.__init__(self)
+ PersistentSolverBase.__init__(self, **kwds)
+ Gurobi._num_instances += 1
+ self._solver_model = None
+ self._symbol_map = SymbolMap()
+ self._labeler = None
+ self._pyomo_var_to_solver_var_map = dict()
+ self._pyomo_con_to_solver_con_map = dict()
+ self._solver_con_to_pyomo_con_map = dict()
+ self._pyomo_sos_to_solver_sos_map = dict()
+ self._range_constraints = OrderedSet()
+ self._mutable_helpers = dict()
+ self._mutable_bounds = dict()
+ self._mutable_quadratic_helpers = dict()
+ self._mutable_objective = None
+ self._needs_updated = True
+ self._callback = None
+ self._callback_func = None
+ self._constraints_added_since_update = OrderedSet()
+ self._vars_added_since_update = ComponentSet()
+ self._last_results_object: Optional[Results] = None
+ self._config: Optional[GurobiConfig] = None
+
+ def available(self):
+ if not gurobipy_available: # this triggers the deferred import
+ return self.Availability.NotFound
+ elif self._available == self.Availability.BadVersion:
+ return self.Availability.BadVersion
+ else:
+ return self._check_license()
+
+ def _check_license(self):
+ avail = False
+ try:
+ # Gurobipy writes out license file information when creating
+ # the environment
+ with capture_output(capture_fd=True):
+ m = gurobipy.Model()
+ if self._solver_model is None:
+ self._solver_model = m
+ avail = True
+ except gurobipy.GurobiError:
+ avail = False
+
+ if avail:
+ if self._available is None:
+ self._available = Gurobi._check_full_license()
+ return self._available
+ else:
+ return self.Availability.BadLicense
+
+ @classmethod
+ def _check_full_license(cls):
+ m = gurobipy.Model()
+ m.setParam('OutputFlag', 0)
+ try:
+ m.addVars(range(2001))
+ m.optimize()
+ return cls.Availability.FullLicense
+ except gurobipy.GurobiError:
+ return cls.Availability.LimitedLicense
+
+ def release_license(self):
+ self._reinit()
+ if gurobipy_available:
+ with capture_output(capture_fd=True):
+ gurobipy.disposeDefaultEnv()
+
+ def __del__(self):
+ if not python_is_shutting_down():
+ Gurobi._num_instances -= 1
+ if Gurobi._num_instances == 0:
+ self.release_license()
+
+ def version(self):
+ version = (
+ gurobipy.GRB.VERSION_MAJOR,
+ gurobipy.GRB.VERSION_MINOR,
+ gurobipy.GRB.VERSION_TECHNICAL,
+ )
+ return version
+
+ @property
+ def symbol_map(self):
+ return self._symbol_map
+
+ def _solve(self):
+ config = self._config
+ timer = config.timer
+ ostreams = [io.StringIO()] + config.tee
+
+ with TeeStream(*ostreams) as t, capture_output(t.STDOUT, capture_fd=False):
+ options = config.solver_options
+
+ self._solver_model.setParam('LogToConsole', 1)
+
+ if config.threads is not None:
+ self._solver_model.setParam('Threads', config.threads)
+ if config.time_limit is not None:
+ self._solver_model.setParam('TimeLimit', config.time_limit)
+ if config.rel_gap is not None:
+ self._solver_model.setParam('MIPGap', config.rel_gap)
+ if config.abs_gap is not None:
+ self._solver_model.setParam('MIPGapAbs', config.abs_gap)
+
+ if config.use_mipstart:
+ for (
+ pyomo_var_id,
+ gurobi_var,
+ ) in self._pyomo_var_to_solver_var_map.items():
+ pyomo_var = self._vars[pyomo_var_id][0]
+ if pyomo_var.is_integer() and pyomo_var.value is not None:
+ self.set_var_attr(pyomo_var, 'Start', pyomo_var.value)
+
+ for key, option in options.items():
+ self._solver_model.setParam(key, option)
+
+ timer.start('optimize')
+ self._solver_model.optimize(self._callback)
+ timer.stop('optimize')
+
+ self._needs_updated = False
+ res = self._postsolve(timer)
+ res.solver_configuration = config
+ res.solver_name = 'Gurobi'
+ res.solver_version = self.version()
+ res.solver_log = ostreams[0].getvalue()
+ return res
+
+ def solve(self, model, **kwds) -> Results:
+ start_timestamp = datetime.datetime.now(datetime.timezone.utc)
+ self._config = config = self.config(value=kwds, preserve_implicit=True)
+ StaleFlagManager.mark_all_as_stale()
+ # Note: solver availability check happens in set_instance(),
+ # which will be called (either by the user before this call, or
+ # below) before this method calls self._solve.
+ if self._last_results_object is not None:
+ self._last_results_object.solution_loader.invalidate()
+ if config.timer is None:
+ config.timer = HierarchicalTimer()
+ timer = config.timer
+ if model is not self._model:
+ timer.start('set_instance')
+ self.set_instance(model)
+ timer.stop('set_instance')
+ else:
+ timer.start('update')
+ self.update(timer=timer)
+ timer.stop('update')
+ res = self._solve()
+ self._last_results_object = res
+ end_timestamp = datetime.datetime.now(datetime.timezone.utc)
+ res.timing_info.start_timestamp = start_timestamp
+ res.timing_info.wall_time = (end_timestamp - start_timestamp).total_seconds()
+ res.timing_info.timer = timer
+ return res
+
+ def _process_domain_and_bounds(
+ self, var, var_id, mutable_lbs, mutable_ubs, ndx, gurobipy_var
+ ):
+ _v, _lb, _ub, _fixed, _domain_interval, _value = self._vars[id(var)]
+ lb, ub, step = _domain_interval
+ if lb is None:
+ lb = -gurobipy.GRB.INFINITY
+ if ub is None:
+ ub = gurobipy.GRB.INFINITY
+ if step == 0:
+ vtype = gurobipy.GRB.CONTINUOUS
+ elif step == 1:
+ if lb == 0 and ub == 1:
+ vtype = gurobipy.GRB.BINARY
+ else:
+ vtype = gurobipy.GRB.INTEGER
+ else:
+ raise ValueError(
+ f'Unrecognized domain step: {step} (should be either 0 or 1)'
+ )
+ if _fixed:
+ lb = _value
+ ub = _value
+ else:
+ if _lb is not None:
+ if not is_constant(_lb):
+ mutable_bound = _MutableLowerBound(NPV_MaxExpression((_lb, lb)))
+ if gurobipy_var is None:
+ mutable_lbs[ndx] = mutable_bound
+ else:
+ mutable_bound.var = gurobipy_var
+ self._mutable_bounds[var_id, 'lb'] = (var, mutable_bound)
+ lb = max(value(_lb), lb)
+ if _ub is not None:
+ if not is_constant(_ub):
+ mutable_bound = _MutableUpperBound(NPV_MinExpression((_ub, ub)))
+ if gurobipy_var is None:
+ mutable_ubs[ndx] = mutable_bound
+ else:
+ mutable_bound.var = gurobipy_var
+ self._mutable_bounds[var_id, 'ub'] = (var, mutable_bound)
+ ub = min(value(_ub), ub)
+
+ return lb, ub, vtype
+
+ def _add_variables(self, variables: List[VarData]):
+ var_names = list()
+ vtypes = list()
+ lbs = list()
+ ubs = list()
+ mutable_lbs = dict()
+ mutable_ubs = dict()
+ for ndx, var in enumerate(variables):
+ varname = self._symbol_map.getSymbol(var, self._labeler)
+ lb, ub, vtype = self._process_domain_and_bounds(
+ var, id(var), mutable_lbs, mutable_ubs, ndx, None
+ )
+ var_names.append(varname)
+ vtypes.append(vtype)
+ lbs.append(lb)
+ ubs.append(ub)
+
+ gurobi_vars = self._solver_model.addVars(
+ len(variables), lb=lbs, ub=ubs, vtype=vtypes, name=var_names
+ )
+
+ for ndx, pyomo_var in enumerate(variables):
+ gurobi_var = gurobi_vars[ndx]
+ self._pyomo_var_to_solver_var_map[id(pyomo_var)] = gurobi_var
+ for ndx, mutable_bound in mutable_lbs.items():
+ mutable_bound.var = gurobi_vars[ndx]
+ for ndx, mutable_bound in mutable_ubs.items():
+ mutable_bound.var = gurobi_vars[ndx]
+ self._vars_added_since_update.update(variables)
+ self._needs_updated = True
+
+ def _add_parameters(self, params: List[ParamData]):
+ pass
+
+ def _reinit(self):
+ saved_config = self.config
+ saved_tmp_config = self._config
+ self.__init__()
+ self.config = saved_config
+ self._config = saved_tmp_config
+
+ def set_instance(self, model):
+ if self._last_results_object is not None:
+ self._last_results_object.solution_loader.invalidate()
+ if not self.available():
+ c = self.__class__
+ raise PyomoException(
+ f'Solver {c.__module__}.{c.__qualname__} is not available '
+ f'({self.available()}).'
+ )
+ self._reinit()
+ self._model = model
+
+ if self.config.symbolic_solver_labels:
+ self._labeler = TextLabeler()
+ else:
+ self._labeler = NumericLabeler('x')
+
+ if model.name is not None:
+ self._solver_model = gurobipy.Model(model.name)
+ else:
+ self._solver_model = gurobipy.Model()
+
+ self.add_block(model)
+ if self._objective is None:
+ self.set_objective(None)
+
+ def _get_expr_from_pyomo_expr(self, expr):
+ mutable_linear_coefficients = list()
+ mutable_quadratic_coefficients = list()
+ repn = generate_standard_repn(expr, quadratic=True, compute_values=False)
+
+ degree = repn.polynomial_degree()
+ if (degree is None) or (degree > 2):
+ raise DegreeError(
+ 'GurobiAuto does not support expressions of degree {0}.'.format(degree)
+ )
+
+ if len(repn.linear_vars) > 0:
+ linear_coef_vals = list()
+ for ndx, coef in enumerate(repn.linear_coefs):
+ if not is_constant(coef):
+ mutable_linear_coefficient = _MutableLinearCoefficient()
+ mutable_linear_coefficient.expr = coef
+ mutable_linear_coefficient.var = self._pyomo_var_to_solver_var_map[
+ id(repn.linear_vars[ndx])
+ ]
+ mutable_linear_coefficients.append(mutable_linear_coefficient)
+ linear_coef_vals.append(value(coef))
+ new_expr = gurobipy.LinExpr(
+ linear_coef_vals,
+ [self._pyomo_var_to_solver_var_map[id(i)] for i in repn.linear_vars],
+ )
+ else:
+ new_expr = 0.0
+
+ for ndx, v in enumerate(repn.quadratic_vars):
+ x, y = v
+ gurobi_x = self._pyomo_var_to_solver_var_map[id(x)]
+ gurobi_y = self._pyomo_var_to_solver_var_map[id(y)]
+ coef = repn.quadratic_coefs[ndx]
+ if not is_constant(coef):
+ mutable_quadratic_coefficient = _MutableQuadraticCoefficient()
+ mutable_quadratic_coefficient.expr = coef
+ mutable_quadratic_coefficient.var1 = gurobi_x
+ mutable_quadratic_coefficient.var2 = gurobi_y
+ mutable_quadratic_coefficients.append(mutable_quadratic_coefficient)
+ coef_val = value(coef)
+ new_expr += coef_val * gurobi_x * gurobi_y
+
+ return (
+ new_expr,
+ repn.constant,
+ mutable_linear_coefficients,
+ mutable_quadratic_coefficients,
+ )
+
+ def _add_constraints(self, cons: List[ConstraintData]):
+ for con in cons:
+ conname = self._symbol_map.getSymbol(con, self._labeler)
+ (
+ gurobi_expr,
+ repn_constant,
+ mutable_linear_coefficients,
+ mutable_quadratic_coefficients,
+ ) = self._get_expr_from_pyomo_expr(con.body)
+
+ if (
+ gurobi_expr.__class__ in {gurobipy.LinExpr, gurobipy.Var}
+ or gurobi_expr.__class__ in native_numeric_types
+ ):
+ if con.equality:
+ rhs_expr = con.lower - repn_constant
+ rhs_val = value(rhs_expr)
+ gurobipy_con = self._solver_model.addLConstr(
+ gurobi_expr, gurobipy.GRB.EQUAL, rhs_val, name=conname
+ )
+ if not is_constant(rhs_expr):
+ mutable_constant = _MutableConstant()
+ mutable_constant.expr = rhs_expr
+ mutable_constant.con = gurobipy_con
+ self._mutable_helpers[con] = [mutable_constant]
+ elif con.has_lb() and con.has_ub():
+ lhs_expr = con.lower - repn_constant
+ rhs_expr = con.upper - repn_constant
+ lhs_val = value(lhs_expr)
+ rhs_val = value(rhs_expr)
+ gurobipy_con = self._solver_model.addRange(
+ gurobi_expr, lhs_val, rhs_val, name=conname
+ )
+ self._range_constraints.add(con)
+ if not is_constant(lhs_expr) or not is_constant(rhs_expr):
+ mutable_range_constant = _MutableRangeConstant()
+ mutable_range_constant.lhs_expr = lhs_expr
+ mutable_range_constant.rhs_expr = rhs_expr
+ mutable_range_constant.con = gurobipy_con
+ mutable_range_constant.slack_name = 'Rg' + conname
+ mutable_range_constant.gurobi_model = self._solver_model
+ self._mutable_helpers[con] = [mutable_range_constant]
+ elif con.has_lb():
+ rhs_expr = con.lower - repn_constant
+ rhs_val = value(rhs_expr)
+ gurobipy_con = self._solver_model.addLConstr(
+ gurobi_expr, gurobipy.GRB.GREATER_EQUAL, rhs_val, name=conname
+ )
+ if not is_constant(rhs_expr):
+ mutable_constant = _MutableConstant()
+ mutable_constant.expr = rhs_expr
+ mutable_constant.con = gurobipy_con
+ self._mutable_helpers[con] = [mutable_constant]
+ elif con.has_ub():
+ rhs_expr = con.upper - repn_constant
+ rhs_val = value(rhs_expr)
+ gurobipy_con = self._solver_model.addLConstr(
+ gurobi_expr, gurobipy.GRB.LESS_EQUAL, rhs_val, name=conname
+ )
+ if not is_constant(rhs_expr):
+ mutable_constant = _MutableConstant()
+ mutable_constant.expr = rhs_expr
+ mutable_constant.con = gurobipy_con
+ self._mutable_helpers[con] = [mutable_constant]
+ else:
+ raise ValueError(
+ "Constraint does not have a lower "
+ "or an upper bound: {0} \n".format(con)
+ )
+ for tmp in mutable_linear_coefficients:
+ tmp.con = gurobipy_con
+ tmp.gurobi_model = self._solver_model
+ if len(mutable_linear_coefficients) > 0:
+ if con not in self._mutable_helpers:
+ self._mutable_helpers[con] = mutable_linear_coefficients
+ else:
+ self._mutable_helpers[con].extend(mutable_linear_coefficients)
+ elif gurobi_expr.__class__ is gurobipy.QuadExpr:
+ if con.equality:
+ rhs_expr = con.lower - repn_constant
+ rhs_val = value(rhs_expr)
+ gurobipy_con = self._solver_model.addQConstr(
+ gurobi_expr, gurobipy.GRB.EQUAL, rhs_val, name=conname
+ )
+ elif con.has_lb() and con.has_ub():
+ raise NotImplementedError(
+ 'Quadratic range constraints are not supported'
+ )
+ elif con.has_lb():
+ rhs_expr = con.lower - repn_constant
+ rhs_val = value(rhs_expr)
+ gurobipy_con = self._solver_model.addQConstr(
+ gurobi_expr, gurobipy.GRB.GREATER_EQUAL, rhs_val, name=conname
+ )
+ elif con.has_ub():
+ rhs_expr = con.upper - repn_constant
+ rhs_val = value(rhs_expr)
+ gurobipy_con = self._solver_model.addQConstr(
+ gurobi_expr, gurobipy.GRB.LESS_EQUAL, rhs_val, name=conname
+ )
+ else:
+ raise ValueError(
+ "Constraint does not have a lower "
+ "or an upper bound: {0} \n".format(con)
+ )
+ if (
+ len(mutable_linear_coefficients) > 0
+ or len(mutable_quadratic_coefficients) > 0
+ or not is_constant(repn_constant)
+ ):
+ mutable_constant = _MutableConstant()
+ mutable_constant.expr = rhs_expr
+ mutable_quadratic_constraint = _MutableQuadraticConstraint(
+ self._solver_model,
+ gurobipy_con,
+ mutable_constant,
+ mutable_linear_coefficients,
+ mutable_quadratic_coefficients,
+ )
+ self._mutable_quadratic_helpers[con] = mutable_quadratic_constraint
+ else:
+ raise ValueError(
+ 'Unrecognized Gurobi expression type: ' + str(gurobi_expr.__class__)
+ )
+
+ self._pyomo_con_to_solver_con_map[con] = gurobipy_con
+ self._solver_con_to_pyomo_con_map[id(gurobipy_con)] = con
+ self._constraints_added_since_update.update(cons)
+ self._needs_updated = True
+
+ def _add_sos_constraints(self, cons: List[SOSConstraintData]):
+ for con in cons:
+ conname = self._symbol_map.getSymbol(con, self._labeler)
+ level = con.level
+ if level == 1:
+ sos_type = gurobipy.GRB.SOS_TYPE1
+ elif level == 2:
+ sos_type = gurobipy.GRB.SOS_TYPE2
+ else:
+ raise ValueError(
+ "Solver does not support SOS level {0} constraints".format(level)
+ )
+
+ gurobi_vars = []
+ weights = []
+
+ for v, w in con.get_items():
+ v_id = id(v)
+ gurobi_vars.append(self._pyomo_var_to_solver_var_map[v_id])
+ weights.append(w)
+
+ gurobipy_con = self._solver_model.addSOS(sos_type, gurobi_vars, weights)
+ self._pyomo_sos_to_solver_sos_map[con] = gurobipy_con
+ self._constraints_added_since_update.update(cons)
+ self._needs_updated = True
+
+ def _remove_constraints(self, cons: List[ConstraintData]):
+ for con in cons:
+ if con in self._constraints_added_since_update:
+ self._update_gurobi_model()
+ solver_con = self._pyomo_con_to_solver_con_map[con]
+ self._solver_model.remove(solver_con)
+ self._symbol_map.removeSymbol(con)
+ del self._pyomo_con_to_solver_con_map[con]
+ del self._solver_con_to_pyomo_con_map[id(solver_con)]
+ self._range_constraints.discard(con)
+ self._mutable_helpers.pop(con, None)
+ self._mutable_quadratic_helpers.pop(con, None)
+ self._needs_updated = True
+
+ def _remove_sos_constraints(self, cons: List[SOSConstraintData]):
+ for con in cons:
+ if con in self._constraints_added_since_update:
+ self._update_gurobi_model()
+ solver_sos_con = self._pyomo_sos_to_solver_sos_map[con]
+ self._solver_model.remove(solver_sos_con)
+ self._symbol_map.removeSymbol(con)
+ del self._pyomo_sos_to_solver_sos_map[con]
+ self._needs_updated = True
+
+ def _remove_variables(self, variables: List[VarData]):
+ for var in variables:
+ v_id = id(var)
+ if var in self._vars_added_since_update:
+ self._update_gurobi_model()
+ solver_var = self._pyomo_var_to_solver_var_map[v_id]
+ self._solver_model.remove(solver_var)
+ self._symbol_map.removeSymbol(var)
+ del self._pyomo_var_to_solver_var_map[v_id]
+ self._mutable_bounds.pop(v_id, None)
+ self._needs_updated = True
+
+ def _remove_parameters(self, params: List[ParamData]):
+ pass
+
+ def _update_variables(self, variables: List[VarData]):
+ for var in variables:
+ var_id = id(var)
+ if var_id not in self._pyomo_var_to_solver_var_map:
+ raise ValueError(
+ 'The Var provided to update_var needs to be added first: {0}'.format(
+ var
+ )
+ )
+ self._mutable_bounds.pop((var_id, 'lb'), None)
+ self._mutable_bounds.pop((var_id, 'ub'), None)
+ gurobipy_var = self._pyomo_var_to_solver_var_map[var_id]
+ lb, ub, vtype = self._process_domain_and_bounds(
+ var, var_id, None, None, None, gurobipy_var
+ )
+ gurobipy_var.setAttr('lb', lb)
+ gurobipy_var.setAttr('ub', ub)
+ gurobipy_var.setAttr('vtype', vtype)
+ self._needs_updated = True
+
+ def update_parameters(self):
+ for con, helpers in self._mutable_helpers.items():
+ for helper in helpers:
+ helper.update()
+ for k, (v, helper) in self._mutable_bounds.items():
+ helper.update()
+
+ for con, helper in self._mutable_quadratic_helpers.items():
+ if con in self._constraints_added_since_update:
+ self._update_gurobi_model()
+ gurobi_con = helper.con
+ new_gurobi_expr = helper.get_updated_expression()
+ new_rhs = helper.get_updated_rhs()
+ new_sense = gurobi_con.qcsense
+ pyomo_con = self._solver_con_to_pyomo_con_map[id(gurobi_con)]
+ name = self._symbol_map.getSymbol(pyomo_con, self._labeler)
+ self._solver_model.remove(gurobi_con)
+ new_con = self._solver_model.addQConstr(
+ new_gurobi_expr, new_sense, new_rhs, name=name
+ )
+ self._pyomo_con_to_solver_con_map[id(pyomo_con)] = new_con
+ del self._solver_con_to_pyomo_con_map[id(gurobi_con)]
+ self._solver_con_to_pyomo_con_map[id(new_con)] = pyomo_con
+ helper.con = new_con
+ self._constraints_added_since_update.add(con)
+
+ helper = self._mutable_objective
+ pyomo_obj = self._objective
+ new_gurobi_expr = helper.get_updated_expression()
+ if new_gurobi_expr is not None:
+ if pyomo_obj.sense == minimize:
+ sense = gurobipy.GRB.MINIMIZE
+ else:
+ sense = gurobipy.GRB.MAXIMIZE
+ self._solver_model.setObjective(new_gurobi_expr, sense=sense)
+
+ def _set_objective(self, obj):
+ if obj is None:
+ sense = gurobipy.GRB.MINIMIZE
+ gurobi_expr = 0
+ repn_constant = 0
+ mutable_linear_coefficients = list()
+ mutable_quadratic_coefficients = list()
+ else:
+ if obj.sense == minimize:
+ sense = gurobipy.GRB.MINIMIZE
+ elif obj.sense == maximize:
+ sense = gurobipy.GRB.MAXIMIZE
+ else:
+ raise ValueError(
+ 'Objective sense is not recognized: {0}'.format(obj.sense)
+ )
+
+ (
+ gurobi_expr,
+ repn_constant,
+ mutable_linear_coefficients,
+ mutable_quadratic_coefficients,
+ ) = self._get_expr_from_pyomo_expr(obj.expr)
+
+ mutable_constant = _MutableConstant()
+ mutable_constant.expr = repn_constant
+ mutable_objective = _MutableObjective(
+ self._solver_model,
+ mutable_constant,
+ mutable_linear_coefficients,
+ mutable_quadratic_coefficients,
+ )
+ self._mutable_objective = mutable_objective
+
+ # These two lines are needed as a workaround
+ # see PR #2454
+ self._solver_model.setObjective(0)
+ self._solver_model.update()
+
+ self._solver_model.setObjective(gurobi_expr + value(repn_constant), sense=sense)
+ self._needs_updated = True
+
+ def _postsolve(self, timer: HierarchicalTimer):
+ config = self._config
+
+ gprob = self._solver_model
+ grb = gurobipy.GRB
+ status = gprob.Status
+
+ results = Results()
+ results.solution_loader = GurobiSolutionLoader(self)
+ results.timing_info.gurobi_time = gprob.Runtime
+
+ if gprob.SolCount > 0:
+ if status == grb.OPTIMAL:
+ results.solution_status = SolutionStatus.optimal
+ else:
+ results.solution_status = SolutionStatus.feasible
+ else:
+ results.solution_status = SolutionStatus.noSolution
+
+ if status == grb.LOADED: # problem is loaded, but no solution
+ results.termination_condition = TerminationCondition.unknown
+ elif status == grb.OPTIMAL: # optimal
+ results.termination_condition = (
+ TerminationCondition.convergenceCriteriaSatisfied
+ )
+ elif status == grb.INFEASIBLE:
+ results.termination_condition = TerminationCondition.provenInfeasible
+ elif status == grb.INF_OR_UNBD:
+ results.termination_condition = TerminationCondition.infeasibleOrUnbounded
+ elif status == grb.UNBOUNDED:
+ results.termination_condition = TerminationCondition.unbounded
+ elif status == grb.CUTOFF:
+ results.termination_condition = TerminationCondition.objectiveLimit
+ elif status == grb.ITERATION_LIMIT:
+ results.termination_condition = TerminationCondition.iterationLimit
+ elif status == grb.NODE_LIMIT:
+ results.termination_condition = TerminationCondition.iterationLimit
+ elif status == grb.TIME_LIMIT:
+ results.termination_condition = TerminationCondition.maxTimeLimit
+ elif status == grb.SOLUTION_LIMIT:
+ results.termination_condition = TerminationCondition.unknown
+ elif status == grb.INTERRUPTED:
+ results.termination_condition = TerminationCondition.interrupted
+ elif status == grb.NUMERIC:
+ results.termination_condition = TerminationCondition.unknown
+ elif status == grb.SUBOPTIMAL:
+ results.termination_condition = TerminationCondition.unknown
+ elif status == grb.USER_OBJ_LIMIT:
+ results.termination_condition = TerminationCondition.objectiveLimit
+ else:
+ results.termination_condition = TerminationCondition.unknown
+
+ if (
+ results.termination_condition
+ != TerminationCondition.convergenceCriteriaSatisfied
+ and config.raise_exception_on_nonoptimal_result
+ ):
+ raise RuntimeError(
+ 'Solver did not find the optimal solution. Set opt.config.raise_exception_on_nonoptimal_result = False to bypass this error.'
+ )
+
+ results.incumbent_objective = None
+ results.objective_bound = None
+ if self._objective is not None:
+ try:
+ results.incumbent_objective = gprob.ObjVal
+ except (gurobipy.GurobiError, AttributeError):
+ results.incumbent_objective = None
+ try:
+ results.objective_bound = gprob.ObjBound
+ except (gurobipy.GurobiError, AttributeError):
+ if self._objective.sense == minimize:
+ results.objective_bound = -math.inf
+ else:
+ results.objective_bound = math.inf
+
+ if results.incumbent_objective is not None and not math.isfinite(
+ results.incumbent_objective
+ ):
+ results.incumbent_objective = None
+
+ results.iteration_count = gprob.getAttr('IterCount')
+
+ timer.start('load solution')
+ if config.load_solutions:
+ if gprob.SolCount > 0:
+ self._load_vars()
+ else:
+ raise RuntimeError(
+ 'A feasible solution was not found, so no solution can be loaded.'
+ 'Please set opt.config.load_solutions=False and check '
+ 'results.solution_status and '
+ 'results.incumbent_objective before loading a solution.'
+ )
+ timer.stop('load solution')
+
+ return results
+
+ def _load_suboptimal_mip_solution(self, vars_to_load, solution_number):
+ if (
+ self.get_model_attr('NumIntVars') == 0
+ and self.get_model_attr('NumBinVars') == 0
+ ):
+ raise ValueError(
+ 'Cannot obtain suboptimal solutions for a continuous model'
+ )
+ var_map = self._pyomo_var_to_solver_var_map
+ ref_vars = self._referenced_variables
+ original_solution_number = self.get_gurobi_param_info('SolutionNumber')[2]
+ self.set_gurobi_param('SolutionNumber', solution_number)
+ gurobi_vars_to_load = [var_map[pyomo_var] for pyomo_var in vars_to_load]
+ vals = self._solver_model.getAttr("Xn", gurobi_vars_to_load)
+ res = ComponentMap()
+ for var_id, val in zip(vars_to_load, vals):
+ using_cons, using_sos, using_obj = ref_vars[var_id]
+ if using_cons or using_sos or (using_obj is not None):
+ res[self._vars[var_id][0]] = val
+ self.set_gurobi_param('SolutionNumber', original_solution_number)
+ return res
+
+ def _load_vars(self, vars_to_load=None, solution_number=0):
+ for v, val in self._get_primals(
+ vars_to_load=vars_to_load, solution_number=solution_number
+ ).items():
+ v.set_value(val, skip_validation=True)
+ StaleFlagManager.mark_all_as_stale(delayed=True)
+
+ def _get_primals(self, vars_to_load=None, solution_number=0):
+ if self._needs_updated:
+ self._update_gurobi_model() # this is needed to ensure that solutions cannot be loaded after the model has been changed
+
+ if self._solver_model.SolCount == 0:
+ raise RuntimeError(
+ 'Solver does not currently have a valid solution. Please '
+ 'check the termination condition.'
+ )
+
+ var_map = self._pyomo_var_to_solver_var_map
+ ref_vars = self._referenced_variables
+ if vars_to_load is None:
+ vars_to_load = self._pyomo_var_to_solver_var_map.keys()
+ else:
+ vars_to_load = [id(v) for v in vars_to_load]
+
+ if solution_number != 0:
+ return self._load_suboptimal_mip_solution(
+ vars_to_load=vars_to_load, solution_number=solution_number
+ )
+ else:
+ gurobi_vars_to_load = [
+ var_map[pyomo_var_id] for pyomo_var_id in vars_to_load
+ ]
+ vals = self._solver_model.getAttr("X", gurobi_vars_to_load)
+
+ res = ComponentMap()
+ for var_id, val in zip(vars_to_load, vals):
+ using_cons, using_sos, using_obj = ref_vars[var_id]
+ if using_cons or using_sos or (using_obj is not None):
+ res[self._vars[var_id][0]] = val
+ return res
+
+ def _get_reduced_costs(self, vars_to_load=None):
+ if self._needs_updated:
+ self._update_gurobi_model()
+
+ if self._solver_model.Status != gurobipy.GRB.OPTIMAL:
+ raise RuntimeError(
+ 'Solver does not currently have valid reduced costs. Please '
+ 'check the termination condition.'
+ )
+
+ var_map = self._pyomo_var_to_solver_var_map
+ ref_vars = self._referenced_variables
+ res = ComponentMap()
+ if vars_to_load is None:
+ vars_to_load = self._pyomo_var_to_solver_var_map.keys()
+ else:
+ vars_to_load = [id(v) for v in vars_to_load]
+
+ gurobi_vars_to_load = [var_map[pyomo_var_id] for pyomo_var_id in vars_to_load]
+ vals = self._solver_model.getAttr("Rc", gurobi_vars_to_load)
+
+ for var_id, val in zip(vars_to_load, vals):
+ using_cons, using_sos, using_obj = ref_vars[var_id]
+ if using_cons or using_sos or (using_obj is not None):
+ res[self._vars[var_id][0]] = val
+
+ return res
+
+ def _get_duals(self, cons_to_load=None):
+ if self._needs_updated:
+ self._update_gurobi_model()
+
+ if self._solver_model.Status != gurobipy.GRB.OPTIMAL:
+ raise RuntimeError(
+ 'Solver does not currently have valid duals. Please '
+ 'check the termination condition.'
+ )
+
+ con_map = self._pyomo_con_to_solver_con_map
+ reverse_con_map = self._solver_con_to_pyomo_con_map
+ dual = dict()
+
+ if cons_to_load is None:
+ linear_cons_to_load = self._solver_model.getConstrs()
+ quadratic_cons_to_load = self._solver_model.getQConstrs()
+ else:
+ gurobi_cons_to_load = OrderedSet(
+ [con_map[pyomo_con] for pyomo_con in cons_to_load]
+ )
+ linear_cons_to_load = list(
+ gurobi_cons_to_load.intersection(
+ OrderedSet(self._solver_model.getConstrs())
+ )
+ )
+ quadratic_cons_to_load = list(
+ gurobi_cons_to_load.intersection(
+ OrderedSet(self._solver_model.getQConstrs())
+ )
+ )
+ linear_vals = self._solver_model.getAttr("Pi", linear_cons_to_load)
+ quadratic_vals = self._solver_model.getAttr("QCPi", quadratic_cons_to_load)
+
+ for gurobi_con, val in zip(linear_cons_to_load, linear_vals):
+ pyomo_con = reverse_con_map[id(gurobi_con)]
+ dual[pyomo_con] = val
+ for gurobi_con, val in zip(quadratic_cons_to_load, quadratic_vals):
+ pyomo_con = reverse_con_map[id(gurobi_con)]
+ dual[pyomo_con] = val
+
+ return dual
+
+ def update(self, timer: HierarchicalTimer = None):
+ if self._needs_updated:
+ self._update_gurobi_model()
+ super(Gurobi, self).update(timer=timer)
+ self._update_gurobi_model()
+
+ def _update_gurobi_model(self):
+ self._solver_model.update()
+ self._constraints_added_since_update = OrderedSet()
+ self._vars_added_since_update = ComponentSet()
+ self._needs_updated = False
+
+ def get_model_attr(self, attr):
+ """
+ Get the value of an attribute on the Gurobi model.
+
+ Parameters
+ ----------
+ attr: str
+ The attribute to get. See Gurobi documentation for descriptions of the attributes.
+ """
+ if self._needs_updated:
+ self._update_gurobi_model()
+ return self._solver_model.getAttr(attr)
+
+ def write(self, filename):
+ """
+ Write the model to a file (e.g., and lp file).
+
+ Parameters
+ ----------
+ filename: str
+ Name of the file to which the model should be written.
+ """
+ self._solver_model.write(filename)
+ self._constraints_added_since_update = OrderedSet()
+ self._vars_added_since_update = ComponentSet()
+ self._needs_updated = False
+
+ def set_linear_constraint_attr(self, con, attr, val):
+ """
+ Set the value of an attribute on a gurobi linear constraint.
+
+ Parameters
+ ----------
+ con: pyomo.core.base.constraint.ConstraintData
+ The pyomo constraint for which the corresponding gurobi constraint attribute
+ should be modified.
+ attr: str
+ The attribute to be modified. Options are:
+ CBasis
+ DStart
+ Lazy
+ val: any
+ See gurobi documentation for acceptable values.
+ """
+ if attr in {'Sense', 'RHS', 'ConstrName'}:
+ raise ValueError(
+ 'Linear constraint attr {0} cannot be set with'.format(attr)
+ + ' the set_linear_constraint_attr method. Please use'
+ + ' the remove_constraint and add_constraint methods.'
+ )
+ self._pyomo_con_to_solver_con_map[con].setAttr(attr, val)
+ self._needs_updated = True
+
+ def set_var_attr(self, var, attr, val):
+ """
+ Set the value of an attribute on a gurobi variable.
+
+ Parameters
+ ----------
+ var: pyomo.core.base.var.VarData
+ The pyomo var for which the corresponding gurobi var attribute
+ should be modified.
+ attr: str
+ The attribute to be modified. Options are:
+ Start
+ VarHintVal
+ VarHintPri
+ BranchPriority
+ VBasis
+ PStart
+ val: any
+ See gurobi documentation for acceptable values.
+ """
+ if attr in {'LB', 'UB', 'VType', 'VarName'}:
+ raise ValueError(
+ 'Var attr {0} cannot be set with'.format(attr)
+ + ' the set_var_attr method. Please use'
+ + ' the update_var method.'
+ )
+ if attr == 'Obj':
+ raise ValueError(
+ 'Var attr Obj cannot be set with'
+ + ' the set_var_attr method. Please use'
+ + ' the set_objective method.'
+ )
+ self._pyomo_var_to_solver_var_map[id(var)].setAttr(attr, val)
+ self._needs_updated = True
+
+ def get_var_attr(self, var, attr):
+ """
+ Get the value of an attribute on a gurobi var.
+
+ Parameters
+ ----------
+ var: pyomo.core.base.var.VarData
+ The pyomo var for which the corresponding gurobi var attribute
+ should be retrieved.
+ attr: str
+ The attribute to get. See gurobi documentation
+ """
+ if self._needs_updated:
+ self._update_gurobi_model()
+ return self._pyomo_var_to_solver_var_map[id(var)].getAttr(attr)
+
+ def get_linear_constraint_attr(self, con, attr):
+ """
+ Get the value of an attribute on a gurobi linear constraint.
+
+ Parameters
+ ----------
+ con: pyomo.core.base.constraint.ConstraintData
+ The pyomo constraint for which the corresponding gurobi constraint attribute
+ should be retrieved.
+ attr: str
+ The attribute to get. See the Gurobi documentation
+ """
+ if self._needs_updated:
+ self._update_gurobi_model()
+ return self._pyomo_con_to_solver_con_map[con].getAttr(attr)
+
+ def get_sos_attr(self, con, attr):
+ """
+ Get the value of an attribute on a gurobi sos constraint.
+
+ Parameters
+ ----------
+ con: pyomo.core.base.sos.SOSConstraintData
+ The pyomo SOS constraint for which the corresponding gurobi SOS constraint attribute
+ should be retrieved.
+ attr: str
+ The attribute to get. See the Gurobi documentation
+ """
+ if self._needs_updated:
+ self._update_gurobi_model()
+ return self._pyomo_sos_to_solver_sos_map[con].getAttr(attr)
+
+ def get_quadratic_constraint_attr(self, con, attr):
+ """
+ Get the value of an attribute on a gurobi quadratic constraint.
+
+ Parameters
+ ----------
+ con: pyomo.core.base.constraint.ConstraintData
+ The pyomo constraint for which the corresponding gurobi constraint attribute
+ should be retrieved.
+ attr: str
+ The attribute to get. See the Gurobi documentation
+ """
+ if self._needs_updated:
+ self._update_gurobi_model()
+ return self._pyomo_con_to_solver_con_map[con].getAttr(attr)
+
+ def set_gurobi_param(self, param, val):
+ """
+ Set a gurobi parameter.
+
+ Parameters
+ ----------
+ param: str
+ The gurobi parameter to set. Options include any gurobi parameter.
+ Please see the Gurobi documentation for options.
+ val: any
+ The value to set the parameter to. See Gurobi documentation for possible values.
+ """
+ self._solver_model.setParam(param, val)
+
+ def get_gurobi_param_info(self, param):
+ """
+ Get information about a gurobi parameter.
+
+ Parameters
+ ----------
+ param: str
+ The gurobi parameter to get info for. See Gurobi documentation for possible options.
+
+ Returns
+ -------
+ six-tuple containing the parameter name, type, value, minimum value, maximum value, and default value.
+ """
+ return self._solver_model.getParamInfo(param)
+
+ def _intermediate_callback(self):
+ def f(gurobi_model, where):
+ self._callback_func(self._model, self, where)
+
+ return f
+
+ def set_callback(self, func=None):
+ """
+ Specify a callback for gurobi to use.
+
+ Parameters
+ ----------
+ func: function
+ The function to call. The function should have three arguments. The first will be the pyomo model being
+ solved. The second will be the GurobiPersistent instance. The third will be an enum member of
+ gurobipy.GRB.Callback. This will indicate where in the branch and bound algorithm gurobi is at. For
+ example, suppose we want to solve
+
+ .. math::
+
+ min 2*x + y
+
+ s.t.
+
+ y >= (x-2)**2
+
+ 0 <= x <= 4
+
+ y >= 0
+
+ y integer
+
+ as an MILP using extended cutting planes in callbacks.
+
+ >>> from gurobipy import GRB # doctest:+SKIP
+ >>> import pyomo.environ as pe
+ >>> from pyomo.core.expr.taylor_series import taylor_series_expansion
+ >>> from pyomo.contrib import appsi
+ >>>
+ >>> m = pe.ConcreteModel()
+ >>> m.x = pe.Var(bounds=(0, 4))
+ >>> m.y = pe.Var(within=pe.Integers, bounds=(0, None))
+ >>> m.obj = pe.Objective(expr=2*m.x + m.y)
+ >>> m.cons = pe.ConstraintList() # for the cutting planes
+ >>>
+ >>> def _add_cut(xval):
+ ... # a function to generate the cut
+ ... m.x.value = xval
+ ... return m.cons.add(m.y >= taylor_series_expansion((m.x - 2)**2))
+ ...
+ >>> _c = _add_cut(0) # start with 2 cuts at the bounds of x
+ >>> _c = _add_cut(4) # this is an arbitrary choice
+ >>>
+ >>> opt = appsi.solvers.Gurobi()
+ >>> opt.config.stream_solver = True
+ >>> opt.set_instance(m) # doctest:+SKIP
+ >>> opt.gurobi_options['PreCrush'] = 1
+ >>> opt.gurobi_options['LazyConstraints'] = 1
+ >>>
+ >>> def my_callback(cb_m, cb_opt, cb_where):
+ ... if cb_where == GRB.Callback.MIPSOL:
+ ... cb_opt.cbGetSolution(vars=[m.x, m.y])
+ ... if m.y.value < (m.x.value - 2)**2 - 1e-6:
+ ... cb_opt.cbLazy(_add_cut(m.x.value))
+ ...
+ >>> opt.set_callback(my_callback)
+ >>> res = opt.solve(m) # doctest:+SKIP
+
+ """
+ if func is not None:
+ self._callback_func = func
+ self._callback = self._intermediate_callback()
+ else:
+ self._callback = None
+ self._callback_func = None
+
+ def cbCut(self, con):
+ """
+ Add a cut within a callback.
+
+ Parameters
+ ----------
+ con: pyomo.core.base.constraint.ConstraintData
+ The cut to add
+ """
+ if not con.active:
+ raise ValueError('cbCut expected an active constraint.')
+
+ if is_fixed(con.body):
+ raise ValueError('cbCut expected a non-trivial constraint')
+
+ (
+ gurobi_expr,
+ repn_constant,
+ mutable_linear_coefficients,
+ mutable_quadratic_coefficients,
+ ) = self._get_expr_from_pyomo_expr(con.body)
+
+ if con.has_lb():
+ if con.has_ub():
+ raise ValueError('Range constraints are not supported in cbCut.')
+ if not is_fixed(con.lower):
+ raise ValueError(
+ 'Lower bound of constraint {0} is not constant.'.format(con)
+ )
+ if con.has_ub():
+ if not is_fixed(con.upper):
+ raise ValueError(
+ 'Upper bound of constraint {0} is not constant.'.format(con)
+ )
+
+ if con.equality:
+ self._solver_model.cbCut(
+ lhs=gurobi_expr,
+ sense=gurobipy.GRB.EQUAL,
+ rhs=value(con.lower - repn_constant),
+ )
+ elif con.has_lb() and (value(con.lower) > -float('inf')):
+ self._solver_model.cbCut(
+ lhs=gurobi_expr,
+ sense=gurobipy.GRB.GREATER_EQUAL,
+ rhs=value(con.lower - repn_constant),
+ )
+ elif con.has_ub() and (value(con.upper) < float('inf')):
+ self._solver_model.cbCut(
+ lhs=gurobi_expr,
+ sense=gurobipy.GRB.LESS_EQUAL,
+ rhs=value(con.upper - repn_constant),
+ )
+ else:
+ raise ValueError(
+ 'Constraint does not have a lower or an upper bound {0} \n'.format(con)
+ )
+
+ def cbGet(self, what):
+ return self._solver_model.cbGet(what)
+
+ def cbGetNodeRel(self, vars):
+ """
+ Parameters
+ ----------
+ vars: Var or iterable of Var
+ """
+ if not isinstance(vars, Iterable):
+ vars = [vars]
+ gurobi_vars = [self._pyomo_var_to_solver_var_map[id(i)] for i in vars]
+ var_values = self._solver_model.cbGetNodeRel(gurobi_vars)
+ for i, v in enumerate(vars):
+ v.set_value(var_values[i], skip_validation=True)
+
+ def cbGetSolution(self, vars):
+ """
+ Parameters
+ ----------
+ vars: iterable of vars
+ """
+ if not isinstance(vars, Iterable):
+ vars = [vars]
+ gurobi_vars = [self._pyomo_var_to_solver_var_map[id(i)] for i in vars]
+ var_values = self._solver_model.cbGetSolution(gurobi_vars)
+ for i, v in enumerate(vars):
+ v.set_value(var_values[i], skip_validation=True)
+
+ def cbLazy(self, con):
+ """
+ Parameters
+ ----------
+ con: pyomo.core.base.constraint.ConstraintData
+ The lazy constraint to add
+ """
+ if not con.active:
+ raise ValueError('cbLazy expected an active constraint.')
+
+ if is_fixed(con.body):
+ raise ValueError('cbLazy expected a non-trivial constraint')
+
+ (
+ gurobi_expr,
+ repn_constant,
+ mutable_linear_coefficients,
+ mutable_quadratic_coefficients,
+ ) = self._get_expr_from_pyomo_expr(con.body)
+
+ if con.has_lb():
+ if con.has_ub():
+ raise ValueError('Range constraints are not supported in cbLazy.')
+ if not is_fixed(con.lower):
+ raise ValueError(
+ 'Lower bound of constraint {0} is not constant.'.format(con)
+ )
+ if con.has_ub():
+ if not is_fixed(con.upper):
+ raise ValueError(
+ 'Upper bound of constraint {0} is not constant.'.format(con)
+ )
+
+ if con.equality:
+ self._solver_model.cbLazy(
+ lhs=gurobi_expr,
+ sense=gurobipy.GRB.EQUAL,
+ rhs=value(con.lower - repn_constant),
+ )
+ elif con.has_lb() and (value(con.lower) > -float('inf')):
+ self._solver_model.cbLazy(
+ lhs=gurobi_expr,
+ sense=gurobipy.GRB.GREATER_EQUAL,
+ rhs=value(con.lower - repn_constant),
+ )
+ elif con.has_ub() and (value(con.upper) < float('inf')):
+ self._solver_model.cbLazy(
+ lhs=gurobi_expr,
+ sense=gurobipy.GRB.LESS_EQUAL,
+ rhs=value(con.upper - repn_constant),
+ )
+ else:
+ raise ValueError(
+ 'Constraint does not have a lower or an upper bound {0} \n'.format(con)
+ )
+
+ def cbSetSolution(self, vars, solution):
+ if not isinstance(vars, Iterable):
+ vars = [vars]
+ gurobi_vars = [self._pyomo_var_to_solver_var_map[id(i)] for i in vars]
+ self._solver_model.cbSetSolution(gurobi_vars, solution)
+
+ def cbUseSolution(self):
+ return self._solver_model.cbUseSolution()
+
+ def reset(self):
+ self._solver_model.reset()
diff --git a/pyomo/contrib/solver/gurobi_direct.py b/pyomo/contrib/solver/gurobi_direct.py
new file mode 100644
index 00000000000..edca7018f92
--- /dev/null
+++ b/pyomo/contrib/solver/gurobi_direct.py
@@ -0,0 +1,420 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 datetime
+import io
+import math
+import os
+
+from pyomo.common.config import ConfigValue
+from pyomo.common.collections import ComponentMap, ComponentSet
+from pyomo.common.dependencies import attempt_import
+from pyomo.common.enums import ObjectiveSense
+from pyomo.common.shutdown import python_is_shutting_down
+from pyomo.common.tee import capture_output, TeeStream
+from pyomo.common.timing import HierarchicalTimer
+
+from pyomo.contrib.solver.base import SolverBase
+from pyomo.contrib.solver.config import BranchAndBoundConfig
+from pyomo.contrib.solver.results import Results, SolutionStatus, TerminationCondition
+from pyomo.contrib.solver.solution import SolutionLoaderBase
+
+from pyomo.core.staleflag import StaleFlagManager
+
+from pyomo.repn.plugins.standard_form import LinearStandardFormCompiler
+
+gurobipy, gurobipy_available = attempt_import('gurobipy')
+
+
+class GurobiConfig(BranchAndBoundConfig):
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super(GurobiConfig, self).__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+ self.use_mipstart: bool = self.declare(
+ 'use_mipstart',
+ ConfigValue(
+ default=False,
+ domain=bool,
+ description="If True, the current values of the integer variables "
+ "will be passed to Gurobi.",
+ ),
+ )
+
+
+class GurobiDirectSolutionLoader(SolutionLoaderBase):
+ def __init__(self, grb_model, grb_cons, grb_vars, pyo_cons, pyo_vars, pyo_obj):
+ self._grb_model = grb_model
+ self._grb_cons = grb_cons
+ self._grb_vars = grb_vars
+ self._pyo_cons = pyo_cons
+ self._pyo_vars = pyo_vars
+ self._pyo_obj = pyo_obj
+ GurobiDirect._num_instances += 1
+
+ def __del__(self):
+ if not python_is_shutting_down():
+ GurobiDirect._num_instances -= 1
+ if GurobiDirect._num_instances == 0:
+ GurobiDirect.release_license()
+
+ def load_vars(self, vars_to_load=None, solution_number=0):
+ assert solution_number == 0
+ if self._grb_model.SolCount == 0:
+ raise RuntimeError(
+ 'Solver does not currently have a valid solution. Please '
+ 'check the termination condition.'
+ )
+
+ iterator = zip(self._pyo_vars, self._grb_vars.x.tolist())
+ if vars_to_load:
+ vars_to_load = ComponentSet(vars_to_load)
+ iterator = filter(lambda var_val: var_val[0] in vars_to_load, iterator)
+ for p_var, g_var in iterator:
+ p_var.set_value(g_var, skip_validation=True)
+ StaleFlagManager.mark_all_as_stale(delayed=True)
+
+ def get_primals(self, vars_to_load=None, solution_number=0):
+ assert solution_number == 0
+ if self._grb_model.SolCount == 0:
+ raise RuntimeError(
+ 'Solver does not currently have a valid solution. Please '
+ 'check the termination condition.'
+ )
+
+ iterator = zip(self._pyo_vars, self._grb_vars.x.tolist())
+ if vars_to_load:
+ vars_to_load = ComponentSet(vars_to_load)
+ iterator = filter(lambda var_val: var_val[0] in vars_to_load, iterator)
+ return ComponentMap(iterator)
+
+ def get_duals(self, cons_to_load=None):
+ if self._grb_model.Status != gurobipy.GRB.OPTIMAL:
+ raise RuntimeError(
+ 'Solver does not currently have valid duals. Please '
+ 'check the termination condition.'
+ )
+
+ def dedup(_iter):
+ last = None
+ for con_info_dual in _iter:
+ if not con_info_dual[1] and con_info_dual[0][0] is last:
+ continue
+ last = con_info_dual[0][0]
+ yield con_info_dual
+
+ iterator = dedup(zip(self._pyo_cons, self._grb_cons.getAttr('Pi').tolist()))
+ if cons_to_load:
+ cons_to_load = set(cons_to_load)
+ iterator = filter(
+ lambda con_info_dual: con_info_dual[0][0] in cons_to_load, iterator
+ )
+ return {con_info[0]: dual for con_info, dual in iterator}
+
+ def get_reduced_costs(self, vars_to_load=None):
+ if self._grb_model.Status != gurobipy.GRB.OPTIMAL:
+ raise RuntimeError(
+ 'Solver does not currently have valid reduced costs. Please '
+ 'check the termination condition.'
+ )
+
+ iterator = zip(self._pyo_vars, self._grb_vars.getAttr('Rc').tolist())
+ if vars_to_load:
+ vars_to_load = ComponentSet(vars_to_load)
+ iterator = filter(lambda var_rc: var_rc[0] in vars_to_load, iterator)
+ return ComponentMap(iterator)
+
+
+class GurobiDirect(SolverBase):
+ CONFIG = GurobiConfig()
+
+ _available = None
+ _num_instances = 0
+ _tc_map = None
+
+ def __init__(self, **kwds):
+ super().__init__(**kwds)
+ GurobiDirect._num_instances += 1
+
+ def available(self):
+ if not gurobipy_available: # this triggers the deferred import
+ return self.Availability.NotFound
+ elif self._available == self.Availability.BadVersion:
+ return self.Availability.BadVersion
+ else:
+ return self._check_license()
+
+ def _check_license(self):
+ avail = False
+ try:
+ # Gurobipy writes out license file information when creating
+ # the environment
+ with capture_output(capture_fd=True):
+ m = gurobipy.Model()
+ avail = True
+ except gurobipy.GurobiError:
+ avail = False
+
+ if avail:
+ if self._available is None:
+ self._available = GurobiDirect._check_full_license(m)
+ return self._available
+ else:
+ return self.Availability.BadLicense
+
+ @classmethod
+ def _check_full_license(cls, model=None):
+ if model is None:
+ model = gurobipy.Model()
+ model.setParam('OutputFlag', 0)
+ try:
+ model.addVars(range(2001))
+ model.optimize()
+ return cls.Availability.FullLicense
+ except gurobipy.GurobiError:
+ return cls.Availability.LimitedLicense
+
+ def __del__(self):
+ if not python_is_shutting_down():
+ GurobiDirect._num_instances -= 1
+ if GurobiDirect._num_instances == 0:
+ self.release_license()
+
+ @staticmethod
+ def release_license():
+ if gurobipy_available:
+ with capture_output(capture_fd=True):
+ gurobipy.disposeDefaultEnv()
+
+ def version(self):
+ version = (
+ gurobipy.GRB.VERSION_MAJOR,
+ gurobipy.GRB.VERSION_MINOR,
+ gurobipy.GRB.VERSION_TECHNICAL,
+ )
+ return version
+
+ def solve(self, model, **kwds) -> Results:
+ start_timestamp = datetime.datetime.now(datetime.timezone.utc)
+ config = self.config(value=kwds, preserve_implicit=True)
+ if config.timer is None:
+ config.timer = HierarchicalTimer()
+ timer = config.timer
+
+ StaleFlagManager.mark_all_as_stale()
+
+ timer.start('compile_model')
+ repn = LinearStandardFormCompiler().write(
+ model, mixed_form=True, set_sense=None
+ )
+ timer.stop('compile_model')
+
+ if len(repn.objectives) > 1:
+ raise ValueError(
+ 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
+ lb = []
+ ub = []
+ for v in repn.columns:
+ _l, _u = v.bounds
+ if _l is None:
+ _l = ninf
+ if _u is None:
+ _u = inf
+ lb.append(_l)
+ ub.append(_u)
+ 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 = '=<>' # Note: ordering matches 0, 1, -1
+ sense = [sense_type[r[1]] for r in repn.rows]
+ timer.stop('prepare_matrices')
+
+ ostreams = [io.StringIO()] + config.tee
+
+ try:
+ orig_cwd = os.getcwd()
+ if config.working_dir:
+ os.chdir(config.working_dir)
+ with TeeStream(*ostreams) as t, capture_output(t.STDOUT, capture_fd=False):
+ gurobi_model = gurobipy.Model()
+
+ 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())
+ timer.stop('transfer_model')
+
+ options = config.solver_options
+
+ gurobi_model.setParam('LogToConsole', 1)
+
+ if config.threads is not None:
+ gurobi_model.setParam('Threads', config.threads)
+ if config.time_limit is not None:
+ gurobi_model.setParam('TimeLimit', config.time_limit)
+ if config.rel_gap is not None:
+ gurobi_model.setParam('MIPGap', config.rel_gap)
+ if config.abs_gap is not None:
+ gurobi_model.setParam('MIPGapAbs', config.abs_gap)
+
+ if config.use_mipstart:
+ raise MouseTrap("MIPSTART not yet supported")
+
+ for key, option in options.items():
+ gurobi_model.setParam(key, option)
+
+ timer.start('optimize')
+ gurobi_model.optimize()
+ timer.stop('optimize')
+ finally:
+ os.chdir(orig_cwd)
+
+ res = self._postsolve(
+ timer,
+ config,
+ GurobiDirectSolutionLoader(
+ gurobi_model, A, x, repn.rows, repn.columns, repn.objectives
+ ),
+ )
+ res.solver_configuration = config
+ res.solver_name = 'Gurobi'
+ res.solver_version = self.version()
+ res.solver_log = ostreams[0].getvalue()
+
+ end_timestamp = datetime.datetime.now(datetime.timezone.utc)
+ res.timing_info.start_timestamp = start_timestamp
+ res.timing_info.wall_time = (end_timestamp - start_timestamp).total_seconds()
+ res.timing_info.timer = timer
+ return res
+
+ def _postsolve(self, timer: HierarchicalTimer, config, loader):
+ grb_model = loader._grb_model
+ status = grb_model.Status
+
+ results = Results()
+ results.solution_loader = loader
+ results.timing_info.gurobi_time = grb_model.Runtime
+
+ if grb_model.SolCount > 0:
+ if status == gurobipy.GRB.OPTIMAL:
+ results.solution_status = SolutionStatus.optimal
+ else:
+ results.solution_status = SolutionStatus.feasible
+ else:
+ results.solution_status = SolutionStatus.noSolution
+
+ results.termination_condition = self._get_tc_map().get(
+ status, TerminationCondition.unknown
+ )
+
+ if (
+ results.termination_condition
+ != TerminationCondition.convergenceCriteriaSatisfied
+ and config.raise_exception_on_nonoptimal_result
+ ):
+ raise RuntimeError(
+ 'Solver did not find the optimal solution. Set '
+ 'opt.config.raise_exception_on_nonoptimal_result=False '
+ 'to bypass this error.'
+ )
+
+ if loader._pyo_obj:
+ try:
+ if math.isfinite(grb_model.ObjVal):
+ results.incumbent_objective = grb_model.ObjVal
+ else:
+ results.incumbent_objective = None
+ except (gurobipy.GurobiError, AttributeError):
+ results.incumbent_objective = None
+ try:
+ results.objective_bound = grb_model.ObjBound
+ except (gurobipy.GurobiError, AttributeError):
+ if grb_model.ModelSense == ObjectiveSense.minimize:
+ results.objective_bound = -math.inf
+ else:
+ results.objective_bound = math.inf
+ else:
+ results.incumbent_objective = None
+ results.objective_bound = None
+
+ results.iteration_count = grb_model.getAttr('IterCount')
+
+ timer.start('load solution')
+ if config.load_solutions:
+ if grb_model.SolCount > 0:
+ results.solution_loader.load_vars()
+ else:
+ raise RuntimeError(
+ 'A feasible solution was not found, so no solution can be loaded.'
+ 'Please set opt.config.load_solutions=False and check '
+ 'results.solution_status and '
+ 'results.incumbent_objective before loading a solution.'
+ )
+ timer.stop('load solution')
+
+ return results
+
+ def _get_tc_map(self):
+ if GurobiDirect._tc_map is None:
+ grb = gurobipy.GRB
+ tc = TerminationCondition
+ GurobiDirect._tc_map = {
+ grb.LOADED: tc.unknown, # problem is loaded, but no solution
+ grb.OPTIMAL: tc.convergenceCriteriaSatisfied,
+ grb.INFEASIBLE: tc.provenInfeasible,
+ grb.INF_OR_UNBD: tc.infeasibleOrUnbounded,
+ grb.UNBOUNDED: tc.unbounded,
+ grb.CUTOFF: tc.objectiveLimit,
+ grb.ITERATION_LIMIT: tc.iterationLimit,
+ grb.NODE_LIMIT: tc.iterationLimit,
+ grb.TIME_LIMIT: tc.maxTimeLimit,
+ grb.SOLUTION_LIMIT: tc.unknown,
+ grb.INTERRUPTED: tc.interrupted,
+ grb.NUMERIC: tc.unknown,
+ grb.SUBOPTIMAL: tc.unknown,
+ grb.USER_OBJ_LIMIT: tc.objectiveLimit,
+ }
+ return GurobiDirect._tc_map
diff --git a/pyomo/contrib/solver/ipopt.py b/pyomo/contrib/solver/ipopt.py
new file mode 100644
index 00000000000..c88696f531b
--- /dev/null
+++ b/pyomo/contrib/solver/ipopt.py
@@ -0,0 +1,537 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 logging
+import os
+import subprocess
+import datetime
+import io
+from typing import Mapping, Optional, Sequence
+
+from pyomo.common import Executable
+from pyomo.common.config import ConfigValue, document_kwargs_from_configdict, ConfigDict
+from pyomo.common.errors import (
+ PyomoException,
+ DeveloperError,
+ InfeasibleConstraintException,
+)
+from pyomo.common.tempfiles import TempfileManager
+from pyomo.common.timing import HierarchicalTimer
+from pyomo.core.base.var import VarData
+from pyomo.core.staleflag import StaleFlagManager
+from pyomo.repn.plugins.nl_writer import NLWriter, NLWriterInfo
+from pyomo.contrib.solver.base import SolverBase
+from pyomo.contrib.solver.config import SolverConfig
+from pyomo.contrib.solver.results import Results, TerminationCondition, SolutionStatus
+from pyomo.contrib.solver.sol_reader import parse_sol_file
+from pyomo.contrib.solver.solution import SolSolutionLoader
+from pyomo.common.tee import TeeStream
+from pyomo.core.expr.visitor import replace_expressions
+from pyomo.core.expr.numvalue import value
+from pyomo.core.base.suffix import Suffix
+from pyomo.common.collections import ComponentMap
+
+logger = logging.getLogger(__name__)
+
+
+class IpoptSolverError(PyomoException):
+ """
+ General exception to catch solver system errors
+ """
+
+
+class IpoptConfig(SolverConfig):
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super().__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+
+ self.executable: Executable = self.declare(
+ 'executable',
+ ConfigValue(
+ default=Executable('ipopt'),
+ description="Preferred executable for ipopt. Defaults to searching the "
+ "``PATH`` for the first available ``ipopt``.",
+ ),
+ )
+ self.writer_config: ConfigDict = self.declare(
+ 'writer_config', NLWriter.CONFIG()
+ )
+
+
+class IpoptSolutionLoader(SolSolutionLoader):
+ def get_reduced_costs(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ if self._nl_info is None:
+ raise RuntimeError(
+ 'Solution loader does not currently have a valid solution. Please '
+ 'check results.TerminationCondition and/or results.SolutionStatus.'
+ )
+ if len(self._nl_info.eliminated_vars) > 0:
+ raise NotImplementedError(
+ 'For now, turn presolve off (opt.config.writer_config.linear_presolve=False) '
+ 'to get dual variable values.'
+ )
+ if self._sol_data is None:
+ raise DeveloperError(
+ "Solution data is empty. This should not "
+ "have happened. Report this error to the Pyomo Developers."
+ )
+ if self._nl_info.scaling is None:
+ scale_list = [1] * len(self._nl_info.variables)
+ obj_scale = 1
+ else:
+ scale_list = self._nl_info.scaling.variables
+ obj_scale = self._nl_info.scaling.objectives[0]
+ sol_data = self._sol_data
+ nl_info = self._nl_info
+ zl_map = sol_data.var_suffixes['ipopt_zL_out']
+ zu_map = sol_data.var_suffixes['ipopt_zU_out']
+ rc = dict()
+ for ndx, v in enumerate(nl_info.variables):
+ scale = scale_list[ndx]
+ v_id = id(v)
+ rc[v_id] = (v, 0)
+ if ndx in zl_map:
+ zl = zl_map[ndx] * scale / obj_scale
+ if abs(zl) > abs(rc[v_id][1]):
+ rc[v_id] = (v, zl)
+ if ndx in zu_map:
+ zu = zu_map[ndx] * scale / obj_scale
+ if abs(zu) > abs(rc[v_id][1]):
+ rc[v_id] = (v, zu)
+
+ if vars_to_load is None:
+ res = ComponentMap(rc.values())
+ for v, _ in nl_info.eliminated_vars:
+ res[v] = 0
+ else:
+ res = ComponentMap()
+ for v in vars_to_load:
+ if id(v) in rc:
+ res[v] = rc[id(v)][1]
+ else:
+ # eliminated vars
+ res[v] = 0
+ return res
+
+
+ipopt_command_line_options = {
+ 'acceptable_compl_inf_tol',
+ 'acceptable_constr_viol_tol',
+ 'acceptable_dual_inf_tol',
+ 'acceptable_tol',
+ 'alpha_for_y',
+ 'bound_frac',
+ 'bound_mult_init_val',
+ 'bound_push',
+ 'bound_relax_factor',
+ 'compl_inf_tol',
+ 'constr_mult_init_max',
+ 'constr_viol_tol',
+ 'diverging_iterates_tol',
+ 'dual_inf_tol',
+ 'expect_infeasible_problem',
+ 'file_print_level',
+ 'halt_on_ampl_error',
+ 'hessian_approximation',
+ 'honor_original_bounds',
+ 'linear_scaling_on_demand',
+ 'linear_solver',
+ 'linear_system_scaling',
+ 'ma27_pivtol',
+ 'ma27_pivtolmax',
+ 'ma57_pivot_order',
+ 'ma57_pivtol',
+ 'ma57_pivtolmax',
+ 'max_cpu_time',
+ 'max_iter',
+ 'max_refinement_steps',
+ 'max_soc',
+ 'maxit',
+ 'min_refinement_steps',
+ 'mu_init',
+ 'mu_max',
+ 'mu_oracle',
+ 'mu_strategy',
+ 'nlp_scaling_max_gradient',
+ 'nlp_scaling_method',
+ 'obj_scaling_factor',
+ 'option_file_name',
+ 'outlev',
+ 'output_file',
+ 'pardiso_matching_strategy',
+ 'print_level',
+ 'print_options_documentation',
+ 'print_user_options',
+ 'required_infeasibility_reduction',
+ 'slack_bound_frac',
+ 'slack_bound_push',
+ 'tol',
+ 'wantsol',
+ 'warm_start_bound_push',
+ 'warm_start_init_point',
+ 'warm_start_mult_bound_push',
+ 'watchdog_shortened_iter_trigger',
+}
+
+
+class Ipopt(SolverBase):
+ CONFIG = IpoptConfig()
+
+ def __init__(self, **kwds):
+ super().__init__(**kwds)
+ self._writer = NLWriter()
+ self._available_cache = None
+ self._version_cache = None
+ self._version_timeout = 2
+
+ def available(self, config=None):
+ if config is None:
+ config = self.config
+ pth = config.executable.path()
+ if self._available_cache is None or self._available_cache[0] != pth:
+ if pth is None:
+ self._available_cache = (None, self.Availability.NotFound)
+ else:
+ self._available_cache = (pth, self.Availability.FullLicense)
+ return self._available_cache[1]
+
+ def version(self, config=None):
+ if config is None:
+ config = self.config
+ pth = config.executable.path()
+ if self._version_cache is None or self._version_cache[0] != pth:
+ if pth is None:
+ self._version_cache = (None, None)
+ else:
+ results = subprocess.run(
+ [str(pth), '--version'],
+ timeout=self._version_timeout,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT,
+ universal_newlines=True,
+ )
+ version = results.stdout.splitlines()[0]
+ version = version.split(' ')[1].strip()
+ version = tuple(int(i) for i in version.split('.'))
+ self._version_cache = (pth, version)
+ return self._version_cache[1]
+
+ def _write_options_file(self, filename: str, options: Mapping):
+ # First we need to determine if we even need to create a file.
+ # If options is empty, then we return False
+ opt_file_exists = False
+ if not options:
+ return False
+ # If it has options in it, parse them and write them to a file.
+ # If they are command line options, ignore them; they will be
+ # parsed during _create_command_line
+ for k, val in options.items():
+ if k not in ipopt_command_line_options:
+ opt_file_exists = True
+ with open(filename + '.opt', 'a+') as opt_file:
+ opt_file.write(str(k) + ' ' + str(val) + '\n')
+ return opt_file_exists
+
+ def _create_command_line(self, basename: str, config: IpoptConfig, opt_file: bool):
+ cmd = [str(config.executable), basename + '.nl', '-AMPL']
+ if opt_file:
+ cmd.append('option_file_name=' + basename + '.opt')
+ if 'option_file_name' in config.solver_options:
+ raise ValueError(
+ 'Pyomo generates the ipopt options file as part of the `solve` method. '
+ 'Add all options to ipopt.config.solver_options instead.'
+ )
+ if (
+ config.time_limit is not None
+ and 'max_cpu_time' not in config.solver_options
+ ):
+ config.solver_options['max_cpu_time'] = config.time_limit
+ for k, val in config.solver_options.items():
+ if k in ipopt_command_line_options:
+ cmd.append(str(k) + '=' + str(val))
+ return cmd
+
+ @document_kwargs_from_configdict(CONFIG)
+ def solve(self, model, **kwds):
+ # Begin time tracking
+ start_timestamp = datetime.datetime.now(datetime.timezone.utc)
+ # Update configuration options, based on keywords passed to solve
+ config: IpoptConfig = self.config(value=kwds, preserve_implicit=True)
+ # Check if solver is available
+ avail = self.available(config)
+ if not avail:
+ raise IpoptSolverError(
+ f'Solver {self.__class__} is not available ({avail}).'
+ )
+ if config.threads:
+ logger.log(
+ logging.WARNING,
+ msg=f"The `threads` option was specified, but this is not used by {self.__class__}.",
+ )
+ if config.timer is None:
+ timer = HierarchicalTimer()
+ else:
+ timer = config.timer
+ StaleFlagManager.mark_all_as_stale()
+ with TempfileManager.new_context() as tempfile:
+ if config.working_dir is None:
+ dname = tempfile.mkdtemp()
+ else:
+ dname = config.working_dir
+ if not os.path.exists(dname):
+ os.mkdir(dname)
+ basename = os.path.join(dname, model.name)
+ if os.path.exists(basename + '.nl'):
+ raise RuntimeError(
+ f"NL file with the same name {basename + '.nl'} already exists!"
+ )
+ # Note: the ASL has an issue where string constants written
+ # to the NL file (e.g. arguments in external functions) MUST
+ # be terminated with '\n' regardless of platform. We will
+ # disable universal newlines in the NL file to prevent
+ # Python from mapping those '\n' to '\r\n' on Windows.
+ with open(basename + '.nl', 'w', newline='\n') as nl_file, open(
+ basename + '.row', 'w'
+ ) as row_file, open(basename + '.col', 'w') as col_file:
+ timer.start('write_nl_file')
+ self._writer.config.set_value(config.writer_config)
+ try:
+ nl_info = self._writer.write(
+ model,
+ nl_file,
+ row_file,
+ col_file,
+ symbolic_solver_labels=config.symbolic_solver_labels,
+ )
+ proven_infeasible = False
+ except InfeasibleConstraintException:
+ proven_infeasible = True
+ timer.stop('write_nl_file')
+ if not proven_infeasible and len(nl_info.variables) > 0:
+ # Get a copy of the environment to pass to the subprocess
+ env = os.environ.copy()
+ if nl_info.external_function_libraries:
+ if env.get('AMPLFUNC'):
+ nl_info.external_function_libraries.append(env.get('AMPLFUNC'))
+ env['AMPLFUNC'] = "\n".join(nl_info.external_function_libraries)
+ # Write the opt_file, if there should be one; return a bool to say
+ # whether or not we have one (so we can correctly build the command line)
+ opt_file = self._write_options_file(
+ filename=basename, options=config.solver_options
+ )
+ # Call ipopt - passing the files via the subprocess
+ cmd = self._create_command_line(
+ basename=basename, config=config, opt_file=opt_file
+ )
+ # this seems silly, but we have to give the subprocess slightly longer to finish than
+ # ipopt
+ if config.time_limit is not None:
+ timeout = config.time_limit + min(
+ max(1.0, 0.01 * config.time_limit), 100
+ )
+ else:
+ timeout = None
+
+ ostreams = [io.StringIO()] + config.tee
+ with TeeStream(*ostreams) as t:
+ timer.start('subprocess')
+ process = subprocess.run(
+ cmd,
+ timeout=timeout,
+ env=env,
+ universal_newlines=True,
+ stdout=t.STDOUT,
+ stderr=t.STDERR,
+ )
+ timer.stop('subprocess')
+ # This is the stuff we need to parse to get the iterations
+ # and time
+ (iters, ipopt_time_nofunc, ipopt_time_func, ipopt_total_time) = (
+ self._parse_ipopt_output(ostreams[0])
+ )
+
+ if proven_infeasible:
+ results = Results()
+ results.termination_condition = TerminationCondition.provenInfeasible
+ results.solution_loader = SolSolutionLoader(None, None)
+ results.iteration_count = 0
+ results.timing_info.total_seconds = 0
+ elif len(nl_info.variables) == 0:
+ if len(nl_info.eliminated_vars) == 0:
+ results = Results()
+ results.termination_condition = TerminationCondition.emptyModel
+ results.solution_loader = SolSolutionLoader(None, None)
+ else:
+ results = Results()
+ results.termination_condition = (
+ TerminationCondition.convergenceCriteriaSatisfied
+ )
+ results.solution_status = SolutionStatus.optimal
+ results.solution_loader = SolSolutionLoader(None, nl_info=nl_info)
+ results.iteration_count = 0
+ results.timing_info.total_seconds = 0
+ else:
+ if os.path.isfile(basename + '.sol'):
+ with open(basename + '.sol', 'r') as sol_file:
+ timer.start('parse_sol')
+ results = self._parse_solution(sol_file, nl_info)
+ timer.stop('parse_sol')
+ else:
+ results = Results()
+ if process.returncode != 0:
+ results.extra_info.return_code = process.returncode
+ results.termination_condition = TerminationCondition.error
+ results.solution_loader = SolSolutionLoader(None, None)
+ else:
+ results.iteration_count = iters
+ if ipopt_time_nofunc is not None:
+ results.timing_info.ipopt_excluding_nlp_functions = (
+ ipopt_time_nofunc
+ )
+
+ if ipopt_time_func is not None:
+ results.timing_info.nlp_function_evaluations = ipopt_time_func
+ if ipopt_total_time is not None:
+ results.timing_info.total_seconds = ipopt_total_time
+ if (
+ config.raise_exception_on_nonoptimal_result
+ and results.solution_status != SolutionStatus.optimal
+ ):
+ raise RuntimeError(
+ 'Solver did not find the optimal solution. Set '
+ 'opt.config.raise_exception_on_nonoptimal_result = False to bypass this error.'
+ )
+
+ results.solver_name = self.name
+ results.solver_version = self.version(config)
+ if (
+ config.load_solutions
+ and results.solution_status == SolutionStatus.noSolution
+ ):
+ raise RuntimeError(
+ 'A feasible solution was not found, so no solution can be loaded.'
+ 'Please set opt.config.load_solutions=False to bypass this error.'
+ )
+
+ if config.load_solutions:
+ results.solution_loader.load_vars()
+ if (
+ hasattr(model, 'dual')
+ and isinstance(model.dual, Suffix)
+ and model.dual.import_enabled()
+ ):
+ model.dual.update(results.solution_loader.get_duals())
+ if (
+ hasattr(model, 'rc')
+ and isinstance(model.rc, Suffix)
+ and model.rc.import_enabled()
+ ):
+ model.rc.update(results.solution_loader.get_reduced_costs())
+
+ if (
+ results.solution_status in {SolutionStatus.feasible, SolutionStatus.optimal}
+ and len(nl_info.objectives) > 0
+ ):
+ if config.load_solutions:
+ results.incumbent_objective = value(nl_info.objectives[0])
+ else:
+ results.incumbent_objective = value(
+ replace_expressions(
+ nl_info.objectives[0].expr,
+ substitution_map={
+ id(v): val
+ for v, val in results.solution_loader.get_primals().items()
+ },
+ descend_into_named_expressions=True,
+ remove_named_expressions=True,
+ )
+ )
+
+ results.solver_configuration = config
+ if not proven_infeasible and len(nl_info.variables) > 0:
+ results.solver_log = ostreams[0].getvalue()
+
+ # Capture/record end-time / wall-time
+ end_timestamp = datetime.datetime.now(datetime.timezone.utc)
+ results.timing_info.start_timestamp = start_timestamp
+ results.timing_info.wall_time = (
+ end_timestamp - start_timestamp
+ ).total_seconds()
+ results.timing_info.timer = timer
+ return results
+
+ def _parse_ipopt_output(self, stream: io.StringIO):
+ """
+ Parse an IPOPT output file and return:
+
+ * number of iterations
+ * time in IPOPT
+
+ """
+
+ iters = None
+ nofunc_time = None
+ func_time = None
+ total_time = None
+ # parse the output stream to get the iteration count and solver time
+ for line in stream.getvalue().splitlines():
+ if line.startswith("Number of Iterations....:"):
+ tokens = line.split()
+ iters = int(tokens[-1])
+ elif line.startswith(
+ "Total seconds in IPOPT ="
+ ):
+ # Newer versions of IPOPT no longer separate timing into
+ # two different values. This is so we have compatibility with
+ # both new and old versions
+ tokens = line.split()
+ total_time = float(tokens[-1])
+ elif line.startswith(
+ "Total CPU secs in IPOPT (w/o function evaluations) ="
+ ):
+ tokens = line.split()
+ nofunc_time = float(tokens[-1])
+ elif line.startswith(
+ "Total CPU secs in NLP function evaluations ="
+ ):
+ tokens = line.split()
+ func_time = float(tokens[-1])
+
+ return iters, nofunc_time, func_time, total_time
+
+ def _parse_solution(self, instream: io.TextIOBase, nl_info: NLWriterInfo):
+ results = Results()
+ res, sol_data = parse_sol_file(
+ sol_file=instream, nl_info=nl_info, result=results
+ )
+
+ if res.solution_status == SolutionStatus.noSolution:
+ res.solution_loader = SolSolutionLoader(None, None)
+ else:
+ res.solution_loader = IpoptSolutionLoader(
+ sol_data=sol_data, nl_info=nl_info
+ )
+
+ return res
diff --git a/pyomo/contrib/solver/persistent.py b/pyomo/contrib/solver/persistent.py
new file mode 100644
index 00000000000..71322b7043e
--- /dev/null
+++ b/pyomo/contrib/solver/persistent.py
@@ -0,0 +1,523 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 abc
+from typing import List
+
+from pyomo.core.base.constraint import ConstraintData, Constraint
+from pyomo.core.base.sos import SOSConstraintData, SOSConstraint
+from pyomo.core.base.var import VarData
+from pyomo.core.base.param import ParamData, Param
+from pyomo.core.base.objective import ObjectiveData
+from pyomo.common.collections import ComponentMap
+from pyomo.common.timing import HierarchicalTimer
+from pyomo.core.expr.numvalue import NumericConstant
+from pyomo.contrib.solver.util import collect_vars_and_named_exprs, get_objective
+
+
+class PersistentSolverUtils(abc.ABC):
+ def __init__(self):
+ self._model = None
+ self._active_constraints = {} # maps constraint to (lower, body, upper)
+ self._vars = {} # maps var id to (var, lb, ub, fixed, domain, value)
+ self._params = {} # maps param id to param
+ self._objective = None
+ self._objective_expr = None
+ self._objective_sense = None
+ self._named_expressions = (
+ {}
+ ) # maps constraint to list of tuples (named_expr, named_expr.expr)
+ self._external_functions = ComponentMap()
+ self._obj_named_expressions = []
+ self._referenced_variables = (
+ {}
+ ) # var_id: [dict[constraints, None], dict[sos constraints, None], None or objective]
+ self._vars_referenced_by_con = {}
+ self._vars_referenced_by_obj = []
+ self._expr_types = None
+
+ def set_instance(self, model):
+ saved_config = self.config
+ self.__init__()
+ self.config = saved_config
+ self._model = model
+ self.add_block(model)
+ if self._objective is None:
+ self.set_objective(None)
+
+ @abc.abstractmethod
+ def _add_variables(self, variables: List[VarData]):
+ pass
+
+ def add_variables(self, variables: List[VarData]):
+ for v in variables:
+ if id(v) in self._referenced_variables:
+ raise ValueError(
+ 'variable {name} has already been added'.format(name=v.name)
+ )
+ self._referenced_variables[id(v)] = [{}, {}, None]
+ self._vars[id(v)] = (
+ v,
+ v._lb,
+ v._ub,
+ v.fixed,
+ v.domain.get_interval(),
+ v.value,
+ )
+ self._add_variables(variables)
+
+ @abc.abstractmethod
+ def _add_parameters(self, params: List[ParamData]):
+ pass
+
+ def add_parameters(self, params: List[ParamData]):
+ for p in params:
+ self._params[id(p)] = p
+ self._add_parameters(params)
+
+ @abc.abstractmethod
+ def _add_constraints(self, cons: List[ConstraintData]):
+ pass
+
+ def _check_for_new_vars(self, variables: List[VarData]):
+ new_vars = {}
+ for v in variables:
+ v_id = id(v)
+ if v_id not in self._referenced_variables:
+ new_vars[v_id] = v
+ self.add_variables(list(new_vars.values()))
+
+ def _check_to_remove_vars(self, variables: List[VarData]):
+ vars_to_remove = {}
+ for v in variables:
+ v_id = id(v)
+ ref_cons, ref_sos, ref_obj = self._referenced_variables[v_id]
+ if len(ref_cons) == 0 and len(ref_sos) == 0 and ref_obj is None:
+ vars_to_remove[v_id] = v
+ self.remove_variables(list(vars_to_remove.values()))
+
+ def add_constraints(self, cons: List[ConstraintData]):
+ all_fixed_vars = {}
+ for con in cons:
+ if con in self._named_expressions:
+ raise ValueError(
+ 'constraint {name} has already been added'.format(name=con.name)
+ )
+ self._active_constraints[con] = (con.lower, con.body, con.upper)
+ tmp = collect_vars_and_named_exprs(con.body)
+ named_exprs, variables, fixed_vars, external_functions = tmp
+ self._check_for_new_vars(variables)
+ self._named_expressions[con] = [(e, e.expr) for e in named_exprs]
+ if len(external_functions) > 0:
+ self._external_functions[con] = external_functions
+ self._vars_referenced_by_con[con] = variables
+ for v in variables:
+ self._referenced_variables[id(v)][0][con] = None
+ if not self.config.auto_updates.treat_fixed_vars_as_params:
+ for v in fixed_vars:
+ v.unfix()
+ all_fixed_vars[id(v)] = v
+ self._add_constraints(cons)
+ for v in all_fixed_vars.values():
+ v.fix()
+
+ @abc.abstractmethod
+ def _add_sos_constraints(self, cons: List[SOSConstraintData]):
+ pass
+
+ def add_sos_constraints(self, cons: List[SOSConstraintData]):
+ for con in cons:
+ if con in self._vars_referenced_by_con:
+ raise ValueError(
+ 'constraint {name} has already been added'.format(name=con.name)
+ )
+ self._active_constraints[con] = tuple()
+ variables = con.get_variables()
+ self._check_for_new_vars(variables)
+ self._named_expressions[con] = []
+ self._vars_referenced_by_con[con] = variables
+ for v in variables:
+ self._referenced_variables[id(v)][1][con] = None
+ self._add_sos_constraints(cons)
+
+ @abc.abstractmethod
+ def _set_objective(self, obj: ObjectiveData):
+ pass
+
+ def set_objective(self, obj: ObjectiveData):
+ if self._objective is not None:
+ for v in self._vars_referenced_by_obj:
+ self._referenced_variables[id(v)][2] = None
+ self._check_to_remove_vars(self._vars_referenced_by_obj)
+ self._external_functions.pop(self._objective, None)
+ if obj is not None:
+ self._objective = obj
+ self._objective_expr = obj.expr
+ self._objective_sense = obj.sense
+ tmp = collect_vars_and_named_exprs(obj.expr)
+ named_exprs, variables, fixed_vars, external_functions = tmp
+ self._check_for_new_vars(variables)
+ self._obj_named_expressions = [(i, i.expr) for i in named_exprs]
+ if len(external_functions) > 0:
+ self._external_functions[obj] = external_functions
+ self._vars_referenced_by_obj = variables
+ for v in variables:
+ self._referenced_variables[id(v)][2] = obj
+ if not self.config.auto_updates.treat_fixed_vars_as_params:
+ for v in fixed_vars:
+ v.unfix()
+ self._set_objective(obj)
+ for v in fixed_vars:
+ v.fix()
+ else:
+ self._vars_referenced_by_obj = []
+ self._objective = None
+ self._objective_expr = None
+ self._objective_sense = None
+ self._obj_named_expressions = []
+ self._set_objective(obj)
+
+ def add_block(self, block):
+ param_dict = {}
+ for p in block.component_objects(Param, descend_into=True):
+ if p.mutable:
+ for _p in p.values():
+ param_dict[id(_p)] = _p
+ self.add_parameters(list(param_dict.values()))
+ self.add_constraints(
+ list(
+ block.component_data_objects(Constraint, descend_into=True, active=True)
+ )
+ )
+ self.add_sos_constraints(
+ list(
+ block.component_data_objects(
+ SOSConstraint, descend_into=True, active=True
+ )
+ )
+ )
+ obj = get_objective(block)
+ if obj is not None:
+ self.set_objective(obj)
+
+ @abc.abstractmethod
+ def _remove_constraints(self, cons: List[ConstraintData]):
+ pass
+
+ def remove_constraints(self, cons: List[ConstraintData]):
+ self._remove_constraints(cons)
+ for con in cons:
+ if con not in self._named_expressions:
+ raise ValueError(
+ 'cannot remove constraint {name} - it was not added'.format(
+ name=con.name
+ )
+ )
+ for v in self._vars_referenced_by_con[con]:
+ self._referenced_variables[id(v)][0].pop(con)
+ self._check_to_remove_vars(self._vars_referenced_by_con[con])
+ del self._active_constraints[con]
+ del self._named_expressions[con]
+ self._external_functions.pop(con, None)
+ del self._vars_referenced_by_con[con]
+
+ @abc.abstractmethod
+ def _remove_sos_constraints(self, cons: List[SOSConstraintData]):
+ pass
+
+ def remove_sos_constraints(self, cons: List[SOSConstraintData]):
+ self._remove_sos_constraints(cons)
+ for con in cons:
+ if con not in self._vars_referenced_by_con:
+ raise ValueError(
+ 'cannot remove constraint {name} - it was not added'.format(
+ name=con.name
+ )
+ )
+ for v in self._vars_referenced_by_con[con]:
+ self._referenced_variables[id(v)][1].pop(con)
+ self._check_to_remove_vars(self._vars_referenced_by_con[con])
+ del self._active_constraints[con]
+ del self._named_expressions[con]
+ del self._vars_referenced_by_con[con]
+
+ @abc.abstractmethod
+ def _remove_variables(self, variables: List[VarData]):
+ pass
+
+ def remove_variables(self, variables: List[VarData]):
+ self._remove_variables(variables)
+ for v in variables:
+ v_id = id(v)
+ if v_id not in self._referenced_variables:
+ raise ValueError(
+ 'cannot remove variable {name} - it has not been added'.format(
+ name=v.name
+ )
+ )
+ cons_using, sos_using, obj_using = self._referenced_variables[v_id]
+ if cons_using or sos_using or (obj_using is not None):
+ raise ValueError(
+ 'cannot remove variable {name} - it is still being used by constraints or the objective'.format(
+ name=v.name
+ )
+ )
+ del self._referenced_variables[v_id]
+ del self._vars[v_id]
+
+ @abc.abstractmethod
+ def _remove_parameters(self, params: List[ParamData]):
+ pass
+
+ def remove_parameters(self, params: List[ParamData]):
+ self._remove_parameters(params)
+ for p in params:
+ del self._params[id(p)]
+
+ def remove_block(self, block):
+ self.remove_constraints(
+ list(
+ block.component_data_objects(
+ ctype=Constraint, descend_into=True, active=True
+ )
+ )
+ )
+ self.remove_sos_constraints(
+ list(
+ block.component_data_objects(
+ ctype=SOSConstraint, descend_into=True, active=True
+ )
+ )
+ )
+ self.remove_parameters(
+ list(
+ dict(
+ (id(p), p)
+ for p in block.component_data_objects(
+ ctype=Param, descend_into=True
+ )
+ ).values()
+ )
+ )
+
+ @abc.abstractmethod
+ def _update_variables(self, variables: List[VarData]):
+ pass
+
+ def update_variables(self, variables: List[VarData]):
+ for v in variables:
+ self._vars[id(v)] = (
+ v,
+ v._lb,
+ v._ub,
+ v.fixed,
+ v.domain.get_interval(),
+ v.value,
+ )
+ self._update_variables(variables)
+
+ @abc.abstractmethod
+ def update_parameters(self):
+ pass
+
+ def update(self, timer: HierarchicalTimer = None):
+ if timer is None:
+ timer = HierarchicalTimer()
+ config = self.config.auto_updates
+ new_vars = []
+ old_vars = []
+ new_params = []
+ old_params = []
+ new_cons = []
+ old_cons = []
+ old_sos = []
+ new_sos = []
+ current_vars_dict = {}
+ current_cons_dict = {}
+ current_sos_dict = {}
+ timer.start('vars')
+ if config.update_vars:
+ start_vars = {v_id: v_tuple[0] for v_id, v_tuple in self._vars.items()}
+ timer.stop('vars')
+ timer.start('params')
+ if config.check_for_new_or_removed_params:
+ current_params_dict = {}
+ for p in self._model.component_objects(Param, descend_into=True):
+ if p.mutable:
+ for _p in p.values():
+ current_params_dict[id(_p)] = _p
+ for p_id, p in current_params_dict.items():
+ if p_id not in self._params:
+ new_params.append(p)
+ for p_id, p in self._params.items():
+ if p_id not in current_params_dict:
+ old_params.append(p)
+ timer.stop('params')
+ timer.start('cons')
+ if config.check_for_new_or_removed_constraints or config.update_constraints:
+ current_cons_dict = {
+ c: None
+ for c in self._model.component_data_objects(
+ Constraint, descend_into=True, active=True
+ )
+ }
+ current_sos_dict = {
+ c: None
+ for c in self._model.component_data_objects(
+ SOSConstraint, descend_into=True, active=True
+ )
+ }
+ for c in current_cons_dict.keys():
+ if c not in self._vars_referenced_by_con:
+ new_cons.append(c)
+ for c in current_sos_dict.keys():
+ if c not in self._vars_referenced_by_con:
+ new_sos.append(c)
+ for c in self._vars_referenced_by_con.keys():
+ if c not in current_cons_dict and c not in current_sos_dict:
+ if (c.ctype is Constraint) or (
+ c.ctype is None and isinstance(c, ConstraintData)
+ ):
+ old_cons.append(c)
+ else:
+ assert (c.ctype is SOSConstraint) or (
+ c.ctype is None and isinstance(c, SOSConstraintData)
+ )
+ old_sos.append(c)
+ self.remove_constraints(old_cons)
+ self.remove_sos_constraints(old_sos)
+ timer.stop('cons')
+ timer.start('params')
+ self.remove_parameters(old_params)
+
+ # sticking this between removal and addition
+ # is important so that we don't do unnecessary work
+ if config.update_parameters:
+ self.update_parameters()
+
+ self.add_parameters(new_params)
+ timer.stop('params')
+ timer.start('vars')
+ self.add_variables(new_vars)
+ timer.stop('vars')
+ timer.start('cons')
+ self.add_constraints(new_cons)
+ self.add_sos_constraints(new_sos)
+ new_cons_set = set(new_cons)
+ new_sos_set = set(new_sos)
+ new_vars_set = set(id(v) for v in new_vars)
+ cons_to_remove_and_add = {}
+ need_to_set_objective = False
+ if config.update_constraints:
+ cons_to_update = []
+ sos_to_update = []
+ for c in current_cons_dict.keys():
+ if c not in new_cons_set:
+ cons_to_update.append(c)
+ for c in current_sos_dict.keys():
+ if c not in new_sos_set:
+ sos_to_update.append(c)
+ for c in cons_to_update:
+ lower, body, upper = self._active_constraints[c]
+ new_lower, new_body, new_upper = c.lower, c.body, c.upper
+ if new_body is not body:
+ cons_to_remove_and_add[c] = None
+ continue
+ if new_lower is not lower:
+ if (
+ type(new_lower) is NumericConstant
+ and type(lower) is NumericConstant
+ and new_lower.value == lower.value
+ ):
+ pass
+ else:
+ cons_to_remove_and_add[c] = None
+ continue
+ if new_upper is not upper:
+ if (
+ type(new_upper) is NumericConstant
+ and type(upper) is NumericConstant
+ and new_upper.value == upper.value
+ ):
+ pass
+ else:
+ cons_to_remove_and_add[c] = None
+ continue
+ self.remove_sos_constraints(sos_to_update)
+ self.add_sos_constraints(sos_to_update)
+ timer.stop('cons')
+ timer.start('vars')
+ if config.update_vars:
+ end_vars = {v_id: v_tuple[0] for v_id, v_tuple in self._vars.items()}
+ vars_to_check = [v for v_id, v in end_vars.items() if v_id in start_vars]
+ if config.update_vars:
+ vars_to_update = []
+ for v in vars_to_check:
+ _v, lb, ub, fixed, domain_interval, value = self._vars[id(v)]
+ if (fixed != v.fixed) or (fixed and (value != v.value)):
+ vars_to_update.append(v)
+ if self.config.auto_updates.treat_fixed_vars_as_params:
+ for c in self._referenced_variables[id(v)][0]:
+ cons_to_remove_and_add[c] = None
+ if self._referenced_variables[id(v)][2] is not None:
+ need_to_set_objective = True
+ elif lb is not v._lb:
+ vars_to_update.append(v)
+ elif ub is not v._ub:
+ vars_to_update.append(v)
+ elif domain_interval != v.domain.get_interval():
+ vars_to_update.append(v)
+ self.update_variables(vars_to_update)
+ timer.stop('vars')
+ timer.start('cons')
+ cons_to_remove_and_add = list(cons_to_remove_and_add.keys())
+ self.remove_constraints(cons_to_remove_and_add)
+ self.add_constraints(cons_to_remove_and_add)
+ timer.stop('cons')
+ timer.start('named expressions')
+ if config.update_named_expressions:
+ cons_to_update = []
+ for c, expr_list in self._named_expressions.items():
+ if c in new_cons_set:
+ continue
+ for named_expr, old_expr in expr_list:
+ if named_expr.expr is not old_expr:
+ cons_to_update.append(c)
+ break
+ self.remove_constraints(cons_to_update)
+ self.add_constraints(cons_to_update)
+ for named_expr, old_expr in self._obj_named_expressions:
+ if named_expr.expr is not old_expr:
+ need_to_set_objective = True
+ break
+ timer.stop('named expressions')
+ timer.start('objective')
+ if self.config.auto_updates.check_for_new_objective:
+ pyomo_obj = get_objective(self._model)
+ if pyomo_obj is not self._objective:
+ need_to_set_objective = True
+ else:
+ pyomo_obj = self._objective
+ if self.config.auto_updates.update_objective:
+ if pyomo_obj is not None and pyomo_obj.expr is not self._objective_expr:
+ need_to_set_objective = True
+ elif pyomo_obj is not None and pyomo_obj.sense is not self._objective_sense:
+ # we can definitely do something faster here than resetting the whole objective
+ need_to_set_objective = True
+ if need_to_set_objective:
+ self.set_objective(pyomo_obj)
+ timer.stop('objective')
+
+ # this has to be done after the objective and constraints in case the
+ # old objective/constraints use old variables
+ timer.start('vars')
+ self.remove_variables(old_vars)
+ timer.stop('vars')
diff --git a/pyomo/contrib/solver/plugins.py b/pyomo/contrib/solver/plugins.py
new file mode 100644
index 00000000000..82c10a32fd8
--- /dev/null
+++ b/pyomo/contrib/solver/plugins.py
@@ -0,0 +1,30 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+
+from .factory import SolverFactory
+from .ipopt import Ipopt
+from .gurobi import Gurobi
+from .gurobi_direct import GurobiDirect
+
+
+def load():
+ SolverFactory.register(
+ name='ipopt', legacy_name='ipopt_v2', doc='The IPOPT NLP solver'
+ )(Ipopt)
+ SolverFactory.register(
+ name='gurobi', legacy_name='gurobi_v2', doc='Persistent interface to Gurobi'
+ )(Gurobi)
+ SolverFactory.register(
+ name='gurobi_direct',
+ legacy_name='gurobi_direct_v2',
+ doc='Direct (scipy-based) interface to Gurobi',
+ )(GurobiDirect)
diff --git a/pyomo/contrib/solver/results.py b/pyomo/contrib/solver/results.py
new file mode 100644
index 00000000000..cbc04681235
--- /dev/null
+++ b/pyomo/contrib/solver/results.py
@@ -0,0 +1,353 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 enum
+from typing import Optional, Tuple
+from datetime import datetime
+
+from pyomo.common.config import (
+ ConfigDict,
+ ConfigValue,
+ IsInstance,
+ NonNegativeInt,
+ In,
+ NonNegativeFloat,
+ ADVANCED_OPTION,
+)
+from pyomo.opt.results.solution import SolutionStatus as LegacySolutionStatus
+from pyomo.opt.results.solver import (
+ TerminationCondition as LegacyTerminationCondition,
+ SolverStatus as LegacySolverStatus,
+)
+
+
+class TerminationCondition(enum.Enum):
+ """
+ An Enum that enumerates all possible exit statuses for a solver call.
+
+ Attributes
+ ----------
+ convergenceCriteriaSatisfied: 0
+ The solver exited because convergence criteria of the problem were
+ satisfied.
+ maxTimeLimit: 1
+ The solver exited due to reaching a specified time limit.
+ iterationLimit: 2
+ The solver exited due to reaching a specified iteration limit.
+ objectiveLimit: 3
+ The solver exited due to reaching an objective limit. For example,
+ in Gurobi, the exit message "Optimal objective for model was proven to
+ be worse than the value specified in the Cutoff parameter" would map
+ to objectiveLimit.
+ minStepLength: 4
+ The solver exited due to a minimum step length.
+ Minimum step length reached may mean that the problem is infeasible or
+ that the problem is feasible but the solver could not converge.
+ unbounded: 5
+ The solver exited because the problem has been found to be unbounded.
+ provenInfeasible: 6
+ The solver exited because the problem has been proven infeasible.
+ locallyInfeasible: 7
+ The solver exited because no feasible solution was found to the
+ submitted problem, but it could not be proven that no such solution exists.
+ infeasibleOrUnbounded: 8
+ Some solvers do not specify between infeasibility or unboundedness and
+ instead return that one or the other has occurred. For example, in
+ Gurobi, this may occur because there are some steps in presolve that
+ prevent Gurobi from distinguishing between infeasibility and unboundedness.
+ error: 9
+ The solver exited with some error. The error message will also be
+ captured and returned.
+ interrupted: 10
+ The solver was interrupted while running.
+ licensingProblems: 11
+ The solver experienced issues with licensing. This could be that no
+ license was found, the license is of the wrong type for the problem (e.g.,
+ problem is too big for type of license), or there was an issue contacting
+ a licensing server.
+ emptyModel: 12
+ The model being solved did not have any variables
+ unknown: 42
+ All other unrecognized exit statuses fall in this category.
+ """
+
+ convergenceCriteriaSatisfied = 0
+
+ maxTimeLimit = 1
+
+ iterationLimit = 2
+
+ objectiveLimit = 3
+
+ minStepLength = 4
+
+ unbounded = 5
+
+ provenInfeasible = 6
+
+ locallyInfeasible = 7
+
+ infeasibleOrUnbounded = 8
+
+ error = 9
+
+ interrupted = 10
+
+ licensingProblems = 11
+
+ emptyModel = 12
+
+ unknown = 42
+
+
+class SolutionStatus(enum.Enum):
+ """
+ An enumeration for interpreting the result of a termination. This describes the designated
+ status by the solver to be loaded back into the model.
+
+ Attributes
+ ----------
+ noSolution: 0
+ No (single) solution was found; possible that a population of solutions
+ was returned.
+ infeasible: 10
+ Solution point does not satisfy some domains and/or constraints.
+ feasible: 20
+ A solution for which all of the constraints in the model are satisfied.
+ optimal: 30
+ A feasible solution where the objective function reaches its specified
+ sense (e.g., maximum, minimum)
+ """
+
+ noSolution = 0
+
+ infeasible = 10
+
+ feasible = 20
+
+ optimal = 30
+
+
+class Results(ConfigDict):
+ """
+ Attributes
+ ----------
+ solution_loader: SolutionLoaderBase
+ Object for loading the solution back into the model.
+ termination_condition: :class:`TerminationCondition`
+ The reason the solver exited. This is a member of the
+ TerminationCondition enum.
+ solution_status: :class:`SolutionStatus`
+ The result of the solve call. This is a member of the SolutionStatus
+ enum.
+ incumbent_objective: float
+ If a feasible solution was found, this is the objective value of
+ the best solution found. If no feasible solution was found, this is
+ None.
+ objective_bound: float
+ The best objective bound found. For minimization problems, this is
+ the lower bound. For maximization problems, this is the upper bound.
+ For solvers that do not provide an objective bound, this should be -inf
+ (minimization) or inf (maximization)
+ solver_name: str
+ The name of the solver in use.
+ solver_version: tuple
+ A tuple representing the version of the solver in use.
+ iteration_count: int
+ The total number of iterations.
+ timing_info: ConfigDict
+ A ConfigDict containing three pieces of information:
+ - ``start_timestamp``: UTC timestamp of when run was initiated
+ - ``wall_time``: elapsed wall clock time for entire process
+ - ``timer``: a HierarchicalTimer object containing timing data about the solve
+
+ Specific solvers may add other relevant timing information, as appropriate.
+ extra_info: ConfigDict
+ A ConfigDict to store extra information such as solver messages.
+ solver_configuration: ConfigDict
+ A copy of the SolverConfig ConfigDict, for later inspection/reproducibility.
+ solver_log: str
+ (ADVANCED OPTION) Any solver log messages.
+ """
+
+ def __init__(
+ self,
+ description=None,
+ doc=None,
+ implicit=False,
+ implicit_domain=None,
+ visibility=0,
+ ):
+ super().__init__(
+ description=description,
+ doc=doc,
+ implicit=implicit,
+ implicit_domain=implicit_domain,
+ visibility=visibility,
+ )
+
+ self.solution_loader = self.declare(
+ 'solution_loader',
+ ConfigValue(
+ description="Object for loading the solution back into the model."
+ ),
+ )
+ self.termination_condition: TerminationCondition = self.declare(
+ 'termination_condition',
+ ConfigValue(
+ domain=In(TerminationCondition),
+ default=TerminationCondition.unknown,
+ description="The reason the solver exited. This is a member of the "
+ "TerminationCondition enum.",
+ ),
+ )
+ self.solution_status: SolutionStatus = self.declare(
+ 'solution_status',
+ ConfigValue(
+ domain=In(SolutionStatus),
+ default=SolutionStatus.noSolution,
+ description="The result of the solve call. This is a member of "
+ "the SolutionStatus enum.",
+ ),
+ )
+ self.incumbent_objective: Optional[float] = self.declare(
+ 'incumbent_objective',
+ ConfigValue(
+ domain=float,
+ default=None,
+ description="If a feasible solution was found, this is the objective "
+ "value of the best solution found. If no feasible solution was found, this is None.",
+ ),
+ )
+ self.objective_bound: Optional[float] = self.declare(
+ 'objective_bound',
+ ConfigValue(
+ domain=float,
+ default=None,
+ description="The best objective bound found. For minimization problems, "
+ "this is the lower bound. For maximization problems, this is the "
+ "upper bound. For solvers that do not provide an objective bound, "
+ "this should be -inf (minimization) or inf (maximization)",
+ ),
+ )
+ self.solver_name: Optional[str] = self.declare(
+ 'solver_name',
+ ConfigValue(domain=str, description="The name of the solver in use."),
+ )
+ self.solver_version: Optional[Tuple[int, ...]] = self.declare(
+ 'solver_version',
+ ConfigValue(
+ domain=tuple,
+ description="A tuple representing the version of the solver in use.",
+ ),
+ )
+ self.iteration_count: Optional[int] = self.declare(
+ 'iteration_count',
+ ConfigValue(
+ domain=NonNegativeInt,
+ default=None,
+ description="The total number of iterations.",
+ ),
+ )
+ self.timing_info: ConfigDict = self.declare(
+ 'timing_info', ConfigDict(implicit=True)
+ )
+
+ self.timing_info.start_timestamp: datetime = self.timing_info.declare(
+ 'start_timestamp',
+ ConfigValue(
+ domain=IsInstance(datetime),
+ description="UTC timestamp of when run was initiated.",
+ ),
+ )
+ self.timing_info.wall_time: Optional[float] = self.timing_info.declare(
+ 'wall_time',
+ ConfigValue(
+ domain=NonNegativeFloat,
+ description="Elapsed wall clock time for entire process.",
+ ),
+ )
+ self.extra_info: ConfigDict = self.declare(
+ 'extra_info', ConfigDict(implicit=True)
+ )
+ self.solver_configuration: ConfigDict = self.declare(
+ 'solver_configuration',
+ ConfigValue(
+ description="A copy of the config object used in the solve call.",
+ visibility=ADVANCED_OPTION,
+ ),
+ )
+ self.solver_log: str = self.declare(
+ 'solver_log',
+ ConfigValue(
+ domain=str,
+ default=None,
+ visibility=ADVANCED_OPTION,
+ description="Any solver log messages.",
+ ),
+ )
+
+ def display(
+ self, content_filter=None, indent_spacing=2, ostream=None, visibility=0
+ ):
+ return super().display(content_filter, indent_spacing, ostream, visibility)
+
+
+# Everything below here preserves backwards compatibility
+
+legacy_termination_condition_map = {
+ TerminationCondition.unknown: LegacyTerminationCondition.unknown,
+ TerminationCondition.maxTimeLimit: LegacyTerminationCondition.maxTimeLimit,
+ TerminationCondition.iterationLimit: LegacyTerminationCondition.maxIterations,
+ TerminationCondition.objectiveLimit: LegacyTerminationCondition.minFunctionValue,
+ TerminationCondition.minStepLength: LegacyTerminationCondition.minStepLength,
+ TerminationCondition.convergenceCriteriaSatisfied: LegacyTerminationCondition.optimal,
+ TerminationCondition.unbounded: LegacyTerminationCondition.unbounded,
+ TerminationCondition.provenInfeasible: LegacyTerminationCondition.infeasible,
+ TerminationCondition.locallyInfeasible: LegacyTerminationCondition.infeasible,
+ TerminationCondition.infeasibleOrUnbounded: LegacyTerminationCondition.infeasibleOrUnbounded,
+ TerminationCondition.error: LegacyTerminationCondition.error,
+ TerminationCondition.interrupted: LegacyTerminationCondition.resourceInterrupt,
+ TerminationCondition.licensingProblems: LegacyTerminationCondition.licensingProblems,
+}
+
+
+legacy_solver_status_map = {
+ TerminationCondition.unknown: LegacySolverStatus.unknown,
+ TerminationCondition.maxTimeLimit: LegacySolverStatus.aborted,
+ TerminationCondition.iterationLimit: LegacySolverStatus.aborted,
+ TerminationCondition.objectiveLimit: LegacySolverStatus.aborted,
+ TerminationCondition.minStepLength: LegacySolverStatus.error,
+ TerminationCondition.convergenceCriteriaSatisfied: LegacySolverStatus.ok,
+ TerminationCondition.unbounded: LegacySolverStatus.error,
+ TerminationCondition.provenInfeasible: LegacySolverStatus.error,
+ TerminationCondition.locallyInfeasible: LegacySolverStatus.error,
+ TerminationCondition.infeasibleOrUnbounded: LegacySolverStatus.error,
+ TerminationCondition.error: LegacySolverStatus.error,
+ TerminationCondition.interrupted: LegacySolverStatus.aborted,
+ TerminationCondition.licensingProblems: LegacySolverStatus.error,
+}
+
+
+legacy_solution_status_map = {
+ SolutionStatus.noSolution: LegacySolutionStatus.unknown,
+ SolutionStatus.noSolution: LegacySolutionStatus.stoppedByLimit,
+ SolutionStatus.noSolution: LegacySolutionStatus.error,
+ SolutionStatus.noSolution: LegacySolutionStatus.other,
+ SolutionStatus.noSolution: LegacySolutionStatus.unsure,
+ SolutionStatus.noSolution: LegacySolutionStatus.unbounded,
+ SolutionStatus.optimal: LegacySolutionStatus.locallyOptimal,
+ SolutionStatus.optimal: LegacySolutionStatus.globallyOptimal,
+ SolutionStatus.optimal: LegacySolutionStatus.optimal,
+ SolutionStatus.infeasible: LegacySolutionStatus.infeasible,
+ SolutionStatus.feasible: LegacySolutionStatus.feasible,
+ SolutionStatus.feasible: LegacySolutionStatus.bestSoFar,
+}
diff --git a/pyomo/contrib/solver/sol_reader.py b/pyomo/contrib/solver/sol_reader.py
new file mode 100644
index 00000000000..41d840f8d07
--- /dev/null
+++ b/pyomo/contrib/solver/sol_reader.py
@@ -0,0 +1,207 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+
+from typing import Tuple, Dict, Any, List
+import io
+
+from pyomo.common.errors import DeveloperError, PyomoException
+from pyomo.repn.plugins.nl_writer import NLWriterInfo
+from pyomo.contrib.solver.results import Results, SolutionStatus, TerminationCondition
+
+
+class SolFileData:
+ def __init__(self) -> None:
+ self.primals: List[float] = list()
+ self.duals: List[float] = list()
+ self.var_suffixes: Dict[str, Dict[int, Any]] = dict()
+ self.con_suffixes: Dict[str, Dict[Any]] = dict()
+ self.obj_suffixes: Dict[str, Dict[int, Any]] = dict()
+ self.problem_suffixes: Dict[str, List[Any]] = dict()
+ self.other: List(str) = list()
+
+
+def parse_sol_file(
+ sol_file: io.TextIOBase, nl_info: NLWriterInfo, result: Results
+) -> Tuple[Results, SolFileData]:
+ sol_data = SolFileData()
+
+ #
+ # Some solvers (minto) do not write a message. We will assume
+ # all non-blank lines up to the 'Options' line is the message.
+ # For backwards compatibility and general safety, we will parse all
+ # lines until "Options" appears. Anything before "Options" we will
+ # consider to be the solver message.
+ message = []
+ for line in sol_file:
+ if not line:
+ break
+ line = line.strip()
+ if "Options" in line:
+ break
+ message.append(line)
+ message = '\n'.join(message)
+ # Once "Options" appears, we must now read the content under it.
+ model_objects = []
+ if "Options" in line:
+ line = sol_file.readline()
+ number_of_options = int(line)
+ # We are adding in this DeveloperError to see if the alternative case
+ # is ever actually hit in the wild. In a previous iteration of the sol
+ # reader, there was logic to check for the number of options, but it
+ # was uncovered by tests and unclear if actually necessary.
+ if number_of_options > 4:
+ raise DeveloperError(
+ """
+The sol file reader has hit an unexpected error while parsing. The number of
+options recorded is greater than 4. Please report this error to the Pyomo
+developers.
+ """
+ )
+ for i in range(number_of_options + 4):
+ line = sol_file.readline()
+ model_objects.append(int(line))
+ else:
+ raise PyomoException("ERROR READING `sol` FILE. No 'Options' line found.")
+ # Identify the total number of variables and constraints
+ number_of_cons = model_objects[number_of_options + 1]
+ number_of_vars = model_objects[number_of_options + 3]
+ assert number_of_cons == len(nl_info.constraints)
+ assert number_of_vars == len(nl_info.variables)
+
+ duals = [float(sol_file.readline()) for i in range(number_of_cons)]
+ variable_vals = [float(sol_file.readline()) for i in range(number_of_vars)]
+
+ # Parse the exit code line and capture it
+ exit_code = [0, 0]
+ line = sol_file.readline()
+ if line and ('objno' in line):
+ exit_code_line = line.split()
+ if len(exit_code_line) != 3:
+ raise PyomoException(
+ f"ERROR READING `sol` FILE. Expected two numbers in `objno` line; received {line}."
+ )
+ exit_code = [int(exit_code_line[1]), int(exit_code_line[2])]
+ else:
+ raise PyomoException(
+ f"ERROR READING `sol` FILE. Expected `objno`; received {line}."
+ )
+ result.extra_info.solver_message = message.strip().replace('\n', '; ')
+ exit_code_message = ''
+ if (exit_code[1] >= 0) and (exit_code[1] <= 99):
+ result.solution_status = SolutionStatus.optimal
+ result.termination_condition = TerminationCondition.convergenceCriteriaSatisfied
+ elif (exit_code[1] >= 100) and (exit_code[1] <= 199):
+ exit_code_message = "Optimal solution indicated, but ERROR LIKELY!"
+ result.solution_status = SolutionStatus.feasible
+ result.termination_condition = TerminationCondition.error
+ elif (exit_code[1] >= 200) and (exit_code[1] <= 299):
+ exit_code_message = "INFEASIBLE SOLUTION: constraints cannot be satisfied!"
+ result.solution_status = SolutionStatus.infeasible
+ result.termination_condition = TerminationCondition.locallyInfeasible
+ elif (exit_code[1] >= 300) and (exit_code[1] <= 399):
+ exit_code_message = (
+ "UNBOUNDED PROBLEM: the objective can be improved without limit!"
+ )
+ result.solution_status = SolutionStatus.noSolution
+ result.termination_condition = TerminationCondition.unbounded
+ elif (exit_code[1] >= 400) and (exit_code[1] <= 499):
+ exit_code_message = (
+ "EXCEEDED MAXIMUM NUMBER OF ITERATIONS: the solver "
+ "was stopped by a limit that you set!"
+ )
+ result.solution_status = SolutionStatus.infeasible
+ result.termination_condition = (
+ TerminationCondition.iterationLimit
+ ) # this is not always correct
+ elif (exit_code[1] >= 500) and (exit_code[1] <= 599):
+ exit_code_message = (
+ "FAILURE: the solver stopped by an error condition "
+ "in the solver routines!"
+ )
+ result.termination_condition = TerminationCondition.error
+
+ if result.extra_info.solver_message:
+ if exit_code_message:
+ result.extra_info.solver_message += '; ' + exit_code_message
+ else:
+ result.extra_info.solver_message = exit_code_message
+
+ if result.solution_status != SolutionStatus.noSolution:
+ sol_data.primals = variable_vals
+ sol_data.duals = duals
+ ### Read suffixes ###
+ line = sol_file.readline()
+ while line:
+ line = line.strip()
+ if line == "":
+ continue
+ line = line.split()
+ # Some sort of garbage we tag onto the solver message, assuming we are past the suffixes
+ if line[0] != 'suffix':
+ # We assume this is the start of a
+ # section like kestrel_option, which
+ # comes after all suffixes.
+ remaining = ""
+ line = sol_file.readline()
+ while line:
+ remaining += line.strip() + "; "
+ line = sol_file.readline()
+ result.extra_info.solver_message += remaining
+ break
+ read_data_type = int(line[1])
+ data_type = read_data_type & 3 # 0-var, 1-con, 2-obj, 3-prob
+ convert_function = int
+ if (read_data_type & 4) == 4:
+ convert_function = float
+ number_of_entries = int(line[2])
+ # The third entry is name length, and it is length+1. This is unnecessary
+ # except for data validation.
+ # The fourth entry is table "length", e.g., memory size.
+ number_of_string_lines = int(line[5])
+ suffix_name = sol_file.readline().strip()
+ # Add any arbitrary string lines to the "other" list
+ for line in range(number_of_string_lines):
+ sol_data.other.append(sol_file.readline())
+ if data_type == 0: # Var
+ sol_data.var_suffixes[suffix_name] = dict()
+ for cnt in range(number_of_entries):
+ suf_line = sol_file.readline().split()
+ var_ndx = int(suf_line[0])
+ sol_data.var_suffixes[suffix_name][var_ndx] = convert_function(
+ suf_line[1]
+ )
+ elif data_type == 1: # Con
+ sol_data.con_suffixes[suffix_name] = dict()
+ for cnt in range(number_of_entries):
+ suf_line = sol_file.readline().split()
+ con_ndx = int(suf_line[0])
+ sol_data.con_suffixes[suffix_name][con_ndx] = convert_function(
+ suf_line[1]
+ )
+ elif data_type == 2: # Obj
+ sol_data.obj_suffixes[suffix_name] = dict()
+ for cnt in range(number_of_entries):
+ suf_line = sol_file.readline().split()
+ obj_ndx = int(suf_line[0])
+ sol_data.obj_suffixes[suffix_name][obj_ndx] = convert_function(
+ suf_line[1]
+ )
+ elif data_type == 3: # Prob
+ sol_data.problem_suffixes[suffix_name] = list()
+ for cnt in range(number_of_entries):
+ suf_line = sol_file.readline().split()
+ sol_data.problem_suffixes[suffix_name].append(
+ convert_function(suf_line[1])
+ )
+ line = sol_file.readline()
+
+ return result, sol_data
diff --git a/pyomo/contrib/solver/solution.py b/pyomo/contrib/solver/solution.py
new file mode 100644
index 00000000000..a3e66475982
--- /dev/null
+++ b/pyomo/contrib/solver/solution.py
@@ -0,0 +1,237 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 abc
+from typing import Sequence, Dict, Optional, Mapping, NoReturn
+
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.var import VarData
+from pyomo.core.expr import value
+from pyomo.common.collections import ComponentMap
+from pyomo.common.errors import DeveloperError
+from pyomo.core.staleflag import StaleFlagManager
+from pyomo.contrib.solver.sol_reader import SolFileData
+from pyomo.repn.plugins.nl_writer import NLWriterInfo
+from pyomo.core.expr.visitor import replace_expressions
+
+
+class SolutionLoaderBase(abc.ABC):
+ """
+ Base class for all future SolutionLoader classes.
+
+ 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:
+ """
+ Load the solution of the primal variables into the value attribute of the variables.
+
+ Parameters
+ ----------
+ vars_to_load: list
+ The minimum set of variables whose solution should be loaded. If vars_to_load is None, then the solution
+ to all primal variables will be loaded. Even if vars_to_load is specified, the values of other
+ variables may also be loaded depending on the interface.
+ """
+ for v, val in self.get_primals(vars_to_load=vars_to_load).items():
+ v.set_value(val, skip_validation=True)
+ StaleFlagManager.mark_all_as_stale(delayed=True)
+
+ @abc.abstractmethod
+ def get_primals(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ """
+ Returns a ComponentMap mapping variable to var value.
+
+ Parameters
+ ----------
+ vars_to_load: list
+ A list of the variables whose solution value should be retrieved. If vars_to_load is None,
+ then the values for all variables will be retrieved.
+
+ Returns
+ -------
+ primals: ComponentMap
+ Maps variables to solution values
+ """
+
+ def get_duals(
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
+ """
+ Returns a dictionary mapping constraint to dual value.
+
+ Parameters
+ ----------
+ cons_to_load: list
+ A list of the constraints whose duals should be retrieved. If cons_to_load is None, then the duals for all
+ constraints will be retrieved.
+
+ Returns
+ -------
+ duals: dict
+ Maps constraints to dual values
+ """
+ raise NotImplementedError(f'{type(self)} does not support the get_duals method')
+
+ def get_reduced_costs(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ """
+ Returns a ComponentMap mapping variable to reduced cost.
+
+ Parameters
+ ----------
+ vars_to_load: list
+ A list of the variables whose reduced cost should be retrieved. If vars_to_load is None, then the
+ reduced costs for all variables will be loaded.
+
+ Returns
+ -------
+ reduced_costs: ComponentMap
+ Maps variables to reduced costs
+ """
+ raise NotImplementedError(
+ f'{type(self)} does not support the get_reduced_costs method'
+ )
+
+
+class PersistentSolutionLoader(SolutionLoaderBase):
+ def __init__(self, solver):
+ self._solver = solver
+ self._valid = True
+
+ def _assert_solution_still_valid(self):
+ if not self._valid:
+ raise RuntimeError('The results in the solver are no longer valid.')
+
+ def get_primals(self, vars_to_load=None):
+ self._assert_solution_still_valid()
+ return self._solver._get_primals(vars_to_load=vars_to_load)
+
+ def get_duals(
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
+ self._assert_solution_still_valid()
+ return self._solver._get_duals(cons_to_load=cons_to_load)
+
+ def get_reduced_costs(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ self._assert_solution_still_valid()
+ return self._solver._get_reduced_costs(vars_to_load=vars_to_load)
+
+ def invalidate(self):
+ self._valid = False
+
+
+class SolSolutionLoader(SolutionLoaderBase):
+ def __init__(self, sol_data: SolFileData, nl_info: NLWriterInfo) -> None:
+ self._sol_data = sol_data
+ self._nl_info = nl_info
+
+ def load_vars(self, vars_to_load: Optional[Sequence[VarData]] = None) -> NoReturn:
+ if self._nl_info is None:
+ raise RuntimeError(
+ 'Solution loader does not currently have a valid solution. Please '
+ 'check results.TerminationCondition and/or results.SolutionStatus.'
+ )
+ if self._sol_data is None:
+ assert len(self._nl_info.variables) == 0
+ else:
+ if self._nl_info.scaling:
+ for v, val, scale in zip(
+ self._nl_info.variables,
+ self._sol_data.primals,
+ self._nl_info.scaling.variables,
+ ):
+ v.set_value(val / scale, skip_validation=True)
+ else:
+ for v, val in zip(self._nl_info.variables, self._sol_data.primals):
+ v.set_value(val, skip_validation=True)
+
+ for v, v_expr in self._nl_info.eliminated_vars:
+ v.value = value(v_expr)
+
+ StaleFlagManager.mark_all_as_stale(delayed=True)
+
+ def get_primals(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ if self._nl_info is None:
+ raise RuntimeError(
+ 'Solution loader does not currently have a valid solution. Please '
+ 'check results.TerminationCondition and/or results.SolutionStatus.'
+ )
+ val_map = dict()
+ if self._sol_data is None:
+ assert len(self._nl_info.variables) == 0
+ else:
+ if self._nl_info.scaling is None:
+ scale_list = [1] * len(self._nl_info.variables)
+ else:
+ scale_list = self._nl_info.scaling.variables
+ for v, val, scale in zip(
+ self._nl_info.variables, self._sol_data.primals, scale_list
+ ):
+ val_map[id(v)] = val / scale
+
+ for v, v_expr in self._nl_info.eliminated_vars:
+ val = replace_expressions(v_expr, substitution_map=val_map)
+ v_id = id(v)
+ val_map[v_id] = val
+
+ res = ComponentMap()
+ if vars_to_load is None:
+ vars_to_load = self._nl_info.variables + [
+ v for v, _ in self._nl_info.eliminated_vars
+ ]
+ for v in vars_to_load:
+ res[v] = val_map[id(v)]
+
+ return res
+
+ def get_duals(
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
+ if self._nl_info is None:
+ raise RuntimeError(
+ 'Solution loader does not currently have a valid solution. Please '
+ 'check results.TerminationCondition and/or results.SolutionStatus.'
+ )
+ if len(self._nl_info.eliminated_vars) > 0:
+ raise NotImplementedError(
+ 'For now, turn presolve off (opt.config.writer_config.linear_presolve=False) '
+ 'to get dual variable values.'
+ )
+ if self._sol_data is None:
+ raise DeveloperError(
+ "Solution data is empty. This should not "
+ "have happened. Report this error to the Pyomo Developers."
+ )
+ res = dict()
+ if self._nl_info.scaling is None:
+ scale_list = [1] * len(self._nl_info.constraints)
+ obj_scale = 1
+ else:
+ scale_list = self._nl_info.scaling.constraints
+ obj_scale = self._nl_info.scaling.objectives[0]
+ if cons_to_load is None:
+ cons_to_load = set(self._nl_info.constraints)
+ else:
+ cons_to_load = set(cons_to_load)
+ for c, val, scale in zip(
+ self._nl_info.constraints, self._sol_data.duals, scale_list
+ ):
+ if c in cons_to_load:
+ res[c] = val * scale / obj_scale
+ return res
diff --git a/pyomo/contrib/solver/tests/__init__.py b/pyomo/contrib/solver/tests/__init__.py
new file mode 100644
index 00000000000..a4a626013c4
--- /dev/null
+++ b/pyomo/contrib/solver/tests/__init__.py
@@ -0,0 +1,10 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
diff --git a/pyomo/contrib/solver/tests/solvers/__init__.py b/pyomo/contrib/solver/tests/solvers/__init__.py
new file mode 100644
index 00000000000..a4a626013c4
--- /dev/null
+++ b/pyomo/contrib/solver/tests/solvers/__init__.py
@@ -0,0 +1,10 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
diff --git a/pyomo/contrib/solver/tests/solvers/test_gurobi_persistent.py b/pyomo/contrib/solver/tests/solvers/test_gurobi_persistent.py
new file mode 100644
index 00000000000..2f281e2abf0
--- /dev/null
+++ b/pyomo/contrib/solver/tests/solvers/test_gurobi_persistent.py
@@ -0,0 +1,700 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.unittest as unittest
+import pyomo.environ as pe
+from pyomo.contrib.solver.gurobi import Gurobi
+from pyomo.contrib.solver.results import SolutionStatus
+from pyomo.core.expr.taylor_series import taylor_series_expansion
+
+
+opt = Gurobi()
+if not opt.available():
+ raise unittest.SkipTest
+import gurobipy
+
+
+def create_pmedian_model():
+ d_dict = {
+ (1, 1): 1.777356642700564,
+ (1, 2): 1.6698255595592497,
+ (1, 3): 1.099139603924817,
+ (1, 4): 1.3529705111901453,
+ (1, 5): 1.467907742900842,
+ (1, 6): 1.5346837414708774,
+ (2, 1): 1.9783090609123972,
+ (2, 2): 1.130315350158659,
+ (2, 3): 1.6712434682302661,
+ (2, 4): 1.3642294159473756,
+ (2, 5): 1.4888357071619858,
+ (2, 6): 1.2030122107340537,
+ (3, 1): 1.6661983755713592,
+ (3, 2): 1.227663031206932,
+ (3, 3): 1.4580640582967632,
+ (3, 4): 1.0407223975549575,
+ (3, 5): 1.9742897953778287,
+ (3, 6): 1.4874760742689066,
+ (4, 1): 1.4616138636373597,
+ (4, 2): 1.7141471558082002,
+ (4, 3): 1.4157281494999725,
+ (4, 4): 1.888011688001529,
+ (4, 5): 1.0232934487237717,
+ (4, 6): 1.8335062677845464,
+ (5, 1): 1.468494740997508,
+ (5, 2): 1.8114798126442795,
+ (5, 3): 1.9455914886158723,
+ (5, 4): 1.983088378194899,
+ (5, 5): 1.1761820755785306,
+ (5, 6): 1.698655759576308,
+ (6, 1): 1.108855711312383,
+ (6, 2): 1.1602637342062019,
+ (6, 3): 1.0928602740245892,
+ (6, 4): 1.3140620798928404,
+ (6, 5): 1.0165386843386672,
+ (6, 6): 1.854049125736362,
+ (7, 1): 1.2910160386456968,
+ (7, 2): 1.7800475863350327,
+ (7, 3): 1.5480965161255695,
+ (7, 4): 1.1943306766997612,
+ (7, 5): 1.2920382721805297,
+ (7, 6): 1.3194527773994338,
+ (8, 1): 1.6585982235379078,
+ (8, 2): 1.2315210354122292,
+ (8, 3): 1.6194303369953538,
+ (8, 4): 1.8953386098022103,
+ (8, 5): 1.8694342085696831,
+ (8, 6): 1.2938069356684523,
+ (9, 1): 1.4582048085805495,
+ (9, 2): 1.484979797871119,
+ (9, 3): 1.2803882693587225,
+ (9, 4): 1.3289569463506004,
+ (9, 5): 1.9842424240265042,
+ (9, 6): 1.0119441379208745,
+ (10, 1): 1.1429007682932852,
+ (10, 2): 1.6519772165446711,
+ (10, 3): 1.0749931799469326,
+ (10, 4): 1.2920787022811089,
+ (10, 5): 1.7934429721917704,
+ (10, 6): 1.9115931008709737,
+ }
+
+ model = pe.ConcreteModel()
+ model.N = pe.Param(initialize=10)
+ model.Locations = pe.RangeSet(1, model.N)
+ model.P = pe.Param(initialize=3)
+ model.M = pe.Param(initialize=6)
+ model.Customers = pe.RangeSet(1, model.M)
+ model.d = pe.Param(
+ model.Locations, model.Customers, initialize=d_dict, within=pe.Reals
+ )
+ model.x = pe.Var(model.Locations, model.Customers, bounds=(0.0, 1.0))
+ model.y = pe.Var(model.Locations, within=pe.Binary)
+
+ def rule(model):
+ return sum(
+ model.d[n, m] * model.x[n, m]
+ for n in model.Locations
+ for m in model.Customers
+ )
+
+ model.obj = pe.Objective(rule=rule)
+
+ def rule(model, m):
+ return (sum(model.x[n, m] for n in model.Locations), 1.0)
+
+ model.single_x = pe.Constraint(model.Customers, rule=rule)
+
+ def rule(model, n, m):
+ return (None, model.x[n, m] - model.y[n], 0.0)
+
+ model.bound_y = pe.Constraint(model.Locations, model.Customers, rule=rule)
+
+ def rule(model):
+ return (sum(model.y[n] for n in model.Locations) - model.P, 0.0)
+
+ model.num_facilities = pe.Constraint(rule=rule)
+
+ return model
+
+
+class TestGurobiPersistentSimpleLPUpdates(unittest.TestCase):
+ def setUp(self):
+ self.m = pe.ConcreteModel()
+ m = self.m
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.p1 = pe.Param(mutable=True)
+ m.p2 = pe.Param(mutable=True)
+ m.p3 = pe.Param(mutable=True)
+ m.p4 = pe.Param(mutable=True)
+ m.obj = pe.Objective(expr=m.x + m.y)
+ m.c1 = pe.Constraint(expr=m.y - m.p1 * m.x >= m.p2)
+ m.c2 = pe.Constraint(expr=m.y - m.p3 * m.x >= m.p4)
+
+ def get_solution(self):
+ try:
+ import numpy as np
+ except:
+ raise unittest.SkipTest('numpy is not available')
+ p1 = self.m.p1.value
+ p2 = self.m.p2.value
+ p3 = self.m.p3.value
+ p4 = self.m.p4.value
+ A = np.array([[1, -p1], [1, -p3]])
+ rhs = np.array([p2, p4])
+ sol = np.linalg.solve(A, rhs)
+ x = float(sol[1])
+ y = float(sol[0])
+ return x, y
+
+ def set_params(self, p1, p2, p3, p4):
+ self.m.p1.value = p1
+ self.m.p2.value = p2
+ self.m.p3.value = p3
+ self.m.p4.value = p4
+
+ def test_lp(self):
+ self.set_params(-1, -2, 0.1, -2)
+ x, y = self.get_solution()
+ opt = Gurobi()
+ res = opt.solve(self.m)
+ self.assertAlmostEqual(x + y, res.incumbent_objective)
+ self.assertAlmostEqual(x + y, res.objective_bound)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertTrue(res.incumbent_objective is not None)
+ self.assertAlmostEqual(x, self.m.x.value)
+ self.assertAlmostEqual(y, self.m.y.value)
+
+ self.set_params(-1.25, -1, 0.5, -2)
+ opt.config.load_solutions = False
+ res = opt.solve(self.m)
+ self.assertAlmostEqual(x, self.m.x.value)
+ self.assertAlmostEqual(y, self.m.y.value)
+ x, y = self.get_solution()
+ self.assertNotAlmostEqual(x, self.m.x.value)
+ self.assertNotAlmostEqual(y, self.m.y.value)
+ res.solution_loader.load_vars()
+ self.assertAlmostEqual(x, self.m.x.value)
+ self.assertAlmostEqual(y, self.m.y.value)
+
+
+class TestGurobiPersistent(unittest.TestCase):
+ def test_nonconvex_qcp_objective_bound_1(self):
+ # the goal of this test is to ensure we can get an objective bound
+ # for nonconvex but continuous problems even if a feasible solution
+ # is not found
+ #
+ # This is a fragile test because it could fail if Gurobi's algorithms improve
+ # (e.g., a heuristic solution is found before an objective bound of -8 is reached
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-5, 5))
+ m.y = pe.Var(bounds=(-5, 5))
+ m.obj = pe.Objective(expr=-m.x**2 - m.y)
+ m.c1 = pe.Constraint(expr=m.y <= -2 * m.x + 1)
+ m.c2 = pe.Constraint(expr=m.y <= m.x - 2)
+ opt = Gurobi()
+ opt.config.solver_options['nonconvex'] = 2
+ opt.config.solver_options['BestBdStop'] = -8
+ opt.config.load_solutions = False
+ opt.config.raise_exception_on_nonoptimal_result = False
+ res = opt.solve(m)
+ self.assertEqual(res.incumbent_objective, None)
+ self.assertAlmostEqual(res.objective_bound, -8)
+
+ def test_nonconvex_qcp_objective_bound_2(self):
+ # the goal of this test is to ensure we can objective_bound properly
+ # for nonconvex but continuous problems when the solver terminates with a nonzero gap
+ #
+ # This is a fragile test because it could fail if Gurobi's algorithms change
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-5, 5))
+ m.y = pe.Var(bounds=(-5, 5))
+ m.obj = pe.Objective(expr=-m.x**2 - m.y)
+ m.c1 = pe.Constraint(expr=m.y <= -2 * m.x + 1)
+ m.c2 = pe.Constraint(expr=m.y <= m.x - 2)
+ opt = Gurobi()
+ opt.config.solver_options['nonconvex'] = 2
+ opt.config.solver_options['MIPGap'] = 0.5
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, -4)
+ self.assertAlmostEqual(res.objective_bound, -6)
+
+ def test_range_constraints(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.xl = pe.Param(initialize=-1, mutable=True)
+ m.xu = pe.Param(initialize=1, mutable=True)
+ m.c = pe.Constraint(expr=pe.inequality(m.xl, m.x, m.xu))
+ m.obj = pe.Objective(expr=m.x)
+
+ opt = Gurobi()
+ opt.set_instance(m)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -1)
+
+ m.xl.value = -3
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -3)
+
+ del m.obj
+ m.obj = pe.Objective(expr=m.x, sense=pe.maximize)
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 1)
+
+ m.xu.value = 3
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 3)
+
+ def test_quadratic_constraint_with_params(self):
+ m = pe.ConcreteModel()
+ m.a = pe.Param(initialize=1, mutable=True)
+ m.b = pe.Param(initialize=1, mutable=True)
+ m.c = pe.Param(initialize=1, mutable=True)
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ m.con = pe.Constraint(expr=m.y >= m.a * m.x**2 + m.b * m.x + m.c)
+
+ opt = Gurobi()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -m.b.value / (2 * m.a.value))
+ self.assertAlmostEqual(
+ m.y.value, m.a.value * m.x.value**2 + m.b.value * m.x.value + m.c.value
+ )
+
+ m.a.value = 2
+ m.b.value = 4
+ m.c.value = -1
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -m.b.value / (2 * m.a.value))
+ self.assertAlmostEqual(
+ m.y.value, m.a.value * m.x.value**2 + m.b.value * m.x.value + m.c.value
+ )
+
+ def test_quadratic_objective(self):
+ m = pe.ConcreteModel()
+ m.a = pe.Param(initialize=1, mutable=True)
+ m.b = pe.Param(initialize=1, mutable=True)
+ m.c = pe.Param(initialize=1, mutable=True)
+ m.x = pe.Var()
+ m.obj = pe.Objective(expr=m.a * m.x**2 + m.b * m.x + m.c)
+
+ opt = Gurobi()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -m.b.value / (2 * m.a.value))
+ self.assertAlmostEqual(
+ res.incumbent_objective,
+ m.a.value * m.x.value**2 + m.b.value * m.x.value + m.c.value,
+ )
+
+ m.a.value = 2
+ m.b.value = 4
+ m.c.value = -1
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -m.b.value / (2 * m.a.value))
+ self.assertAlmostEqual(
+ res.incumbent_objective,
+ m.a.value * m.x.value**2 + m.b.value * m.x.value + m.c.value,
+ )
+
+ def test_var_bounds(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-1, 1))
+ m.obj = pe.Objective(expr=m.x)
+
+ opt = Gurobi()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -1)
+
+ m.x.setlb(-3)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -3)
+
+ del m.obj
+ m.obj = pe.Objective(expr=m.x, sense=pe.maximize)
+
+ opt = Gurobi()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 1)
+
+ m.x.setub(3)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 3)
+
+ def test_fixed_var(self):
+ m = pe.ConcreteModel()
+ m.a = pe.Param(initialize=1, mutable=True)
+ m.b = pe.Param(initialize=1, mutable=True)
+ m.c = pe.Param(initialize=1, mutable=True)
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ m.con = pe.Constraint(expr=m.y >= m.a * m.x**2 + m.b * m.x + m.c)
+
+ m.x.fix(1)
+ opt = Gurobi()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 1)
+ self.assertAlmostEqual(m.y.value, 3)
+
+ m.x.value = 2
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 2)
+ self.assertAlmostEqual(m.y.value, 7)
+
+ m.x.unfix()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -m.b.value / (2 * m.a.value))
+ self.assertAlmostEqual(
+ m.y.value, m.a.value * m.x.value**2 + m.b.value * m.x.value + m.c.value
+ )
+
+ def test_linear_constraint_attr(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.c = pe.Constraint(expr=m.x + m.y == 1)
+
+ opt = Gurobi()
+ opt.set_instance(m)
+ opt.set_linear_constraint_attr(m.c, 'Lazy', 1)
+ self.assertEqual(opt.get_linear_constraint_attr(m.c, 'Lazy'), 1)
+
+ def test_quadratic_constraint_attr(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.c = pe.Constraint(expr=m.y >= m.x**2)
+
+ opt = Gurobi()
+ opt.set_instance(m)
+ self.assertEqual(opt.get_quadratic_constraint_attr(m.c, 'QCRHS'), 0)
+
+ def test_var_attr(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var(within=pe.Binary)
+ m.obj = pe.Objective(expr=m.x)
+
+ opt = Gurobi()
+ opt.set_instance(m)
+ opt.set_var_attr(m.x, 'Start', 1)
+ self.assertEqual(opt.get_var_attr(m.x, 'Start'), 1)
+
+ def test_callback(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(0, 4))
+ m.y = pe.Var(within=pe.Integers, bounds=(0, None))
+ m.obj = pe.Objective(expr=2 * m.x + m.y)
+ m.cons = pe.ConstraintList()
+
+ def _add_cut(xval):
+ m.x.value = xval
+ return m.cons.add(m.y >= taylor_series_expansion((m.x - 2) ** 2))
+
+ _add_cut(0)
+ _add_cut(4)
+
+ opt = Gurobi()
+ opt.set_instance(m)
+ opt.set_gurobi_param('PreCrush', 1)
+ opt.set_gurobi_param('LazyConstraints', 1)
+
+ def _my_callback(cb_m, cb_opt, cb_where):
+ if cb_where == gurobipy.GRB.Callback.MIPSOL:
+ cb_opt.cbGetSolution(vars=[m.x, m.y])
+ if m.y.value < (m.x.value - 2) ** 2 - 1e-6:
+ cb_opt.cbLazy(_add_cut(m.x.value))
+
+ opt.set_callback(_my_callback)
+ opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 1)
+ self.assertAlmostEqual(m.y.value, 1)
+
+ def test_nonconvex(self):
+ if gurobipy.GRB.VERSION_MAJOR < 9:
+ raise unittest.SkipTest
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2)
+ m.c = pe.Constraint(expr=m.y == (m.x - 1) ** 2 - 2)
+ opt = Gurobi()
+ opt.config.solver_options['nonconvex'] = 2
+ opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -0.3660254037844423, 2)
+ self.assertAlmostEqual(m.y.value, -0.13397459621555508, 2)
+
+ def test_nonconvex2(self):
+ if gurobipy.GRB.VERSION_MAJOR < 9:
+ raise unittest.SkipTest
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2)
+ m.c1 = pe.Constraint(expr=0 <= -m.y + (m.x - 1) ** 2 - 2)
+ m.c2 = pe.Constraint(expr=0 >= -m.y + (m.x - 1) ** 2 - 2)
+ opt = Gurobi()
+ opt.config.solver_options['nonconvex'] = 2
+ opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -0.3660254037844423, 2)
+ self.assertAlmostEqual(m.y.value, -0.13397459621555508, 2)
+
+ def test_solution_number(self):
+ m = create_pmedian_model()
+ opt = Gurobi()
+ opt.config.solver_options['PoolSolutions'] = 3
+ opt.config.solver_options['PoolSearchMode'] = 2
+ res = opt.solve(m)
+ num_solutions = opt.get_model_attr('SolCount')
+ self.assertEqual(num_solutions, 3)
+ res.solution_loader.load_vars(solution_number=0)
+ self.assertAlmostEqual(pe.value(m.obj.expr), 6.431184939357673)
+ res.solution_loader.load_vars(solution_number=1)
+ self.assertAlmostEqual(pe.value(m.obj.expr), 6.584793218502477)
+ res.solution_loader.load_vars(solution_number=2)
+ self.assertAlmostEqual(pe.value(m.obj.expr), 6.592304628123309)
+
+ def test_zero_time_limit(self):
+ m = create_pmedian_model()
+ opt = Gurobi()
+ opt.config.time_limit = 0
+ opt.config.load_solutions = False
+ opt.config.raise_exception_on_nonoptimal_result = False
+ res = opt.solve(m)
+ num_solutions = opt.get_model_attr('SolCount')
+
+ # Behavior is different on different platforms, so
+ # we have to see if there are any solutions
+ # This means that there is no guarantee we are testing
+ # what we are trying to test. Unfortunately, I'm
+ # not sure of a good way to guarantee that
+ if num_solutions == 0:
+ self.assertIsNone(res.incumbent_objective)
+
+
+class TestManualModel(unittest.TestCase):
+ def setUp(self):
+ opt = Gurobi()
+ opt.config.auto_updates.check_for_new_or_removed_params = False
+ opt.config.auto_updates.check_for_new_or_removed_vars = False
+ opt.config.auto_updates.check_for_new_or_removed_constraints = False
+ opt.config.auto_updates.update_parameters = False
+ opt.config.auto_updates.update_vars = False
+ opt.config.auto_updates.update_constraints = False
+ opt.config.auto_updates.update_named_expressions = False
+ self.opt = opt
+
+ def test_basics(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-10, 10))
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2)
+ m.c1 = pe.Constraint(expr=m.y >= 2 * m.x + 1)
+
+ opt = self.opt
+ opt.set_instance(m)
+
+ self.assertEqual(opt.get_model_attr('NumVars'), 2)
+ self.assertEqual(opt.get_model_attr('NumConstrs'), 1)
+ self.assertEqual(opt.get_model_attr('NumQConstrs'), 0)
+ self.assertEqual(opt.get_var_attr(m.x, 'LB'), -10)
+ self.assertEqual(opt.get_var_attr(m.x, 'UB'), 10)
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -0.4)
+ self.assertAlmostEqual(m.y.value, 0.2)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -0.4)
+
+ m.c2 = pe.Constraint(expr=m.y >= -m.x + 1)
+ opt.add_constraints([m.c2])
+ self.assertEqual(opt.get_model_attr('NumVars'), 2)
+ self.assertEqual(opt.get_model_attr('NumConstrs'), 2)
+ self.assertEqual(opt.get_model_attr('NumQConstrs'), 0)
+
+ opt.config.load_solutions = False
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -0.4)
+ self.assertAlmostEqual(m.y.value, 0.2)
+ res.solution_loader.load_vars()
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 1)
+
+ opt.remove_constraints([m.c2])
+ m.del_component(m.c2)
+ self.assertEqual(opt.get_model_attr('NumVars'), 2)
+ self.assertEqual(opt.get_model_attr('NumConstrs'), 1)
+ self.assertEqual(opt.get_model_attr('NumQConstrs'), 0)
+
+ self.assertEqual(opt.get_gurobi_param_info('FeasibilityTol')[2], 1e-6)
+ opt.config.solver_options['FeasibilityTol'] = 1e-7
+ opt.config.load_solutions = True
+ res = opt.solve(m)
+ self.assertEqual(opt.get_gurobi_param_info('FeasibilityTol')[2], 1e-7)
+ self.assertAlmostEqual(m.x.value, -0.4)
+ self.assertAlmostEqual(m.y.value, 0.2)
+
+ m.x.setlb(-5)
+ m.x.setub(5)
+ opt.update_variables([m.x])
+ self.assertEqual(opt.get_var_attr(m.x, 'LB'), -5)
+ self.assertEqual(opt.get_var_attr(m.x, 'UB'), 5)
+
+ m.x.fix(0)
+ opt.update_variables([m.x])
+ self.assertEqual(opt.get_var_attr(m.x, 'LB'), 0)
+ self.assertEqual(opt.get_var_attr(m.x, 'UB'), 0)
+
+ m.x.unfix()
+ opt.update_variables([m.x])
+ self.assertEqual(opt.get_var_attr(m.x, 'LB'), -5)
+ self.assertEqual(opt.get_var_attr(m.x, 'UB'), 5)
+
+ m.c2 = pe.Constraint(expr=m.y >= m.x**2)
+ opt.add_constraints([m.c2])
+ self.assertEqual(opt.get_model_attr('NumVars'), 2)
+ self.assertEqual(opt.get_model_attr('NumConstrs'), 1)
+ self.assertEqual(opt.get_model_attr('NumQConstrs'), 1)
+
+ opt.remove_constraints([m.c2])
+ m.del_component(m.c2)
+ self.assertEqual(opt.get_model_attr('NumVars'), 2)
+ self.assertEqual(opt.get_model_attr('NumConstrs'), 1)
+ self.assertEqual(opt.get_model_attr('NumQConstrs'), 0)
+
+ m.z = pe.Var()
+ opt.add_variables([m.z])
+ self.assertEqual(opt.get_model_attr('NumVars'), 3)
+ opt.remove_variables([m.z])
+ del m.z
+ self.assertEqual(opt.get_model_attr('NumVars'), 2)
+
+ def test_update1(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.z = pe.Var()
+ m.obj = pe.Objective(expr=m.z)
+ m.c1 = pe.Constraint(expr=m.z >= m.x**2 + m.y**2)
+
+ opt = self.opt
+ opt.set_instance(m)
+ self.assertEqual(opt._solver_model.getAttr('NumQConstrs'), 1)
+
+ opt.remove_constraints([m.c1])
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumQConstrs'), 0)
+
+ opt.add_constraints([m.c1])
+ self.assertEqual(opt._solver_model.getAttr('NumQConstrs'), 0)
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumQConstrs'), 1)
+
+ def test_update2(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.z = pe.Var()
+ m.obj = pe.Objective(expr=m.z)
+ m.c2 = pe.Constraint(expr=m.x + m.y == 1)
+
+ opt = self.opt
+ opt.config.symbolic_solver_labels = True
+ opt.set_instance(m)
+ self.assertEqual(opt._solver_model.getAttr('NumConstrs'), 1)
+
+ opt.remove_constraints([m.c2])
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumConstrs'), 0)
+
+ opt.add_constraints([m.c2])
+ self.assertEqual(opt._solver_model.getAttr('NumConstrs'), 0)
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumConstrs'), 1)
+
+ def test_update3(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.z = pe.Var()
+ m.obj = pe.Objective(expr=m.z)
+ m.c1 = pe.Constraint(expr=m.z >= m.x**2 + m.y**2)
+
+ opt = self.opt
+ opt.set_instance(m)
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumQConstrs'), 1)
+ m.c2 = pe.Constraint(expr=m.y >= m.x**2)
+ opt.add_constraints([m.c2])
+ self.assertEqual(opt._solver_model.getAttr('NumQConstrs'), 1)
+ opt.remove_constraints([m.c2])
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumQConstrs'), 1)
+
+ def test_update4(self):
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.z = pe.Var()
+ m.obj = pe.Objective(expr=m.z)
+ m.c1 = pe.Constraint(expr=m.z >= m.x + m.y)
+
+ opt = self.opt
+ opt.set_instance(m)
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumConstrs'), 1)
+ m.c2 = pe.Constraint(expr=m.y >= m.x)
+ opt.add_constraints([m.c2])
+ self.assertEqual(opt._solver_model.getAttr('NumConstrs'), 1)
+ opt.remove_constraints([m.c2])
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumConstrs'), 1)
+
+ def test_update5(self):
+ m = pe.ConcreteModel()
+ m.a = pe.Set(initialize=[1, 2, 3], ordered=True)
+ m.x = pe.Var(m.a, within=pe.Binary)
+ m.y = pe.Var(within=pe.Binary)
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.SOSConstraint(var=m.x, sos=1)
+
+ opt = self.opt
+ opt.set_instance(m)
+ self.assertEqual(opt._solver_model.getAttr('NumSOS'), 1)
+
+ opt.remove_sos_constraints([m.c1])
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumSOS'), 0)
+
+ opt.add_sos_constraints([m.c1])
+ self.assertEqual(opt._solver_model.getAttr('NumSOS'), 0)
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumSOS'), 1)
+
+ def test_update6(self):
+ m = pe.ConcreteModel()
+ m.a = pe.Set(initialize=[1, 2, 3], ordered=True)
+ m.x = pe.Var(m.a, within=pe.Binary)
+ m.y = pe.Var(within=pe.Binary)
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.SOSConstraint(var=m.x, sos=1)
+
+ opt = self.opt
+ opt.set_instance(m)
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumSOS'), 1)
+ m.c2 = pe.SOSConstraint(var=m.x, sos=2)
+ opt.add_sos_constraints([m.c2])
+ self.assertEqual(opt._solver_model.getAttr('NumSOS'), 1)
+ opt.remove_sos_constraints([m.c2])
+ opt.update()
+ self.assertEqual(opt._solver_model.getAttr('NumSOS'), 1)
diff --git a/pyomo/contrib/solver/tests/solvers/test_ipopt.py b/pyomo/contrib/solver/tests/solvers/test_ipopt.py
new file mode 100644
index 00000000000..d5d82981ed8
--- /dev/null
+++ b/pyomo/contrib/solver/tests/solvers/test_ipopt.py
@@ -0,0 +1,57 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.environ as pyo
+from pyomo.common.fileutils import ExecutableData
+from pyomo.common.config import ConfigDict
+from pyomo.contrib.solver.ipopt import IpoptConfig
+from pyomo.contrib.solver.factory import SolverFactory
+from pyomo.common import unittest
+
+
+"""
+TODO:
+ - Test unique configuration options
+ - Test unique results options
+ - Ensure that `*.opt` file is only created when needed
+ - Ensure options are correctly parsing to env or opt file
+ - Failures at appropriate times
+"""
+
+
+class TestIpopt(unittest.TestCase):
+ def create_model(self):
+ model = pyo.ConcreteModel()
+ model.x = pyo.Var(initialize=1.5)
+ model.y = pyo.Var(initialize=1.5)
+
+ def rosenbrock(m):
+ return (1.0 - m.x) ** 2 + 100.0 * (m.y - m.x**2) ** 2
+
+ model.obj = pyo.Objective(rule=rosenbrock, sense=pyo.minimize)
+ return model
+
+ def test_ipopt_config(self):
+ # Test default initialization
+ config = IpoptConfig()
+ self.assertTrue(config.load_solutions)
+ self.assertIsInstance(config.solver_options, ConfigDict)
+ self.assertIsInstance(config.executable, ExecutableData)
+
+ # Test custom initialization
+ solver = SolverFactory('ipopt', executable='/path/to/exe')
+ self.assertFalse(solver.config.tee)
+ self.assertTrue(solver.config.executable.startswith('/path'))
+
+ # Change value on a solve call
+ # model = self.create_model()
+ # result = solver.solve(model, tee=True)
diff --git a/pyomo/contrib/solver/tests/solvers/test_solvers.py b/pyomo/contrib/solver/tests/solvers/test_solvers.py
new file mode 100644
index 00000000000..f91de2287b7
--- /dev/null
+++ b/pyomo/contrib/solver/tests/solvers/test_solvers.py
@@ -0,0 +1,1682 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 random
+import math
+from typing import Type
+
+import pyomo.environ as pe
+from pyomo import gdp
+from pyomo.common.dependencies import attempt_import
+import pyomo.common.unittest as unittest
+from pyomo.contrib.solver.results import TerminationCondition, SolutionStatus, Results
+from pyomo.contrib.solver.base import SolverBase
+from pyomo.contrib.solver.ipopt import Ipopt
+from pyomo.contrib.solver.gurobi import Gurobi
+from pyomo.contrib.solver.gurobi_direct import GurobiDirect
+from pyomo.core.expr.numeric_expr import LinearExpression
+
+
+np, numpy_available = attempt_import('numpy')
+parameterized, param_available = attempt_import('parameterized')
+parameterized = parameterized.parameterized
+
+
+if not param_available:
+ raise unittest.SkipTest('Parameterized is not available.')
+
+all_solvers = [('gurobi', Gurobi), ('gurobi_direct', GurobiDirect), ('ipopt', Ipopt)]
+mip_solvers = [('gurobi', Gurobi), ('gurobi_direct', GurobiDirect)]
+nlp_solvers = [('ipopt', Ipopt)]
+qcp_solvers = [('gurobi', Gurobi), ('ipopt', Ipopt)]
+miqcqp_solvers = [('gurobi', Gurobi)]
+nl_solvers = [('ipopt', Ipopt)]
+nl_solvers_set = {i[0] for i in nl_solvers}
+
+
+def _load_tests(solver_list):
+ res = list()
+ for solver_name, solver in solver_list:
+ if solver_name in nl_solvers_set:
+ test_name = f"{solver_name}_presolve"
+ res.append((test_name, solver, True))
+ test_name = f"{solver_name}"
+ res.append((test_name, solver, False))
+ else:
+ test_name = f"{solver_name}"
+ res.append((test_name, solver, None))
+ return res
+
+
+@unittest.skipUnless(numpy_available, 'numpy is not available')
+class TestSolvers(unittest.TestCase):
+ @parameterized.expand(input=all_solvers)
+ def test_config_overwrite(self, name: str, opt_class: Type[SolverBase]):
+ self.assertIsNot(SolverBase.CONFIG, opt_class.CONFIG)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_remove_variable_and_objective(
+ self, name: str, opt_class: Type[SolverBase], use_presolve
+ ):
+ # this test is for issue #2888
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(2, None))
+ m.obj = pe.Objective(expr=m.x)
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, 2)
+
+ del m.x
+ del m.obj
+ m.x = pe.Var(bounds=(2, None))
+ m.obj = pe.Objective(expr=m.x)
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, 2)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_stale_vars(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.z = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y >= m.x)
+ m.c2 = pe.Constraint(expr=m.y >= -m.x)
+ m.x.value = 1
+ m.y.value = 1
+ m.z.value = 1
+ self.assertFalse(m.x.stale)
+ self.assertFalse(m.y.stale)
+ self.assertFalse(m.z.stale)
+
+ res = opt.solve(m)
+ self.assertFalse(m.x.stale)
+ self.assertFalse(m.y.stale)
+ self.assertTrue(m.z.stale)
+
+ opt.config.load_solutions = False
+ res = opt.solve(m)
+ self.assertTrue(m.x.stale)
+ self.assertTrue(m.y.stale)
+ self.assertTrue(m.z.stale)
+ res.solution_loader.load_vars()
+ self.assertFalse(m.x.stale)
+ self.assertFalse(m.y.stale)
+ self.assertTrue(m.z.stale)
+
+ res = opt.solve(m)
+ self.assertTrue(m.x.stale)
+ self.assertTrue(m.y.stale)
+ self.assertTrue(m.z.stale)
+ res.solution_loader.load_vars([m.y])
+ self.assertFalse(m.y.stale)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_range_constraint(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.obj = pe.Objective(expr=m.x)
+ m.c = pe.Constraint(expr=(-1, m.x, 1))
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, -1)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c], 1)
+ m.obj.sense = pe.maximize
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, 1)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c], 1)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_reduced_costs(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-1, 1))
+ m.y = pe.Var(bounds=(-2, 2))
+ m.obj = pe.Objective(expr=3 * m.x + 4 * m.y)
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, -1)
+ self.assertAlmostEqual(m.y.value, -2)
+ rc = res.solution_loader.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], 3)
+ self.assertAlmostEqual(rc[m.y], 4)
+ m.obj.expr *= -1
+ res = opt.solve(m)
+ rc = res.solution_loader.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], -3)
+ self.assertAlmostEqual(rc[m.y], -4)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_reduced_costs2(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-1, 1))
+ m.obj = pe.Objective(expr=m.x)
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, -1)
+ rc = res.solution_loader.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], 1)
+ m.obj.sense = pe.maximize
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, 1)
+ rc = res.solution_loader.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], 1)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_param_changes(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a1 = pe.Param(mutable=True)
+ m.a2 = pe.Param(mutable=True)
+ m.b1 = pe.Param(mutable=True)
+ m.b2 = pe.Param(mutable=True)
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=(0, m.y - m.a1 * m.x - m.b1, None))
+ m.c2 = pe.Constraint(expr=(None, -m.y + m.a2 * m.x + m.b2, 0))
+
+ params_to_test = [(1, -1, 2, 1), (1, -2, 2, 1), (1, -1, 3, 1)]
+ for a1, a2, b1, b2 in params_to_test:
+ m.a1.value = a1
+ m.a2.value = a2
+ m.b1.value = b1
+ m.b2.value = b2
+ res: Results = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value)
+ if res.objective_bound is None:
+ bound = -math.inf
+ else:
+ bound = res.objective_bound
+ self.assertTrue(bound <= m.y.value)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_immutable_param(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ """
+ This test is important because component_data_objects returns immutable params as floats.
+ We want to make sure we process these correctly.
+ """
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a1 = pe.Param(mutable=True)
+ m.a2 = pe.Param(initialize=-1)
+ m.b1 = pe.Param(mutable=True)
+ m.b2 = pe.Param(mutable=True)
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=(0, m.y - m.a1 * m.x - m.b1, None))
+ m.c2 = pe.Constraint(expr=(None, -m.y + m.a2 * m.x + m.b2, 0))
+
+ params_to_test = [(1, 2, 1), (1, 2, 1), (1, 3, 1)]
+ for a1, b1, b2 in params_to_test:
+ a2 = m.a2.value
+ m.a1.value = a1
+ m.b1.value = b1
+ m.b2.value = b2
+ res: Results = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value)
+ if res.objective_bound is None:
+ bound = -math.inf
+ else:
+ bound = res.objective_bound
+ self.assertTrue(bound <= m.y.value)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_equality(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ check_duals = True
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ check_duals = False
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a1 = pe.Param(mutable=True)
+ m.a2 = pe.Param(mutable=True)
+ m.b1 = pe.Param(mutable=True)
+ m.b2 = pe.Param(mutable=True)
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y == m.a1 * m.x + m.b1)
+ m.c2 = pe.Constraint(expr=m.y == m.a2 * m.x + m.b2)
+
+ params_to_test = [(1, -1, 2, 1), (1, -2, 2, 1), (1, -1, 3, 1)]
+ for a1, a2, b1, b2 in params_to_test:
+ m.a1.value = a1
+ m.a2.value = a2
+ m.b1.value = b1
+ m.b2.value = b2
+ res: Results = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value)
+ if res.objective_bound is None:
+ bound = -math.inf
+ else:
+ bound = res.objective_bound
+ self.assertTrue(bound <= m.y.value)
+ if check_duals:
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], (1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], -a1 / (a2 - a1))
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_linear_expression(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a1 = pe.Param(mutable=True)
+ m.a2 = pe.Param(mutable=True)
+ m.b1 = pe.Param(mutable=True)
+ m.b2 = pe.Param(mutable=True)
+ m.obj = pe.Objective(expr=m.y)
+ e = LinearExpression(
+ constant=m.b1, linear_coefs=[-1, m.a1], linear_vars=[m.y, m.x]
+ )
+ m.c1 = pe.Constraint(expr=e == 0)
+ e = LinearExpression(
+ constant=m.b2, linear_coefs=[-1, m.a2], linear_vars=[m.y, m.x]
+ )
+ m.c2 = pe.Constraint(expr=e == 0)
+
+ params_to_test = [(1, -1, 2, 1), (1, -2, 2, 1), (1, -1, 3, 1)]
+ for a1, a2, b1, b2 in params_to_test:
+ m.a1.value = a1
+ m.a2.value = a2
+ m.b1.value = b1
+ m.b2.value = b2
+ res: Results = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value)
+ if res.objective_bound is None:
+ bound = -math.inf
+ else:
+ bound = res.objective_bound
+ self.assertTrue(bound <= m.y.value)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_no_objective(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ check_duals = True
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ check_duals = False
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a1 = pe.Param(mutable=True)
+ m.a2 = pe.Param(mutable=True)
+ m.b1 = pe.Param(mutable=True)
+ m.b2 = pe.Param(mutable=True)
+ m.c1 = pe.Constraint(expr=m.y == m.a1 * m.x + m.b1)
+ m.c2 = pe.Constraint(expr=m.y == m.a2 * m.x + m.b2)
+
+ params_to_test = [(1, -1, 2, 1), (1, -2, 2, 1), (1, -1, 3, 1)]
+ for a1, a2, b1, b2 in params_to_test:
+ m.a1.value = a1
+ m.a2.value = a2
+ m.b1.value = b1
+ m.b2.value = b2
+ res: Results = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ self.assertEqual(res.incumbent_objective, None)
+ self.assertEqual(res.objective_bound, None)
+ if check_duals:
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], 0)
+ self.assertAlmostEqual(duals[m.c2], 0)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_add_remove_cons(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ a1 = -1
+ a2 = 1
+ b1 = 1
+ b2 = 2
+ a3 = 1
+ b3 = 3
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y >= a1 * m.x + b1)
+ m.c2 = pe.Constraint(expr=m.y >= a2 * m.x + b2)
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value)
+ if res.objective_bound is None:
+ bound = -math.inf
+ else:
+ bound = res.objective_bound
+ self.assertTrue(bound <= m.y.value)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
+
+ m.c3 = pe.Constraint(expr=m.y >= a3 * m.x + b3)
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, (b3 - b1) / (a1 - a3))
+ self.assertAlmostEqual(m.y.value, a1 * (b3 - b1) / (a1 - a3) + b1)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value)
+ self.assertTrue(res.objective_bound is None or res.objective_bound <= m.y.value)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a3 - a1)))
+ self.assertAlmostEqual(duals[m.c2], 0)
+ self.assertAlmostEqual(duals[m.c3], a1 / (a3 - a1))
+
+ del m.c3
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value)
+ self.assertTrue(res.objective_bound is None or res.objective_bound <= m.y.value)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -(1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(duals[m.c2], a1 / (a2 - a1))
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_results_infeasible(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y >= m.x)
+ m.c2 = pe.Constraint(expr=m.y <= m.x - 1)
+ with self.assertRaises(Exception):
+ res = opt.solve(m)
+ opt.config.load_solutions = False
+ opt.config.raise_exception_on_nonoptimal_result = False
+ res = opt.solve(m)
+ self.assertNotEqual(res.solution_status, SolutionStatus.optimal)
+ if isinstance(opt, Ipopt):
+ acceptable_termination_conditions = {
+ TerminationCondition.locallyInfeasible,
+ TerminationCondition.unbounded,
+ }
+ else:
+ acceptable_termination_conditions = {
+ TerminationCondition.provenInfeasible,
+ TerminationCondition.infeasibleOrUnbounded,
+ }
+ self.assertIn(res.termination_condition, acceptable_termination_conditions)
+ self.assertAlmostEqual(m.x.value, None)
+ self.assertAlmostEqual(m.y.value, None)
+ self.assertTrue(res.incumbent_objective is None)
+
+ if not isinstance(opt, Ipopt):
+ # ipopt can return the values of the variables/duals at the last iterate
+ # even if it did not converge; raise_exception_on_nonoptimal_result
+ # is set to False, so we are free to load infeasible solutions
+ with self.assertRaisesRegex(
+ RuntimeError, '.*does not currently have a valid solution.*'
+ ):
+ res.solution_loader.load_vars()
+ with self.assertRaisesRegex(
+ RuntimeError, '.*does not currently have valid duals.*'
+ ):
+ res.solution_loader.get_duals()
+ with self.assertRaisesRegex(
+ RuntimeError, '.*does not currently have valid reduced costs.*'
+ ):
+ res.solution_loader.get_reduced_costs()
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_duals(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y - m.x >= 0)
+ m.c2 = pe.Constraint(expr=m.y + m.x - 2 >= 0)
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 1)
+ self.assertAlmostEqual(m.y.value, 1)
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], 0.5)
+ self.assertAlmostEqual(duals[m.c2], 0.5)
+
+ duals = res.solution_loader.get_duals(cons_to_load=[m.c1])
+ self.assertAlmostEqual(duals[m.c1], 0.5)
+ self.assertNotIn(m.c2, duals)
+
+ @parameterized.expand(input=_load_tests(qcp_solvers))
+ def test_mutable_quadratic_coefficient(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a = pe.Param(initialize=1, mutable=True)
+ m.b = pe.Param(initialize=-1, mutable=True)
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2)
+ m.c = pe.Constraint(expr=m.y >= (m.a * m.x + m.b) ** 2)
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0.41024548525899274, 4)
+ self.assertAlmostEqual(m.y.value, 0.34781038127030117, 4)
+ m.a.value = 2
+ m.b.value = -0.5
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0.10256137418973625, 4)
+ self.assertAlmostEqual(m.y.value, 0.0869525991355825, 4)
+
+ @parameterized.expand(input=_load_tests(qcp_solvers))
+ def test_mutable_quadratic_objective(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a = pe.Param(initialize=1, mutable=True)
+ m.b = pe.Param(initialize=-1, mutable=True)
+ m.c = pe.Param(initialize=1, mutable=True)
+ m.d = pe.Param(initialize=1, mutable=True)
+ m.obj = pe.Objective(expr=m.x**2 + m.c * m.y**2 + m.d * m.x)
+ m.ccon = pe.Constraint(expr=m.y >= (m.a * m.x + m.b) ** 2)
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0.2719178742733325, 4)
+ self.assertAlmostEqual(m.y.value, 0.5301035741688002, 4)
+ m.c.value = 3.5
+ m.d.value = -1
+ res = opt.solve(m)
+
+ self.assertAlmostEqual(m.x.value, 0.6962249634573562, 4)
+ self.assertAlmostEqual(m.y.value, 0.09227926676152151, 4)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_fixed_vars(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ for treat_fixed_vars_as_params in [True, False]:
+ opt: SolverBase = opt_class()
+ if opt.is_persistent():
+ opt.config.auto_updates.treat_fixed_vars_as_params = (
+ treat_fixed_vars_as_params
+ )
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.x.fix(0)
+ m.y = pe.Var()
+ a1 = 1
+ a2 = -1
+ b1 = 1
+ b2 = 2
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y >= a1 * m.x + b1)
+ m.c2 = pe.Constraint(expr=m.y >= a2 * m.x + b2)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 2)
+ m.x.unfix()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ m.x.fix(0)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 2)
+ m.x.value = 2
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 2)
+ self.assertAlmostEqual(m.y.value, 3)
+ m.x.value = 0
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 2)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_fixed_vars_2(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if opt.is_persistent():
+ opt.config.auto_updates.treat_fixed_vars_as_params = True
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.x.fix(0)
+ m.y = pe.Var()
+ a1 = 1
+ a2 = -1
+ b1 = 1
+ b2 = 2
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y >= a1 * m.x + b1)
+ m.c2 = pe.Constraint(expr=m.y >= a2 * m.x + b2)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 2)
+ m.x.unfix()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ m.x.fix(0)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 2)
+ m.x.value = 2
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 2)
+ self.assertAlmostEqual(m.y.value, 3)
+ m.x.value = 0
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 2)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_fixed_vars_3(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if opt.is_persistent():
+ opt.config.auto_updates.treat_fixed_vars_as_params = True
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.x + m.y)
+ m.c1 = pe.Constraint(expr=m.x == 2 / m.y)
+ m.y.fix(1)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 3)
+ self.assertAlmostEqual(m.x.value, 2)
+
+ @parameterized.expand(input=_load_tests(nlp_solvers))
+ def test_fixed_vars_4(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if opt.is_persistent():
+ opt.config.auto_updates.treat_fixed_vars_as_params = True
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2)
+ m.c1 = pe.Constraint(expr=m.x == 2 / m.y)
+ m.y.fix(1)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 2)
+ m.y.unfix()
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 2**0.5)
+ self.assertAlmostEqual(m.y.value, 2**0.5)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_mutable_param_with_range(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a1 = pe.Param(initialize=0, mutable=True)
+ m.a2 = pe.Param(initialize=0, mutable=True)
+ m.b1 = pe.Param(initialize=0, mutable=True)
+ m.b2 = pe.Param(initialize=0, mutable=True)
+ m.c1 = pe.Param(initialize=0, mutable=True)
+ m.c2 = pe.Param(initialize=0, mutable=True)
+ m.obj = pe.Objective(expr=m.y)
+ m.con1 = pe.Constraint(expr=(m.b1, m.y - m.a1 * m.x, m.c1))
+ m.con2 = pe.Constraint(expr=(m.b2, m.y - m.a2 * m.x, m.c2))
+
+ np.random.seed(0)
+ params_to_test = [
+ (
+ np.random.uniform(0, 10),
+ np.random.uniform(-10, 0),
+ np.random.uniform(-5, 2.5),
+ np.random.uniform(-5, 2.5),
+ np.random.uniform(2.5, 10),
+ np.random.uniform(2.5, 10),
+ pe.minimize,
+ ),
+ (
+ np.random.uniform(0, 10),
+ np.random.uniform(-10, 0),
+ np.random.uniform(-5, 2.5),
+ np.random.uniform(-5, 2.5),
+ np.random.uniform(2.5, 10),
+ np.random.uniform(2.5, 10),
+ pe.maximize,
+ ),
+ (
+ np.random.uniform(0, 10),
+ np.random.uniform(-10, 0),
+ np.random.uniform(-5, 2.5),
+ np.random.uniform(-5, 2.5),
+ np.random.uniform(2.5, 10),
+ np.random.uniform(2.5, 10),
+ pe.minimize,
+ ),
+ (
+ np.random.uniform(0, 10),
+ np.random.uniform(-10, 0),
+ np.random.uniform(-5, 2.5),
+ np.random.uniform(-5, 2.5),
+ np.random.uniform(2.5, 10),
+ np.random.uniform(2.5, 10),
+ pe.maximize,
+ ),
+ ]
+ for a1, a2, b1, b2, c1, c2, sense in params_to_test:
+ m.a1.value = float(a1)
+ m.a2.value = float(a2)
+ m.b1.value = float(b1)
+ m.b2.value = float(b2)
+ m.c1.value = float(c1)
+ m.c2.value = float(c2)
+ m.obj.sense = sense
+ res: Results = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ if sense is pe.minimize:
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2), 6)
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1, 6)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value, 6)
+ self.assertTrue(
+ res.objective_bound is None
+ or res.objective_bound <= m.y.value + 1e-12
+ )
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.con1], (1 + a1 / (a2 - a1)), 6)
+ self.assertAlmostEqual(duals[m.con2], -a1 / (a2 - a1), 6)
+ else:
+ self.assertAlmostEqual(m.x.value, (c2 - c1) / (a1 - a2), 6)
+ self.assertAlmostEqual(m.y.value, a1 * (c2 - c1) / (a1 - a2) + c1, 6)
+ self.assertAlmostEqual(res.incumbent_objective, m.y.value, 6)
+ self.assertTrue(
+ res.objective_bound is None
+ or res.objective_bound >= m.y.value - 1e-12
+ )
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.con1], (1 + a1 / (a2 - a1)), 6)
+ self.assertAlmostEqual(duals[m.con2], -a1 / (a2 - a1), 6)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_add_and_remove_vars(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.y = pe.Var(bounds=(-1, None))
+ m.obj = pe.Objective(expr=m.y)
+ if opt.is_persistent():
+ opt.config.auto_updates.update_parameters = False
+ opt.config.auto_updates.update_vars = False
+ opt.config.auto_updates.update_constraints = False
+ opt.config.auto_updates.update_named_expressions = False
+ opt.config.auto_updates.check_for_new_or_removed_params = False
+ opt.config.auto_updates.check_for_new_or_removed_constraints = False
+ opt.config.auto_updates.check_for_new_or_removed_vars = False
+ opt.config.load_solutions = False
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ res.solution_loader.load_vars()
+ self.assertAlmostEqual(m.y.value, -1)
+ m.x = pe.Var()
+ a1 = 1
+ a2 = -1
+ b1 = 2
+ b2 = 1
+ m.c1 = pe.Constraint(expr=(0, m.y - a1 * m.x - b1, None))
+ m.c2 = pe.Constraint(expr=(None, -m.y + a2 * m.x + b2, 0))
+ if opt.is_persistent():
+ opt.add_constraints([m.c1, m.c2])
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ res.solution_loader.load_vars()
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ m.c1.deactivate()
+ m.c2.deactivate()
+ if opt.is_persistent():
+ opt.remove_constraints([m.c1, m.c2])
+ m.x.value = None
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ res.solution_loader.load_vars()
+ self.assertEqual(m.x.value, None)
+ self.assertAlmostEqual(m.y.value, -1)
+
+ @parameterized.expand(input=_load_tests(nlp_solvers))
+ def test_exp(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ opt = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2)
+ m.c1 = pe.Constraint(expr=m.y >= pe.exp(m.x))
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, -0.42630274815985264)
+ self.assertAlmostEqual(m.y.value, 0.6529186341994245)
+
+ @parameterized.expand(input=_load_tests(nlp_solvers))
+ def test_log(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ opt = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var(initialize=1)
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2)
+ m.c1 = pe.Constraint(expr=m.y <= pe.log(m.x))
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.x.value, 0.6529186341994245)
+ self.assertAlmostEqual(m.y.value, -0.42630274815985264)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_with_numpy(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ a1 = 1
+ b1 = 3
+ a2 = -2
+ b2 = 1
+ m.c1 = pe.Constraint(
+ expr=(np.float64(0), m.y - np.int64(1) * m.x - np.float32(3), None)
+ )
+ m.c2 = pe.Constraint(
+ expr=(None, -m.y + np.int32(-2) * m.x + np.float64(1), np.float16(0))
+ )
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_bounds_with_params(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.y = pe.Var()
+ m.p = pe.Param(mutable=True)
+ m.y.setlb(m.p)
+ m.p.value = 1
+ m.obj = pe.Objective(expr=m.y)
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.y.value, 1)
+ m.p.value = -1
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.y.value, -1)
+ m.y.setlb(None)
+ m.y.setub(m.p)
+ m.obj.sense = pe.maximize
+ m.p.value = 5
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.y.value, 5)
+ m.p.value = 4
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.y.value, 4)
+ m.y.setub(None)
+ m.y.setlb(m.p)
+ m.obj.sense = pe.minimize
+ m.p.value = 3
+ res = opt.solve(m)
+ self.assertAlmostEqual(m.y.value, 3)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_solution_loader(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(1, None))
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=(0, m.y - m.x, None))
+ m.c2 = pe.Constraint(expr=(0, m.y - m.x + 1, None))
+ opt.config.load_solutions = False
+ res = opt.solve(m)
+ self.assertIsNone(m.x.value)
+ self.assertIsNone(m.y.value)
+ res.solution_loader.load_vars()
+ self.assertAlmostEqual(m.x.value, 1)
+ self.assertAlmostEqual(m.y.value, 1)
+ m.x.value = None
+ m.y.value = None
+ res.solution_loader.load_vars([m.y])
+ self.assertAlmostEqual(m.y.value, 1)
+ primals = res.solution_loader.get_primals()
+ self.assertIn(m.x, primals)
+ self.assertIn(m.y, primals)
+ self.assertAlmostEqual(primals[m.x], 1)
+ self.assertAlmostEqual(primals[m.y], 1)
+ primals = res.solution_loader.get_primals([m.y])
+ self.assertNotIn(m.x, primals)
+ self.assertIn(m.y, primals)
+ self.assertAlmostEqual(primals[m.y], 1)
+ reduced_costs = res.solution_loader.get_reduced_costs()
+ self.assertIn(m.x, reduced_costs)
+ self.assertIn(m.y, reduced_costs)
+ self.assertAlmostEqual(reduced_costs[m.x], 1)
+ self.assertAlmostEqual(reduced_costs[m.y], 0)
+ reduced_costs = res.solution_loader.get_reduced_costs([m.y])
+ self.assertNotIn(m.x, reduced_costs)
+ self.assertIn(m.y, reduced_costs)
+ self.assertAlmostEqual(reduced_costs[m.y], 0)
+ duals = res.solution_loader.get_duals()
+ self.assertIn(m.c1, duals)
+ self.assertIn(m.c2, duals)
+ self.assertAlmostEqual(duals[m.c1], 1)
+ self.assertAlmostEqual(duals[m.c2], 0)
+ duals = res.solution_loader.get_duals([m.c1])
+ self.assertNotIn(m.c2, duals)
+ self.assertIn(m.c1, duals)
+ self.assertAlmostEqual(duals[m.c1], 1)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_time_limit(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ from sys import platform
+
+ if platform == 'win32':
+ raise unittest.SkipTest
+
+ N = 30
+ m = pe.ConcreteModel()
+ m.jobs = pe.Set(initialize=list(range(N)))
+ m.tasks = pe.Set(initialize=list(range(N)))
+ m.x = pe.Var(m.jobs, m.tasks, bounds=(0, 1))
+
+ random.seed(0)
+ coefs = list()
+ lin_vars = list()
+ for j in m.jobs:
+ for t in m.tasks:
+ coefs.append(random.uniform(0, 10))
+ lin_vars.append(m.x[j, t])
+ obj_expr = LinearExpression(
+ linear_coefs=coefs, linear_vars=lin_vars, constant=0
+ )
+ m.obj = pe.Objective(expr=obj_expr, sense=pe.maximize)
+
+ m.c1 = pe.Constraint(m.jobs)
+ m.c2 = pe.Constraint(m.tasks)
+ for j in m.jobs:
+ expr = LinearExpression(
+ linear_coefs=[1] * N,
+ linear_vars=[m.x[j, t] for t in m.tasks],
+ constant=0,
+ )
+ m.c1[j] = expr == 1
+ for t in m.tasks:
+ expr = LinearExpression(
+ linear_coefs=[1] * N,
+ linear_vars=[m.x[j, t] for j in m.jobs],
+ constant=0,
+ )
+ m.c2[t] = expr == 1
+ if isinstance(opt, Ipopt):
+ opt.config.time_limit = 1e-6
+ else:
+ opt.config.time_limit = 0
+ opt.config.load_solutions = False
+ opt.config.raise_exception_on_nonoptimal_result = False
+ res = opt.solve(m)
+ self.assertIn(
+ res.termination_condition,
+ {TerminationCondition.maxTimeLimit, TerminationCondition.iterationLimit},
+ )
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_objective_changes(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.c1 = pe.Constraint(expr=m.y >= m.x + 1)
+ m.c2 = pe.Constraint(expr=m.y >= -m.x + 1)
+ m.obj = pe.Objective(expr=m.y)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ del m.obj
+ m.obj = pe.Objective(expr=2 * m.y)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 2)
+ m.obj.expr = 3 * m.y
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 3)
+ m.obj.sense = pe.maximize
+ opt.config.raise_exception_on_nonoptimal_result = False
+ opt.config.load_solutions = False
+ res = opt.solve(m)
+ self.assertIn(
+ res.termination_condition,
+ {
+ TerminationCondition.unbounded,
+ TerminationCondition.infeasibleOrUnbounded,
+ },
+ )
+ m.obj.sense = pe.minimize
+ opt.config.load_solutions = True
+ del m.obj
+ m.obj = pe.Objective(expr=m.x * m.y)
+ m.x.fix(2)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 6, 6)
+ m.x.fix(3)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 12, 6)
+ m.x.unfix()
+ m.y.fix(2)
+ m.x.setlb(-3)
+ m.x.setub(5)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, -2, 6)
+ m.y.unfix()
+ m.x.setlb(None)
+ m.x.setub(None)
+ m.e = pe.Expression(expr=2)
+ del m.obj
+ m.obj = pe.Objective(expr=m.e * m.y)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 2)
+ m.e.expr = 3
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 3)
+ if opt.is_persistent():
+ opt.config.auto_updates.check_for_new_objective = False
+ m.e.expr = 4
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 4)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_domain(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(1, None), domain=pe.NonNegativeReals)
+ m.obj = pe.Objective(expr=m.x)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ m.x.setlb(-1)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+ m.x.setlb(1)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ m.x.setlb(-1)
+ m.x.domain = pe.Reals
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, -1)
+ m.x.domain = pe.NonNegativeReals
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+
+ @parameterized.expand(input=_load_tests(mip_solvers))
+ def test_domain_with_integers(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-1, None), domain=pe.NonNegativeIntegers)
+ m.obj = pe.Objective(expr=m.x)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+ m.x.setlb(0.5)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ m.x.setlb(-5.5)
+ m.x.domain = pe.Integers
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, -5)
+ m.x.domain = pe.Binary
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+ m.x.setlb(0.5)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_fixed_binaries(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ m = pe.ConcreteModel()
+ m.x = pe.Var(domain=pe.Binary)
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ m.c = pe.Constraint(expr=m.y >= m.x)
+ m.x.fix(0)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+ m.x.fix(1)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+
+ opt: SolverBase = opt_class()
+ if opt.is_persistent():
+ opt.config.auto_updates.treat_fixed_vars_as_params = False
+ m.x.fix(0)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+ m.x.fix(1)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+
+ @parameterized.expand(input=_load_tests(mip_solvers))
+ def test_with_gdp(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-10, 10))
+ m.y = pe.Var(bounds=(-10, 10))
+ m.obj = pe.Objective(expr=m.y)
+ m.d1 = gdp.Disjunct()
+ m.d1.c1 = pe.Constraint(expr=m.y >= m.x + 2)
+ m.d1.c2 = pe.Constraint(expr=m.y >= -m.x + 2)
+ m.d2 = gdp.Disjunct()
+ m.d2.c1 = pe.Constraint(expr=m.y >= m.x + 1)
+ m.d2.c2 = pe.Constraint(expr=m.y >= -m.x + 1)
+ m.disjunction = gdp.Disjunction(expr=[m.d2, m.d1])
+ pe.TransformationFactory("gdp.bigm").apply_to(m)
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 1)
+
+ opt: SolverBase = opt_class()
+ opt.use_extensions = True
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 1)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_variables_elsewhere(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.b = pe.Block()
+ m.b.obj = pe.Objective(expr=m.y)
+ m.b.c1 = pe.Constraint(expr=m.y >= m.x + 2)
+ m.b.c2 = pe.Constraint(expr=m.y >= -m.x)
+
+ res = opt.solve(m.b)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ self.assertAlmostEqual(m.x.value, -1)
+ self.assertAlmostEqual(m.y.value, 1)
+
+ m.x.setlb(0)
+ res = opt.solve(m.b)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(res.incumbent_objective, 2)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 2)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_variables_elsewhere2(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.z = pe.Var()
+
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y >= m.x)
+ m.c2 = pe.Constraint(expr=m.y >= -m.x)
+ m.c3 = pe.Constraint(expr=m.y >= m.z + 1)
+ m.c4 = pe.Constraint(expr=m.y >= -m.z + 1)
+
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ sol = res.solution_loader.get_primals()
+ self.assertIn(m.x, sol)
+ self.assertIn(m.y, sol)
+ self.assertIn(m.z, sol)
+
+ del m.c3
+ del m.c4
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+ sol = res.solution_loader.get_primals()
+ self.assertIn(m.x, sol)
+ self.assertIn(m.y, sol)
+ self.assertNotIn(m.z, sol)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_bug_1(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(3, 7))
+ m.y = pe.Var(bounds=(-10, 10))
+ m.p = pe.Param(mutable=True, initialize=0)
+
+ m.obj = pe.Objective(expr=m.y)
+ m.c = pe.Constraint(expr=m.y >= m.p * m.x)
+
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+
+ m.p.value = 1
+ res = opt.solve(m)
+ self.assertEqual(res.solution_status, SolutionStatus.optimal)
+ self.assertAlmostEqual(res.incumbent_objective, 3)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_bug_2(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ """
+ This test is for a bug where an objective containing a fixed variable does
+ not get updated properly when the variable is unfixed.
+ """
+ for fixed_var_option in [True, False]:
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+ if opt.is_persistent():
+ opt.config.auto_updates.treat_fixed_vars_as_params = fixed_var_option
+
+ m = pe.ConcreteModel()
+ m.x = pe.Var(bounds=(-10, 10))
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=3 * m.y - m.x)
+ m.c = pe.Constraint(expr=m.y >= m.x)
+
+ m.x.fix(1)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 2, 5)
+
+ m.x.unfix()
+ m.x.setlb(-9)
+ m.x.setub(9)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, -18, 5)
+
+ @parameterized.expand(input=_load_tests(nl_solvers))
+ def test_presolve_with_zero_coef(
+ self, name: str, opt_class: Type[SolverBase], use_presolve: bool
+ ):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ if use_presolve:
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+
+ """
+ when c2 gets presolved out, c1 becomes
+ x - y + y = 0 which becomes
+ x - 0*y == 0 which is the zero we are testing for
+ """
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.z = pe.Var()
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2 + m.z**2)
+ m.c1 = pe.Constraint(expr=m.x == m.y + m.z + 1.5)
+ m.c2 = pe.Constraint(expr=m.z == -m.y)
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 2.25)
+ self.assertAlmostEqual(m.x.value, 1.5)
+ self.assertAlmostEqual(m.y.value, 0)
+ self.assertAlmostEqual(m.z.value, 0)
+
+ m.x.setlb(2)
+ res = opt.solve(
+ m, load_solutions=False, raise_exception_on_nonoptimal_result=False
+ )
+ if use_presolve:
+ exp = TerminationCondition.provenInfeasible
+ else:
+ exp = TerminationCondition.locallyInfeasible
+ self.assertEqual(res.termination_condition, exp)
+
+ m = pe.ConcreteModel()
+ m.w = pe.Var()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.z = pe.Var()
+ m.obj = pe.Objective(expr=m.x**2 + m.y**2 + m.z**2 + m.w**2)
+ m.c1 = pe.Constraint(expr=m.x + m.w == m.y + m.z)
+ m.c2 = pe.Constraint(expr=m.z == -m.y)
+ m.c3 = pe.Constraint(expr=m.x == -m.w)
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 0)
+ self.assertAlmostEqual(m.w.value, 0)
+ self.assertAlmostEqual(m.x.value, 0)
+ self.assertAlmostEqual(m.y.value, 0)
+ self.assertAlmostEqual(m.z.value, 0)
+
+ del m.c1
+ m.c1 = pe.Constraint(expr=m.x + m.w == m.y + m.z + 1.5)
+ res = opt.solve(
+ m, load_solutions=False, raise_exception_on_nonoptimal_result=False
+ )
+ self.assertEqual(res.termination_condition, exp)
+
+ @parameterized.expand(input=_load_tests(all_solvers))
+ def test_scaling(self, name: str, opt_class: Type[SolverBase], use_presolve: bool):
+ opt: SolverBase = opt_class()
+ if not opt.available():
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ check_duals = True
+ if any(name.startswith(i) for i in nl_solvers_set):
+ if use_presolve:
+ check_duals = False
+ opt.config.writer_config.linear_presolve = True
+ else:
+ opt.config.writer_config.linear_presolve = False
+
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=m.y >= (m.x - 1) + 1)
+ m.c2 = pe.Constraint(expr=m.y >= -(m.x - 1) + 1)
+ m.scaling_factor = pe.Suffix(direction=pe.Suffix.EXPORT)
+ m.scaling_factor[m.x] = 0.5
+ m.scaling_factor[m.y] = 2
+ m.scaling_factor[m.c1] = 0.5
+ m.scaling_factor[m.c2] = 2
+ m.scaling_factor[m.obj] = 2
+
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 1)
+ self.assertAlmostEqual(m.x.value, 1)
+ self.assertAlmostEqual(m.y.value, 1)
+ primals = res.solution_loader.get_primals()
+ self.assertAlmostEqual(primals[m.x], 1)
+ self.assertAlmostEqual(primals[m.y], 1)
+ if check_duals:
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -0.5)
+ self.assertAlmostEqual(duals[m.c2], -0.5)
+ rc = res.solution_loader.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], 0)
+ self.assertAlmostEqual(rc[m.y], 0)
+
+ m.x.setlb(2)
+ res = opt.solve(m)
+ self.assertAlmostEqual(res.incumbent_objective, 2)
+ self.assertAlmostEqual(m.x.value, 2)
+ self.assertAlmostEqual(m.y.value, 2)
+ primals = res.solution_loader.get_primals()
+ self.assertAlmostEqual(primals[m.x], 2)
+ self.assertAlmostEqual(primals[m.y], 2)
+ if check_duals:
+ duals = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], -1)
+ self.assertAlmostEqual(duals[m.c2], 0)
+ rc = res.solution_loader.get_reduced_costs()
+ self.assertAlmostEqual(rc[m.x], 1)
+ self.assertAlmostEqual(rc[m.y], 0)
+
+
+class TestLegacySolverInterface(unittest.TestCase):
+ @parameterized.expand(input=all_solvers)
+ def test_param_updates(self, name: str, opt_class: Type[SolverBase]):
+ opt = pe.SolverFactory(name + '_v2')
+ if not opt.available(exception_flag=False):
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.y = pe.Var()
+ m.a1 = pe.Param(mutable=True)
+ m.a2 = pe.Param(mutable=True)
+ m.b1 = pe.Param(mutable=True)
+ m.b2 = pe.Param(mutable=True)
+ m.obj = pe.Objective(expr=m.y)
+ m.c1 = pe.Constraint(expr=(0, m.y - m.a1 * m.x - m.b1, None))
+ m.c2 = pe.Constraint(expr=(None, -m.y + m.a2 * m.x + m.b2, 0))
+ m.dual = pe.Suffix(direction=pe.Suffix.IMPORT)
+
+ params_to_test = [(1, -1, 2, 1), (1, -2, 2, 1), (1, -1, 3, 1)]
+ for a1, a2, b1, b2 in params_to_test:
+ m.a1.value = a1
+ m.a2.value = a2
+ m.b1.value = b1
+ m.b2.value = b2
+ res = opt.solve(m)
+ pe.assert_optimal_termination(res)
+ self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2))
+ self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1)
+ self.assertAlmostEqual(m.dual[m.c1], (1 + a1 / (a2 - a1)))
+ self.assertAlmostEqual(m.dual[m.c2], a1 / (a2 - a1))
+
+ @parameterized.expand(input=all_solvers)
+ def test_load_solutions(self, name: str, opt_class: Type[SolverBase]):
+ opt = pe.SolverFactory(name + '_v2')
+ if not opt.available(exception_flag=False):
+ raise unittest.SkipTest(f'Solver {opt.name} not available.')
+ m = pe.ConcreteModel()
+ m.x = pe.Var()
+ m.obj = pe.Objective(expr=m.x)
+ m.c = pe.Constraint(expr=(-1, m.x, 1))
+ m.dual = pe.Suffix(direction=pe.Suffix.IMPORT)
+ res = opt.solve(m, load_solutions=False)
+ pe.assert_optimal_termination(res)
+ self.assertIsNone(m.x.value)
+ self.assertNotIn(m.c, m.dual)
+ m.solutions.load_from(res)
+ self.assertAlmostEqual(m.x.value, -1)
+ self.assertAlmostEqual(m.dual[m.c], 1)
diff --git a/pyomo/contrib/solver/tests/unit/__init__.py b/pyomo/contrib/solver/tests/unit/__init__.py
new file mode 100644
index 00000000000..a4a626013c4
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/__init__.py
@@ -0,0 +1,10 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/__init__.py b/pyomo/contrib/solver/tests/unit/sol_files/__init__.py
new file mode 100644
index 00000000000..a4a626013c4
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/__init__.py
@@ -0,0 +1,10 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/bad_objno.sol b/pyomo/contrib/solver/tests/unit/sol_files/bad_objno.sol
new file mode 100644
index 00000000000..a7eccfca388
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/bad_objno.sol
@@ -0,0 +1,22 @@
+CONOPT 3.17A: Optimal; objective 1
+4 iterations; evals: nf = 2, ng = 0, nc = 2, nJ = 0, nH = 0, nHv = 0
+
+Options
+3
+1
+1
+0
+1
+1
+1
+1
+1
+1
+Xobjno 0 0
+suffix 0 1 8 0 0
+sstatus
+0 1
+suffix 1 1 8 0 0
+sstatus
+0 3
+
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/bad_objnoline.sol b/pyomo/contrib/solver/tests/unit/sol_files/bad_objnoline.sol
new file mode 100644
index 00000000000..6abcacbb3c4
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/bad_objnoline.sol
@@ -0,0 +1,22 @@
+CONOPT 3.17A: Optimal; objective 1
+4 iterations; evals: nf = 2, ng = 0, nc = 2, nJ = 0, nH = 0, nHv = 0
+
+Options
+3
+1
+1
+0
+1
+1
+1
+1
+1
+1
+objno 0 0 1
+suffix 0 1 8 0 0
+sstatus
+0 1
+suffix 1 1 8 0 0
+sstatus
+0 3
+
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/bad_options.sol b/pyomo/contrib/solver/tests/unit/sol_files/bad_options.sol
new file mode 100644
index 00000000000..f59a2ffd3b4
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/bad_options.sol
@@ -0,0 +1,22 @@
+CONOPT 3.17A: Optimal; objective 1
+4 iterations; evals: nf = 2, ng = 0, nc = 2, nJ = 0, nH = 0, nHv = 0
+
+OXptions
+3
+1
+1
+0
+1
+1
+1
+1
+1
+1
+objno 0 0
+suffix 0 1 8 0 0
+sstatus
+0 1
+suffix 1 1 8 0 0
+sstatus
+0 3
+
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/conopt_optimal.sol b/pyomo/contrib/solver/tests/unit/sol_files/conopt_optimal.sol
new file mode 100644
index 00000000000..4ff14b50bc7
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/conopt_optimal.sol
@@ -0,0 +1,22 @@
+CONOPT 3.17A: Optimal; objective 1
+4 iterations; evals: nf = 2, ng = 0, nc = 2, nJ = 0, nH = 0, nHv = 0
+
+Options
+3
+1
+1
+0
+1
+1
+1
+1
+1
+1
+objno 0 0
+suffix 0 1 8 0 0
+sstatus
+0 1
+suffix 1 1 8 0 0
+sstatus
+0 3
+
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/depr_solver.sol b/pyomo/contrib/solver/tests/unit/sol_files/depr_solver.sol
new file mode 100644
index 00000000000..01ceb566334
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/depr_solver.sol
@@ -0,0 +1,67 @@
+PICO Solver: final f = 88.200000
+
+Options
+3
+0
+0
+0
+24
+24
+32
+32
+0
+0
+0.12599999999999997
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+46.666666666666664
+0
+0
+0
+0
+0
+0
+933.3333333333336
+10000
+10000
+10000
+10000
+0
+100
+0
+100
+0
+100
+0
+100
+46.666666666666664
+53.333333333333336
+0
+100
+0
+100
+0
+100
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/iis_no_variable_values.sol b/pyomo/contrib/solver/tests/unit/sol_files/iis_no_variable_values.sol
new file mode 100644
index 00000000000..641a3162a8f
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/iis_no_variable_values.sol
@@ -0,0 +1,34 @@
+CPLEX 12.8.0.0: integer infeasible.
+0 MIP simplex iterations
+0 branch-and-bound nodes
+Returning an IIS of 2 variables and 1 constraints.
+No basis.
+
+Options
+3
+1
+1
+0
+1
+0
+2
+0
+objno 0 220
+suffix 0 2 4 181 11
+iis
+
+0 non not in the iis
+1 low at lower bound
+2 fix fixed
+3 upp at upper bound
+4 mem member
+5 pmem possible member
+6 plow possibly at lower bound
+7 pupp possibly at upper bound
+8 bug
+
+0 1
+1 1
+suffix 1 1 4 0 0
+iis
+0 4
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/infeasible1.sol b/pyomo/contrib/solver/tests/unit/sol_files/infeasible1.sol
new file mode 100644
index 00000000000..9e7c47f2091
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/infeasible1.sol
@@ -0,0 +1,491 @@
+
+Ipopt 3.12: Converged to a locally infeasible point. Problem may be infeasible.
+
+Options
+3
+1
+1
+0
+242
+242
+86
+86
+-3.5031247438024307e-14
+-3.5234584915901186e-14
+-3.5172095867741636e-14
+-3.530546013164763e-14
+-3.5172095867741636e-14
+-3.5305460131648396e-14
+-2.366093398247632e-13
+-2.3660933995816667e-13
+-2.366093403160036e-13
+-2.366093402111279e-13
+-2.366093403160036e-13
+-2.366093402111279e-13
+-3.230618014133495e-14
+-3.229008861611988e-14
+-3.2372291959738883e-14
+-3.233107904711923e-14
+-3.2372291959738883e-14
+-3.233107904711986e-14
+-2.366093402825742e-13
+-2.3660934046399004e-13
+-2.366093408240676e-13
+-2.3660934074259244e-13
+-2.366093408240676e-13
+-2.3660934074259244e-13
+-3.5337260190603076e-15
+-3.5384985959538063e-15
+-3.5360752870197467e-15
+-3.5401103667524204e-15
+-3.5360752870197475e-15
+-3.540110366752954e-15
+-1.1241014244910024e-13
+-7.229408362081387e-14
+-1.1241014257725814e-13
+-7.229408365067014e-14
+-1.1241014257725814e-13
+-7.229408365067014e-14
+-0.045045044618550245
+-2.2503048100082865e-13
+-0.04504504461894986
+-2.3019280438209537e-13
+-2.4246742873024166e-13
+-2.3089017630512727e-13
+-2.303517676239642e-13
+-2.3258460904987257e-13
+-2.2657149778091163e-13
+-2.3561210481068387e-13
+-2.260257681221233e-13
+-2.4196851090379605e-13
+-2.2609595226592818e-13
+-0.04504504461900244
+-2.249595193064585e-13
+-0.04504504461913233
+-2.2215413967954347e-13
+-0.045045044619133334
+1.4720100770836167e-13
+0.5405405354313707
+-1.1746366725687393e-13
+-8.181817954545458e-14
+3.3628105937413004e-10
+2.5420446367682183e-10
+-4.068865957494519e-10
+-3.3083656247909664e-10
+2.0162505532975142e-10
+1.3899803000287233e-10
+1.9264257030343367e-10
+1.5784707460270425e-10
+4.0453655296452274e-10
+1.8623815108786813e-10
+4.023012427968502e-10
+2.2427204843237042e-10
+4.285852894154949e-10
+2.7438151967949997e-10
+4.990725722952413e-10
+3.24233733037425e-10
+6.365790489375267e-10
+1.8786461752037693e-10
+9.36934851555115e-10
+1.9328729420874646e-10
+2.1302900967163764e-09
+1.9184434624295806e-10
+1.839058810801874e-10
+3.1045038304739125e-08
+2.033627397720737e-10
+1.965179362792721e-09
+3.9014568630621037e-10
+9.629991995490913e-10
+3.8529492862465446e-10
+6.543016210883198e-10
+3.1023232285992586e-10
+5.203524431666233e-10
+2.443053484937026e-10
+4.814394103716646e-10
+1.9839047821553417e-10
+2.29157081595439e-10
+1.6697733108860693e-10
+2.2885043298472609e-10
+1.4439699240241691e-10
+2.231817349184844e-10
+7.996844380007978e-07
+7.95878555840714e-07
+-6.161782990947841e-09
+-6.174783045271923e-09
+-6.180473110458713e-09
+-6.1838001759594465e-09
+-6.180473110458713e-09
+-6.183800175957144e-09
+-1.3264604647361279e-14
+-1.3437580361963064e-14
+-1.381614108205247e-14
+-1.3724139850276759e-14
+-1.381614108205247e-14
+-1.3724139850276584e-14
+-1.3264604647361279e-14
+-1.3437580361963064e-14
+-1.381614108205247e-14
+-1.3724139850276759e-14
+-1.381614108205247e-14
+-1.3724139850276584e-14
+-1.3264604647357383e-14
+-1.3264604647357383e-14
+-1.258629585661237e-14
+-1.2586303131773045e-14
+-1.2586307639008801e-14
+-1.2586311120145482e-14
+-1.2586314285443517e-14
+-1.258631748040718e-14
+-1.2586321221671653e-14
+-1.2741959563395428e-14
+-1.2741955464025058e-14
+-1.2741952925774324e-14
+-1.2741950138083889e-14
+-1.2741945491635486e-14
+-1.274193825746462e-14
+-1.3437580361959015e-14
+-1.3437580361959015e-14
+-1.3437580361959015e-14
+-1.3816141082048241e-14
+-1.3816141082048241e-14
+-1.3081851406508949e-14
+-1.308185926540242e-14
+-1.3081864134282786e-14
+-1.3081867894733614e-14
+-1.308187131400409e-14
+-1.308187476532053e-14
+-1.3081878806771144e-14
+-1.2999353684840647e-14
+-1.299934941829921e-14
+-1.2999346776539415e-14
+-1.2999343875167873e-14
+-1.2999339039238868e-14
+-1.2999331510061096e-14
+-1.3724139850272537e-14
+-1.3724139850272537e-14
+-1.3724139850272537e-14
+-1.3816141082048243e-14
+-1.3816141082048243e-14
+-1.3081851406508949e-14
+-1.3081859265402422e-14
+-1.3081864134282784e-14
+-1.3081867894733614e-14
+-1.308187131400409e-14
+-1.308187476532053e-14
+-1.3081878806771145e-14
+-1.299935368484049e-14
+-1.2999349418299049e-14
+-1.2999346776539257e-14
+-1.2999343875167712e-14
+-1.299933903923871e-14
+-1.2999331510060935e-14
+-1.3724139850272359e-14
+-1.3724139850272359e-14
+-1.3724139850272359e-14
+-0.39647376852165084
+-0.4455844823264693
+-0.3964737698727394
+-0.4455844904349083
+-0.04058112126213324
+-2.37392784926522e-13
+-0.04058112126182639
+-2.3739125313713354e-13
+-2.3738581599973924e-13
+-2.3739030469186293e-13
+-2.373886019673396e-13
+-2.3738926304868226e-13
+-2.3739032800906814e-13
+-2.373875268840388e-13
+-2.3739166112281285e-13
+-2.373848238523691e-13
+-2.3739287329689576e-13
+-0.04058112126709927
+-2.3739409684312144e-13
+-0.04058112126734901
+-2.3739552961585984e-13
+-0.040581121263560345
+-7.976233462779415e-11
+-8.149038165921345e-11
+-8.149038165921345e-11
+-8.022671984428942e-11
+-8.112229180405433e-11
+-8.112229180405698e-11
+-1.1362727144888948e-10
+-4.545363318183219e-10
+-1.5766054471383136e-10
+-999.9999999987843
+2.0239864420785628e-10
+3.6952311802810024e-10
+2.123373938372435e-10
+2.804864327332228e-10
+1.346149969721881e-10
+2.2070281853153174e-10
+1.3486437441647496e-10
+1.837701666832909e-10
+1.3214731344936636e-10
+1.59848684557641e-10
+1.2663217798563007e-10
+1.4670685236091518e-10
+1.2005152713943525e-10
+2.1846147211317584e-10
+1.1320656639453056e-10
+2.1155957764572616e-10
+1.0602947953081767e-10
+2.1331568061293854e-10
+2.2406981587244565e-10
+1.0144323269437438e-10
+2.0067712609010725e-10
+1.0647572138657723e-10
+1.3628795523686926e-10
+1.1283736217061156e-10
+1.3689006597815967e-10
+1.1944117806753888e-10
+1.4976540231691364e-10
+1.2533138246033542e-10
+1.7219937613078787e-10
+1.2782000199367948e-10
+2.0576625901474408e-10
+1.8061506448741275e-10
+2.5564782647515365e-10
+1.8080595589290967e-10
+3.3611540082361537e-10
+1.8450853640157845e-10
+-999.9999999992634
+500.00000267889834
+3700.000036997707
+3700.00003699796
+3700.000036997707
+3700.00003699796
+3700.000036977598
+3700.000036977598
+11.65620349374497
+11.697892989049905
+11.723721175743378
+11.743669409189184
+11.761807757832353
+11.780116092441125
+11.801554922843986
+11.760485435103986
+11.737564481489017
+11.723372263570411
+11.70778533743834
+11.68180544764916
+11.64135667458445
+3700.000036977598
+3700.000036977598
+3700.000036977598
+0.3151184672323908
+0.32392866804605874
+0.34244076638380455
+0.33803566597697493
+0.34244076638380455
+0.3380356659769663
+0.27110063090377123
+0.2699297687440479
+0.2929786728909554
+0.29344480424126584
+0.28838393432428394
+0.2893992806145764
+0.2710728789062779
+0.26993404119945896
+0.2934152392453943
+0.29361001971947676
+0.2884212793214469
+0.28944447549328195
+0.2710728789062779
+0.2699340411994531
+0.29341523924539437
+0.29361001971947087
+0.28842127932144684
+0.2894444754932388
+0.5508615869879336
+0.15398873818985254
+0.6718832432569866
+0.17589826345513584
+0.5247189958883286
+0.18810973351399282
+0.6259675738420305
+0.20533542867213556
+0.7121098490801165
+0.23131269225729922
+0.7821527320463884
+0.28037348913556315
+0.8428067559035302
+0.5838840489481971
+0.8970272395501521
+0.6703093152878702
+0.94267886174376
+0.7738465562949745
+0.8177198430399907
+0.9786900926762641
+0.6704296542151029
+0.9210489338249574
+0.3564282839324347
+0.8691777702202935
+0.2593618184144545
+0.8137154539828636
+0.21644752420062746
+0.7494805564573437
+0.1955192721716388
+0.6636009115148781
+0.1816326651938952
+0.7714724374833359
+0.16783059150769936
+0.6720038647474075
+0.15295832306009652
+0.5820927246947017
+0
+5.999999940000606
+3.2342062150876796
+9.747775650827162
+objno 0 200
+suffix 4 60 13 0 0
+ipopt_zU_out
+22 -1.327369555645263e-09
+23 -1.3446671271054377e-09
+24 -1.382523199114386e-09
+25 -1.373323075936809e-09
+26 -1.382523199114386e-09
+27 -1.3733230759367915e-09
+28 -1.2472104315043693e-09
+29 -1.2452101972496192e-09
+30 -1.2858040647227637e-09
+31 -1.2866523403876923e-09
+32 -1.2775019286011434e-09
+33 -1.2793272952136163e-09
+34 -1.2471629472231613e-09
+35 -1.2452174844060395e-09
+36 -1.2865985041388369e-09
+37 -1.2869532717202986e-09
+38 -1.2775689743171436e-09
+39 -1.2794086668147935e-09
+40 -1.2471629472231613e-09
+41 -1.2452174844060298e-09
+42 -1.2865985041388369e-09
+43 -1.2869532717202878e-09
+44 -1.2775689743171434e-09
+45 -1.2794086668147155e-09
+46 -2.0240773556752306e-09
+47 -1.0745612255836558e-09
+48 -2.770632290509263e-09
+49 -1.103129453565228e-09
+50 -1.9127440056903688e-09
+51 -1.1197213910483093e-09
+52 -2.430513566198766e-09
+53 -1.1439932412498466e-09
+54 -3.1577699873109563e-09
+55 -1.182653712929702e-09
+56 -4.173065268467735e-09
+57 -1.2632815552706913e-09
+58 -5.783269227344645e-09
+59 -2.1847056932251413e-09
+60 -8.828459262787896e-09
+61 -2.7574054223382863e-09
+62 -1.5860201572267072e-08
+63 -4.019796745114287e-09
+64 -4.987327799213503e-09
+65 -4.128677327837785e-08
+66 -2.7584122571707027e-09
+67 -1.1514963264478648e-08
+68 -1.4125712376227499e-09
+69 -6.9490543282105264e-09
+70 -1.2274426584743552e-09
+71 -4.880119585077116e-09
+72 -1.160216995366489e-09
+73 -3.628823630675873e-09
+74 -1.13003440308759e-09
+75 -2.7024178093492304e-09
+76 -1.1108592195439713e-09
+77 -3.978035995523888e-09
+78 -1.0924348929579286e-09
+79 -2.7716511991201962e-09
+80 -1.073254036073809e-09
+81 -2.175341139896496e-09
+suffix 4 86 13 0 0
+ipopt_zL_out
+0 2.457002432427315e-13
+1 2.457002432427147e-13
+2 2.457002432427315e-13
+3 2.457002432427147e-13
+4 2.457002432440668e-13
+5 2.457002432440668e-13
+6 7.799202448711829e-11
+7 7.771407288173584e-11
+8 7.754286328443318e-11
+9 7.741114609420585e-11
+10 7.72917673061454e-11
+11 7.717164255304123e-11
+12 7.703145172513595e-11
+13 7.730045781990877e-11
+14 7.7451409084917e-11
+15 7.754517112285163e-11
+16 7.76484093372809e-11
+17 7.782109643810629e-11
+18 7.809149171545744e-11
+19 2.457002432440668e-13
+20 2.457002432440668e-13
+21 2.457002432440668e-13
+22 2.88491781594494e-09
+23 2.806453922602062e-09
+24 2.6547390725285084e-09
+25 2.6893342144319893e-09
+26 2.6547390725285084e-09
+27 2.6893342144320575e-09
+28 3.3533336782625715e-09
+29 3.367879281546927e-09
+30 3.1029251008167857e-09
+31 3.0979961649984553e-09
+32 3.152363115331538e-09
+33 3.1413031705213295e-09
+34 3.353676987058653e-09
+35 3.3678259755079893e-09
+36 3.0983083240635833e-09
+37 3.096252910785026e-09
+38 3.1519549450665203e-09
+39 3.1408126764021113e-09
+40 3.353676987058653e-09
+41 3.367825975508062e-09
+42 3.0983083240635824e-09
+43 3.0962529107850877e-09
+44 3.151954945066521e-09
+45 3.140812676402579e-09
+46 1.6503072927322882e-09
+47 5.903619062223097e-09
+48 1.3530489183372102e-09
+49 5.168276510428202e-09
+50 1.7325290303934247e-09
+51 4.8327689212818915e-09
+52 1.4522971044995076e-09
+53 4.4273454737645e-09
+54 1.276616097383978e-09
+55 3.930138360770138e-09
+56 1.1622933223262232e-09
+57 3.242428123819113e-09
+58 1.0786469044524248e-09
+59 1.556971619947646e-09
+60 1.0134484872637181e-09
+61 1.356225961423535e-09
+62 9.643698375125132e-10
+63 1.174768939146355e-09
+64 1.1117388275802617e-09
+65 9.288986889801197e-10
+66 1.3559825252250914e-09
+67 9.870172368223874e-10
+68 2.55055764727633e-09
+69 1.0459205566343963e-09
+70 3.5051068618760334e-09
+71 1.1172098225860037e-09
+72 4.2000521577056155e-09
+73 1.212961283078632e-09
+74 4.649622902405193e-09
+75 1.3699361786951016e-09
+76 5.005106744564875e-09
+77 1.1783841562800436e-09
+78 5.416717299785639e-09
+79 1.3528060526165563e-09
+80 5.943389257560972e-09
+81 1.561763024323873e-09
+82 500.00000026951534
+83 1.515151527777625e-10
+84 2.8108595681091103e-10
+85 9.326135918021712e-11
diff --git a/pyomo/contrib/solver/tests/unit/sol_files/infeasible2.sol b/pyomo/contrib/solver/tests/unit/sol_files/infeasible2.sol
new file mode 100644
index 00000000000..6fddb053745
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/sol_files/infeasible2.sol
@@ -0,0 +1,13 @@
+
+ Couenne (C:\Users\SASCHA~1\AppData\Local\Temp\tmpvcmknhw0.pyomo.nl May 18 2015): Infeasible
+
+Options
+3
+0
+1
+0
+242
+0
+86
+0
+objno 0 220
diff --git a/pyomo/contrib/solver/tests/unit/test_base.py b/pyomo/contrib/solver/tests/unit/test_base.py
new file mode 100644
index 00000000000..b52f96ba903
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/test_base.py
@@ -0,0 +1,374 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 os
+
+from pyomo.common import unittest
+from pyomo.common.config import ConfigDict
+from pyomo.contrib.solver import base
+
+
+class TestSolverBase(unittest.TestCase):
+ def test_abstract_member_list(self):
+ expected_list = ['solve', 'available', 'version']
+ member_list = list(base.SolverBase.__abstractmethods__)
+ self.assertEqual(sorted(expected_list), sorted(member_list))
+
+ def test_class_method_list(self):
+ expected_list = [
+ 'Availability',
+ 'CONFIG',
+ 'available',
+ 'is_persistent',
+ 'solve',
+ 'version',
+ ]
+ method_list = [
+ method for method in dir(base.SolverBase) if method.startswith('_') is False
+ ]
+ self.assertEqual(sorted(expected_list), sorted(method_list))
+
+ @unittest.mock.patch.multiple(base.SolverBase, __abstractmethods__=set())
+ def test_init(self):
+ self.instance = base.SolverBase()
+ self.assertFalse(self.instance.is_persistent())
+ self.assertEqual(self.instance.version(), None)
+ self.assertEqual(self.instance.name, 'solverbase')
+ self.assertEqual(self.instance.CONFIG, self.instance.config)
+ self.assertEqual(self.instance.solve(None), None)
+ self.assertEqual(self.instance.available(), None)
+
+ @unittest.mock.patch.multiple(base.SolverBase, __abstractmethods__=set())
+ def test_context_manager(self):
+ with base.SolverBase() as self.instance:
+ self.assertFalse(self.instance.is_persistent())
+ self.assertEqual(self.instance.version(), None)
+ self.assertEqual(self.instance.name, 'solverbase')
+ self.assertEqual(self.instance.CONFIG, self.instance.config)
+ self.assertEqual(self.instance.solve(None), None)
+ self.assertEqual(self.instance.available(), None)
+
+ @unittest.mock.patch.multiple(base.SolverBase, __abstractmethods__=set())
+ def test_config_kwds(self):
+ self.instance = base.SolverBase(tee=True)
+ self.assertTrue(self.instance.config.tee)
+
+ @unittest.mock.patch.multiple(base.SolverBase, __abstractmethods__=set())
+ def test_solver_availability(self):
+ self.instance = base.SolverBase()
+ self.instance.Availability._value_ = 1
+ self.assertTrue(self.instance.Availability.__bool__(self.instance.Availability))
+ self.instance.Availability._value_ = -1
+ self.assertFalse(
+ self.instance.Availability.__bool__(self.instance.Availability)
+ )
+
+ @unittest.mock.patch.multiple(base.SolverBase, __abstractmethods__=set())
+ def test_custom_solver_name(self):
+ self.instance = base.SolverBase(name='my_unique_name')
+ self.assertEqual(self.instance.name, 'my_unique_name')
+
+
+class TestPersistentSolverBase(unittest.TestCase):
+ def test_abstract_member_list(self):
+ expected_list = [
+ 'remove_parameters',
+ 'version',
+ 'update_variables',
+ 'remove_variables',
+ 'add_constraints',
+ '_get_primals',
+ 'set_instance',
+ 'set_objective',
+ 'update_parameters',
+ 'remove_block',
+ 'add_block',
+ 'available',
+ 'add_parameters',
+ 'remove_constraints',
+ 'add_variables',
+ 'solve',
+ ]
+ member_list = list(base.PersistentSolverBase.__abstractmethods__)
+ self.assertEqual(sorted(expected_list), sorted(member_list))
+
+ def test_class_method_list(self):
+ expected_list = [
+ 'Availability',
+ 'CONFIG',
+ '_get_duals',
+ '_get_primals',
+ '_get_reduced_costs',
+ '_load_vars',
+ 'add_block',
+ 'add_constraints',
+ 'add_parameters',
+ 'add_variables',
+ 'available',
+ 'is_persistent',
+ 'remove_block',
+ 'remove_constraints',
+ 'remove_parameters',
+ 'remove_variables',
+ 'set_instance',
+ 'set_objective',
+ 'solve',
+ 'update_parameters',
+ 'update_variables',
+ 'version',
+ ]
+ method_list = [
+ method
+ for method in dir(base.PersistentSolverBase)
+ if (method.startswith('__') or method.startswith('_abc')) is False
+ ]
+ self.assertEqual(sorted(expected_list), sorted(method_list))
+
+ @unittest.mock.patch.multiple(base.PersistentSolverBase, __abstractmethods__=set())
+ def test_init(self):
+ self.instance = base.PersistentSolverBase()
+ self.assertTrue(self.instance.is_persistent())
+ self.assertEqual(self.instance.set_instance(None), None)
+ self.assertEqual(self.instance.add_variables(None), None)
+ self.assertEqual(self.instance.add_parameters(None), None)
+ self.assertEqual(self.instance.add_constraints(None), None)
+ self.assertEqual(self.instance.add_block(None), None)
+ self.assertEqual(self.instance.remove_variables(None), None)
+ self.assertEqual(self.instance.remove_parameters(None), None)
+ self.assertEqual(self.instance.remove_constraints(None), None)
+ self.assertEqual(self.instance.remove_block(None), None)
+ self.assertEqual(self.instance.set_objective(None), None)
+ self.assertEqual(self.instance.update_variables(None), None)
+ self.assertEqual(self.instance.update_parameters(), None)
+
+ with self.assertRaises(NotImplementedError):
+ self.instance._get_primals()
+
+ with self.assertRaises(NotImplementedError):
+ self.instance._get_duals()
+
+ with self.assertRaises(NotImplementedError):
+ self.instance._get_reduced_costs()
+
+ @unittest.mock.patch.multiple(base.PersistentSolverBase, __abstractmethods__=set())
+ def test_context_manager(self):
+ with base.PersistentSolverBase() as self.instance:
+ self.assertTrue(self.instance.is_persistent())
+ self.assertEqual(self.instance.set_instance(None), None)
+ self.assertEqual(self.instance.add_variables(None), None)
+ self.assertEqual(self.instance.add_parameters(None), None)
+ self.assertEqual(self.instance.add_constraints(None), None)
+ self.assertEqual(self.instance.add_block(None), None)
+ self.assertEqual(self.instance.remove_variables(None), None)
+ self.assertEqual(self.instance.remove_parameters(None), None)
+ self.assertEqual(self.instance.remove_constraints(None), None)
+ self.assertEqual(self.instance.remove_block(None), None)
+ self.assertEqual(self.instance.set_objective(None), None)
+ self.assertEqual(self.instance.update_variables(None), None)
+ self.assertEqual(self.instance.update_parameters(), None)
+
+
+class TestLegacySolverWrapper(unittest.TestCase):
+ def test_class_method_list(self):
+ expected_list = [
+ 'available',
+ 'config_block',
+ 'license_is_valid',
+ 'set_options',
+ 'solve',
+ ]
+ method_list = [
+ method
+ for method in dir(base.LegacySolverWrapper)
+ if method.startswith('_') is False
+ ]
+ self.assertEqual(sorted(expected_list), sorted(method_list))
+
+ def test_context_manager(self):
+ with base.LegacySolverWrapper() as instance:
+ with self.assertRaises(AttributeError):
+ instance.available()
+
+ def test_map_config(self):
+ # Create a fake/empty config structure that can be added to an empty
+ # instance of LegacySolverWrapper
+ self.config = ConfigDict(implicit=True)
+ self.config.declare(
+ 'solver_options',
+ ConfigDict(implicit=True, description="Options to pass to the solver."),
+ )
+ instance = base.LegacySolverWrapper()
+ instance.config = self.config
+ instance._map_config(
+ True, False, False, 20, True, False, None, None, None, False, None, None
+ )
+ self.assertTrue(instance.config.tee)
+ self.assertFalse(instance.config.load_solutions)
+ self.assertEqual(instance.config.time_limit, 20)
+ self.assertEqual(instance.config.report_timing, True)
+ # Keepfiles should not be created because we did not declare keepfiles on
+ # the original config
+ with self.assertRaises(AttributeError):
+ print(instance.config.keepfiles)
+ # We haven't implemented solver_io, suffixes, or logfile
+ with self.assertRaises(NotImplementedError):
+ instance._map_config(
+ False,
+ False,
+ False,
+ 20,
+ False,
+ False,
+ None,
+ None,
+ '/path/to/bogus/file',
+ False,
+ None,
+ None,
+ )
+ with self.assertRaises(NotImplementedError):
+ instance._map_config(
+ False,
+ False,
+ False,
+ 20,
+ False,
+ False,
+ None,
+ '/path/to/bogus/file',
+ None,
+ False,
+ None,
+ None,
+ )
+ with self.assertRaises(NotImplementedError):
+ instance._map_config(
+ False,
+ False,
+ False,
+ 20,
+ False,
+ False,
+ '/path/to/bogus/file',
+ None,
+ None,
+ False,
+ None,
+ None,
+ )
+ # If they ask for keepfiles, we redirect them to working_dir
+ instance._map_config(
+ False, False, False, 20, False, False, None, None, None, True, None, None
+ )
+ self.assertEqual(instance.config.working_dir, os.getcwd())
+ with self.assertRaises(AttributeError):
+ print(instance.config.keepfiles)
+
+ def test_solver_options_behavior(self):
+ # options can work in multiple ways (set from instantiation, set
+ # after instantiation, set during solve).
+ # Test case 1: Set at instantiation
+ solver = base.LegacySolverWrapper(options={'max_iter': 6})
+ self.assertEqual(solver.options, {'max_iter': 6})
+
+ # Test case 2: Set later
+ solver = base.LegacySolverWrapper()
+ solver.options = {'max_iter': 4, 'foo': 'bar'}
+ self.assertEqual(solver.options, {'max_iter': 4, 'foo': 'bar'})
+
+ # Test case 3: pass some options to the mapping (aka, 'solve' command)
+ solver = base.LegacySolverWrapper()
+ config = ConfigDict(implicit=True)
+ config.declare(
+ 'solver_options',
+ ConfigDict(implicit=True, description="Options to pass to the solver."),
+ )
+ solver.config = config
+ solver._map_config(options={'max_iter': 4})
+ self.assertEqual(solver.config.solver_options, {'max_iter': 4})
+
+ # Test case 4: Set at instantiation and override during 'solve' call
+ solver = base.LegacySolverWrapper(options={'max_iter': 6})
+ config = ConfigDict(implicit=True)
+ config.declare(
+ 'solver_options',
+ ConfigDict(implicit=True, description="Options to pass to the solver."),
+ )
+ solver.config = config
+ solver._map_config(options={'max_iter': 4})
+ self.assertEqual(solver.config.solver_options, {'max_iter': 4})
+ self.assertEqual(solver.options, {'max_iter': 6})
+
+ # solver_options are also supported
+ # Test case 1: set at instantiation
+ solver = base.LegacySolverWrapper(solver_options={'max_iter': 6})
+ self.assertEqual(solver.options, {'max_iter': 6})
+
+ # Test case 2: pass some solver_options to the mapping (aka, 'solve' command)
+ solver = base.LegacySolverWrapper()
+ config = ConfigDict(implicit=True)
+ config.declare(
+ 'solver_options',
+ ConfigDict(implicit=True, description="Options to pass to the solver."),
+ )
+ solver.config = config
+ solver._map_config(solver_options={'max_iter': 4})
+ self.assertEqual(solver.config.solver_options, {'max_iter': 4})
+
+ # Test case 3: Set at instantiation and override during 'solve' call
+ solver = base.LegacySolverWrapper(solver_options={'max_iter': 6})
+ config = ConfigDict(implicit=True)
+ config.declare(
+ 'solver_options',
+ ConfigDict(implicit=True, description="Options to pass to the solver."),
+ )
+ solver.config = config
+ solver._map_config(solver_options={'max_iter': 4})
+ self.assertEqual(solver.config.solver_options, {'max_iter': 4})
+ self.assertEqual(solver.options, {'max_iter': 6})
+
+ # users can mix... sort of
+ # Test case 1: Initialize with options, solve with solver_options
+ solver = base.LegacySolverWrapper(options={'max_iter': 6})
+ config = ConfigDict(implicit=True)
+ config.declare(
+ 'solver_options',
+ ConfigDict(implicit=True, description="Options to pass to the solver."),
+ )
+ solver.config = config
+ solver._map_config(solver_options={'max_iter': 4})
+ self.assertEqual(solver.config.solver_options, {'max_iter': 4})
+
+ # users CANNOT initialize both values at the same time, because how
+ # do we know what to do with it then?
+ # Test case 1: Class instance
+ with self.assertRaises(ValueError):
+ solver = base.LegacySolverWrapper(
+ options={'max_iter': 6}, solver_options={'max_iter': 4}
+ )
+ # Test case 2: Passing to `solve`
+ solver = base.LegacySolverWrapper()
+ config = ConfigDict(implicit=True)
+ config.declare(
+ 'solver_options',
+ ConfigDict(implicit=True, description="Options to pass to the solver."),
+ )
+ solver.config = config
+ with self.assertRaises(ValueError):
+ solver._map_config(solver_options={'max_iter': 4}, options={'max_iter': 6})
+
+ def test_map_results(self):
+ # Unclear how to test this
+ pass
+
+ def test_solution_handler(self):
+ # Unclear how to test this
+ pass
diff --git a/pyomo/contrib/solver/tests/unit/test_config.py b/pyomo/contrib/solver/tests/unit/test_config.py
new file mode 100644
index 00000000000..354cfd8a37a
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/test_config.py
@@ -0,0 +1,120 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.common import unittest
+from pyomo.contrib.solver.config import (
+ SolverConfig,
+ BranchAndBoundConfig,
+ AutoUpdateConfig,
+ PersistentSolverConfig,
+)
+
+
+class TestSolverConfig(unittest.TestCase):
+ def test_interface_default_instantiation(self):
+ config = SolverConfig()
+ self.assertIsNone(config._description)
+ self.assertEqual(config._visibility, 0)
+ self.assertFalse(config.tee)
+ self.assertTrue(config.load_solutions)
+ self.assertTrue(config.raise_exception_on_nonoptimal_result)
+ self.assertFalse(config.symbolic_solver_labels)
+ self.assertIsNone(config.timer)
+ self.assertIsNone(config.threads)
+ self.assertIsNone(config.time_limit)
+
+ def test_interface_custom_instantiation(self):
+ config = SolverConfig(description="A description")
+ config.tee = True
+ self.assertTrue(config.tee)
+ self.assertEqual(config._description, "A description")
+ self.assertFalse(config.time_limit)
+ config.time_limit = 1.0
+ self.assertEqual(config.time_limit, 1.0)
+ self.assertIsInstance(config.time_limit, float)
+
+
+class TestBranchAndBoundConfig(unittest.TestCase):
+ def test_interface_default_instantiation(self):
+ config = BranchAndBoundConfig()
+ self.assertIsNone(config._description)
+ self.assertEqual(config._visibility, 0)
+ self.assertFalse(config.tee)
+ self.assertTrue(config.load_solutions)
+ self.assertFalse(config.symbolic_solver_labels)
+ self.assertIsNone(config.rel_gap)
+ self.assertIsNone(config.abs_gap)
+
+ def test_interface_custom_instantiation(self):
+ config = BranchAndBoundConfig(description="A description")
+ config.tee = True
+ self.assertTrue(config.tee)
+ self.assertEqual(config._description, "A description")
+ self.assertFalse(config.time_limit)
+ config.time_limit = 1.0
+ self.assertEqual(config.time_limit, 1.0)
+ self.assertIsInstance(config.time_limit, float)
+ config.rel_gap = 2.5
+ self.assertEqual(config.rel_gap, 2.5)
+
+
+class TestAutoUpdateConfig(unittest.TestCase):
+ def test_interface_default_instantiation(self):
+ config = AutoUpdateConfig()
+ self.assertTrue(config.check_for_new_or_removed_constraints)
+ self.assertTrue(config.check_for_new_or_removed_vars)
+ self.assertTrue(config.check_for_new_or_removed_params)
+ self.assertTrue(config.check_for_new_objective)
+ self.assertTrue(config.update_constraints)
+ self.assertTrue(config.update_vars)
+ self.assertTrue(config.update_named_expressions)
+ self.assertTrue(config.update_objective)
+ self.assertTrue(config.update_objective)
+ self.assertTrue(config.treat_fixed_vars_as_params)
+
+ def test_interface_custom_instantiation(self):
+ config = AutoUpdateConfig(description="A description")
+ config.check_for_new_objective = False
+ self.assertEqual(config._description, "A description")
+ self.assertTrue(config.check_for_new_or_removed_constraints)
+ self.assertFalse(config.check_for_new_objective)
+
+
+class TestPersistentSolverConfig(unittest.TestCase):
+ def test_interface_default_instantiation(self):
+ config = PersistentSolverConfig()
+ self.assertIsNone(config._description)
+ self.assertEqual(config._visibility, 0)
+ self.assertFalse(config.tee)
+ self.assertTrue(config.load_solutions)
+ self.assertTrue(config.raise_exception_on_nonoptimal_result)
+ self.assertFalse(config.symbolic_solver_labels)
+ self.assertIsNone(config.timer)
+ self.assertIsNone(config.threads)
+ self.assertIsNone(config.time_limit)
+ self.assertTrue(config.auto_updates.check_for_new_or_removed_constraints)
+ self.assertTrue(config.auto_updates.check_for_new_or_removed_vars)
+ self.assertTrue(config.auto_updates.check_for_new_or_removed_params)
+ self.assertTrue(config.auto_updates.check_for_new_objective)
+ self.assertTrue(config.auto_updates.update_constraints)
+ self.assertTrue(config.auto_updates.update_vars)
+ self.assertTrue(config.auto_updates.update_named_expressions)
+ self.assertTrue(config.auto_updates.update_objective)
+ self.assertTrue(config.auto_updates.update_objective)
+ self.assertTrue(config.auto_updates.treat_fixed_vars_as_params)
+
+ def test_interface_custom_instantiation(self):
+ config = PersistentSolverConfig(description="A description")
+ config.tee = True
+ config.auto_updates.check_for_new_objective = False
+ self.assertTrue(config.tee)
+ self.assertEqual(config._description, "A description")
+ self.assertFalse(config.auto_updates.check_for_new_objective)
diff --git a/pyomo/contrib/solver/tests/unit/test_ipopt.py b/pyomo/contrib/solver/tests/unit/test_ipopt.py
new file mode 100644
index 00000000000..cc459245506
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/test_ipopt.py
@@ -0,0 +1,225 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 os
+
+from pyomo.common import unittest, Executable
+from pyomo.common.errors import DeveloperError
+from pyomo.common.tempfiles import TempfileManager
+from pyomo.repn.plugins.nl_writer import NLWriter
+from pyomo.contrib.solver import ipopt
+
+
+ipopt_available = ipopt.Ipopt().available()
+
+
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+class TestIpoptSolverConfig(unittest.TestCase):
+ def test_default_instantiation(self):
+ config = ipopt.IpoptConfig()
+ # Should be inherited
+ self.assertIsNone(config._description)
+ self.assertEqual(config._visibility, 0)
+ self.assertFalse(config.tee)
+ self.assertTrue(config.load_solutions)
+ self.assertTrue(config.raise_exception_on_nonoptimal_result)
+ self.assertFalse(config.symbolic_solver_labels)
+ self.assertIsNone(config.timer)
+ self.assertIsNone(config.threads)
+ self.assertIsNone(config.time_limit)
+ # Unique to this object
+ self.assertIsInstance(config.executable, type(Executable('path')))
+ self.assertIsInstance(config.writer_config, type(NLWriter.CONFIG()))
+
+ def test_custom_instantiation(self):
+ config = ipopt.IpoptConfig(description="A description")
+ config.tee = True
+ self.assertTrue(config.tee)
+ self.assertEqual(config._description, "A description")
+ self.assertIsNone(config.time_limit)
+ # Default should be `ipopt`
+ self.assertIsNotNone(str(config.executable))
+ self.assertIn('ipopt', str(config.executable))
+ # Set to a totally bogus path
+ config.executable = Executable('/bogus/path')
+ self.assertIsNone(config.executable.executable)
+ self.assertFalse(config.executable.available())
+
+
+class TestIpoptSolutionLoader(unittest.TestCase):
+ def test_get_reduced_costs_error(self):
+ loader = ipopt.IpoptSolutionLoader(None, None)
+ with self.assertRaises(RuntimeError):
+ loader.get_reduced_costs()
+
+ # Set _nl_info to something completely bogus but is not None
+ class NLInfo:
+ pass
+
+ loader._nl_info = NLInfo()
+ loader._nl_info.eliminated_vars = [1, 2, 3]
+ with self.assertRaises(NotImplementedError):
+ loader.get_reduced_costs()
+ # Reset _nl_info so we can ensure we get an error
+ # when _sol_data is None
+ loader._nl_info.eliminated_vars = []
+ with self.assertRaises(DeveloperError):
+ loader.get_reduced_costs()
+
+
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+class TestIpoptInterface(unittest.TestCase):
+ def test_class_member_list(self):
+ opt = ipopt.Ipopt()
+ expected_list = [
+ 'Availability',
+ 'CONFIG',
+ 'config',
+ 'available',
+ 'is_persistent',
+ 'solve',
+ 'version',
+ 'name',
+ ]
+ method_list = [method for method in dir(opt) if method.startswith('_') is False]
+ self.assertEqual(sorted(expected_list), sorted(method_list))
+
+ def test_default_instantiation(self):
+ opt = ipopt.Ipopt()
+ self.assertFalse(opt.is_persistent())
+ self.assertIsNotNone(opt.version())
+ self.assertEqual(opt.name, 'ipopt')
+ self.assertEqual(opt.CONFIG, opt.config)
+ self.assertTrue(opt.available())
+
+ def test_context_manager(self):
+ with ipopt.Ipopt() as opt:
+ self.assertFalse(opt.is_persistent())
+ self.assertIsNotNone(opt.version())
+ self.assertEqual(opt.name, 'ipopt')
+ self.assertEqual(opt.CONFIG, opt.config)
+ self.assertTrue(opt.available())
+
+ def test_available_cache(self):
+ opt = ipopt.Ipopt()
+ opt.available()
+ self.assertTrue(opt._available_cache[1])
+ self.assertIsNotNone(opt._available_cache[0])
+ # Now we will try with a custom config that has a fake path
+ config = ipopt.IpoptConfig()
+ config.executable = Executable('/a/bogus/path')
+ opt.available(config=config)
+ self.assertFalse(opt._available_cache[1])
+ self.assertIsNone(opt._available_cache[0])
+
+ def test_version_cache(self):
+ opt = ipopt.Ipopt()
+ opt.version()
+ self.assertIsNotNone(opt._version_cache[0])
+ self.assertIsNotNone(opt._version_cache[1])
+ # Now we will try with a custom config that has a fake path
+ config = ipopt.IpoptConfig()
+ config.executable = Executable('/a/bogus/path')
+ opt.version(config=config)
+ self.assertIsNone(opt._version_cache[0])
+ self.assertIsNone(opt._version_cache[1])
+
+ def test_write_options_file(self):
+ # If we have no options, we should get false back
+ opt = ipopt.Ipopt()
+ result = opt._write_options_file('fakename', None)
+ self.assertFalse(result)
+ # Pass it some options that ARE on the command line
+ opt = ipopt.Ipopt(solver_options={'max_iter': 4})
+ result = opt._write_options_file('myfile', opt.config.solver_options)
+ self.assertFalse(result)
+ self.assertFalse(os.path.isfile('myfile.opt'))
+ # Now we are going to actually pass it some options that are NOT on
+ # the command line
+ opt = ipopt.Ipopt(solver_options={'custom_option': 4})
+ with TempfileManager.new_context() as temp:
+ dname = temp.mkdtemp()
+ if not os.path.exists(dname):
+ os.mkdir(dname)
+ filename = os.path.join(dname, 'myfile')
+ result = opt._write_options_file(filename, opt.config.solver_options)
+ self.assertTrue(result)
+ self.assertTrue(os.path.isfile(filename + '.opt'))
+ # Make sure all options are writing to the file
+ opt = ipopt.Ipopt(solver_options={'custom_option_1': 4, 'custom_option_2': 3})
+ with TempfileManager.new_context() as temp:
+ dname = temp.mkdtemp()
+ if not os.path.exists(dname):
+ os.mkdir(dname)
+ filename = os.path.join(dname, 'myfile')
+ result = opt._write_options_file(filename, opt.config.solver_options)
+ self.assertTrue(result)
+ self.assertTrue(os.path.isfile(filename + '.opt'))
+ with open(filename + '.opt', 'r') as f:
+ data = f.readlines()
+ self.assertEqual(len(data), len(list(opt.config.solver_options.keys())))
+
+ def test_create_command_line(self):
+ opt = ipopt.Ipopt()
+ # No custom options, no file created. Plain and simple.
+ result = opt._create_command_line('myfile', opt.config, False)
+ self.assertEqual(result, [str(opt.config.executable), 'myfile.nl', '-AMPL'])
+ # Custom command line options
+ opt = ipopt.Ipopt(solver_options={'max_iter': 4})
+ result = opt._create_command_line('myfile', opt.config, False)
+ self.assertEqual(
+ result, [str(opt.config.executable), 'myfile.nl', '-AMPL', 'max_iter=4']
+ )
+ # Let's see if we correctly parse config.time_limit
+ opt = ipopt.Ipopt(solver_options={'max_iter': 4}, time_limit=10)
+ result = opt._create_command_line('myfile', opt.config, False)
+ self.assertEqual(
+ result,
+ [
+ str(opt.config.executable),
+ 'myfile.nl',
+ '-AMPL',
+ 'max_iter=4',
+ 'max_cpu_time=10.0',
+ ],
+ )
+ # Now let's do multiple command line options
+ opt = ipopt.Ipopt(solver_options={'max_iter': 4, 'max_cpu_time': 10})
+ result = opt._create_command_line('myfile', opt.config, False)
+ self.assertEqual(
+ result,
+ [
+ str(opt.config.executable),
+ 'myfile.nl',
+ '-AMPL',
+ 'max_cpu_time=10',
+ 'max_iter=4',
+ ],
+ )
+ # Let's now include if we "have" an options file
+ result = opt._create_command_line('myfile', opt.config, True)
+ self.assertEqual(
+ result,
+ [
+ str(opt.config.executable),
+ 'myfile.nl',
+ '-AMPL',
+ 'option_file_name=myfile.opt',
+ 'max_cpu_time=10',
+ 'max_iter=4',
+ ],
+ )
+ # Finally, let's make sure it errors if someone tries to pass option_file_name
+ opt = ipopt.Ipopt(
+ solver_options={'max_iter': 4, 'option_file_name': 'myfile.opt'}
+ )
+ with self.assertRaises(ValueError):
+ result = opt._create_command_line('myfile', opt.config, False)
diff --git a/pyomo/contrib/solver/tests/unit/test_results.py b/pyomo/contrib/solver/tests/unit/test_results.py
new file mode 100644
index 00000000000..a15c9b87253
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/test_results.py
@@ -0,0 +1,261 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from io import StringIO
+from typing import Sequence, Dict, Optional, Mapping, MutableMapping
+
+
+from pyomo.common import unittest
+from pyomo.common.config import ConfigDict
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.var import VarData
+from pyomo.common.collections import ComponentMap
+from pyomo.contrib.solver import results
+from pyomo.contrib.solver import solution
+import pyomo.environ as pyo
+from pyomo.core.base.var import Var
+
+
+class SolutionLoaderExample(solution.SolutionLoaderBase):
+ """
+ This is an example instantiation of a SolutionLoader that is used for
+ testing generated results.
+ """
+
+ def __init__(
+ self,
+ primals: Optional[MutableMapping],
+ duals: Optional[MutableMapping],
+ reduced_costs: Optional[MutableMapping],
+ ):
+ """
+ Parameters
+ ----------
+ primals: dict
+ maps id(Var) to (var, value)
+ duals: dict
+ maps Constraint to dual value
+ reduced_costs: dict
+ maps id(Var) to (var, reduced_cost)
+ """
+ self._primals = primals
+ self._duals = duals
+ self._reduced_costs = reduced_costs
+
+ def get_primals(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ if self._primals is None:
+ raise RuntimeError(
+ 'Solution loader does not currently have a valid solution. Please '
+ 'check the termination condition.'
+ )
+ if vars_to_load is None:
+ return ComponentMap(self._primals.values())
+ else:
+ primals = ComponentMap()
+ for v in vars_to_load:
+ primals[v] = self._primals[id(v)][1]
+ return primals
+
+ def get_duals(
+ self, cons_to_load: Optional[Sequence[ConstraintData]] = None
+ ) -> Dict[ConstraintData, float]:
+ if self._duals is None:
+ raise RuntimeError(
+ 'Solution loader does not currently have valid duals. Please '
+ 'check the termination condition and ensure the solver returns duals '
+ 'for the given problem type.'
+ )
+ if cons_to_load is None:
+ duals = dict(self._duals)
+ else:
+ duals = {}
+ for c in cons_to_load:
+ duals[c] = self._duals[c]
+ return duals
+
+ def get_reduced_costs(
+ self, vars_to_load: Optional[Sequence[VarData]] = None
+ ) -> Mapping[VarData, float]:
+ if self._reduced_costs is None:
+ raise RuntimeError(
+ 'Solution loader does not currently have valid reduced costs. Please '
+ 'check the termination condition and ensure the solver returns reduced '
+ 'costs for the given problem type.'
+ )
+ if vars_to_load is None:
+ rc = ComponentMap(self._reduced_costs.values())
+ else:
+ rc = ComponentMap()
+ for v in vars_to_load:
+ rc[v] = self._reduced_costs[id(v)][1]
+ return rc
+
+
+class TestTerminationCondition(unittest.TestCase):
+ def test_member_list(self):
+ member_list = results.TerminationCondition._member_names_
+ expected_list = [
+ 'unknown',
+ 'convergenceCriteriaSatisfied',
+ 'maxTimeLimit',
+ 'iterationLimit',
+ 'objectiveLimit',
+ 'minStepLength',
+ 'unbounded',
+ 'provenInfeasible',
+ 'locallyInfeasible',
+ 'infeasibleOrUnbounded',
+ 'error',
+ 'interrupted',
+ 'licensingProblems',
+ ]
+ self.assertEqual(member_list.sort(), expected_list.sort())
+
+ def test_codes(self):
+ self.assertEqual(results.TerminationCondition.unknown.value, 42)
+ self.assertEqual(
+ results.TerminationCondition.convergenceCriteriaSatisfied.value, 0
+ )
+ self.assertEqual(results.TerminationCondition.maxTimeLimit.value, 1)
+ self.assertEqual(results.TerminationCondition.iterationLimit.value, 2)
+ self.assertEqual(results.TerminationCondition.objectiveLimit.value, 3)
+ self.assertEqual(results.TerminationCondition.minStepLength.value, 4)
+ self.assertEqual(results.TerminationCondition.unbounded.value, 5)
+ self.assertEqual(results.TerminationCondition.provenInfeasible.value, 6)
+ self.assertEqual(results.TerminationCondition.locallyInfeasible.value, 7)
+ self.assertEqual(results.TerminationCondition.infeasibleOrUnbounded.value, 8)
+ self.assertEqual(results.TerminationCondition.error.value, 9)
+ self.assertEqual(results.TerminationCondition.interrupted.value, 10)
+ self.assertEqual(results.TerminationCondition.licensingProblems.value, 11)
+
+
+class TestSolutionStatus(unittest.TestCase):
+ def test_member_list(self):
+ member_list = results.SolutionStatus._member_names_
+ expected_list = ['noSolution', 'infeasible', 'feasible', 'optimal']
+ self.assertEqual(member_list, expected_list)
+
+ def test_codes(self):
+ self.assertEqual(results.SolutionStatus.noSolution.value, 0)
+ self.assertEqual(results.SolutionStatus.infeasible.value, 10)
+ self.assertEqual(results.SolutionStatus.feasible.value, 20)
+ self.assertEqual(results.SolutionStatus.optimal.value, 30)
+
+
+class TestResults(unittest.TestCase):
+ def test_member_list(self):
+ res = results.Results()
+ expected_declared = {
+ 'extra_info',
+ 'incumbent_objective',
+ 'iteration_count',
+ 'objective_bound',
+ 'solution_loader',
+ 'solution_status',
+ 'solver_name',
+ 'solver_version',
+ 'termination_condition',
+ 'timing_info',
+ 'solver_log',
+ 'solver_configuration',
+ }
+ actual_declared = res._declared
+ self.assertEqual(expected_declared, actual_declared)
+
+ def test_default_initialization(self):
+ res = results.Results()
+ self.assertIsNone(res.solution_loader)
+ self.assertIsNone(res.incumbent_objective)
+ self.assertIsNone(res.objective_bound)
+ self.assertEqual(
+ res.termination_condition, results.TerminationCondition.unknown
+ )
+ self.assertEqual(res.solution_status, results.SolutionStatus.noSolution)
+ self.assertIsNone(res.solver_name)
+ self.assertIsNone(res.solver_version)
+ self.assertIsNone(res.iteration_count)
+ self.assertIsInstance(res.timing_info, ConfigDict)
+ self.assertIsInstance(res.extra_info, ConfigDict)
+ self.assertIsNone(res.timing_info.start_timestamp)
+ self.assertIsNone(res.timing_info.wall_time)
+
+ def test_display(self):
+ res = results.Results()
+ stream = StringIO()
+ res.display(ostream=stream)
+ expected_print = """solution_loader: None
+termination_condition: TerminationCondition.unknown
+solution_status: SolutionStatus.noSolution
+incumbent_objective: None
+objective_bound: None
+solver_name: None
+solver_version: None
+iteration_count: None
+timing_info:
+ start_timestamp: None
+ wall_time: None
+extra_info:
+"""
+ out = stream.getvalue()
+ if 'null' in out:
+ out = out.replace('null', 'None')
+ self.assertEqual(expected_print, out)
+
+ def test_generated_results(self):
+ m = pyo.ConcreteModel()
+ m.x = Var()
+ m.y = Var()
+ m.c1 = pyo.Constraint(expr=m.x == 1)
+ m.c2 = pyo.Constraint(expr=m.y == 2)
+
+ primals = {}
+ primals[id(m.x)] = (m.x, 1)
+ primals[id(m.y)] = (m.y, 2)
+ duals = {}
+ duals[m.c1] = 3
+ duals[m.c2] = 4
+ rc = {}
+ rc[id(m.x)] = (m.x, 5)
+ rc[id(m.y)] = (m.y, 6)
+
+ res = results.Results()
+ res.solution_loader = SolutionLoaderExample(
+ primals=primals, duals=duals, reduced_costs=rc
+ )
+
+ res.solution_loader.load_vars()
+ self.assertAlmostEqual(m.x.value, 1)
+ self.assertAlmostEqual(m.y.value, 2)
+
+ m.x.value = None
+ m.y.value = None
+
+ res.solution_loader.load_vars([m.y])
+ self.assertIsNone(m.x.value)
+ self.assertAlmostEqual(m.y.value, 2)
+
+ duals2 = res.solution_loader.get_duals()
+ self.assertAlmostEqual(duals[m.c1], duals2[m.c1])
+ self.assertAlmostEqual(duals[m.c2], duals2[m.c2])
+
+ duals2 = res.solution_loader.get_duals([m.c2])
+ self.assertNotIn(m.c1, duals2)
+ self.assertAlmostEqual(duals[m.c2], duals2[m.c2])
+
+ rc2 = res.solution_loader.get_reduced_costs()
+ self.assertAlmostEqual(rc[id(m.x)][1], rc2[m.x])
+ self.assertAlmostEqual(rc[id(m.y)][1], rc2[m.y])
+
+ rc2 = res.solution_loader.get_reduced_costs([m.y])
+ self.assertNotIn(m.x, rc2)
+ self.assertAlmostEqual(rc[id(m.y)][1], rc2[m.y])
diff --git a/pyomo/contrib/solver/tests/unit/test_sol_reader.py b/pyomo/contrib/solver/tests/unit/test_sol_reader.py
new file mode 100644
index 00000000000..d5602945e07
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/test_sol_reader.py
@@ -0,0 +1,51 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.common import unittest
+from pyomo.common.fileutils import this_file_dir
+from pyomo.common.tempfiles import TempfileManager
+from pyomo.contrib.solver.sol_reader import parse_sol_file, SolFileData
+
+currdir = this_file_dir()
+
+
+class TestSolFileData(unittest.TestCase):
+ def test_default_instantiation(self):
+ instance = SolFileData()
+ self.assertIsInstance(instance.primals, list)
+ self.assertIsInstance(instance.duals, list)
+ self.assertIsInstance(instance.var_suffixes, dict)
+ self.assertIsInstance(instance.con_suffixes, dict)
+ self.assertIsInstance(instance.obj_suffixes, dict)
+ self.assertIsInstance(instance.problem_suffixes, dict)
+ self.assertIsInstance(instance.other, list)
+
+
+class TestSolParser(unittest.TestCase):
+ # I am not sure how to write these tests best since the sol parser requires
+ # not only a file but also the nl_info and results objects.
+ def setUp(self):
+ TempfileManager.push()
+
+ def tearDown(self):
+ TempfileManager.pop(remove=True)
+
+ def test_default_behavior(self):
+ pass
+
+ def test_custom_behavior(self):
+ pass
+
+ def test_infeasible1(self):
+ pass
+
+ def test_infeasible2(self):
+ pass
diff --git a/pyomo/contrib/solver/tests/unit/test_solution.py b/pyomo/contrib/solver/tests/unit/test_solution.py
new file mode 100644
index 00000000000..a5ee8a9e391
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/test_solution.py
@@ -0,0 +1,88 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.common import unittest
+from pyomo.contrib.solver.solution import SolutionLoaderBase, PersistentSolutionLoader
+
+
+class TestSolutionLoaderBase(unittest.TestCase):
+ def test_abstract_member_list(self):
+ expected_list = ['get_primals']
+ member_list = list(SolutionLoaderBase.__abstractmethods__)
+ self.assertEqual(sorted(expected_list), sorted(member_list))
+
+ def test_member_list(self):
+ expected_list = ['load_vars', 'get_primals', 'get_duals', 'get_reduced_costs']
+ method_list = [
+ method
+ for method in dir(SolutionLoaderBase)
+ if method.startswith('_') is False
+ ]
+ self.assertEqual(sorted(expected_list), sorted(method_list))
+
+ @unittest.mock.patch.multiple(SolutionLoaderBase, __abstractmethods__=set())
+ def test_solution_loader_base(self):
+ self.instance = SolutionLoaderBase()
+ self.assertEqual(self.instance.get_primals(), None)
+ with self.assertRaises(NotImplementedError):
+ self.instance.get_duals()
+ with self.assertRaises(NotImplementedError):
+ self.instance.get_reduced_costs()
+
+
+class TestSolSolutionLoader(unittest.TestCase):
+ # I am currently unsure how to test this further because it relies heavily on
+ # SolFileData and NLWriterInfo
+ def test_member_list(self):
+ expected_list = ['load_vars', 'get_primals', 'get_duals', 'get_reduced_costs']
+ method_list = [
+ method
+ for method in dir(SolutionLoaderBase)
+ if method.startswith('_') is False
+ ]
+ self.assertEqual(sorted(expected_list), sorted(method_list))
+
+
+class TestPersistentSolutionLoader(unittest.TestCase):
+ def test_abstract_member_list(self):
+ # We expect no abstract members at this point because it's a real-life
+ # instantiation of SolutionLoaderBase
+ member_list = list(PersistentSolutionLoader('ipopt').__abstractmethods__)
+ self.assertEqual(member_list, [])
+
+ def test_member_list(self):
+ expected_list = [
+ 'load_vars',
+ 'get_primals',
+ 'get_duals',
+ 'get_reduced_costs',
+ 'invalidate',
+ ]
+ method_list = [
+ method
+ for method in dir(PersistentSolutionLoader)
+ if method.startswith('_') is False
+ ]
+ self.assertEqual(sorted(expected_list), sorted(method_list))
+
+ def test_default_initialization(self):
+ # Realistically, a solver object should be passed into this.
+ # However, it works with a string. It'll just error loudly if you
+ # try to run get_primals, etc.
+ self.instance = PersistentSolutionLoader('ipopt')
+ self.assertTrue(self.instance._valid)
+ self.assertEqual(self.instance._solver, 'ipopt')
+
+ def test_invalid(self):
+ self.instance = PersistentSolutionLoader('ipopt')
+ self.instance.invalidate()
+ with self.assertRaises(RuntimeError):
+ self.instance.get_primals()
diff --git a/pyomo/contrib/solver/tests/unit/test_util.py b/pyomo/contrib/solver/tests/unit/test_util.py
new file mode 100644
index 00000000000..f2e8ee707f4
--- /dev/null
+++ b/pyomo/contrib/solver/tests/unit/test_util.py
@@ -0,0 +1,142 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.common import unittest
+import pyomo.environ as pyo
+from pyomo.contrib.solver.util import (
+ collect_vars_and_named_exprs,
+ get_objective,
+ check_optimal_termination,
+ assert_optimal_termination,
+ SolverStatus,
+ LegacyTerminationCondition,
+)
+from pyomo.contrib.solver.results import Results, SolutionStatus, TerminationCondition
+from typing import Callable
+from pyomo.common.gsl import find_GSL
+from pyomo.opt.results import SolverResults
+
+
+class TestGenericUtils(unittest.TestCase):
+ def basics_helper(self, collector: Callable, *args):
+ m = pyo.ConcreteModel()
+ m.x = pyo.Var()
+ m.y = pyo.Var()
+ m.z = pyo.Var()
+ m.E = pyo.Expression(expr=2 * m.z + 1)
+ m.y.fix(3)
+ e = m.x * m.y + m.x * m.E
+ named_exprs, var_list, fixed_vars, external_funcs = collector(e, *args)
+ self.assertEqual([m.E], named_exprs)
+ self.assertEqual([m.x, m.y, m.z], var_list)
+ self.assertEqual([m.y], fixed_vars)
+ self.assertEqual([], external_funcs)
+
+ def test_collect_vars_basics(self):
+ self.basics_helper(collect_vars_and_named_exprs)
+
+ def external_func_helper(self, collector: Callable, *args):
+ DLL = find_GSL()
+ if not DLL:
+ self.skipTest('Could not find amplgsl.dll library')
+
+ m = pyo.ConcreteModel()
+ m.x = pyo.Var()
+ m.y = pyo.Var()
+ m.z = pyo.Var()
+ m.hypot = pyo.ExternalFunction(library=DLL, function='gsl_hypot')
+ func = m.hypot(m.x, m.x * m.y)
+ m.E = pyo.Expression(expr=2 * func)
+ m.y.fix(3)
+ e = m.z + m.x * m.E
+ named_exprs, var_list, fixed_vars, external_funcs = collector(e, *args)
+ self.assertEqual([m.E], named_exprs)
+ self.assertEqual([m.z, m.x, m.y], var_list)
+ self.assertEqual([m.y], fixed_vars)
+ self.assertEqual([func], external_funcs)
+
+ def test_collect_vars_external(self):
+ self.external_func_helper(collect_vars_and_named_exprs)
+
+ def simple_model(self):
+ model = pyo.ConcreteModel()
+ model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
+ model.OBJ = pyo.Objective(expr=2 * model.x[1] + 3 * model.x[2])
+ model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
+ return model
+
+ def test_get_objective_success(self):
+ model = self.simple_model()
+ self.assertEqual(model.OBJ, get_objective(model))
+
+ def test_get_objective_raise(self):
+ model = self.simple_model()
+ model.OBJ2 = pyo.Objective(expr=model.x[1] - 4 * model.x[2])
+ with self.assertRaises(ValueError):
+ get_objective(model)
+
+ def test_check_optimal_termination_new_interface(self):
+ results = Results()
+ results.solution_status = SolutionStatus.optimal
+ results.termination_condition = (
+ TerminationCondition.convergenceCriteriaSatisfied
+ )
+ # Both items satisfied
+ self.assertTrue(check_optimal_termination(results))
+ # Termination condition not satisfied
+ results.termination_condition = TerminationCondition.iterationLimit
+ self.assertFalse(check_optimal_termination(results))
+ # Both not satisfied
+ results.solution_status = SolutionStatus.noSolution
+ self.assertFalse(check_optimal_termination(results))
+
+ def test_check_optimal_termination_condition_legacy_interface(self):
+ results = SolverResults()
+ results.solver.status = SolverStatus.ok
+ results.solver.termination_condition = LegacyTerminationCondition.optimal
+ # Both items satisfied
+ self.assertTrue(check_optimal_termination(results))
+ # Termination condition not satisfied
+ results.solver.termination_condition = LegacyTerminationCondition.unknown
+ self.assertFalse(check_optimal_termination(results))
+ # Both not satisfied
+ results.solver.termination_condition = SolverStatus.aborted
+ self.assertFalse(check_optimal_termination(results))
+
+ def test_assert_optimal_termination_new_interface(self):
+ results = Results()
+ results.solution_status = SolutionStatus.optimal
+ results.termination_condition = (
+ TerminationCondition.convergenceCriteriaSatisfied
+ )
+ assert_optimal_termination(results)
+ # Termination condition not satisfied
+ results.termination_condition = TerminationCondition.iterationLimit
+ with self.assertRaises(RuntimeError):
+ assert_optimal_termination(results)
+ # Both not satisfied
+ results.solution_status = SolutionStatus.noSolution
+ with self.assertRaises(RuntimeError):
+ assert_optimal_termination(results)
+
+ def test_assert_optimal_termination_legacy_interface(self):
+ results = SolverResults()
+ results.solver.status = SolverStatus.ok
+ results.solver.termination_condition = LegacyTerminationCondition.optimal
+ assert_optimal_termination(results)
+ # Termination condition not satisfied
+ results.solver.termination_condition = LegacyTerminationCondition.unknown
+ with self.assertRaises(RuntimeError):
+ assert_optimal_termination(results)
+ # Both not satisfied
+ results.solver.termination_condition = SolverStatus.aborted
+ with self.assertRaises(RuntimeError):
+ assert_optimal_termination(results)
diff --git a/pyomo/contrib/solver/util.py b/pyomo/contrib/solver/util.py
new file mode 100644
index 00000000000..c6bbfbd22ad
--- /dev/null
+++ b/pyomo/contrib/solver/util.py
@@ -0,0 +1,143 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+from pyomo.core.expr.visitor import ExpressionValueVisitor, nonpyomo_leaf_types
+import pyomo.core.expr as EXPR
+from pyomo.core.base.objective import Objective
+from pyomo.opt.results.solver import (
+ SolverStatus,
+ TerminationCondition as LegacyTerminationCondition,
+)
+
+
+from pyomo.contrib.solver.results import TerminationCondition, SolutionStatus
+
+
+def get_objective(block):
+ """
+ Get current active objective on a block. If there is more than one active,
+ return an error.
+ """
+ obj = None
+ for o in block.component_data_objects(
+ Objective, descend_into=True, active=True, sort=True
+ ):
+ if obj is not None:
+ raise ValueError('Multiple active objectives found')
+ obj = o
+ return obj
+
+
+def check_optimal_termination(results):
+ """
+ This function returns True if the termination condition for the solver
+ is 'optimal'.
+
+ Parameters
+ ----------
+ results : Pyomo Results object returned from solver.solve
+
+ Returns
+ -------
+ `bool`
+ """
+ if hasattr(results, 'solution_status'):
+ if results.solution_status == SolutionStatus.optimal and (
+ results.termination_condition
+ == TerminationCondition.convergenceCriteriaSatisfied
+ ):
+ return True
+ else:
+ if results.solver.status == SolverStatus.ok and (
+ results.solver.termination_condition == LegacyTerminationCondition.optimal
+ or results.solver.termination_condition
+ == LegacyTerminationCondition.locallyOptimal
+ or results.solver.termination_condition
+ == LegacyTerminationCondition.globallyOptimal
+ ):
+ return True
+ return False
+
+
+def assert_optimal_termination(results):
+ """
+ This function checks if the termination condition for the solver
+ is 'optimal', 'locallyOptimal', or 'globallyOptimal', and the status is 'ok'
+ and it raises a RuntimeError exception if this is not true.
+
+ Parameters
+ ----------
+ results : Pyomo Results object returned from solver.solve
+ """
+ if not check_optimal_termination(results):
+ if hasattr(results, 'solution_status'):
+ msg = (
+ 'Solver failed to return an optimal solution. '
+ 'Solution status: {}, Termination condition: {}'.format(
+ results.solution_status, results.termination_condition
+ )
+ )
+ else:
+ msg = (
+ 'Solver failed to return an optimal solution. '
+ 'Solver status: {}, Termination condition: {}'.format(
+ results.solver.status, results.solver.termination_condition
+ )
+ )
+ raise RuntimeError(msg)
+
+
+class _VarAndNamedExprCollector(ExpressionValueVisitor):
+ def __init__(self):
+ self.named_expressions = {}
+ self.variables = {}
+ self.fixed_vars = {}
+ self._external_functions = {}
+
+ def visit(self, node, values):
+ pass
+
+ def visiting_potential_leaf(self, node):
+ if type(node) in nonpyomo_leaf_types:
+ return True, None
+
+ if node.is_variable_type():
+ self.variables[id(node)] = node
+ if node.is_fixed():
+ self.fixed_vars[id(node)] = node
+ return True, None
+
+ if node.is_named_expression_type():
+ self.named_expressions[id(node)] = node
+ return False, None
+
+ if type(node) is EXPR.ExternalFunctionExpression:
+ self._external_functions[id(node)] = node
+ return False, None
+
+ if node.is_expression_type():
+ return False, None
+
+ return True, None
+
+
+_visitor = _VarAndNamedExprCollector()
+
+
+def collect_vars_and_named_exprs(expr):
+ _visitor.__init__()
+ _visitor.dfs_postorder_stack(expr)
+ return (
+ list(_visitor.named_expressions.values()),
+ list(_visitor.variables.values()),
+ list(_visitor.fixed_vars.values()),
+ list(_visitor._external_functions.values()),
+ )
diff --git a/pyomo/contrib/trustregion/TRF.py b/pyomo/contrib/trustregion/TRF.py
index 6d2cf863d69..ea3a8c746a4 100644
--- a/pyomo/contrib/trustregion/TRF.py
+++ b/pyomo/contrib/trustregion/TRF.py
@@ -35,7 +35,7 @@
logger = logging.getLogger('pyomo.contrib.trustregion')
-__version__ = '0.2.0'
+__version__ = (0, 2, 0)
def trust_region_method(model, decision_variables, ext_fcn_surrogate_map_rule, config):
diff --git a/pyomo/contrib/trustregion/tests/test_interface.py b/pyomo/contrib/trustregion/tests/test_interface.py
index 148caceddd1..0922ccf950b 100644
--- a/pyomo/contrib/trustregion/tests/test_interface.py
+++ b/pyomo/contrib/trustregion/tests/test_interface.py
@@ -33,7 +33,7 @@
cos,
SolverFactory,
)
-from pyomo.core.base.var import _GeneralVarData
+from pyomo.core.base.var import VarData
from pyomo.core.expr.numeric_expr import ExternalFunctionExpression
from pyomo.core.expr.visitor import identify_variables
from pyomo.contrib.trustregion.interface import TRFInterface
@@ -158,7 +158,7 @@ def test_replaceExternalFunctionsWithVariables(self):
self.assertIsInstance(k, ExternalFunctionExpression)
self.assertIn(str(self.interface.model.x[0]), str(k))
self.assertIn(str(self.interface.model.x[1]), str(k))
- self.assertIsInstance(i, _GeneralVarData)
+ self.assertIsInstance(i, VarData)
self.assertEqual(i, self.interface.data.ef_outputs[1])
for i, k in self.interface.data.basis_expressions.items():
self.assertEqual(k, 0)
diff --git a/pyomo/contrib/viewer/model_browser.py b/pyomo/contrib/viewer/model_browser.py
index 5887a577ba0..91dc946c55d 100644
--- a/pyomo/contrib/viewer/model_browser.py
+++ b/pyomo/contrib/viewer/model_browser.py
@@ -33,7 +33,7 @@
import pyomo.contrib.viewer.qt as myqt
from pyomo.contrib.viewer.report import value_no_exception, get_residual
-from pyomo.core.base.param import _ParamData
+from pyomo.core.base.param import ParamData
from pyomo.environ import (
Block,
BooleanVar,
@@ -243,7 +243,7 @@ def _get_expr_callback(self):
return None
def _get_value_callback(self):
- if isinstance(self.data, _ParamData):
+ if isinstance(self.data, ParamData):
v = value_no_exception(self.data, div0="divide_by_0")
# Check the param value for numpy float and int, sometimes numpy
# values can sneak in especially if you set parameters from data
@@ -295,7 +295,7 @@ def _get_residual_callback(self):
def _get_units_callback(self):
if isinstance(self.data, (Var, Var._ComponentDataClass)):
return str(units.get_units(self.data))
- if isinstance(self.data, (Param, _ParamData)):
+ if isinstance(self.data, (Param, ParamData)):
return str(units.get_units(self.data))
return self._cache_units
@@ -320,7 +320,7 @@ def _set_value_callback(self, val):
o.value = val
except:
return
- elif isinstance(self.data, _ParamData):
+ elif isinstance(self.data, ParamData):
if not self.data.parent_component().mutable:
return
try:
diff --git a/pyomo/contrib/viewer/report.py b/pyomo/contrib/viewer/report.py
index f83a53c608d..a28e0082212 100644
--- a/pyomo/contrib/viewer/report.py
+++ b/pyomo/contrib/viewer/report.py
@@ -50,7 +50,7 @@ def get_residual(ui_data, c):
values of the constraint body. This function uses the cached values
and will not trigger recalculation. If variable values have changed,
this may not yield accurate results.
- c(_ConstraintData): a constraint or constraint data
+ c(ConstraintData): a constraint or constraint data
Returns:
(float) residual
"""
@@ -149,7 +149,7 @@ def degrees_of_freedom(blk):
Return the degrees of freedom.
Args:
- blk (Block or _BlockData): Block to count degrees of freedom in
+ blk (Block or BlockData): Block to count degrees of freedom in
Returns:
(int): Number of degrees of freedom
"""
diff --git a/pyomo/contrib/viewer/tests/test_data_model_item.py b/pyomo/contrib/viewer/tests/test_data_model_item.py
index 781ca25508a..d780b315044 100644
--- a/pyomo/contrib/viewer/tests/test_data_model_item.py
+++ b/pyomo/contrib/viewer/tests/test_data_model_item.py
@@ -46,15 +46,10 @@
from pyomo.contrib.viewer.model_browser import ComponentDataItem
from pyomo.contrib.viewer.ui_data import UIData
from pyomo.common.dependencies import DeferredImportError
+from pyomo.core.base.units_container import pint_available
-try:
- x = pyo.units.m
- units_available = True
-except DeferredImportError:
- units_available = False
-
-@unittest.skipIf(not units_available, "Pyomo units are not available")
+@unittest.skipIf(not pint_available, "Pyomo units are not available")
class TestDataModelItem(unittest.TestCase):
def setUp(self):
# Borrowed this test model from the trust region tests
diff --git a/pyomo/contrib/viewer/tests/test_data_model_tree.py b/pyomo/contrib/viewer/tests/test_data_model_tree.py
index d517c91b353..2e5c3592198 100644
--- a/pyomo/contrib/viewer/tests/test_data_model_tree.py
+++ b/pyomo/contrib/viewer/tests/test_data_model_tree.py
@@ -42,12 +42,7 @@
from pyomo.contrib.viewer.model_browser import ComponentDataModel
import pyomo.contrib.viewer.qt as myqt
from pyomo.common.dependencies import DeferredImportError
-
-try:
- _x = pyo.units.m
- units_available = True
-except DeferredImportError:
- units_available = False
+from pyomo.core.base.units_container import pint_available
available = myqt.available
@@ -63,7 +58,7 @@ def __init__(*args, **kwargs):
pass
-@unittest.skipIf(not available or not units_available, "PyQt or units not available")
+@unittest.skipIf(not available or not pint_available, "PyQt or units not available")
class TestDataModel(unittest.TestCase):
def setUp(self):
# Borrowed this test model from the trust region tests
diff --git a/pyomo/core/__init__.py b/pyomo/core/__init__.py
index bce79faacc5..f0d168d98f9 100644
--- a/pyomo/core/__init__.py
+++ b/pyomo/core/__init__.py
@@ -101,7 +101,7 @@
BooleanValue,
native_logical_values,
)
-from pyomo.core.kernel.objective import minimize, maximize
+from pyomo.core.base import minimize, maximize
from pyomo.core.base.config import PyomoOptions
from pyomo.core.base.expression import Expression
diff --git a/pyomo/core/base/PyomoModel.py b/pyomo/core/base/PyomoModel.py
index ba7823c642a..22bbc5fa02b 100644
--- a/pyomo/core/base/PyomoModel.py
+++ b/pyomo/core/base/PyomoModel.py
@@ -786,7 +786,7 @@ def _load_model_data(self, modeldata, namespaces, **kwds):
profile_memory = kwds.get('profile_memory', 0)
if profile_memory >= 2 and pympler_available:
- mem_used = pympler.muppy.get_size(muppy.get_objects())
+ mem_used = pympler.muppy.get_size(pympler.muppy.get_objects())
print("")
print(
" Total memory = %d bytes prior to model "
@@ -795,7 +795,7 @@ def _load_model_data(self, modeldata, namespaces, **kwds):
if profile_memory >= 3:
gc.collect()
- mem_used = pympler.muppy.get_size(muppy.get_objects())
+ mem_used = pympler.muppy.get_size(pympler.muppy.get_objects())
print(
" Total memory = %d bytes prior to model "
"construction (after garbage collection)" % mem_used
diff --git a/pyomo/core/base/__init__.py b/pyomo/core/base/__init__.py
index 4bbd0c9dc44..6b295196864 100644
--- a/pyomo/core/base/__init__.py
+++ b/pyomo/core/base/__init__.py
@@ -12,6 +12,7 @@
# TODO: this import is for historical backwards compatibility and should
# probably be removed
from pyomo.common.collections import ComponentMap
+from pyomo.common.enums import minimize, maximize
from pyomo.core.expr.symbol_map import SymbolMap
from pyomo.core.expr.numvalue import (
@@ -33,10 +34,11 @@
BooleanValue,
native_logical_values,
)
-from pyomo.core.kernel.objective import minimize, maximize
-from pyomo.core.base.config import PyomoOptions
-from pyomo.core.base.expression import Expression, _ExpressionData
+from pyomo.core.base.component import name, Component, ModelComponentFactory
+from pyomo.core.base.componentuid import ComponentUID
+from pyomo.core.base.config import PyomoOptions
+from pyomo.core.base.enums import SortComponents, TraversalStrategy
from pyomo.core.base.label import (
CuidLabeler,
CounterLabeler,
@@ -47,56 +49,73 @@
NameLabeler,
ShortNameLabeler,
)
+from pyomo.core.base.misc import display
+from pyomo.core.base.reference import Reference
+from pyomo.core.base.symbol_map import symbol_map_from_instance
+from pyomo.core.base.transformation import (
+ Transformation,
+ TransformationFactory,
+ ReverseTransformationToken,
+)
+
+from pyomo.core.base.PyomoModel import (
+ global_option,
+ ModelSolution,
+ ModelSolutions,
+ Model,
+ ConcreteModel,
+ AbstractModel,
+)
#
# Components
#
-from pyomo.core.base.component import name, Component, ModelComponentFactory
-from pyomo.core.base.componentuid import ComponentUID
from pyomo.core.base.action import BuildAction
-from pyomo.core.base.check import BuildCheck
-from pyomo.core.base.set import Set, SetOf, simple_set_rule, RangeSet
-from pyomo.core.base.param import Param
-from pyomo.core.base.var import Var, _VarData, _GeneralVarData, ScalarVar, VarList
+from pyomo.core.base.block import (
+ Block,
+ BlockData,
+ ScalarBlock,
+ active_components,
+ components,
+ active_components_data,
+ components_data,
+)
from pyomo.core.base.boolean_var import (
BooleanVar,
- _BooleanVarData,
- _GeneralBooleanVarData,
+ BooleanVarData,
BooleanVarList,
ScalarBooleanVar,
)
+from pyomo.core.base.check import BuildCheck
+from pyomo.core.base.connector import Connector, ConnectorData
from pyomo.core.base.constraint import (
simple_constraint_rule,
simple_constraintlist_rule,
ConstraintList,
Constraint,
- _ConstraintData,
+ ConstraintData,
)
+from pyomo.core.base.expression import Expression, NamedExpressionData, ExpressionData
+from pyomo.core.base.external import ExternalFunction
from pyomo.core.base.logical_constraint import (
LogicalConstraint,
LogicalConstraintList,
- _LogicalConstraintData,
+ LogicalConstraintData,
)
from pyomo.core.base.objective import (
simple_objective_rule,
simple_objectivelist_rule,
Objective,
ObjectiveList,
- _ObjectiveData,
-)
-from pyomo.core.base.connector import Connector
-from pyomo.core.base.sos import SOSConstraint
-from pyomo.core.base.piecewise import Piecewise
-from pyomo.core.base.suffix import (
- active_export_suffix_generator,
- active_import_suffix_generator,
- Suffix,
+ ObjectiveData,
)
-from pyomo.core.base.external import ExternalFunction
-from pyomo.core.base.symbol_map import symbol_map_from_instance
-from pyomo.core.base.reference import Reference
-
+from pyomo.core.base.param import Param, ParamData
+from pyomo.core.base.piecewise import Piecewise, PiecewiseData
from pyomo.core.base.set import (
+ Set,
+ SetData,
+ SetOf,
+ RangeSet,
Reals,
PositiveReals,
NonPositiveReals,
@@ -116,34 +135,21 @@
PercentFraction,
RealInterval,
IntegerInterval,
+ simple_set_rule,
)
-from pyomo.core.base.misc import display
-from pyomo.core.base.block import (
- Block,
- ScalarBlock,
- active_components,
- components,
- active_components_data,
- components_data,
-)
-from pyomo.core.base.enums import SortComponents, TraversalStrategy
-from pyomo.core.base.PyomoModel import (
- global_option,
- ModelSolution,
- ModelSolutions,
- Model,
- ConcreteModel,
- AbstractModel,
-)
-from pyomo.core.base.transformation import (
- Transformation,
- TransformationFactory,
- ReverseTransformationToken,
+from pyomo.core.base.sos import SOSConstraint, SOSConstraintData
+from pyomo.core.base.suffix import (
+ active_export_suffix_generator,
+ active_import_suffix_generator,
+ Suffix,
)
+from pyomo.core.base.var import Var, VarData, ScalarVar, VarList
from pyomo.core.base.instance2dat import instance2dat
+#
# These APIs are deprecated and should be removed in the near future
+#
from pyomo.core.base.set import set_options, RealSet, IntegerSet, BooleanSet
from pyomo.common.deprecation import relocated_module_attribute
@@ -155,4 +161,25 @@
relocated_module_attribute(
'SimpleBooleanVar', 'pyomo.core.base.boolean_var.SimpleBooleanVar', version='6.0'
)
+# Historically, only a subset of "private" component data classes were imported here
+relocated_module_attribute(
+ f'_GeneralVarData', f'pyomo.core.base.VarData', version='6.7.2'
+)
+relocated_module_attribute(
+ f'_GeneralBooleanVarData', f'pyomo.core.base.BooleanVarData', version='6.7.2'
+)
+relocated_module_attribute(
+ f'_ExpressionData', f'pyomo.core.base.NamedExpressionData', version='6.7.2'
+)
+for _cdata in (
+ 'ConstraintData',
+ 'LogicalConstraintData',
+ 'VarData',
+ 'BooleanVarData',
+ 'ObjectiveData',
+):
+ relocated_module_attribute(
+ f'_{_cdata}', f'pyomo.core.base.{_cdata}', version='6.7.2'
+ )
+del _cdata
del relocated_module_attribute
diff --git a/pyomo/core/base/block.py b/pyomo/core/base/block.py
index 48353078fca..653809e0419 100644
--- a/pyomo/core/base/block.py
+++ b/pyomo/core/base/block.py
@@ -9,18 +9,20 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
+from __future__ import annotations
import copy
import logging
import sys
import weakref
import textwrap
-from contextlib import contextmanager
+from collections import defaultdict
+from contextlib import contextmanager
from inspect import isclass, currentframe
+from io import StringIO
from itertools import filterfalse, chain
from operator import itemgetter, attrgetter
-from io import StringIO
-from pyomo.common.pyomo_typing import overload
+from typing import Union, Any, Type
from pyomo.common.autoslots import AutoSlots
from pyomo.common.collections import Mapping
@@ -28,6 +30,7 @@
from pyomo.common.formatting import StreamIndenter
from pyomo.common.gc_manager import PauseGC
from pyomo.common.log import is_debug_set
+from pyomo.common.pyomo_typing import overload
from pyomo.common.timing import ConstructionTimer
from pyomo.core.base.component import (
Component,
@@ -43,6 +46,7 @@
from pyomo.core.base.indexed_component import (
ActiveIndexedComponent,
UnindexedComponent_set,
+ IndexedComponent,
)
from pyomo.opt.base import ProblemFormat, guess_format
@@ -156,13 +160,13 @@ def __init__(self):
self.seen_data = set()
def unique(self, comp, items, are_values):
- """Returns generator that filters duplicate _ComponentData objects from items
+ """Returns generator that filters duplicate ComponentData objects from items
Parameters
----------
comp: ComponentBase
The Component (indexed or scalar) that contains all
- _ComponentData returned by the `items` generator. `comp` may
+ ComponentData returned by the `items` generator. `comp` may
be an IndexedComponent generated by :py:func:`Reference` (and
hence may not own the component datas in `items`)
@@ -171,8 +175,8 @@ def unique(self, comp, items, are_values):
`comp` Component.
are_values: bool
- If `True`, `items` yields _ComponentData objects, otherwise,
- `items` yields `(index, _ComponentData)` tuples.
+ If `True`, `items` yields ComponentData objects, otherwise,
+ `items` yields `(index, ComponentData)` tuples.
"""
if comp.is_reference():
@@ -250,7 +254,7 @@ class _BlockConstruction(object):
class PseudoMap(AutoSlots.Mixin):
"""
This class presents a "mock" dict interface to the internal
- _BlockData data structures. We return this object to the
+ BlockData data structures. We return this object to the
user to preserve the historical "{ctype : {name : obj}}"
interface without actually regenerating that dict-of-dicts data
structure.
@@ -483,7 +487,7 @@ def iteritems(self):
return self.items()
-class _BlockData(ActiveComponentData):
+class BlockData(ActiveComponentData):
"""
This class holds the fundamental block data.
"""
@@ -533,12 +537,12 @@ def __init__(self, component):
# _ctypes: { ctype -> [1st idx, last idx, count] }
# _decl: { name -> idx }
# _decl_order: list( tuples( obj, next_type_idx ) )
- super(_BlockData, self).__setattr__('_ctypes', {})
- super(_BlockData, self).__setattr__('_decl', {})
- super(_BlockData, self).__setattr__('_decl_order', [])
+ super(BlockData, self).__setattr__('_ctypes', {})
+ super(BlockData, self).__setattr__('_decl', {})
+ super(BlockData, self).__setattr__('_decl_order', [])
self._private_data = None
- def __getattr__(self, val):
+ def __getattr__(self, val) -> Union[Component, IndexedComponent, Any]:
if val in ModelComponentFactory:
return _component_decorator(self, ModelComponentFactory.get_class(val))
# Since the base classes don't support getattr, we can just
@@ -547,7 +551,7 @@ def __getattr__(self, val):
"'%s' object has no attribute '%s'" % (self.__class__.__name__, val)
)
- def __setattr__(self, name, val):
+ def __setattr__(self, name: str, val: Union[Component, IndexedComponent, Any]):
"""
Set an attribute of a block data object.
"""
@@ -570,7 +574,7 @@ def __setattr__(self, name, val):
# Other Python objects are added with the standard __setattr__
# method.
#
- super(_BlockData, self).__setattr__(name, val)
+ super(BlockData, self).__setattr__(name, val)
#
# Case 2. The attribute exists and it is a component in the
# list of declarations in this block. We will use the
@@ -624,11 +628,11 @@ def __setattr__(self, name, val):
#
else:
#
- # NB: This is important: the _BlockData is either a scalar
+ # NB: This is important: the BlockData is either a scalar
# Block (where _parent and _component are defined) or a
# single block within an Indexed Block (where only
# _component is defined). Regardless, the
- # _BlockData.__init__() method declares these methods and
+ # BlockData.__init__() method declares these methods and
# sets them either to None or a weakref. Thus, we will
# never have a problem converting these objects from
# weakrefs into Blocks and back (when pickling); the
@@ -643,23 +647,23 @@ def __setattr__(self, name, val):
# return True, this shouldn't be too inefficient.
#
if name == '_parent':
- if val is not None and not isinstance(val(), _BlockData):
+ if val is not None and not isinstance(val(), BlockData):
raise ValueError(
"Cannot set the '_parent' attribute of Block '%s' "
"to a non-Block object (with type=%s); Did you "
"try to create a model component named '_parent'?"
% (self.name, type(val))
)
- super(_BlockData, self).__setattr__(name, val)
+ super(BlockData, self).__setattr__(name, val)
elif name == '_component':
- if val is not None and not isinstance(val(), _BlockData):
+ if val is not None and not isinstance(val(), BlockData):
raise ValueError(
"Cannot set the '_component' attribute of Block '%s' "
"to a non-Block object (with type=%s); Did you "
"try to create a model component named '_component'?"
% (self.name, type(val))
)
- super(_BlockData, self).__setattr__(name, val)
+ super(BlockData, self).__setattr__(name, val)
#
# At this point, we should only be seeing non-component data
# the user is hanging on the blocks (uncommon) or the
@@ -676,7 +680,7 @@ def __setattr__(self, name, val):
delattr(self, name)
self.add_component(name, val)
else:
- super(_BlockData, self).__setattr__(name, val)
+ super(BlockData, self).__setattr__(name, val)
def __delattr__(self, name):
"""
@@ -699,7 +703,7 @@ def __delattr__(self, name):
# Other Python objects are removed with the standard __detattr__
# method.
#
- super(_BlockData, self).__delattr__(name)
+ super(BlockData, self).__delattr__(name)
def _compact_decl_storage(self):
idxMap = {}
@@ -771,11 +775,11 @@ def transfer_attributes_from(self, src):
Parameters
----------
- src: _BlockData or dict
+ src: BlockData or dict
The Block or mapping that contains the new attributes to
assign to this block.
"""
- if isinstance(src, _BlockData):
+ if isinstance(src, BlockData):
# There is a special case where assigning a parent block to
# this block creates a circular hierarchy
if src is self:
@@ -784,7 +788,7 @@ def transfer_attributes_from(self, src):
while p_block is not None:
if p_block is src:
raise ValueError(
- "_BlockData.transfer_attributes_from(): Cannot set a "
+ "BlockData.transfer_attributes_from(): Cannot set a "
"sub-block (%s) to a parent block (%s): creates a "
"circular hierarchy" % (self, src)
)
@@ -800,7 +804,7 @@ def transfer_attributes_from(self, src):
del_src_comp = lambda x: None
else:
raise ValueError(
- "_BlockData.transfer_attributes_from(): expected a "
+ "BlockData.transfer_attributes_from(): expected a "
"Block or dict; received %s" % (type(src).__name__,)
)
@@ -874,7 +878,7 @@ def collect_ctypes(self, active=None, descend_into=True):
def model(self):
#
- # Special case: the "Model" is always the top-level _BlockData,
+ # Special case: the "Model" is always the top-level BlockData,
# so if this is the top-level block, it must be the model
#
# Also note the interesting and intentional characteristic for
@@ -1031,7 +1035,7 @@ def add_component(self, name, val):
# is inappropriate here. The correct way to add the attribute
# is to delegate the work to the next class up the MRO.
#
- super(_BlockData, self).__setattr__(name, val)
+ super(BlockData, self).__setattr__(name, val)
#
# Update the ctype linked lists
#
@@ -1053,26 +1057,13 @@ def add_component(self, name, val):
# Error, for disabled support implicit rule names
#
if '_rule' in val.__dict__ and val._rule is None:
- _found = False
try:
_test = val.local_name + '_rule'
for i in (1, 2):
frame = sys._getframe(i)
- _found |= _test in frame.f_locals
except:
pass
- if _found:
- # JDS: Do not blindly reformat this message. The
- # formatter inserts arbitrarily-long names(), which can
- # cause the resulting logged message to be very poorly
- # formatted due to long lines.
- logger.warning(
- """As of Pyomo 4.0, Pyomo components no longer support implicit rules.
-You defined a component (%s) that appears
-to rely on an implicit rule (%s).
-Components must now specify their rules explicitly using 'rule=' keywords."""
- % (val.name, _test)
- )
+
#
# Don't reconstruct if this component has already been constructed.
# This allows a user to move a component from one block to
@@ -1102,7 +1093,7 @@ def add_component(self, name, val):
# This is tricky: If we are in the middle of
# constructing an indexed block, the block component
# already has _constructed=True. Now, if the
- # _BlockData.__init__() defines any local variables
+ # BlockData.__init__() defines any local variables
# (like pyomo.gdp.Disjunct's indicator_var), name(True)
# will fail: this block data exists and has a parent(),
# but it has not yet been added to the parent's _data
@@ -1190,7 +1181,7 @@ def del_component(self, name_or_object):
# Note: 'del self.__dict__[name]' is inappropriate here. The
# correct way to add the attribute is to delegate the work to
# the next class up the MRO.
- super(_BlockData, self).__delattr__(name)
+ super(BlockData, self).__delattr__(name)
def reclassify_component_type(
self, name_or_object, new_ctype, preserve_declaration_order=True
@@ -1395,7 +1386,7 @@ def _component_data_iteritems(self, ctype, active, sort, dedup):
Generator that returns a nested 2-tuple of
- ((component name, index value), _ComponentData)
+ ((component name, index value), ComponentData)
for every component data in the block matching the specified
ctype(s).
@@ -1412,7 +1403,7 @@ def _component_data_iteritems(self, ctype, active, sort, dedup):
Iterate over the components in a specified sorted order
dedup: _DeduplicateInfo
- Deduplicator to prevent returning the same _ComponentData twice
+ Deduplicator to prevent returning the same ComponentData twice
"""
for name, comp in PseudoMap(self, ctype, active, sort).items():
# NOTE: Suffix has a dict interface (something other derived
@@ -1448,7 +1439,7 @@ def _component_data_iteritems(self, ctype, active, sort, dedup):
yield from dedup.unique(comp, _items, False)
def _component_data_itervalues(self, ctype, active, sort, dedup):
- """Generator that returns the _ComponentData for every component data
+ """Generator that returns the ComponentData for every component data
in the block.
Parameters
@@ -1463,7 +1454,7 @@ def _component_data_itervalues(self, ctype, active, sort, dedup):
Iterate over the components in a specified sorted order
dedup: _DeduplicateInfo
- Deduplicator to prevent returning the same _ComponentData twice
+ Deduplicator to prevent returning the same ComponentData twice
"""
for comp in PseudoMap(self, ctype, active, sort).values():
# NOTE: Suffix has a dict interface (something other derived
@@ -1569,7 +1560,7 @@ def component_data_iterindex(
generator recursively descends into sub-blocks. The
tuple is
- ((component name, index value), _ComponentData)
+ ((component name, index value), ComponentData)
"""
dedup = _DeduplicateInfo()
@@ -1986,10 +1977,15 @@ def private_data(self, scope=None):
if self._private_data is None:
self._private_data = {}
if scope not in self._private_data:
- self._private_data[scope] = {}
+ self._private_data[scope] = Block._private_data_initializers[scope]()
return self._private_data[scope]
+class _BlockData(metaclass=RenamedClass):
+ __renamed__new_class__ = BlockData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register(
"A component that contains one or more model components."
)
@@ -2003,7 +1999,19 @@ class Block(ActiveIndexedComponent):
is deferred.
"""
- _ComponentDataClass = _BlockData
+ _ComponentDataClass = BlockData
+ _private_data_initializers = defaultdict(lambda: dict)
+
+ @overload
+ def __new__(
+ cls: Type[Block], *args, **kwds
+ ) -> Union[ScalarBlock, IndexedBlock]: ...
+
+ @overload
+ def __new__(cls: Type[ScalarBlock], *args, **kwds) -> ScalarBlock: ...
+
+ @overload
+ def __new__(cls: Type[IndexedBlock], *args, **kwds) -> IndexedBlock: ...
def __new__(cls, *args, **kwds):
if cls != Block:
@@ -2084,7 +2092,7 @@ def _getitem_when_not_present(self, idx):
# components declared by the rule have the opportunity
# to be initialized with data from
# _BlockConstruction.data as they are transferred over.
- if obj is not _block and isinstance(obj, _BlockData):
+ if obj is not _block and isinstance(obj, BlockData):
_block.transfer_attributes_from(obj)
finally:
if data is not None and _block is not self:
@@ -2205,12 +2213,29 @@ def display(self, filename=None, ostream=None, prefix=""):
ostream = sys.stdout
for key in sorted(self):
- _BlockData.display(self[key], filename, ostream, prefix)
+ BlockData.display(self[key], filename, ostream, prefix)
+
+ @staticmethod
+ def register_private_data_initializer(initializer, scope=None):
+ mod = currentframe().f_back.f_globals['__name__']
+ if scope is None:
+ scope = mod
+ elif not mod.startswith(scope):
+ raise ValueError(
+ "'private_data' scope must be substrings of the caller's module name. "
+ f"Received '{scope}' when calling register_private_data_initializer()."
+ )
+ if scope in Block._private_data_initializers:
+ raise RuntimeError(
+ "Duplicate initializer registration for 'private_data' dictionary "
+ f"(scope={scope})"
+ )
+ Block._private_data_initializers[scope] = initializer
-class ScalarBlock(_BlockData, Block):
+class ScalarBlock(BlockData, Block):
def __init__(self, *args, **kwds):
- _BlockData.__init__(self, component=self)
+ BlockData.__init__(self, component=self)
Block.__init__(self, *args, **kwds)
# Initialize the data dict so that (abstract) attribute
# assignment will work. Note that we do not trigger
@@ -2232,6 +2257,11 @@ class IndexedBlock(Block):
def __init__(self, *args, **kwds):
Block.__init__(self, *args, **kwds)
+ @overload
+ def __getitem__(self, index) -> BlockData: ...
+
+ __getitem__ = IndexedComponent.__getitem__ # type: ignore
+
#
# Deprecated functions.
@@ -2287,101 +2317,120 @@ def components_data(block, ctype, sort=None, sort_by_keys=False, sort_by_names=F
# Create a Block and record all the default attributes, methods, etc.
# These will be assumed to be the set of illegal component names.
#
-_BlockData._Block_reserved_words = set(dir(Block()))
-
+BlockData._Block_reserved_words = set(dir(Block()))
-class _IndexedCustomBlockMeta(type):
- """Metaclass for creating an indexed custom block."""
- pass
-
-
-class _ScalarCustomBlockMeta(type):
- """Metaclass for creating a scalar custom block."""
-
- def __new__(meta, name, bases, dct):
- def __init__(self, *args, **kwargs):
- # bases[0] is the custom block data object
- bases[0].__init__(self, component=self)
- # bases[1] is the custom block object that
- # is used for declaration
- bases[1].__init__(self, *args, **kwargs)
-
- dct["__init__"] = __init__
- return type.__new__(meta, name, bases, dct)
+class ScalarCustomBlockMixin(object):
+ def __init__(self, *args, **kwargs):
+ # __bases__ for the ScalarCustomBlock is
+ #
+ # (ScalarCustomBlockMixin, {custom_data}, {custom_block})
+ #
+ # Unfortunately, we cannot guarantee that this is being called
+ # from the ScalarCustomBlock (someone could have inherited from
+ # that class to make another scalar class). We will walk up the
+ # MRO to find the Scalar class (which should be the only class
+ # that has this Mixin as the first base class)
+ for cls in self.__class__.__mro__:
+ if cls.__bases__[0] is ScalarCustomBlockMixin:
+ _mixin, _data, _block = cls.__bases__
+ _data.__init__(self, component=self)
+ _block.__init__(self, *args, **kwargs)
+ break
class CustomBlock(Block):
"""The base class used by instances of custom block components"""
- def __init__(self, *args, **kwds):
+ def __init__(self, *args, **kwargs):
if self._default_ctype is not None:
- kwds.setdefault('ctype', self._default_ctype)
- Block.__init__(self, *args, **kwds)
-
- def __new__(cls, *args, **kwds):
- if cls.__name__.startswith('_Indexed') or cls.__name__.startswith('_Scalar'):
- # we are entering here the second time (recursive)
- # therefore, we need to create what we have
- return super(CustomBlock, cls).__new__(cls)
+ kwargs.setdefault('ctype', self._default_ctype)
+ Block.__init__(self, *args, **kwargs)
+
+ def __new__(cls, *args, **kwargs):
+ if cls.__bases__[0] is not CustomBlock:
+ # we are creating a class other than the "generic" derived
+ # custom block class. We can assume that the routing of the
+ # generic block class to the specific Scalar or Indexed
+ # subclass has already occurred and we can pass control up
+ # to (toward) object.__new__()
+ return super().__new__(cls, *args, **kwargs)
+ # If the first base class is this CustomBlock class, then the
+ # user is attempting to create the "generic" block class.
+ # Depending on the arguments, we need to map this to either the
+ # Scalar or Indexed block subclass.
if not args or (args[0] is UnindexedComponent_set and len(args) == 1):
- n = _ScalarCustomBlockMeta(
- "_Scalar%s" % (cls.__name__,), (cls._ComponentDataClass, cls), {}
- )
- return n.__new__(n)
+ return super().__new__(cls._scalar_custom_block, *args, **kwargs)
else:
- n = _IndexedCustomBlockMeta("_Indexed%s" % (cls.__name__,), (cls,), {})
- return n.__new__(n)
+ return super().__new__(cls._indexed_custom_block, *args, **kwargs)
def declare_custom_block(name, new_ctype=None):
"""Decorator to declare components for a custom block data class
- >>> @declare_custom_block(name=FooBlock)
- ... class FooBlockData(_BlockData):
+ >>> @declare_custom_block(name="FooBlock")
+ ... class FooBlockData(BlockData):
... # custom block data class
... pass
"""
- def proc_dec(cls):
- # this is the decorator function that
- # creates the block component class
-
- # Default (derived) Block attributes
- clsbody = {
- "__module__": cls.__module__, # magic to fix the module
- # Default IndexedComponent data object is the decorated class:
- "_ComponentDataClass": cls,
- # By default this new block does not declare a new ctype
- "_default_ctype": None,
- }
+ def block_data_decorator(block_data):
+ # this is the decorator function that creates the block
+ # component classes
- c = type(
+ # Declare the new Block component (derived from CustomBlock)
+ # corresponding to the BlockData that we are decorating
+ #
+ # Note the use of `type(CustomBlock)` to pick up the metaclass
+ # that was used to create the CustomBlock (in general, it should
+ # be `type`)
+ comp = type(CustomBlock)(
name, # name of new class
(CustomBlock,), # base classes
- clsbody, # class body definitions (will populate __dict__)
+ # class body definitions (populate the new class' __dict__)
+ {
+ # ensure the created class is associated with the calling module
+ "__module__": block_data.__module__,
+ # Default IndexedComponent data object is the decorated class:
+ "_ComponentDataClass": block_data,
+ # By default this new block does not declare a new ctype
+ "_default_ctype": None,
+ },
)
if new_ctype is not None:
if new_ctype is True:
- c._default_ctype = c
- elif type(new_ctype) is type:
- c._default_ctype = new_ctype
+ comp._default_ctype = comp
+ elif isinstance(new_ctype, type):
+ comp._default_ctype = new_ctype
else:
raise ValueError(
"Expected new_ctype to be either type "
"or 'True'; received: %s" % (new_ctype,)
)
- # Register the new Block type in the same module as the BlockData
- setattr(sys.modules[cls.__module__], name, c)
- # TODO: can we also register concrete Indexed* and Scalar*
- # classes into the original BlockData module (instead of relying
- # on metaclasses)?
+ # Declare Indexed and Scalar versions of the custom block. We
+ # will register them both with the calling module scope, and
+ # with the CustomBlock (so that CustomBlock.__new__ can route
+ # the object creation to the correct class)
+ comp._indexed_custom_block = type(comp)(
+ "Indexed" + name,
+ (comp,),
+ { # ensure the created class is associated with the calling module
+ "__module__": block_data.__module__
+ },
+ )
+ comp._scalar_custom_block = type(comp)(
+ "Scalar" + name,
+ (ScalarCustomBlockMixin, block_data, comp),
+ { # ensure the created class is associated with the calling module
+ "__module__": block_data.__module__
+ },
+ )
- # are these necessary?
- setattr(cls, '_orig_name', name)
- setattr(cls, '_orig_module', cls.__module__)
- return cls
+ # Register the new Block types in the same module as the BlockData
+ for _cls in (comp, comp._indexed_custom_block, comp._scalar_custom_block):
+ setattr(sys.modules[block_data.__module__], _cls.__name__, _cls)
+ return block_data
- return proc_dec
+ return block_data_decorator
diff --git a/pyomo/core/base/boolean_var.py b/pyomo/core/base/boolean_var.py
index 246dcea6214..db9a41fceda 100644
--- a/pyomo/core/base/boolean_var.py
+++ b/pyomo/core/base/boolean_var.py
@@ -68,27 +68,65 @@ def __setstate__(self, state):
self._boolvar = weakref_ref(state)
-class _BooleanVarData(ComponentData, BooleanValue):
- """
- This class defines the data for a single variable.
-
- Constructor Arguments:
- component The BooleanVar object that owns this data.
- Public Class Attributes:
- fixed If True, then this variable is treated as a
- fixed constant in the model.
- stale A Boolean indicating whether the value of this variable is
- legitimate. This value is true if the value should
- be considered legitimate for purposes of reporting or
- other interrogation.
- value The numeric value of this variable.
+def _associated_binary_mapper(encode, val):
+ if val is None:
+ return None
+ if encode:
+ if val.__class__ is not _DeprecatedImplicitAssociatedBinaryVariable:
+ return val()
+ else:
+ if val.__class__ is not _DeprecatedImplicitAssociatedBinaryVariable:
+ return weakref_ref(val)
+ return val
+
+
+class BooleanVarData(ComponentData, BooleanValue):
+ """This class defines the data for a single Boolean variable.
+
+ Parameters
+ ----------
+ component: Component
+ The BooleanVar object that owns this data.
+
+ Attributes
+ ----------
+ domain: SetData
+ The domain of this variable.
+
+ fixed: bool
+ If True, then this variable is treated as a fixed constant in
+ the model.
+
+ stale: bool
+ A Boolean indicating whether the value of this variable is
+ Consistent with the most recent solve. `True` indicates that
+ this variable's value was set prior to the most recent solve and
+ was not updated by the results returned by the solve.
+
+ value: bool
+ The value of this variable.
"""
- __slots__ = ()
+ __slots__ = ('_value', 'fixed', '_stale', '_associated_binary')
+ __autoslot_mappers__ = {
+ '_associated_binary': _associated_binary_mapper,
+ '_stale': StaleFlagManager.stale_mapper,
+ }
def __init__(self, component=None):
+ #
+ # These lines represent in-lining of the
+ # following constructors:
+ # - BooleanVarData
+ # - ComponentData
+ # - BooleanValue
self._component = weakref_ref(component) if (component is not None) else None
self._index = NOTSET
+ self._value = None
+ self.fixed = False
+ self._stale = 0 # True
+
+ self._associated_binary = None
def is_fixed(self):
"""Returns True if this variable is fixed, otherwise returns False."""
@@ -132,113 +170,6 @@ def __call__(self, exception=True):
"""Compute the value of this variable."""
return self.value
- @property
- def value(self):
- """Return the value for this variable."""
- raise NotImplementedError
-
- @property
- def domain(self):
- """Return the domain for this variable."""
- raise NotImplementedError
-
- @property
- def fixed(self):
- """Return the fixed indicator for this variable."""
- raise NotImplementedError
-
- @property
- def stale(self):
- """Return the stale indicator for this variable."""
- raise NotImplementedError
-
- def fix(self, value=NOTSET, skip_validation=False):
- """Fix the value of this variable (treat as nonvariable)
-
- This sets the `fixed` indicator to True. If ``value`` is
- provided, the value (and the ``skip_validation`` flag) are first
- passed to :py:meth:`set_value()`.
-
- """
- self.fixed = True
- if value is not NOTSET:
- self.set_value(value, skip_validation)
-
- def unfix(self):
- """Unfix this variable (treat as variable)
-
- This sets the `fixed` indicator to False.
-
- """
- self.fixed = False
-
- def free(self):
- """Alias for :py:meth:`unfix`"""
- return self.unfix()
-
-
-def _associated_binary_mapper(encode, val):
- if val is None:
- return None
- if encode:
- if val.__class__ is not _DeprecatedImplicitAssociatedBinaryVariable:
- return val()
- else:
- if val.__class__ is not _DeprecatedImplicitAssociatedBinaryVariable:
- return weakref_ref(val)
- return val
-
-
-class _GeneralBooleanVarData(_BooleanVarData):
- """
- This class defines the data for a single Boolean variable.
-
- Constructor Arguments:
- component The BooleanVar object that owns this data.
-
- Public Class Attributes:
- domain The domain of this variable.
- fixed If True, then this variable is treated as a
- fixed constant in the model.
- stale A Boolean indicating whether the value of this variable is
- legitimiate. This value is true if the value should
- be considered legitimate for purposes of reporting or
- other interrogation.
- value The numeric value of this variable.
-
- The domain attribute is a property because it is
- too widely accessed directly to enforce explicit getter/setter
- methods and we need to deter directly modifying or accessing
- these attributes in certain cases.
- """
-
- __slots__ = ('_value', 'fixed', '_stale', '_associated_binary')
- __autoslot_mappers__ = {
- '_associated_binary': _associated_binary_mapper,
- '_stale': StaleFlagManager.stale_mapper,
- }
-
- def __init__(self, component=None):
- #
- # These lines represent in-lining of the
- # following constructors:
- # - _BooleanVarData
- # - ComponentData
- # - BooleanValue
- self._component = weakref_ref(component) if (component is not None) else None
- self._index = NOTSET
- self._value = None
- self.fixed = False
- self._stale = 0 # True
-
- self._associated_binary = None
-
- #
- # Abstract Interface
- #
-
- # value is an attribute
-
@property
def value(self):
"""Return (or set) the value for this variable."""
@@ -265,14 +196,14 @@ def stale(self, val):
self._stale = StaleFlagManager.get_flag(0)
def get_associated_binary(self):
- """Get the binary _VarData associated with this
- _GeneralBooleanVarData"""
+ """Get the binary VarData associated with this
+ BooleanVarData"""
return (
self._associated_binary() if self._associated_binary is not None else None
)
def associate_binary_var(self, binary_var):
- """Associate a binary _VarData to this _GeneralBooleanVarData"""
+ """Associate a binary VarData to this BooleanVarData"""
if (
self._associated_binary is not None
and type(self._associated_binary)
@@ -294,6 +225,40 @@ def associate_binary_var(self, binary_var):
if binary_var is not None:
self._associated_binary = weakref_ref(binary_var)
+ def fix(self, value=NOTSET, skip_validation=False):
+ """Fix the value of this variable (treat as nonvariable)
+
+ This sets the `fixed` indicator to True. If ``value`` is
+ provided, the value (and the ``skip_validation`` flag) are first
+ passed to :py:meth:`set_value()`.
+
+ """
+ self.fixed = True
+ if value is not NOTSET:
+ self.set_value(value, skip_validation)
+
+ def unfix(self):
+ """Unfix this variable (treat as variable)
+
+ This sets the `fixed` indicator to False.
+
+ """
+ self.fixed = False
+
+ def free(self):
+ """Alias for :py:meth:`unfix`"""
+ return self.unfix()
+
+
+class _BooleanVarData(metaclass=RenamedClass):
+ __renamed__new_class__ = BooleanVarData
+ __renamed__version__ = '6.7.2'
+
+
+class _GeneralBooleanVarData(metaclass=RenamedClass):
+ __renamed__new_class__ = BooleanVarData
+ __renamed__version__ = '6.7.2'
+
@ModelComponentFactory.register("Logical decision variables.")
class BooleanVar(IndexedComponent):
@@ -309,7 +274,7 @@ class BooleanVar(IndexedComponent):
to True.
"""
- _ComponentDataClass = _GeneralBooleanVarData
+ _ComponentDataClass = BooleanVarData
def __new__(cls, *args, **kwds):
if cls != BooleanVar:
@@ -390,7 +355,7 @@ def construct(self, data=None):
_set.construct()
#
- # Construct _BooleanVarData objects for all index values
+ # Construct BooleanVarData objects for all index values
#
if not self.is_indexed():
self._data[None] = self
@@ -501,11 +466,11 @@ def _pprint(self):
)
-class ScalarBooleanVar(_GeneralBooleanVarData, BooleanVar):
+class ScalarBooleanVar(BooleanVarData, BooleanVar):
"""A single variable."""
def __init__(self, *args, **kwd):
- _GeneralBooleanVarData.__init__(self, component=self)
+ BooleanVarData.__init__(self, component=self)
BooleanVar.__init__(self, *args, **kwd)
self._index = UnindexedComponent_index
@@ -521,7 +486,7 @@ def __init__(self, *args, **kwd):
def value(self):
"""Return the value for this variable."""
if self._constructed:
- return _GeneralBooleanVarData.value.fget(self)
+ return BooleanVarData.value.fget(self)
raise ValueError(
"Accessing the value of variable '%s' "
"before the Var has been constructed (there "
@@ -532,7 +497,7 @@ def value(self):
def value(self, val):
"""Set the value for this variable."""
if self._constructed:
- return _GeneralBooleanVarData.value.fset(self, val)
+ return BooleanVarData.value.fset(self, val)
raise ValueError(
"Setting the value of variable '%s' "
"before the Var has been constructed (there "
@@ -541,7 +506,7 @@ def value(self, val):
@property
def domain(self):
- return _GeneralBooleanVarData.domain.fget(self)
+ return BooleanVarData.domain.fget(self)
def fix(self, value=NOTSET, skip_validation=False):
"""
@@ -549,7 +514,7 @@ def fix(self, value=NOTSET, skip_validation=False):
indicating the variable should be fixed at its current value.
"""
if self._constructed:
- return _GeneralBooleanVarData.fix(self, value, skip_validation)
+ return BooleanVarData.fix(self, value, skip_validation)
raise ValueError(
"Fixing variable '%s' "
"before the Var has been constructed (there "
@@ -559,7 +524,7 @@ def fix(self, value=NOTSET, skip_validation=False):
def unfix(self):
"""Sets the fixed indicator to False."""
if self._constructed:
- return _GeneralBooleanVarData.unfix(self)
+ return BooleanVarData.unfix(self)
raise ValueError(
"Freeing variable '%s' "
"before the Var has been constructed (there "
diff --git a/pyomo/core/base/component.py b/pyomo/core/base/component.py
index 22c2bc4b804..966ce8c0737 100644
--- a/pyomo/core/base/component.py
+++ b/pyomo/core/base/component.py
@@ -20,6 +20,7 @@
from pyomo.common.autoslots import AutoSlots, fast_deepcopy
from pyomo.common.collections import OrderedDict
from pyomo.common.deprecation import (
+ RenamedClass,
deprecated,
deprecation_warning,
relocated_module_attribute,
@@ -79,7 +80,7 @@ class CloneError(pyomo.common.errors.PyomoException):
pass
-class _ComponentBase(PyomoObject):
+class ComponentBase(PyomoObject):
"""A base class for Component and ComponentData
This class defines some fundamental methods and properties that are
@@ -368,7 +369,7 @@ def pprint(self, ostream=None, verbose=False, prefix=""):
@property
def name(self):
- """Get the fully qualifed component name."""
+ """Get the fully qualified component name."""
return self.getname(fully_qualified=True)
# Adding a setter here to help users adapt to the new
@@ -474,7 +475,12 @@ def _pprint_base_impl(
ostream.write(_data)
-class Component(_ComponentBase):
+class _ComponentBase(metaclass=RenamedClass):
+ __renamed__new_class__ = ComponentBase
+ __renamed__version__ = '6.7.2'
+
+
+class Component(ComponentBase):
"""
This is the base class for all Pyomo modeling components.
@@ -657,14 +663,14 @@ def getname(self, fully_qualified=False, name_buffer=None, relative_to=None):
"use of this argument poses risks if the buffer contains "
"names relative to different Blocks in the model hierarchy or "
"a mixture of local and fully_qualified names.",
- version='TODO',
+ version='6.4.1',
)
name_buffer[id(self)] = ans
return ans
@property
def name(self):
- """Get the fully qualifed component name."""
+ """Get the fully qualified component name."""
return self.getname(fully_qualified=True)
# Allow setting a component's name if it is not owned by a parent
@@ -779,7 +785,7 @@ def deactivate(self):
self._active = False
-class ComponentData(_ComponentBase):
+class ComponentData(ComponentBase):
"""
This is the base class for the component data used
in Pyomo modeling components. Subclasses of ComponentData are
@@ -802,11 +808,11 @@ class ComponentData(_ComponentBase):
__autoslot_mappers__ = {'_component': AutoSlots.weakref_mapper}
# NOTE: This constructor is in-lined in the constructors for the following
- # classes: _BooleanVarData, _ConnectorData, _ConstraintData,
- # _GeneralExpressionData, _LogicalConstraintData,
- # _GeneralLogicalConstraintData, _GeneralObjectiveData,
- # _ParamData,_GeneralVarData, _GeneralBooleanVarData, _DisjunctionData,
- # _ArcData, _PortData, _LinearConstraintData, and
+ # classes: BooleanVarData, ConnectorData, ConstraintData,
+ # ExpressionData, LogicalConstraintData,
+ # LogicalConstraintData, ObjectiveData,
+ # ParamData,VarData, BooleanVarData, DisjunctionData,
+ # ArcData, PortData, _LinearConstraintData, and
# _LinearMatrixConstraintData. Changes made here need to be made in those
# constructors as well!
def __init__(self, component):
@@ -916,7 +922,7 @@ def getname(self, fully_qualified=False, name_buffer=None, relative_to=None):
"use of this argument poses risks if the buffer contains "
"names relative to different Blocks in the model hierarchy or "
"a mixture of local and fully_qualified names.",
- version='TODO',
+ version='6.4.1',
)
if id(self) in name_buffer:
# Return the name if it is in the buffer
diff --git a/pyomo/core/base/connector.py b/pyomo/core/base/connector.py
index 435a2c2fccb..1363f5abd65 100644
--- a/pyomo/core/base/connector.py
+++ b/pyomo/core/base/connector.py
@@ -28,7 +28,7 @@
logger = logging.getLogger('pyomo.core')
-class _ConnectorData(ComponentData, NumericValue):
+class ConnectorData(ComponentData, NumericValue):
"""Holds the actual connector information"""
__slots__ = ('vars', 'aggregators')
@@ -105,6 +105,11 @@ def _iter_vars(self):
yield v
+class _ConnectorData(metaclass=RenamedClass):
+ __renamed__new_class__ = ConnectorData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register(
"A bundle of variables that can be manipulated together."
)
@@ -157,7 +162,7 @@ def __init__(self, *args, **kwd):
# IndexedComponent
#
def _getitem_when_not_present(self, idx):
- _conval = self._data[idx] = _ConnectorData(component=self)
+ _conval = self._data[idx] = ConnectorData(component=self)
return _conval
def construct(self, data=None):
@@ -170,7 +175,7 @@ def construct(self, data=None):
timer = ConstructionTimer(self)
self._constructed = True
#
- # Construct _ConnectorData objects for all index values
+ # Construct ConnectorData objects for all index values
#
if self.is_indexed():
self._initialize_members(self._index_set)
@@ -258,9 +263,9 @@ def _line_generator(k, v):
)
-class ScalarConnector(Connector, _ConnectorData):
+class ScalarConnector(Connector, ConnectorData):
def __init__(self, *args, **kwd):
- _ConnectorData.__init__(self, component=self)
+ ConnectorData.__init__(self, component=self)
Connector.__init__(self, *args, **kwd)
self._index = UnindexedComponent_index
diff --git a/pyomo/core/base/constraint.py b/pyomo/core/base/constraint.py
index c67236656be..e12860991c2 100644
--- a/pyomo/core/base/constraint.py
+++ b/pyomo/core/base/constraint.py
@@ -9,10 +9,12 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
+from __future__ import annotations
import sys
import logging
from weakref import ref as weakref_ref
from pyomo.common.pyomo_typing import overload
+from typing import Union, Type
from pyomo.common.deprecation import RenamedClass
from pyomo.common.errors import DeveloperError
@@ -27,6 +29,7 @@
as_numeric,
is_fixed,
native_numeric_types,
+ native_logical_types,
native_types,
)
from pyomo.core.expr import (
@@ -41,6 +44,7 @@
ActiveIndexedComponent,
UnindexedComponent_set,
rule_wrapper,
+ IndexedComponent,
)
from pyomo.core.base.set import Set
from pyomo.core.base.disable_methods import disable_methods
@@ -84,14 +88,15 @@ def C_rule(model, i, j):
model.c = Constraint(rule=simple_constraint_rule(...))
"""
- return rule_wrapper(
- rule,
- {
- None: Constraint.Skip,
- True: Constraint.Feasible,
- False: Constraint.Infeasible,
- },
- )
+ map_types = set([type(None)]) | native_logical_types
+ result_map = {None: Constraint.Skip}
+ for l_type in native_logical_types:
+ result_map[l_type(True)] = Constraint.Feasible
+ result_map[l_type(False)] = Constraint.Infeasible
+ # Note: some logical types hash the same as bool (e.g., np.bool_), so
+ # we will pass the set of all logical types in addition to the
+ # result_map
+ return rule_wrapper(rule, result_map, map_types=map_types)
def simple_constraintlist_rule(rule):
@@ -109,27 +114,24 @@ def C_rule(model, i, j):
model.c = ConstraintList(expr=simple_constraintlist_rule(...))
"""
- return rule_wrapper(
- rule,
- {
- None: ConstraintList.End,
- True: Constraint.Feasible,
- False: Constraint.Infeasible,
- },
- )
-
-
-#
-# This class is a pure interface
-#
-
-
-class _ConstraintData(ActiveComponentData):
+ map_types = set([type(None)]) | native_logical_types
+ result_map = {None: ConstraintList.End}
+ for l_type in native_logical_types:
+ result_map[l_type(True)] = Constraint.Feasible
+ result_map[l_type(False)] = Constraint.Infeasible
+ # Note: some logical types hash the same as bool (e.g., np.bool_), so
+ # we will pass the set of all logical types in addition to the
+ # result_map
+ return rule_wrapper(rule, result_map, map_types=map_types)
+
+
+class ConstraintData(ActiveComponentData):
"""
- This class defines the data for a single constraint.
+ This class defines the data for a single algebraic constraint.
Constructor arguments:
component The Constraint object that owns this data.
+ expr The Pyomo expression stored in this constraint.
Public class attributes:
active A boolean that is true if this constraint is
@@ -149,164 +151,17 @@ class _ConstraintData(ActiveComponentData):
_active A boolean that indicates whether this data is active
"""
- __slots__ = ()
+ __slots__ = ('_body', '_lower', '_upper', '_expr')
# Set to true when a constraint class stores its expression
# in linear canonical form
_linear_canonical_form = False
- def __init__(self, component=None):
- #
- # These lines represent in-lining of the
- # following constructors:
- # - _ConstraintData,
- # - ActiveComponentData
- # - ComponentData
- self._component = weakref_ref(component) if (component is not None) else None
- self._index = NOTSET
- self._active = True
-
- #
- # Interface
- #
-
- def __call__(self, exception=True):
- """Compute the value of the body of this constraint."""
- return value(self.body, exception=exception)
-
- def has_lb(self):
- """Returns :const:`False` when the lower bound is
- :const:`None` or negative infinity"""
- return self.lb is not None
-
- def has_ub(self):
- """Returns :const:`False` when the upper bound is
- :const:`None` or positive infinity"""
- return self.ub is not None
-
- def lslack(self):
- """
- Returns the value of f(x)-L for constraints of the form:
- L <= f(x) (<= U)
- (U >=) f(x) >= L
- """
- lb = self.lb
- if lb is None:
- return _inf
- else:
- return value(self.body) - lb
-
- def uslack(self):
- """
- Returns the value of U-f(x) for constraints of the form:
- (L <=) f(x) <= U
- U >= f(x) (>= L)
- """
- ub = self.ub
- if ub is None:
- return _inf
- else:
- return ub - value(self.body)
-
- def slack(self):
- """
- Returns the smaller of lslack and uslack values
- """
- lb = self.lb
- ub = self.ub
- body = value(self.body)
- if lb is None:
- return ub - body
- elif ub is None:
- return body - lb
- return min(ub - body, body - lb)
-
- #
- # Abstract Interface
- #
-
- @property
- def body(self):
- """Access the body of a constraint expression."""
- raise NotImplementedError
-
- @property
- def lower(self):
- """Access the lower bound of a constraint expression."""
- raise NotImplementedError
-
- @property
- def upper(self):
- """Access the upper bound of a constraint expression."""
- raise NotImplementedError
-
- @property
- def lb(self):
- """Access the value of the lower bound of a constraint expression."""
- raise NotImplementedError
-
- @property
- def ub(self):
- """Access the value of the upper bound of a constraint expression."""
- raise NotImplementedError
-
- @property
- def equality(self):
- """A boolean indicating whether this is an equality constraint."""
- raise NotImplementedError
-
- @property
- def strict_lower(self):
- """True if this constraint has a strict lower bound."""
- raise NotImplementedError
-
- @property
- def strict_upper(self):
- """True if this constraint has a strict upper bound."""
- raise NotImplementedError
-
- def set_value(self, expr):
- """Set the expression on this constraint."""
- raise NotImplementedError
-
- def get_value(self):
- """Get the expression on this constraint."""
- raise NotImplementedError
-
-
-class _GeneralConstraintData(_ConstraintData):
- """
- This class defines the data for a single general constraint.
-
- Constructor arguments:
- component The Constraint object that owns this data.
- expr The Pyomo expression stored in this constraint.
-
- Public class attributes:
- active A boolean that is true if this constraint is
- active in the model.
- body The Pyomo expression for this constraint
- lower The Pyomo expression for the lower bound
- upper The Pyomo expression for the upper bound
- equality A boolean that indicates whether this is an
- equality constraint
- strict_lower A boolean that indicates whether this
- constraint uses a strict lower bound
- strict_upper A boolean that indicates whether this
- constraint uses a strict upper bound
-
- Private class attributes:
- _component The objective component.
- _active A boolean that indicates whether this data is active
- """
-
- __slots__ = ('_body', '_lower', '_upper', '_expr')
-
def __init__(self, expr=None, component=None):
#
# These lines represent in-lining of the
# following constructors:
- # - _ConstraintData,
+ # - ConstraintData,
# - ActiveComponentData
# - ComponentData
self._component = weakref_ref(component) if (component is not None) else None
@@ -319,9 +174,9 @@ def __init__(self, expr=None, component=None):
if expr is not None:
self.set_value(expr)
- #
- # Abstract Interface
- #
+ def __call__(self, exception=True):
+ """Compute the value of the body of this constraint."""
+ return value(self.body, exception=exception)
@property
def body(self):
@@ -445,6 +300,16 @@ def strict_upper(self):
"""True if this constraint has a strict upper bound."""
return False
+ def has_lb(self):
+ """Returns :const:`False` when the lower bound is
+ :const:`None` or negative infinity"""
+ return self.lb is not None
+
+ def has_ub(self):
+ """Returns :const:`False` when the upper bound is
+ :const:`None` or positive infinity"""
+ return self.ub is not None
+
@property
def expr(self):
"""Return the expression associated with this constraint."""
@@ -672,6 +537,53 @@ def set_value(self, expr):
"upper bound (%s)." % (self.name, self._upper)
)
+ def lslack(self):
+ """
+ Returns the value of f(x)-L for constraints of the form:
+ L <= f(x) (<= U)
+ (U >=) f(x) >= L
+ """
+ lb = self.lb
+ if lb is None:
+ return _inf
+ else:
+ return value(self.body) - lb
+
+ def uslack(self):
+ """
+ Returns the value of U-f(x) for constraints of the form:
+ (L <=) f(x) <= U
+ U >= f(x) (>= L)
+ """
+ ub = self.ub
+ if ub is None:
+ return _inf
+ else:
+ return ub - value(self.body)
+
+ def slack(self):
+ """
+ Returns the smaller of lslack and uslack values
+ """
+ lb = self.lb
+ ub = self.ub
+ body = value(self.body)
+ if lb is None:
+ return ub - body
+ elif ub is None:
+ return body - lb
+ return min(ub - body, body - lb)
+
+
+class _ConstraintData(metaclass=RenamedClass):
+ __renamed__new_class__ = ConstraintData
+ __renamed__version__ = '6.7.2'
+
+
+class _GeneralConstraintData(metaclass=RenamedClass):
+ __renamed__new_class__ = ConstraintData
+ __renamed__version__ = '6.7.2'
+
@ModelComponentFactory.register("General constraint expressions.")
class Constraint(ActiveIndexedComponent):
@@ -715,7 +627,7 @@ class Constraint(ActiveIndexedComponent):
The class type for the derived subclass
"""
- _ComponentDataClass = _GeneralConstraintData
+ _ComponentDataClass = ConstraintData
class Infeasible(object):
pass
@@ -725,6 +637,17 @@ class Infeasible(object):
Violated = Infeasible
Satisfied = Feasible
+ @overload
+ def __new__(
+ cls: Type[Constraint], *args, **kwds
+ ) -> Union[ScalarConstraint, IndexedConstraint]: ...
+
+ @overload
+ def __new__(cls: Type[ScalarConstraint], *args, **kwds) -> ScalarConstraint: ...
+
+ @overload
+ def __new__(cls: Type[IndexedConstraint], *args, **kwds) -> IndexedConstraint: ...
+
def __new__(cls, *args, **kwds):
if cls != Constraint:
return super(Constraint, cls).__new__(cls)
@@ -862,14 +785,14 @@ def display(self, prefix="", ostream=None):
)
-class ScalarConstraint(_GeneralConstraintData, Constraint):
+class ScalarConstraint(ConstraintData, Constraint):
"""
ScalarConstraint is the implementation representing a single,
non-indexed constraint.
"""
def __init__(self, *args, **kwds):
- _GeneralConstraintData.__init__(self, component=self, expr=None)
+ ConstraintData.__init__(self, component=self, expr=None)
Constraint.__init__(self, *args, **kwds)
self._index = UnindexedComponent_index
@@ -880,7 +803,7 @@ def __init__(self, *args, **kwds):
# currently in place). So during initialization only, we will
# treat them as "indexed" objects where things like
# Constraint.Skip are managed. But after that they will behave
- # like _ConstraintData objects where set_value does not handle
+ # like ConstraintData objects where set_value does not handle
# Constraint.Skip but expects a valid expression or None.
#
@property
@@ -893,7 +816,7 @@ def body(self):
"an expression. There is currently "
"nothing to access." % (self.name)
)
- return _GeneralConstraintData.body.fget(self)
+ return ConstraintData.body.fget(self)
@property
def lower(self):
@@ -905,7 +828,7 @@ def lower(self):
"an expression. There is currently "
"nothing to access." % (self.name)
)
- return _GeneralConstraintData.lower.fget(self)
+ return ConstraintData.lower.fget(self)
@property
def upper(self):
@@ -917,7 +840,7 @@ def upper(self):
"an expression. There is currently "
"nothing to access." % (self.name)
)
- return _GeneralConstraintData.upper.fget(self)
+ return ConstraintData.upper.fget(self)
@property
def equality(self):
@@ -929,7 +852,7 @@ def equality(self):
"an expression. There is currently "
"nothing to access." % (self.name)
)
- return _GeneralConstraintData.equality.fget(self)
+ return ConstraintData.equality.fget(self)
@property
def strict_lower(self):
@@ -941,7 +864,7 @@ def strict_lower(self):
"an expression. There is currently "
"nothing to access." % (self.name)
)
- return _GeneralConstraintData.strict_lower.fget(self)
+ return ConstraintData.strict_lower.fget(self)
@property
def strict_upper(self):
@@ -953,7 +876,7 @@ def strict_upper(self):
"an expression. There is currently "
"nothing to access." % (self.name)
)
- return _GeneralConstraintData.strict_upper.fget(self)
+ return ConstraintData.strict_upper.fget(self)
def clear(self):
self._data = {}
@@ -1017,6 +940,11 @@ def add(self, index, expr):
"""Add a constraint with a given index."""
return self.__setitem__(index, expr)
+ @overload
+ def __getitem__(self, index) -> ConstraintData: ...
+
+ __getitem__ = IndexedComponent.__getitem__ # type: ignore
+
@ModelComponentFactory.register("A list of constraint expressions.")
class ConstraintList(IndexedConstraint):
diff --git a/pyomo/core/base/expression.py b/pyomo/core/base/expression.py
index 3ce998b62a4..a5120759236 100644
--- a/pyomo/core/base/expression.py
+++ b/pyomo/core/base/expression.py
@@ -36,24 +36,24 @@
logger = logging.getLogger('pyomo.core')
-class _ExpressionData(numeric_expr.NumericValue):
- """
- An object that defines a named expression.
+class NamedExpressionData(numeric_expr.NumericValue):
+ """An object that defines a generic "named expression".
+
+ This is the base class for both :py:class:`ExpressionData` and
+ :py:class:`ObjectiveData`.
Public Class Attributes
expr The expression owned by this data.
+
"""
+ # Note: derived classes are expected to declare the _args_ slot
__slots__ = ()
EXPRESSION_SYSTEM = EXPR.ExpressionType.NUMERIC
PRECEDENCE = 0
ASSOCIATIVITY = EXPR.OperatorAssociativity.NON_ASSOCIATIVE
- #
- # Interface
- #
-
def __call__(self, exception=True):
"""Compute the value of this expression."""
(arg,) = self._args_
@@ -62,6 +62,18 @@ def __call__(self, exception=True):
return arg
return arg(exception=exception)
+ def create_node_with_local_data(self, values):
+ """
+ Construct a simple expression after constructing the
+ contained expression.
+
+ This class provides a consistent interface for constructing a
+ node, which is used in tree visitor scripts.
+ """
+ obj = self.__class__()
+ obj._args_ = values
+ return obj
+
def is_named_expression_type(self):
"""A boolean indicating whether this in a named expression."""
return True
@@ -110,9 +122,10 @@ def _compute_polynomial_degree(self, result):
def _is_fixed(self, values):
return values[0]
- #
- # Abstract Interface
- #
+ # NamedExpressionData should never return False because
+ # they can store subexpressions that contain variables
+ def is_potentially_variable(self):
+ return True
@property
def expr(self):
@@ -125,58 +138,6 @@ def expr(self):
def expr(self, value):
self.set_value(value)
- def set_value(self, expr):
- """Set the expression on this expression."""
- raise NotImplementedError
-
- def is_constant(self):
- """A boolean indicating whether this expression is constant."""
- raise NotImplementedError
-
- def is_fixed(self):
- """A boolean indicating whether this expression is fixed."""
- raise NotImplementedError
-
- # _ExpressionData should never return False because
- # they can store subexpressions that contain variables
- def is_potentially_variable(self):
- return True
-
-
-class _GeneralExpressionDataImpl(_ExpressionData):
- """
- An object that defines an expression that is never cloned
-
- Constructor Arguments
- expr The Pyomo expression stored in this expression.
- component The Expression object that owns this data.
-
- Public Class Attributes
- expr The expression owned by this data.
- """
-
- __slots__ = ()
-
- def __init__(self, expr=None):
- self._args_ = (expr,)
-
- def create_node_with_local_data(self, values):
- """
- Construct a simple expression after constructing the
- contained expression.
-
- This class provides a consistent interface for constructing a
- node, which is used in tree visitor scripts.
- """
- obj = ScalarExpression()
- obj.construct()
- obj._args_ = values
- return obj
-
- #
- # Abstract Interface
- #
-
def set_value(self, expr):
"""Set the expression on this expression."""
if expr is None or expr.__class__ in native_numeric_types:
@@ -235,7 +196,17 @@ def __ipow__(self, other):
return numeric_expr._pow_dispatcher[e.__class__, other.__class__](e, other)
-class _GeneralExpressionData(_GeneralExpressionDataImpl, ComponentData):
+class _ExpressionData(metaclass=RenamedClass):
+ __renamed__new_class__ = NamedExpressionData
+ __renamed__version__ = '6.7.2'
+
+
+class _GeneralExpressionDataImpl(metaclass=RenamedClass):
+ __renamed__new_class__ = NamedExpressionData
+ __renamed__version__ = '6.7.2'
+
+
+class ExpressionData(NamedExpressionData, ComponentData):
"""
An object that defines an expression that is never cloned
@@ -253,12 +224,16 @@ class _GeneralExpressionData(_GeneralExpressionDataImpl, ComponentData):
__slots__ = ('_args_',)
def __init__(self, expr=None, component=None):
- _GeneralExpressionDataImpl.__init__(self, expr)
- # Inlining ComponentData.__init__
+ self._args_ = (expr,)
self._component = weakref_ref(component) if (component is not None) else None
self._index = NOTSET
+class _GeneralExpressionData(metaclass=RenamedClass):
+ __renamed__new_class__ = ExpressionData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register(
"Named expressions that can be used in other expressions."
)
@@ -275,7 +250,7 @@ class Expression(IndexedComponent):
doc Text describing this component.
"""
- _ComponentDataClass = _GeneralExpressionData
+ _ComponentDataClass = ExpressionData
# This seems like a copy-paste error, and should be renamed/removed
NoConstraint = IndexedComponent.Skip
@@ -402,9 +377,9 @@ def construct(self, data=None):
timer.report()
-class ScalarExpression(_GeneralExpressionData, Expression):
+class ScalarExpression(ExpressionData, Expression):
def __init__(self, *args, **kwds):
- _GeneralExpressionData.__init__(self, expr=None, component=self)
+ ExpressionData.__init__(self, expr=None, component=self)
Expression.__init__(self, *args, **kwds)
self._index = UnindexedComponent_index
@@ -427,7 +402,7 @@ def __call__(self, exception=True):
def expr(self):
"""Return expression on this expression."""
if self._constructed:
- return _GeneralExpressionData.expr.fget(self)
+ return ExpressionData.expr.fget(self)
raise ValueError(
"Accessing the expression of Expression '%s' "
"before the Expression has been constructed (there "
@@ -445,7 +420,7 @@ def clear(self):
def set_value(self, expr):
"""Set the expression on this expression."""
if self._constructed:
- return _GeneralExpressionData.set_value(self, expr)
+ return ExpressionData.set_value(self, expr)
raise ValueError(
"Setting the expression of Expression '%s' "
"before the Expression has been constructed (there "
@@ -455,7 +430,7 @@ def set_value(self, expr):
def is_constant(self):
"""A boolean indicating whether this expression is constant."""
if self._constructed:
- return _GeneralExpressionData.is_constant(self)
+ return ExpressionData.is_constant(self)
raise ValueError(
"Accessing the is_constant flag of Expression '%s' "
"before the Expression has been constructed (there "
@@ -465,7 +440,7 @@ def is_constant(self):
def is_fixed(self):
"""A boolean indicating whether this expression is fixed."""
if self._constructed:
- return _GeneralExpressionData.is_fixed(self)
+ return ExpressionData.is_fixed(self)
raise ValueError(
"Accessing the is_fixed flag of Expression '%s' "
"before the Expression has been constructed (there "
@@ -509,6 +484,6 @@ def add(self, index, expr):
"""Add an expression with a given index."""
if (type(expr) is tuple) and (expr == Expression.Skip):
return None
- cdata = _GeneralExpressionData(expr, component=self)
+ cdata = ExpressionData(expr, component=self)
self._data[index] = cdata
return cdata
diff --git a/pyomo/core/base/external.py b/pyomo/core/base/external.py
index 3c0038d745d..0fda004b664 100644
--- a/pyomo/core/base/external.py
+++ b/pyomo/core/base/external.py
@@ -31,14 +31,14 @@
from pyomo.common.autoslots import AutoSlots
from pyomo.common.fileutils import find_library
-from pyomo.core.expr.numvalue import (
+from pyomo.common.numeric_types import (
+ check_if_native_type,
native_types,
native_numeric_types,
- pyomo_constant_types,
- NonNumericValue,
- NumericConstant,
value,
+ _pyomo_constant_types,
)
+from pyomo.core.expr.numvalue import NonNumericValue, NumericConstant
import pyomo.core.expr as EXPR
from pyomo.core.base.component import Component
from pyomo.core.base.units_container import units
@@ -197,14 +197,15 @@ def __call__(self, *args):
pv = False
for i, arg in enumerate(args_):
try:
- # Q: Is there a better way to test if a value is an object
- # not in native_types and not a standard expression type?
if arg.__class__ in native_types:
continue
if arg.is_potentially_variable():
pv = True
+ continue
except AttributeError:
- args_[i] = NonNumericValue(arg)
+ if check_if_native_type(arg):
+ continue
+ args_[i] = NonNumericValue(arg)
#
if pv:
return EXPR.ExternalFunctionExpression(args_, self)
@@ -491,7 +492,7 @@ def is_constant(self):
return False
-pyomo_constant_types.add(_PythonCallbackFunctionID)
+_pyomo_constant_types.add(_PythonCallbackFunctionID)
class PythonCallbackFunction(ExternalFunction):
diff --git a/pyomo/core/base/indexed_component.py b/pyomo/core/base/indexed_component.py
index abb29580960..37a62e5c4d7 100644
--- a/pyomo/core/base/indexed_component.py
+++ b/pyomo/core/base/indexed_component.py
@@ -18,7 +18,7 @@
import pyomo.core.base as BASE
from pyomo.core.base.indexed_component_slice import IndexedComponent_slice
from pyomo.core.base.initializer import Initializer
-from pyomo.core.base.component import Component, ActiveComponent
+from pyomo.core.base.component import Component, ActiveComponent, ComponentData
from pyomo.core.base.config import PyomoOptions
from pyomo.core.base.enums import SortComponents
from pyomo.core.base.global_set import UnindexedComponent_set
@@ -160,9 +160,12 @@ def _get_indexed_component_data_name(component, index):
"""
-def rule_result_substituter(result_map):
+def rule_result_substituter(result_map, map_types):
_map = result_map
- _map_types = set(type(key) for key in result_map)
+ if map_types is None:
+ _map_types = set(type(key) for key in result_map)
+ else:
+ _map_types = map_types
def rule_result_substituter_impl(rule, *args, **kwargs):
if rule.__class__ in _map_types:
@@ -203,7 +206,7 @@ def rule_result_substituter_impl(rule, *args, **kwargs):
"""
-def rule_wrapper(rule, wrapping_fcn, positional_arg_map=None):
+def rule_wrapper(rule, wrapping_fcn, positional_arg_map=None, map_types=None):
"""Wrap a rule with another function
This utility method provides a way to wrap a function (rule) with
@@ -230,7 +233,7 @@ def rule_wrapper(rule, wrapping_fcn, positional_arg_map=None):
"""
if isinstance(wrapping_fcn, dict):
- wrapping_fcn = rule_result_substituter(wrapping_fcn)
+ wrapping_fcn = rule_result_substituter(wrapping_fcn, map_types)
if not inspect.isfunction(rule):
return wrapping_fcn(rule)
# Because some of our processing of initializer functions relies on
@@ -603,7 +606,7 @@ def iteritems(self):
"""Return a list (index,data) tuples from the dictionary"""
return self.items()
- def __getitem__(self, index):
+ def __getitem__(self, index) -> ComponentData:
"""
This method returns the data corresponding to the given index.
"""
@@ -728,7 +731,7 @@ def __delitem__(self, index):
# this supports "del m.x[:,1]" through a simple recursive call
if index.__class__ is IndexedComponent_slice:
- # Assert that this slice ws just generated
+ # Assert that this slice was just generated
assert len(index._call_stack) == 1
# Make a copy of the slicer items *before* we start
# iterating over it (since we will be removing items!).
diff --git a/pyomo/core/base/logical_constraint.py b/pyomo/core/base/logical_constraint.py
index f32d727931a..cc0780fd9bd 100644
--- a/pyomo/core/base/logical_constraint.py
+++ b/pyomo/core/base/logical_constraint.py
@@ -42,64 +42,7 @@
"""
-class _LogicalConstraintData(ActiveComponentData):
- """
- This class defines the data for a single logical constraint.
-
- It functions as a pure interface.
-
- Constructor arguments:
- component The LogicalConstraint object that owns this data.
-
- Public class attributes:
- active A boolean that is true if this statement is
- active in the model.
- body The Pyomo logical expression for this statement
-
- Private class attributes:
- _component The statement component.
- _active A boolean that indicates whether this data is active
- """
-
- __slots__ = ()
-
- def __init__(self, component=None):
- #
- # These lines represent in-lining of the
- # following constructors:
- # - ActiveComponentData
- # - ComponentData
- self._component = weakref_ref(component) if (component is not None) else None
- self._index = NOTSET
- self._active = True
-
- #
- # Interface
- #
- def __call__(self, exception=True):
- """Compute the value of the body of this logical constraint."""
- if self.body is None:
- return None
- return self.body(exception=exception)
-
- #
- # Abstract Interface
- #
- @property
- def expr(self):
- """Get the expression on this logical constraint."""
- raise NotImplementedError
-
- def set_value(self, expr):
- """Set the expression on this logical constraint."""
- raise NotImplementedError
-
- def get_value(self):
- """Get the expression on this logical constraint."""
- raise NotImplementedError
-
-
-class _GeneralLogicalConstraintData(_LogicalConstraintData):
+class LogicalConstraintData(ActiveComponentData):
"""
This class defines the data for a single general logical constraint.
@@ -123,7 +66,7 @@ def __init__(self, expr=None, component=None):
#
# These lines represent in-lining of the
# following constructors:
- # - _LogicalConstraintData,
+ # - LogicalConstraintData,
# - ActiveComponentData
# - ComponentData
self._component = weakref_ref(component) if (component is not None) else None
@@ -134,6 +77,12 @@ def __init__(self, expr=None, component=None):
if expr is not None:
self.set_value(expr)
+ def __call__(self, exception=True):
+ """Compute the value of the body of this logical constraint."""
+ if self.body is None:
+ return None
+ return self.body(exception=exception)
+
#
# Abstract Interface
#
@@ -173,6 +122,16 @@ def get_value(self):
return self._expr
+class _LogicalConstraintData(metaclass=RenamedClass):
+ __renamed__new_class__ = LogicalConstraintData
+ __renamed__version__ = '6.7.2'
+
+
+class _GeneralLogicalConstraintData(metaclass=RenamedClass):
+ __renamed__new_class__ = LogicalConstraintData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register("General logical constraints.")
class LogicalConstraint(ActiveIndexedComponent):
"""
@@ -215,7 +174,7 @@ class LogicalConstraint(ActiveIndexedComponent):
The class type for the derived subclass
"""
- _ComponentDataClass = _GeneralLogicalConstraintData
+ _ComponentDataClass = LogicalConstraintData
class Infeasible(object):
pass
@@ -373,7 +332,7 @@ def display(self, prefix="", ostream=None):
#
# Checks flags like Constraint.Skip, etc. before actually creating a
- # constraint object. Returns the _ConstraintData object when it should be
+ # constraint object. Returns the ConstraintData object when it should be
# added to the _data dict; otherwise, None is returned or an exception
# is raised.
#
@@ -409,14 +368,14 @@ def _check_skip_add(self, index, expr):
return expr
-class ScalarLogicalConstraint(_GeneralLogicalConstraintData, LogicalConstraint):
+class ScalarLogicalConstraint(LogicalConstraintData, LogicalConstraint):
"""
ScalarLogicalConstraint is the implementation representing a single,
non-indexed logical constraint.
"""
def __init__(self, *args, **kwds):
- _GeneralLogicalConstraintData.__init__(self, component=self, expr=None)
+ LogicalConstraintData.__init__(self, component=self, expr=None)
LogicalConstraint.__init__(self, *args, **kwds)
self._index = UnindexedComponent_index
@@ -436,7 +395,7 @@ def body(self):
"an expression. There is currently "
"nothing to access." % self.name
)
- return _GeneralLogicalConstraintData.body.fget(self)
+ return LogicalConstraintData.body.fget(self)
raise ValueError(
"Accessing the body of logical constraint '%s' "
"before the LogicalConstraint has been constructed (there "
@@ -450,7 +409,7 @@ def body(self):
# currently in place). So during initialization only, we will
# treat them as "indexed" objects where things like
# True are managed. But after that they will behave
- # like _LogicalConstraintData objects where set_value expects
+ # like LogicalConstraintData objects where set_value expects
# a valid expression or None.
#
diff --git a/pyomo/core/base/matrix_constraint.py b/pyomo/core/base/matrix_constraint.py
index adc9742302e..8dac7c3d24b 100644
--- a/pyomo/core/base/matrix_constraint.py
+++ b/pyomo/core/base/matrix_constraint.py
@@ -19,7 +19,7 @@
from pyomo.core.expr.numvalue import value
from pyomo.core.expr.numeric_expr import LinearExpression
from pyomo.core.base.component import ModelComponentFactory
-from pyomo.core.base.constraint import IndexedConstraint, _ConstraintData
+from pyomo.core.base.constraint import IndexedConstraint, ConstraintData
from pyomo.repn.standard_repn import StandardRepn
from collections.abc import Mapping
@@ -28,7 +28,7 @@
logger = logging.getLogger('pyomo.core')
-class _MatrixConstraintData(_ConstraintData):
+class _MatrixConstraintData(ConstraintData):
"""
This class defines the data for a single linear constraint
derived from a canonical form Ax=b constraint.
@@ -104,7 +104,7 @@ def __init__(self, index, component_ref):
#
# These lines represent in-lining of the
# following constructors:
- # - _ConstraintData,
+ # - ConstraintData,
# - ActiveComponentData
# - ComponentData
self._component = component_ref
@@ -209,7 +209,7 @@ def index(self):
return self._index
#
- # Abstract Interface (_ConstraintData)
+ # Abstract Interface (ConstraintData)
#
@property
diff --git a/pyomo/core/base/objective.py b/pyomo/core/base/objective.py
index fcc63755f2b..f1204f2a09c 100644
--- a/pyomo/core/base/objective.py
+++ b/pyomo/core/base/objective.py
@@ -15,6 +15,7 @@
from pyomo.common.pyomo_typing import overload
from pyomo.common.deprecation import RenamedClass
+from pyomo.common.enums import ObjectiveSense, minimize, maximize
from pyomo.common.log import is_debug_set
from pyomo.common.modeling import NOTSET
from pyomo.common.formatting import tabular_writer
@@ -28,14 +29,13 @@
UnindexedComponent_set,
rule_wrapper,
)
-from pyomo.core.base.expression import _ExpressionData, _GeneralExpressionDataImpl
+from pyomo.core.base.expression import NamedExpressionData
from pyomo.core.base.set import Set
from pyomo.core.base.initializer import (
Initializer,
IndexedCallInitializer,
CountedCallInitializer,
)
-from pyomo.core.base import minimize, maximize
logger = logging.getLogger('pyomo.core')
@@ -81,47 +81,7 @@ def O_rule(model, i, j):
return rule_wrapper(rule, {None: ObjectiveList.End})
-#
-# This class is a pure interface
-#
-
-
-class _ObjectiveData(_ExpressionData):
- """
- This class defines the data for a single objective.
-
- Public class attributes:
- expr The Pyomo expression for this objective
- sense The direction for this objective.
- """
-
- __slots__ = ()
-
- #
- # Interface
- #
-
- def is_minimizing(self):
- """Return True if this is a minimization objective."""
- return self.sense == minimize
-
- #
- # Abstract Interface
- #
-
- @property
- def sense(self):
- """Access sense (direction) of this objective."""
- raise NotImplementedError
-
- def set_sense(self, sense):
- """Set the sense (direction) of this objective."""
- raise NotImplementedError
-
-
-class _GeneralObjectiveData(
- _GeneralExpressionDataImpl, _ObjectiveData, ActiveComponentData
-):
+class ObjectiveData(NamedExpressionData, ActiveComponentData):
"""
This class defines the data for a single objective.
@@ -144,22 +104,20 @@ class _GeneralObjectiveData(
_active A boolean that indicates whether this data is active
"""
- __slots__ = ("_sense", "_args_")
+ __slots__ = ("_args_", "_sense")
def __init__(self, expr=None, sense=minimize, component=None):
- _GeneralExpressionDataImpl.__init__(self, expr)
+ # Inlining NamedExpressionData.__init__
+ self._args_ = (expr,)
# Inlining ActiveComponentData.__init__
self._component = weakref_ref(component) if (component is not None) else None
self._index = NOTSET
self._active = True
- self._sense = sense
+ self._sense = ObjectiveSense(sense)
- if (self._sense != minimize) and (self._sense != maximize):
- raise ValueError(
- "Objective sense must be set to one of "
- "'minimize' (%s) or 'maximize' (%s). Invalid "
- "value: %s'" % (minimize, maximize, sense)
- )
+ def is_minimizing(self):
+ """Return True if this is a minimization objective."""
+ return self.sense == minimize
def set_value(self, expr):
if expr is None:
@@ -182,14 +140,17 @@ def sense(self, sense):
def set_sense(self, sense):
"""Set the sense (direction) of this objective."""
- if sense in {minimize, maximize}:
- self._sense = sense
- else:
- raise ValueError(
- "Objective sense must be set to one of "
- "'minimize' (%s) or 'maximize' (%s). Invalid "
- "value: %s'" % (minimize, maximize, sense)
- )
+ self._sense = ObjectiveSense(sense)
+
+
+class _ObjectiveData(metaclass=RenamedClass):
+ __renamed__new_class__ = ObjectiveData
+ __renamed__version__ = '6.7.2'
+
+
+class _GeneralObjectiveData(metaclass=RenamedClass):
+ __renamed__new_class__ = ObjectiveData
+ __renamed__version__ = '6.7.2'
@ModelComponentFactory.register("Expressions that are minimized or maximized.")
@@ -240,7 +201,7 @@ class Objective(ActiveIndexedComponent):
The class type for the derived subclass
"""
- _ComponentDataClass = _GeneralObjectiveData
+ _ComponentDataClass = ObjectiveData
NoObjective = ActiveIndexedComponent.Skip
def __new__(cls, *args, **kwds):
@@ -353,11 +314,7 @@ def _pprint(self):
],
self._data.items(),
("Active", "Sense", "Expression"),
- lambda k, v: [
- v.active,
- ("minimize" if (v.sense == minimize) else "maximize"),
- v.expr,
- ],
+ lambda k, v: [v.active, v.sense, v.expr],
)
def display(self, prefix="", ostream=None):
@@ -389,14 +346,14 @@ def display(self, prefix="", ostream=None):
)
-class ScalarObjective(_GeneralObjectiveData, Objective):
+class ScalarObjective(ObjectiveData, Objective):
"""
ScalarObjective is the implementation representing a single,
non-indexed objective.
"""
def __init__(self, *args, **kwd):
- _GeneralObjectiveData.__init__(self, expr=None, component=self)
+ ObjectiveData.__init__(self, expr=None, component=self)
Objective.__init__(self, *args, **kwd)
self._index = UnindexedComponent_index
@@ -432,7 +389,7 @@ def expr(self):
"a sense or expression (there is currently "
"no value to return)." % (self.name)
)
- return _GeneralObjectiveData.expr.fget(self)
+ return ObjectiveData.expr.fget(self)
raise ValueError(
"Accessing the expression of objective '%s' "
"before the Objective has been constructed (there "
@@ -455,7 +412,7 @@ def sense(self):
"a sense or expression (there is currently "
"no value to return)." % (self.name)
)
- return _GeneralObjectiveData.sense.fget(self)
+ return ObjectiveData.sense.fget(self)
raise ValueError(
"Accessing the sense of objective '%s' "
"before the Objective has been constructed (there "
@@ -474,7 +431,7 @@ def sense(self, sense):
# currently in place). So during initialization only, we will
# treat them as "indexed" objects where things like
# Objective.Skip are managed. But after that they will behave
- # like _ObjectiveData objects where set_value does not handle
+ # like ObjectiveData objects where set_value does not handle
# Objective.Skip but expects a valid expression or None
#
@@ -498,7 +455,7 @@ def set_sense(self, sense):
if self._constructed:
if len(self._data) == 0:
self._data[None] = self
- return _GeneralObjectiveData.set_sense(self, sense)
+ return ObjectiveData.set_sense(self, sense)
raise ValueError(
"Setting the sense of objective '%s' "
"before the Objective has been constructed (there "
diff --git a/pyomo/core/base/param.py b/pyomo/core/base/param.py
index 03d700140e8..45de3286589 100644
--- a/pyomo/core/base/param.py
+++ b/pyomo/core/base/param.py
@@ -9,11 +9,13 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
+from __future__ import annotations
import sys
import types
import logging
from weakref import ref as weakref_ref
from pyomo.common.pyomo_typing import overload
+from typing import Union, Type
from pyomo.common.autoslots import AutoSlots
from pyomo.common.deprecation import deprecation_warning, RenamedClass
@@ -116,7 +118,7 @@ def _parent(self, val):
pass
-class _ParamData(ComponentData, NumericValue):
+class ParamData(ComponentData, NumericValue):
"""
This class defines the data for a mutable parameter.
@@ -162,16 +164,31 @@ def set_value(self, value, idx=NOTSET):
# required to be mutable.
#
_comp = self.parent_component()
- if type(value) in native_types:
+ if value.__class__ in native_types:
# TODO: warn/error: check if this Param has units: assigning
# a dimensionless value to a united param should be an error
pass
elif _comp._units is not None:
_src_magnitude = expr_value(value)
- _src_units = units.get_units(value)
- value = units.convert_value(
- num_value=_src_magnitude, from_units=_src_units, to_units=_comp._units
- )
+ # Note: expr_value() could have just registered a new numeric type
+ if value.__class__ in native_types:
+ value = _src_magnitude
+ else:
+ _src_units = units.get_units(value)
+ value = units.convert_value(
+ num_value=_src_magnitude,
+ from_units=_src_units,
+ to_units=_comp._units,
+ )
+ # FIXME: we should call value() here [to ensure types get
+ # registered], but doing so breaks non-numeric Params (which we
+ # allow). The real fix will be to follow the precedent from
+ # GetItemExpression and have separate types based on which
+ # expression "system" the Param should participate in (numeric,
+ # logical, or structural).
+ #
+ # else:
+ # value = expr_value(value)
old_value, self._value = self._value, value
try:
@@ -235,6 +252,11 @@ def _compute_polynomial_degree(self, result):
return 0
+class _ParamData(metaclass=RenamedClass):
+ __renamed__new_class__ = ParamData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register(
"Parameter data that is used to define a model instance."
)
@@ -268,7 +290,7 @@ class Param(IndexedComponent, IndexedComponent_NDArrayMixin):
"""
DefaultMutable = False
- _ComponentDataClass = _ParamData
+ _ComponentDataClass = ParamData
class NoValue(object):
"""A dummy type that is pickle-safe that we can use as the default
@@ -276,6 +298,17 @@ class NoValue(object):
pass
+ @overload
+ def __new__(
+ cls: Type[Param], *args, **kwds
+ ) -> Union[ScalarParam, IndexedParam]: ...
+
+ @overload
+ def __new__(cls: Type[ScalarParam], *args, **kwds) -> ScalarParam: ...
+
+ @overload
+ def __new__(cls: Type[IndexedParam], *args, **kwds) -> IndexedParam: ...
+
def __new__(cls, *args, **kwds):
if cls != Param:
return super(Param, cls).__new__(cls)
@@ -495,14 +528,14 @@ def store_values(self, new_values, check=True):
# instead of incurring the penalty of checking.
for index, new_value in new_values.items():
if index not in self._data:
- self._data[index] = _ParamData(self)
+ self._data[index] = ParamData(self)
self._data[index]._value = new_value
else:
# For scalars, we will choose an approach based on
# how "dense" the Param is
if not self._data: # empty
for index in self._index_set:
- p = self._data[index] = _ParamData(self)
+ p = self._data[index] = ParamData(self)
p._value = new_values
elif len(self._data) == len(self._index_set):
for index in self._index_set:
@@ -510,7 +543,7 @@ def store_values(self, new_values, check=True):
else:
for index in self._index_set:
if index not in self._data:
- self._data[index] = _ParamData(self)
+ self._data[index] = ParamData(self)
self._data[index]._value = new_values
else:
#
@@ -573,9 +606,9 @@ def _getitem_when_not_present(self, index):
# a default value, as long as *solving* a model without
# reasonable values produces an informative error.
if self._mutable:
- # Note: _ParamData defaults to Param.NoValue
+ # Note: ParamData defaults to Param.NoValue
if self.is_indexed():
- ans = self._data[index] = _ParamData(self)
+ ans = self._data[index] = ParamData(self)
else:
ans = self._data[index] = self
ans._index = index
@@ -670,8 +703,8 @@ def _setitem_impl(self, index, obj, value):
return obj
else:
old_value, self._data[index] = self._data[index], value
- # Because we do not have a _ParamData, we cannot rely on the
- # validation that occurs in _ParamData.set_value()
+ # Because we do not have a ParamData, we cannot rely on the
+ # validation that occurs in ParamData.set_value()
try:
self._validate_value(index, value)
return value
@@ -708,14 +741,14 @@ def _setitem_when_not_present(self, index, value, _check_domain=True):
self._index = UnindexedComponent_index
return self
elif self._mutable:
- obj = self._data[index] = _ParamData(self)
+ obj = self._data[index] = ParamData(self)
obj.set_value(value, index)
obj._index = index
return obj
else:
self._data[index] = value
- # Because we do not have a _ParamData, we cannot rely on the
- # validation that occurs in _ParamData.set_value()
+ # Because we do not have a ParamData, we cannot rely on the
+ # validation that occurs in ParamData.set_value()
self._validate_value(index, value, _check_domain)
return value
except:
@@ -873,9 +906,9 @@ def _pprint(self):
return (headers, self.sparse_iteritems(), ("Value",), dataGen)
-class ScalarParam(_ParamData, Param):
+class ScalarParam(ParamData, Param):
def __init__(self, *args, **kwds):
- _ParamData.__init__(self, component=self)
+ ParamData.__init__(self, component=self)
Param.__init__(self, *args, **kwds)
self._index = UnindexedComponent_index
@@ -968,7 +1001,7 @@ def _create_objects_for_deepcopy(self, memo, component_list):
# between potentially variable GetItemExpression objects and
# "constant" GetItemExpression objects. That will need to wait for
# the expression rework [JDS; Nov 22].
- def __getitem__(self, args):
+ def __getitem__(self, args) -> ParamData:
try:
return super().__getitem__(args)
except:
diff --git a/pyomo/core/base/piecewise.py b/pyomo/core/base/piecewise.py
index 7817a61b2f2..8c5f34d2b53 100644
--- a/pyomo/core/base/piecewise.py
+++ b/pyomo/core/base/piecewise.py
@@ -40,14 +40,14 @@
import enum
from pyomo.common.log import is_debug_set
-from pyomo.common.deprecation import deprecation_warning
+from pyomo.common.deprecation import RenamedClass, deprecation_warning
from pyomo.common.numeric_types import value
from pyomo.common.timing import ConstructionTimer
-from pyomo.core.base.block import Block, _BlockData
+from pyomo.core.base.block import Block, BlockData
from pyomo.core.base.component import ModelComponentFactory
from pyomo.core.base.constraint import Constraint, ConstraintList
from pyomo.core.base.sos import SOSConstraint
-from pyomo.core.base.var import Var, _VarData, IndexedVar
+from pyomo.core.base.var import Var, VarData, IndexedVar
from pyomo.core.base.set_types import PositiveReals, NonNegativeReals, Binary
from pyomo.core.base.util import flatten_tuple
@@ -214,14 +214,14 @@ def _characterize_function(name, tol, f_rule, model, points, *index):
return 0, values, False
-class _PiecewiseData(_BlockData):
+class PiecewiseData(BlockData):
"""
This class defines the base class for all linearization
and piecewise constraint generators..
"""
def __init__(self, parent):
- _BlockData.__init__(self, parent)
+ BlockData.__init__(self, parent)
self._constructed = True
self._bound_type = None
self._domain_pts = None
@@ -272,6 +272,11 @@ def __call__(self, x):
)
+class _PiecewiseData(metaclass=RenamedClass):
+ __renamed__new_class__ = PiecewiseData
+ __renamed__version__ = '6.7.2'
+
+
class _SimpleSinglePiecewise(object):
"""
Called when the piecewise points list has only two points
@@ -1125,7 +1130,7 @@ def f(model,j,x):
not be modified.
"""
- _ComponentDataClass = _PiecewiseData
+ _ComponentDataClass = PiecewiseData
def __new__(cls, *args, **kwds):
if cls != Piecewise:
@@ -1235,7 +1240,7 @@ def __init__(self, *args, **kwds):
# Check that the variables args are actually Pyomo Vars
if not (
- isinstance(self._domain_var, _VarData)
+ isinstance(self._domain_var, VarData)
or isinstance(self._domain_var, IndexedVar)
):
msg = (
@@ -1244,7 +1249,7 @@ def __init__(self, *args, **kwds):
)
raise TypeError(msg % (repr(self._domain_var),))
if not (
- isinstance(self._range_var, _VarData)
+ isinstance(self._range_var, VarData)
or isinstance(self._range_var, IndexedVar)
):
msg = (
@@ -1354,22 +1359,22 @@ def add(self, index, _is_indexed=None):
_self_yvar = None
_self_domain_pts_index = None
if not _is_indexed:
- # allows one to mix Var and _VarData as input to
+ # allows one to mix Var and VarData as input to
# non-indexed Piecewise, index would be None in this case
- # so for Var elements Var[None] is Var, but _VarData[None] would fail
+ # so for Var elements Var[None] is Var, but VarData[None] would fail
_self_xvar = self._domain_var
_self_yvar = self._range_var
_self_domain_pts_index = self._domain_points[index]
else:
- # The following allows one to specify a Var or _VarData
+ # The following allows one to specify a Var or VarData
# object even with an indexed Piecewise component.
# The most common situation will most likely be a VarArray,
# so we try this first.
- if not isinstance(self._domain_var, _VarData):
+ if not isinstance(self._domain_var, VarData):
_self_xvar = self._domain_var[index]
else:
_self_xvar = self._domain_var
- if not isinstance(self._range_var, _VarData):
+ if not isinstance(self._range_var, VarData):
_self_yvar = self._range_var[index]
else:
_self_yvar = self._range_var
@@ -1541,7 +1546,7 @@ def add(self, index, _is_indexed=None):
raise ValueError(msg % (self.name, index, self._pw_rep))
if _is_indexed:
- comp = _PiecewiseData(self)
+ comp = PiecewiseData(self)
else:
comp = self
self._data[index] = comp
@@ -1551,9 +1556,9 @@ def add(self, index, _is_indexed=None):
comp.build_constraints(func, _self_xvar, _self_yvar)
-class SimplePiecewise(_PiecewiseData, Piecewise):
+class SimplePiecewise(PiecewiseData, Piecewise):
def __init__(self, *args, **kwds):
- _PiecewiseData.__init__(self, self)
+ PiecewiseData.__init__(self, self)
Piecewise.__init__(self, *args, **kwds)
diff --git a/pyomo/core/base/reference.py b/pyomo/core/base/reference.py
index 2279db067a6..558ced64f1b 100644
--- a/pyomo/core/base/reference.py
+++ b/pyomo/core/base/reference.py
@@ -18,7 +18,7 @@
Sequence,
)
from pyomo.common.modeling import NOTSET
-from pyomo.core.base.set import DeclareGlobalSet, Set, SetOf, OrderedSetOf, _SetDataBase
+from pyomo.core.base.set import DeclareGlobalSet, Set, SetOf, OrderedSetOf, SetData
from pyomo.core.base.component import Component, ComponentData
from pyomo.core.base.global_set import UnindexedComponent_set
from pyomo.core.base.enums import SortComponents
@@ -579,7 +579,7 @@ def Reference(reference, ctype=NOTSET):
:py:class:`IndexedComponent`.
If the indices associated with wildcards in the component slice all
- refer to the same :py:class:`Set` objects for all data identifed by
+ refer to the same :py:class:`Set` objects for all data identified by
the slice, then the resulting indexed component will be indexed by
the product of those sets. However, if all data do not share common
set objects, or only a subset of indices in a multidimentional set
@@ -774,10 +774,10 @@ def Reference(reference, ctype=NOTSET):
# is that within the subsets list, and set is a wildcard set.
index = wildcards[0][1]
# index is the first wildcard set.
- if not isinstance(index, _SetDataBase):
+ if not isinstance(index, SetData):
index = SetOf(index)
for lvl, idx in wildcards[1:]:
- if not isinstance(idx, _SetDataBase):
+ if not isinstance(idx, SetData):
idx = SetOf(idx)
index = index * idx
# index is now either a single Set, or a SetProduct of the
diff --git a/pyomo/core/base/set.py b/pyomo/core/base/set.py
index 2dc14460911..8b7c2a246d6 100644
--- a/pyomo/core/base/set.py
+++ b/pyomo/core/base/set.py
@@ -9,6 +9,7 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
+from __future__ import annotations
import inspect
import itertools
import logging
@@ -16,6 +17,8 @@
import sys
import weakref
from pyomo.common.pyomo_typing import overload
+from typing import Union, Type, Any as typingAny
+from collections.abc import Iterator
from pyomo.common.collections import ComponentSet
from pyomo.common.deprecation import deprecated, deprecation_warning, RenamedClass
@@ -47,7 +50,7 @@
RangeDifferenceError,
)
from pyomo.core.base.component import (
- _ComponentBase,
+ ComponentBase,
Component,
ComponentData,
ModelComponentFactory,
@@ -81,10 +84,7 @@
All Sets implement one of the following APIs:
-0. `class _SetDataBase(ComponentData)`
- *(pure virtual interface)*
-
-1. `class _SetData(_SetDataBase)`
+1. `class SetData(ComponentData)`
*(base class for all AML Sets)*
2. `class _FiniteSetMixin(object)`
@@ -99,7 +99,7 @@
bounded continuous ranges as well as unbounded discrete ranges). As
there are an infinite number of values, iteration is *not*
supported. The base class also implements all Python set operations.
-Note that `_SetData` does *not* implement `len()`, as Python requires
+Note that `SetData` does *not* implement `len()`, as Python requires
`len()` to return a positive integer.
Finite sets add iteration and support for `len()`. In addition, they
@@ -125,7 +125,7 @@
def process_setarg(arg):
- if isinstance(arg, _SetDataBase):
+ if isinstance(arg, SetData):
if (
getattr(arg, '_parent', None) is not None
or getattr(arg, '_anonymous_sets', None) is GlobalSetBase
@@ -137,7 +137,7 @@ def process_setarg(arg):
_anonymous.update(arg._anonymous_sets)
return arg, _anonymous
- elif isinstance(arg, _ComponentBase):
+ elif isinstance(arg, ComponentBase):
if isinstance(arg, IndexedComponent) and arg.is_indexed():
raise TypeError(
"Cannot apply a Set operator to an "
@@ -509,16 +509,8 @@ class _NotFound(object):
pass
-# A trivial class that we can use to test if an object is a "legitimate"
-# set (either ScalarSet, or a member of an IndexedSet)
-class _SetDataBase(ComponentData):
- """The base for all objects that can be used as a component indexing set."""
-
- __slots__ = ()
-
-
-class _SetData(_SetDataBase):
- """The base for all Pyomo AML objects that can be used as a component
+class SetData(ComponentData):
+ """The base for all Pyomo objects that can be used as a component
indexing set.
Derived versions of this class can be used as the Index for any
@@ -531,13 +523,13 @@ def __contains__(self, value):
ans = self.get(value, _NotFound)
except TypeError:
# In Python 3.x, Sets are unhashable
- if isinstance(value, _SetData):
+ if isinstance(value, SetData):
ans = _NotFound
else:
raise
if ans is _NotFound:
- if isinstance(value, _SetData):
+ if isinstance(value, SetData):
deprecation_warning(
"Testing for set subsets with 'a in b' is deprecated. "
"Use 'a.issubset(b)'.",
@@ -569,7 +561,7 @@ def isordered(self):
def subsets(self, expand_all_set_operators=None):
return iter((self,))
- def __iter__(self):
+ def __iter__(self) -> Iterator[typingAny]:
"""Iterate over the set members
Raises AttributeError for non-finite sets. This must be
@@ -891,7 +883,7 @@ def _get_continuous_interval(self):
@property
@deprecated("The 'virtual' attribute is no longer supported", version='5.7')
def virtual(self):
- return isinstance(self, (_AnySet, SetOperator, _InfiniteRangeSetData))
+ return isinstance(self, (_AnySet, SetOperator, InfiniteRangeSetData))
@virtual.setter
def virtual(self, value):
@@ -1185,6 +1177,16 @@ def __gt__(self, other):
return self >= other and not self == other
+class _SetData(metaclass=RenamedClass):
+ __renamed__new_class__ = SetData
+ __renamed__version__ = '6.7.2'
+
+
+class _SetDataBase(metaclass=RenamedClass):
+ __renamed__new_class__ = SetData
+ __renamed__version__ = '6.7.2'
+
+
class _FiniteSetMixin(object):
__slots__ = ()
@@ -1291,14 +1293,14 @@ def ranges(self):
yield NonNumericRange(i)
-class _FiniteSetData(_FiniteSetMixin, _SetData):
+class FiniteSetData(_FiniteSetMixin, SetData):
"""A general unordered iterable Set"""
__slots__ = ('_values', '_domain', '_validate', '_filter', '_dimen')
def __init__(self, component):
- _SetData.__init__(self, component=component)
- # Derived classes (like _OrderedSetData) may want to change the
+ SetData.__init__(self, component=component)
+ # Derived classes (like OrderedSetData) may want to change the
# storage
if not hasattr(self, '_values'):
self._values = set()
@@ -1467,6 +1469,11 @@ def pop(self):
return self._values.pop()
+class _FiniteSetData(metaclass=RenamedClass):
+ __renamed__new_class__ = FiniteSetData
+ __renamed__version__ = '6.7.2'
+
+
class _ScalarOrderedSetMixin(object):
# This mixin is required because scalar ordered sets implement
# __getitem__() as an alias of at()
@@ -1627,16 +1634,16 @@ def _to_0_based_index(self, item):
)
-class _OrderedSetData(_OrderedSetMixin, _FiniteSetData):
+class OrderedSetData(_OrderedSetMixin, FiniteSetData):
"""
This class defines the base class for an ordered set of concrete data.
In older Pyomo terms, this defines a "concrete" ordered set - that is,
a set that "owns" the list of set members. While this class actually
implements a set ordered by insertion order, we make the "official"
- _InsertionOrderSetData an empty derivative class, so that
+ InsertionOrderSetData an empty derivative class, so that
- issubclass(_SortedSetData, _InsertionOrderSetData) == False
+ issubclass(SortedSetData, InsertionOrderSetData) == False
Constructor Arguments:
component The Set object that owns this data.
@@ -1649,7 +1656,7 @@ class _OrderedSetData(_OrderedSetMixin, _FiniteSetData):
def __init__(self, component):
self._values = {}
self._ordered_values = []
- _FiniteSetData.__init__(self, component=component)
+ FiniteSetData.__init__(self, component=component)
def _iter_impl(self):
"""
@@ -1727,7 +1734,12 @@ def ord(self, item):
raise ValueError("%s.ord(x): x not in %s" % (self.name, self.name))
-class _InsertionOrderSetData(_OrderedSetData):
+class _OrderedSetData(metaclass=RenamedClass):
+ __renamed__new_class__ = OrderedSetData
+ __renamed__version__ = '6.7.2'
+
+
+class InsertionOrderSetData(OrderedSetData):
"""
This class defines the data for a ordered set where the items are ordered
in insertion order (similar to Python's OrderedSet.
@@ -1748,7 +1760,7 @@ def set_value(self, val):
"This WILL potentially lead to nondeterministic behavior "
"in Pyomo" % (type(val).__name__,)
)
- super(_InsertionOrderSetData, self).set_value(val)
+ super(InsertionOrderSetData, self).set_value(val)
def update(self, values):
if type(values) in Set._UnorderedInitializers:
@@ -1758,7 +1770,12 @@ def update(self, values):
"This WILL potentially lead to nondeterministic behavior "
"in Pyomo" % (type(values).__name__,)
)
- super(_InsertionOrderSetData, self).update(values)
+ super(InsertionOrderSetData, self).update(values)
+
+
+class _InsertionOrderSetData(metaclass=RenamedClass):
+ __renamed__new_class__ = InsertionOrderSetData
+ __renamed__version__ = '6.7.2'
class _SortedSetMixin(object):
@@ -1773,7 +1790,7 @@ def sorted_iter(self):
return iter(self)
-class _SortedSetData(_SortedSetMixin, _OrderedSetData):
+class SortedSetData(_SortedSetMixin, OrderedSetData):
"""
This class defines the data for a sorted set.
@@ -1788,7 +1805,7 @@ class _SortedSetData(_SortedSetMixin, _OrderedSetData):
def __init__(self, component):
# An empty set is sorted...
self._is_sorted = True
- _OrderedSetData.__init__(self, component=component)
+ OrderedSetData.__init__(self, component=component)
def _iter_impl(self):
"""
@@ -1796,12 +1813,12 @@ def _iter_impl(self):
"""
if not self._is_sorted:
self._sort()
- return super(_SortedSetData, self)._iter_impl()
+ return super(SortedSetData, self)._iter_impl()
def __reversed__(self):
if not self._is_sorted:
self._sort()
- return super(_SortedSetData, self).__reversed__()
+ return super(SortedSetData, self).__reversed__()
def _add_impl(self, value):
# Note that the sorted status has no bearing on insertion,
@@ -1815,7 +1832,7 @@ def _add_impl(self, value):
# def discard(self, val):
def clear(self):
- super(_SortedSetData, self).clear()
+ super(SortedSetData, self).clear()
self._is_sorted = True
def at(self, index):
@@ -1827,7 +1844,7 @@ def at(self, index):
"""
if not self._is_sorted:
self._sort()
- return super(_SortedSetData, self).at(index)
+ return super(SortedSetData, self).at(index)
def ord(self, item):
"""
@@ -1839,7 +1856,7 @@ def ord(self, item):
"""
if not self._is_sorted:
self._sort()
- return super(_SortedSetData, self).ord(item)
+ return super(SortedSetData, self).ord(item)
def sorted_data(self):
return self.data()
@@ -1852,6 +1869,11 @@ def _sort(self):
self._is_sorted = True
+class _SortedSetData(metaclass=RenamedClass):
+ __renamed__new_class__ = SortedSetData
+ __renamed__version__ = '6.7.2'
+
+
############################################################################
_SET_API = (('__contains__', 'test membership in'), 'get', 'ranges', 'bounds')
@@ -1967,6 +1989,12 @@ class SortedOrder(object):
_ValidOrderedAuguments = {True, False, InsertionOrder, SortedOrder}
_UnorderedInitializers = {set}
+ @overload
+ def __new__(cls: Type[Set], *args, **kwds) -> Union[SetData, IndexedSet]: ...
+
+ @overload
+ def __new__(cls: Type[OrderedScalarSet], *args, **kwds) -> OrderedScalarSet: ...
+
def __new__(cls, *args, **kwds):
if cls is not Set:
return super(Set, cls).__new__(cls)
@@ -1976,7 +2004,7 @@ def __new__(cls, *args, **kwds):
# Many things are easier by forcing it to be consistent across
# the set (namely, the _ComponentDataClass is constant).
# However, it is a bit off that 'ordered' it the only arg NOT
- # processed by Initializer. We can mock up a _SortedSetData
+ # processed by Initializer. We can mock up a SortedSetData
# sort function that preserves Insertion Order (lambda x: x), but
# the unsorted is harder (it would effectively be insertion
# order, but ordered() may not be deterministic based on how the
@@ -2021,11 +2049,11 @@ def __new__(cls, *args, **kwds):
else:
newObj = super(Set, cls).__new__(IndexedSet)
if ordered is Set.InsertionOrder:
- newObj._ComponentDataClass = _InsertionOrderSetData
+ newObj._ComponentDataClass = InsertionOrderSetData
elif ordered is Set.SortedOrder:
- newObj._ComponentDataClass = _SortedSetData
+ newObj._ComponentDataClass = SortedSetData
else:
- newObj._ComponentDataClass = _FiniteSetData
+ newObj._ComponentDataClass = FiniteSetData
return newObj
@overload
@@ -2169,7 +2197,7 @@ def _getitem_when_not_present(self, index):
"""Returns the default component data value."""
# Because we allow sets within an IndexedSet to have different
# dimen, we have moved the tuplization logic from PyomoModel
- # into Set (because we cannot know the dimen of a _SetData until
+ # into Set (because we cannot know the dimen of a SetData until
# we are actually constructing that index). This also means
# that we need to potentially communicate the dimen to the
# (wrapped) value initializer. So, we will get the dimen first,
@@ -2329,7 +2357,7 @@ def _pprint(self):
# else:
# return '{' + str(ans)[1:-1] + "}"
- # TBD: In the current design, we force all _SetData within an
+ # TBD: In the current design, we force all SetData within an
# indexed Set to have the same isordered value, so we will only
# print it once in the header. Is this a good design?
try:
@@ -2349,7 +2377,7 @@ def _pprint(self):
_ordered = "Sorted"
else:
_ordered = "{user}"
- elif issubclass(_refClass, _InsertionOrderSetData):
+ elif issubclass(_refClass, InsertionOrderSetData):
_ordered = "Insertion"
return (
[
@@ -2373,10 +2401,15 @@ def data(self):
"Return a dict containing the data() of each Set in this IndexedSet"
return {k: v.data() for k, v in self.items()}
+ @overload
+ def __getitem__(self, index) -> SetData: ...
+
+ __getitem__ = IndexedComponent.__getitem__ # type: ignore
-class FiniteScalarSet(_FiniteSetData, Set):
+
+class FiniteScalarSet(FiniteSetData, Set):
def __init__(self, **kwds):
- _FiniteSetData.__init__(self, component=self)
+ FiniteSetData.__init__(self, component=self)
Set.__init__(self, **kwds)
self._index = UnindexedComponent_index
@@ -2386,13 +2419,13 @@ class FiniteSimpleSet(metaclass=RenamedClass):
__renamed__version__ = '6.0'
-class OrderedScalarSet(_ScalarOrderedSetMixin, _InsertionOrderSetData, Set):
+class OrderedScalarSet(_ScalarOrderedSetMixin, InsertionOrderSetData, Set):
def __init__(self, **kwds):
# In case someone inherits from us, we will provide a rational
# default for the "ordered" flag
kwds.setdefault('ordered', Set.InsertionOrder)
- _InsertionOrderSetData.__init__(self, component=self)
+ InsertionOrderSetData.__init__(self, component=self)
Set.__init__(self, **kwds)
@@ -2401,13 +2434,13 @@ class OrderedSimpleSet(metaclass=RenamedClass):
__renamed__version__ = '6.0'
-class SortedScalarSet(_ScalarOrderedSetMixin, _SortedSetData, Set):
+class SortedScalarSet(_ScalarOrderedSetMixin, SortedSetData, Set):
def __init__(self, **kwds):
# In case someone inherits from us, we will provide a rational
# default for the "ordered" flag
kwds.setdefault('ordered', Set.SortedOrder)
- _SortedSetData.__init__(self, component=self)
+ SortedSetData.__init__(self, component=self)
Set.__init__(self, **kwds)
self._index = UnindexedComponent_index
@@ -2450,14 +2483,14 @@ class AbstractSortedSimpleSet(metaclass=RenamedClass):
############################################################################
-class SetOf(_SetData, Component):
+class SetOf(SetData, Component):
""""""
def __new__(cls, *args, **kwds):
if cls is not SetOf:
return super(SetOf, cls).__new__(cls)
(reference,) = args
- if isinstance(reference, (_SetData, GlobalSetBase)):
+ if isinstance(reference, (SetData, GlobalSetBase)):
if reference.isfinite():
if reference.isordered():
return super(SetOf, cls).__new__(OrderedSetOf)
@@ -2471,7 +2504,7 @@ def __new__(cls, *args, **kwds):
return super(SetOf, cls).__new__(FiniteSetOf)
def __init__(self, reference, **kwds):
- _SetData.__init__(self, component=self)
+ SetData.__init__(self, component=self)
kwds.setdefault('ctype', SetOf)
Component.__init__(self, **kwds)
self._ref = reference
@@ -2494,7 +2527,7 @@ def construct(self, data=None):
@property
def dimen(self):
- if isinstance(self._ref, _SetData):
+ if isinstance(self._ref, SetData):
return self._ref.dimen
_iter = iter(self)
try:
@@ -2589,7 +2622,7 @@ def ord(self, item):
############################################################################
-class _InfiniteRangeSetData(_SetData):
+class InfiniteRangeSetData(SetData):
"""Data class for a infinite set.
This Set implements an interface to an *infinite set* defined by one
@@ -2601,7 +2634,7 @@ class _InfiniteRangeSetData(_SetData):
__slots__ = ('_ranges',)
def __init__(self, component):
- _SetData.__init__(self, component=component)
+ SetData.__init__(self, component=component)
self._ranges = None
def get(self, value, default=None):
@@ -2634,8 +2667,13 @@ def ranges(self):
return iter(self._ranges)
-class _FiniteRangeSetData(
- _SortedSetMixin, _OrderedSetMixin, _FiniteSetMixin, _InfiniteRangeSetData
+class _InfiniteRangeSetData(metaclass=RenamedClass):
+ __renamed__new_class__ = InfiniteRangeSetData
+ __renamed__version__ = '6.7.2'
+
+
+class FiniteRangeSetData(
+ _SortedSetMixin, _OrderedSetMixin, _FiniteSetMixin, InfiniteRangeSetData
):
__slots__ = ()
@@ -2658,7 +2696,7 @@ def _iter_impl(self):
# iterate over it
nIters = len(self._ranges) - 1
if not nIters:
- yield from _FiniteRangeSetData._range_gen(self._ranges[0])
+ yield from FiniteRangeSetData._range_gen(self._ranges[0])
return
# The trick here is that we need to remove any duplicates from
@@ -2669,7 +2707,7 @@ def _iter_impl(self):
for r in self._ranges:
# Note: there should always be at least 1 member in each
# NumericRange
- i = _FiniteRangeSetData._range_gen(r)
+ i = FiniteRangeSetData._range_gen(r)
iters.append([next(i), i])
iters.sort(reverse=True, key=lambda x: x[0])
@@ -2735,11 +2773,16 @@ def ord(self, item):
)
# We must redefine ranges(), bounds(), and domain so that we get the
- # _InfiniteRangeSetData version and not the one from
+ # InfiniteRangeSetData version and not the one from
# _FiniteSetMixin.
- bounds = _InfiniteRangeSetData.bounds
- ranges = _InfiniteRangeSetData.ranges
- domain = _InfiniteRangeSetData.domain
+ bounds = InfiniteRangeSetData.bounds
+ ranges = InfiniteRangeSetData.ranges
+ domain = InfiniteRangeSetData.domain
+
+
+class _FiniteRangeSetData(metaclass=RenamedClass):
+ __renamed__new_class__ = FiniteRangeSetData
+ __renamed__version__ = '6.7.2'
@ModelComponentFactory.register(
@@ -3106,7 +3149,7 @@ def construct(self, data=None):
old_ranges.reverse()
while old_ranges:
r = old_ranges.pop()
- for i, val in enumerate(_FiniteRangeSetData._range_gen(r)):
+ for i, val in enumerate(FiniteRangeSetData._range_gen(r)):
if not _filter(_block, val):
split_r = r.range_difference((NumericRange(val, val, 0),))
if len(split_r) == 2:
@@ -3204,9 +3247,9 @@ def _pprint(self):
)
-class InfiniteScalarRangeSet(_InfiniteRangeSetData, RangeSet):
+class InfiniteScalarRangeSet(InfiniteRangeSetData, RangeSet):
def __init__(self, *args, **kwds):
- _InfiniteRangeSetData.__init__(self, component=self)
+ InfiniteRangeSetData.__init__(self, component=self)
RangeSet.__init__(self, *args, **kwds)
self._index = UnindexedComponent_index
@@ -3219,9 +3262,9 @@ class InfiniteSimpleRangeSet(metaclass=RenamedClass):
__renamed__version__ = '6.0'
-class FiniteScalarRangeSet(_ScalarOrderedSetMixin, _FiniteRangeSetData, RangeSet):
+class FiniteScalarRangeSet(_ScalarOrderedSetMixin, FiniteRangeSetData, RangeSet):
def __init__(self, *args, **kwds):
- _FiniteRangeSetData.__init__(self, component=self)
+ FiniteRangeSetData.__init__(self, component=self)
RangeSet.__init__(self, *args, **kwds)
self._index = UnindexedComponent_index
@@ -3259,11 +3302,11 @@ class AbstractFiniteSimpleRangeSet(metaclass=RenamedClass):
############################################################################
-class SetOperator(_SetData, Set):
+class SetOperator(SetData, Set):
__slots__ = ('_sets',)
def __init__(self, *args, **kwds):
- _SetData.__init__(self, component=self)
+ SetData.__init__(self, component=self)
Set.__init__(self, **kwds)
self._sets, _anonymous = zip(*(process_setarg(_set) for _set in args))
_anonymous = tuple(filter(None, _anonymous))
@@ -3447,7 +3490,7 @@ def _domain(self, val):
def _checkArgs(*sets):
ans = []
for s in sets:
- if isinstance(s, _SetDataBase):
+ if isinstance(s, SetData):
ans.append((s.isordered(), s.isfinite()))
elif type(s) in {tuple, list}:
ans.append((True, True))
@@ -4203,9 +4246,9 @@ def ord(self, item):
############################################################################
-class _AnySet(_SetData, Set):
+class _AnySet(SetData, Set):
def __init__(self, **kwds):
- _SetData.__init__(self, component=self)
+ SetData.__init__(self, component=self)
# There is a chicken-and-egg game here: the SetInitializer uses
# Any as part of the processing of the domain/within/bounds
# domain restrictions. However, Any has not been declared when
@@ -4259,9 +4302,9 @@ def get(self, val, default=None):
return super(_AnyWithNoneSet, self).get(val, default)
-class _EmptySet(_FiniteSetMixin, _SetData, Set):
+class _EmptySet(_FiniteSetMixin, SetData, Set):
def __init__(self, **kwds):
- _SetData.__init__(self, component=self)
+ SetData.__init__(self, component=self)
Set.__init__(self, **kwds)
self.construct()
diff --git a/pyomo/core/base/sets.py b/pyomo/core/base/sets.py
index ca693cf7d8b..72d49479dd3 100644
--- a/pyomo/core/base/sets.py
+++ b/pyomo/core/base/sets.py
@@ -18,7 +18,7 @@
set_options,
simple_set_rule,
_SetDataBase,
- _SetData,
+ SetData,
Set,
SetOf,
IndexedSet,
diff --git a/pyomo/core/base/sos.py b/pyomo/core/base/sos.py
index 6b8586c9b49..afd52c111bc 100644
--- a/pyomo/core/base/sos.py
+++ b/pyomo/core/base/sos.py
@@ -28,7 +28,7 @@
logger = logging.getLogger('pyomo.core')
-class _SOSConstraintData(ActiveComponentData):
+class SOSConstraintData(ActiveComponentData):
"""
This class defines the data for a single special ordered set.
@@ -101,6 +101,11 @@ def set_items(self, variables, weights):
self._weights.append(w)
+class _SOSConstraintData(metaclass=RenamedClass):
+ __renamed__new_class__ = SOSConstraintData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register("SOS constraint expressions.")
class SOSConstraint(ActiveIndexedComponent):
"""
@@ -512,10 +517,10 @@ def add(self, index, variables, weights=None):
Add a component data for the specified index.
"""
if index is None:
- # because ScalarSOSConstraint already makes an _SOSConstraintData instance
+ # because ScalarSOSConstraint already makes an SOSConstraintData instance
soscondata = self
else:
- soscondata = _SOSConstraintData(self)
+ soscondata = SOSConstraintData(self)
self._data[index] = soscondata
soscondata._index = index
@@ -549,9 +554,9 @@ def pprint(self, ostream=None, verbose=False, prefix=""):
ostream.write("\t\t" + str(weight) + ' : ' + var.name + '\n')
-class ScalarSOSConstraint(SOSConstraint, _SOSConstraintData):
+class ScalarSOSConstraint(SOSConstraint, SOSConstraintData):
def __init__(self, *args, **kwd):
- _SOSConstraintData.__init__(self, self)
+ SOSConstraintData.__init__(self, self)
SOSConstraint.__init__(self, *args, **kwd)
self._index = UnindexedComponent_index
diff --git a/pyomo/core/base/suffix.py b/pyomo/core/base/suffix.py
index 0c27eee060f..be2f732650d 100644
--- a/pyomo/core/base/suffix.py
+++ b/pyomo/core/base/suffix.py
@@ -341,7 +341,7 @@ def clear_all_values(self):
@deprecated(
'Suffix.set_datatype is replaced with the Suffix.datatype property',
- version='6.7.1.dev0',
+ version='6.7.1',
)
def set_datatype(self, datatype):
"""
@@ -351,7 +351,7 @@ def set_datatype(self, datatype):
@deprecated(
'Suffix.get_datatype is replaced with the Suffix.datatype property',
- version='6.7.1.dev0',
+ version='6.7.1',
)
def get_datatype(self):
"""
@@ -361,7 +361,7 @@ def get_datatype(self):
@deprecated(
'Suffix.set_direction is replaced with the Suffix.direction property',
- version='6.7.1.dev0',
+ version='6.7.1',
)
def set_direction(self, direction):
"""
@@ -371,7 +371,7 @@ def set_direction(self, direction):
@deprecated(
'Suffix.get_direction is replaced with the Suffix.direction property',
- version='6.7.1.dev0',
+ version='6.7.1',
)
def get_direction(self):
"""
diff --git a/pyomo/core/base/units_container.py b/pyomo/core/base/units_container.py
index 1bf25ffdead..f3dec1e0db1 100644
--- a/pyomo/core/base/units_container.py
+++ b/pyomo/core/base/units_container.py
@@ -119,7 +119,6 @@
value,
native_types,
native_numeric_types,
- pyomo_constant_types,
)
from pyomo.core.expr.template_expr import IndexTemplate
from pyomo.core.expr.visitor import ExpressionValueVisitor
@@ -127,7 +126,6 @@
pint_module, pint_available = attempt_import(
'pint',
- defer_check=True,
error_message=(
'The "pint" package failed to import. '
'This package is necessary to use Pyomo units.'
@@ -902,7 +900,7 @@ def initializeWalker(self, expr):
def beforeChild(self, node, child, child_idx):
ctype = child.__class__
- if ctype in native_types or ctype in pyomo_constant_types:
+ if ctype in native_types:
return False, self._pint_dimensionless
if child.is_expression_type():
@@ -917,7 +915,7 @@ def beforeChild(self, node, child, child_idx):
pint_unit = self._pyomo_units_container._get_pint_units(pyomo_unit)
return False, pint_unit
- return True, None
+ return False, self._pint_dimensionless
def exitNode(self, node, data):
"""Visitor callback when moving up the expression tree.
diff --git a/pyomo/core/base/var.py b/pyomo/core/base/var.py
index d03fd0b677f..38d1d38a864 100644
--- a/pyomo/core/base/var.py
+++ b/pyomo/core/base/var.py
@@ -9,10 +9,12 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
+from __future__ import annotations
import logging
import sys
from pyomo.common.pyomo_typing import overload
from weakref import ref as weakref_ref
+from typing import Union, Type
from pyomo.common.deprecation import RenamedClass
from pyomo.common.log import is_debug_set
@@ -83,241 +85,11 @@
'value',
'stale',
'fixed',
+ ('__call__', "access property 'value' on"),
)
-class _VarData(ComponentData, NumericValue):
- """This class defines the abstract interface for a single variable.
-
- Note that this "abstract" class is not intended to be directly
- instantiated.
-
- """
-
- __slots__ = ()
-
- #
- # Interface
- #
-
- def has_lb(self):
- """Returns :const:`False` when the lower bound is
- :const:`None` or negative infinity"""
- return self.lb is not None
-
- def has_ub(self):
- """Returns :const:`False` when the upper bound is
- :const:`None` or positive infinity"""
- return self.ub is not None
-
- # TODO: deprecate this? Properties are generally preferred over "set*()"
- def setlb(self, val):
- """
- Set the lower bound for this variable after validating that
- the value is fixed (or None).
- """
- self.lower = val
-
- # TODO: deprecate this? Properties are generally preferred over "set*()"
- def setub(self, val):
- """
- Set the upper bound for this variable after validating that
- the value is fixed (or None).
- """
- self.upper = val
-
- @property
- def bounds(self):
- """Returns (or set) the tuple (lower bound, upper bound).
-
- This returns the current (numeric) values of the lower and upper
- bounds as a tuple. If there is no bound, returns None (and not
- +/-inf)
-
- """
- return self.lb, self.ub
-
- @bounds.setter
- def bounds(self, val):
- self.lower, self.upper = val
-
- @property
- def lb(self):
- """Return (or set) the numeric value of the variable lower bound."""
- lb = value(self.lower)
- return None if lb == _ninf else lb
-
- @lb.setter
- def lb(self, val):
- self.lower = val
-
- @property
- def ub(self):
- """Return (or set) the numeric value of the variable upper bound."""
- ub = value(self.upper)
- return None if ub == _inf else ub
-
- @ub.setter
- def ub(self, val):
- self.upper = val
-
- def is_integer(self):
- """Returns True when the domain is a contiguous integer range."""
- _id = id(self.domain)
- if _id in _known_global_real_domains:
- return not _known_global_real_domains[_id]
- _interval = self.domain.get_interval()
- if _interval is None:
- return False
- # Note: it is not sufficient to just check the step: the
- # starting / ending points must be integers (or not specified)
- start, stop, step = _interval
- return (
- step == 1
- and (start is None or int(start) == start)
- and (stop is None or int(stop) == stop)
- )
-
- def is_binary(self):
- """Returns True when the domain is restricted to Binary values."""
- domain = self.domain
- if domain is Binary:
- return True
- if id(domain) in _known_global_real_domains:
- return False
- return domain.get_interval() == (0, 1, 1)
-
- def is_continuous(self):
- """Returns True when the domain is a continuous real range"""
- _id = id(self.domain)
- if _id in _known_global_real_domains:
- return _known_global_real_domains[_id]
- _interval = self.domain.get_interval()
- return _interval is not None and _interval[2] == 0
-
- def is_fixed(self):
- """Returns True if this variable is fixed, otherwise returns False."""
- return self.fixed
-
- def is_constant(self):
- """Returns False because this is not a constant in an expression."""
- return False
-
- def is_variable_type(self):
- """Returns True because this is a variable."""
- return True
-
- def is_potentially_variable(self):
- """Returns True because this is a variable."""
- return True
-
- def _compute_polynomial_degree(self, result):
- """
- If the variable is fixed, it represents a constant
- is a polynomial with degree 0. Otherwise, it has
- degree 1. This method is used in expressions to
- compute polynomial degree.
- """
- if self.fixed:
- return 0
- return 1
-
- def clear(self):
- self.value = None
-
- def __call__(self, exception=True):
- """Compute the value of this variable."""
- return self.value
-
- #
- # Abstract Interface
- #
-
- def set_value(self, val, skip_validation=False):
- """Set the current variable value."""
- raise NotImplementedError
-
- @property
- def value(self):
- """Return (or set) the value for this variable."""
- raise NotImplementedError
-
- @property
- def domain(self):
- """Return (or set) the domain for this variable."""
- raise NotImplementedError
-
- @property
- def lower(self):
- """Return (or set) an expression for the variable lower bound."""
- raise NotImplementedError
-
- @property
- def upper(self):
- """Return (or set) an expression for the variable upper bound."""
- raise NotImplementedError
-
- @property
- def fixed(self):
- """Return (or set) the fixed indicator for this variable.
-
- Alias for :meth:`is_fixed` / :meth:`fix` / :meth:`unfix`.
-
- """
- raise NotImplementedError
-
- @property
- def stale(self):
- """The stale status for this variable.
-
- Variables are "stale" if their current value was not updated as
- part of the most recent model update. A "model update" can be
- one of several things: a solver invocation, loading a previous
- solution, or manually updating a non-stale :class:`Var` value.
-
- Returns
- -------
- bool
-
- Notes
- -----
- Fixed :class:`Var` objects will be stale after invoking a solver
- (as their value was not updated by the solver).
-
- Updating a stale :class:`Var` value will not cause other
- variable values to be come stale. However, updating the first
- non-stale :class:`Var` value after a solve or solution load
- *will* cause all other variables to be marked as stale
-
- """
- raise NotImplementedError
-
- def fix(self, value=NOTSET, skip_validation=False):
- """Fix the value of this variable (treat as nonvariable)
-
- This sets the :attr:`fixed` indicator to True. If ``value`` is
- provided, the value (and the ``skip_validation`` flag) are first
- passed to :meth:`set_value()`.
-
- """
- self.fixed = True
- if value is not NOTSET:
- self.set_value(value, skip_validation)
-
- def unfix(self):
- """Unfix this variable (treat as variable in solver interfaces)
-
- This sets the :attr:`fixed` indicator to False.
-
- """
- self.fixed = False
-
- def free(self):
- """Alias for :meth:`unfix`"""
- return self.unfix()
-
-
-class _GeneralVarData(_VarData):
+class VarData(ComponentData, NumericValue):
"""This class defines the data for a single variable."""
__slots__ = ('_value', '_lb', '_ub', '_domain', '_fixed', '_stale')
@@ -327,7 +99,7 @@ def __init__(self, component=None):
#
# These lines represent in-lining of the
# following constructors:
- # - _VarData
+ # - VarData
# - ComponentData
# - NumericValue
self._component = weakref_ref(component) if (component is not None) else None
@@ -358,10 +130,6 @@ def copy(cls, src):
self._index = src._index
return self
- #
- # Abstract Interface
- #
-
def set_value(self, val, skip_validation=False):
"""Set the current variable value.
@@ -384,17 +152,22 @@ def set_value(self, val, skip_validation=False):
#
# Check if this Var has units: assigning dimensionless
# values to a variable with units should be an error
- if type(val) not in native_numeric_types:
- if self.parent_component()._units is not None:
- _src_magnitude = value(val)
+ if val.__class__ in native_numeric_types:
+ pass
+ elif self.parent_component()._units is not None:
+ _src_magnitude = value(val)
+ # Note: value() could have just registered a new numeric type
+ if val.__class__ in native_numeric_types:
+ val = _src_magnitude
+ else:
_src_units = units.get_units(val)
val = units.convert_value(
num_value=_src_magnitude,
from_units=_src_units,
to_units=self.parent_component()._units,
)
- else:
- val = value(val)
+ else:
+ val = value(val)
if not skip_validation:
if val not in self.domain:
@@ -417,14 +190,20 @@ def set_value(self, val, skip_validation=False):
@property
def value(self):
+ """Return (or set) the value for this variable."""
return self._value
@value.setter
def value(self, val):
self.set_value(val)
+ def __call__(self, exception=True):
+ """Compute the value of this variable."""
+ return self._value
+
@property
def domain(self):
+ """Return (or set) the domain for this variable."""
return self._domain
@domain.setter
@@ -441,9 +220,42 @@ def domain(self, domain):
)
raise
- @_VarData.bounds.getter
+ def has_lb(self):
+ """Returns :const:`False` when the lower bound is
+ :const:`None` or negative infinity"""
+ return self.lb is not None
+
+ def has_ub(self):
+ """Returns :const:`False` when the upper bound is
+ :const:`None` or positive infinity"""
+ return self.ub is not None
+
+ # TODO: deprecate this? Properties are generally preferred over "set*()"
+ def setlb(self, val):
+ """
+ Set the lower bound for this variable after validating that
+ the value is fixed (or None).
+ """
+ self.lower = val
+
+ # TODO: deprecate this? Properties are generally preferred over "set*()"
+ def setub(self, val):
+ """
+ Set the upper bound for this variable after validating that
+ the value is fixed (or None).
+ """
+ self.upper = val
+
+ @property
def bounds(self):
- # Custom implementation of _VarData.bounds to avoid unnecessary
+ """Returns (or set) the tuple (lower bound, upper bound).
+
+ This returns the current (numeric) values of the lower and upper
+ bounds as a tuple. If there is no bound, returns None (and not
+ +/-inf)
+
+ """
+ # Custom implementation of lb / ub to avoid unnecessary
# expression generation and duplicate calls to domain.bounds()
domain_lb, domain_ub = self.domain.bounds()
# lb is the tighter of the domain and bounds
@@ -484,10 +296,14 @@ def bounds(self):
ub = min(ub, domain_ub)
return lb, ub
- @_VarData.lb.getter
+ @bounds.setter
+ def bounds(self, val):
+ self.lower, self.upper = val
+
+ @property
def lb(self):
- # Custom implementation of _VarData.lb to avoid unnecessary
- # expression generation
+ """Return (or set) the numeric value of the variable lower bound."""
+ # Note: Implementation avoids unnecessary expression generation
domain_lb, domain_ub = self.domain.bounds()
# lb is the tighter of the domain and bounds
lb = self._lb
@@ -509,10 +325,14 @@ def lb(self):
lb = max(lb, domain_lb)
return lb
- @_VarData.ub.getter
+ @lb.setter
+ def lb(self, val):
+ self.lower = val
+
+ @property
def ub(self):
- # Custom implementation of _VarData.ub to avoid unnecessary
- # expression generation
+ """Return (or set) the numeric value of the variable upper bound."""
+ # Note: implementation avoids unnecessary expression generation
domain_lb, domain_ub = self.domain.bounds()
# ub is the tighter of the domain and bounds
ub = self._ub
@@ -534,6 +354,10 @@ def ub(self):
ub = min(ub, domain_ub)
return ub
+ @ub.setter
+ def ub(self, val):
+ self.upper = val
+
@property
def lower(self):
"""Return (or set) an expression for the variable lower bound.
@@ -590,8 +414,37 @@ def get_units(self):
# component if not scalar
return self.parent_component()._units
+ def fix(self, value=NOTSET, skip_validation=False):
+ """Fix the value of this variable (treat as nonvariable)
+
+ This sets the :attr:`fixed` indicator to True. If ``value`` is
+ provided, the value (and the ``skip_validation`` flag) are first
+ passed to :meth:`set_value()`.
+
+ """
+ self.fixed = True
+ if value is not NOTSET:
+ self.set_value(value, skip_validation)
+
+ def unfix(self):
+ """Unfix this variable (treat as variable in solver interfaces)
+
+ This sets the :attr:`fixed` indicator to False.
+
+ """
+ self.fixed = False
+
+ def free(self):
+ """Alias for :meth:`unfix`"""
+ return self.unfix()
+
@property
def fixed(self):
+ """Return (or set) the fixed indicator for this variable.
+
+ Alias for :meth:`is_fixed` / :meth:`fix` / :meth:`unfix`.
+
+ """
return self._fixed
@fixed.setter
@@ -600,6 +453,28 @@ def fixed(self, val):
@property
def stale(self):
+ """The stale status for this variable.
+
+ Variables are "stale" if their current value was not updated as
+ part of the most recent model update. A "model update" can be
+ one of several things: a solver invocation, loading a previous
+ solution, or manually updating a non-stale :class:`Var` value.
+
+ Returns
+ -------
+ bool
+
+ Notes
+ -----
+ Fixed :class:`Var` objects will be stale after invoking a solver
+ (as their value was not updated by the solver).
+
+ Updating a stale :class:`Var` value will not cause other
+ variable values to be come stale. However, updating the first
+ non-stale :class:`Var` value after a solve or solution load
+ *will* cause all other variables to be marked as stale
+
+ """
return StaleFlagManager.is_stale(self._stale)
@stale.setter
@@ -609,11 +484,70 @@ def stale(self, val):
else:
self._stale = StaleFlagManager.get_flag(0)
- # Note: override the base class definition to avoid a call through a
- # property
+ def is_integer(self):
+ """Returns True when the domain is a contiguous integer range."""
+ _id = id(self.domain)
+ if _id in _known_global_real_domains:
+ return not _known_global_real_domains[_id]
+ _interval = self.domain.get_interval()
+ if _interval is None:
+ return False
+ # Note: it is not sufficient to just check the step: the
+ # starting / ending points must be integers (or not specified)
+ start, stop, step = _interval
+ return (
+ step == 1
+ and (start is None or int(start) == start)
+ and (stop is None or int(stop) == stop)
+ )
+
+ def is_binary(self):
+ """Returns True when the domain is restricted to Binary values."""
+ domain = self.domain
+ if domain is Binary:
+ return True
+ if id(domain) in _known_global_real_domains:
+ return False
+ return domain.get_interval() == (0, 1, 1)
+
+ def is_continuous(self):
+ """Returns True when the domain is a continuous real range"""
+ _id = id(self.domain)
+ if _id in _known_global_real_domains:
+ return _known_global_real_domains[_id]
+ _interval = self.domain.get_interval()
+ return _interval is not None and _interval[2] == 0
+
def is_fixed(self):
+ """Returns True if this variable is fixed, otherwise returns False."""
return self._fixed
+ def is_constant(self):
+ """Returns False because this is not a constant in an expression."""
+ return False
+
+ def is_variable_type(self):
+ """Returns True because this is a variable."""
+ return True
+
+ def is_potentially_variable(self):
+ """Returns True because this is a variable."""
+ return True
+
+ def clear(self):
+ self.value = None
+
+ def _compute_polynomial_degree(self, result):
+ """
+ If the variable is fixed, it represents a constant
+ is a polynomial with degree 0. Otherwise, it has
+ degree 1. This method is used in expressions to
+ compute polynomial degree.
+ """
+ if self._fixed:
+ return 0
+ return 1
+
def _process_bound(self, val, bound_type):
if type(val) in native_numeric_types or val is None:
# TODO: warn/error: check if this Var has units: assigning
@@ -636,6 +570,16 @@ def _process_bound(self, val, bound_type):
return val
+class _VarData(metaclass=RenamedClass):
+ __renamed__new_class__ = VarData
+ __renamed__version__ = '6.7.2'
+
+
+class _GeneralVarData(metaclass=RenamedClass):
+ __renamed__new_class__ = VarData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register("Decision variables.")
class Var(IndexedComponent, IndexedComponent_NDArrayMixin):
"""A numeric variable, which may be defined over an index.
@@ -661,7 +605,16 @@ class Var(IndexedComponent, IndexedComponent_NDArrayMixin):
doc (str, optional): Text describing this component.
"""
- _ComponentDataClass = _GeneralVarData
+ _ComponentDataClass = VarData
+
+ @overload
+ def __new__(cls: Type[Var], *args, **kwargs) -> Union[ScalarVar, IndexedVar]: ...
+
+ @overload
+ def __new__(cls: Type[ScalarVar], *args, **kwargs) -> ScalarVar: ...
+
+ @overload
+ def __new__(cls: Type[IndexedVar], *args, **kwargs) -> IndexedVar: ...
def __new__(cls, *args, **kwargs):
if cls is not Var:
@@ -683,7 +636,7 @@ def __init__(
dense=True,
units=None,
name=None,
- doc=None
+ doc=None,
): ...
def __init__(self, *args, **kwargs):
@@ -759,7 +712,7 @@ def add(self, index):
def construct(self, data=None):
"""
- Construct the _VarData objects for this variable
+ Construct the VarData objects for this variable
"""
if self._constructed:
return
@@ -818,7 +771,7 @@ def construct(self, data=None):
# initializers that are constant, we can avoid
# re-calling (and re-validating) the inputs in certain
# cases. To support this, we will create the first
- # _VarData and then use it as a template to initialize
+ # VarData and then use it as a template to initialize
# (constant portions of) every VarData so as to not
# repeat all the domain/bounds validation.
try:
@@ -936,11 +889,11 @@ def _pprint(self):
)
-class ScalarVar(_GeneralVarData, Var):
+class ScalarVar(VarData, Var):
"""A single variable."""
def __init__(self, *args, **kwd):
- _GeneralVarData.__init__(self, component=self)
+ VarData.__init__(self, component=self)
Var.__init__(self, *args, **kwd)
self._index = UnindexedComponent_index
@@ -987,7 +940,7 @@ def fix(self, value=NOTSET, skip_validation=False):
def unfix(self):
"""Unfix all variables in this :class:`IndexedVar` (treat as variable)
- This sets the :attr:`_VarData.fixed` indicator to False for
+ This sets the :attr:`VarData.fixed` indicator to False for
every variable in this :class:`IndexedVar`.
"""
@@ -1041,7 +994,7 @@ def domain(self, domain):
# between potentially variable GetItemExpression objects and
# "constant" GetItemExpression objects. That will need to wait for
# the expression rework [JDS; Nov 22].
- def __getitem__(self, args):
+ def __getitem__(self, args) -> VarData:
try:
return super().__getitem__(args)
except RuntimeError:
diff --git a/pyomo/core/beta/dict_objects.py b/pyomo/core/beta/dict_objects.py
index a8298b08e63..eedb3c45bf3 100644
--- a/pyomo/core/beta/dict_objects.py
+++ b/pyomo/core/beta/dict_objects.py
@@ -14,10 +14,10 @@
from pyomo.common.log import is_debug_set
from pyomo.core.base.set_types import Any
-from pyomo.core.base.var import IndexedVar, _VarData
-from pyomo.core.base.constraint import IndexedConstraint, _ConstraintData
-from pyomo.core.base.objective import IndexedObjective, _ObjectiveData
-from pyomo.core.base.expression import IndexedExpression, _ExpressionData
+from pyomo.core.base.var import IndexedVar, VarData
+from pyomo.core.base.constraint import IndexedConstraint, ConstraintData
+from pyomo.core.base.objective import IndexedObjective, ObjectiveData
+from pyomo.core.base.expression import IndexedExpression, ExpressionData
from collections.abc import MutableMapping
from collections.abc import Mapping
@@ -184,7 +184,7 @@ def __init__(self, *args, **kwds):
# Constructor for ComponentDict needs to
# go last in order to handle any initialization
# iterable as an argument
- ComponentDict.__init__(self, _VarData, *args, **kwds)
+ ComponentDict.__init__(self, VarData, *args, **kwds)
class ConstraintDict(ComponentDict, IndexedConstraint):
@@ -193,7 +193,7 @@ def __init__(self, *args, **kwds):
# Constructor for ComponentDict needs to
# go last in order to handle any initialization
# iterable as an argument
- ComponentDict.__init__(self, _ConstraintData, *args, **kwds)
+ ComponentDict.__init__(self, ConstraintData, *args, **kwds)
class ObjectiveDict(ComponentDict, IndexedObjective):
@@ -202,7 +202,7 @@ def __init__(self, *args, **kwds):
# Constructor for ComponentDict needs to
# go last in order to handle any initialization
# iterable as an argument
- ComponentDict.__init__(self, _ObjectiveData, *args, **kwds)
+ ComponentDict.__init__(self, ObjectiveData, *args, **kwds)
class ExpressionDict(ComponentDict, IndexedExpression):
@@ -211,4 +211,4 @@ def __init__(self, *args, **kwds):
# Constructor for ComponentDict needs to
# go last in order to handle any initialization
# iterable as an argument
- ComponentDict.__init__(self, _ExpressionData, *args, **kwds)
+ ComponentDict.__init__(self, ExpressionData, *args, **kwds)
diff --git a/pyomo/core/beta/list_objects.py b/pyomo/core/beta/list_objects.py
index f53997fed17..005bfc38a1f 100644
--- a/pyomo/core/beta/list_objects.py
+++ b/pyomo/core/beta/list_objects.py
@@ -14,10 +14,10 @@
from pyomo.common.log import is_debug_set
from pyomo.core.base.set_types import Any
-from pyomo.core.base.var import IndexedVar, _VarData
-from pyomo.core.base.constraint import IndexedConstraint, _ConstraintData
-from pyomo.core.base.objective import IndexedObjective, _ObjectiveData
-from pyomo.core.base.expression import IndexedExpression, _ExpressionData
+from pyomo.core.base.var import IndexedVar, VarData
+from pyomo.core.base.constraint import IndexedConstraint, ConstraintData
+from pyomo.core.base.objective import IndexedObjective, ObjectiveData
+from pyomo.core.base.expression import IndexedExpression, ExpressionData
from collections.abc import MutableSequence
@@ -232,7 +232,7 @@ def __init__(self, *args, **kwds):
# Constructor for ComponentList needs to
# go last in order to handle any initialization
# iterable as an argument
- ComponentList.__init__(self, _VarData, *args, **kwds)
+ ComponentList.__init__(self, VarData, *args, **kwds)
class XConstraintList(ComponentList, IndexedConstraint):
@@ -241,7 +241,7 @@ def __init__(self, *args, **kwds):
# Constructor for ComponentList needs to
# go last in order to handle any initialization
# iterable as an argument
- ComponentList.__init__(self, _ConstraintData, *args, **kwds)
+ ComponentList.__init__(self, ConstraintData, *args, **kwds)
class XObjectiveList(ComponentList, IndexedObjective):
@@ -250,7 +250,7 @@ def __init__(self, *args, **kwds):
# Constructor for ComponentList needs to
# go last in order to handle any initialization
# iterable as an argument
- ComponentList.__init__(self, _ObjectiveData, *args, **kwds)
+ ComponentList.__init__(self, ObjectiveData, *args, **kwds)
class XExpressionList(ComponentList, IndexedExpression):
@@ -259,4 +259,4 @@ def __init__(self, *args, **kwds):
# Constructor for ComponentList needs to
# go last in order to handle any initialization
# iterable as an argument
- ComponentList.__init__(self, _ExpressionData, *args, **kwds)
+ ComponentList.__init__(self, ExpressionData, *args, **kwds)
diff --git a/pyomo/core/expr/base.py b/pyomo/core/expr/base.py
index f506956e478..6e2066afcc5 100644
--- a/pyomo/core/expr/base.py
+++ b/pyomo/core/expr/base.py
@@ -360,7 +360,7 @@ def size(self):
"""
return visitor.sizeof_expression(self)
- def _apply_operation(self, result): # pragma: no cover
+ def _apply_operation(self, result):
"""
Compute the values of this node given the values of its children.
diff --git a/pyomo/core/expr/calculus/derivatives.py b/pyomo/core/expr/calculus/derivatives.py
index ecfdce02fd4..69fe4969938 100644
--- a/pyomo/core/expr/calculus/derivatives.py
+++ b/pyomo/core/expr/calculus/derivatives.py
@@ -39,11 +39,11 @@ def differentiate(expr, wrt=None, wrt_list=None, mode=Modes.reverse_numeric):
----------
expr: pyomo.core.expr.numeric_expr.NumericExpression
The expression to differentiate
- wrt: pyomo.core.base.var._GeneralVarData
+ wrt: pyomo.core.base.var.VarData
If specified, this function will return the derivative with
- respect to wrt. wrt is normally a _GeneralVarData, but could
- also be a _ParamData. wrt and wrt_list cannot both be specified.
- wrt_list: list of pyomo.core.base.var._GeneralVarData
+ respect to wrt. wrt is normally a VarData, but could
+ also be a ParamData. wrt and wrt_list cannot both be specified.
+ wrt_list: list of pyomo.core.base.var.VarData
If specified, this function will return the derivative with
respect to each element in wrt_list. A list will be returned
where the values are the derivatives with respect to the
diff --git a/pyomo/core/expr/compare.py b/pyomo/core/expr/compare.py
index 790bc30aaee..44d9c4205d7 100644
--- a/pyomo/core/expr/compare.py
+++ b/pyomo/core/expr/compare.py
@@ -196,7 +196,7 @@ def compare_expressions(expr1, expr2, include_named_exprs=True):
)
try:
res = pn1 == pn2
- except PyomoException:
+ except (PyomoException, AttributeError):
res = False
return res
diff --git a/pyomo/core/expr/numeric_expr.py b/pyomo/core/expr/numeric_expr.py
index c1199ffdcad..21896c63219 100644
--- a/pyomo/core/expr/numeric_expr.py
+++ b/pyomo/core/expr/numeric_expr.py
@@ -722,7 +722,7 @@ def args(self):
@deprecated(
'The implicit recasting of a "not potentially variable" '
'expression node to a potentially variable one is no '
- 'longer supported (this violates that immutability '
+ 'longer supported (this violates the immutability '
'promise for Pyomo5 expression trees).',
version='6.4.3',
)
@@ -1234,9 +1234,11 @@ class LinearExpression(SumExpression):
"""An expression object for linear polynomials.
This is a derived :py:class`SumExpression` that guarantees all
- arguments are either not potentially variable (e.g., native types,
- Params, or NPV expressions) OR :py:class:`MonomialTermExpression`
- objects.
+ arguments are one of the following types:
+
+ - not potentially variable (e.g., native types, Params, or NPV expressions)
+ - :py:class:`MonomialTermExpression`
+ - :py:class:`VarData`
Args:
args (tuple): Children nodes
@@ -1253,7 +1255,7 @@ def __init__(self, args=None, constant=None, linear_coefs=None, linear_vars=None
You can specify `args` OR (`constant`, `linear_coefs`, and
`linear_vars`). If `args` is provided, it should be a list that
- contains only constants, NPV objects/expressions, or
+ contains only constants, NPV objects/expressions, variables, or
:py:class:`MonomialTermExpression` objects. Alternatively, you
can specify the constant, the list of linear_coefs and the list
of linear_vars separately. Note that these lists are NOT
@@ -1298,8 +1300,14 @@ def _build_cache(self):
if arg.__class__ is MonomialTermExpression:
coef.append(arg._args_[0])
var.append(arg._args_[1])
- else:
+ elif arg.__class__ in native_numeric_types:
+ const += arg
+ elif not arg.is_potentially_variable():
const += arg
+ else:
+ assert arg.is_potentially_variable()
+ coef.append(1)
+ var.append(arg)
LinearExpression._cache = (self, const, coef, var)
@property
@@ -1325,7 +1333,7 @@ def create_node_with_local_data(self, args, classtype=None):
classtype = self.__class__
if type(args) is not list:
args = list(args)
- for i, arg in enumerate(args):
+ for arg in args:
if arg.__class__ in self._allowable_linear_expr_arg_types:
# 99% of the time, the arg type hasn't changed
continue
@@ -1336,8 +1344,7 @@ def create_node_with_local_data(self, args, classtype=None):
# NPV expressions are OK
pass
elif arg.is_variable_type():
- # vars are OK, but need to be mapped to monomial terms
- args[i] = MonomialTermExpression((1, arg))
+ # vars are OK
continue
else:
# For anything else, convert this to a general sum
@@ -1820,7 +1827,7 @@ def _add_native_param(a, b):
def _add_native_var(a, b):
if not a:
return b
- return LinearExpression([a, MonomialTermExpression((1, b))])
+ return LinearExpression([a, b])
def _add_native_monomial(a, b):
@@ -1871,7 +1878,7 @@ def _add_npv_param(a, b):
def _add_npv_var(a, b):
- return LinearExpression([a, MonomialTermExpression((1, b))])
+ return LinearExpression([a, b])
def _add_npv_monomial(a, b):
@@ -1929,7 +1936,7 @@ def _add_param_var(a, b):
a = a.value
if not a:
return b
- return LinearExpression([a, MonomialTermExpression((1, b))])
+ return LinearExpression([a, b])
def _add_param_monomial(a, b):
@@ -1972,11 +1979,11 @@ def _add_param_other(a, b):
def _add_var_native(a, b):
if not b:
return a
- return LinearExpression([MonomialTermExpression((1, a)), b])
+ return LinearExpression([a, b])
def _add_var_npv(a, b):
- return LinearExpression([MonomialTermExpression((1, a)), b])
+ return LinearExpression([a, b])
def _add_var_param(a, b):
@@ -1984,21 +1991,19 @@ def _add_var_param(a, b):
b = b.value
if not b:
return a
- return LinearExpression([MonomialTermExpression((1, a)), b])
+ return LinearExpression([a, b])
def _add_var_var(a, b):
- return LinearExpression(
- [MonomialTermExpression((1, a)), MonomialTermExpression((1, b))]
- )
+ return LinearExpression([a, b])
def _add_var_monomial(a, b):
- return LinearExpression([MonomialTermExpression((1, a)), b])
+ return LinearExpression([a, b])
def _add_var_linear(a, b):
- return b._trunc_append(MonomialTermExpression((1, a)))
+ return b._trunc_append(a)
def _add_var_sum(a, b):
@@ -2033,7 +2038,7 @@ def _add_monomial_param(a, b):
def _add_monomial_var(a, b):
- return LinearExpression([a, MonomialTermExpression((1, b))])
+ return LinearExpression([a, b])
def _add_monomial_monomial(a, b):
@@ -2076,7 +2081,7 @@ def _add_linear_param(a, b):
def _add_linear_var(a, b):
- return a._trunc_append(MonomialTermExpression((1, b)))
+ return a._trunc_append(b)
def _add_linear_monomial(a, b):
@@ -2283,8 +2288,11 @@ def _iadd_mutablenpvsum_mutable(a, b):
def _iadd_mutablenpvsum_native(a, b):
if not b:
return a
- a._args_.append(b)
- a._nargs += 1
+ if a._args_ and a._args_[-1].__class__ in native_numeric_types:
+ a._args_[-1] += b
+ else:
+ a._args_.append(b)
+ a._nargs += 1
return a
@@ -2296,9 +2304,7 @@ def _iadd_mutablenpvsum_npv(a, b):
def _iadd_mutablenpvsum_param(a, b):
if b.is_constant():
- b = b.value
- if not b:
- return a
+ return _iadd_mutablesum_native(a, b.value)
a._args_.append(b)
a._nargs += 1
return a
@@ -2379,8 +2385,11 @@ def _iadd_mutablelinear_mutable(a, b):
def _iadd_mutablelinear_native(a, b):
if not b:
return a
- a._args_.append(b)
- a._nargs += 1
+ if a._args_ and a._args_[-1].__class__ in native_numeric_types:
+ a._args_[-1] += b
+ else:
+ a._args_.append(b)
+ a._nargs += 1
return a
@@ -2392,16 +2401,14 @@ def _iadd_mutablelinear_npv(a, b):
def _iadd_mutablelinear_param(a, b):
if b.is_constant():
- b = b.value
- if not b:
- return a
+ return _iadd_mutablesum_native(a, b.value)
a._args_.append(b)
a._nargs += 1
return a
def _iadd_mutablelinear_var(a, b):
- a._args_.append(MonomialTermExpression((1, b)))
+ a._args_.append(b)
a._nargs += 1
return a
@@ -2478,8 +2485,11 @@ def _iadd_mutablesum_mutable(a, b):
def _iadd_mutablesum_native(a, b):
if not b:
return a
- a._args_.append(b)
- a._nargs += 1
+ if a._args_ and a._args_[-1].__class__ in native_numeric_types:
+ a._args_[-1] += b
+ else:
+ a._args_.append(b)
+ a._nargs += 1
return a
@@ -2491,9 +2501,7 @@ def _iadd_mutablesum_npv(a, b):
def _iadd_mutablesum_param(a, b):
if b.is_constant():
- b = b.value
- if not b:
- return a
+ return _iadd_mutablesum_native(a, b.value)
a._args_.append(b)
a._nargs += 1
return a
diff --git a/pyomo/core/expr/numvalue.py b/pyomo/core/expr/numvalue.py
index 3a4359af2f9..96e2f50b3f8 100644
--- a/pyomo/core/expr/numvalue.py
+++ b/pyomo/core/expr/numvalue.py
@@ -28,7 +28,7 @@
native_numeric_types,
native_integer_types,
native_logical_types,
- pyomo_constant_types,
+ _pyomo_constant_types,
check_if_numeric_type,
value,
)
@@ -44,6 +44,16 @@
"be treated as if they were bool (as was the case for the other "
"native_*_types sets). Users likely should use native_logical_types.",
)
+relocated_module_attribute(
+ 'pyomo_constant_types',
+ 'pyomo.common.numeric_types._pyomo_constant_types',
+ version='6.7.2',
+ f_globals=globals(),
+ msg="The pyomo_constant_types set will be removed in the future: the set "
+ "contained only NumericConstant and _PythonCallbackFunctionID, and provided "
+ "no meaningful value to clients or walkers. Users should likely handle "
+ "these types in the same manner as immutable Params.",
+)
relocated_module_attribute(
'RegisterNumericType',
'pyomo.common.numeric_types.RegisterNumericType',
@@ -85,7 +95,7 @@
##------------------------------------------------------------------------
-class NonNumericValue(object):
+class NonNumericValue(PyomoObject):
"""An object that contains a non-numeric value
Constructor Arguments:
@@ -100,6 +110,9 @@ def __init__(self, value):
def __str__(self):
return str(self.value)
+ def __call__(self, exception=None):
+ return self.value
+
nonpyomo_leaf_types.add(NonNumericValue)
@@ -410,7 +423,7 @@ def pprint(self, ostream=None, verbose=False):
ostream.write(str(self))
-pyomo_constant_types.add(NumericConstant)
+_pyomo_constant_types.add(NumericConstant)
# We use as_numeric() so that the constant is also in the cache
ZeroConstant = as_numeric(0)
diff --git a/pyomo/core/expr/sympy_tools.py b/pyomo/core/expr/sympy_tools.py
index 48bd542be0f..d751ca35e5f 100644
--- a/pyomo/core/expr/sympy_tools.py
+++ b/pyomo/core/expr/sympy_tools.py
@@ -9,13 +9,13 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
import operator
-import sys
+from math import prod as _prod
+import pyomo.core.expr as EXPR
from pyomo.common import DeveloperError
from pyomo.common.collections import ComponentMap
from pyomo.common.dependencies import attempt_import
from pyomo.common.errors import NondifferentiableError
-import pyomo.core.expr as EXPR
from pyomo.core.expr.numvalue import value, native_types
#
@@ -28,6 +28,25 @@
_functionMap = {}
+def _nondifferentiable(x):
+ if type(x[1]) is tuple:
+ # sympy >= 1.3 returns tuples (var, order)
+ wrt = x[1][0]
+ else:
+ # early versions of sympy returned the bare var
+ wrt = x[1]
+ raise NondifferentiableError(
+ "The sub-expression '%s' is not differentiable with respect to %s" % (x[0], wrt)
+ )
+
+
+def _external_fcn(*x):
+ raise TypeError(
+ "Expressions containing external functions are not convertible to "
+ f"sympy expressions (found 'f{x}')"
+ )
+
+
def _configure_sympy(sympy, available):
if not available:
return
@@ -113,37 +132,6 @@ def _configure_sympy(sympy, available):
sympy, sympy_available = attempt_import('sympy', callback=_configure_sympy)
-if sys.version_info[:2] < (3, 8):
-
- def _prod(args):
- ans = 1
- for arg in args:
- ans *= arg
- return ans
-
-else:
- from math import prod as _prod
-
-
-def _nondifferentiable(x):
- if type(x[1]) is tuple:
- # sympy >= 1.3 returns tuples (var, order)
- wrt = x[1][0]
- else:
- # early versions of sympy returned the bare var
- wrt = x[1]
- raise NondifferentiableError(
- "The sub-expression '%s' is not differentiable with respect to %s" % (x[0], wrt)
- )
-
-
-def _external_fcn(*x):
- raise TypeError(
- "Expressions containing external functions are not convertible to "
- f"sympy expressions (found 'f{x}')"
- )
-
-
class PyomoSympyBimap(object):
def __init__(self):
self.pyomo2sympy = ComponentMap()
@@ -175,10 +163,11 @@ def sympyVars(self):
class Pyomo2SympyVisitor(EXPR.StreamBasedExpressionVisitor):
- def __init__(self, object_map):
+ def __init__(self, object_map, keep_mutable_parameters=False):
sympy.Add # this ensures _configure_sympy gets run
super(Pyomo2SympyVisitor, self).__init__()
self.object_map = object_map
+ self.keep_mutable_parameters = keep_mutable_parameters
def initializeWalker(self, expr):
return self.beforeChild(None, expr, None)
@@ -212,6 +201,8 @@ def beforeChild(self, node, child, child_idx):
#
# Everything else is a constant...
#
+ if self.keep_mutable_parameters and child.is_parameter_type() and child.mutable:
+ return False, self.object_map.getSympySymbol(child)
return False, value(child)
@@ -245,13 +236,15 @@ def beforeChild(self, node, child, child_idx):
return True, None
-def sympyify_expression(expr):
+def sympyify_expression(expr, keep_mutable_parameters=False):
"""Convert a Pyomo expression to a Sympy expression"""
#
# Create the visitor and call it.
#
object_map = PyomoSympyBimap()
- visitor = Pyomo2SympyVisitor(object_map)
+ visitor = Pyomo2SympyVisitor(
+ object_map, keep_mutable_parameters=keep_mutable_parameters
+ )
return object_map, visitor.walk_expression(expr)
diff --git a/pyomo/core/expr/template_expr.py b/pyomo/core/expr/template_expr.py
index f65a1f2b9b0..d30046e9d82 100644
--- a/pyomo/core/expr/template_expr.py
+++ b/pyomo/core/expr/template_expr.py
@@ -19,11 +19,12 @@
from pyomo.core.expr.base import ExpressionBase, ExpressionArgs_Mixin, NPV_Mixin
from pyomo.core.expr.logical_expr import BooleanExpression
from pyomo.core.expr.numeric_expr import (
+ ARG_TYPE,
NumericExpression,
- SumExpression,
Numeric_NPV_Mixin,
+ SumExpression,
+ mutable_expression,
register_arg_type,
- ARG_TYPE,
_balanced_parens,
)
from pyomo.core.expr.numvalue import (
@@ -116,18 +117,10 @@ def _to_string(self, values, verbose, smap):
return "%s[%s]" % (values[0], ','.join(values[1:]))
def _resolve_template(self, args):
- return args[0].__getitem__(tuple(args[1:]))
+ return args[0].__getitem__(args[1:])
def _apply_operation(self, result):
- args = tuple(
- (
- arg
- if arg.__class__ in native_types or not arg.is_numeric_type()
- else value(arg)
- )
- for arg in result[1:]
- )
- return result[0].__getitem__(tuple(result[1:]))
+ return result[0].__getitem__(result[1:])
class Numeric_GetItemExpression(GetItemExpression, NumericExpression):
@@ -258,8 +251,8 @@ def nargs(self):
return 2
def _apply_operation(self, result):
- assert len(result) == 2
- return getattr(result[0], result[1])
+ obj, attr = result
+ return getattr(obj, attr)
def _to_string(self, values, verbose, smap):
assert len(values) == 2
@@ -273,7 +266,7 @@ def _to_string(self, values, verbose, smap):
return "%s.%s" % (values[0], attr)
def _resolve_template(self, args):
- return getattr(*tuple(args))
+ return getattr(*args)
class Numeric_GetAttrExpression(GetAttrExpression, NumericExpression):
@@ -521,7 +514,15 @@ def _to_string(self, values, verbose, smap):
return 'SUM(%s %s)' % (val, iterStr)
def _resolve_template(self, args):
- return SumExpression(args)
+ with mutable_expression() as e:
+ for arg in args:
+ e += arg
+ if e.nargs() > 1:
+ return e
+ elif not e.nargs():
+ return 0
+ else:
+ return e.arg(0)
class IndexTemplate(NumericValue):
diff --git a/pyomo/core/expr/visitor.py b/pyomo/core/expr/visitor.py
index 6a9b7955281..08015f8b42c 100644
--- a/pyomo/core/expr/visitor.py
+++ b/pyomo/core/expr/visitor.py
@@ -1373,22 +1373,125 @@ def identify_components(expr, component_types):
# =====================================================
-class _VariableVisitor(SimpleExpressionVisitor):
- def __init__(self):
- self.seen = set()
+class _VariableVisitor(StreamBasedExpressionVisitor):
+ def __init__(self, include_fixed=False, named_expression_cache=None):
+ """Visitor that collects all unique variables participating in an
+ expression
- def visit(self, node):
- if node.__class__ in nonpyomo_leaf_types:
- return
+ Args:
+ include_fixed (bool): Whether to include fixed variables
+ named_expression_cache (optional, dict): Dict mapping ids of named
+ expressions to a tuple of the list of all variables and the
+ set of all variable ids contained in the named expression.
- if node.is_variable_type():
- if id(node) in self.seen:
- return
- self.seen.add(id(node))
- return node
+ """
+ super().__init__()
+ self._include_fixed = include_fixed
+ if named_expression_cache is None:
+ # This cache will map named expression ids to the
+ # tuple: ([variables], {variable ids})
+ named_expression_cache = {}
+ self._named_expression_cache = named_expression_cache
+ # Stack of active named expressions. This holds the id of
+ # expressions we are currently in.
+ self._active_named_expressions = []
+ def initializeWalker(self, expr):
+ if expr.__class__ in native_types:
+ return False, []
+ elif expr.is_named_expression_type():
+ eid = id(expr)
+ if eid in self._named_expression_cache:
+ # If we were given a named expression that is already cached,
+ # just do nothing and return the expression's variables
+ variables, var_set = self._named_expression_cache[eid]
+ return False, variables
+ else:
+ # We were given a named expression that is not cached.
+ # Initialize data structures and add this expression to the
+ # stack. This expression will get popped in exitNode.
+ self._variables = []
+ self._seen = set()
+ self._named_expression_cache[eid] = [], set()
+ self._active_named_expressions.append(eid)
+ return True, expr
+ elif expr.is_variable_type():
+ return False, [expr]
+ else:
+ self._variables = []
+ self._seen = set()
+ return True, expr
-def identify_variables(expr, include_fixed=True):
+ def beforeChild(self, parent, child, index):
+ if child.__class__ in native_types:
+ return False, None
+ elif child.is_named_expression_type():
+ eid = id(child)
+ if eid in self._named_expression_cache:
+ # We have already encountered this named expression. We just add
+ # the cached variables to our list and don't descend.
+ if self._active_named_expressions:
+ # If we are in another named expression, we update the
+ # parent expression's cache. We don't need to update the
+ # global list as we will do this when we exit the active
+ # named expression.
+ parent_eid = self._active_named_expressions[-1]
+ variables, var_set = self._named_expression_cache[parent_eid]
+ else:
+ # If we are not in a named expression, we update the global
+ # list.
+ variables = self._variables
+ var_set = self._seen
+ for var in self._named_expression_cache[eid][0]:
+ if id(var) not in var_set:
+ var_set.add(id(var))
+ variables.append(var)
+ return False, None
+ else:
+ # If we are descending into a new named expression, initialize
+ # a cache to store the expression's local variables.
+ self._named_expression_cache[id(child)] = ([], set())
+ self._active_named_expressions.append(id(child))
+ return True, None
+ elif child.is_variable_type() and (self._include_fixed or not child.fixed):
+ if self._active_named_expressions:
+ # If we are in a named expression, add new variables to the cache.
+ eid = self._active_named_expressions[-1]
+ variables, var_set = self._named_expression_cache[eid]
+ else:
+ variables = self._variables
+ var_set = self._seen
+ if id(child) not in var_set:
+ var_set.add(id(child))
+ variables.append(child)
+ return False, None
+ else:
+ return True, None
+
+ def exitNode(self, node, data):
+ if node.is_named_expression_type():
+ # If we are returning from a named expression, we have at least one
+ # active named expression. We must make sure that we properly
+ # handle the variables for the named expression we just exited.
+ eid = self._active_named_expressions.pop()
+ if self._active_named_expressions:
+ # If we still are in a named expression, we update that expression's
+ # cache with any new variables encountered.
+ parent_eid = self._active_named_expressions[-1]
+ variables, var_set = self._named_expression_cache[parent_eid]
+ else:
+ variables = self._variables
+ var_set = self._seen
+ for var in self._named_expression_cache[eid][0]:
+ if id(var) not in var_set:
+ var_set.add(id(var))
+ variables.append(var)
+
+ def finalizeResult(self, result):
+ return self._variables
+
+
+def identify_variables(expr, include_fixed=True, named_expression_cache=None):
"""
A generator that yields a sequence of variables
in an expression tree.
@@ -1402,22 +1505,13 @@ def identify_variables(expr, include_fixed=True):
Yields:
Each variable that is found.
"""
- visitor = _VariableVisitor()
- if include_fixed:
- for v in visitor.xbfs_yield_leaves(expr):
- if isinstance(v, tuple):
- yield from v
- else:
- yield v
- else:
- for v in visitor.xbfs_yield_leaves(expr):
- if isinstance(v, tuple):
- for v_i in v:
- if not v_i.is_fixed():
- yield v_i
- else:
- if not v.is_fixed():
- yield v
+ if named_expression_cache is None:
+ named_expression_cache = {}
+ visitor = _VariableVisitor(
+ named_expression_cache=named_expression_cache, include_fixed=include_fixed
+ )
+ variables = visitor.walk_expression(expr)
+ yield from variables
# =====================================================
diff --git a/pyomo/core/kernel/objective.py b/pyomo/core/kernel/objective.py
index 9aa8e3315ef..ac6f22d07d3 100644
--- a/pyomo/core/kernel/objective.py
+++ b/pyomo/core/kernel/objective.py
@@ -9,15 +9,12 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
+from pyomo.common.enums import ObjectiveSense, minimize, maximize
from pyomo.core.expr.numvalue import as_numeric
from pyomo.core.kernel.base import _abstract_readwrite_property
from pyomo.core.kernel.container_utils import define_simple_containers
from pyomo.core.kernel.expression import IExpression
-# Constants used to define the optimization sense
-minimize = 1
-maximize = -1
-
class IObjective(IExpression):
"""
@@ -84,14 +81,7 @@ def sense(self):
@sense.setter
def sense(self, sense):
"""Set the sense (direction) of this objective."""
- if (sense == minimize) or (sense == maximize):
- self._sense = sense
- else:
- raise ValueError(
- "Objective sense must be set to one of: "
- "[minimize (%s), maximize (%s)]. Invalid "
- "value: %s'" % (minimize, maximize, sense)
- )
+ self._sense = ObjectiveSense(sense)
# inserts class definitions for simple _tuple, _list, and
diff --git a/pyomo/core/plugins/transform/add_slack_vars.py b/pyomo/core/plugins/transform/add_slack_vars.py
index 6b5096d315c..39903384729 100644
--- a/pyomo/core/plugins/transform/add_slack_vars.py
+++ b/pyomo/core/plugins/transform/add_slack_vars.py
@@ -23,7 +23,6 @@
from pyomo.core.plugins.transform.hierarchy import NonIsomorphicTransformation
from pyomo.common.config import ConfigBlock, ConfigValue
from pyomo.core.base import ComponentUID
-from pyomo.core.base.constraint import _ConstraintData
from pyomo.common.deprecation import deprecation_warning
@@ -42,7 +41,7 @@ def target_list(x):
# [ESJ 07/15/2020] We have to just pass it through because we need the
# instance in order to be able to do anything about it...
return [x]
- elif isinstance(x, (Constraint, _ConstraintData)):
+ elif getattr(x, 'ctype', None) is Constraint:
return [x]
elif hasattr(x, '__iter__'):
ans = []
@@ -53,7 +52,7 @@ def target_list(x):
deprecation_msg = None
# same as above...
ans.append(i)
- elif isinstance(i, (Constraint, _ConstraintData)):
+ elif getattr(i, 'ctype', None) is Constraint:
ans.append(i)
else:
raise ValueError(
diff --git a/pyomo/core/plugins/transform/eliminate_fixed_vars.py b/pyomo/core/plugins/transform/eliminate_fixed_vars.py
index 9312035b8c8..934228afd7c 100644
--- a/pyomo/core/plugins/transform/eliminate_fixed_vars.py
+++ b/pyomo/core/plugins/transform/eliminate_fixed_vars.py
@@ -11,7 +11,7 @@
from pyomo.core.expr import ExpressionBase, as_numeric
from pyomo.core import Constraint, Objective, TransformationFactory
-from pyomo.core.base.var import Var, _VarData
+from pyomo.core.base.var import Var, VarData
from pyomo.core.util import sequence
from pyomo.core.plugins.transform.hierarchy import IsomorphicTransformation
@@ -77,7 +77,7 @@ def _fix_vars(self, expr, model):
if isinstance(expr._args[i], ExpressionBase):
_args.append(self._fix_vars(expr._args[i], model))
elif (
- isinstance(expr._args[i], Var) or isinstance(expr._args[i], _VarData)
+ isinstance(expr._args[i], Var) or isinstance(expr._args[i], VarData)
) and expr._args[i].fixed:
if expr._args[i].value != 0.0:
_args.append(as_numeric(expr._args[i].value))
diff --git a/pyomo/core/plugins/transform/equality_transform.py b/pyomo/core/plugins/transform/equality_transform.py
index a1a1b72f146..99291c2227c 100644
--- a/pyomo/core/plugins/transform/equality_transform.py
+++ b/pyomo/core/plugins/transform/equality_transform.py
@@ -66,7 +66,7 @@ def _create_using(self, model, **kwds):
con = equality.__getattribute__(con_name)
#
- # Get all _ConstraintData objects
+ # Get all ConstraintData objects
#
# We need to get the keys ahead of time because we are modifying
# con._data on-the-fly.
@@ -104,7 +104,7 @@ def _create_using(self, model, **kwds):
con.add(ub_name, new_expr)
# Since we explicitly `continue` for equality constraints, we
- # can safely remove the old _ConstraintData object
+ # can safely remove the old ConstraintData object
del con._data[ndx]
return equality.create()
diff --git a/pyomo/core/plugins/transform/expand_connectors.py b/pyomo/core/plugins/transform/expand_connectors.py
index 8c02f3e5698..82ec546e593 100644
--- a/pyomo/core/plugins/transform/expand_connectors.py
+++ b/pyomo/core/plugins/transform/expand_connectors.py
@@ -25,7 +25,7 @@
Var,
SortComponents,
)
-from pyomo.core.base.connector import _ConnectorData, ScalarConnector
+from pyomo.core.base.connector import ConnectorData, ScalarConnector
@TransformationFactory.register(
@@ -69,7 +69,7 @@ def _apply_to(self, instance, **kwds):
# The set of connectors found in the current constraint
found = ComponentSet()
- connector_types = set([ScalarConnector, _ConnectorData])
+ connector_types = set([ScalarConnector, ConnectorData])
for constraint in instance.component_data_objects(
Constraint, sort=SortComponents.deterministic
):
diff --git a/pyomo/core/plugins/transform/logical_to_linear.py b/pyomo/core/plugins/transform/logical_to_linear.py
index 7aa541a5fdd..da69ca113bd 100644
--- a/pyomo/core/plugins/transform/logical_to_linear.py
+++ b/pyomo/core/plugins/transform/logical_to_linear.py
@@ -29,7 +29,7 @@
BooleanVarList,
SortComponents,
)
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.core.base.boolean_var import _DeprecatedImplicitAssociatedBinaryVariable
from pyomo.core.expr.cnf_walker import to_cnf
from pyomo.core.expr import (
@@ -100,7 +100,7 @@ def _apply_to(self, model, **kwds):
# the GDP will be solved, and it would be wrong to assume that a GDP
# will *necessarily* be solved as an algebraic model. The star
# example of not doing so being GDPopt.)
- if t.ctype is Block or isinstance(t, _BlockData):
+ if t.ctype is Block or isinstance(t, BlockData):
self._transform_block(t, model, new_var_lists, transBlocks)
elif t.ctype is LogicalConstraint:
if t.is_indexed():
@@ -285,7 +285,7 @@ class CnfToLinearVisitor(StreamBasedExpressionVisitor):
"""Convert CNF logical constraint to linear constraints.
Expected expression node types: AndExpression, OrExpression, NotExpression,
- AtLeastExpression, AtMostExpression, ExactlyExpression, _BooleanVarData
+ AtLeastExpression, AtMostExpression, ExactlyExpression, BooleanVarData
"""
@@ -372,7 +372,7 @@ def beforeChild(self, node, child, child_idx):
if child.is_expression_type():
return True, None
- # Only thing left should be _BooleanVarData
+ # Only thing left should be BooleanVarData
#
# TODO: After the expr_multiple_dispatch is merged, this should
# be switched to using as_numeric.
diff --git a/pyomo/core/plugins/transform/model.py b/pyomo/core/plugins/transform/model.py
index db8376afd29..8fe828854ce 100644
--- a/pyomo/core/plugins/transform/model.py
+++ b/pyomo/core/plugins/transform/model.py
@@ -16,10 +16,17 @@
# because we may support an explicit matrix representation for models.
#
+from pyomo.common.deprecation import deprecated
from pyomo.core.base import Objective, Constraint
import array
+@deprecated(
+ "to_standard_form() is deprecated. "
+ "Please use WriterFactory('compile_standard_form')",
+ version='6.7.3',
+ remove_in='6.8.0',
+)
def to_standard_form(self):
"""
Produces a standard-form representation of the model. Returns
@@ -55,8 +62,8 @@ def to_standard_form(self):
# N.B. Structure hierarchy:
#
# active_components: {class: {attr_name: object}}
- # object -> Constraint: ._data: {ndx: _ConstraintData}
- # _ConstraintData: .lower, .body, .upper
+ # object -> Constraint: ._data: {ndx: ConstraintData}
+ # ConstraintData: .lower, .body, .upper
#
# So, altogether, we access a lower bound via
#
diff --git a/pyomo/core/plugins/transform/radix_linearization.py b/pyomo/core/plugins/transform/radix_linearization.py
index c67e556d60c..92270655f31 100644
--- a/pyomo/core/plugins/transform/radix_linearization.py
+++ b/pyomo/core/plugins/transform/radix_linearization.py
@@ -21,7 +21,7 @@
Block,
RangeSet,
)
-from pyomo.core.base.var import _VarData
+from pyomo.core.base.var import VarData
import logging
@@ -268,8 +268,8 @@ def _collect_bilinear(self, expr, bilin, quad):
self._collect_bilinear(e, bilin, quad)
# No need to check denominator, as this is poly_degree==2
return
- if not isinstance(expr._numerator[0], _VarData) or not isinstance(
- expr._numerator[1], _VarData
+ if not isinstance(expr._numerator[0], VarData) or not isinstance(
+ expr._numerator[1], VarData
):
raise RuntimeError("Cannot yet handle complex subexpressions")
if expr._numerator[0] is expr._numerator[1]:
diff --git a/pyomo/core/plugins/transform/scaling.py b/pyomo/core/plugins/transform/scaling.py
index ad894b31fde..11d4ac8c493 100644
--- a/pyomo/core/plugins/transform/scaling.py
+++ b/pyomo/core/plugins/transform/scaling.py
@@ -10,16 +10,7 @@
# ___________________________________________________________________________
from pyomo.common.collections import ComponentMap
-from pyomo.core.base import (
- Block,
- Var,
- Constraint,
- Objective,
- _ConstraintData,
- _ObjectiveData,
- Suffix,
- value,
-)
+from pyomo.core.base import Block, Var, Constraint, Objective, Suffix, value
from pyomo.core.plugins.transform.hierarchy import Transformation
from pyomo.core.base import TransformationFactory
from pyomo.core.base.suffix import SuffixFinder
@@ -197,7 +188,7 @@ def _apply_to(self, model, rename=True):
already_scaled.add(id(c))
# perform the constraint/objective scaling and variable sub
scaling_factor = component_scaling_factor_map[c]
- if isinstance(c, _ConstraintData):
+ if c.ctype is Constraint:
body = scaling_factor * replace_expressions(
expr=c.body,
substitution_map=variable_substitution_dict,
@@ -226,7 +217,7 @@ def _apply_to(self, model, rename=True):
else:
c.set_value((lower, body, upper))
- elif isinstance(c, _ObjectiveData):
+ elif c.ctype is Objective:
c.expr = scaling_factor * replace_expressions(
expr=c.expr,
substitution_map=variable_substitution_dict,
diff --git a/pyomo/core/tests/examples/pmedian_concrete.py b/pyomo/core/tests/examples/pmedian_concrete.py
new file mode 100644
index 00000000000..a6a1859df23
--- /dev/null
+++ b/pyomo/core/tests/examples/pmedian_concrete.py
@@ -0,0 +1,70 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 math
+from pyomo.environ import (
+ ConcreteModel,
+ Param,
+ RangeSet,
+ Var,
+ Reals,
+ Binary,
+ PositiveIntegers,
+)
+
+
+def _cost_rule(model, n, m):
+ # We will assume costs are an arbitrary function of the indices
+ return math.sin(n * 2.33333 + m * 7.99999)
+
+
+def create_model(n=3, m=3, p=2):
+ model = ConcreteModel(name="M1")
+
+ model.N = Param(initialize=n, within=PositiveIntegers)
+ model.M = Param(initialize=m, within=PositiveIntegers)
+ model.P = Param(initialize=p, within=RangeSet(1, model.N), mutable=True)
+
+ model.Locations = RangeSet(1, model.N)
+ model.Customers = RangeSet(1, model.M)
+
+ model.cost = Param(
+ model.Locations, model.Customers, initialize=_cost_rule, within=Reals
+ )
+ model.serve_customer_from_location = Var(
+ model.Locations, model.Customers, bounds=(0.0, 1.0)
+ )
+ model.select_location = Var(model.Locations, within=Binary)
+
+ @model.Objective()
+ def obj(model):
+ return sum(
+ model.cost[n, m] * model.serve_customer_from_location[n, m]
+ for n in model.Locations
+ for m in model.Customers
+ )
+
+ @model.Constraint(model.Customers)
+ def single_x(model, m):
+ return (
+ sum(model.serve_customer_from_location[n, m] for n in model.Locations)
+ == 1.0
+ )
+
+ @model.Constraint(model.Locations, model.Customers)
+ def bound_y(model, n, m):
+ return model.serve_customer_from_location[n, m] <= model.select_location[n]
+
+ @model.Constraint()
+ def num_facilities(model):
+ return sum(model.select_location[n] for n in model.Locations) == model.P
+
+ return model
diff --git a/pyomo/core/tests/transform/test_add_slacks.py b/pyomo/core/tests/transform/test_add_slacks.py
index 7896cab7e88..b395237b8e4 100644
--- a/pyomo/core/tests/transform/test_add_slacks.py
+++ b/pyomo/core/tests/transform/test_add_slacks.py
@@ -102,10 +102,7 @@ def checkRule1(self, m):
self,
cons.body,
EXPR.LinearExpression(
- [
- EXPR.MonomialTermExpression((1, m.x)),
- EXPR.MonomialTermExpression((-1, transBlock._slack_minus_rule1)),
- ]
+ [m.x, EXPR.MonomialTermExpression((-1, transBlock._slack_minus_rule1))]
),
)
@@ -118,14 +115,7 @@ def checkRule3(self, m):
self.assertEqual(cons.lower, 0.1)
assertExpressionsEqual(
- self,
- cons.body,
- EXPR.LinearExpression(
- [
- EXPR.MonomialTermExpression((1, m.x)),
- EXPR.MonomialTermExpression((1, transBlock._slack_plus_rule3)),
- ]
- ),
+ self, cons.body, EXPR.LinearExpression([m.x, transBlock._slack_plus_rule3])
)
def test_ub_constraint_modified(self):
@@ -154,8 +144,8 @@ def test_both_bounds_constraint_modified(self):
cons.body,
EXPR.LinearExpression(
[
- EXPR.MonomialTermExpression((1, m.y)),
- EXPR.MonomialTermExpression((1, transBlock._slack_plus_rule2)),
+ m.y,
+ transBlock._slack_plus_rule2,
EXPR.MonomialTermExpression((-1, transBlock._slack_minus_rule2)),
]
),
@@ -184,10 +174,10 @@ def test_new_obj_created(self):
obj.expr,
EXPR.LinearExpression(
[
- EXPR.MonomialTermExpression((1, transBlock._slack_minus_rule1)),
- EXPR.MonomialTermExpression((1, transBlock._slack_plus_rule2)),
- EXPR.MonomialTermExpression((1, transBlock._slack_minus_rule2)),
- EXPR.MonomialTermExpression((1, transBlock._slack_plus_rule3)),
+ transBlock._slack_minus_rule1,
+ transBlock._slack_plus_rule2,
+ transBlock._slack_minus_rule2,
+ transBlock._slack_plus_rule3,
]
),
)
@@ -302,10 +292,7 @@ def checkTargetsObj(self, m):
self,
obj.expr,
EXPR.LinearExpression(
- [
- EXPR.MonomialTermExpression((1, transBlock._slack_minus_rule1)),
- EXPR.MonomialTermExpression((1, transBlock._slack_plus_rule3)),
- ]
+ [transBlock._slack_minus_rule1, transBlock._slack_plus_rule3]
),
)
@@ -343,7 +330,7 @@ def test_error_for_non_constraint_noniterable_target(self):
self.assertRaisesRegex(
ValueError,
"Expected Constraint or list of Constraints.\n\tReceived "
- "",
+ "",
TransformationFactory('core.add_slack_variables').apply_to,
m,
targets=m.indexedVar[1],
@@ -423,9 +410,9 @@ def test_transformed_constraints_sumexpression_body(self):
c.body,
EXPR.LinearExpression(
[
- EXPR.MonomialTermExpression((1, m.x)),
+ m.x,
EXPR.MonomialTermExpression((-2, m.y)),
- EXPR.MonomialTermExpression((1, transBlock._slack_plus_rule4)),
+ transBlock._slack_plus_rule4,
EXPR.MonomialTermExpression((-1, transBlock._slack_minus_rule4)),
]
),
@@ -518,15 +505,9 @@ def checkTargetObj(self, m):
obj.expr,
EXPR.LinearExpression(
[
- EXPR.MonomialTermExpression(
- (1, transBlock.component("_slack_plus_rule1[1]"))
- ),
- EXPR.MonomialTermExpression(
- (1, transBlock.component("_slack_plus_rule1[2]"))
- ),
- EXPR.MonomialTermExpression(
- (1, transBlock.component("_slack_plus_rule1[3]"))
- ),
+ transBlock.component("_slack_plus_rule1[1]"),
+ transBlock.component("_slack_plus_rule1[2]"),
+ transBlock.component("_slack_plus_rule1[3]"),
]
),
)
@@ -558,14 +539,7 @@ def checkTransformedRule1(self, m, i):
EXPR.LinearExpression(
[
EXPR.MonomialTermExpression((2, m.x[i])),
- EXPR.MonomialTermExpression(
- (
- 1,
- m._core_add_slack_variables.component(
- "_slack_plus_rule1[%s]" % i
- ),
- )
- ),
+ m._core_add_slack_variables.component("_slack_plus_rule1[%s]" % i),
]
),
)
diff --git a/pyomo/core/tests/unit/test_block.py b/pyomo/core/tests/unit/test_block.py
index c9c68a820f7..3d578f7dc88 100644
--- a/pyomo/core/tests/unit/test_block.py
+++ b/pyomo/core/tests/unit/test_block.py
@@ -13,6 +13,7 @@
#
from io import StringIO
+import logging
import os
import sys
import types
@@ -54,7 +55,7 @@
from pyomo.core.base.block import (
ScalarBlock,
SubclassOf,
- _BlockData,
+ BlockData,
declare_custom_block,
)
import pyomo.core.expr as EXPR
@@ -851,7 +852,7 @@ class DerivedBlock(ScalarBlock):
_Block_reserved_words = None
DerivedBlock._Block_reserved_words = (
- set(['a', 'b', 'c']) | _BlockData._Block_reserved_words
+ set(['a', 'b', 'c']) | BlockData._Block_reserved_words
)
m = ConcreteModel()
@@ -965,7 +966,7 @@ def __init__(self, *args, **kwds):
b.c.d.e = Block()
with self.assertRaisesRegex(
ValueError,
- r'_BlockData.transfer_attributes_from\(\): '
+ r'BlockData.transfer_attributes_from\(\): '
r'Cannot set a sub-block \(c.d.e\) to a parent block \(c\):',
):
b.c.d.e.transfer_attributes_from(b.c)
@@ -974,7 +975,7 @@ def __init__(self, *args, **kwds):
b = Block(concrete=True)
with self.assertRaisesRegex(
ValueError,
- r'_BlockData.transfer_attributes_from\(\): expected a Block '
+ r'BlockData.transfer_attributes_from\(\): expected a Block '
'or dict; received str',
):
b.transfer_attributes_from('foo')
@@ -2667,7 +2668,6 @@ def test_pprint(self):
5 Declarations: a1_IDX a3_IDX c a b
"""
- self.maxDiff = None
self.assertEqual(ref, buf.getvalue())
@unittest.skipIf(not 'glpk' in solvers, "glpk solver is not available")
@@ -2976,9 +2976,70 @@ def test_write_exceptions(self):
with self.assertRaisesRegex(ValueError, ".*Cannot write model in format"):
m.write(format="bogus")
- def test_override_pprint(self):
+ def test_custom_block(self):
+ @declare_custom_block('TestingBlock')
+ class TestingBlockData(BlockData):
+ def __init__(self, component):
+ BlockData.__init__(self, component)
+ logging.getLogger(__name__).warning("TestingBlockData.__init__")
+
+ self.assertIn('TestingBlock', globals())
+ self.assertIn('ScalarTestingBlock', globals())
+ self.assertIn('IndexedTestingBlock', globals())
+ self.assertIs(TestingBlock.__module__, __name__)
+ self.assertIs(ScalarTestingBlock.__module__, __name__)
+ self.assertIs(IndexedTestingBlock.__module__, __name__)
+
+ with LoggingIntercept() as LOG:
+ obj = TestingBlock()
+ self.assertIs(type(obj), ScalarTestingBlock)
+ self.assertEqual(LOG.getvalue().strip(), "TestingBlockData.__init__")
+
+ with LoggingIntercept() as LOG:
+ obj = TestingBlock([1, 2])
+ self.assertIs(type(obj), IndexedTestingBlock)
+ self.assertEqual(LOG.getvalue(), "")
+
+ # Test that we can derive from a ScalarCustomBlock
+ class DerivedScalarTestingBlock(ScalarTestingBlock):
+ pass
+
+ with LoggingIntercept() as LOG:
+ obj = DerivedScalarTestingBlock()
+ self.assertIs(type(obj), DerivedScalarTestingBlock)
+ self.assertEqual(LOG.getvalue().strip(), "TestingBlockData.__init__")
+
+ def test_custom_block_ctypes(self):
+ @declare_custom_block('TestingBlock')
+ class TestingBlockData(BlockData):
+ pass
+
+ self.assertIs(TestingBlock().ctype, Block)
+
+ @declare_custom_block('TestingBlock', True)
+ class TestingBlockData(BlockData):
+ pass
+
+ self.assertIs(TestingBlock().ctype, TestingBlock)
+
+ @declare_custom_block('TestingBlock', Constraint)
+ class TestingBlockData(BlockData):
+ pass
+
+ self.assertIs(TestingBlock().ctype, Constraint)
+
+ with self.assertRaisesRegex(
+ ValueError,
+ r"Expected new_ctype to be either type or 'True'; received: \[\]",
+ ):
+
+ @declare_custom_block('TestingBlock', [])
+ class TestingBlockData(BlockData):
+ pass
+
+ def test_custom_block_override_pprint(self):
@declare_custom_block('TempBlock')
- class TempBlockData(_BlockData):
+ class TempBlockData(BlockData):
def pprint(self, ostream=None, verbose=False, prefix=""):
ostream.write('Testing pprint of a custom block.')
@@ -3053,9 +3114,9 @@ def test_derived_block_construction(self):
class ConcreteBlock(Block):
pass
- class ScalarConcreteBlock(_BlockData, ConcreteBlock):
+ class ScalarConcreteBlock(BlockData, ConcreteBlock):
def __init__(self, *args, **kwds):
- _BlockData.__init__(self, component=self)
+ BlockData.__init__(self, component=self)
ConcreteBlock.__init__(self, *args, **kwds)
_buf = []
@@ -3437,6 +3498,64 @@ def test_private_data(self):
mfe4 = m.b.b[1].private_data('pyomo.core.tests')
self.assertIs(mfe4, mfe3)
+ def test_register_private_data(self):
+ _save = Block._private_data_initializers
+
+ Block._private_data_initializers = pdi = _save.copy()
+ pdi.clear()
+ try:
+ self.assertEqual(len(pdi), 0)
+ b = Block(concrete=True)
+ ps = b.private_data()
+ self.assertEqual(ps, {})
+ self.assertEqual(len(pdi), 1)
+ finally:
+ Block._private_data_initializers = _save
+
+ def init():
+ return {'a': None, 'b': 1}
+
+ Block._private_data_initializers = pdi = _save.copy()
+ pdi.clear()
+ try:
+ self.assertEqual(len(pdi), 0)
+ Block.register_private_data_initializer(init)
+ self.assertEqual(len(pdi), 1)
+
+ b = Block(concrete=True)
+ ps = b.private_data()
+ self.assertEqual(ps, {'a': None, 'b': 1})
+ self.assertEqual(len(pdi), 1)
+ finally:
+ Block._private_data_initializers = _save
+
+ Block._private_data_initializers = pdi = _save.copy()
+ pdi.clear()
+ try:
+ Block.register_private_data_initializer(init)
+ self.assertEqual(len(pdi), 1)
+ Block.register_private_data_initializer(init, 'pyomo')
+ self.assertEqual(len(pdi), 2)
+
+ with self.assertRaisesRegex(
+ RuntimeError,
+ r"Duplicate initializer registration for 'private_data' "
+ r"dictionary \(scope=pyomo.core.tests.unit.test_block\)",
+ ):
+ Block.register_private_data_initializer(init)
+
+ with self.assertRaisesRegex(
+ ValueError,
+ r"'private_data' scope must be substrings of the caller's "
+ r"module name. Received 'invalid' when calling "
+ r"register_private_data_initializer\(\).",
+ ):
+ Block.register_private_data_initializer(init, 'invalid')
+
+ self.assertEqual(len(pdi), 2)
+ finally:
+ Block._private_data_initializers = _save
+
if __name__ == "__main__":
unittest.main()
diff --git a/pyomo/core/tests/unit/test_compare.py b/pyomo/core/tests/unit/test_compare.py
index f80753bdb61..7c3536bc084 100644
--- a/pyomo/core/tests/unit/test_compare.py
+++ b/pyomo/core/tests/unit/test_compare.py
@@ -165,17 +165,11 @@ def test_expr_if(self):
0,
(EqualityExpression, 2),
(LinearExpression, 2),
- (MonomialTermExpression, 2),
- 1,
m.y,
- (MonomialTermExpression, 2),
- 1,
m.x,
0,
(EqualityExpression, 2),
(LinearExpression, 2),
- (MonomialTermExpression, 2),
- 1,
m.y,
(MonomialTermExpression, 2),
-1,
diff --git a/pyomo/core/tests/unit/test_component.py b/pyomo/core/tests/unit/test_component.py
index 175c4c47d46..b12db9af047 100644
--- a/pyomo/core/tests/unit/test_component.py
+++ b/pyomo/core/tests/unit/test_component.py
@@ -66,19 +66,17 @@ def test_getname(self):
)
m.b[2]._component = None
- self.assertEqual(
- m.b[2].getname(fully_qualified=True), "[Unattached _BlockData]"
- )
+ self.assertEqual(m.b[2].getname(fully_qualified=True), "[Unattached BlockData]")
# I think that getname() should do this:
# self.assertEqual(m.b[2].c[2,4].getname(fully_qualified=True),
- # "[Unattached _BlockData].c[2,4]")
+ # "[Unattached BlockData].c[2,4]")
# but it doesn't match current behavior. I will file a PEP to
# propose changing the behavior later and proceed to test
# current behavior.
self.assertEqual(m.b[2].c[2, 4].getname(fully_qualified=True), "c[2,4]")
self.assertEqual(
- m.b[2].getname(fully_qualified=False), "[Unattached _BlockData]"
+ m.b[2].getname(fully_qualified=False), "[Unattached BlockData]"
)
self.assertEqual(m.b[2].c[2, 4].getname(fully_qualified=False), "c[2,4]")
diff --git a/pyomo/core/tests/unit/test_con.py b/pyomo/core/tests/unit/test_con.py
index 6ed19c1bcfd..15f190e281e 100644
--- a/pyomo/core/tests/unit/test_con.py
+++ b/pyomo/core/tests/unit/test_con.py
@@ -44,7 +44,7 @@
InequalityExpression,
RangedExpression,
)
-from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.base.constraint import ConstraintData
class TestConstraintCreation(unittest.TestCase):
@@ -1074,7 +1074,7 @@ def test_setitem(self):
m.c[2] = m.x**2 <= 4
self.assertEqual(len(m.c), 1)
self.assertEqual(list(m.c.keys()), [2])
- self.assertIsInstance(m.c[2], _GeneralConstraintData)
+ self.assertIsInstance(m.c[2], ConstraintData)
self.assertEqual(m.c[2].upper, 4)
m.c[3] = Constraint.Skip
@@ -1388,7 +1388,7 @@ def test_empty_singleton(self):
# Even though we construct a ScalarConstraint,
# if it is not initialized that means it is "empty"
# and we should encounter errors when trying to access the
- # _ConstraintData interface methods until we assign
+ # ConstraintData interface methods until we assign
# something to the constraint.
#
self.assertEqual(a._constructed, True)
diff --git a/pyomo/core/tests/unit/test_dict_objects.py b/pyomo/core/tests/unit/test_dict_objects.py
index 8260f1ae320..ef9f330bfff 100644
--- a/pyomo/core/tests/unit/test_dict_objects.py
+++ b/pyomo/core/tests/unit/test_dict_objects.py
@@ -17,10 +17,10 @@
ObjectiveDict,
ExpressionDict,
)
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.objective import _GeneralObjectiveData
-from pyomo.core.base.expression import _GeneralExpressionData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.objective import ObjectiveData
+from pyomo.core.base.expression import ExpressionData
class _TestComponentDictBase(object):
@@ -348,10 +348,10 @@ def test_active(self):
class TestVarDict(_TestComponentDictBase, unittest.TestCase):
- # Note: the updated _GeneralVarData class only takes an optional
+ # Note: the updated VarData class only takes an optional
# parent argument (you no longer pass the domain in)
_ctype = VarDict
- _cdatatype = lambda self, arg: _GeneralVarData()
+ _cdatatype = lambda self, arg: VarData()
def setUp(self):
_TestComponentDictBase.setUp(self)
@@ -360,7 +360,7 @@ def setUp(self):
class TestExpressionDict(_TestComponentDictBase, unittest.TestCase):
_ctype = ExpressionDict
- _cdatatype = _GeneralExpressionData
+ _cdatatype = ExpressionData
def setUp(self):
_TestComponentDictBase.setUp(self)
@@ -375,7 +375,7 @@ def setUp(self):
class TestConstraintDict(_TestActiveComponentDictBase, unittest.TestCase):
_ctype = ConstraintDict
- _cdatatype = _GeneralConstraintData
+ _cdatatype = ConstraintData
def setUp(self):
_TestComponentDictBase.setUp(self)
@@ -384,7 +384,7 @@ def setUp(self):
class TestObjectiveDict(_TestActiveComponentDictBase, unittest.TestCase):
_ctype = ObjectiveDict
- _cdatatype = _GeneralObjectiveData
+ _cdatatype = ObjectiveData
def setUp(self):
_TestComponentDictBase.setUp(self)
diff --git a/pyomo/core/tests/unit/test_expression.py b/pyomo/core/tests/unit/test_expression.py
index c9afc6a1f76..eb16f7c6142 100644
--- a/pyomo/core/tests/unit/test_expression.py
+++ b/pyomo/core/tests/unit/test_expression.py
@@ -29,7 +29,7 @@
value,
sum_product,
)
-from pyomo.core.base.expression import _GeneralExpressionData
+from pyomo.core.base.expression import ExpressionData
from pyomo.core.expr.compare import compare_expressions, assertExpressionsEqual
from pyomo.common.tee import capture_output
@@ -515,10 +515,10 @@ def test_implicit_definition(self):
model.E = Expression(model.idx)
self.assertEqual(len(model.E), 3)
expr = model.E[1]
- self.assertIs(type(expr), _GeneralExpressionData)
+ self.assertIs(type(expr), ExpressionData)
model.E[1] = None
self.assertIs(expr, model.E[1])
- self.assertIs(type(expr), _GeneralExpressionData)
+ self.assertIs(type(expr), ExpressionData)
self.assertIs(expr.expr, None)
model.E[1] = 5
self.assertIs(expr, model.E[1])
@@ -537,7 +537,7 @@ def test_explicit_skip_definition(self):
model.E[1] = None
expr = model.E[1]
- self.assertIs(type(expr), _GeneralExpressionData)
+ self.assertIs(type(expr), ExpressionData)
self.assertIs(expr.expr, None)
model.E[1] = 5
self.assertIs(expr, model.E[1])
@@ -738,10 +738,10 @@ def test_pprint_oldStyle(self):
expr = model.e * model.x**2 + model.E[1]
output = """\
-sum(prod(e{sum(mon(1, x), 2)}, pow(x, 2)), E[1]{sum(pow(x, 2), 1)})
+sum(prod(e{sum(x, 2)}, pow(x, 2)), E[1]{sum(pow(x, 2), 1)})
e : Size=1, Index=None
Key : Expression
- None : sum(mon(1, x), 2)
+ None : sum(x, 2)
E : Size=2, Index={1, 2}
Key : Expression
1 : sum(pow(x, 2), 1)
@@ -951,12 +951,7 @@ def test_isub(self):
assertExpressionsEqual(
self,
m.e.expr,
- EXPR.LinearExpression(
- [
- EXPR.MonomialTermExpression((1, m.x)),
- EXPR.MonomialTermExpression((-1, m.y)),
- ]
- ),
+ EXPR.LinearExpression([m.x, EXPR.MonomialTermExpression((-1, m.y))]),
)
self.assertTrue(compare_expressions(m.e.expr, m.x - m.y))
diff --git a/pyomo/core/tests/unit/test_indexed_slice.py b/pyomo/core/tests/unit/test_indexed_slice.py
index babd3f3c46a..40aaad9fec9 100644
--- a/pyomo/core/tests/unit/test_indexed_slice.py
+++ b/pyomo/core/tests/unit/test_indexed_slice.py
@@ -17,7 +17,7 @@
import pyomo.common.unittest as unittest
from pyomo.environ import Var, Block, ConcreteModel, RangeSet, Set, Any
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.core.base.indexed_component_slice import IndexedComponent_slice
from pyomo.core.base.set import normalize_index
@@ -64,7 +64,7 @@ def tearDown(self):
self.m = None
def test_simple_getitem(self):
- self.assertIsInstance(self.m.b[1, 4], _BlockData)
+ self.assertIsInstance(self.m.b[1, 4], BlockData)
def test_simple_getslice(self):
_slicer = self.m.b[:, 4]
diff --git a/pyomo/core/tests/unit/test_list_objects.py b/pyomo/core/tests/unit/test_list_objects.py
index 3eb2e279964..671a8429e06 100644
--- a/pyomo/core/tests/unit/test_list_objects.py
+++ b/pyomo/core/tests/unit/test_list_objects.py
@@ -17,10 +17,10 @@
XObjectiveList,
XExpressionList,
)
-from pyomo.core.base.var import _GeneralVarData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.objective import _GeneralObjectiveData
-from pyomo.core.base.expression import _GeneralExpressionData
+from pyomo.core.base.var import VarData
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.objective import ObjectiveData
+from pyomo.core.base.expression import ExpressionData
class _TestComponentListBase(object):
@@ -365,10 +365,10 @@ def test_active(self):
class TestVarList(_TestComponentListBase, unittest.TestCase):
- # Note: the updated _GeneralVarData class only takes an optional
+ # Note: the updated VarData class only takes an optional
# parent argument (you no longer pass the domain in)
_ctype = XVarList
- _cdatatype = lambda self, arg: _GeneralVarData()
+ _cdatatype = lambda self, arg: VarData()
def setUp(self):
_TestComponentListBase.setUp(self)
@@ -377,7 +377,7 @@ def setUp(self):
class TestExpressionList(_TestComponentListBase, unittest.TestCase):
_ctype = XExpressionList
- _cdatatype = _GeneralExpressionData
+ _cdatatype = ExpressionData
def setUp(self):
_TestComponentListBase.setUp(self)
@@ -392,7 +392,7 @@ def setUp(self):
class TestConstraintList(_TestActiveComponentListBase, unittest.TestCase):
_ctype = XConstraintList
- _cdatatype = _GeneralConstraintData
+ _cdatatype = ConstraintData
def setUp(self):
_TestComponentListBase.setUp(self)
@@ -401,7 +401,7 @@ def setUp(self):
class TestObjectiveList(_TestActiveComponentListBase, unittest.TestCase):
_ctype = XObjectiveList
- _cdatatype = _GeneralObjectiveData
+ _cdatatype = ObjectiveData
def setUp(self):
_TestComponentListBase.setUp(self)
diff --git a/pyomo/core/tests/unit/test_numeric_expr.py b/pyomo/core/tests/unit/test_numeric_expr.py
index c073ee0f726..efb01e6d6ce 100644
--- a/pyomo/core/tests/unit/test_numeric_expr.py
+++ b/pyomo/core/tests/unit/test_numeric_expr.py
@@ -112,7 +112,7 @@
from pyomo.core.base.label import NumericLabeler
from pyomo.core.expr.template_expr import IndexTemplate
from pyomo.core.expr import expr_common
-from pyomo.core.base.var import _GeneralVarData
+from pyomo.core.base.var import VarData
from pyomo.repn import generate_standard_repn
from pyomo.core.expr.numvalue import NumericValue
@@ -294,7 +294,7 @@ def value_check(self, exp, val):
class TestExpression_EvaluateVarData(TestExpression_EvaluateNumericValue):
def create(self, val, domain):
- tmp = _GeneralVarData()
+ tmp = VarData()
tmp.domain = domain
tmp.value = val
return tmp
@@ -638,12 +638,7 @@ def test_simpleSum(self):
m.b = Var()
e = m.a + m.b
#
- self.assertExpressionsEqual(
- e,
- LinearExpression(
- [MonomialTermExpression((1, m.a)), MonomialTermExpression((1, m.b))]
- ),
- )
+ self.assertExpressionsEqual(e, LinearExpression([m.a, m.b]))
self.assertRaises(KeyError, e.arg, 3)
@@ -654,14 +649,7 @@ def test_simpleSum_API(self):
e = m.a + m.b
e += 2 * m.a
self.assertExpressionsEqual(
- e,
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((2, m.a)),
- ]
- ),
+ e, LinearExpression([m.a, m.b, MonomialTermExpression((2, m.a))])
)
def test_constSum(self):
@@ -669,13 +657,9 @@ def test_constSum(self):
m = AbstractModel()
m.a = Var()
#
- self.assertExpressionsEqual(
- m.a + 5, LinearExpression([MonomialTermExpression((1, m.a)), 5])
- )
+ self.assertExpressionsEqual(m.a + 5, LinearExpression([m.a, 5]))
- self.assertExpressionsEqual(
- 5 + m.a, LinearExpression([5, MonomialTermExpression((1, m.a))])
- )
+ self.assertExpressionsEqual(5 + m.a, LinearExpression([5, m.a]))
def test_nestedSum(self):
#
@@ -696,12 +680,7 @@ def test_nestedSum(self):
# a b
e1 = m.a + m.b
e = e1 + 5
- self.assertExpressionsEqual(
- e,
- LinearExpression(
- [MonomialTermExpression((1, m.a)), MonomialTermExpression((1, m.b)), 5]
- ),
- )
+ self.assertExpressionsEqual(e, LinearExpression([m.a, m.b, 5]))
# +
# / \
@@ -710,12 +689,7 @@ def test_nestedSum(self):
# a b
e1 = m.a + m.b
e = 5 + e1
- self.assertExpressionsEqual(
- e,
- LinearExpression(
- [MonomialTermExpression((1, m.a)), MonomialTermExpression((1, m.b)), 5]
- ),
- )
+ self.assertExpressionsEqual(e, LinearExpression([m.a, m.b, 5]))
# +
# / \
@@ -724,16 +698,7 @@ def test_nestedSum(self):
# a b
e1 = m.a + m.b
e = e1 + m.c
- self.assertExpressionsEqual(
- e,
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((1, m.c)),
- ]
- ),
- )
+ self.assertExpressionsEqual(e, LinearExpression([m.a, m.b, m.c]))
# +
# / \
@@ -742,16 +707,7 @@ def test_nestedSum(self):
# a b
e1 = m.a + m.b
e = m.c + e1
- self.assertExpressionsEqual(
- e,
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((1, m.c)),
- ]
- ),
- )
+ self.assertExpressionsEqual(e, LinearExpression([m.a, m.b, m.c]))
# +
# / \
@@ -762,17 +718,7 @@ def test_nestedSum(self):
e2 = m.c + m.d
e = e1 + e2
#
- self.assertExpressionsEqual(
- e,
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((1, m.c)),
- MonomialTermExpression((1, m.d)),
- ]
- ),
- )
+ self.assertExpressionsEqual(e, LinearExpression([m.a, m.b, m.c, m.d]))
def test_nestedSum2(self):
#
@@ -798,22 +744,7 @@ def test_nestedSum2(self):
self.assertExpressionsEqual(
e,
- SumExpression(
- [
- ProductExpression(
- (
- 2,
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((1, m.b)),
- ]
- ),
- )
- ),
- m.c,
- ]
- ),
+ SumExpression([ProductExpression((2, LinearExpression([m.a, m.b]))), m.c]),
)
# *
@@ -834,20 +765,7 @@ def test_nestedSum2(self):
(
3,
SumExpression(
- [
- ProductExpression(
- (
- 2,
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((1, m.b)),
- ]
- ),
- )
- ),
- m.c,
- ]
+ [ProductExpression((2, LinearExpression([m.a, m.b]))), m.c]
),
)
),
@@ -891,10 +809,7 @@ def test_sumOf_nestedTrivialProduct(self):
e = e1 + m.b
#
self.assertExpressionsEqual(
- e,
- LinearExpression(
- [MonomialTermExpression((5, m.a)), MonomialTermExpression((1, m.b))]
- ),
+ e, LinearExpression([MonomialTermExpression((5, m.a)), m.b])
)
# +
@@ -905,10 +820,7 @@ def test_sumOf_nestedTrivialProduct(self):
e = m.b + e1
#
self.assertExpressionsEqual(
- e,
- LinearExpression(
- [MonomialTermExpression((1, m.b)), MonomialTermExpression((5, m.a))]
- ),
+ e, LinearExpression([m.b, MonomialTermExpression((5, m.a))])
)
# +
@@ -920,14 +832,7 @@ def test_sumOf_nestedTrivialProduct(self):
e = e1 + e2
#
self.assertExpressionsEqual(
- e,
- LinearExpression(
- [
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((1, m.c)),
- MonomialTermExpression((5, m.a)),
- ]
- ),
+ e, LinearExpression([m.b, m.c, MonomialTermExpression((5, m.a))])
)
# +
@@ -939,14 +844,7 @@ def test_sumOf_nestedTrivialProduct(self):
e = e2 + e1
#
self.assertExpressionsEqual(
- e,
- LinearExpression(
- [
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((1, m.c)),
- MonomialTermExpression((5, m.a)),
- ]
- ),
+ e, LinearExpression([m.b, m.c, MonomialTermExpression((5, m.a))])
)
def test_simpleDiff(self):
@@ -962,10 +860,7 @@ def test_simpleDiff(self):
# a b
e = m.a - m.b
self.assertExpressionsEqual(
- e,
- LinearExpression(
- [MonomialTermExpression((1, m.a)), MonomialTermExpression((-1, m.b))]
- ),
+ e, LinearExpression([m.a, MonomialTermExpression((-1, m.b))])
)
def test_constDiff(self):
@@ -978,9 +873,7 @@ def test_constDiff(self):
# -
# / \
# a 5
- self.assertExpressionsEqual(
- m.a - 5, LinearExpression([MonomialTermExpression((1, m.a)), -5])
- )
+ self.assertExpressionsEqual(m.a - 5, LinearExpression([m.a, -5]))
# -
# / \
@@ -1002,10 +895,7 @@ def test_paramDiff(self):
# a p
e = m.a - m.p
self.assertExpressionsEqual(
- e,
- LinearExpression(
- [MonomialTermExpression((1, m.a)), NPV_NegationExpression((m.p,))]
- ),
+ e, LinearExpression([m.a, NPV_NegationExpression((m.p,))])
)
# -
@@ -1079,14 +969,7 @@ def test_nestedDiff(self):
e1 = m.a - m.b
e = e1 - 5
self.assertExpressionsEqual(
- e,
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((-1, m.b)),
- -5,
- ]
- ),
+ e, LinearExpression([m.a, MonomialTermExpression((-1, m.b)), -5])
)
# -
@@ -1102,14 +985,7 @@ def test_nestedDiff(self):
[
5,
NegationExpression(
- (
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((-1, m.b)),
- ]
- ),
- )
+ (LinearExpression([m.a, MonomialTermExpression((-1, m.b))]),)
),
]
),
@@ -1126,7 +1002,7 @@ def test_nestedDiff(self):
e,
LinearExpression(
[
- MonomialTermExpression((1, m.a)),
+ m.a,
MonomialTermExpression((-1, m.b)),
MonomialTermExpression((-1, m.c)),
]
@@ -1146,14 +1022,7 @@ def test_nestedDiff(self):
[
m.c,
NegationExpression(
- (
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((-1, m.b)),
- ]
- ),
- )
+ (LinearExpression([m.a, MonomialTermExpression((-1, m.b))]),)
),
]
),
@@ -1171,21 +1040,9 @@ def test_nestedDiff(self):
e,
SumExpression(
[
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((-1, m.b)),
- ]
- ),
+ LinearExpression([m.a, MonomialTermExpression((-1, m.b))]),
NegationExpression(
- (
- LinearExpression(
- [
- MonomialTermExpression((1, m.c)),
- MonomialTermExpression((-1, m.d)),
- ]
- ),
- )
+ (LinearExpression([m.c, MonomialTermExpression((-1, m.d))]),)
),
]
),
@@ -1382,10 +1239,7 @@ def test_sumOf_nestedTrivialProduct2(self):
self.assertExpressionsEqual(
e,
LinearExpression(
- [
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((NPV_NegationExpression((m.p,)), m.a)),
- ]
+ [m.b, MonomialTermExpression((NPV_NegationExpression((m.p,)), m.a))]
),
)
@@ -1403,14 +1257,7 @@ def test_sumOf_nestedTrivialProduct2(self):
[
MonomialTermExpression((m.p, m.a)),
NegationExpression(
- (
- LinearExpression(
- [
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((-1, m.c)),
- ]
- ),
- )
+ (LinearExpression([m.b, MonomialTermExpression((-1, m.c))]),)
),
]
),
@@ -1424,12 +1271,11 @@ def test_sumOf_nestedTrivialProduct2(self):
e1 = m.a * m.p
e2 = m.b - m.c
e = e2 - e1
- self.maxDiff = None
self.assertExpressionsEqual(
e,
LinearExpression(
[
- MonomialTermExpression((1, m.b)),
+ m.b,
MonomialTermExpression((-1, m.c)),
MonomialTermExpression((NPV_NegationExpression((m.p,)), m.a)),
]
@@ -1599,22 +1445,7 @@ def test_nestedProduct2(self):
self.assertExpressionsEqual(
e,
ProductExpression(
- (
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((1, m.c)),
- ]
- ),
- LinearExpression(
- [
- MonomialTermExpression((1, m.a)),
- MonomialTermExpression((1, m.b)),
- MonomialTermExpression((1, m.d)),
- ]
- ),
- )
+ (LinearExpression([m.a, m.b, m.c]), LinearExpression([m.a, m.b, m.d]))
),
)
# Verify shared args...
@@ -1639,9 +1470,7 @@ def test_nestedProduct2(self):
e3 = e1 * m.d
e = e2 * e3
#
- inner = LinearExpression(
- [MonomialTermExpression((1, m.a)), MonomialTermExpression((1, m.b))]
- )
+ inner = LinearExpression([m.a, m.b])
self.assertExpressionsEqual(
e,
ProductExpression(
@@ -2035,10 +1864,10 @@ def test_sum(self):
model.p = Param(mutable=True)
expr = 5 + model.a + model.a
- self.assertEqual("sum(5, mon(1, a), mon(1, a))", str(expr))
+ self.assertEqual("sum(5, a, a)", str(expr))
expr += 5
- self.assertEqual("sum(5, mon(1, a), mon(1, a), 5)", str(expr))
+ self.assertEqual("sum(5, a, a, 5)", str(expr))
expr = 2 + model.p
self.assertEqual("sum(2, p)", str(expr))
@@ -2054,24 +1883,18 @@ def test_linearsum(self):
expr = quicksum(i * model.a[i] for i in A)
self.assertEqual(
- "sum(mon(0, a[0]), mon(1, a[1]), mon(2, a[2]), mon(3, a[3]), "
- "mon(4, a[4]))",
+ "sum(mon(0, a[0]), a[1], mon(2, a[2]), mon(3, a[3]), " "mon(4, a[4]))",
str(expr),
)
expr = quicksum((i - 2) * model.a[i] for i in A)
self.assertEqual(
- "sum(mon(-2, a[0]), mon(-1, a[1]), mon(0, a[2]), mon(1, a[3]), "
- "mon(2, a[4]))",
+ "sum(mon(-2, a[0]), mon(-1, a[1]), mon(0, a[2]), a[3], " "mon(2, a[4]))",
str(expr),
)
expr = quicksum(model.a[i] for i in A)
- self.assertEqual(
- "sum(mon(1, a[0]), mon(1, a[1]), mon(1, a[2]), mon(1, a[3]), "
- "mon(1, a[4]))",
- str(expr),
- )
+ self.assertEqual("sum(a[0], a[1], a[2], a[3], a[4])", str(expr))
model.p[1].value = 0
model.p[3].value = 3
@@ -2139,10 +1962,10 @@ def test_inequality(self):
self.assertEqual("5 <= a < 10", str(expr))
expr = 5 <= model.a + 5
- self.assertEqual("5 <= sum(mon(1, a), 5)", str(expr))
+ self.assertEqual("5 <= sum(a, 5)", str(expr))
expr = expr < 10
- self.assertEqual("5 <= sum(mon(1, a), 5) < 10", str(expr))
+ self.assertEqual("5 <= sum(a, 5) < 10", str(expr))
def test_equality(self):
#
@@ -2167,10 +1990,10 @@ def test_equality(self):
self.assertEqual("a == 10", str(expr))
expr = 5 == model.a + 5
- self.assertEqual("sum(mon(1, a), 5) == 5", str(expr))
+ self.assertEqual("sum(a, 5) == 5", str(expr))
expr = model.a + 5 == 5
- self.assertEqual("sum(mon(1, a), 5) == 5", str(expr))
+ self.assertEqual("sum(a, 5) == 5", str(expr))
def test_getitem(self):
m = ConcreteModel()
@@ -2207,7 +2030,7 @@ def test_small_expression(self):
expr = abs(expr)
self.assertEqual(
"abs(neg(pow(2, div(2, prod(2, sum(1, neg(pow(div(prod(sum("
- "mon(1, a), 1, -1), a), a), b)), 1))))))",
+ "a, 1, -1), a), a), b)), 1))))))",
str(expr),
)
@@ -3755,13 +3578,7 @@ def test_summation1(self):
self.assertExpressionsEqual(
e,
LinearExpression(
- [
- MonomialTermExpression((1, self.m.a[1])),
- MonomialTermExpression((1, self.m.a[2])),
- MonomialTermExpression((1, self.m.a[3])),
- MonomialTermExpression((1, self.m.a[4])),
- MonomialTermExpression((1, self.m.a[5])),
- ]
+ [self.m.a[1], self.m.a[2], self.m.a[3], self.m.a[4], self.m.a[5]]
),
)
@@ -3873,16 +3690,16 @@ def test_summation_compression(self):
e,
LinearExpression(
[
- MonomialTermExpression((1, self.m.a[1])),
- MonomialTermExpression((1, self.m.a[2])),
- MonomialTermExpression((1, self.m.a[3])),
- MonomialTermExpression((1, self.m.a[4])),
- MonomialTermExpression((1, self.m.a[5])),
- MonomialTermExpression((1, self.m.b[1])),
- MonomialTermExpression((1, self.m.b[2])),
- MonomialTermExpression((1, self.m.b[3])),
- MonomialTermExpression((1, self.m.b[4])),
- MonomialTermExpression((1, self.m.b[5])),
+ self.m.a[1],
+ self.m.a[2],
+ self.m.a[3],
+ self.m.a[4],
+ self.m.a[5],
+ self.m.b[1],
+ self.m.b[2],
+ self.m.b[3],
+ self.m.b[4],
+ self.m.b[5],
]
),
)
@@ -3913,13 +3730,7 @@ def test_deprecation(self):
self.assertExpressionsEqual(
e,
LinearExpression(
- [
- MonomialTermExpression((1, self.m.a[1])),
- MonomialTermExpression((1, self.m.a[2])),
- MonomialTermExpression((1, self.m.a[3])),
- MonomialTermExpression((1, self.m.a[4])),
- MonomialTermExpression((1, self.m.a[5])),
- ]
+ [self.m.a[1], self.m.a[2], self.m.a[3], self.m.a[4], self.m.a[5]]
),
)
@@ -3929,13 +3740,7 @@ def test_summation1(self):
self.assertExpressionsEqual(
e,
LinearExpression(
- [
- MonomialTermExpression((1, self.m.a[1])),
- MonomialTermExpression((1, self.m.a[2])),
- MonomialTermExpression((1, self.m.a[3])),
- MonomialTermExpression((1, self.m.a[4])),
- MonomialTermExpression((1, self.m.a[5])),
- ]
+ [self.m.a[1], self.m.a[2], self.m.a[3], self.m.a[4], self.m.a[5]]
),
)
@@ -4157,15 +3962,15 @@ def test_SumExpression(self):
self.assertEqual(expr2(), 15)
self.assertNotEqual(id(expr1), id(expr2))
self.assertNotEqual(id(expr1._args_), id(expr2._args_))
- self.assertIs(expr1.arg(0).arg(1), expr2.arg(0).arg(1))
- self.assertIs(expr1.arg(1).arg(1), expr2.arg(1).arg(1))
+ self.assertIs(expr1.arg(0), expr2.arg(0))
+ self.assertIs(expr1.arg(1), expr2.arg(1))
expr1 += self.m.b
self.assertEqual(expr1(), 25)
self.assertEqual(expr2(), 15)
self.assertNotEqual(id(expr1), id(expr2))
self.assertNotEqual(id(expr1._args_), id(expr2._args_))
- self.assertIs(expr1.arg(0).arg(1), expr2.arg(0).arg(1))
- self.assertIs(expr1.arg(1).arg(1), expr2.arg(1).arg(1))
+ self.assertIs(expr1.arg(0), expr2.arg(0))
+ self.assertIs(expr1.arg(1), expr2.arg(1))
#
total = counter.count - start
self.assertEqual(total, 1)
@@ -4342,9 +4147,9 @@ def test_productOfExpressions(self):
self.assertEqual(expr1.arg(1).nargs(), 2)
self.assertEqual(expr2.arg(1).nargs(), 2)
- self.assertIs(expr1.arg(0).arg(0).arg(1), expr2.arg(0).arg(0).arg(1))
- self.assertIs(expr1.arg(0).arg(1).arg(1), expr2.arg(0).arg(1).arg(1))
- self.assertIs(expr1.arg(1).arg(0).arg(1), expr2.arg(1).arg(0).arg(1))
+ self.assertIs(expr1.arg(0).arg(0), expr2.arg(0).arg(0))
+ self.assertIs(expr1.arg(0).arg(1), expr2.arg(0).arg(1))
+ self.assertIs(expr1.arg(1).arg(0), expr2.arg(1).arg(0))
expr1 *= self.m.b
self.assertEqual(expr1(), 1500)
@@ -4383,8 +4188,8 @@ def test_productOfExpressions_div(self):
self.assertEqual(expr1.arg(1).nargs(), 2)
self.assertEqual(expr2.arg(1).nargs(), 2)
- self.assertIs(expr1.arg(0).arg(0).arg(1), expr2.arg(0).arg(0).arg(1))
- self.assertIs(expr1.arg(0).arg(1).arg(1), expr2.arg(0).arg(1).arg(1))
+ self.assertIs(expr1.arg(0).arg(0), expr2.arg(0).arg(0))
+ self.assertIs(expr1.arg(0).arg(1), expr2.arg(0).arg(1))
expr1 /= self.m.b
self.assertAlmostEqual(expr1(), 0.15)
@@ -5215,18 +5020,7 @@ def test_pow_other(self):
e += m.v[0] + m.v[1]
e = m.v[0] ** e
self.assertExpressionsEqual(
- e,
- PowExpression(
- (
- m.v[0],
- LinearExpression(
- [
- MonomialTermExpression((1, m.v[0])),
- MonomialTermExpression((1, m.v[1])),
- ]
- ),
- )
- ),
+ e, PowExpression((m.v[0], LinearExpression([m.v[0], m.v[1]])))
)
diff --git a/pyomo/core/tests/unit/test_numeric_expr_api.py b/pyomo/core/tests/unit/test_numeric_expr_api.py
index 4e0af126315..923f78af1be 100644
--- a/pyomo/core/tests/unit/test_numeric_expr_api.py
+++ b/pyomo/core/tests/unit/test_numeric_expr_api.py
@@ -223,7 +223,7 @@ def test_negation(self):
self.assertEqual(is_fixed(e), False)
self.assertEqual(value(e), -15)
self.assertEqual(str(e), "- (x + 2*x)")
- self.assertEqual(e.to_string(verbose=True), "neg(sum(mon(1, x), mon(2, x)))")
+ self.assertEqual(e.to_string(verbose=True), "neg(sum(x, mon(2, x)))")
# This can't occur through operator overloading, but could
# through expression substitution
@@ -634,8 +634,7 @@ def test_linear(self):
self.assertEqual(value(e), 1 + 4 + 5 + 2)
self.assertEqual(str(e), "0*x[0] + x[1] + 2*x[2] + 5 + y - 3")
self.assertEqual(
- e.to_string(verbose=True),
- "sum(mon(0, x[0]), mon(1, x[1]), mon(2, x[2]), 5, mon(1, y), -3)",
+ e.to_string(verbose=True), "sum(mon(0, x[0]), x[1], mon(2, x[2]), 5, y, -3)"
)
self.assertIs(type(e), LinearExpression)
@@ -701,7 +700,7 @@ def test_expr_if(self):
)
self.assertEqual(
e.to_string(verbose=True),
- "Expr_if( ( 5 <= y ), then=( sum(mon(1, x[0]), 5) ), else=( pow(x[1], 2) ) )",
+ "Expr_if( ( 5 <= y ), then=( sum(x[0], 5) ), else=( pow(x[1], 2) ) )",
)
m.y.fix()
@@ -972,9 +971,7 @@ def test_sum(self):
f = e.create_node_with_local_data((m.p, m.x))
self.assertIsNot(f, e)
self.assertIs(type(f), LinearExpression)
- assertExpressionsStructurallyEqual(
- self, f.args, [m.p, MonomialTermExpression((1, m.x))]
- )
+ assertExpressionsStructurallyEqual(self, f.args, [m.p, m.x])
f = e.create_node_with_local_data((m.p, m.x**2))
self.assertIsNot(f, e)
diff --git a/pyomo/core/tests/unit/test_numeric_expr_dispatcher.py b/pyomo/core/tests/unit/test_numeric_expr_dispatcher.py
index 3787f00de47..bb7a291e67d 100644
--- a/pyomo/core/tests/unit/test_numeric_expr_dispatcher.py
+++ b/pyomo/core/tests/unit/test_numeric_expr_dispatcher.py
@@ -123,8 +123,6 @@ def setUp(self):
self.mutable_l3 = _MutableNPVSumExpression([self.npv])
# often repeated reference expressions
- self.mon_bin = MonomialTermExpression((1, self.bin))
- self.mon_var = MonomialTermExpression((1, self.var))
self.minus_bin = MonomialTermExpression((-1, self.bin))
self.minus_npv = NPV_NegationExpression((self.npv,))
self.minus_param_mut = NPV_NegationExpression((self.param_mut,))
@@ -368,38 +366,34 @@ def test_add_asbinary(self):
# BooleanVar objects do not support addition
(self.asbinary, self.asbinary, NotImplemented),
(self.asbinary, self.zero, self.bin),
- (self.asbinary, self.one, LinearExpression([self.mon_bin, 1])),
+ (self.asbinary, self.one, LinearExpression([self.bin, 1])),
# 4:
- (self.asbinary, self.native, LinearExpression([self.mon_bin, 5])),
- (self.asbinary, self.npv, LinearExpression([self.mon_bin, self.npv])),
- (self.asbinary, self.param, LinearExpression([self.mon_bin, 6])),
+ (self.asbinary, self.native, LinearExpression([self.bin, 5])),
+ (self.asbinary, self.npv, LinearExpression([self.bin, self.npv])),
+ (self.asbinary, self.param, LinearExpression([self.bin, 6])),
(
self.asbinary,
self.param_mut,
- LinearExpression([self.mon_bin, self.param_mut]),
+ LinearExpression([self.bin, self.param_mut]),
),
# 8:
- (self.asbinary, self.var, LinearExpression([self.mon_bin, self.mon_var])),
+ (self.asbinary, self.var, LinearExpression([self.bin, self.var])),
(
self.asbinary,
self.mon_native,
- LinearExpression([self.mon_bin, self.mon_native]),
+ LinearExpression([self.bin, self.mon_native]),
),
(
self.asbinary,
self.mon_param,
- LinearExpression([self.mon_bin, self.mon_param]),
- ),
- (
- self.asbinary,
- self.mon_npv,
- LinearExpression([self.mon_bin, self.mon_npv]),
+ LinearExpression([self.bin, self.mon_param]),
),
+ (self.asbinary, self.mon_npv, LinearExpression([self.bin, self.mon_npv])),
# 12:
(
self.asbinary,
self.linear,
- LinearExpression(self.linear.args + [self.mon_bin]),
+ LinearExpression(self.linear.args + [self.bin]),
),
(self.asbinary, self.sum, SumExpression(self.sum.args + [self.bin])),
(self.asbinary, self.other, SumExpression([self.bin, self.other])),
@@ -408,7 +402,7 @@ def test_add_asbinary(self):
(
self.asbinary,
self.mutable_l1,
- LinearExpression([self.mon_bin, self.mon_npv]),
+ LinearExpression([self.bin, self.mon_npv]),
),
(
self.asbinary,
@@ -416,13 +410,9 @@ def test_add_asbinary(self):
SumExpression(self.mutable_l2.args + [self.bin]),
),
(self.asbinary, self.param0, self.bin),
- (self.asbinary, self.param1, LinearExpression([self.mon_bin, 1])),
+ (self.asbinary, self.param1, LinearExpression([self.bin, 1])),
# 20:
- (
- self.asbinary,
- self.mutable_l3,
- LinearExpression([self.mon_bin, self.npv]),
- ),
+ (self.asbinary, self.mutable_l3, LinearExpression([self.bin, self.npv])),
]
self._run_cases(tests, operator.add)
self._run_cases(tests, operator.iadd)
@@ -462,7 +452,7 @@ def test_add_zero(self):
def test_add_one(self):
tests = [
(self.one, self.invalid, NotImplemented),
- (self.one, self.asbinary, LinearExpression([1, self.mon_bin])),
+ (self.one, self.asbinary, LinearExpression([1, self.bin])),
(self.one, self.zero, 1),
(self.one, self.one, 2),
# 4:
@@ -471,7 +461,7 @@ def test_add_one(self):
(self.one, self.param, 7),
(self.one, self.param_mut, NPV_SumExpression([1, self.param_mut])),
# 8:
- (self.one, self.var, LinearExpression([1, self.mon_var])),
+ (self.one, self.var, LinearExpression([1, self.var])),
(self.one, self.mon_native, LinearExpression([1, self.mon_native])),
(self.one, self.mon_param, LinearExpression([1, self.mon_param])),
(self.one, self.mon_npv, LinearExpression([1, self.mon_npv])),
@@ -494,7 +484,7 @@ def test_add_one(self):
def test_add_native(self):
tests = [
(self.native, self.invalid, NotImplemented),
- (self.native, self.asbinary, LinearExpression([5, self.mon_bin])),
+ (self.native, self.asbinary, LinearExpression([5, self.bin])),
(self.native, self.zero, 5),
(self.native, self.one, 6),
# 4:
@@ -503,7 +493,7 @@ def test_add_native(self):
(self.native, self.param, 11),
(self.native, self.param_mut, NPV_SumExpression([5, self.param_mut])),
# 8:
- (self.native, self.var, LinearExpression([5, self.mon_var])),
+ (self.native, self.var, LinearExpression([5, self.var])),
(self.native, self.mon_native, LinearExpression([5, self.mon_native])),
(self.native, self.mon_param, LinearExpression([5, self.mon_param])),
(self.native, self.mon_npv, LinearExpression([5, self.mon_npv])),
@@ -530,7 +520,7 @@ def test_add_native(self):
def test_add_npv(self):
tests = [
(self.npv, self.invalid, NotImplemented),
- (self.npv, self.asbinary, LinearExpression([self.npv, self.mon_bin])),
+ (self.npv, self.asbinary, LinearExpression([self.npv, self.bin])),
(self.npv, self.zero, self.npv),
(self.npv, self.one, NPV_SumExpression([self.npv, 1])),
# 4:
@@ -539,7 +529,7 @@ def test_add_npv(self):
(self.npv, self.param, NPV_SumExpression([self.npv, 6])),
(self.npv, self.param_mut, NPV_SumExpression([self.npv, self.param_mut])),
# 8:
- (self.npv, self.var, LinearExpression([self.npv, self.mon_var])),
+ (self.npv, self.var, LinearExpression([self.npv, self.var])),
(self.npv, self.mon_native, LinearExpression([self.npv, self.mon_native])),
(self.npv, self.mon_param, LinearExpression([self.npv, self.mon_param])),
(self.npv, self.mon_npv, LinearExpression([self.npv, self.mon_npv])),
@@ -570,7 +560,7 @@ def test_add_npv(self):
def test_add_param(self):
tests = [
(self.param, self.invalid, NotImplemented),
- (self.param, self.asbinary, LinearExpression([6, self.mon_bin])),
+ (self.param, self.asbinary, LinearExpression([6, self.bin])),
(self.param, self.zero, 6),
(self.param, self.one, 7),
# 4:
@@ -579,7 +569,7 @@ def test_add_param(self):
(self.param, self.param, 12),
(self.param, self.param_mut, NPV_SumExpression([6, self.param_mut])),
# 8:
- (self.param, self.var, LinearExpression([6, self.mon_var])),
+ (self.param, self.var, LinearExpression([6, self.var])),
(self.param, self.mon_native, LinearExpression([6, self.mon_native])),
(self.param, self.mon_param, LinearExpression([6, self.mon_param])),
(self.param, self.mon_npv, LinearExpression([6, self.mon_npv])),
@@ -605,7 +595,7 @@ def test_add_param_mut(self):
(
self.param_mut,
self.asbinary,
- LinearExpression([self.param_mut, self.mon_bin]),
+ LinearExpression([self.param_mut, self.bin]),
),
(self.param_mut, self.zero, self.param_mut),
(self.param_mut, self.one, NPV_SumExpression([self.param_mut, 1])),
@@ -619,11 +609,7 @@ def test_add_param_mut(self):
NPV_SumExpression([self.param_mut, self.param_mut]),
),
# 8:
- (
- self.param_mut,
- self.var,
- LinearExpression([self.param_mut, self.mon_var]),
- ),
+ (self.param_mut, self.var, LinearExpression([self.param_mut, self.var])),
(
self.param_mut,
self.mon_native,
@@ -674,37 +660,21 @@ def test_add_param_mut(self):
def test_add_var(self):
tests = [
(self.var, self.invalid, NotImplemented),
- (self.var, self.asbinary, LinearExpression([self.mon_var, self.mon_bin])),
+ (self.var, self.asbinary, LinearExpression([self.var, self.bin])),
(self.var, self.zero, self.var),
- (self.var, self.one, LinearExpression([self.mon_var, 1])),
+ (self.var, self.one, LinearExpression([self.var, 1])),
# 4:
- (self.var, self.native, LinearExpression([self.mon_var, 5])),
- (self.var, self.npv, LinearExpression([self.mon_var, self.npv])),
- (self.var, self.param, LinearExpression([self.mon_var, 6])),
- (
- self.var,
- self.param_mut,
- LinearExpression([self.mon_var, self.param_mut]),
- ),
+ (self.var, self.native, LinearExpression([self.var, 5])),
+ (self.var, self.npv, LinearExpression([self.var, self.npv])),
+ (self.var, self.param, LinearExpression([self.var, 6])),
+ (self.var, self.param_mut, LinearExpression([self.var, self.param_mut])),
# 8:
- (self.var, self.var, LinearExpression([self.mon_var, self.mon_var])),
- (
- self.var,
- self.mon_native,
- LinearExpression([self.mon_var, self.mon_native]),
- ),
- (
- self.var,
- self.mon_param,
- LinearExpression([self.mon_var, self.mon_param]),
- ),
- (self.var, self.mon_npv, LinearExpression([self.mon_var, self.mon_npv])),
+ (self.var, self.var, LinearExpression([self.var, self.var])),
+ (self.var, self.mon_native, LinearExpression([self.var, self.mon_native])),
+ (self.var, self.mon_param, LinearExpression([self.var, self.mon_param])),
+ (self.var, self.mon_npv, LinearExpression([self.var, self.mon_npv])),
# 12:
- (
- self.var,
- self.linear,
- LinearExpression(self.linear.args + [self.mon_var]),
- ),
+ (self.var, self.linear, LinearExpression(self.linear.args + [self.var])),
(self.var, self.sum, SumExpression(self.sum.args + [self.var])),
(self.var, self.other, SumExpression([self.var, self.other])),
(self.var, self.mutable_l0, self.var),
@@ -712,7 +682,7 @@ def test_add_var(self):
(
self.var,
self.mutable_l1,
- LinearExpression([self.mon_var] + self.mutable_l1.args),
+ LinearExpression([self.var] + self.mutable_l1.args),
),
(
self.var,
@@ -720,13 +690,9 @@ def test_add_var(self):
SumExpression(self.mutable_l2.args + [self.var]),
),
(self.var, self.param0, self.var),
- (self.var, self.param1, LinearExpression([self.mon_var, 1])),
+ (self.var, self.param1, LinearExpression([self.var, 1])),
# 20:
- (
- self.var,
- self.mutable_l3,
- LinearExpression([MonomialTermExpression((1, self.var)), self.npv]),
- ),
+ (self.var, self.mutable_l3, LinearExpression([self.var, self.npv])),
]
self._run_cases(tests, operator.add)
self._run_cases(tests, operator.iadd)
@@ -737,7 +703,7 @@ def test_add_mon_native(self):
(
self.mon_native,
self.asbinary,
- LinearExpression([self.mon_native, self.mon_bin]),
+ LinearExpression([self.mon_native, self.bin]),
),
(self.mon_native, self.zero, self.mon_native),
(self.mon_native, self.one, LinearExpression([self.mon_native, 1])),
@@ -751,11 +717,7 @@ def test_add_mon_native(self):
LinearExpression([self.mon_native, self.param_mut]),
),
# 8:
- (
- self.mon_native,
- self.var,
- LinearExpression([self.mon_native, self.mon_var]),
- ),
+ (self.mon_native, self.var, LinearExpression([self.mon_native, self.var])),
(
self.mon_native,
self.mon_native,
@@ -813,7 +775,7 @@ def test_add_mon_param(self):
(
self.mon_param,
self.asbinary,
- LinearExpression([self.mon_param, self.mon_bin]),
+ LinearExpression([self.mon_param, self.bin]),
),
(self.mon_param, self.zero, self.mon_param),
(self.mon_param, self.one, LinearExpression([self.mon_param, 1])),
@@ -827,11 +789,7 @@ def test_add_mon_param(self):
LinearExpression([self.mon_param, self.param_mut]),
),
# 8:
- (
- self.mon_param,
- self.var,
- LinearExpression([self.mon_param, self.mon_var]),
- ),
+ (self.mon_param, self.var, LinearExpression([self.mon_param, self.var])),
(
self.mon_param,
self.mon_native,
@@ -882,11 +840,7 @@ def test_add_mon_param(self):
def test_add_mon_npv(self):
tests = [
(self.mon_npv, self.invalid, NotImplemented),
- (
- self.mon_npv,
- self.asbinary,
- LinearExpression([self.mon_npv, self.mon_bin]),
- ),
+ (self.mon_npv, self.asbinary, LinearExpression([self.mon_npv, self.bin])),
(self.mon_npv, self.zero, self.mon_npv),
(self.mon_npv, self.one, LinearExpression([self.mon_npv, 1])),
# 4:
@@ -899,7 +853,7 @@ def test_add_mon_npv(self):
LinearExpression([self.mon_npv, self.param_mut]),
),
# 8:
- (self.mon_npv, self.var, LinearExpression([self.mon_npv, self.mon_var])),
+ (self.mon_npv, self.var, LinearExpression([self.mon_npv, self.var])),
(
self.mon_npv,
self.mon_native,
@@ -949,7 +903,7 @@ def test_add_linear(self):
(
self.linear,
self.asbinary,
- LinearExpression(self.linear.args + [self.mon_bin]),
+ LinearExpression(self.linear.args + [self.bin]),
),
(self.linear, self.zero, self.linear),
(self.linear, self.one, LinearExpression(self.linear.args + [1])),
@@ -963,11 +917,7 @@ def test_add_linear(self):
LinearExpression(self.linear.args + [self.param_mut]),
),
# 8:
- (
- self.linear,
- self.var,
- LinearExpression(self.linear.args + [self.mon_var]),
- ),
+ (self.linear, self.var, LinearExpression(self.linear.args + [self.var])),
(
self.linear,
self.mon_native,
@@ -1134,7 +1084,7 @@ def test_add_mutable_l1(self):
(
self.mutable_l1,
self.asbinary,
- LinearExpression(self.mutable_l1.args + [self.mon_bin]),
+ LinearExpression(self.mutable_l1.args + [self.bin]),
),
(self.mutable_l1, self.zero, self.mon_npv),
(self.mutable_l1, self.one, LinearExpression(self.mutable_l1.args + [1])),
@@ -1159,7 +1109,7 @@ def test_add_mutable_l1(self):
(
self.mutable_l1,
self.var,
- LinearExpression(self.mutable_l1.args + [self.mon_var]),
+ LinearExpression(self.mutable_l1.args + [self.var]),
),
(
self.mutable_l1,
@@ -1341,7 +1291,7 @@ def test_add_param0(self):
def test_add_param1(self):
tests = [
(self.param1, self.invalid, NotImplemented),
- (self.param1, self.asbinary, LinearExpression([1, self.mon_bin])),
+ (self.param1, self.asbinary, LinearExpression([1, self.bin])),
(self.param1, self.zero, 1),
(self.param1, self.one, 2),
# 4:
@@ -1350,7 +1300,7 @@ def test_add_param1(self):
(self.param1, self.param, 7),
(self.param1, self.param_mut, NPV_SumExpression([1, self.param_mut])),
# 8:
- (self.param1, self.var, LinearExpression([1, self.mon_var])),
+ (self.param1, self.var, LinearExpression([1, self.var])),
(self.param1, self.mon_native, LinearExpression([1, self.mon_native])),
(self.param1, self.mon_param, LinearExpression([1, self.mon_param])),
(self.param1, self.mon_npv, LinearExpression([1, self.mon_npv])),
@@ -1380,7 +1330,7 @@ def test_add_mutable_l3(self):
(
self.mutable_l3,
self.asbinary,
- LinearExpression(self.mutable_l3.args + [self.mon_bin]),
+ LinearExpression(self.mutable_l3.args + [self.bin]),
),
(self.mutable_l3, self.zero, self.npv),
(self.mutable_l3, self.one, NPV_SumExpression(self.mutable_l3.args + [1])),
@@ -1409,7 +1359,7 @@ def test_add_mutable_l3(self):
(
self.mutable_l3,
self.var,
- LinearExpression(self.mutable_l3.args + [self.mon_var]),
+ LinearExpression(self.mutable_l3.args + [self.var]),
),
(
self.mutable_l3,
@@ -1515,32 +1465,32 @@ def test_sub_asbinary(self):
# BooleanVar objects do not support addition
(self.asbinary, self.asbinary, NotImplemented),
(self.asbinary, self.zero, self.bin),
- (self.asbinary, self.one, LinearExpression([self.mon_bin, -1])),
+ (self.asbinary, self.one, LinearExpression([self.bin, -1])),
# 4:
- (self.asbinary, self.native, LinearExpression([self.mon_bin, -5])),
- (self.asbinary, self.npv, LinearExpression([self.mon_bin, self.minus_npv])),
- (self.asbinary, self.param, LinearExpression([self.mon_bin, -6])),
+ (self.asbinary, self.native, LinearExpression([self.bin, -5])),
+ (self.asbinary, self.npv, LinearExpression([self.bin, self.minus_npv])),
+ (self.asbinary, self.param, LinearExpression([self.bin, -6])),
(
self.asbinary,
self.param_mut,
- LinearExpression([self.mon_bin, self.minus_param_mut]),
+ LinearExpression([self.bin, self.minus_param_mut]),
),
# 8:
- (self.asbinary, self.var, LinearExpression([self.mon_bin, self.minus_var])),
+ (self.asbinary, self.var, LinearExpression([self.bin, self.minus_var])),
(
self.asbinary,
self.mon_native,
- LinearExpression([self.mon_bin, self.minus_mon_native]),
+ LinearExpression([self.bin, self.minus_mon_native]),
),
(
self.asbinary,
self.mon_param,
- LinearExpression([self.mon_bin, self.minus_mon_param]),
+ LinearExpression([self.bin, self.minus_mon_param]),
),
(
self.asbinary,
self.mon_npv,
- LinearExpression([self.mon_bin, self.minus_mon_npv]),
+ LinearExpression([self.bin, self.minus_mon_npv]),
),
# 12:
(self.asbinary, self.linear, SumExpression([self.bin, self.minus_linear])),
@@ -1551,7 +1501,7 @@ def test_sub_asbinary(self):
(
self.asbinary,
self.mutable_l1,
- LinearExpression([self.mon_bin, self.minus_mon_npv]),
+ LinearExpression([self.bin, self.minus_mon_npv]),
),
(
self.asbinary,
@@ -1559,12 +1509,12 @@ def test_sub_asbinary(self):
SumExpression([self.bin, self.minus_mutable_l2]),
),
(self.asbinary, self.param0, self.bin),
- (self.asbinary, self.param1, LinearExpression([self.mon_bin, -1])),
+ (self.asbinary, self.param1, LinearExpression([self.bin, -1])),
# 20:
(
self.asbinary,
self.mutable_l3,
- LinearExpression([self.mon_bin, self.minus_npv]),
+ LinearExpression([self.bin, self.minus_npv]),
),
]
self._run_cases(tests, operator.sub)
@@ -1837,35 +1787,31 @@ def test_sub_param_mut(self):
def test_sub_var(self):
tests = [
(self.var, self.invalid, NotImplemented),
- (self.var, self.asbinary, LinearExpression([self.mon_var, self.minus_bin])),
+ (self.var, self.asbinary, LinearExpression([self.var, self.minus_bin])),
(self.var, self.zero, self.var),
- (self.var, self.one, LinearExpression([self.mon_var, -1])),
+ (self.var, self.one, LinearExpression([self.var, -1])),
# 4:
- (self.var, self.native, LinearExpression([self.mon_var, -5])),
- (self.var, self.npv, LinearExpression([self.mon_var, self.minus_npv])),
- (self.var, self.param, LinearExpression([self.mon_var, -6])),
+ (self.var, self.native, LinearExpression([self.var, -5])),
+ (self.var, self.npv, LinearExpression([self.var, self.minus_npv])),
+ (self.var, self.param, LinearExpression([self.var, -6])),
(
self.var,
self.param_mut,
- LinearExpression([self.mon_var, self.minus_param_mut]),
+ LinearExpression([self.var, self.minus_param_mut]),
),
# 8:
- (self.var, self.var, LinearExpression([self.mon_var, self.minus_var])),
+ (self.var, self.var, LinearExpression([self.var, self.minus_var])),
(
self.var,
self.mon_native,
- LinearExpression([self.mon_var, self.minus_mon_native]),
+ LinearExpression([self.var, self.minus_mon_native]),
),
(
self.var,
self.mon_param,
- LinearExpression([self.mon_var, self.minus_mon_param]),
- ),
- (
- self.var,
- self.mon_npv,
- LinearExpression([self.mon_var, self.minus_mon_npv]),
+ LinearExpression([self.var, self.minus_mon_param]),
),
+ (self.var, self.mon_npv, LinearExpression([self.var, self.minus_mon_npv])),
# 12:
(
self.var,
@@ -1879,7 +1825,7 @@ def test_sub_var(self):
(
self.var,
self.mutable_l1,
- LinearExpression([self.mon_var, self.minus_mon_npv]),
+ LinearExpression([self.var, self.minus_mon_npv]),
),
(
self.var,
@@ -1887,13 +1833,9 @@ def test_sub_var(self):
SumExpression([self.var, self.minus_mutable_l2]),
),
(self.var, self.param0, self.var),
- (self.var, self.param1, LinearExpression([self.mon_var, -1])),
+ (self.var, self.param1, LinearExpression([self.var, -1])),
# 20:
- (
- self.var,
- self.mutable_l3,
- LinearExpression([self.mon_var, self.minus_npv]),
- ),
+ (self.var, self.mutable_l3, LinearExpression([self.var, self.minus_npv])),
]
self._run_cases(tests, operator.sub)
self._run_cases(tests, operator.isub)
@@ -6511,7 +6453,7 @@ def test_mutable_nvp_iadd(self):
mutable_npv = _MutableNPVSumExpression([])
tests = [
(mutable_npv, self.invalid, NotImplemented),
- (mutable_npv, self.asbinary, _MutableLinearExpression([self.mon_bin])),
+ (mutable_npv, self.asbinary, _MutableLinearExpression([self.bin])),
(mutable_npv, self.zero, _MutableNPVSumExpression([])),
(mutable_npv, self.one, _MutableNPVSumExpression([1])),
# 4:
@@ -6520,7 +6462,7 @@ def test_mutable_nvp_iadd(self):
(mutable_npv, self.param, _MutableNPVSumExpression([6])),
(mutable_npv, self.param_mut, _MutableNPVSumExpression([self.param_mut])),
# 8:
- (mutable_npv, self.var, _MutableLinearExpression([self.mon_var])),
+ (mutable_npv, self.var, _MutableLinearExpression([self.var])),
(mutable_npv, self.mon_native, _MutableLinearExpression([self.mon_native])),
(mutable_npv, self.mon_param, _MutableLinearExpression([self.mon_param])),
(mutable_npv, self.mon_npv, _MutableLinearExpression([self.mon_npv])),
@@ -6546,20 +6488,20 @@ def test_mutable_nvp_iadd(self):
mutable_npv = _MutableNPVSumExpression([10])
tests = [
(mutable_npv, self.invalid, NotImplemented),
- (mutable_npv, self.asbinary, _MutableLinearExpression([10, self.mon_bin])),
+ (mutable_npv, self.asbinary, _MutableLinearExpression([10, self.bin])),
(mutable_npv, self.zero, _MutableNPVSumExpression([10])),
- (mutable_npv, self.one, _MutableNPVSumExpression([10, 1])),
+ (mutable_npv, self.one, _MutableNPVSumExpression([11])),
# 4:
- (mutable_npv, self.native, _MutableNPVSumExpression([10, 5])),
+ (mutable_npv, self.native, _MutableNPVSumExpression([15])),
(mutable_npv, self.npv, _MutableNPVSumExpression([10, self.npv])),
- (mutable_npv, self.param, _MutableNPVSumExpression([10, 6])),
+ (mutable_npv, self.param, _MutableNPVSumExpression([16])),
(
mutable_npv,
self.param_mut,
_MutableNPVSumExpression([10, self.param_mut]),
),
# 8:
- (mutable_npv, self.var, _MutableLinearExpression([10, self.mon_var])),
+ (mutable_npv, self.var, _MutableLinearExpression([10, self.var])),
(
mutable_npv,
self.mon_native,
@@ -6592,7 +6534,7 @@ def test_mutable_nvp_iadd(self):
_MutableSumExpression([10] + self.mutable_l2.args),
),
(mutable_npv, self.param0, _MutableNPVSumExpression([10])),
- (mutable_npv, self.param1, _MutableNPVSumExpression([10, 1])),
+ (mutable_npv, self.param1, _MutableNPVSumExpression([11])),
# 20:
(mutable_npv, self.mutable_l3, _MutableNPVSumExpression([10, self.npv])),
]
@@ -6602,7 +6544,7 @@ def test_mutable_lin_iadd(self):
mutable_lin = _MutableLinearExpression([])
tests = [
(mutable_lin, self.invalid, NotImplemented),
- (mutable_lin, self.asbinary, _MutableLinearExpression([self.mon_bin])),
+ (mutable_lin, self.asbinary, _MutableLinearExpression([self.bin])),
(mutable_lin, self.zero, _MutableLinearExpression([])),
(mutable_lin, self.one, _MutableLinearExpression([1])),
# 4:
@@ -6611,7 +6553,7 @@ def test_mutable_lin_iadd(self):
(mutable_lin, self.param, _MutableLinearExpression([6])),
(mutable_lin, self.param_mut, _MutableLinearExpression([self.param_mut])),
# 8:
- (mutable_lin, self.var, _MutableLinearExpression([self.mon_var])),
+ (mutable_lin, self.var, _MutableLinearExpression([self.var])),
(mutable_lin, self.mon_native, _MutableLinearExpression([self.mon_native])),
(mutable_lin, self.mon_param, _MutableLinearExpression([self.mon_param])),
(mutable_lin, self.mon_npv, _MutableLinearExpression([self.mon_npv])),
@@ -6634,81 +6576,69 @@ def test_mutable_lin_iadd(self):
]
self._run_iadd_cases(tests, operator.iadd)
- mutable_lin = _MutableLinearExpression([self.mon_bin])
+ mutable_lin = _MutableLinearExpression([self.bin])
tests = [
(mutable_lin, self.invalid, NotImplemented),
(
mutable_lin,
self.asbinary,
- _MutableLinearExpression([self.mon_bin, self.mon_bin]),
+ _MutableLinearExpression([self.bin, self.bin]),
),
- (mutable_lin, self.zero, _MutableLinearExpression([self.mon_bin])),
- (mutable_lin, self.one, _MutableLinearExpression([self.mon_bin, 1])),
+ (mutable_lin, self.zero, _MutableLinearExpression([self.bin])),
+ (mutable_lin, self.one, _MutableLinearExpression([self.bin, 1])),
# 4:
- (mutable_lin, self.native, _MutableLinearExpression([self.mon_bin, 5])),
- (mutable_lin, self.npv, _MutableLinearExpression([self.mon_bin, self.npv])),
- (mutable_lin, self.param, _MutableLinearExpression([self.mon_bin, 6])),
+ (mutable_lin, self.native, _MutableLinearExpression([self.bin, 5])),
+ (mutable_lin, self.npv, _MutableLinearExpression([self.bin, self.npv])),
+ (mutable_lin, self.param, _MutableLinearExpression([self.bin, 6])),
(
mutable_lin,
self.param_mut,
- _MutableLinearExpression([self.mon_bin, self.param_mut]),
+ _MutableLinearExpression([self.bin, self.param_mut]),
),
# 8:
- (
- mutable_lin,
- self.var,
- _MutableLinearExpression([self.mon_bin, self.mon_var]),
- ),
+ (mutable_lin, self.var, _MutableLinearExpression([self.bin, self.var])),
(
mutable_lin,
self.mon_native,
- _MutableLinearExpression([self.mon_bin, self.mon_native]),
+ _MutableLinearExpression([self.bin, self.mon_native]),
),
(
mutable_lin,
self.mon_param,
- _MutableLinearExpression([self.mon_bin, self.mon_param]),
+ _MutableLinearExpression([self.bin, self.mon_param]),
),
(
mutable_lin,
self.mon_npv,
- _MutableLinearExpression([self.mon_bin, self.mon_npv]),
+ _MutableLinearExpression([self.bin, self.mon_npv]),
),
# 12:
(
mutable_lin,
self.linear,
- _MutableLinearExpression([self.mon_bin] + self.linear.args),
- ),
- (
- mutable_lin,
- self.sum,
- _MutableSumExpression([self.mon_bin] + self.sum.args),
- ),
- (
- mutable_lin,
- self.other,
- _MutableSumExpression([self.mon_bin, self.other]),
+ _MutableLinearExpression([self.bin] + self.linear.args),
),
- (mutable_lin, self.mutable_l0, _MutableLinearExpression([self.mon_bin])),
+ (mutable_lin, self.sum, _MutableSumExpression([self.bin] + self.sum.args)),
+ (mutable_lin, self.other, _MutableSumExpression([self.bin, self.other])),
+ (mutable_lin, self.mutable_l0, _MutableLinearExpression([self.bin])),
# 16:
(
mutable_lin,
self.mutable_l1,
- _MutableLinearExpression([self.mon_bin] + self.mutable_l1.args),
+ _MutableLinearExpression([self.bin] + self.mutable_l1.args),
),
(
mutable_lin,
self.mutable_l2,
- _MutableSumExpression([self.mon_bin] + self.mutable_l2.args),
+ _MutableSumExpression([self.bin] + self.mutable_l2.args),
),
- (mutable_lin, self.param0, _MutableLinearExpression([self.mon_bin])),
- (mutable_lin, self.param1, _MutableLinearExpression([self.mon_bin, 1])),
+ (mutable_lin, self.param0, _MutableLinearExpression([self.bin])),
+ (mutable_lin, self.param1, _MutableLinearExpression([self.bin, 1])),
# 20:
(
mutable_lin,
self.mutable_l3,
- _MutableLinearExpression([self.mon_bin, self.npv]),
+ _MutableLinearExpression([self.bin, self.npv]),
),
]
self._run_iadd_cases(tests, operator.iadd)
@@ -6854,7 +6784,7 @@ def as_numeric(self):
assertExpressionsEqual(self, PowExpression((self.var, 2)), e)
e = obj + obj
- assertExpressionsEqual(self, LinearExpression((self.mon_var, self.mon_var)), e)
+ assertExpressionsEqual(self, LinearExpression((self.var, self.var)), e)
def test_categorize_arg_type(self):
class CustomAsNumeric(NumericValue):
diff --git a/pyomo/core/tests/unit/test_numeric_expr_zerofilter.py b/pyomo/core/tests/unit/test_numeric_expr_zerofilter.py
index 162d664e0f8..19968640a21 100644
--- a/pyomo/core/tests/unit/test_numeric_expr_zerofilter.py
+++ b/pyomo/core/tests/unit/test_numeric_expr_zerofilter.py
@@ -102,38 +102,34 @@ def test_add_asbinary(self):
# BooleanVar objects do not support addition
(self.asbinary, self.asbinary, NotImplemented),
(self.asbinary, self.zero, self.bin),
- (self.asbinary, self.one, LinearExpression([self.mon_bin, 1])),
+ (self.asbinary, self.one, LinearExpression([self.bin, 1])),
# 4:
- (self.asbinary, self.native, LinearExpression([self.mon_bin, 5])),
- (self.asbinary, self.npv, LinearExpression([self.mon_bin, self.npv])),
- (self.asbinary, self.param, LinearExpression([self.mon_bin, 6])),
+ (self.asbinary, self.native, LinearExpression([self.bin, 5])),
+ (self.asbinary, self.npv, LinearExpression([self.bin, self.npv])),
+ (self.asbinary, self.param, LinearExpression([self.bin, 6])),
(
self.asbinary,
self.param_mut,
- LinearExpression([self.mon_bin, self.param_mut]),
+ LinearExpression([self.bin, self.param_mut]),
),
# 8:
- (self.asbinary, self.var, LinearExpression([self.mon_bin, self.mon_var])),
+ (self.asbinary, self.var, LinearExpression([self.bin, self.var])),
(
self.asbinary,
self.mon_native,
- LinearExpression([self.mon_bin, self.mon_native]),
+ LinearExpression([self.bin, self.mon_native]),
),
(
self.asbinary,
self.mon_param,
- LinearExpression([self.mon_bin, self.mon_param]),
- ),
- (
- self.asbinary,
- self.mon_npv,
- LinearExpression([self.mon_bin, self.mon_npv]),
+ LinearExpression([self.bin, self.mon_param]),
),
+ (self.asbinary, self.mon_npv, LinearExpression([self.bin, self.mon_npv])),
# 12:
(
self.asbinary,
self.linear,
- LinearExpression(self.linear.args + [self.mon_bin]),
+ LinearExpression(self.linear.args + [self.bin]),
),
(self.asbinary, self.sum, SumExpression(self.sum.args + [self.bin])),
(self.asbinary, self.other, SumExpression([self.bin, self.other])),
@@ -142,7 +138,7 @@ def test_add_asbinary(self):
(
self.asbinary,
self.mutable_l1,
- LinearExpression([self.mon_bin, self.mon_npv]),
+ LinearExpression([self.bin, self.mon_npv]),
),
(
self.asbinary,
@@ -150,13 +146,9 @@ def test_add_asbinary(self):
SumExpression(self.mutable_l2.args + [self.bin]),
),
(self.asbinary, self.param0, self.bin),
- (self.asbinary, self.param1, LinearExpression([self.mon_bin, 1])),
+ (self.asbinary, self.param1, LinearExpression([self.bin, 1])),
# 20:
- (
- self.asbinary,
- self.mutable_l3,
- LinearExpression([self.mon_bin, self.npv]),
- ),
+ (self.asbinary, self.mutable_l3, LinearExpression([self.bin, self.npv])),
]
self._run_cases(tests, operator.add)
self._run_cases(tests, operator.iadd)
@@ -196,7 +188,7 @@ def test_add_zero(self):
def test_add_one(self):
tests = [
(self.one, self.invalid, NotImplemented),
- (self.one, self.asbinary, LinearExpression([1, self.mon_bin])),
+ (self.one, self.asbinary, LinearExpression([1, self.bin])),
(self.one, self.zero, 1),
(self.one, self.one, 2),
# 4:
@@ -205,7 +197,7 @@ def test_add_one(self):
(self.one, self.param, 7),
(self.one, self.param_mut, NPV_SumExpression([1, self.param_mut])),
# 8:
- (self.one, self.var, LinearExpression([1, self.mon_var])),
+ (self.one, self.var, LinearExpression([1, self.var])),
(self.one, self.mon_native, LinearExpression([1, self.mon_native])),
(self.one, self.mon_param, LinearExpression([1, self.mon_param])),
(self.one, self.mon_npv, LinearExpression([1, self.mon_npv])),
@@ -228,7 +220,7 @@ def test_add_one(self):
def test_add_native(self):
tests = [
(self.native, self.invalid, NotImplemented),
- (self.native, self.asbinary, LinearExpression([5, self.mon_bin])),
+ (self.native, self.asbinary, LinearExpression([5, self.bin])),
(self.native, self.zero, 5),
(self.native, self.one, 6),
# 4:
@@ -237,7 +229,7 @@ def test_add_native(self):
(self.native, self.param, 11),
(self.native, self.param_mut, NPV_SumExpression([5, self.param_mut])),
# 8:
- (self.native, self.var, LinearExpression([5, self.mon_var])),
+ (self.native, self.var, LinearExpression([5, self.var])),
(self.native, self.mon_native, LinearExpression([5, self.mon_native])),
(self.native, self.mon_param, LinearExpression([5, self.mon_param])),
(self.native, self.mon_npv, LinearExpression([5, self.mon_npv])),
@@ -264,7 +256,7 @@ def test_add_native(self):
def test_add_npv(self):
tests = [
(self.npv, self.invalid, NotImplemented),
- (self.npv, self.asbinary, LinearExpression([self.npv, self.mon_bin])),
+ (self.npv, self.asbinary, LinearExpression([self.npv, self.bin])),
(self.npv, self.zero, self.npv),
(self.npv, self.one, NPV_SumExpression([self.npv, 1])),
# 4:
@@ -273,7 +265,7 @@ def test_add_npv(self):
(self.npv, self.param, NPV_SumExpression([self.npv, 6])),
(self.npv, self.param_mut, NPV_SumExpression([self.npv, self.param_mut])),
# 8:
- (self.npv, self.var, LinearExpression([self.npv, self.mon_var])),
+ (self.npv, self.var, LinearExpression([self.npv, self.var])),
(self.npv, self.mon_native, LinearExpression([self.npv, self.mon_native])),
(self.npv, self.mon_param, LinearExpression([self.npv, self.mon_param])),
(self.npv, self.mon_npv, LinearExpression([self.npv, self.mon_npv])),
@@ -304,7 +296,7 @@ def test_add_npv(self):
def test_add_param(self):
tests = [
(self.param, self.invalid, NotImplemented),
- (self.param, self.asbinary, LinearExpression([6, self.mon_bin])),
+ (self.param, self.asbinary, LinearExpression([6, self.bin])),
(self.param, self.zero, 6),
(self.param, self.one, 7),
# 4:
@@ -313,7 +305,7 @@ def test_add_param(self):
(self.param, self.param, 12),
(self.param, self.param_mut, NPV_SumExpression([6, self.param_mut])),
# 8:
- (self.param, self.var, LinearExpression([6, self.mon_var])),
+ (self.param, self.var, LinearExpression([6, self.var])),
(self.param, self.mon_native, LinearExpression([6, self.mon_native])),
(self.param, self.mon_param, LinearExpression([6, self.mon_param])),
(self.param, self.mon_npv, LinearExpression([6, self.mon_npv])),
@@ -339,7 +331,7 @@ def test_add_param_mut(self):
(
self.param_mut,
self.asbinary,
- LinearExpression([self.param_mut, self.mon_bin]),
+ LinearExpression([self.param_mut, self.bin]),
),
(self.param_mut, self.zero, self.param_mut),
(self.param_mut, self.one, NPV_SumExpression([self.param_mut, 1])),
@@ -353,11 +345,7 @@ def test_add_param_mut(self):
NPV_SumExpression([self.param_mut, self.param_mut]),
),
# 8:
- (
- self.param_mut,
- self.var,
- LinearExpression([self.param_mut, self.mon_var]),
- ),
+ (self.param_mut, self.var, LinearExpression([self.param_mut, self.var])),
(
self.param_mut,
self.mon_native,
@@ -408,37 +396,21 @@ def test_add_param_mut(self):
def test_add_var(self):
tests = [
(self.var, self.invalid, NotImplemented),
- (self.var, self.asbinary, LinearExpression([self.mon_var, self.mon_bin])),
+ (self.var, self.asbinary, LinearExpression([self.var, self.bin])),
(self.var, self.zero, self.var),
- (self.var, self.one, LinearExpression([self.mon_var, 1])),
+ (self.var, self.one, LinearExpression([self.var, 1])),
# 4:
- (self.var, self.native, LinearExpression([self.mon_var, 5])),
- (self.var, self.npv, LinearExpression([self.mon_var, self.npv])),
- (self.var, self.param, LinearExpression([self.mon_var, 6])),
- (
- self.var,
- self.param_mut,
- LinearExpression([self.mon_var, self.param_mut]),
- ),
+ (self.var, self.native, LinearExpression([self.var, 5])),
+ (self.var, self.npv, LinearExpression([self.var, self.npv])),
+ (self.var, self.param, LinearExpression([self.var, 6])),
+ (self.var, self.param_mut, LinearExpression([self.var, self.param_mut])),
# 8:
- (self.var, self.var, LinearExpression([self.mon_var, self.mon_var])),
- (
- self.var,
- self.mon_native,
- LinearExpression([self.mon_var, self.mon_native]),
- ),
- (
- self.var,
- self.mon_param,
- LinearExpression([self.mon_var, self.mon_param]),
- ),
- (self.var, self.mon_npv, LinearExpression([self.mon_var, self.mon_npv])),
+ (self.var, self.var, LinearExpression([self.var, self.var])),
+ (self.var, self.mon_native, LinearExpression([self.var, self.mon_native])),
+ (self.var, self.mon_param, LinearExpression([self.var, self.mon_param])),
+ (self.var, self.mon_npv, LinearExpression([self.var, self.mon_npv])),
# 12:
- (
- self.var,
- self.linear,
- LinearExpression(self.linear.args + [self.mon_var]),
- ),
+ (self.var, self.linear, LinearExpression(self.linear.args + [self.var])),
(self.var, self.sum, SumExpression(self.sum.args + [self.var])),
(self.var, self.other, SumExpression([self.var, self.other])),
(self.var, self.mutable_l0, self.var),
@@ -446,7 +418,7 @@ def test_add_var(self):
(
self.var,
self.mutable_l1,
- LinearExpression([self.mon_var] + self.mutable_l1.args),
+ LinearExpression([self.var] + self.mutable_l1.args),
),
(
self.var,
@@ -454,13 +426,9 @@ def test_add_var(self):
SumExpression(self.mutable_l2.args + [self.var]),
),
(self.var, self.param0, self.var),
- (self.var, self.param1, LinearExpression([self.mon_var, 1])),
+ (self.var, self.param1, LinearExpression([self.var, 1])),
# 20:
- (
- self.var,
- self.mutable_l3,
- LinearExpression([MonomialTermExpression((1, self.var)), self.npv]),
- ),
+ (self.var, self.mutable_l3, LinearExpression([self.var, self.npv])),
]
self._run_cases(tests, operator.add)
self._run_cases(tests, operator.iadd)
@@ -471,7 +439,7 @@ def test_add_mon_native(self):
(
self.mon_native,
self.asbinary,
- LinearExpression([self.mon_native, self.mon_bin]),
+ LinearExpression([self.mon_native, self.bin]),
),
(self.mon_native, self.zero, self.mon_native),
(self.mon_native, self.one, LinearExpression([self.mon_native, 1])),
@@ -485,11 +453,7 @@ def test_add_mon_native(self):
LinearExpression([self.mon_native, self.param_mut]),
),
# 8:
- (
- self.mon_native,
- self.var,
- LinearExpression([self.mon_native, self.mon_var]),
- ),
+ (self.mon_native, self.var, LinearExpression([self.mon_native, self.var])),
(
self.mon_native,
self.mon_native,
@@ -547,7 +511,7 @@ def test_add_mon_param(self):
(
self.mon_param,
self.asbinary,
- LinearExpression([self.mon_param, self.mon_bin]),
+ LinearExpression([self.mon_param, self.bin]),
),
(self.mon_param, self.zero, self.mon_param),
(self.mon_param, self.one, LinearExpression([self.mon_param, 1])),
@@ -561,11 +525,7 @@ def test_add_mon_param(self):
LinearExpression([self.mon_param, self.param_mut]),
),
# 8:
- (
- self.mon_param,
- self.var,
- LinearExpression([self.mon_param, self.mon_var]),
- ),
+ (self.mon_param, self.var, LinearExpression([self.mon_param, self.var])),
(
self.mon_param,
self.mon_native,
@@ -616,11 +576,7 @@ def test_add_mon_param(self):
def test_add_mon_npv(self):
tests = [
(self.mon_npv, self.invalid, NotImplemented),
- (
- self.mon_npv,
- self.asbinary,
- LinearExpression([self.mon_npv, self.mon_bin]),
- ),
+ (self.mon_npv, self.asbinary, LinearExpression([self.mon_npv, self.bin])),
(self.mon_npv, self.zero, self.mon_npv),
(self.mon_npv, self.one, LinearExpression([self.mon_npv, 1])),
# 4:
@@ -633,7 +589,7 @@ def test_add_mon_npv(self):
LinearExpression([self.mon_npv, self.param_mut]),
),
# 8:
- (self.mon_npv, self.var, LinearExpression([self.mon_npv, self.mon_var])),
+ (self.mon_npv, self.var, LinearExpression([self.mon_npv, self.var])),
(
self.mon_npv,
self.mon_native,
@@ -683,7 +639,7 @@ def test_add_linear(self):
(
self.linear,
self.asbinary,
- LinearExpression(self.linear.args + [self.mon_bin]),
+ LinearExpression(self.linear.args + [self.bin]),
),
(self.linear, self.zero, self.linear),
(self.linear, self.one, LinearExpression(self.linear.args + [1])),
@@ -697,11 +653,7 @@ def test_add_linear(self):
LinearExpression(self.linear.args + [self.param_mut]),
),
# 8:
- (
- self.linear,
- self.var,
- LinearExpression(self.linear.args + [self.mon_var]),
- ),
+ (self.linear, self.var, LinearExpression(self.linear.args + [self.var])),
(
self.linear,
self.mon_native,
@@ -868,7 +820,7 @@ def test_add_mutable_l1(self):
(
self.mutable_l1,
self.asbinary,
- LinearExpression(self.mutable_l1.args + [self.mon_bin]),
+ LinearExpression(self.mutable_l1.args + [self.bin]),
),
(self.mutable_l1, self.zero, self.mon_npv),
(self.mutable_l1, self.one, LinearExpression(self.mutable_l1.args + [1])),
@@ -893,7 +845,7 @@ def test_add_mutable_l1(self):
(
self.mutable_l1,
self.var,
- LinearExpression(self.mutable_l1.args + [self.mon_var]),
+ LinearExpression(self.mutable_l1.args + [self.var]),
),
(
self.mutable_l1,
@@ -1075,7 +1027,7 @@ def test_add_param0(self):
def test_add_param1(self):
tests = [
(self.param1, self.invalid, NotImplemented),
- (self.param1, self.asbinary, LinearExpression([1, self.mon_bin])),
+ (self.param1, self.asbinary, LinearExpression([1, self.bin])),
(self.param1, self.zero, 1),
(self.param1, self.one, 2),
# 4:
@@ -1084,7 +1036,7 @@ def test_add_param1(self):
(self.param1, self.param, 7),
(self.param1, self.param_mut, NPV_SumExpression([1, self.param_mut])),
# 8:
- (self.param1, self.var, LinearExpression([1, self.mon_var])),
+ (self.param1, self.var, LinearExpression([1, self.var])),
(self.param1, self.mon_native, LinearExpression([1, self.mon_native])),
(self.param1, self.mon_param, LinearExpression([1, self.mon_param])),
(self.param1, self.mon_npv, LinearExpression([1, self.mon_npv])),
@@ -1114,7 +1066,7 @@ def test_add_mutable_l3(self):
(
self.mutable_l3,
self.asbinary,
- LinearExpression(self.mutable_l3.args + [self.mon_bin]),
+ LinearExpression(self.mutable_l3.args + [self.bin]),
),
(self.mutable_l3, self.zero, self.npv),
(self.mutable_l3, self.one, NPV_SumExpression(self.mutable_l3.args + [1])),
@@ -1143,7 +1095,7 @@ def test_add_mutable_l3(self):
(
self.mutable_l3,
self.var,
- LinearExpression(self.mutable_l3.args + [self.mon_var]),
+ LinearExpression(self.mutable_l3.args + [self.var]),
),
(
self.mutable_l3,
@@ -1249,32 +1201,32 @@ def test_sub_asbinary(self):
# BooleanVar objects do not support addition
(self.asbinary, self.asbinary, NotImplemented),
(self.asbinary, self.zero, self.bin),
- (self.asbinary, self.one, LinearExpression([self.mon_bin, -1])),
+ (self.asbinary, self.one, LinearExpression([self.bin, -1])),
# 4:
- (self.asbinary, self.native, LinearExpression([self.mon_bin, -5])),
- (self.asbinary, self.npv, LinearExpression([self.mon_bin, self.minus_npv])),
- (self.asbinary, self.param, LinearExpression([self.mon_bin, -6])),
+ (self.asbinary, self.native, LinearExpression([self.bin, -5])),
+ (self.asbinary, self.npv, LinearExpression([self.bin, self.minus_npv])),
+ (self.asbinary, self.param, LinearExpression([self.bin, -6])),
(
self.asbinary,
self.param_mut,
- LinearExpression([self.mon_bin, self.minus_param_mut]),
+ LinearExpression([self.bin, self.minus_param_mut]),
),
# 8:
- (self.asbinary, self.var, LinearExpression([self.mon_bin, self.minus_var])),
+ (self.asbinary, self.var, LinearExpression([self.bin, self.minus_var])),
(
self.asbinary,
self.mon_native,
- LinearExpression([self.mon_bin, self.minus_mon_native]),
+ LinearExpression([self.bin, self.minus_mon_native]),
),
(
self.asbinary,
self.mon_param,
- LinearExpression([self.mon_bin, self.minus_mon_param]),
+ LinearExpression([self.bin, self.minus_mon_param]),
),
(
self.asbinary,
self.mon_npv,
- LinearExpression([self.mon_bin, self.minus_mon_npv]),
+ LinearExpression([self.bin, self.minus_mon_npv]),
),
# 12:
(self.asbinary, self.linear, SumExpression([self.bin, self.minus_linear])),
@@ -1285,7 +1237,7 @@ def test_sub_asbinary(self):
(
self.asbinary,
self.mutable_l1,
- LinearExpression([self.mon_bin, self.minus_mon_npv]),
+ LinearExpression([self.bin, self.minus_mon_npv]),
),
(
self.asbinary,
@@ -1293,12 +1245,12 @@ def test_sub_asbinary(self):
SumExpression([self.bin, self.minus_mutable_l2]),
),
(self.asbinary, self.param0, self.bin),
- (self.asbinary, self.param1, LinearExpression([self.mon_bin, -1])),
+ (self.asbinary, self.param1, LinearExpression([self.bin, -1])),
# 20:
(
self.asbinary,
self.mutable_l3,
- LinearExpression([self.mon_bin, self.minus_npv]),
+ LinearExpression([self.bin, self.minus_npv]),
),
]
self._run_cases(tests, operator.sub)
@@ -1571,35 +1523,31 @@ def test_sub_param_mut(self):
def test_sub_var(self):
tests = [
(self.var, self.invalid, NotImplemented),
- (self.var, self.asbinary, LinearExpression([self.mon_var, self.minus_bin])),
+ (self.var, self.asbinary, LinearExpression([self.var, self.minus_bin])),
(self.var, self.zero, self.var),
- (self.var, self.one, LinearExpression([self.mon_var, -1])),
+ (self.var, self.one, LinearExpression([self.var, -1])),
# 4:
- (self.var, self.native, LinearExpression([self.mon_var, -5])),
- (self.var, self.npv, LinearExpression([self.mon_var, self.minus_npv])),
- (self.var, self.param, LinearExpression([self.mon_var, -6])),
+ (self.var, self.native, LinearExpression([self.var, -5])),
+ (self.var, self.npv, LinearExpression([self.var, self.minus_npv])),
+ (self.var, self.param, LinearExpression([self.var, -6])),
(
self.var,
self.param_mut,
- LinearExpression([self.mon_var, self.minus_param_mut]),
+ LinearExpression([self.var, self.minus_param_mut]),
),
# 8:
- (self.var, self.var, LinearExpression([self.mon_var, self.minus_var])),
+ (self.var, self.var, LinearExpression([self.var, self.minus_var])),
(
self.var,
self.mon_native,
- LinearExpression([self.mon_var, self.minus_mon_native]),
+ LinearExpression([self.var, self.minus_mon_native]),
),
(
self.var,
self.mon_param,
- LinearExpression([self.mon_var, self.minus_mon_param]),
- ),
- (
- self.var,
- self.mon_npv,
- LinearExpression([self.mon_var, self.minus_mon_npv]),
+ LinearExpression([self.var, self.minus_mon_param]),
),
+ (self.var, self.mon_npv, LinearExpression([self.var, self.minus_mon_npv])),
# 12:
(
self.var,
@@ -1613,7 +1561,7 @@ def test_sub_var(self):
(
self.var,
self.mutable_l1,
- LinearExpression([self.mon_var, self.minus_mon_npv]),
+ LinearExpression([self.var, self.minus_mon_npv]),
),
(
self.var,
@@ -1621,13 +1569,9 @@ def test_sub_var(self):
SumExpression([self.var, self.minus_mutable_l2]),
),
(self.var, self.param0, self.var),
- (self.var, self.param1, LinearExpression([self.mon_var, -1])),
+ (self.var, self.param1, LinearExpression([self.var, -1])),
# 20:
- (
- self.var,
- self.mutable_l3,
- LinearExpression([self.mon_var, self.minus_npv]),
- ),
+ (self.var, self.mutable_l3, LinearExpression([self.var, self.minus_npv])),
]
self._run_cases(tests, operator.sub)
self._run_cases(tests, operator.isub)
@@ -6039,7 +5983,7 @@ def test_mutable_nvp_iadd(self):
mutable_npv = _MutableNPVSumExpression([])
tests = [
(mutable_npv, self.invalid, NotImplemented),
- (mutable_npv, self.asbinary, _MutableLinearExpression([self.mon_bin])),
+ (mutable_npv, self.asbinary, _MutableLinearExpression([self.bin])),
(mutable_npv, self.zero, _MutableNPVSumExpression([])),
(mutable_npv, self.one, _MutableNPVSumExpression([1])),
# 4:
@@ -6048,7 +5992,7 @@ def test_mutable_nvp_iadd(self):
(mutable_npv, self.param, _MutableNPVSumExpression([6])),
(mutable_npv, self.param_mut, _MutableNPVSumExpression([self.param_mut])),
# 8:
- (mutable_npv, self.var, _MutableLinearExpression([self.mon_var])),
+ (mutable_npv, self.var, _MutableLinearExpression([self.var])),
(mutable_npv, self.mon_native, _MutableLinearExpression([self.mon_native])),
(mutable_npv, self.mon_param, _MutableLinearExpression([self.mon_param])),
(mutable_npv, self.mon_npv, _MutableLinearExpression([self.mon_npv])),
@@ -6074,20 +6018,20 @@ def test_mutable_nvp_iadd(self):
mutable_npv = _MutableNPVSumExpression([10])
tests = [
(mutable_npv, self.invalid, NotImplemented),
- (mutable_npv, self.asbinary, _MutableLinearExpression([10, self.mon_bin])),
+ (mutable_npv, self.asbinary, _MutableLinearExpression([10, self.bin])),
(mutable_npv, self.zero, _MutableNPVSumExpression([10])),
- (mutable_npv, self.one, _MutableNPVSumExpression([10, 1])),
+ (mutable_npv, self.one, _MutableNPVSumExpression([11])),
# 4:
- (mutable_npv, self.native, _MutableNPVSumExpression([10, 5])),
+ (mutable_npv, self.native, _MutableNPVSumExpression([15])),
(mutable_npv, self.npv, _MutableNPVSumExpression([10, self.npv])),
- (mutable_npv, self.param, _MutableNPVSumExpression([10, 6])),
+ (mutable_npv, self.param, _MutableNPVSumExpression([16])),
(
mutable_npv,
self.param_mut,
_MutableNPVSumExpression([10, self.param_mut]),
),
# 8:
- (mutable_npv, self.var, _MutableLinearExpression([10, self.mon_var])),
+ (mutable_npv, self.var, _MutableLinearExpression([10, self.var])),
(
mutable_npv,
self.mon_native,
@@ -6120,7 +6064,7 @@ def test_mutable_nvp_iadd(self):
_MutableSumExpression([10] + self.mutable_l2.args),
),
(mutable_npv, self.param0, _MutableNPVSumExpression([10])),
- (mutable_npv, self.param1, _MutableNPVSumExpression([10, 1])),
+ (mutable_npv, self.param1, _MutableNPVSumExpression([11])),
# 20:
(mutable_npv, self.mutable_l3, _MutableNPVSumExpression([10, self.npv])),
]
@@ -6130,7 +6074,7 @@ def test_mutable_lin_iadd(self):
mutable_lin = _MutableLinearExpression([])
tests = [
(mutable_lin, self.invalid, NotImplemented),
- (mutable_lin, self.asbinary, _MutableLinearExpression([self.mon_bin])),
+ (mutable_lin, self.asbinary, _MutableLinearExpression([self.bin])),
(mutable_lin, self.zero, _MutableLinearExpression([])),
(mutable_lin, self.one, _MutableLinearExpression([1])),
# 4:
@@ -6139,7 +6083,7 @@ def test_mutable_lin_iadd(self):
(mutable_lin, self.param, _MutableLinearExpression([6])),
(mutable_lin, self.param_mut, _MutableLinearExpression([self.param_mut])),
# 8:
- (mutable_lin, self.var, _MutableLinearExpression([self.mon_var])),
+ (mutable_lin, self.var, _MutableLinearExpression([self.var])),
(mutable_lin, self.mon_native, _MutableLinearExpression([self.mon_native])),
(mutable_lin, self.mon_param, _MutableLinearExpression([self.mon_param])),
(mutable_lin, self.mon_npv, _MutableLinearExpression([self.mon_npv])),
@@ -6162,81 +6106,69 @@ def test_mutable_lin_iadd(self):
]
self._run_iadd_cases(tests, operator.iadd)
- mutable_lin = _MutableLinearExpression([self.mon_bin])
+ mutable_lin = _MutableLinearExpression([self.bin])
tests = [
(mutable_lin, self.invalid, NotImplemented),
(
mutable_lin,
self.asbinary,
- _MutableLinearExpression([self.mon_bin, self.mon_bin]),
+ _MutableLinearExpression([self.bin, self.bin]),
),
- (mutable_lin, self.zero, _MutableLinearExpression([self.mon_bin])),
- (mutable_lin, self.one, _MutableLinearExpression([self.mon_bin, 1])),
+ (mutable_lin, self.zero, _MutableLinearExpression([self.bin])),
+ (mutable_lin, self.one, _MutableLinearExpression([self.bin, 1])),
# 4:
- (mutable_lin, self.native, _MutableLinearExpression([self.mon_bin, 5])),
- (mutable_lin, self.npv, _MutableLinearExpression([self.mon_bin, self.npv])),
- (mutable_lin, self.param, _MutableLinearExpression([self.mon_bin, 6])),
+ (mutable_lin, self.native, _MutableLinearExpression([self.bin, 5])),
+ (mutable_lin, self.npv, _MutableLinearExpression([self.bin, self.npv])),
+ (mutable_lin, self.param, _MutableLinearExpression([self.bin, 6])),
(
mutable_lin,
self.param_mut,
- _MutableLinearExpression([self.mon_bin, self.param_mut]),
+ _MutableLinearExpression([self.bin, self.param_mut]),
),
# 8:
- (
- mutable_lin,
- self.var,
- _MutableLinearExpression([self.mon_bin, self.mon_var]),
- ),
+ (mutable_lin, self.var, _MutableLinearExpression([self.bin, self.var])),
(
mutable_lin,
self.mon_native,
- _MutableLinearExpression([self.mon_bin, self.mon_native]),
+ _MutableLinearExpression([self.bin, self.mon_native]),
),
(
mutable_lin,
self.mon_param,
- _MutableLinearExpression([self.mon_bin, self.mon_param]),
+ _MutableLinearExpression([self.bin, self.mon_param]),
),
(
mutable_lin,
self.mon_npv,
- _MutableLinearExpression([self.mon_bin, self.mon_npv]),
+ _MutableLinearExpression([self.bin, self.mon_npv]),
),
# 12:
(
mutable_lin,
self.linear,
- _MutableLinearExpression([self.mon_bin] + self.linear.args),
- ),
- (
- mutable_lin,
- self.sum,
- _MutableSumExpression([self.mon_bin] + self.sum.args),
- ),
- (
- mutable_lin,
- self.other,
- _MutableSumExpression([self.mon_bin, self.other]),
+ _MutableLinearExpression([self.bin] + self.linear.args),
),
- (mutable_lin, self.mutable_l0, _MutableLinearExpression([self.mon_bin])),
+ (mutable_lin, self.sum, _MutableSumExpression([self.bin] + self.sum.args)),
+ (mutable_lin, self.other, _MutableSumExpression([self.bin, self.other])),
+ (mutable_lin, self.mutable_l0, _MutableLinearExpression([self.bin])),
# 16:
(
mutable_lin,
self.mutable_l1,
- _MutableLinearExpression([self.mon_bin] + self.mutable_l1.args),
+ _MutableLinearExpression([self.bin] + self.mutable_l1.args),
),
(
mutable_lin,
self.mutable_l2,
- _MutableSumExpression([self.mon_bin] + self.mutable_l2.args),
+ _MutableSumExpression([self.bin] + self.mutable_l2.args),
),
- (mutable_lin, self.param0, _MutableLinearExpression([self.mon_bin])),
- (mutable_lin, self.param1, _MutableLinearExpression([self.mon_bin, 1])),
+ (mutable_lin, self.param0, _MutableLinearExpression([self.bin])),
+ (mutable_lin, self.param1, _MutableLinearExpression([self.bin, 1])),
# 20:
(
mutable_lin,
self.mutable_l3,
- _MutableLinearExpression([self.mon_bin, self.npv]),
+ _MutableLinearExpression([self.bin, self.npv]),
),
]
self._run_iadd_cases(tests, operator.iadd)
diff --git a/pyomo/core/tests/unit/test_numvalue.py b/pyomo/core/tests/unit/test_numvalue.py
index eceab3a42d9..1cccd3863ea 100644
--- a/pyomo/core/tests/unit/test_numvalue.py
+++ b/pyomo/core/tests/unit/test_numvalue.py
@@ -18,6 +18,7 @@
import pyomo.common.unittest as unittest
from pyomo.common.dependencies import numpy, numpy_available
+from pyomo.core.base.units_container import pint_available
from pyomo.environ import (
value,
@@ -50,7 +51,16 @@ def __init__(self, val=0):
class MyBogusNumericType(MyBogusType):
def __add__(self, other):
- return MyBogusNumericType(self.val + float(other))
+ if other.__class__ in native_numeric_types:
+ return MyBogusNumericType(self.val + float(other))
+ else:
+ return NotImplemented
+
+ def __le__(self, other):
+ if other.__class__ in native_numeric_types:
+ return self.val <= float(other)
+ else:
+ return NotImplemented
def __lt__(self, other):
return self.val < float(other)
@@ -534,6 +544,8 @@ def test_unknownNumericType(self):
try:
val = as_numeric(ref)
self.assertEqual(val().val, 42.0)
+ self.assertIn(MyBogusNumericType, native_numeric_types)
+ self.assertIn(MyBogusNumericType, native_types)
finally:
native_numeric_types.remove(MyBogusNumericType)
native_types.remove(MyBogusNumericType)
@@ -562,9 +574,43 @@ def test_numpy_basic_bool_registration(self):
@unittest.skipUnless(numpy_available, "This test requires NumPy")
def test_automatic_numpy_registration(self):
cmd = (
- 'import pyomo; from pyomo.core.base import Var, Param; import numpy as np; '
- 'print(np.float64 in pyomo.common.numeric_types.native_numeric_types); '
- '%s; print(np.float64 in pyomo.common.numeric_types.native_numeric_types)'
+ 'from pyomo.common.numeric_types import native_numeric_types as nnt; '
+ 'print("float64" in [_.__name__ for _ in nnt]); '
+ 'import numpy; '
+ 'print("float64" in [_.__name__ for _ in nnt])'
+ )
+
+ rc = subprocess.run(
+ [sys.executable, '-c', cmd],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT,
+ text=True,
+ )
+ self.assertEqual((rc.returncode, rc.stdout), (0, "False\nTrue\n"))
+
+ cmd = (
+ 'import numpy; '
+ 'from pyomo.common.numeric_types import native_numeric_types as nnt; '
+ 'print("float64" in [_.__name__ for _ in nnt])'
+ )
+
+ rc = subprocess.run(
+ [sys.executable, '-c', cmd],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT,
+ text=True,
+ )
+ self.assertEqual((rc.returncode, rc.stdout), (0, "True\n"))
+
+ def test_unknownNumericType_expr_registration(self):
+ cmd = (
+ 'import pyomo; '
+ 'from pyomo.core.base import Var, Param; '
+ 'from pyomo.core.base.units_container import units; '
+ 'from pyomo.common.numeric_types import native_numeric_types as nnt; '
+ f'from {__name__} import MyBogusNumericType; '
+ 'ref = MyBogusNumericType(42); '
+ 'print(MyBogusNumericType in nnt); %s; print(MyBogusNumericType in nnt); '
)
def _tester(expr):
@@ -574,14 +620,32 @@ def _tester(expr):
stderr=subprocess.STDOUT,
text=True,
)
- self.assertEqual((rc.returncode, rc.stdout), (0, "False\nTrue\n"))
-
- _tester('Var() <= np.float64(5)')
- _tester('np.float64(5) <= Var()')
- _tester('np.float64(5) + Var()')
- _tester('Var() + np.float64(5)')
- _tester('v = Var(); v.construct(); v.value = np.float64(5)')
- _tester('p = Param(mutable=True); p.construct(); p.value = np.float64(5)')
+ self.assertEqual(
+ (rc.returncode, rc.stdout),
+ (
+ 0,
+ '''False
+WARNING: Dynamically registering the following numeric type:
+ pyomo.core.tests.unit.test_numvalue.MyBogusNumericType
+ Dynamic registration is supported for convenience, but there are known
+ limitations to this approach. We recommend explicitly registering numeric
+ types using RegisterNumericType() or RegisterIntegerType().
+True
+''',
+ ),
+ )
+
+ _tester('Var() <= ref')
+ _tester('ref <= Var()')
+ _tester('ref + Var()')
+ _tester('Var() + ref')
+ _tester('v = Var(); v.construct(); v.value = ref')
+ _tester('p = Param(mutable=True); p.construct(); p.value = ref')
+ if pint_available:
+ _tester('v = Var(units=units.m); v.construct(); v.value = ref')
+ _tester(
+ 'p = Param(mutable=True, units=units.m); p.construct(); p.value = ref'
+ )
if __name__ == "__main__":
diff --git a/pyomo/core/tests/unit/test_obj.py b/pyomo/core/tests/unit/test_obj.py
index 3c8a05f7058..dc2e320e63b 100644
--- a/pyomo/core/tests/unit/test_obj.py
+++ b/pyomo/core/tests/unit/test_obj.py
@@ -78,7 +78,7 @@ def test_empty_singleton(self):
# Even though we construct a ScalarObjective,
# if it is not initialized that means it is "empty"
# and we should encounter errors when trying to access the
- # _ObjectiveData interface methods until we assign
+ # ObjectiveData interface methods until we assign
# something to the objective.
#
self.assertEqual(a._constructed, True)
diff --git a/pyomo/core/tests/unit/test_param.py b/pyomo/core/tests/unit/test_param.py
index 9bc0c4b2ad2..f22674b6bf7 100644
--- a/pyomo/core/tests/unit/test_param.py
+++ b/pyomo/core/tests/unit/test_param.py
@@ -65,8 +65,8 @@
from pyomo.common.errors import PyomoException
from pyomo.common.log import LoggingIntercept
from pyomo.common.tempfiles import TempfileManager
-from pyomo.core.base.param import _ParamData
-from pyomo.core.base.set import _SetData
+from pyomo.core.base.param import ParamData
+from pyomo.core.base.set import SetData
from pyomo.core.base.units_container import units, pint_available, UnitsError
from io import StringIO
@@ -181,7 +181,7 @@ def test_setitem_preexisting(self):
idx = sorted(keys)[0]
self.assertEqual(value(self.instance.A[idx]), self.data[idx])
if self.instance.A.mutable:
- self.assertTrue(isinstance(self.instance.A[idx], _ParamData))
+ self.assertTrue(isinstance(self.instance.A[idx], ParamData))
else:
self.assertEqual(type(self.instance.A[idx]), float)
@@ -190,7 +190,7 @@ def test_setitem_preexisting(self):
if not self.instance.A.mutable:
self.fail("Expected setitem[%s] to fail for immutable Params" % (idx,))
self.assertEqual(value(self.instance.A[idx]), 4.3)
- self.assertTrue(isinstance(self.instance.A[idx], _ParamData))
+ self.assertTrue(isinstance(self.instance.A[idx], ParamData))
except TypeError:
# immutable Params should raise a TypeError exception
if self.instance.A.mutable:
@@ -249,7 +249,7 @@ def test_setitem_default_override(self):
self.assertEqual(value(self.instance.A[idx]), self.instance.A._default_val)
if self.instance.A.mutable:
- self.assertIsInstance(self.instance.A[idx], _ParamData)
+ self.assertIsInstance(self.instance.A[idx], ParamData)
else:
self.assertEqual(
type(self.instance.A[idx]), type(value(self.instance.A._default_val))
@@ -260,7 +260,7 @@ def test_setitem_default_override(self):
if not self.instance.A.mutable:
self.fail("Expected setitem[%s] to fail for immutable Params" % (idx,))
self.assertEqual(self.instance.A[idx].value, 4.3)
- self.assertIsInstance(self.instance.A[idx], _ParamData)
+ self.assertIsInstance(self.instance.A[idx], ParamData)
except TypeError:
# immutable Params should raise a TypeError exception
if self.instance.A.mutable:
@@ -1487,7 +1487,7 @@ def test_domain_set_initializer(self):
m.I = Set(initialize=[1, 2, 3])
param_vals = {1: 1, 2: 1, 3: -1}
m.p = Param(m.I, initialize=param_vals, domain={-1, 1})
- self.assertIsInstance(m.p.domain, _SetData)
+ self.assertIsInstance(m.p.domain, SetData)
@unittest.skipUnless(pint_available, "units test requires pint module")
def test_set_value_units(self):
diff --git a/pyomo/core/tests/unit/test_piecewise.py b/pyomo/core/tests/unit/test_piecewise.py
index af82ef7c06d..7b8e01e6a45 100644
--- a/pyomo/core/tests/unit/test_piecewise.py
+++ b/pyomo/core/tests/unit/test_piecewise.py
@@ -104,7 +104,7 @@ def test_indexed_with_nonindexed_vars(self):
model.con3 = Piecewise(*args, **keywords)
# test that nonindexed Piecewise can handle
- # _VarData (e.g model.x[1]
+ # VarData (e.g model.x[1]
def test_nonindexed_with_indexed_vars(self):
model = ConcreteModel()
model.range = Var([1])
diff --git a/pyomo/core/tests/unit/test_reference.py b/pyomo/core/tests/unit/test_reference.py
index 287ff204f9e..7370881612f 100644
--- a/pyomo/core/tests/unit/test_reference.py
+++ b/pyomo/core/tests/unit/test_reference.py
@@ -800,8 +800,8 @@ def test_reference_indexedcomponent_pprint(self):
buf.getvalue(),
"""r : Size=2, Index={1, 2}, ReferenceTo=x
Key : Object
- 1 :
- 2 :
+ 1 :
+ 2 :
""",
)
m.s = Reference(m.x[:, ...], ctype=IndexedComponent)
@@ -811,8 +811,8 @@ def test_reference_indexedcomponent_pprint(self):
buf.getvalue(),
"""s : Size=2, Index={1, 2}, ReferenceTo=x[:, ...]
Key : Object
- 1 :
- 2 :
+ 1 :
+ 2 :
""",
)
@@ -1280,7 +1280,6 @@ def test_contains_with_nonflattened(self):
normalize_index.flatten = _old_flatten
def test_pprint_nonfinite_sets(self):
- self.maxDiff = None
m = ConcreteModel()
m.v = Var(NonNegativeIntegers, dense=False)
m.ref = Reference(m.v)
@@ -1322,7 +1321,6 @@ def test_pprint_nonfinite_sets(self):
def test_pprint_nonfinite_sets_ctypeNone(self):
# test issue #2039
- self.maxDiff = None
m = ConcreteModel()
m.v = Var(NonNegativeIntegers, dense=False)
m.ref = Reference(m.v, ctype=None)
@@ -1359,8 +1357,8 @@ def test_pprint_nonfinite_sets_ctypeNone(self):
1 IndexedComponent Declarations
ref : Size=2, Index=NonNegativeIntegers, ReferenceTo=v
Key : Object
- 3 :
- 5 :
+ 3 :
+ 5 :
2 Declarations: v ref
""".strip(),
diff --git a/pyomo/core/tests/unit/test_set.py b/pyomo/core/tests/unit/test_set.py
index 1ad08ba025c..f62589a6873 100644
--- a/pyomo/core/tests/unit/test_set.py
+++ b/pyomo/core/tests/unit/test_set.py
@@ -60,8 +60,8 @@
FiniteSetOf,
InfiniteSetOf,
RangeSet,
- _FiniteRangeSetData,
- _InfiniteRangeSetData,
+ FiniteRangeSetData,
+ InfiniteRangeSetData,
FiniteScalarRangeSet,
InfiniteScalarRangeSet,
AbstractFiniteScalarRangeSet,
@@ -81,10 +81,10 @@
SetProduct_InfiniteSet,
SetProduct_FiniteSet,
SetProduct_OrderedSet,
- _SetData,
- _FiniteSetData,
- _InsertionOrderSetData,
- _SortedSetData,
+ SetData,
+ FiniteSetData,
+ InsertionOrderSetData,
+ SortedSetData,
_FiniteSetMixin,
_OrderedSetMixin,
SetInitializer,
@@ -1285,19 +1285,19 @@ def test_is_functions(self):
self.assertTrue(i.isdiscrete())
self.assertTrue(i.isfinite())
self.assertTrue(i.isordered())
- self.assertIsInstance(i, _FiniteRangeSetData)
+ self.assertIsInstance(i, FiniteRangeSetData)
i = RangeSet(1, 3)
self.assertTrue(i.isdiscrete())
self.assertTrue(i.isfinite())
self.assertTrue(i.isordered())
- self.assertIsInstance(i, _FiniteRangeSetData)
+ self.assertIsInstance(i, FiniteRangeSetData)
i = RangeSet(1, 3, 0)
self.assertFalse(i.isdiscrete())
self.assertFalse(i.isfinite())
self.assertFalse(i.isordered())
- self.assertIsInstance(i, _InfiniteRangeSetData)
+ self.assertIsInstance(i, InfiniteRangeSetData)
def test_pprint(self):
m = ConcreteModel()
@@ -4137,9 +4137,9 @@ def test_indexed_set(self):
self.assertFalse(m.I[1].isordered())
self.assertFalse(m.I[2].isordered())
self.assertFalse(m.I[3].isordered())
- self.assertIs(type(m.I[1]), _FiniteSetData)
- self.assertIs(type(m.I[2]), _FiniteSetData)
- self.assertIs(type(m.I[3]), _FiniteSetData)
+ self.assertIs(type(m.I[1]), FiniteSetData)
+ self.assertIs(type(m.I[2]), FiniteSetData)
+ self.assertIs(type(m.I[3]), FiniteSetData)
self.assertEqual(m.I.data(), {1: (1,), 2: (2,), 3: (4,)})
# Explicit (constant) construction
@@ -4155,9 +4155,9 @@ def test_indexed_set(self):
self.assertTrue(m.I[1].isordered())
self.assertTrue(m.I[2].isordered())
self.assertTrue(m.I[3].isordered())
- self.assertIs(type(m.I[1]), _InsertionOrderSetData)
- self.assertIs(type(m.I[2]), _InsertionOrderSetData)
- self.assertIs(type(m.I[3]), _InsertionOrderSetData)
+ self.assertIs(type(m.I[1]), InsertionOrderSetData)
+ self.assertIs(type(m.I[2]), InsertionOrderSetData)
+ self.assertIs(type(m.I[3]), InsertionOrderSetData)
self.assertEqual(m.I.data(), {1: (4, 2, 5), 2: (4, 2, 5), 3: (4, 2, 5)})
# Explicit (constant) construction
@@ -4173,9 +4173,9 @@ def test_indexed_set(self):
self.assertTrue(m.I[1].isordered())
self.assertTrue(m.I[2].isordered())
self.assertTrue(m.I[3].isordered())
- self.assertIs(type(m.I[1]), _SortedSetData)
- self.assertIs(type(m.I[2]), _SortedSetData)
- self.assertIs(type(m.I[3]), _SortedSetData)
+ self.assertIs(type(m.I[1]), SortedSetData)
+ self.assertIs(type(m.I[2]), SortedSetData)
+ self.assertIs(type(m.I[3]), SortedSetData)
self.assertEqual(m.I.data(), {1: (2, 4, 5), 2: (2, 4, 5), 3: (2, 4, 5)})
# Explicit (procedural) construction
@@ -4300,7 +4300,7 @@ def _l_tri(model, i, j):
# This tests a filter that matches the dimentionality of the
# component. construct() needs to recognize that the filter is
# returning a constant in construct() and re-assign it to be the
- # _filter for each _SetData
+ # _filter for each SetData
def _lt_3(model, i):
self.assertIs(model, m)
return i < 3
@@ -5297,15 +5297,15 @@ def test_no_normalize_index(self):
class TestAbstractSetAPI(unittest.TestCase):
- def test_SetData(self):
+ def testSetData(self):
# This tests an anstract non-finite set API
m = ConcreteModel()
m.I = Set(initialize=[1])
- s = _SetData(m.I)
+ s = SetData(m.I)
#
- # _SetData API
+ # SetData API
#
with self.assertRaises(DeveloperError):
@@ -5395,7 +5395,7 @@ def test_SetData(self):
def test_FiniteMixin(self):
# This tests an anstract finite set API
- class FiniteMixin(_FiniteSetMixin, _SetData):
+ class FiniteMixin(_FiniteSetMixin, SetData):
pass
m = ConcreteModel()
@@ -5403,7 +5403,7 @@ class FiniteMixin(_FiniteSetMixin, _SetData):
s = FiniteMixin(m.I)
#
- # _SetData API
+ # SetData API
#
with self.assertRaises(DeveloperError):
@@ -5520,7 +5520,7 @@ class FiniteMixin(_FiniteSetMixin, _SetData):
def test_OrderedMixin(self):
# This tests an anstract ordered set API
- class OrderedMixin(_OrderedSetMixin, _FiniteSetMixin, _SetData):
+ class OrderedMixin(_OrderedSetMixin, _FiniteSetMixin, SetData):
pass
m = ConcreteModel()
@@ -5528,7 +5528,7 @@ class OrderedMixin(_OrderedSetMixin, _FiniteSetMixin, _SetData):
s = OrderedMixin(m.I)
#
- # _SetData API
+ # SetData API
#
with self.assertRaises(DeveloperError):
@@ -6267,7 +6267,6 @@ def test_issue_835(self):
@unittest.skipIf(NamedTuple is None, "typing module not available")
def test_issue_938(self):
- self.maxDiff = None
NodeKey = NamedTuple('NodeKey', [('id', int)])
ArcKey = NamedTuple('ArcKey', [('node_from', NodeKey), ('node_to', NodeKey)])
diff --git a/pyomo/core/tests/unit/test_template_expr.py b/pyomo/core/tests/unit/test_template_expr.py
index 4f255e3567a..80f5d90b60e 100644
--- a/pyomo/core/tests/unit/test_template_expr.py
+++ b/pyomo/core/tests/unit/test_template_expr.py
@@ -127,7 +127,7 @@ def test_template_scalar_with_set(self):
# Note that structural expressions do not implement polynomial_degree
with self.assertRaisesRegex(
AttributeError,
- "'_InsertionOrderSetData' object has " "no attribute 'polynomial_degree'",
+ "'InsertionOrderSetData' object has " "no attribute 'polynomial_degree'",
):
e.polynomial_degree()
self.assertEqual(str(e), "s[{I}]")
@@ -490,14 +490,14 @@ def c(m):
self.assertEqual(
str(resolve_template(template)),
'x[1,1,10] + '
- '(x[2,1,10] + x[2,1,20]) + '
- '(x[3,1,10] + x[3,1,20] + x[3,1,30]) + '
- '(x[1,2,10]) + '
- '(x[2,2,10] + x[2,2,20]) + '
- '(x[3,2,10] + x[3,2,20] + x[3,2,30]) + '
- '(x[1,3,10]) + '
- '(x[2,3,10] + x[2,3,20]) + '
- '(x[3,3,10] + x[3,3,20] + x[3,3,30]) <= 0',
+ 'x[2,1,10] + x[2,1,20] + '
+ 'x[3,1,10] + x[3,1,20] + x[3,1,30] + '
+ 'x[1,2,10] + '
+ 'x[2,2,10] + x[2,2,20] + '
+ 'x[3,2,10] + x[3,2,20] + x[3,2,30] + '
+ 'x[1,3,10] + '
+ 'x[2,3,10] + x[2,3,20] + '
+ 'x[3,3,10] + x[3,3,20] + x[3,3,30] <= 0',
)
def test_multidim_nested_sum_rule(self):
@@ -566,14 +566,14 @@ def c(m):
self.assertEqual(
str(resolve_template(template)),
'x[1,1,10] + '
- '(x[2,1,10] + x[2,1,20]) + '
- '(x[3,1,10] + x[3,1,20] + x[3,1,30]) + '
- '(x[1,2,10]) + '
- '(x[2,2,10] + x[2,2,20]) + '
- '(x[3,2,10] + x[3,2,20] + x[3,2,30]) + '
- '(x[1,3,10]) + '
- '(x[2,3,10] + x[2,3,20]) + '
- '(x[3,3,10] + x[3,3,20] + x[3,3,30]) <= 0',
+ 'x[2,1,10] + x[2,1,20] + '
+ 'x[3,1,10] + x[3,1,20] + x[3,1,30] + '
+ 'x[1,2,10] + '
+ 'x[2,2,10] + x[2,2,20] + '
+ 'x[3,2,10] + x[3,2,20] + x[3,2,30] + '
+ 'x[1,3,10] + '
+ 'x[2,3,10] + x[2,3,20] + '
+ 'x[3,3,10] + x[3,3,20] + x[3,3,30] <= 0',
)
def test_multidim_nested_getattr_sum_rule(self):
@@ -609,14 +609,14 @@ def c(m):
self.assertEqual(
str(resolve_template(template)),
'x[1,1,10] + '
- '(x[2,1,10] + x[2,1,20]) + '
- '(x[3,1,10] + x[3,1,20] + x[3,1,30]) + '
- '(x[1,2,10]) + '
- '(x[2,2,10] + x[2,2,20]) + '
- '(x[3,2,10] + x[3,2,20] + x[3,2,30]) + '
- '(x[1,3,10]) + '
- '(x[2,3,10] + x[2,3,20]) + '
- '(x[3,3,10] + x[3,3,20] + x[3,3,30]) <= 0',
+ 'x[2,1,10] + x[2,1,20] + '
+ 'x[3,1,10] + x[3,1,20] + x[3,1,30] + '
+ 'x[1,2,10] + '
+ 'x[2,2,10] + x[2,2,20] + '
+ 'x[3,2,10] + x[3,2,20] + x[3,2,30] + '
+ 'x[1,3,10] + '
+ 'x[2,3,10] + x[2,3,20] + '
+ 'x[3,3,10] + x[3,3,20] + x[3,3,30] <= 0',
)
def test_eval_getattr(self):
diff --git a/pyomo/core/tests/unit/test_var_set_bounds.py b/pyomo/core/tests/unit/test_var_set_bounds.py
index bae89556ce3..1686ba4f1c6 100644
--- a/pyomo/core/tests/unit/test_var_set_bounds.py
+++ b/pyomo/core/tests/unit/test_var_set_bounds.py
@@ -36,7 +36,7 @@
# GAH: These tests been temporarily disabled. It is no longer the job of Var
# to validate its domain at the time of construction. It only needs to
# ensure that whatever object is passed as its domain is suitable for
-# interacting with the _VarData interface (e.g., has a bounds method)
+# interacting with the VarData interface (e.g., has a bounds method)
# The plan is to start adding functionality to the solver interfaces
# that will support custom domains.
diff --git a/pyomo/core/tests/unit/test_visitor.py b/pyomo/core/tests/unit/test_visitor.py
index fada7d6f6b2..5733710ab46 100644
--- a/pyomo/core/tests/unit/test_visitor.py
+++ b/pyomo/core/tests/unit/test_visitor.py
@@ -72,7 +72,7 @@
RECURSION_LIMIT,
get_stack_depth,
)
-from pyomo.core.base.param import _ParamData, ScalarParam
+from pyomo.core.base.param import ParamData, ScalarParam
from pyomo.core.expr.template_expr import IndexTemplate
from pyomo.common.collections import ComponentSet
from pyomo.common.errors import TemplateExpressionError
@@ -145,7 +145,8 @@ def test_identify_vars_vars(self):
self.assertEqual(list(identify_variables(m.a + m.b[1])), [m.a, m.b[1]])
self.assertEqual(list(identify_variables(m.a ** m.b[1])), [m.a, m.b[1]])
self.assertEqual(
- list(identify_variables(m.a ** m.b[1] + m.b[2])), [m.b[2], m.a, m.b[1]]
+ ComponentSet(identify_variables(m.a ** m.b[1] + m.b[2])),
+ ComponentSet([m.b[2], m.a, m.b[1]]),
)
self.assertEqual(
list(identify_variables(m.a ** m.b[1] + m.b[2] * m.b[3] * m.b[2])),
@@ -159,14 +160,20 @@ def test_identify_vars_vars(self):
# Identify variables in the arguments to functions
#
self.assertEqual(
- list(identify_variables(m.x(m.a, 'string_param', 1, []) * m.b[1])),
- [m.b[1], m.a],
+ ComponentSet(identify_variables(m.x(m.a, 'string_param', 1, []) * m.b[1])),
+ ComponentSet([m.b[1], m.a]),
)
self.assertEqual(
list(identify_variables(m.x(m.p, 'string_param', 1, []) * m.b[1])), [m.b[1]]
)
- self.assertEqual(list(identify_variables(tanh(m.a) * m.b[1])), [m.b[1], m.a])
- self.assertEqual(list(identify_variables(abs(m.a) * m.b[1])), [m.b[1], m.a])
+ self.assertEqual(
+ ComponentSet(identify_variables(tanh(m.a) * m.b[1])),
+ ComponentSet([m.b[1], m.a]),
+ )
+ self.assertEqual(
+ ComponentSet(identify_variables(abs(m.a) * m.b[1])),
+ ComponentSet([m.b[1], m.a]),
+ )
#
# Check logic for allowing duplicates
#
@@ -437,9 +444,7 @@ def test_replacement_linear_expression_with_constant(self):
sub_map = dict()
sub_map[id(m.x)] = 5
e2 = replace_expressions(e, sub_map)
- assertExpressionsEqual(
- self, e2, LinearExpression([10, MonomialTermExpression((1, m.y))])
- )
+ assertExpressionsEqual(self, e2, LinearExpression([10, m.y]))
e = LinearExpression(linear_coefs=[2, 3], linear_vars=[m.x, m.y])
sub_map = dict()
@@ -687,7 +692,7 @@ def __init__(self, model):
self.model = model
def visiting_potential_leaf(self, node):
- if node.__class__ in (_ParamData, ScalarParam):
+ if node.__class__ in (ParamData, ScalarParam):
if id(node) in self.substitute:
return True, self.substitute[id(node)]
self.substitute[id(node)] = 2 * self.model.w.add()
@@ -886,20 +891,7 @@ def test_replace(self):
assertExpressionsEqual(
self,
SumExpression(
- [
- LinearExpression(
- [
- MonomialTermExpression((1, m.y[1])),
- MonomialTermExpression((1, m.y[2])),
- ]
- ),
- LinearExpression(
- [
- MonomialTermExpression((1, m.y[2])),
- MonomialTermExpression((1, m.y[3])),
- ]
- ),
- ]
+ [LinearExpression([m.y[1], m.y[2]]), LinearExpression([m.y[2], m.y[3]])]
)
== 0,
f,
@@ -930,9 +922,7 @@ def test_npv_sum(self):
e3 = replace_expressions(e1, {id(m.p1): m.x})
assertExpressionsEqual(self, e2, m.p2 + 2)
- assertExpressionsEqual(
- self, e3, LinearExpression([MonomialTermExpression((1, m.x)), 2])
- )
+ assertExpressionsEqual(self, e3, LinearExpression([m.x, 2]))
def test_npv_negation(self):
m = ConcreteModel()
diff --git a/pyomo/core/util.py b/pyomo/core/util.py
index f337b487cef..4b6cc8f3320 100644
--- a/pyomo/core/util.py
+++ b/pyomo/core/util.py
@@ -18,7 +18,7 @@
from pyomo.core.expr.numeric_expr import mutable_expression, NPV_SumExpression
from pyomo.core.base.var import Var
from pyomo.core.base.expression import Expression
-from pyomo.core.base.component import _ComponentBase
+from pyomo.core.base.component import ComponentBase
import logging
logger = logging.getLogger(__name__)
@@ -238,12 +238,12 @@ def sequence(*args):
def target_list(x):
- if isinstance(x, _ComponentBase):
+ if isinstance(x, ComponentBase):
return [x]
elif hasattr(x, '__iter__'):
ans = []
for i in x:
- if isinstance(i, _ComponentBase):
+ if isinstance(i, ComponentBase):
ans.append(i)
else:
raise ValueError(
diff --git a/pyomo/dae/flatten.py b/pyomo/dae/flatten.py
index febaf7c10c9..3d90cc443c1 100644
--- a/pyomo/dae/flatten.py
+++ b/pyomo/dae/flatten.py
@@ -259,7 +259,7 @@ def generate_sliced_components(
Parameters
----------
- b: _BlockData
+ b: BlockData
Block whose components will be sliced
index_stack: list
@@ -267,7 +267,7 @@ def generate_sliced_components(
component, that have been sliced. This is necessary to return the
sets that have been sliced.
- slice_: IndexedComponent_slice or _BlockData
+ slice_: IndexedComponent_slice or BlockData
Slice generated so far. This function will yield extensions to
this slice at the current level of the block hierarchy.
@@ -443,7 +443,7 @@ def flatten_components_along_sets(m, sets, ctype, indices=None, active=None):
Parameters
----------
- m: _BlockData
+ m: BlockData
Block whose components (and their sub-components) will be
partitioned
@@ -546,7 +546,7 @@ def flatten_dae_components(model, time, ctype, indices=None, active=None):
Parameters
----------
- model: _BlockData
+ model: BlockData
Block whose components are partitioned
time: Set
diff --git a/pyomo/dae/integral.py b/pyomo/dae/integral.py
index 41114296a93..8c9512d98dd 100644
--- a/pyomo/dae/integral.py
+++ b/pyomo/dae/integral.py
@@ -14,7 +14,7 @@
from pyomo.core.base.indexed_component import rule_wrapper
from pyomo.core.base.expression import (
Expression,
- _GeneralExpressionData,
+ ExpressionData,
ScalarExpression,
IndexedExpression,
)
@@ -151,7 +151,7 @@ class ScalarIntegral(ScalarExpression, Integral):
"""
def __init__(self, *args, **kwds):
- _GeneralExpressionData.__init__(self, None, component=self)
+ ExpressionData.__init__(self, None, component=self)
Integral.__init__(self, *args, **kwds)
def clear(self):
diff --git a/pyomo/dae/misc.py b/pyomo/dae/misc.py
index 3e09a055577..dcb73f60c9e 100644
--- a/pyomo/dae/misc.py
+++ b/pyomo/dae/misc.py
@@ -263,7 +263,7 @@ def _update_var(v):
# Note: This is not required it is handled by the _default method on
# Var (which is now a IndexedComponent). However, it
# would be much slower to rely on that method to generate new
- # _VarData for a large number of new indices.
+ # VarData for a large number of new indices.
new_indices = set(v.index_set()) - set(v._data.keys())
for index in new_indices:
v.add(index)
diff --git a/pyomo/dataportal/plugins/db_table.py b/pyomo/dataportal/plugins/db_table.py
index a39705a6058..71fd499f725 100644
--- a/pyomo/dataportal/plugins/db_table.py
+++ b/pyomo/dataportal/plugins/db_table.py
@@ -385,8 +385,9 @@ def __init__(self, filename=None, data=None):
will override that in the file.
"""
- # ugh hardcoded strings. See following URL for info:
- # http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.odbc.doc/odbc58.htm
+ # Hardcoded string required here.
+ # See documentation:
+ # https://www.ibm.com/docs/en/informix-servers/12.10?topic=SSGU8G_12.1.0/com.ibm.odbc.doc/ids_odbc_062.html
self.ODBC_DS_KEY = 'ODBC Data Sources'
self.ODBC_INFO_KEY = 'ODBC'
diff --git a/pyomo/environ/__init__.py b/pyomo/environ/__init__.py
index ec0cc5878e4..07b3dfad680 100644
--- a/pyomo/environ/__init__.py
+++ b/pyomo/environ/__init__.py
@@ -50,6 +50,8 @@ def _do_import(pkg_name):
'pyomo.contrib.multistart',
'pyomo.contrib.preprocessing',
'pyomo.contrib.pynumero',
+ 'pyomo.contrib.simplification',
+ 'pyomo.contrib.solver',
'pyomo.contrib.trustregion',
]
diff --git a/pyomo/environ/tests/test_environ.py b/pyomo/environ/tests/test_environ.py
index 9c89fd135d5..9811b412af7 100644
--- a/pyomo/environ/tests/test_environ.py
+++ b/pyomo/environ/tests/test_environ.py
@@ -140,6 +140,7 @@ def test_tpl_import_time(self):
'cPickle',
'csv',
'ctypes', # mandatory import in core/base/external.py; TODO: fix this
+ 'datetime', # imported by contrib.solver
'decimal',
'gc', # Imported on MacOS, Windows; Linux in 3.10
'glob',
diff --git a/pyomo/environ/tests/test_package_layout.py b/pyomo/environ/tests/test_package_layout.py
index 4e1574ab158..47c6422a879 100644
--- a/pyomo/environ/tests/test_package_layout.py
+++ b/pyomo/environ/tests/test_package_layout.py
@@ -38,6 +38,7 @@
_NON_MODULE_DIRS = {
join('contrib', 'ampl_function_demo', 'src'),
join('contrib', 'appsi', 'cmodel', 'src'),
+ join('contrib', 'simplification', 'ginac', 'src'),
join('contrib', 'pynumero', 'src'),
join('core', 'tests', 'data', 'baselines'),
join('core', 'tests', 'diet', 'baselines'),
diff --git a/pyomo/gdp/__init__.py b/pyomo/gdp/__init__.py
index a18bc03084a..d204369cdba 100644
--- a/pyomo/gdp/__init__.py
+++ b/pyomo/gdp/__init__.py
@@ -9,7 +9,13 @@
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
-from pyomo.gdp.disjunct import GDP_Error, Disjunct, Disjunction
+from pyomo.gdp.disjunct import (
+ GDP_Error,
+ Disjunct,
+ DisjunctData,
+ Disjunction,
+ DisjunctionData,
+)
# Do not import these files: importing them registers the transformation
# plugins with the pyomo script so that they get automatically invoked.
diff --git a/pyomo/gdp/disjunct.py b/pyomo/gdp/disjunct.py
index d6e5fcfec57..637f55cbed1 100644
--- a/pyomo/gdp/disjunct.py
+++ b/pyomo/gdp/disjunct.py
@@ -41,7 +41,7 @@
ComponentData,
)
from pyomo.core.base.global_set import UnindexedComponent_index
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.core.base.misc import apply_indexed_rule
from pyomo.core.base.indexed_component import ActiveIndexedComponent
from pyomo.core.expr.expr_common import ExpressionType
@@ -412,7 +412,7 @@ def process(arg):
return (_Initializer.deferred_value, arg)
-class _DisjunctData(_BlockData):
+class DisjunctData(BlockData):
__autoslot_mappers__ = {'_transformation_block': AutoSlots.weakref_mapper}
_Block_reserved_words = set()
@@ -424,7 +424,7 @@ def transformation_block(self):
)
def __init__(self, component):
- _BlockData.__init__(self, component)
+ BlockData.__init__(self, component)
with self._declare_reserved_components():
self.indicator_var = AutoLinkedBooleanVar()
self.binary_indicator_var = AutoLinkedBinaryVar(self.indicator_var)
@@ -434,23 +434,28 @@ def __init__(self, component):
self._transformation_block = None
def activate(self):
- super(_DisjunctData, self).activate()
+ super(DisjunctData, self).activate()
self.indicator_var.unfix()
def deactivate(self):
- super(_DisjunctData, self).deactivate()
+ super(DisjunctData, self).deactivate()
self.indicator_var.fix(False)
def _deactivate_without_fixing_indicator(self):
- super(_DisjunctData, self).deactivate()
+ super(DisjunctData, self).deactivate()
def _activate_without_unfixing_indicator(self):
- super(_DisjunctData, self).activate()
+ super(DisjunctData, self).activate()
+
+
+class _DisjunctData(metaclass=RenamedClass):
+ __renamed__new_class__ = DisjunctData
+ __renamed__version__ = '6.7.2'
@ModelComponentFactory.register("Disjunctive blocks.")
class Disjunct(Block):
- _ComponentDataClass = _DisjunctData
+ _ComponentDataClass = DisjunctData
def __new__(cls, *args, **kwds):
if cls != Disjunct:
@@ -475,7 +480,7 @@ def __init__(self, *args, **kwargs):
# def _deactivate_without_fixing_indicator(self):
# # Ideally, this would be a super call from this class. However,
# # doing that would trigger a call to deactivate() on all the
- # # _DisjunctData objects (exactly what we want to avoid!)
+ # # DisjunctData objects (exactly what we want to avoid!)
# #
# # For the time being, we will do something bad and directly call
# # the base class method from where we would otherwise want to
@@ -484,7 +489,7 @@ def __init__(self, *args, **kwargs):
def _activate_without_unfixing_indicator(self):
# Ideally, this would be a super call from this class. However,
# doing that would trigger a call to deactivate() on all the
- # _DisjunctData objects (exactly what we want to avoid!)
+ # DisjunctData objects (exactly what we want to avoid!)
#
# For the time being, we will do something bad and directly call
# the base class method from where we would otherwise want to
@@ -495,15 +500,15 @@ def _activate_without_unfixing_indicator(self):
component_data._activate_without_unfixing_indicator()
-class ScalarDisjunct(_DisjunctData, Disjunct):
+class ScalarDisjunct(DisjunctData, Disjunct):
def __init__(self, *args, **kwds):
## FIXME: This is a HACK to get around a chicken-and-egg issue
- ## where _BlockData creates the indicator_var *before*
+ ## where BlockData creates the indicator_var *before*
## Block.__init__ declares the _defer_construction flag.
self._defer_construction = True
self._suppress_ctypes = set()
- _DisjunctData.__init__(self, self)
+ DisjunctData.__init__(self, self)
Disjunct.__init__(self, *args, **kwds)
self._data[None] = self
self._index = UnindexedComponent_index
@@ -524,10 +529,10 @@ def active(self):
return any(d.active for d in self._data.values())
-_DisjunctData._Block_reserved_words = set(dir(Disjunct()))
+DisjunctData._Block_reserved_words = set(dir(Disjunct()))
-class _DisjunctionData(ActiveComponentData):
+class DisjunctionData(ActiveComponentData):
__slots__ = ('disjuncts', 'xor', '_algebraic_constraint', '_transformation_map')
__autoslot_mappers__ = {'_algebraic_constraint': AutoSlots.weakref_mapper}
_NoArgument = (0,)
@@ -542,7 +547,7 @@ def __init__(self, component=None):
#
# These lines represent in-lining of the
# following constructors:
- # - _ConstraintData,
+ # - ConstraintData,
# - ActiveComponentData
# - ComponentData
self._component = weakref_ref(component) if (component is not None) else None
@@ -620,9 +625,14 @@ def set_value(self, expr):
self.disjuncts.append(disjunct)
+class _DisjunctionData(metaclass=RenamedClass):
+ __renamed__new_class__ = DisjunctionData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register("Disjunction expressions.")
class Disjunction(ActiveIndexedComponent):
- _ComponentDataClass = _DisjunctionData
+ _ComponentDataClass = DisjunctionData
def __new__(cls, *args, **kwds):
if cls != Disjunction:
@@ -763,9 +773,9 @@ def _pprint(self):
)
-class ScalarDisjunction(_DisjunctionData, Disjunction):
+class ScalarDisjunction(DisjunctionData, Disjunction):
def __init__(self, *args, **kwds):
- _DisjunctionData.__init__(self, component=self)
+ DisjunctionData.__init__(self, component=self)
Disjunction.__init__(self, *args, **kwds)
self._index = UnindexedComponent_index
@@ -776,7 +786,7 @@ def __init__(self, *args, **kwds):
# currently in place). So during initialization only, we will
# treat them as "indexed" objects where things like
# Constraint.Skip are managed. But after that they will behave
- # like _DisjunctionData objects where set_value does not handle
+ # like DisjunctionData objects where set_value does not handle
# Disjunction.Skip but expects a valid expression or None.
#
diff --git a/pyomo/gdp/plugins/bigm.py b/pyomo/gdp/plugins/bigm.py
index bdd353a6136..d715d913db8 100644
--- a/pyomo/gdp/plugins/bigm.py
+++ b/pyomo/gdp/plugins/bigm.py
@@ -13,6 +13,7 @@
import logging
+from pyomo.common.autoslots import AutoSlots
from pyomo.common.collections import ComponentMap
from pyomo.common.config import ConfigDict, ConfigValue
from pyomo.common.gc_manager import PauseGC
@@ -58,6 +59,26 @@
logger = logging.getLogger('pyomo.gdp.bigm')
+class _BigMData(AutoSlots.Mixin):
+ __slots__ = ('bigm_src',)
+
+ def __init__(self):
+ # we will keep a map of constraints (hashable, ha!) to a tuple to
+ # indicate what their M value is and where it came from, of the form:
+ # ((lower_value, lower_source, lower_key), (upper_value, upper_source,
+ # upper_key)), where the first tuple is the information for the lower M,
+ # the second tuple is the info for the upper M, source is the Suffix or
+ # argument dictionary and None if the value was calculated, and key is
+ # the key in the Suffix or argument dictionary, and None if it was
+ # calculated. (Note that it is possible the lower or upper is
+ # user-specified and the other is not, hence the need to store
+ # information for both.)
+ self.bigm_src = {}
+
+
+Block.register_private_data_initializer(_BigMData)
+
+
@TransformationFactory.register(
'gdp.bigm', doc="Relax disjunctive model using big-M terms."
)
@@ -94,15 +115,8 @@ class BigM_Transformation(GDP_to_MIP_Transformation, _BigM_MixIn):
name beginning "_pyomo_gdp_bigm_reformulation". That Block will
contain an indexed Block named "relaxedDisjuncts", which will hold
the relaxed disjuncts. This block is indexed by an integer
- indicating the order in which the disjuncts were relaxed.
- Each block has a dictionary "_constraintMap":
-
- 'srcConstraints': ComponentMap(:
- )
- 'transformedConstraints': ComponentMap(:
- )
-
- All transformed Disjuncts will have a pointer to the block their transformed
+ indicating the order in which the disjuncts were relaxed. All
+ transformed Disjuncts will have a pointer to the block their transformed
constraints are on, and all transformed Disjunctions will have a
pointer to the corresponding 'Or' or 'ExactlyOne' constraint.
@@ -199,21 +213,15 @@ def _apply_to_impl(self, instance, **kwds):
bigM = self._config.bigM
for t in preprocessed_targets:
if t.ctype is Disjunction:
- self._transform_disjunctionData(
- t,
- t.index(),
- bigM,
- parent_disjunct=gdp_tree.parent(t),
- root_disjunct=gdp_tree.root_disjunct(t),
- )
+ self._transform_disjunctionData(t, t.index(), bigM, gdp_tree)
# issue warnings about anything that was in the bigM args dict that we
# didn't use
_warn_for_unused_bigM_args(bigM, self.used_args, logger)
- def _transform_disjunctionData(
- self, obj, index, bigM, parent_disjunct=None, root_disjunct=None
- ):
+ def _transform_disjunctionData(self, obj, index, bigM, gdp_tree):
+ parent_disjunct = gdp_tree.parent(obj)
+ root_disjunct = gdp_tree.root_disjunct(obj)
(transBlock, xorConstraint) = self._setup_transform_disjunctionData(
obj, root_disjunct
)
@@ -222,13 +230,12 @@ def _transform_disjunctionData(
or_expr = 0
for disjunct in obj.disjuncts:
or_expr += disjunct.binary_indicator_var
- self._transform_disjunct(disjunct, bigM, transBlock)
+ self._transform_disjunct(disjunct, bigM, transBlock, gdp_tree)
- rhs = 1 if parent_disjunct is None else parent_disjunct.binary_indicator_var
if obj.xor:
- xorConstraint[index] = or_expr == rhs
+ xorConstraint[index] = or_expr == 1
else:
- xorConstraint[index] = or_expr >= rhs
+ xorConstraint[index] = or_expr >= 1
# Mark the DisjunctionData as transformed by mapping it to its XOR
# constraint.
obj._algebraic_constraint = weakref_ref(xorConstraint[index])
@@ -236,7 +243,7 @@ def _transform_disjunctionData(
# and deactivate for the writers
obj.deactivate()
- def _transform_disjunct(self, obj, bigM, transBlock):
+ def _transform_disjunct(self, obj, bigM, transBlock, gdp_tree):
# We're not using the preprocessed list here, so this could be
# inactive. We've already done the error checking in preprocessing, so
# we just skip it here.
@@ -248,17 +255,11 @@ def _transform_disjunct(self, obj, bigM, transBlock):
relaxationBlock = self._get_disjunct_transformation_block(obj, transBlock)
- # we will keep a map of constraints (hashable, ha!) to a tuple to
- # indicate what their M value is and where it came from, of the form:
- # ((lower_value, lower_source, lower_key), (upper_value, upper_source,
- # upper_key)), where the first tuple is the information for the lower M,
- # the second tuple is the info for the upper M, source is the Suffix or
- # argument dictionary and None if the value was calculated, and key is
- # the key in the Suffix or argument dictionary, and None if it was
- # calculated. (Note that it is possible the lower or upper is
- # user-specified and the other is not, hence the need to store
- # information for both.)
- relaxationBlock.bigm_src = {}
+ indicator_expression = 0
+ node = obj
+ while node is not None:
+ indicator_expression += 1 - node.binary_indicator_var
+ node = gdp_tree.parent_disjunct(node)
# This is crazy, but if the disjunction has been previously
# relaxed, the disjunct *could* be deactivated. This is a big
@@ -269,18 +270,26 @@ def _transform_disjunct(self, obj, bigM, transBlock):
# comparing the two relaxations.
#
# Transform each component within this disjunct
- self._transform_block_components(obj, obj, bigM, arg_list, suffix_list)
+ self._transform_block_components(
+ obj, obj, bigM, arg_list, suffix_list, indicator_expression
+ )
# deactivate disjunct to keep the writers happy
obj._deactivate_without_fixing_indicator()
def _transform_constraint(
- self, obj, disjunct, bigMargs, arg_list, disjunct_suffix_list
+ self,
+ obj,
+ disjunct,
+ bigMargs,
+ arg_list,
+ disjunct_suffix_list,
+ indicator_expression,
):
# add constraint to the transformation block, we'll transform it there.
transBlock = disjunct._transformation_block()
- bigm_src = transBlock.bigm_src
- constraintMap = transBlock._constraintMap
+ bigm_src = transBlock.private_data().bigm_src
+ constraint_map = transBlock.private_data('pyomo.gdp')
disjunctionRelaxationBlock = transBlock.parent_block()
@@ -347,7 +356,13 @@ def _transform_constraint(
bigm_src[c] = (lower, upper)
self._add_constraint_expressions(
- c, i, M, disjunct.binary_indicator_var, newConstraint, constraintMap
+ c,
+ i,
+ M,
+ disjunct.binary_indicator_var,
+ newConstraint,
+ constraint_map,
+ indicator_expression=indicator_expression,
)
# deactivate because we relaxed
@@ -410,7 +425,7 @@ def _update_M_from_suffixes(self, constraint, suffix_list, lower, upper):
def get_m_value_src(self, constraint):
transBlock = _get_constraint_transBlock(constraint)
((lower_val, lower_source, lower_key), (upper_val, upper_source, upper_key)) = (
- transBlock.bigm_src[constraint]
+ transBlock.private_data().bigm_src[constraint]
)
if (
@@ -465,7 +480,7 @@ def get_M_value_src(self, constraint):
transBlock = _get_constraint_transBlock(constraint)
# This is a KeyError if it fails, but it is also my fault if it
# fails... (That is, it's a bug in the mapping.)
- return transBlock.bigm_src[constraint]
+ return transBlock.private_data().bigm_src[constraint]
def get_M_value(self, constraint):
"""Returns the M values used to transform constraint. Return is a tuple:
@@ -480,7 +495,7 @@ def get_M_value(self, constraint):
transBlock = _get_constraint_transBlock(constraint)
# This is a KeyError if it fails, but it is also my fault if it
# fails... (That is, it's a bug in the mapping.)
- lower, upper = transBlock.bigm_src[constraint]
+ lower, upper = transBlock.private_data().bigm_src[constraint]
return (lower[0], upper[0])
def get_all_M_values_by_constraint(self, model):
@@ -500,9 +515,8 @@ def get_all_M_values_by_constraint(self, model):
# First check if it was transformed at all.
if transBlock is not None:
# If it was transformed with BigM, we get the M values.
- if hasattr(transBlock, 'bigm_src'):
- for cons in transBlock.bigm_src:
- m_values[cons] = self.get_M_value(cons)
+ for cons in transBlock.private_data().bigm_src:
+ m_values[cons] = self.get_M_value(cons)
return m_values
def get_largest_M_value(self, model):
diff --git a/pyomo/gdp/plugins/bigm_mixin.py b/pyomo/gdp/plugins/bigm_mixin.py
index ad6e6dcad86..1c3fcb2c64a 100644
--- a/pyomo/gdp/plugins/bigm_mixin.py
+++ b/pyomo/gdp/plugins/bigm_mixin.py
@@ -232,7 +232,14 @@ def _estimate_M(self, expr, constraint):
return tuple(M)
def _add_constraint_expressions(
- self, c, i, M, indicator_var, newConstraint, constraintMap
+ self,
+ c,
+ i,
+ M,
+ indicator_var,
+ newConstraint,
+ constraint_map,
+ indicator_expression=None,
):
# Since we are both combining components from multiple blocks and using
# local names, we need to make sure that the first index for
@@ -244,6 +251,8 @@ def _add_constraint_expressions(
# over the constraint indices, but I don't think it matters a lot.)
unique = len(newConstraint)
name = c.local_name + "_%s" % unique
+ if indicator_expression is None:
+ indicator_expression = 1 - indicator_var
if c.lower is not None:
if M[0] is None:
@@ -251,25 +260,21 @@ def _add_constraint_expressions(
"Cannot relax disjunctive constraint '%s' "
"because M is not defined." % name
)
- M_expr = M[0] * (1 - indicator_var)
+ M_expr = M[0] * indicator_expression
newConstraint.add((name, i, 'lb'), c.lower <= c.body - M_expr)
- constraintMap['transformedConstraints'][c] = [newConstraint[name, i, 'lb']]
- constraintMap['srcConstraints'][newConstraint[name, i, 'lb']] = c
+ constraint_map.transformed_constraints[c].append(
+ newConstraint[name, i, 'lb']
+ )
+ constraint_map.src_constraint[newConstraint[name, i, 'lb']] = c
if c.upper is not None:
if M[1] is None:
raise GDP_Error(
"Cannot relax disjunctive constraint '%s' "
"because M is not defined." % name
)
- M_expr = M[1] * (1 - indicator_var)
+ M_expr = M[1] * indicator_expression
newConstraint.add((name, i, 'ub'), c.body - M_expr <= c.upper)
- transformed = constraintMap['transformedConstraints'].get(c)
- if transformed is not None:
- constraintMap['transformedConstraints'][c].append(
- newConstraint[name, i, 'ub']
- )
- else:
- constraintMap['transformedConstraints'][c] = [
- newConstraint[name, i, 'ub']
- ]
- constraintMap['srcConstraints'][newConstraint[name, i, 'ub']] = c
+ constraint_map.transformed_constraints[c].append(
+ newConstraint[name, i, 'ub']
+ )
+ constraint_map.src_constraint[newConstraint[name, i, 'ub']] = c
diff --git a/pyomo/gdp/plugins/binary_multiplication.py b/pyomo/gdp/plugins/binary_multiplication.py
index ef4239e09dc..bea33580ed6 100644
--- a/pyomo/gdp/plugins/binary_multiplication.py
+++ b/pyomo/gdp/plugins/binary_multiplication.py
@@ -92,11 +92,10 @@ def _transform_disjunctionData(
or_expr += disjunct.binary_indicator_var
self._transform_disjunct(disjunct, transBlock)
- rhs = 1 if parent_disjunct is None else parent_disjunct.binary_indicator_var
if obj.xor:
- xorConstraint[index] = or_expr == rhs
+ xorConstraint[index] = or_expr == 1
else:
- xorConstraint[index] = or_expr >= rhs
+ xorConstraint[index] = or_expr >= 1
# Mark the DisjunctionData as transformed by mapping it to its XOR
# constraint.
obj._algebraic_constraint = weakref_ref(xorConstraint[index])
@@ -122,7 +121,7 @@ def _transform_disjunct(self, obj, transBlock):
def _transform_constraint(self, obj, disjunct):
# add constraint to the transformation block, we'll transform it there.
transBlock = disjunct._transformation_block()
- constraintMap = transBlock._constraintMap
+ constraint_map = transBlock.private_data('pyomo.gdp')
disjunctionRelaxationBlock = transBlock.parent_block()
@@ -138,14 +137,14 @@ def _transform_constraint(self, obj, disjunct):
continue
self._add_constraint_expressions(
- c, i, disjunct.binary_indicator_var, newConstraint, constraintMap
+ c, i, disjunct.binary_indicator_var, newConstraint, constraint_map
)
# deactivate because we relaxed
c.deactivate()
def _add_constraint_expressions(
- self, c, i, indicator_var, newConstraint, constraintMap
+ self, c, i, indicator_var, newConstraint, constraint_map
):
# Since we are both combining components from multiple blocks and using
# local names, we need to make sure that the first index for
@@ -157,21 +156,21 @@ def _add_constraint_expressions(
# over the constraint indices, but I don't think it matters a lot.)
unique = len(newConstraint)
name = c.local_name + "_%s" % unique
- transformed = constraintMap['transformedConstraints'][c] = []
+ transformed = constraint_map.transformed_constraints[c]
lb, ub = c.lower, c.upper
if (c.equality or lb is ub) and lb is not None:
# equality
newConstraint.add((name, i, 'eq'), (c.body - lb) * indicator_var == 0)
transformed.append(newConstraint[name, i, 'eq'])
- constraintMap['srcConstraints'][newConstraint[name, i, 'eq']] = c
+ constraint_map.src_constraint[newConstraint[name, i, 'eq']] = c
else:
# inequality
if lb is not None:
newConstraint.add((name, i, 'lb'), 0 <= (c.body - lb) * indicator_var)
transformed.append(newConstraint[name, i, 'lb'])
- constraintMap['srcConstraints'][newConstraint[name, i, 'lb']] = c
+ constraint_map.src_constraint[newConstraint[name, i, 'lb']] = c
if ub is not None:
newConstraint.add((name, i, 'ub'), (c.body - ub) * indicator_var <= 0)
transformed.append(newConstraint[name, i, 'ub'])
- constraintMap['srcConstraints'][newConstraint[name, i, 'ub']] = c
+ constraint_map.src_constraint[newConstraint[name, i, 'ub']] = c
diff --git a/pyomo/gdp/plugins/fix_disjuncts.py b/pyomo/gdp/plugins/fix_disjuncts.py
index 44a9d91d513..172363caab7 100644
--- a/pyomo/gdp/plugins/fix_disjuncts.py
+++ b/pyomo/gdp/plugins/fix_disjuncts.py
@@ -52,7 +52,7 @@ class GDP_Disjunct_Fixer(Transformation):
This reclassifies all disjuncts in the passed model instance as ctype Block
and deactivates the constraints and disjunctions within inactive disjuncts.
- In addition, it transforms relvant LogicalConstraints and BooleanVars so
+ In addition, it transforms relevant LogicalConstraints and BooleanVars so
that the resulting model is a (MI)(N)LP (where it is only mixed-integer
if the model contains integer-domain Vars or BooleanVars which were not
indicator_vars of Disjuncs.
diff --git a/pyomo/gdp/plugins/gdp_to_mip_transformation.py b/pyomo/gdp/plugins/gdp_to_mip_transformation.py
index 96d97206c97..8dcd22b292a 100644
--- a/pyomo/gdp/plugins/gdp_to_mip_transformation.py
+++ b/pyomo/gdp/plugins/gdp_to_mip_transformation.py
@@ -11,7 +11,8 @@
from functools import wraps
-from pyomo.common.collections import ComponentMap
+from pyomo.common.autoslots import AutoSlots
+from pyomo.common.collections import ComponentMap, DefaultComponentMap
from pyomo.common.log import is_debug_set
from pyomo.common.modeling import unique_component_name
@@ -48,6 +49,17 @@
from weakref import ref as weakref_ref
+class _GDPTransformationData(AutoSlots.Mixin):
+ __slots__ = ('src_constraint', 'transformed_constraints')
+
+ def __init__(self):
+ self.src_constraint = ComponentMap()
+ self.transformed_constraints = DefaultComponentMap(list)
+
+
+Block.register_private_data_initializer(_GDPTransformationData, scope='pyomo.gdp')
+
+
class GDP_to_MIP_Transformation(Transformation):
"""
Base class for transformations from GDP to MIP
@@ -213,21 +225,26 @@ def _setup_transform_disjunctionData(self, obj, root_disjunct):
"likely indicative of a modeling error." % obj.name
)
- # Create or fetch the transformation block
+ # We always need to create or fetch a transformation block on the parent block.
+ trans_block, new_block = self._add_transformation_block(obj.parent_block())
+ # This is where we put exactly_one/or constraint
+ algebraic_constraint = self._add_xor_constraint(
+ obj.parent_component(), trans_block
+ )
+
+ # If requested, create or fetch the transformation block above the
+ # nested hierarchy
if root_disjunct is not None:
- # We want to put all the transformed things on the root
- # Disjunct's parent's block so that they do not get
- # re-transformed
- transBlock, new_block = self._add_transformation_block(
+ # We want to put some transformed things on the root Disjunct's
+ # parent's block so that they do not get re-transformed. (Note this
+ # is never true for hull, but it calls this method with
+ # root_disjunct=None. BigM can't put the exactly-one constraint up
+ # here, but it can put everything else.)
+ trans_block, new_block = self._add_transformation_block(
root_disjunct.parent_block()
)
- else:
- # This isn't nested--just put it on the parent block.
- transBlock, new_block = self._add_transformation_block(obj.parent_block())
-
- xorConstraint = self._add_xor_constraint(obj.parent_component(), transBlock)
- return transBlock, xorConstraint
+ return trans_block, algebraic_constraint
def _get_disjunct_transformation_block(self, disjunct, transBlock):
if disjunct.transformation_block is not None:
@@ -238,14 +255,7 @@ def _get_disjunct_transformation_block(self, disjunct, transBlock):
relaxationBlock = relaxedDisjuncts[len(relaxedDisjuncts)]
relaxationBlock.transformedConstraints = Constraint(Any)
-
relaxationBlock.localVarReferences = Block()
- # add the map that will link back and forth between transformed
- # constraints and their originals.
- relaxationBlock._constraintMap = {
- 'srcConstraints': ComponentMap(),
- 'transformedConstraints': ComponentMap(),
- }
# add mappings to source disjunct (so we'll know we've relaxed)
disjunct._transformation_block = weakref_ref(relaxationBlock)
diff --git a/pyomo/gdp/plugins/gdp_var_mover.py b/pyomo/gdp/plugins/gdp_var_mover.py
index 5402b576368..7b1df0bb68f 100644
--- a/pyomo/gdp/plugins/gdp_var_mover.py
+++ b/pyomo/gdp/plugins/gdp_var_mover.py
@@ -115,7 +115,7 @@ def _apply_to(self, instance, **kwds):
disjunct_component, Block
)
# HACK: activate the block, but do not activate the
- # _BlockData objects
+ # BlockData objects
super(ActiveIndexedComponent, disjunct_component).activate()
# Deactivate all constraints. Note that we only need to
diff --git a/pyomo/gdp/plugins/hull.py b/pyomo/gdp/plugins/hull.py
index 630560b57f0..854366c0cf0 100644
--- a/pyomo/gdp/plugins/hull.py
+++ b/pyomo/gdp/plugins/hull.py
@@ -11,9 +11,12 @@
import logging
+from collections import defaultdict
+
+from pyomo.common.autoslots import AutoSlots
import pyomo.common.config as cfg
from pyomo.common import deprecated
-from pyomo.common.collections import ComponentMap, ComponentSet
+from pyomo.common.collections import ComponentMap, ComponentSet, DefaultComponentMap
from pyomo.common.modeling import unique_component_name
from pyomo.core.expr.numvalue import ZeroConstant
import pyomo.core.expr as EXPR
@@ -39,6 +42,7 @@
Binary,
)
from pyomo.gdp import Disjunct, Disjunction, GDP_Error
+from pyomo.gdp.disjunct import DisjunctData
from pyomo.gdp.plugins.gdp_to_mip_transformation import GDP_to_MIP_Transformation
from pyomo.gdp.transformed_disjunct import _TransformedDisjunct
from pyomo.gdp.util import (
@@ -47,11 +51,30 @@
_warn_for_active_disjunct,
)
from pyomo.core.util import target_list
+from pyomo.util.vars_from_expressions import get_vars_from_components
from weakref import ref as weakref_ref
logger = logging.getLogger('pyomo.gdp.hull')
+class _HullTransformationData(AutoSlots.Mixin):
+ __slots__ = (
+ 'disaggregated_var_map',
+ 'original_var_map',
+ 'bigm_constraint_map',
+ 'disaggregation_constraint_map',
+ )
+
+ def __init__(self):
+ self.disaggregated_var_map = DefaultComponentMap(ComponentMap)
+ self.original_var_map = ComponentMap()
+ self.bigm_constraint_map = DefaultComponentMap(ComponentMap)
+ self.disaggregation_constraint_map = DefaultComponentMap(ComponentMap)
+
+
+Block.register_private_data_initializer(_HullTransformationData)
+
+
@TransformationFactory.register(
'gdp.hull', doc="Relax disjunctive model by forming the hull reformulation."
)
@@ -76,35 +99,13 @@ class Hull_Reformulation(GDP_to_MIP_Transformation):
list of blocks and Disjunctions [default: the instance]
The transformation will create a new Block with a unique
- name beginning "_pyomo_gdp_hull_reformulation".
- The block will have a dictionary "_disaggregatedVarMap:
- 'srcVar': ComponentMap(:),
- 'disaggregatedVar': ComponentMap(:)
-
- It will also have a ComponentMap "_bigMConstraintMap":
-
- :
-
- Last, it will contain an indexed Block named "relaxedDisjuncts",
- which will hold the relaxed disjuncts. This block is indexed by
- an integer indicating the order in which the disjuncts were relaxed.
- Each block has a dictionary "_constraintMap":
-
- 'srcConstraints': ComponentMap(:
- ),
- 'transformedConstraints':
- ComponentMap( :
- ,
- : [])
-
- All transformed Disjuncts will have a pointer to the block their transformed
- constraints are on, and all transformed Disjunctions will have a
- pointer to the corresponding OR or XOR constraint.
-
- The _pyomo_gdp_hull_reformulation block will have a ComponentMap
- "_disaggregationConstraintMap":
- :ComponentMap(: )
-
+ name beginning "_pyomo_gdp_hull_reformulation". It will contain an
+ indexed Block named "relaxedDisjuncts" that will hold the relaxed
+ disjuncts. This block is indexed by an integer indicating the order
+ in which the disjuncts were relaxed. All transformed Disjuncts will
+ have a pointer to the block their transformed constraints are on,
+ and all transformed Disjunctions will have a pointer to the
+ corresponding OR or XOR constraint.
"""
CONFIG = cfg.ConfigDict('gdp.hull')
@@ -204,33 +205,40 @@ def __init__(self):
super().__init__(logger)
self._targets = set()
- def _add_local_vars(self, block, local_var_dict):
+ def _collect_local_vars_from_block(self, block, local_var_dict):
localVars = block.component('LocalVars')
- if type(localVars) is Suffix:
+ if localVars is not None and localVars.ctype is Suffix:
for disj, var_list in localVars.items():
- if local_var_dict.get(disj) is None:
- local_var_dict[disj] = ComponentSet(var_list)
- else:
- local_var_dict[disj].update(var_list)
-
- def _get_local_var_suffixes(self, block, local_var_dict):
- # You can specify suffixes on any block (disjuncts included). This
- # method starts from a Disjunct (presumably) and checks for a LocalVar
- # suffixes going both up and down the tree, adding them into the
- # dictionary that is the second argument.
-
- # first look beneath where we are (there could be Blocks on this
- # disjunct)
- for b in block.component_data_objects(
- Block, descend_into=(Block), active=True, sort=SortComponents.deterministic
- ):
- self._add_local_vars(b, local_var_dict)
- # now traverse upwards and get what's above
- while block is not None:
- self._add_local_vars(block, local_var_dict)
- block = block.parent_block()
-
- return local_var_dict
+ local_var_dict[disj].update(var_list)
+
+ def _get_user_defined_local_vars(self, targets):
+ user_defined_local_vars = defaultdict(ComponentSet)
+ seen_blocks = set()
+ # we go through the targets looking both up and down the hierarchy, but
+ # we cache what Blocks/Disjuncts we've already looked on so that we
+ # don't duplicate effort.
+ for t in targets:
+ if t.ctype is Disjunct:
+ # first look beneath where we are (there could be Blocks on this
+ # disjunct)
+ for b in t.component_data_objects(
+ Block,
+ descend_into=Block,
+ active=True,
+ sort=SortComponents.deterministic,
+ ):
+ if b not in seen_blocks:
+ self._collect_local_vars_from_block(b, user_defined_local_vars)
+ seen_blocks.add(b)
+ # now look up in the tree
+ blk = t
+ while blk is not None:
+ if blk in seen_blocks:
+ break
+ self._collect_local_vars_from_block(blk, user_defined_local_vars)
+ seen_blocks.add(blk)
+ blk = blk.parent_block()
+ return user_defined_local_vars
def _apply_to(self, instance, **kwds):
try:
@@ -239,7 +247,6 @@ def _apply_to(self, instance, **kwds):
self._restore_state()
self._transformation_blocks.clear()
self._algebraic_constraints.clear()
- self._targets_set = set()
def _apply_to_impl(self, instance, **kwds):
self._process_arguments(instance, **kwds)
@@ -253,16 +260,17 @@ def _apply_to_impl(self, instance, **kwds):
# Preprocess in order to find what disjunctive components need
# transformation
gdp_tree = self._get_gdp_tree_from_targets(instance, targets)
- preprocessed_targets = gdp_tree.topological_sort()
- self._targets_set = set(preprocessed_targets)
+ # Transform from leaf to root: This is important for hull because for
+ # nested GDPs, we will introduce variables that need disaggregating into
+ # parent Disjuncts as we transform their child Disjunctions.
+ preprocessed_targets = gdp_tree.reverse_topological_sort()
+ # Get all LocalVars from Suffixes ahead of time
+ local_vars_by_disjunct = self._get_user_defined_local_vars(preprocessed_targets)
for t in preprocessed_targets:
if t.ctype is Disjunction:
self._transform_disjunctionData(
- t,
- t.index(),
- parent_disjunct=gdp_tree.parent(t),
- root_disjunct=gdp_tree.root_disjunct(t),
+ t, t.index(), gdp_tree.parent(t), local_vars_by_disjunct
)
# We skip disjuncts now, because we need information from the
# disjunctions to transform them (which variables to disaggregate),
@@ -274,23 +282,11 @@ def _add_transformation_block(self, to_block):
return transBlock, new_block
transBlock.lbub = Set(initialize=['lb', 'ub', 'eq'])
- # Map between disaggregated variables and their
- # originals
- transBlock._disaggregatedVarMap = {
- 'srcVar': ComponentMap(),
- 'disaggregatedVar': ComponentMap(),
- }
- # Map between disaggregated variables and their lb*indicator <= var <=
- # ub*indicator constraints
- transBlock._bigMConstraintMap = ComponentMap()
+
# We will store all of the disaggregation constraints for any
# Disjunctions we transform onto this block here.
transBlock.disaggregationConstraints = Constraint(NonNegativeIntegers)
- # This will map from srcVar to a map of srcDisjunction to the
- # disaggregation constraint corresponding to srcDisjunction
- transBlock._disaggregationConstraintMap = ComponentMap()
-
# we are going to store some of the disaggregated vars directly here
# when we have vars that don't appear in every disjunct
transBlock._disaggregatedVars = Var(NonNegativeIntegers, dense=False)
@@ -299,46 +295,55 @@ def _add_transformation_block(self, to_block):
return transBlock, True
def _transform_disjunctionData(
- self, obj, index, parent_disjunct=None, root_disjunct=None
+ self, obj, index, parent_disjunct, local_vars_by_disjunct
):
# Hull reformulation doesn't work if this is an OR constraint. So if
# xor is false, give up
if not obj.xor:
raise GDP_Error(
"Cannot do hull reformulation for "
- "Disjunction '%s' with OR constraint. "
+ "Disjunction '%s' with OR constraint. "
"Must be an XOR!" % obj.name
)
-
+ # collect the Disjuncts we are going to transform now because we will
+ # change their active status when we transform them, but we still need
+ # this list after the fact.
+ active_disjuncts = [disj for disj in obj.disjuncts if disj.active]
+
+ # We put *all* transformed things on the parent Block of this
+ # disjunction. We'll mark the disaggregated Vars as local, but beyond
+ # that, we actually need everything to get transformed again as we go up
+ # the nested hierarchy (if there is one)
transBlock, xorConstraint = self._setup_transform_disjunctionData(
- obj, root_disjunct
+ obj, root_disjunct=None
)
disaggregationConstraint = transBlock.disaggregationConstraints
- disaggregationConstraintMap = transBlock._disaggregationConstraintMap
+ disaggregationConstraintMap = (
+ transBlock.private_data().disaggregation_constraint_map
+ )
disaggregatedVars = transBlock._disaggregatedVars
disaggregated_var_bounds = transBlock._boundsConstraints
- # We first go through and collect all the variables that we
- # are going to disaggregate.
- varOrder_set = ComponentSet()
- varOrder = []
- varsByDisjunct = ComponentMap()
- localVarsByDisjunct = ComponentMap()
- include_fixed_vars = not self._config.assume_fixed_vars_permanent
- for disjunct in obj.disjuncts:
- if not disjunct.active:
- continue
- disjunctVars = varsByDisjunct[disjunct] = ComponentSet()
+ # We first go through and collect all the variables that we are going to
+ # disaggregate. We do this in its own pass because we want to know all
+ # the Disjuncts that each Var appears in since that will tell us exactly
+ # which diaggregated variables we need.
+ var_order = ComponentSet()
+ disjuncts_var_appears_in = ComponentMap()
+ # For each disjunct in the disjunction, we will store a list of Vars
+ # that need a disaggregated counterpart in that disjunct.
+ disjunct_disaggregated_var_map = {}
+ for disjunct in active_disjuncts:
# create the key for each disjunct now
- transBlock._disaggregatedVarMap['disaggregatedVar'][
- disjunct
- ] = ComponentMap()
- for cons in disjunct.component_data_objects(
+ disjunct_disaggregated_var_map[disjunct] = ComponentMap()
+ for var in get_vars_from_components(
+ disjunct,
Constraint,
+ include_fixed=not self._config.assume_fixed_vars_permanent,
active=True,
sort=SortComponents.deterministic,
- descend_into=(Block, Disjunct),
+ descend_into=Block,
):
# [ESJ 02/14/2020] By default, we disaggregate fixed variables
# on the philosophy that fixing is not a promise for the future
@@ -347,189 +352,159 @@ def _transform_disjunctionData(
# with their transformed model. However, the user may have set
# assume_fixed_vars_permanent to True in which case we will skip
# them
- for var in EXPR.identify_variables(
- cons.body, include_fixed=include_fixed_vars
- ):
- # Note the use of a list so that we will
- # eventually disaggregate the vars in a
- # deterministic order (the order that we found
- # them)
- disjunctVars.add(var)
- if not var in varOrder_set:
- varOrder.append(var)
- varOrder_set.add(var)
-
- # check for LocalVars Suffix
- localVarsByDisjunct = self._get_local_var_suffixes(
- disjunct, localVarsByDisjunct
- )
- # We will disaggregate all variables that are not explicitly declared as
- # being local. Since we transform from leaf to root, we are implicitly
- # treating our own disaggregated variables as local, so they will not be
+ # Note that, because ComponentSets are ordered, we will
+ # eventually disaggregate the vars in a deterministic order
+ # (the order that we found them)
+ if var not in var_order:
+ var_order.add(var)
+ disjuncts_var_appears_in[var] = ComponentSet([disjunct])
+ else:
+ disjuncts_var_appears_in[var].add(disjunct)
+
+ # Now, we will disaggregate all variables that are not explicitly
+ # declared as being local. If we are moving up in a nested tree, we have
+ # marked our own disaggregated variables as local, so they will not be
# re-disaggregated.
- varSet = []
- varSet = {disj: [] for disj in obj.disjuncts}
- # Note that variables are local with respect to a Disjunct. We deal with
- # them here to do some error checking (if something is obviously not
- # local since it is used in multiple Disjuncts in this Disjunction) and
- # also to get a deterministic order in which to process them when we
- # transform the Disjuncts: Values of localVarsByDisjunct are
- # ComponentSets, so we need this for determinism (we iterate through the
- # localVars of a Disjunct later)
- localVars = ComponentMap()
- varsToDisaggregate = []
- disjunctsVarAppearsIn = ComponentMap()
- for var in varOrder:
- disjuncts = disjunctsVarAppearsIn[var] = [
- d for d in varsByDisjunct if var in varsByDisjunct[d]
- ]
+ vars_to_disaggregate = {disj: ComponentSet() for disj in obj.disjuncts}
+ all_vars_to_disaggregate = ComponentSet()
+ # We will ignore variables declared as local in a Disjunct that don't
+ # actually appear in any Constraints on that Disjunct, but in order to
+ # do this, we will explicitly collect the set of local_vars in this
+ # loop.
+ local_vars = defaultdict(ComponentSet)
+ for var in var_order:
+ disjuncts = disjuncts_var_appears_in[var]
# clearly not local if used in more than one disjunct
if len(disjuncts) > 1:
if self._generate_debug_messages:
logger.debug(
"Assuming '%s' is not a local var since it is"
- "used in multiple disjuncts."
- % var.getname(fully_qualified=True)
+ "used in multiple disjuncts." % var.name
)
for disj in disjuncts:
- varSet[disj].append(var)
- varsToDisaggregate.append(var)
- # disjuncts is a list of length 1
- elif localVarsByDisjunct.get(disjuncts[0]) is not None:
- if var in localVarsByDisjunct[disjuncts[0]]:
- localVars_thisDisjunct = localVars.get(disjuncts[0])
- if localVars_thisDisjunct is not None:
- localVars[disjuncts[0]].append(var)
- else:
- localVars[disjuncts[0]] = [var]
- else:
- # It's not local to this Disjunct
- varSet[disjuncts[0]].append(var)
- varsToDisaggregate.append(var)
- else:
- # We don't even have have any local vars for this Disjunct.
- varSet[disjuncts[0]].append(var)
- varsToDisaggregate.append(var)
+ vars_to_disaggregate[disj].add(var)
+ all_vars_to_disaggregate.add(var)
+ else: # var only appears in one disjunct
+ disjunct = next(iter(disjuncts))
+ # We check if the user declared it as local
+ if disjunct in local_vars_by_disjunct:
+ if var in local_vars_by_disjunct[disjunct]:
+ local_vars[disjunct].add(var)
+ continue
+ # It's not declared local to this Disjunct, so we
+ # disaggregate
+ vars_to_disaggregate[disjunct].add(var)
+ all_vars_to_disaggregate.add(var)
# Now that we know who we need to disaggregate, we will do it
# while we also transform the disjuncts.
- local_var_set = self._get_local_var_set(obj)
+
+ # Get the list of local variables for the parent Disjunct so that we can
+ # add the disaggregated variables we're about to make to it:
+ parent_local_var_list = self._get_local_var_list(parent_disjunct)
or_expr = 0
for disjunct in obj.disjuncts:
or_expr += disjunct.indicator_var.get_associated_binary()
- self._transform_disjunct(
- disjunct,
- transBlock,
- varSet[disjunct],
- localVars.get(disjunct, []),
- local_var_set,
- )
- rhs = 1 if parent_disjunct is None else parent_disjunct.binary_indicator_var
- xorConstraint.add(index, (or_expr, rhs))
+ if disjunct.active:
+ self._transform_disjunct(
+ obj=disjunct,
+ transBlock=transBlock,
+ vars_to_disaggregate=vars_to_disaggregate[disjunct],
+ local_vars=local_vars[disjunct],
+ parent_local_var_suffix=parent_local_var_list,
+ parent_disjunct_local_vars=local_vars_by_disjunct[parent_disjunct],
+ disjunct_disaggregated_var_map=disjunct_disaggregated_var_map,
+ )
+ xorConstraint.add(index, (or_expr, 1))
# map the DisjunctionData to its XOR constraint to mark it as
# transformed
obj._algebraic_constraint = weakref_ref(xorConstraint[index])
- # add the reaggregation constraints
- for i, var in enumerate(varsToDisaggregate):
+ # Now add the reaggregation constraints
+ for var in all_vars_to_disaggregate:
# There are two cases here: Either the var appeared in every
# disjunct in the disjunction, or it didn't. If it did, there's
# nothing special to do: All of the disaggregated variables have
# been created, and we can just proceed and make this constraint. If
# it didn't, we need one more disaggregated variable, correctly
# defined. And then we can make the constraint.
- if len(disjunctsVarAppearsIn[var]) < len(obj.disjuncts):
+ if len(disjuncts_var_appears_in[var]) < len(active_disjuncts):
# create one more disaggregated var
idx = len(disaggregatedVars)
disaggregated_var = disaggregatedVars[idx]
- # mark this as local because we won't re-disaggregate if this is
- # a nested disjunction
- if local_var_set is not None:
- local_var_set.append(disaggregated_var)
+ # mark this as local because we won't re-disaggregate it if this
+ # is a nested disjunction
+ if parent_local_var_list is not None:
+ parent_local_var_list.append(disaggregated_var)
+ local_vars_by_disjunct[parent_disjunct].add(disaggregated_var)
var_free = 1 - sum(
disj.indicator_var.get_associated_binary()
- for disj in disjunctsVarAppearsIn[var]
+ for disj in disjuncts_var_appears_in[var]
)
self._declare_disaggregated_var_bounds(
- var,
- disaggregated_var,
- obj,
- disaggregated_var_bounds,
- (idx, 'lb'),
- (idx, 'ub'),
- var_free,
+ original_var=var,
+ disaggregatedVar=disaggregated_var,
+ disjunct=obj,
+ bigmConstraint=disaggregated_var_bounds,
+ lb_idx=(idx, 'lb'),
+ ub_idx=(idx, 'ub'),
+ var_free_indicator=var_free,
+ )
+ # Update mappings:
+ var_info = var.parent_block().private_data()
+ disaggregated_var_map = var_info.disaggregated_var_map
+ dis_var_info = disaggregated_var.parent_block().private_data()
+
+ dis_var_info.bigm_constraint_map[disaggregated_var][obj] = Reference(
+ disaggregated_var_bounds[idx, :]
)
- # maintain the mappings
- for disj in obj.disjuncts:
+ dis_var_info.original_var_map[disaggregated_var] = var
+
+ # For every Disjunct the Var does not appear in, we want to map
+ # that this new variable is its disaggreggated variable.
+ for disj in active_disjuncts:
# Because we called _transform_disjunct above, we know that
# if this isn't transformed it is because it was cleanly
# deactivated, and we can just skip it.
if (
disj._transformation_block is not None
- and disj not in disjunctsVarAppearsIn[var]
+ and disj not in disjuncts_var_appears_in[var]
):
- relaxationBlock = disj._transformation_block().parent_block()
- relaxationBlock._bigMConstraintMap[disaggregated_var] = (
- Reference(disaggregated_var_bounds[idx, :])
- )
- relaxationBlock._disaggregatedVarMap['srcVar'][
- disaggregated_var
- ] = var
- relaxationBlock._disaggregatedVarMap['disaggregatedVar'][disj][
- var
- ] = disaggregated_var
+ disaggregated_var_map[disj][var] = disaggregated_var
+ # start the expression for the reaggregation constraint with
+ # this var
disaggregatedExpr = disaggregated_var
else:
disaggregatedExpr = 0
- for disjunct in disjunctsVarAppearsIn[var]:
- if disjunct._transformation_block is None:
- # Because we called _transform_disjunct above, we know that
- # if this isn't transformed it is because it was cleanly
- # deactivated, and we can just skip it.
- continue
+ for disjunct in disjuncts_var_appears_in[var]:
+ disaggregatedExpr += disjunct_disaggregated_var_map[disjunct][var]
- disaggregatedVar = (
- disjunct._transformation_block()
- .parent_block()
- ._disaggregatedVarMap['disaggregatedVar'][disjunct][var]
- )
- disaggregatedExpr += disaggregatedVar
-
- # We equate the sum of the disaggregated vars to var (the original)
- # if parent_disjunct is None, else it needs to be the disaggregated
- # var corresponding to var on the parent disjunct. This is the
- # reason we transform from root to leaf: This constraint is now
- # correct regardless of how nested something may have been.
- parent_var = (
- var
- if parent_disjunct is None
- else self.get_disaggregated_var(var, parent_disjunct)
- )
cons_idx = len(disaggregationConstraint)
- disaggregationConstraint.add(cons_idx, parent_var == disaggregatedExpr)
+ # We always aggregate to the original var. If this is nested, this
+ # constraint will be transformed again. (And if it turns out
+ # everything in it is local, then that transformation won't actually
+ # change the mathematical expression, so it's okay.
+ disaggregationConstraint.add(cons_idx, var == disaggregatedExpr)
# and update the map so that we can find this later. We index by
# variable and the particular disjunction because there is a
# different one for each disjunction
- if disaggregationConstraintMap.get(var) is not None:
- disaggregationConstraintMap[var][obj] = disaggregationConstraint[
- cons_idx
- ]
- else:
- thismap = disaggregationConstraintMap[var] = ComponentMap()
- thismap[obj] = disaggregationConstraint[cons_idx]
+ disaggregationConstraintMap[var][obj] = disaggregationConstraint[cons_idx]
# deactivate for the writers
obj.deactivate()
- def _transform_disjunct(self, obj, transBlock, varSet, localVars, local_var_set):
- # We're not using the preprocessed list here, so this could be
- # inactive. We've already done the error checking in preprocessing, so
- # we just skip it here.
- if not obj.active:
- return
-
+ def _transform_disjunct(
+ self,
+ obj,
+ transBlock,
+ vars_to_disaggregate,
+ local_vars,
+ parent_local_var_suffix,
+ parent_disjunct_local_vars,
+ disjunct_disaggregated_var_map,
+ ):
relaxationBlock = self._get_disjunct_transformation_block(obj, transBlock)
# Put the disaggregated variables all on their own block so that we can
@@ -539,7 +514,7 @@ def _transform_disjunct(self, obj, transBlock, varSet, localVars, local_var_set)
# add the disaggregated variables and their bigm constraints
# to the relaxationBlock
- for var in varSet:
+ for var in vars_to_disaggregate:
disaggregatedVar = Var(within=Reals, initialize=var.value)
# naming conflicts are possible here since this is a bunch
# of variables from different blocks coming together, so we
@@ -550,10 +525,13 @@ def _transform_disjunct(self, obj, transBlock, varSet, localVars, local_var_set)
relaxationBlock.disaggregatedVars.add_component(
disaggregatedVarName, disaggregatedVar
)
- # mark this as local because we won't re-disaggregate if this is a
- # nested disjunction
- if local_var_set is not None:
- local_var_set.append(disaggregatedVar)
+ # mark this as local via the Suffix in case this is a partial
+ # transformation:
+ if parent_local_var_suffix is not None:
+ parent_local_var_suffix.append(disaggregatedVar)
+ # Record that it's local for our own bookkeeping in case we're in a
+ # nested tree in *this* transformation
+ parent_disjunct_local_vars.add(disaggregatedVar)
# add the bigm constraint
bigmConstraint = Constraint(transBlock.lbub)
@@ -562,19 +540,22 @@ def _transform_disjunct(self, obj, transBlock, varSet, localVars, local_var_set)
)
self._declare_disaggregated_var_bounds(
- var,
- disaggregatedVar,
- obj,
- bigmConstraint,
- 'lb',
- 'ub',
- obj.indicator_var.get_associated_binary(),
- transBlock,
+ original_var=var,
+ disaggregatedVar=disaggregatedVar,
+ disjunct=obj,
+ bigmConstraint=bigmConstraint,
+ lb_idx='lb',
+ ub_idx='ub',
+ var_free_indicator=obj.indicator_var.get_associated_binary(),
)
+ # update the bigm constraint mappings
+ data_dict = disaggregatedVar.parent_block().private_data()
+ data_dict.bigm_constraint_map[disaggregatedVar][obj] = bigmConstraint
+ disjunct_disaggregated_var_map[obj][var] = disaggregatedVar
- for var in localVars:
- # we don't need to disaggregated, we can use this Var, but we do
- # need to set up its bounds constraints.
+ for var in local_vars:
+ # we don't need to disaggregate, i.e., we can use this Var, but we
+ # do need to set up its bounds constraints.
# naming conflicts are possible here since this is a bunch
# of variables from different blocks coming together, so we
@@ -585,36 +566,38 @@ def _transform_disjunct(self, obj, transBlock, varSet, localVars, local_var_set)
bigmConstraint = Constraint(transBlock.lbub)
relaxationBlock.add_component(conName, bigmConstraint)
+ parent_block = var.parent_block()
+
self._declare_disaggregated_var_bounds(
- var,
- var,
- obj,
- bigmConstraint,
- 'lb',
- 'ub',
- obj.indicator_var.get_associated_binary(),
- transBlock,
+ original_var=var,
+ disaggregatedVar=var,
+ disjunct=obj,
+ bigmConstraint=bigmConstraint,
+ lb_idx='lb',
+ ub_idx='ub',
+ var_free_indicator=obj.indicator_var.get_associated_binary(),
)
+ # update the bigm constraint mappings
+ data_dict = var.parent_block().private_data()
+ data_dict.bigm_constraint_map[var][obj] = bigmConstraint
+ disjunct_disaggregated_var_map[obj][var] = var
var_substitute_map = dict(
- (id(v), newV)
- for v, newV in transBlock._disaggregatedVarMap['disaggregatedVar'][
- obj
- ].items()
+ (id(v), newV) for v, newV in disjunct_disaggregated_var_map[obj].items()
)
zero_substitute_map = dict(
(id(v), ZeroConstant)
- for v, newV in transBlock._disaggregatedVarMap['disaggregatedVar'][
- obj
- ].items()
+ for v, newV in disjunct_disaggregated_var_map[obj].items()
)
- zero_substitute_map.update((id(v), ZeroConstant) for v in localVars)
# Transform each component within this disjunct
self._transform_block_components(
obj, obj, var_substitute_map, zero_substitute_map
)
+ # Anything that was local to this Disjunct is also local to the parent,
+ # and just got "promoted" up there, so to speak.
+ parent_disjunct_local_vars.update(local_vars)
# deactivate disjunct so writers can be happy
obj._deactivate_without_fixing_indicator()
@@ -627,10 +610,7 @@ def _declare_disaggregated_var_bounds(
lb_idx,
ub_idx,
var_free_indicator,
- transBlock=None,
):
- # If transBlock is None then this is a disaggregated variable for
- # multiple Disjuncts and we will handle the mappings separately.
lb = original_var.lb
ub = original_var.ub
if lb is None or ub is None:
@@ -648,61 +628,39 @@ def _declare_disaggregated_var_bounds(
if ub:
bigmConstraint.add(ub_idx, disaggregatedVar <= ub * var_free_indicator)
+ original_var_info = original_var.parent_block().private_data()
+ disaggregated_var_map = original_var_info.disaggregated_var_map
+ disaggregated_var_info = disaggregatedVar.parent_block().private_data()
+
# store the mappings from variables to their disaggregated selves on
- # the transformation block.
- if transBlock is not None:
- transBlock._disaggregatedVarMap['disaggregatedVar'][disjunct][
- original_var
- ] = disaggregatedVar
- transBlock._disaggregatedVarMap['srcVar'][disaggregatedVar] = original_var
- transBlock._bigMConstraintMap[disaggregatedVar] = bigmConstraint
-
- def _get_local_var_set(self, disjunction):
- # add Suffix to the relaxation block that disaggregated variables are
- # local (in case this is nested in another Disjunct)
- local_var_set = None
- parent_disjunct = disjunction.parent_block()
- while parent_disjunct is not None:
- if parent_disjunct.ctype is Disjunct:
- break
- parent_disjunct = parent_disjunct.parent_block()
+ # the transformation block
+ disaggregated_var_map[disjunct][original_var] = disaggregatedVar
+ disaggregated_var_info.original_var_map[disaggregatedVar] = original_var
+
+ def _get_local_var_list(self, parent_disjunct):
+ # Add or retrieve Suffix from parent_disjunct so that, if this is
+ # nested, we can use it to declare that the disaggregated variables are
+ # local. We return the list so that we can add to it.
+ local_var_list = None
if parent_disjunct is not None:
# This limits the cases that a user is allowed to name something
# (other than a Suffix) 'LocalVars' on a Disjunct. But I am assuming
# that the Suffix has to be somewhere above the disjunct in the
# tree, so I can't put it on a Block that I own. And if I'm coopting
# something of theirs, it may as well be here.
- self._add_local_var_suffix(parent_disjunct)
+ self._get_local_var_suffix(parent_disjunct)
if parent_disjunct.LocalVars.get(parent_disjunct) is None:
parent_disjunct.LocalVars[parent_disjunct] = []
- local_var_set = parent_disjunct.LocalVars[parent_disjunct]
+ local_var_list = parent_disjunct.LocalVars[parent_disjunct]
- return local_var_set
-
- def _warn_for_active_disjunct(
- self, innerdisjunct, outerdisjunct, var_substitute_map, zero_substitute_map
- ):
- # We override the base class method because in hull, it might just be
- # that we haven't gotten here yet.
- disjuncts = (
- innerdisjunct.values() if innerdisjunct.is_indexed() else (innerdisjunct,)
- )
- for disj in disjuncts:
- if disj in self._targets_set:
- # We're getting to this, have some patience.
- continue
- else:
- # But if it wasn't in the targets after preprocessing, it
- # doesn't belong in an active Disjunction that we are
- # transforming and we should be confused.
- _warn_for_active_disjunct(innerdisjunct, outerdisjunct)
+ return local_var_list
def _transform_constraint(
self, obj, disjunct, var_substitute_map, zero_substitute_map
):
# we will put a new transformed constraint on the relaxation block.
relaxationBlock = disjunct._transformation_block()
- constraintMap = relaxationBlock._constraintMap
+ constraint_map = relaxationBlock.private_data('pyomo.gdp')
# We will make indexes from ({obj.local_name} x obj.index_set() x ['lb',
# 'ub']), but don't bother construct that set here, as taking Cartesian
@@ -784,32 +742,32 @@ def _transform_constraint(
# this variable, so I'm going to return
# it. Alternatively we could return an empty list, but I
# think I like this better.
- constraintMap['transformedConstraints'][c] = [v[0]]
+ constraint_map.transformed_constraints[c].append(v[0])
# Reverse map also (this is strange)
- constraintMap['srcConstraints'][v[0]] = c
+ constraint_map.src_constraint[v[0]] = c
continue
newConsExpr = expr - (1 - y) * h_0 == c.lower * y
if obj.is_indexed():
newConstraint.add((name, i, 'eq'), newConsExpr)
- # map the _ConstraintDatas (we mapped the container above)
- constraintMap['transformedConstraints'][c] = [
+ # map the ConstraintDatas (we mapped the container above)
+ constraint_map.transformed_constraints[c].append(
newConstraint[name, i, 'eq']
- ]
- constraintMap['srcConstraints'][newConstraint[name, i, 'eq']] = c
+ )
+ constraint_map.src_constraint[newConstraint[name, i, 'eq']] = c
else:
newConstraint.add((name, 'eq'), newConsExpr)
- # map to the _ConstraintData (And yes, for
+ # map to the ConstraintData (And yes, for
# ScalarConstraints, this is overwriting the map to the
# container we made above, and that is what I want to
# happen. ScalarConstraints will map to lists. For
# IndexedConstraints, we can map the container to the
# container, but more importantly, we are mapping the
- # _ConstraintDatas to each other above)
- constraintMap['transformedConstraints'][c] = [
+ # ConstraintDatas to each other above)
+ constraint_map.transformed_constraints[c].append(
newConstraint[name, 'eq']
- ]
- constraintMap['srcConstraints'][newConstraint[name, 'eq']] = c
+ )
+ constraint_map.src_constraint[newConstraint[name, 'eq']] = c
continue
@@ -824,16 +782,16 @@ def _transform_constraint(
if obj.is_indexed():
newConstraint.add((name, i, 'lb'), newConsExpr)
- constraintMap['transformedConstraints'][c] = [
+ constraint_map.transformed_constraints[c].append(
newConstraint[name, i, 'lb']
- ]
- constraintMap['srcConstraints'][newConstraint[name, i, 'lb']] = c
+ )
+ constraint_map.src_constraint[newConstraint[name, i, 'lb']] = c
else:
newConstraint.add((name, 'lb'), newConsExpr)
- constraintMap['transformedConstraints'][c] = [
+ constraint_map.transformed_constraints[c].append(
newConstraint[name, 'lb']
- ]
- constraintMap['srcConstraints'][newConstraint[name, 'lb']] = c
+ )
+ constraint_map.src_constraint[newConstraint[name, 'lb']] = c
if c.upper is not None:
if self._generate_debug_messages:
@@ -848,29 +806,21 @@ def _transform_constraint(
newConstraint.add((name, i, 'ub'), newConsExpr)
# map (have to account for fact we might have created list
# above
- transformed = constraintMap['transformedConstraints'].get(c)
- if transformed is not None:
- transformed.append(newConstraint[name, i, 'ub'])
- else:
- constraintMap['transformedConstraints'][c] = [
- newConstraint[name, i, 'ub']
- ]
- constraintMap['srcConstraints'][newConstraint[name, i, 'ub']] = c
+ constraint_map.transformed_constraints[c].append(
+ newConstraint[name, i, 'ub']
+ )
+ constraint_map.src_constraint[newConstraint[name, i, 'ub']] = c
else:
newConstraint.add((name, 'ub'), newConsExpr)
- transformed = constraintMap['transformedConstraints'].get(c)
- if transformed is not None:
- transformed.append(newConstraint[name, 'ub'])
- else:
- constraintMap['transformedConstraints'][c] = [
- newConstraint[name, 'ub']
- ]
- constraintMap['srcConstraints'][newConstraint[name, 'ub']] = c
+ constraint_map.transformed_constraints[c].append(
+ newConstraint[name, 'ub']
+ )
+ constraint_map.src_constraint[newConstraint[name, 'ub']] = c
# deactivate now that we have transformed
obj.deactivate()
- def _add_local_var_suffix(self, disjunct):
+ def _get_local_var_suffix(self, disjunct):
# If the Suffix is there, we will borrow it. If not, we make it. If it's
# something else, we complain.
localSuffix = disjunct.component("LocalVars")
@@ -885,7 +835,7 @@ def _add_local_var_suffix(self, disjunct):
% (disjunct.getname(fully_qualified=True), localSuffix.ctype)
)
- def get_disaggregated_var(self, v, disjunct):
+ def get_disaggregated_var(self, v, disjunct, raise_exception=True):
"""
Returns the disaggregated variable corresponding to the Var v and the
Disjunct disjunct.
@@ -899,15 +849,16 @@ def get_disaggregated_var(self, v, disjunct):
"""
if disjunct._transformation_block is None:
raise GDP_Error("Disjunct '%s' has not been transformed" % disjunct.name)
- transBlock = disjunct._transformation_block().parent_block()
- try:
- return transBlock._disaggregatedVarMap['disaggregatedVar'][disjunct][v]
- except:
- logger.error(
- "It does not appear '%s' is a "
- "variable that appears in disjunct '%s'" % (v.name, disjunct.name)
- )
- raise
+ msg = (
+ "It does not appear '%s' is a "
+ "variable that appears in disjunct '%s'" % (v.name, disjunct.name)
+ )
+ disaggregated_var_map = v.parent_block().private_data().disaggregated_var_map
+ if v in disaggregated_var_map[disjunct]:
+ return disaggregated_var_map[disjunct][v]
+ else:
+ if raise_exception:
+ raise GDP_Error(msg)
def get_src_var(self, disaggregated_var):
"""
@@ -916,35 +867,24 @@ def get_src_var(self, disaggregated_var):
Parameters
----------
- disaggregated_var: a Var which was created by the hull
+ disaggregated_var: a Var that was created by the hull
transformation as a disaggregated variable
(and so appears on a transformation block
of some Disjunct)
"""
- msg = (
+ var_map = disaggregated_var.parent_block().private_data()
+ if disaggregated_var in var_map.original_var_map:
+ return var_map.original_var_map[disaggregated_var]
+ raise GDP_Error(
"'%s' does not appear to be a "
"disaggregated variable" % disaggregated_var.name
)
- # There are two possibilities: It is declared on a Disjunct
- # transformation Block, or it is declared on the parent of a Disjunct
- # transformation block (if it is a single variable for multiple
- # Disjuncts the original doesn't appear in)
- transBlock = disaggregated_var.parent_block()
- if not hasattr(transBlock, '_disaggregatedVarMap'):
- try:
- transBlock = transBlock.parent_block().parent_block()
- except:
- logger.error(msg)
- raise
- try:
- return transBlock._disaggregatedVarMap['srcVar'][disaggregated_var]
- except:
- logger.error(msg)
- raise
# retrieves the disaggregation constraint for original_var resulting from
# transforming disjunction
- def get_disaggregation_constraint(self, original_var, disjunction):
+ def get_disaggregation_constraint(
+ self, original_var, disjunction, raise_exception=True
+ ):
"""
Returns the disaggregation (re-aggregation?) constraint
(which links the disaggregated variables to their original)
@@ -957,7 +897,7 @@ def get_disaggregation_constraint(self, original_var, disjunction):
disjunction: a transformed Disjunction containing original_var
"""
for disjunct in disjunction.disjuncts:
- transBlock = disjunct._transformation_block
+ transBlock = disjunct.transformation_block
if transBlock is not None:
break
if transBlock is None:
@@ -968,20 +908,25 @@ def get_disaggregation_constraint(self, original_var, disjunction):
)
try:
- return (
- transBlock()
- .parent_block()
- ._disaggregationConstraintMap[original_var][disjunction]
+ cons = (
+ transBlock.parent_block()
+ .private_data()
+ .disaggregation_constraint_map[original_var][disjunction]
)
except:
- logger.error(
- "It doesn't appear that '%s' is a variable that was "
- "disaggregated by Disjunction '%s'"
- % (original_var.name, disjunction.name)
- )
- raise
+ if raise_exception:
+ logger.error(
+ "It doesn't appear that '%s' is a variable that was "
+ "disaggregated by Disjunction '%s'"
+ % (original_var.name, disjunction.name)
+ )
+ raise
+ return None
+ while not cons.active:
+ cons = self.get_transformed_constraints(cons)[0]
+ return cons
- def get_var_bounds_constraint(self, v):
+ def get_var_bounds_constraint(self, v, disjunct=None):
"""
Returns the IndexedConstraint which sets a disaggregated
variable to be within its bounds when its Disjunct is active and to
@@ -990,28 +935,43 @@ def get_var_bounds_constraint(self, v):
Parameters
----------
- v: a Var which was created by the hull transformation as a
+ v: a Var that was created by the hull transformation as a
disaggregated variable (and so appears on a transformation
block of some Disjunct)
+ disjunct: (For nested Disjunctions) Which Disjunct in the
+ hierarchy the bounds Constraint should correspond to.
+ Optional since for non-nested models this can be inferred.
"""
- msg = (
+ info = v.parent_block().private_data()
+ if v in info.bigm_constraint_map:
+ if len(info.bigm_constraint_map[v]) == 1:
+ # Not nested, or it's at the top layer, so we're fine.
+ return list(info.bigm_constraint_map[v].values())[0]
+ elif disjunct is not None:
+ # This is nested, so we need to walk up to find the active ones
+ return info.bigm_constraint_map[v][disjunct]
+ else:
+ raise ValueError(
+ "It appears that the variable '%s' appears "
+ "within a nested GDP hierarchy, and no "
+ "'disjunct' argument was specified. Please "
+ "specify for which Disjunct the bounds "
+ "constraint for '%s' should be returned." % (v, v)
+ )
+ raise GDP_Error(
"Either '%s' is not a disaggregated variable, or "
"the disjunction that disaggregates it has not "
"been properly transformed." % v.name
)
- # This can only go well if v is a disaggregated var
- transBlock = v.parent_block()
- if not hasattr(transBlock, '_bigMConstraintMap'):
- try:
- transBlock = transBlock.parent_block().parent_block()
- except:
- logger.error(msg)
- raise
- try:
- return transBlock._bigMConstraintMap[v]
- except:
- logger.error(msg)
- raise
+
+ def get_transformed_constraints(self, cons):
+ cons = super().get_transformed_constraints(cons)
+ while not cons[0].active:
+ transformed_cons = []
+ for con in cons:
+ transformed_cons += super().get_transformed_constraints(con)
+ cons = transformed_cons
+ return cons
@TransformationFactory.register(
diff --git a/pyomo/gdp/plugins/multiple_bigm.py b/pyomo/gdp/plugins/multiple_bigm.py
index a2e7d5beeec..4dffd4e9f9a 100644
--- a/pyomo/gdp/plugins/multiple_bigm.py
+++ b/pyomo/gdp/plugins/multiple_bigm.py
@@ -336,8 +336,7 @@ def _transform_disjunctionData(self, obj, index, parent_disjunct, root_disjunct)
for disjunct in active_disjuncts:
or_expr += disjunct.indicator_var.get_associated_binary()
self._transform_disjunct(disjunct, transBlock, active_disjuncts, Ms)
- rhs = 1 if parent_disjunct is None else parent_disjunct.binary_indicator_var
- algebraic_constraint.add(index, (or_expr, rhs))
+ algebraic_constraint.add(index, or_expr == 1)
# map the DisjunctionData to its XOR constraint to mark it as
# transformed
obj._algebraic_constraint = weakref_ref(algebraic_constraint[index])
@@ -360,7 +359,7 @@ def _transform_disjunct(self, obj, transBlock, active_disjuncts, Ms):
def _transform_constraint(self, obj, disjunct, active_disjuncts, Ms):
# we will put a new transformed constraint on the relaxation block.
relaxationBlock = disjunct._transformation_block()
- constraintMap = relaxationBlock._constraintMap
+ constraint_map = relaxationBlock.private_data('pyomo.gdp')
transBlock = relaxationBlock.parent_block()
# Though rare, it is possible to get naming conflicts here
@@ -379,7 +378,7 @@ def _transform_constraint(self, obj, disjunct, active_disjuncts, Ms):
continue
if not self._config.only_mbigm_bound_constraints:
- transformed = []
+ transformed = constraint_map.transformed_constraints[c]
if c.lower is not None:
rhs = sum(
Ms[c, disj][0] * disj.indicator_var.get_associated_binary()
@@ -398,8 +397,7 @@ def _transform_constraint(self, obj, disjunct, active_disjuncts, Ms):
newConstraint.add((i, 'ub'), c.body - c.upper <= rhs)
transformed.append(newConstraint[i, 'ub'])
for c_new in transformed:
- constraintMap['srcConstraints'][c_new] = [c]
- constraintMap['transformedConstraints'][c] = transformed
+ constraint_map.src_constraint[c_new] = [c]
else:
lower = (None, None, None)
upper = (None, None, None)
@@ -428,7 +426,7 @@ def _transform_constraint(self, obj, disjunct, active_disjuncts, Ms):
M,
disjunct.indicator_var.get_associated_binary(),
newConstraint,
- constraintMap,
+ constraint_map,
)
# deactivate now that we have transformed
@@ -497,6 +495,7 @@ def _transform_bound_constraints(self, active_disjuncts, transBlock, Ms):
relaxationBlock = self._get_disjunct_transformation_block(
disj, transBlock
)
+ constraint_map = relaxationBlock.private_data('pyomo.gdp')
if len(lower_dict) > 0:
M = lower_dict.get(disj, None)
if M is None:
@@ -528,39 +527,24 @@ def _transform_bound_constraints(self, active_disjuncts, transBlock, Ms):
idx = i + offset
if len(lower_dict) > 0:
transformed.add((idx, 'lb'), v >= lower_rhs)
- relaxationBlock._constraintMap['srcConstraints'][
- transformed[idx, 'lb']
- ] = []
+ constraint_map.src_constraint[transformed[idx, 'lb']] = []
for c, disj in lower_bound_constraints_by_var[v]:
- relaxationBlock._constraintMap['srcConstraints'][
- transformed[idx, 'lb']
- ].append(c)
- disj.transformation_block._constraintMap['transformedConstraints'][
- c
- ] = [transformed[idx, 'lb']]
+ constraint_map.src_constraint[transformed[idx, 'lb']].append(c)
+ disj.transformation_block.private_data(
+ 'pyomo.gdp'
+ ).transformed_constraints[c].append(transformed[idx, 'lb'])
if len(upper_dict) > 0:
transformed.add((idx, 'ub'), v <= upper_rhs)
- relaxationBlock._constraintMap['srcConstraints'][
- transformed[idx, 'ub']
- ] = []
+ constraint_map.src_constraint[transformed[idx, 'ub']] = []
for c, disj in upper_bound_constraints_by_var[v]:
- relaxationBlock._constraintMap['srcConstraints'][
- transformed[idx, 'ub']
- ].append(c)
+ constraint_map.src_constraint[transformed[idx, 'ub']].append(c)
# might already be here if it had an upper bound
- if (
- c
- in disj.transformation_block._constraintMap[
- 'transformedConstraints'
- ]
- ):
- disj.transformation_block._constraintMap[
- 'transformedConstraints'
- ][c].append(transformed[idx, 'ub'])
- else:
- disj.transformation_block._constraintMap[
- 'transformedConstraints'
- ][c] = [transformed[idx, 'ub']]
+ disj_constraint_map = disj.transformation_block.private_data(
+ 'pyomo.gdp'
+ )
+ disj_constraint_map.transformed_constraints[c].append(
+ transformed[idx, 'ub']
+ )
return transformed_constraints
diff --git a/pyomo/gdp/tests/common_tests.py b/pyomo/gdp/tests/common_tests.py
index e6d38ef1502..50bc8b05f86 100644
--- a/pyomo/gdp/tests/common_tests.py
+++ b/pyomo/gdp/tests/common_tests.py
@@ -30,7 +30,7 @@
from pyomo.gdp import Disjunct, Disjunction, GDP_Error
from pyomo.core.expr.compare import assertExpressionsEqual
from pyomo.core.base import constraint, ComponentUID
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.repn import generate_standard_repn
import pyomo.core.expr as EXPR
import pyomo.gdp.tests.models as models
@@ -425,12 +425,7 @@ def check_two_term_disjunction_xor(self, xor, disj1, disj2):
assertExpressionsEqual(
self,
xor.body,
- EXPR.LinearExpression(
- [
- EXPR.MonomialTermExpression((1, disj1.binary_indicator_var)),
- EXPR.MonomialTermExpression((1, disj2.binary_indicator_var)),
- ]
- ),
+ EXPR.LinearExpression([disj1.binary_indicator_var, disj2.binary_indicator_var]),
)
self.assertEqual(xor.lower, 1)
self.assertEqual(xor.upper, 1)
@@ -697,32 +692,29 @@ def check_indexedDisj_only_targets_transformed(self, transformation):
trans.get_transformed_constraints(m.disjunct1[1, 0].c)[0]
.parent_block()
.parent_block(),
- disjBlock[2],
+ disjBlock[0],
)
self.assertIs(
trans.get_transformed_constraints(m.disjunct1[1, 1].c)[0].parent_block(),
- disjBlock[3],
+ disjBlock[1],
)
# In the disaggregated var bounds
self.assertIs(
trans.get_transformed_constraints(m.disjunct1[2, 0].c)[0]
.parent_block()
.parent_block(),
- disjBlock[0],
+ disjBlock[2],
)
self.assertIs(
trans.get_transformed_constraints(m.disjunct1[2, 1].c)[0].parent_block(),
- disjBlock[1],
+ disjBlock[3],
)
# This relies on the disjunctions being transformed in the same order
# every time. These are the mappings between the indices of the original
# disjuncts and the indices on the indexed block on the transformation
# block.
- if transformation == 'bigm':
- pairs = [((1, 0), 0), ((1, 1), 1), ((2, 0), 2), ((2, 1), 3)]
- elif transformation == 'hull':
- pairs = [((2, 0), 0), ((2, 1), 1), ((1, 0), 2), ((1, 1), 3)]
+ pairs = [((1, 0), 0), ((1, 1), 1), ((2, 0), 2), ((2, 1), 3)]
for i, j in pairs:
self.assertIs(trans.get_src_disjunct(disjBlock[j]), m.disjunct1[i])
@@ -960,9 +952,7 @@ def check_disjunction_data_target(self, transformation):
transBlock = m.component("_pyomo_gdp_%s_reformulation" % transformation)
self.assertIsInstance(transBlock, Block)
self.assertIsInstance(transBlock.component("disjunction_xor"), Constraint)
- self.assertIsInstance(
- transBlock.disjunction_xor[2], constraint._GeneralConstraintData
- )
+ self.assertIsInstance(transBlock.disjunction_xor[2], constraint.ConstraintData)
self.assertIsInstance(transBlock.component("relaxedDisjuncts"), Block)
self.assertEqual(len(transBlock.relaxedDisjuncts), 3)
@@ -971,7 +961,7 @@ def check_disjunction_data_target(self, transformation):
m, targets=[m.disjunction[1]]
)
self.assertIsInstance(
- m.disjunction[1].algebraic_constraint, constraint._GeneralConstraintData
+ m.disjunction[1].algebraic_constraint, constraint.ConstraintData
)
transBlock = m.component("_pyomo_gdp_%s_reformulation_4" % transformation)
self.assertIsInstance(transBlock, Block)
@@ -1712,26 +1702,78 @@ def check_all_components_transformed(self, m):
# makeNestedDisjunctions_NestedDisjuncts model.
self.assertIsInstance(m.disj.algebraic_constraint, Constraint)
self.assertIsInstance(m.d1.disj2.algebraic_constraint, Constraint)
- self.assertIsInstance(m.d1.transformation_block, _BlockData)
- self.assertIsInstance(m.d2.transformation_block, _BlockData)
- self.assertIsInstance(m.d1.d3.transformation_block, _BlockData)
- self.assertIsInstance(m.d1.d4.transformation_block, _BlockData)
+ self.assertIsInstance(m.d1.transformation_block, BlockData)
+ self.assertIsInstance(m.d2.transformation_block, BlockData)
+ self.assertIsInstance(m.d1.d3.transformation_block, BlockData)
+ self.assertIsInstance(m.d1.d4.transformation_block, BlockData)
def check_transformation_blocks_nestedDisjunctions(self, m, transformation):
disjunctionTransBlock = m.disj.algebraic_constraint.parent_block()
transBlocks = disjunctionTransBlock.relaxedDisjuncts
- self.assertEqual(len(transBlocks), 4)
if transformation == 'bigm':
+ self.assertEqual(len(transBlocks), 4)
self.assertIs(transBlocks[0], m.d1.d3.transformation_block)
self.assertIs(transBlocks[1], m.d1.d4.transformation_block)
self.assertIs(transBlocks[2], m.d1.transformation_block)
self.assertIs(transBlocks[3], m.d2.transformation_block)
if transformation == 'hull':
- self.assertIs(transBlocks[2], m.d1.d3.transformation_block)
- self.assertIs(transBlocks[3], m.d1.d4.transformation_block)
- self.assertIs(transBlocks[0], m.d1.transformation_block)
- self.assertIs(transBlocks[1], m.d2.transformation_block)
+ # This is a much more comprehensive test that doesn't depend on
+ # transformation Block structure, so just reuse it:
+ hull = TransformationFactory('gdp.hull')
+ d3 = hull.get_disaggregated_var(m.d1.d3.binary_indicator_var, m.d1)
+ d4 = hull.get_disaggregated_var(m.d1.d4.binary_indicator_var, m.d1)
+ self.check_transformed_model_nestedDisjuncts(m, d3, d4)
+
+ # Check the 4 constraints that are unique to the case where we didn't
+ # declare d1.d3 and d1.d4 as local
+ d32 = hull.get_disaggregated_var(m.d1.d3.binary_indicator_var, m.d2)
+ d42 = hull.get_disaggregated_var(m.d1.d4.binary_indicator_var, m.d2)
+ # check the additional disaggregated indicator var bound constraints
+ cons = hull.get_var_bounds_constraint(d32)
+ self.assertEqual(len(cons), 1)
+ check_obj_in_active_tree(self, cons['ub'])
+ cons_expr = self.simplify_leq_cons(cons['ub'])
+ # Note that this comes out as d32 <= 1 - d1.ind_var because it's the
+ # "extra" disaggregated var that gets created when it need to be
+ # disaggregated for d1, but it's not used in d2
+ assertExpressionsEqual(
+ self, cons_expr, d32 + m.d1.binary_indicator_var - 1 <= 0.0
+ )
+
+ cons = hull.get_var_bounds_constraint(d42)
+ self.assertEqual(len(cons), 1)
+ check_obj_in_active_tree(self, cons['ub'])
+ cons_expr = self.simplify_leq_cons(cons['ub'])
+ # Note that this comes out as d42 <= 1 - d1.ind_var because it's the
+ # "extra" disaggregated var that gets created when it need to be
+ # disaggregated for d1, but it's not used in d2
+ assertExpressionsEqual(
+ self, cons_expr, d42 + m.d1.binary_indicator_var - 1 <= 0.0
+ )
+ # check the aggregation constraints for the disaggregated indicator vars
+ cons = hull.get_disaggregation_constraint(m.d1.d3.binary_indicator_var, m.disj)
+ check_obj_in_active_tree(self, cons)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(
+ self, cons_expr, m.d1.d3.binary_indicator_var - d32 - d3 == 0.0
+ )
+ cons = hull.get_disaggregation_constraint(m.d1.d4.binary_indicator_var, m.disj)
+ check_obj_in_active_tree(self, cons)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(
+ self, cons_expr, m.d1.d4.binary_indicator_var - d42 - d4 == 0.0
+ )
+
+ num_cons = len(
+ list(m.component_data_objects(Constraint, active=True, descend_into=Block))
+ )
+ # 30 total constraints in transformed model minus 10 trivial bounds
+ # (lower bounds of 0) gives us 20 constraints total:
+ self.assertEqual(num_cons, 20)
+ # (And this is 4 more than we test in
+ # self.check_transformed_model_nestedDisjuncts, so that's comforting
+ # too.)
def check_nested_disjunction_target(self, transformation):
@@ -1895,3 +1937,17 @@ def check_nested_disjuncts_in_flat_gdp(self, transformation):
for t in m.T:
self.assertTrue(value(m.disj1[t].indicator_var))
self.assertTrue(value(m.disj1[t].sub1.indicator_var))
+
+
+def check_do_not_assume_nested_indicators_local(self, transformation):
+ m = models.why_indicator_vars_are_not_always_local()
+ TransformationFactory(transformation).apply_to(m)
+
+ results = SolverFactory('gurobi').solve(m)
+ self.assertEqual(results.solver.termination_condition, TerminationCondition.optimal)
+ self.assertAlmostEqual(value(m.obj), 9)
+ self.assertAlmostEqual(value(m.x), 9)
+ self.assertTrue(value(m.Y2.indicator_var))
+ self.assertFalse(value(m.Y1.indicator_var))
+ self.assertTrue(value(m.Z1.indicator_var))
+ self.assertTrue(value(m.Z1.indicator_var))
diff --git a/pyomo/gdp/tests/jobshop_large_hull.lp b/pyomo/gdp/tests/jobshop_large_hull.lp
index df3833bdee3..f0a9d3ccbf0 100644
--- a/pyomo/gdp/tests/jobshop_large_hull.lp
+++ b/pyomo/gdp/tests/jobshop_large_hull.lp
@@ -42,75 +42,75 @@ c_u_Feas(G)_:
<= -17
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(0)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(G)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(1)_:
-+1 t(F)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(F)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(2)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(G)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(3)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(E)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(4)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(G)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(5)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(E)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(6)_:
-+1 t(F)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(F)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(7)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(E)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(8)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(G)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(9)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(D)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(10)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(G)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(11)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(D)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(12)_:
@@ -120,9 +120,9 @@ c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(12)_:
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(13)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(D)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(14)_:
@@ -132,81 +132,81 @@ c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(14)_:
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(15)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(D)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(16)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(E)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(17)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(D)_
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(A)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(18)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(E)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(19)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(D)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(20)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(G)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(21)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(C)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(22)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(G)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(23)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(C)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(24)_:
-+1 t(F)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(F)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(25)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(C)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(26)_:
-+1 t(F)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(F)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(27)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(C)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(28)_:
@@ -216,33 +216,33 @@ c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(28)_:
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(29)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(C)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(30)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(D)_
++1 t(F)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(F)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(31)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(C)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(32)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(D)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(33)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(C)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(34)_:
@@ -258,27 +258,27 @@ c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(35)_:
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(36)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(G)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(37)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(B)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(38)_:
-+1 t(F)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(F)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(39)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(B)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(40)_:
@@ -288,81 +288,81 @@ c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(40)_:
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(41)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(B)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(42)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(E)_
++1 t(F)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(F)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(43)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(B)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(44)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(E)_
++1 t(F)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(F)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(45)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(B)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(46)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(D)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(47)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(B)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(48)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(D)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(49)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(B)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(50)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(C)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(51)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(B)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(52)_:
-+1 t(G)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(G)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(53)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(A)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(54)_:
@@ -372,9 +372,9 @@ c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(54)_:
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(55)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(A)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(56)_:
@@ -384,81 +384,81 @@ c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(56)_:
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(57)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(A)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(58)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(E)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(59)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(A)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(60)_:
-+1 t(E)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(E)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(61)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(A)_
++1 t(D)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(D)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(62)_:
-+1 t(D)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(D)_
++1 t(F)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(F)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(63)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(A)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(64)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(C)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(65)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(A)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(66)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(B)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(67)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(A)_
++1 t(E)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(E)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(68)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(B)_
++1 t(G)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(G)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(69)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(A)_
++1 t(F)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(F)_
= 0
c_e__pyomo_gdp_hull_reformulation_disj_xor(A_B_3)_:
@@ -637,546 +637,544 @@ c_e__pyomo_gdp_hull_reformulation_disj_xor(F_G_4)_:
= 1
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(F)_
-+6.0 NoClash(F_G_4_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(A)_
++4.0 NoClash(A_B_3_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(G)_
--92 NoClash(F_G_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_
+-92 NoClash(A_B_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(F)_
--92 NoClash(F_G_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(A)_
+-92 NoClash(A_B_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(F)_
-+6.0 NoClash(F_G_4_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(A)_
++5.0 NoClash(A_B_3_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(G)_
--92 NoClash(F_G_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_
+-92 NoClash(A_B_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(F)_
--92 NoClash(F_G_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(A)_
+-92 NoClash(A_B_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(E)_
-+7.0 NoClash(E_G_5_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(A)_
++2.0 NoClash(A_B_5_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(G)_
--92 NoClash(E_G_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(B)_
+-92 NoClash(A_B_5_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(E)_
--92 NoClash(E_G_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(A)_
+-92 NoClash(A_B_5_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(E)_
--1 NoClash(E_G_5_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(B)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(A)_
++3.0 NoClash(A_B_5_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(G)_
--92 NoClash(E_G_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(B)_
+-92 NoClash(A_B_5_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(E)_
--92 NoClash(E_G_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(A)_
+-92 NoClash(A_B_5_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(E)_
-+8.0 NoClash(E_G_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(A)_
++6.0 NoClash(A_C_1_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(G)_
--92 NoClash(E_G_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(C)_
+-92 NoClash(A_C_1_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(E)_
--92 NoClash(E_G_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(A)_
+-92 NoClash(A_C_1_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(E)_
-+4.0 NoClash(E_G_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(C)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(A)_
++3.0 NoClash(A_C_1_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(G)_
--92 NoClash(E_G_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(C)_
+-92 NoClash(A_C_1_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(E)_
--92 NoClash(E_G_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(A)_
+-92 NoClash(A_C_1_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(E)_
-+3.0 NoClash(E_F_3_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(A)_
++10.0 NoClash(A_D_3_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(F)_
--92 NoClash(E_F_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(D)_
+-92 NoClash(A_D_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(E)_
--92 NoClash(E_F_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(A)_
+-92 NoClash(A_D_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(F)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(E)_
-+8.0 NoClash(E_F_3_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(D)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(A)_
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(F)_
--92 NoClash(E_F_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(D)_
+-92 NoClash(A_D_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(E)_
--92 NoClash(E_F_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(A)_
+-92 NoClash(A_D_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(D)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(A)_
++7.0 NoClash(A_E_3_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(G)_
--92 NoClash(D_G_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(E)_
+-92 NoClash(A_E_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(D)_
--92 NoClash(D_G_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(A)_
+-92 NoClash(A_E_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(D)_
-+6.0 NoClash(D_G_4_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(E)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(A)_
++4.0 NoClash(A_E_3_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(G)_
--92 NoClash(D_G_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(E)_
+-92 NoClash(A_E_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(D)_
--92 NoClash(D_G_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(A)_
+-92 NoClash(A_E_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(D)_
-+8.0 NoClash(D_G_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(A)_
++4.0 NoClash(A_E_5_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(G)_
--92 NoClash(D_G_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(E)_
+-92 NoClash(A_E_5_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(D)_
--92 NoClash(D_G_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(A)_
+-92 NoClash(A_E_5_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(D)_
-+8.0 NoClash(D_G_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(E)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(A)_
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(G)_
--92 NoClash(D_G_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(E)_
+-92 NoClash(A_E_5_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(D)_
--92 NoClash(D_G_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(A)_
+-92 NoClash(A_E_5_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_transformedConstraints(c_0_ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(D)_
-+1 NoClash(D_F_4_0)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(A)_
++2.0 NoClash(A_F_1_0)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)__t(F)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(F)_
--92 NoClash(D_F_4_0)_binary_indicator_var
+-92 NoClash(A_F_1_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(D)_
--92 NoClash(D_F_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(A)_
+-92 NoClash(A_F_1_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_transformedConstraints(c_0_ub)_:
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(F)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(D)_
-+7.0 NoClash(D_F_4_1)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(A)_
++3.0 NoClash(A_F_1_1)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)__t(F)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(F)_
--92 NoClash(D_F_4_1)_binary_indicator_var
+-92 NoClash(A_F_1_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(D)_
--92 NoClash(D_F_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(A)_
+-92 NoClash(A_F_1_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_transformedConstraints(c_0_ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(D)_
--1 NoClash(D_F_3_0)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(A)_
++4.0 NoClash(A_F_3_0)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)__t(F)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(F)_
--92 NoClash(D_F_3_0)_binary_indicator_var
+-92 NoClash(A_F_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(D)_
--92 NoClash(D_F_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(A)_
+-92 NoClash(A_F_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_transformedConstraints(c_0_ub)_:
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(F)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(D)_
-+11.0 NoClash(D_F_3_1)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(A)_
++6.0 NoClash(A_F_3_1)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)__t(F)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(F)_
--92 NoClash(D_F_3_1)_binary_indicator_var
+-92 NoClash(A_F_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(D)_
--92 NoClash(D_F_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(A)_
+-92 NoClash(A_F_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(D)_
-+2.0 NoClash(D_E_3_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(A)_
++9.0 NoClash(A_G_5_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(E)_
--92 NoClash(D_E_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(G)_
+-92 NoClash(A_G_5_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(D)_
--92 NoClash(D_E_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(A)_
+-92 NoClash(A_G_5_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(E)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(D)_
-+9.0 NoClash(D_E_3_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(A)_
+-3.0 NoClash(A_G_5_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(E)_
--92 NoClash(D_E_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(G)_
+-92 NoClash(A_G_5_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(D)_
--92 NoClash(D_E_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(A)_
+-92 NoClash(A_G_5_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(D)_
-+4.0 NoClash(D_E_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(B)_
++9.0 NoClash(B_C_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(E)_
--92 NoClash(D_E_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(C)_
+-92 NoClash(B_C_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(D)_
--92 NoClash(D_E_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(B)_
+-92 NoClash(B_C_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(E)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(D)_
-+8.0 NoClash(D_E_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(C)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(B)_
+-3.0 NoClash(B_C_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(E)_
--92 NoClash(D_E_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(C)_
+-92 NoClash(B_C_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(D)_
--92 NoClash(D_E_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(B)_
+-92 NoClash(B_C_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(C)_
-+4.0 NoClash(C_G_4_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(B)_
++8.0 NoClash(B_D_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(G)_
--92 NoClash(C_G_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(D)_
+-92 NoClash(B_D_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(C)_
--92 NoClash(C_G_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(B)_
+-92 NoClash(B_D_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(C)_
-+7.0 NoClash(C_G_4_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(D)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(B)_
++3.0 NoClash(B_D_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(G)_
--92 NoClash(C_G_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(D)_
+-92 NoClash(B_D_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(C)_
--92 NoClash(C_G_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(B)_
+-92 NoClash(B_D_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(C)_
-+2.0 NoClash(C_G_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(B)_
++10.0 NoClash(B_D_3_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(G)_
--92 NoClash(C_G_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(D)_
+-92 NoClash(B_D_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(C)_
--92 NoClash(C_G_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(B)_
+-92 NoClash(B_D_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(C)_
-+9.0 NoClash(C_G_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(D)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(B)_
+-1 NoClash(B_D_3_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(G)_
--92 NoClash(C_G_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(D)_
+-92 NoClash(B_D_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(C)_
--92 NoClash(C_G_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(B)_
+-92 NoClash(B_D_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(C)_
-+5.0 NoClash(C_F_4_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(B)_
++4.0 NoClash(B_E_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(F)_
--92 NoClash(C_F_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(E)_
+-92 NoClash(B_E_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(C)_
--92 NoClash(C_F_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(B)_
+-92 NoClash(B_E_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(F)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(C)_
-+8.0 NoClash(C_F_4_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(E)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(B)_
++3.0 NoClash(B_E_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(F)_
--92 NoClash(C_F_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(E)_
+-92 NoClash(B_E_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(C)_
--92 NoClash(C_F_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(B)_
+-92 NoClash(B_E_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(C)_
-+2.0 NoClash(C_F_1_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(B)_
++7.0 NoClash(B_E_3_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(F)_
--92 NoClash(C_F_1_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(E)_
+-92 NoClash(B_E_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(C)_
--92 NoClash(C_F_1_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(B)_
+-92 NoClash(B_E_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(F)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(C)_
-+6.0 NoClash(C_F_1_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(E)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(B)_
++3.0 NoClash(B_E_3_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(F)_
--92 NoClash(C_F_1_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(E)_
+-92 NoClash(B_E_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(C)_
--92 NoClash(C_F_1_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(B)_
+-92 NoClash(B_E_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_transformedConstraints(c_0_ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(C)_
--2.0 NoClash(C_E_2_0)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(B)_
++5.0 NoClash(B_E_5_0)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)__t(E)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(E)_
--92 NoClash(C_E_2_0)_binary_indicator_var
+-92 NoClash(B_E_5_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(C)_
--92 NoClash(C_E_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(B)_
+-92 NoClash(B_E_5_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_transformedConstraints(c_0_ub)_:
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(E)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(C)_
-+9.0 NoClash(C_E_2_1)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(B)_
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)__t(E)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(E)_
--92 NoClash(C_E_2_1)_binary_indicator_var
+-92 NoClash(B_E_5_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(C)_
--92 NoClash(C_E_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(B)_
+-92 NoClash(B_E_5_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(C)_
-+5.0 NoClash(C_D_4_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(B)_
++4.0 NoClash(B_F_3_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(D)_
--92 NoClash(C_D_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(F)_
+-92 NoClash(B_F_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(C)_
--92 NoClash(C_D_4_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(B)_
+-92 NoClash(B_F_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(D)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(C)_
-+2.0 NoClash(C_D_4_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(F)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(B)_
++5.0 NoClash(B_F_3_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(D)_
--92 NoClash(C_D_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(F)_
+-92 NoClash(B_F_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(C)_
--92 NoClash(C_D_4_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(B)_
+-92 NoClash(B_F_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(C)_
-+2.0 NoClash(C_D_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(B)_
++8.0 NoClash(B_G_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(D)_
--92 NoClash(C_D_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(G)_
+-92 NoClash(B_G_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(C)_
--92 NoClash(C_D_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(B)_
+-92 NoClash(B_G_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(D)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(C)_
-+9.0 NoClash(C_D_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(B)_
++3.0 NoClash(B_G_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(D)_
--92 NoClash(C_D_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(G)_
+-92 NoClash(B_G_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(C)_
--92 NoClash(C_D_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(B)_
+-92 NoClash(B_G_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(34)_transformedConstraints(c_0_ub)_:
@@ -1212,544 +1210,546 @@ c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(35)__t(B)_bounds_(ub)_:
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(B)_
-+8.0 NoClash(B_G_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(C)_
++2.0 NoClash(C_D_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(G)_
--92 NoClash(B_G_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(D)_
+-92 NoClash(C_D_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(B)_
--92 NoClash(B_G_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(C)_
+-92 NoClash(C_D_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(B)_
-+3.0 NoClash(B_G_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(D)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(C)_
++9.0 NoClash(C_D_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(G)_
--92 NoClash(B_G_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(D)_
+-92 NoClash(C_D_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(B)_
--92 NoClash(B_G_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(C)_
+-92 NoClash(C_D_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(B)_
-+4.0 NoClash(B_F_3_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(D)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(C)_
++5.0 NoClash(C_D_4_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(F)_
--92 NoClash(B_F_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(D)_
+-92 NoClash(C_D_4_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(B)_
--92 NoClash(B_F_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(C)_
+-92 NoClash(C_D_4_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(F)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(B)_
-+5.0 NoClash(B_F_3_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(D)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(C)_
++2.0 NoClash(C_D_4_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)__t(F)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(F)_
--92 NoClash(B_F_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(D)_
+-92 NoClash(C_D_4_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(B)_
--92 NoClash(B_F_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(C)_
+-92 NoClash(C_D_4_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_transformedConstraints(c_0_ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(B)_
-+5.0 NoClash(B_E_5_0)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(C)_
+-2.0 NoClash(C_E_2_0)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)__t(E)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(E)_
--92 NoClash(B_E_5_0)_binary_indicator_var
+-92 NoClash(C_E_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(B)_
--92 NoClash(B_E_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(C)_
+-92 NoClash(C_E_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_transformedConstraints(c_0_ub)_:
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(E)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(B)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(C)_
++9.0 NoClash(C_E_2_1)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)__t(E)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(E)_
--92 NoClash(B_E_5_1)_binary_indicator_var
+-92 NoClash(C_E_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(B)_
--92 NoClash(B_E_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(C)_
+-92 NoClash(C_E_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(B)_
-+7.0 NoClash(B_E_3_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(C)_
++2.0 NoClash(C_F_1_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(E)_
--92 NoClash(B_E_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(F)_
+-92 NoClash(C_F_1_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(B)_
--92 NoClash(B_E_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(C)_
+-92 NoClash(C_F_1_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(E)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(B)_
-+3.0 NoClash(B_E_3_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(F)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(C)_
++6.0 NoClash(C_F_1_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(E)_
--92 NoClash(B_E_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(F)_
+-92 NoClash(C_F_1_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(B)_
--92 NoClash(B_E_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(C)_
+-92 NoClash(C_F_1_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(B)_
-+4.0 NoClash(B_E_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(C)_
++5.0 NoClash(C_F_4_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(E)_
--92 NoClash(B_E_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(F)_
+-92 NoClash(C_F_4_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(B)_
--92 NoClash(B_E_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(C)_
+-92 NoClash(C_F_4_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(E)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(B)_
-+3.0 NoClash(B_E_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(F)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(C)_
++8.0 NoClash(C_F_4_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(E)_
--92 NoClash(B_E_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(F)_
+-92 NoClash(C_F_4_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(B)_
--92 NoClash(B_E_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(C)_
+-92 NoClash(C_F_4_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(B)_
-+10.0 NoClash(B_D_3_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(C)_
++2.0 NoClash(C_G_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(D)_
--92 NoClash(B_D_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(G)_
+-92 NoClash(C_G_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(B)_
--92 NoClash(B_D_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(C)_
+-92 NoClash(C_G_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(D)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(B)_
--1 NoClash(B_D_3_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(C)_
++9.0 NoClash(C_G_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(D)_
--92 NoClash(B_D_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(G)_
+-92 NoClash(C_G_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(B)_
--92 NoClash(B_D_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(C)_
+-92 NoClash(C_G_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(B)_
-+8.0 NoClash(B_D_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(C)_
++4.0 NoClash(C_G_4_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(D)_
--92 NoClash(B_D_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(G)_
+-92 NoClash(C_G_4_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(B)_
--92 NoClash(B_D_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(C)_
+-92 NoClash(C_G_4_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(D)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(B)_
-+3.0 NoClash(B_D_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(C)_
++7.0 NoClash(C_G_4_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(D)_
--92 NoClash(B_D_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(G)_
+-92 NoClash(C_G_4_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(B)_
--92 NoClash(B_D_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(C)_
+-92 NoClash(C_G_4_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(B)_
-+9.0 NoClash(B_C_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(D)_
++4.0 NoClash(D_E_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(C)_
--92 NoClash(B_C_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(E)_
+-92 NoClash(D_E_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(B)_
--92 NoClash(B_C_2_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(D)_
+-92 NoClash(D_E_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(C)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(B)_
--3.0 NoClash(B_C_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(E)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(D)_
++8.0 NoClash(D_E_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(C)_
--92 NoClash(B_C_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(E)_
+-92 NoClash(D_E_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(B)_
--92 NoClash(B_C_2_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(D)_
+-92 NoClash(D_E_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(G)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(A)_
-+9.0 NoClash(A_G_5_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(E)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(D)_
++2.0 NoClash(D_E_3_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(G)_
--92 NoClash(A_G_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(E)_
+-92 NoClash(D_E_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(A)_
--92 NoClash(A_G_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(D)_
+-92 NoClash(D_E_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(G)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(A)_
--3.0 NoClash(A_G_5_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(E)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(D)_
++9.0 NoClash(D_E_3_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)__t(G)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(G)_
--92 NoClash(A_G_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(E)_
+-92 NoClash(D_E_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(A)_
--92 NoClash(A_G_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(D)_
+-92 NoClash(D_E_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_transformedConstraints(c_0_ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(A)_
-+4.0 NoClash(A_F_3_0)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(D)_
+-1 NoClash(D_F_3_0)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)__t(F)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(F)_
--92 NoClash(A_F_3_0)_binary_indicator_var
+-92 NoClash(D_F_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(A)_
--92 NoClash(A_F_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(D)_
+-92 NoClash(D_F_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_transformedConstraints(c_0_ub)_:
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(F)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(A)_
-+6.0 NoClash(A_F_3_1)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(D)_
++11.0 NoClash(D_F_3_1)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)__t(F)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(F)_
--92 NoClash(A_F_3_1)_binary_indicator_var
+-92 NoClash(D_F_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(A)_
--92 NoClash(A_F_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(D)_
+-92 NoClash(D_F_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_transformedConstraints(c_0_ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(F)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(A)_
-+2.0 NoClash(A_F_1_0)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(D)_
++1 NoClash(D_F_4_0)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)__t(F)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(F)_
--92 NoClash(A_F_1_0)_binary_indicator_var
+-92 NoClash(D_F_4_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(A)_
--92 NoClash(A_F_1_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(D)_
+-92 NoClash(D_F_4_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_transformedConstraints(c_0_ub)_:
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(F)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(A)_
-+3.0 NoClash(A_F_1_1)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(D)_
++7.0 NoClash(D_F_4_1)_binary_indicator_var
<= 0.0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)__t(F)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(F)_
--92 NoClash(A_F_1_1)_binary_indicator_var
+-92 NoClash(D_F_4_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(A)_
--92 NoClash(A_F_1_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(D)_
+-92 NoClash(D_F_4_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(A)_
-+4.0 NoClash(A_E_5_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(D)_
++8.0 NoClash(D_G_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(E)_
--92 NoClash(A_E_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(G)_
+-92 NoClash(D_G_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(A)_
--92 NoClash(A_E_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(D)_
+-92 NoClash(D_G_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(E)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(D)_
++8.0 NoClash(D_G_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(E)_
--92 NoClash(A_E_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(G)_
+-92 NoClash(D_G_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(A)_
--92 NoClash(A_E_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(D)_
+-92 NoClash(D_G_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(E)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(A)_
-+7.0 NoClash(A_E_3_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(D)_
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(E)_
--92 NoClash(A_E_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(G)_
+-92 NoClash(D_G_4_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(A)_
--92 NoClash(A_E_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(D)_
+-92 NoClash(D_G_4_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(E)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(A)_
-+4.0 NoClash(A_E_3_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(D)_
++6.0 NoClash(D_G_4_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)__t(E)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(E)_
--92 NoClash(A_E_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(G)_
+-92 NoClash(D_G_4_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(A)_
--92 NoClash(A_E_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)__t(D)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(D)_
+-92 NoClash(D_G_4_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(D)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(A)_
-+10.0 NoClash(A_D_3_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(F)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(E)_
++3.0 NoClash(E_F_3_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(D)_
--92 NoClash(A_D_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(F)_
+-92 NoClash(E_F_3_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(A)_
--92 NoClash(A_D_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(E)_
+-92 NoClash(E_F_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(D)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(F)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(E)_
++8.0 NoClash(E_F_3_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)__t(D)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(D)_
--92 NoClash(A_D_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(F)_
+-92 NoClash(E_F_3_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(A)_
--92 NoClash(A_D_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(E)_
+-92 NoClash(E_F_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(A)_
-+6.0 NoClash(A_C_1_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(E)_
++8.0 NoClash(E_G_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(C)_
--92 NoClash(A_C_1_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(G)_
+-92 NoClash(E_G_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(A)_
--92 NoClash(A_C_1_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(E)_
+-92 NoClash(E_G_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(C)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(A)_
-+3.0 NoClash(A_C_1_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(E)_
++4.0 NoClash(E_G_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(C)_
--92 NoClash(A_C_1_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(G)_
+-92 NoClash(E_G_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(A)_
--92 NoClash(A_C_1_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(E)_
+-92 NoClash(E_G_2_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(A)_
-+2.0 NoClash(A_B_5_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(E)_
++7.0 NoClash(E_G_5_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(B)_
--92 NoClash(A_B_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(G)_
+-92 NoClash(E_G_5_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(A)_
--92 NoClash(A_B_5_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(E)_
+-92 NoClash(E_G_5_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(B)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(A)_
-+3.0 NoClash(A_B_5_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(E)_
+-1 NoClash(E_G_5_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(B)_
--92 NoClash(A_B_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(G)_
+-92 NoClash(E_G_5_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(A)_
--92 NoClash(A_B_5_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)__t(E)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(E)_
+-92 NoClash(E_G_5_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(A)_
-+4.0 NoClash(A_B_3_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(G)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(F)_
++6.0 NoClash(F_G_4_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(B)_
--92 NoClash(A_B_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(G)_
+-92 NoClash(F_G_4_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(A)_
--92 NoClash(A_B_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(F)_
+-92 NoClash(F_G_4_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(B)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(A)_
-+5.0 NoClash(A_B_3_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(G)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(F)_
++6.0 NoClash(F_G_4_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(B)_
--92 NoClash(A_B_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)__t(G)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(G)_
+-92 NoClash(F_G_4_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(A)_
--92 NoClash(A_B_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)__t(F)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(F)_
+-92 NoClash(F_G_4_1)_binary_indicator_var
<= 0
bounds
@@ -1761,146 +1761,146 @@ bounds
0 <= t(E) <= 92
0 <= t(F) <= 92
0 <= t(G) <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(6)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(7)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(8)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(9)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(10)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(11)_disaggregatedVars__t(A)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(F)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(12)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(13)_disaggregatedVars__t(A)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(F)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(14)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(15)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(16)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(17)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(18)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(19)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(20)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(21)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(22)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(23)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(24)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(25)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(26)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(27)_disaggregatedVars__t(B)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(E)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(28)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(29)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(30)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(31)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(32)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(33)_disaggregatedVars__t(B)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(34)_disaggregatedVars__t(G)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(35)_disaggregatedVars__t(G)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(34)_disaggregatedVars__t(B)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(35)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(B)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(36)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(37)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(38)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(39)_disaggregatedVars__t(C)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(E)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(G)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(40)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(41)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(42)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(43)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(44)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(45)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(46)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(47)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(48)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(49)_disaggregatedVars__t(C)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(50)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(51)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(52)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(53)_disaggregatedVars__t(D)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(F)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(54)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(55)_disaggregatedVars__t(D)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(F)_ <= 92
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(F)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(E)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(D)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(C)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(B)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(A)_ <= 92
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(A)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(56)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(57)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(58)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(59)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(60)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(61)_disaggregatedVars__t(D)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(62)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(63)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(64)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(65)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(66)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(67)_disaggregatedVars__t(E)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(G)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(68)_disaggregatedVars__t(F)_ <= 92
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(69)_disaggregatedVars__t(F)_ <= 92
0 <= NoClash(A_B_3_0)_binary_indicator_var <= 1
0 <= NoClash(A_B_3_1)_binary_indicator_var <= 1
0 <= NoClash(A_B_5_0)_binary_indicator_var <= 1
diff --git a/pyomo/gdp/tests/jobshop_small_hull.lp b/pyomo/gdp/tests/jobshop_small_hull.lp
index c07b9cd048e..eccaa800600 100644
--- a/pyomo/gdp/tests/jobshop_small_hull.lp
+++ b/pyomo/gdp/tests/jobshop_small_hull.lp
@@ -22,17 +22,17 @@ c_u_Feas(C)_:
<= -6
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(0)_:
-+1 t(C)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(C)_
-= 0
-
-c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(1)_:
+1 t(B)
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_
= 0
+c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(1)_:
++1 t(A)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(A)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(A)_
+= 0
+
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(2)_:
+1 t(C)
-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(C)_
@@ -46,15 +46,15 @@ c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(3)_:
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(4)_:
-+1 t(B)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(B)_
++1 t(C)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(C)_
= 0
c_e__pyomo_gdp_hull_reformulation_disaggregationConstraints(5)_:
-+1 t(A)
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(A)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(A)_
++1 t(B)
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(B)_
= 0
c_e__pyomo_gdp_hull_reformulation_disj_xor(A_B_3)_:
@@ -73,35 +73,34 @@ c_e__pyomo_gdp_hull_reformulation_disj_xor(B_C_2)_:
= 1
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(C)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_
-+6.0 NoClash(B_C_2_0)_binary_indicator_var
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(A)_
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(C)_
--19 NoClash(B_C_2_0)_binary_indicator_var
-<= 0
-
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)__t(B)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_
--19 NoClash(B_C_2_0)_binary_indicator_var
+-19 NoClash(A_B_3_0)_binary_indicator_var
+<= 0
+
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(A)_
+-19 NoClash(A_B_3_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(C)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_
-+1 NoClash(B_C_2_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(A)_
++5.0 NoClash(A_B_3_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)__t(C)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(C)_
--19 NoClash(B_C_2_1)_binary_indicator_var
-<= 0
-
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)__t(B)_bounds_(ub)_:
+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_
--19 NoClash(B_C_2_1)_binary_indicator_var
+-19 NoClash(A_B_3_1)_binary_indicator_var
+<= 0
+
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)__t(A)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(A)_
+-19 NoClash(A_B_3_1)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_transformedConstraints(c_0_ub)_:
@@ -137,34 +136,35 @@ c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)__t(A)_bounds_(ub)_:
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_transformedConstraints(c_0_ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(B)_
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(A)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(C)_
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(B)_
++6.0 NoClash(B_C_2_0)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(B)_
--19 NoClash(A_B_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(C)_
+-19 NoClash(B_C_2_0)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(A)_
--19 NoClash(A_B_3_0)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(B)_
+-19 NoClash(B_C_2_0)_binary_indicator_var
<= 0
c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_transformedConstraints(c_0_ub)_:
--1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(B)_
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(A)_
-+5.0 NoClash(A_B_3_1)_binary_indicator_var
+-1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(C)_
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(B)_
++1 NoClash(B_C_2_1)_binary_indicator_var
<= 0.0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)__t(B)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(B)_
--19 NoClash(A_B_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)__t(C)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(C)_
+-19 NoClash(B_C_2_1)_binary_indicator_var
<= 0
-c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)__t(A)_bounds_(ub)_:
-+1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(A)_
--19 NoClash(A_B_3_1)_binary_indicator_var
+c_u__pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)__t(B)_bounds_(ub)_:
++1 _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(B)_
+-19 NoClash(B_C_2_1)_binary_indicator_var
<= 0
bounds
@@ -172,18 +172,18 @@ bounds
0 <= t(A) <= 19
0 <= t(B) <= 19
0 <= t(C) <= 19
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(C)_ <= 19
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(C)_ <= 19
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(B)_ <= 19
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(B)_ <= 19
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(0)_disaggregatedVars__t(A)_ <= 19
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(1)_disaggregatedVars__t(A)_ <= 19
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(C)_ <= 19
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(C)_ <= 19
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(2)_disaggregatedVars__t(A)_ <= 19
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(3)_disaggregatedVars__t(A)_ <= 19
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(C)_ <= 19
+ 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(C)_ <= 19
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(B)_ <= 19
0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(B)_ <= 19
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(4)_disaggregatedVars__t(A)_ <= 19
- 0 <= _pyomo_gdp_hull_reformulation_relaxedDisjuncts(5)_disaggregatedVars__t(A)_ <= 19
0 <= NoClash(A_B_3_0)_binary_indicator_var <= 1
0 <= NoClash(A_B_3_1)_binary_indicator_var <= 1
0 <= NoClash(A_C_1_0)_binary_indicator_var <= 1
diff --git a/pyomo/gdp/tests/models.py b/pyomo/gdp/tests/models.py
index 273bdec7261..2995cacb450 100644
--- a/pyomo/gdp/tests/models.py
+++ b/pyomo/gdp/tests/models.py
@@ -474,7 +474,7 @@ def makeNestedDisjunctions():
(makeNestedDisjunctions_NestedDisjuncts is a much simpler model. All
this adds is that it has a nested disjunction on a DisjunctData as well
- as on a SimpleDisjunct. So mostly it exists for historical reasons.)
+ as on a ScalarDisjunct. So mostly it exists for historical reasons.)
"""
m = ConcreteModel()
m.x = Var(bounds=(-9, 9))
@@ -563,6 +563,44 @@ def makeNestedDisjunctions_NestedDisjuncts():
return m
+def why_indicator_vars_are_not_always_local():
+ m = ConcreteModel()
+ m.x = Var(bounds=(1, 10))
+
+ @m.Disjunct()
+ def Z1(d):
+ m = d.model()
+ d.c = Constraint(expr=m.x >= 1.1)
+
+ @m.Disjunct()
+ def Z2(d):
+ m = d.model()
+ d.c = Constraint(expr=m.x >= 1.2)
+
+ @m.Disjunct()
+ def Y1(d):
+ m = d.model()
+ d.c = Constraint(expr=(1.15, m.x, 8))
+ d.disjunction = Disjunction(expr=[m.Z1, m.Z2])
+
+ @m.Disjunct()
+ def Y2(d):
+ m = d.model()
+ d.c = Constraint(expr=m.x == 9)
+
+ m.disjunction = Disjunction(expr=[m.Y1, m.Y2])
+
+ m.logical_cons = LogicalConstraint(
+ expr=m.Y2.indicator_var.implies(m.Z1.indicator_var.land(m.Z2.indicator_var))
+ )
+
+ # optimal value is 9, but it will be 8 if we wrongly assume that the nested
+ # indicator_vars are local.
+ m.obj = Objective(expr=m.x, sense=maximize)
+
+ return m
+
+
def makeTwoSimpleDisjunctions():
"""Two SimpleDisjunctions on the same model."""
m = ConcreteModel()
@@ -802,7 +840,7 @@ def makeAnyIndexedDisjunctionOfDisjunctDatas():
build from DisjunctDatas. Identical mathematically to
makeDisjunctionOfDisjunctDatas.
- Used to test that the right things happen for a case where soemone
+ Used to test that the right things happen for a case where someone
implements an algorithm which iteratively generates disjuncts and
retransforms"""
m = ConcreteModel()
diff --git a/pyomo/gdp/tests/test_bigm.py b/pyomo/gdp/tests/test_bigm.py
index d518219eabd..c27d7cbe0cb 100644
--- a/pyomo/gdp/tests/test_bigm.py
+++ b/pyomo/gdp/tests/test_bigm.py
@@ -19,20 +19,24 @@
Set,
Constraint,
ComponentMap,
+ LogicalConstraint,
+ Objective,
SolverFactory,
Suffix,
+ TerminationCondition,
ConcreteModel,
Var,
Any,
value,
)
from pyomo.gdp import Disjunct, Disjunction, GDP_Error
-from pyomo.core.base import constraint, _ConstraintData
+from pyomo.core.base import constraint, ConstraintData
from pyomo.core.expr.compare import (
assertExpressionsEqual,
assertExpressionsStructurallyEqual,
)
from pyomo.repn import generate_standard_repn
+from pyomo.repn.linear import LinearRepnVisitor
from pyomo.common.log import LoggingIntercept
import logging
@@ -154,10 +158,7 @@ def test_or_constraints(self):
self,
orcons.body,
EXPR.LinearExpression(
- [
- EXPR.MonomialTermExpression((1, m.d[0].binary_indicator_var)),
- EXPR.MonomialTermExpression((1, m.d[1].binary_indicator_var)),
- ]
+ [m.d[0].binary_indicator_var, m.d[1].binary_indicator_var]
),
)
self.assertEqual(orcons.lower, 1)
@@ -655,14 +656,14 @@ def test_disjunct_and_constraint_maps(self):
if src[0]:
# equality
self.assertEqual(len(transformed), 2)
- self.assertIsInstance(transformed[0], _ConstraintData)
- self.assertIsInstance(transformed[1], _ConstraintData)
+ self.assertIsInstance(transformed[0], ConstraintData)
+ self.assertIsInstance(transformed[1], ConstraintData)
self.assertIs(bigm.get_src_constraint(transformed[0]), srcDisjunct.c)
self.assertIs(bigm.get_src_constraint(transformed[1]), srcDisjunct.c)
else:
# >=
self.assertEqual(len(transformed), 1)
- self.assertIsInstance(transformed[0], _ConstraintData)
+ self.assertIsInstance(transformed[0], ConstraintData)
# check reverse map from the container
self.assertIs(bigm.get_src_constraint(transformed[0]), srcDisjunct.c)
@@ -1315,26 +1316,18 @@ def test_do_not_transform_deactivated_constraintDatas(self):
bigm.apply_to(m)
# the real test: This wasn't transformed
- log = StringIO()
- with LoggingIntercept(log, 'pyomo.gdp', logging.ERROR):
- self.assertRaisesRegex(
- KeyError,
- r".*b.simpledisj1.c\[1\]",
- bigm.get_transformed_constraints,
- m.b.simpledisj1.c[1],
- )
- self.assertRegex(
- log.getvalue(),
- r".*Constraint 'b.simpledisj1.c\[1\]' has not been transformed.",
- )
+ with self.assertRaisesRegex(
+ GDP_Error, r"Constraint 'b.simpledisj1.c\[1\]' has not been transformed."
+ ):
+ bigm.get_transformed_constraints(m.b.simpledisj1.c[1])
# and the rest of the container was transformed
cons_list = bigm.get_transformed_constraints(m.b.simpledisj1.c[2])
self.assertEqual(len(cons_list), 2)
lb = cons_list[0]
ub = cons_list[1]
- self.assertIsInstance(lb, constraint._GeneralConstraintData)
- self.assertIsInstance(ub, constraint._GeneralConstraintData)
+ self.assertIsInstance(lb, constraint.ConstraintData)
+ self.assertIsInstance(ub, constraint.ConstraintData)
def checkMs(
self, m, disj1c1lb, disj1c1ub, disj1c2lb, disj1c2ub, disj2c1ub, disj2c2ub
@@ -1764,22 +1757,19 @@ def test_transformation_block_structure(self):
# we have the XOR constraints for both the outer and inner disjunctions
self.assertIsInstance(transBlock.component("disjunction_xor"), Constraint)
- def test_transformation_block_on_inner_disjunct_empty(self):
- m = models.makeNestedDisjunctions()
- TransformationFactory('gdp.bigm').apply_to(m)
- self.assertIsNone(m.disjunct[1].component("_pyomo_gdp_bigm_reformulation"))
-
def test_mappings_between_disjunctions_and_xors(self):
m = models.makeNestedDisjunctions()
transform = TransformationFactory('gdp.bigm')
transform.apply_to(m)
transBlock1 = m.component("_pyomo_gdp_bigm_reformulation")
+ transBlock2 = m.disjunct[1].component("_pyomo_gdp_bigm_reformulation")
+ transBlock3 = m.simpledisjunct.component("_pyomo_gdp_bigm_reformulation")
disjunctionPairs = [
(m.disjunction, transBlock1.disjunction_xor),
- (m.disjunct[1].innerdisjunction[0], transBlock1.innerdisjunction_xor_4[0]),
- (m.simpledisjunct.innerdisjunction, transBlock1.innerdisjunction_xor),
+ (m.disjunct[1].innerdisjunction[0], transBlock2.innerdisjunction_xor[0]),
+ (m.simpledisjunct.innerdisjunction, transBlock3.innerdisjunction_xor),
]
# check disjunction mappings
@@ -1892,26 +1882,38 @@ def test_m_value_mappings(self):
# many of the transformed constraints look like this, so can call this
# function to test them.
def check_bigM_constraint(self, cons, variable, M, indicator_var):
- repn = generate_standard_repn(cons.body)
- self.assertTrue(repn.is_linear())
- self.assertEqual(repn.constant, -M)
- self.assertEqual(len(repn.linear_vars), 2)
- ct.check_linear_coef(self, repn, variable, 1)
- ct.check_linear_coef(self, repn, indicator_var, M)
+ assertExpressionsEqual(
+ self,
+ cons.body,
+ variable - float(M) * (1 - indicator_var.get_associated_binary()),
+ )
- def check_inner_xor_constraint(
- self, inner_disjunction, outer_disjunct, inner_disjuncts
- ):
- self.assertIsNotNone(inner_disjunction.algebraic_constraint)
- cons = inner_disjunction.algebraic_constraint
- self.assertEqual(cons.lower, 0)
- self.assertEqual(cons.upper, 0)
- repn = generate_standard_repn(cons.body)
- self.assertTrue(repn.is_linear())
- self.assertEqual(repn.constant, 0)
- for disj in inner_disjuncts:
- ct.check_linear_coef(self, repn, disj.binary_indicator_var, 1)
- ct.check_linear_coef(self, repn, outer_disjunct.binary_indicator_var, -1)
+ def check_inner_xor_constraint(self, inner_disjunction, outer_disjunct, bigm):
+ inner_xor = inner_disjunction.algebraic_constraint
+ sum_indicators = sum(
+ d.binary_indicator_var for d in inner_disjunction.disjuncts
+ )
+ assertExpressionsEqual(self, inner_xor.expr, sum_indicators == 1)
+ # this guy has been transformed
+ self.assertFalse(inner_xor.active)
+ cons = bigm.get_transformed_constraints(inner_xor)
+ self.assertEqual(len(cons), 2)
+ lb = cons[0]
+ ct.check_obj_in_active_tree(self, lb)
+ lb_expr = self.simplify_cons(lb, leq=False)
+ assertExpressionsEqual(
+ self,
+ lb_expr,
+ 1.0 <= sum_indicators - outer_disjunct.binary_indicator_var + 1.0,
+ )
+ ub = cons[1]
+ ct.check_obj_in_active_tree(self, ub)
+ ub_expr = self.simplify_cons(ub, leq=True)
+ assertExpressionsEqual(
+ self,
+ ub_expr,
+ sum_indicators + outer_disjunct.binary_indicator_var - 1 <= 1.0,
+ )
def test_transformed_constraints(self):
# We'll check all the transformed constraints to make sure
@@ -1949,6 +1951,10 @@ def test_transformed_constraints(self):
.binary_indicator_var,
)
),
+ 1,
+ EXPR.MonomialTermExpression(
+ (-1, m.disjunct[1].binary_indicator_var)
+ ),
]
),
)
@@ -1958,61 +1964,76 @@ def test_transformed_constraints(self):
]
),
)
- self.assertIsNone(cons1ub.lower)
- self.assertEqual(cons1ub.upper, 0)
- self.check_bigM_constraint(
- cons1ub, m.z, 10, m.disjunct[1].innerdisjunct[0].indicator_var
+ assertExpressionsEqual(
+ self,
+ cons1ub.expr,
+ m.z
+ - 10.0
+ * (
+ 1
+ - m.disjunct[1].innerdisjunct[0].binary_indicator_var
+ + 1
+ - m.disjunct[1].binary_indicator_var
+ )
+ <= 0.0,
)
cons2 = bigm.get_transformed_constraints(m.disjunct[1].innerdisjunct[1].c)
self.assertEqual(len(cons2), 1)
cons2lb = cons2[0]
- self.assertEqual(cons2lb.lower, 5)
- self.assertIsNone(cons2lb.upper)
- self.check_bigM_constraint(
- cons2lb, m.z, -5, m.disjunct[1].innerdisjunct[1].indicator_var
+ assertExpressionsEqual(
+ self,
+ cons2lb.expr,
+ 5.0
+ <= m.z
+ - (-5.0)
+ * (
+ 1
+ - m.disjunct[1].innerdisjunct[1].binary_indicator_var
+ + 1
+ - m.disjunct[1].binary_indicator_var
+ ),
)
cons3 = bigm.get_transformed_constraints(m.simpledisjunct.innerdisjunct0.c)
self.assertEqual(len(cons3), 1)
cons3ub = cons3[0]
- self.assertEqual(cons3ub.upper, 2)
- self.assertIsNone(cons3ub.lower)
- self.check_bigM_constraint(
- cons3ub, m.x, 7, m.simpledisjunct.innerdisjunct0.indicator_var
+ assertExpressionsEqual(
+ self,
+ cons3ub.expr,
+ m.x
+ - 7.0
+ * (
+ 1
+ - m.simpledisjunct.innerdisjunct0.binary_indicator_var
+ + 1
+ - m.simpledisjunct.binary_indicator_var
+ )
+ <= 2.0,
)
cons4 = bigm.get_transformed_constraints(m.simpledisjunct.innerdisjunct1.c)
self.assertEqual(len(cons4), 1)
cons4lb = cons4[0]
- self.assertEqual(cons4lb.lower, 4)
- self.assertIsNone(cons4lb.upper)
- self.check_bigM_constraint(
- cons4lb, m.x, -13, m.simpledisjunct.innerdisjunct1.indicator_var
+ assertExpressionsEqual(
+ self,
+ cons4lb.expr,
+ m.x
+ - (-13.0)
+ * (
+ 1
+ - m.simpledisjunct.innerdisjunct1.binary_indicator_var
+ + 1
+ - m.simpledisjunct.binary_indicator_var
+ )
+ >= 4.0,
)
# Here we check that the xor constraint from
# simpledisjunct.innerdisjunction is transformed.
- cons5 = m.simpledisjunct.innerdisjunction.algebraic_constraint
- self.assertIsNotNone(cons5)
self.check_inner_xor_constraint(
- m.simpledisjunct.innerdisjunction,
- m.simpledisjunct,
- [m.simpledisjunct.innerdisjunct0, m.simpledisjunct.innerdisjunct1],
- )
- self.assertIsInstance(cons5, Constraint)
- self.assertEqual(cons5.lower, 0)
- self.assertEqual(cons5.upper, 0)
- repn = generate_standard_repn(cons5.body)
- self.assertTrue(repn.is_linear())
- self.assertEqual(repn.constant, 0)
- ct.check_linear_coef(
- self, repn, m.simpledisjunct.innerdisjunct0.binary_indicator_var, 1
+ m.simpledisjunct.innerdisjunction, m.simpledisjunct, bigm
)
- ct.check_linear_coef(
- self, repn, m.simpledisjunct.innerdisjunct1.binary_indicator_var, 1
- )
- ct.check_linear_coef(self, repn, m.simpledisjunct.binary_indicator_var, -1)
cons6 = bigm.get_transformed_constraints(m.disjunct[0].c)
self.assertEqual(len(cons6), 2)
@@ -2028,9 +2049,7 @@ def test_transformed_constraints(self):
# now we check that the xor constraint from disjunct[1].innerdisjunction
# is correct.
self.check_inner_xor_constraint(
- m.disjunct[1].innerdisjunction[0],
- m.disjunct[1],
- [m.disjunct[1].innerdisjunct[0], m.disjunct[1].innerdisjunct[1]],
+ m.disjunct[1].innerdisjunction[0], m.disjunct[1], bigm
)
cons8 = bigm.get_transformed_constraints(m.disjunct[1].c)
@@ -2107,34 +2126,18 @@ def innerIndexed(d, i):
m._pyomo_gdp_bigm_reformulation.relaxedDisjuncts,
)
- def check_first_disjunct_constraint(self, disj1c, x, ind_var):
- self.assertEqual(len(disj1c), 1)
- cons = disj1c[0]
- self.assertIsNone(cons.lower)
- self.assertEqual(cons.upper, 1)
- repn = generate_standard_repn(cons.body)
- self.assertTrue(repn.is_quadratic())
- self.assertEqual(len(repn.linear_vars), 1)
- self.assertEqual(len(repn.quadratic_vars), 4)
- ct.check_linear_coef(self, repn, ind_var, 143)
- self.assertEqual(repn.constant, -143)
- for i in range(1, 5):
- ct.check_squared_term_coef(self, repn, x[i], 1)
-
- def check_second_disjunct_constraint(self, disj2c, x, ind_var):
- self.assertEqual(len(disj2c), 1)
- cons = disj2c[0]
- self.assertIsNone(cons.lower)
- self.assertEqual(cons.upper, 1)
- repn = generate_standard_repn(cons.body)
- self.assertTrue(repn.is_quadratic())
- self.assertEqual(len(repn.linear_vars), 5)
- self.assertEqual(len(repn.quadratic_vars), 4)
- self.assertEqual(repn.constant, -63) # M = 99, so this is 36 - 99
- ct.check_linear_coef(self, repn, ind_var, 99)
- for i in range(1, 5):
- ct.check_squared_term_coef(self, repn, x[i], 1)
- ct.check_linear_coef(self, repn, x[i], -6)
+ def simplify_cons(self, cons, leq):
+ visitor = LinearRepnVisitor({}, {}, {}, None)
+ repn = visitor.walk_expression(cons.body)
+ self.assertIsNone(repn.nonlinear)
+ if leq:
+ self.assertIsNone(cons.lower)
+ ub = cons.upper
+ return ub >= repn.to_expression(visitor)
+ else:
+ self.assertIsNone(cons.upper)
+ lb = cons.lower
+ return lb <= repn.to_expression(visitor)
def check_hierarchical_nested_model(self, m, bigm):
outer_xor = m.disjunction_block.disjunction.algebraic_constraint
@@ -2142,55 +2145,82 @@ def check_hierarchical_nested_model(self, m, bigm):
self, outer_xor, m.disj1, m.disjunct_block.disj2
)
- inner_xor = m.disjunct_block.disj2.disjunction.algebraic_constraint
- self.assertEqual(inner_xor.lower, 0)
- self.assertEqual(inner_xor.upper, 0)
- repn = generate_standard_repn(inner_xor.body)
- self.assertTrue(repn.is_linear())
- self.assertEqual(len(repn.linear_vars), 3)
- self.assertEqual(repn.constant, 0)
- ct.check_linear_coef(
- self,
- repn,
- m.disjunct_block.disj2.disjunction_disjuncts[0].binary_indicator_var,
- 1,
- )
- ct.check_linear_coef(
- self,
- repn,
- m.disjunct_block.disj2.disjunction_disjuncts[1].binary_indicator_var,
- 1,
- )
- ct.check_linear_coef(
- self, repn, m.disjunct_block.disj2.binary_indicator_var, -1
+ self.check_inner_xor_constraint(
+ m.disjunct_block.disj2.disjunction, m.disjunct_block.disj2, bigm
)
# outer disjunction constraints
disj1c = bigm.get_transformed_constraints(m.disj1.c)
- self.check_first_disjunct_constraint(disj1c, m.x, m.disj1.binary_indicator_var)
+ self.assertEqual(len(disj1c), 1)
+ cons = disj1c[0]
+ assertExpressionsEqual(
+ self,
+ cons.expr,
+ m.x[1] ** 2
+ + m.x[2] ** 2
+ + m.x[3] ** 2
+ + m.x[4] ** 2
+ - 143.0 * (1 - m.disj1.binary_indicator_var)
+ <= 1.0,
+ )
disj2c = bigm.get_transformed_constraints(m.disjunct_block.disj2.c)
- self.check_second_disjunct_constraint(
- disj2c, m.x, m.disjunct_block.disj2.binary_indicator_var
+ self.assertEqual(len(disj2c), 1)
+ cons = disj2c[0]
+ assertExpressionsEqual(
+ self,
+ cons.expr,
+ (3 - m.x[1]) ** 2
+ + (3 - m.x[2]) ** 2
+ + (3 - m.x[3]) ** 2
+ + (3 - m.x[4]) ** 2
+ - 99.0 * (1 - m.disjunct_block.disj2.binary_indicator_var)
+ <= 1.0,
)
# inner disjunction constraints
innerd1c = bigm.get_transformed_constraints(
m.disjunct_block.disj2.disjunction_disjuncts[0].constraint[1]
)
- self.check_first_disjunct_constraint(
- innerd1c,
- m.x,
- m.disjunct_block.disj2.disjunction_disjuncts[0].binary_indicator_var,
+ self.assertEqual(len(innerd1c), 1)
+ cons = innerd1c[0]
+ assertExpressionsEqual(
+ self,
+ cons.expr,
+ m.x[1] ** 2
+ + m.x[2] ** 2
+ + m.x[3] ** 2
+ + m.x[4] ** 2
+ - 143.0
+ * (
+ 1
+ - m.disjunct_block.disj2.disjunction_disjuncts[0].binary_indicator_var
+ + 1
+ - m.disjunct_block.disj2.binary_indicator_var
+ )
+ <= 1.0,
)
innerd2c = bigm.get_transformed_constraints(
m.disjunct_block.disj2.disjunction_disjuncts[1].constraint[1]
)
- self.check_second_disjunct_constraint(
- innerd2c,
- m.x,
- m.disjunct_block.disj2.disjunction_disjuncts[1].binary_indicator_var,
+ self.assertEqual(len(innerd2c), 1)
+ cons = innerd2c[0]
+ assertExpressionsEqual(
+ self,
+ cons.expr,
+ (3 - m.x[1]) ** 2
+ + (3 - m.x[2]) ** 2
+ + (3 - m.x[3]) ** 2
+ + (3 - m.x[4]) ** 2
+ - 99.0
+ * (
+ 1
+ - m.disjunct_block.disj2.disjunction_disjuncts[1].binary_indicator_var
+ + 1
+ - m.disjunct_block.disj2.binary_indicator_var
+ )
+ <= 1.0,
)
def test_hierarchical_badly_ordered_targets(self):
@@ -2214,10 +2244,54 @@ def test_decl_order_opposite_instantiation_order(self):
# the same check to make sure everything is transformed correctly.
self.check_hierarchical_nested_model(m, bigm)
+ @unittest.skipUnless(gurobi_available, "Gurobi is not available")
+ def test_do_not_assume_nested_indicators_local(self):
+ ct.check_do_not_assume_nested_indicators_local(self, 'gdp.bigm')
+
+ @unittest.skipUnless(gurobi_available, "Gurobi is not available")
+ def test_constraints_not_enforced_when_an_ancestor_indicator_is_False(self):
+ m = ConcreteModel()
+ m.x = Var(bounds=(0, 30))
+
+ m.left = Disjunct()
+ m.left.left = Disjunct()
+ m.left.left.c = Constraint(expr=m.x >= 10)
+ m.left.right = Disjunct()
+ m.left.right.c = Constraint(expr=m.x >= 9)
+ m.left.disjunction = Disjunction(expr=[m.left.left, m.left.right])
+ m.right = Disjunct()
+ m.right.left = Disjunct()
+ m.right.left.c = Constraint(expr=m.x >= 11)
+ m.right.right = Disjunct()
+ m.right.right.c = Constraint(expr=m.x >= 8)
+ m.right.disjunction = Disjunction(expr=[m.right.left, m.right.right])
+ m.disjunction = Disjunction(expr=[m.left, m.right])
+
+ m.equiv_left = LogicalConstraint(
+ expr=m.left.left.indicator_var.equivalent_to(m.right.left.indicator_var)
+ )
+ m.equiv_right = LogicalConstraint(
+ expr=m.left.right.indicator_var.equivalent_to(m.right.right.indicator_var)
+ )
+
+ m.obj = Objective(expr=m.x)
+
+ TransformationFactory('gdp.bigm').apply_to(m)
+ results = SolverFactory('gurobi').solve(m)
+ self.assertEqual(
+ results.solver.termination_condition, TerminationCondition.optimal
+ )
+ self.assertTrue(value(m.right.indicator_var))
+ self.assertFalse(value(m.left.indicator_var))
+ self.assertTrue(value(m.right.right.indicator_var))
+ self.assertFalse(value(m.right.left.indicator_var))
+ self.assertTrue(value(m.left.right.indicator_var))
+ self.assertAlmostEqual(value(m.x), 8)
+
class IndexedDisjunction(unittest.TestCase):
# this tests that if the targets are a subset of the
- # _DisjunctDatas in an IndexedDisjunction that the xor constraint
+ # DisjunctDatas in an IndexedDisjunction that the xor constraint
# created on the parent block will still be indexed as expected.
def test_xor_constraint(self):
ct.check_indexed_xor_constraints_with_targets(self, 'bigm')
@@ -2282,18 +2356,12 @@ def check_all_but_evil1_b_anotherblock_constraint_transformed(self, m):
self.assertEqual(len(evil1), 2)
self.assertIs(evil1[0].parent_block(), disjBlock[1])
self.assertIs(evil1[1].parent_block(), disjBlock[1])
- out = StringIO()
- with LoggingIntercept(out, 'pyomo.gdp', logging.ERROR):
- self.assertRaisesRegex(
- KeyError,
- r".*.evil\[1\].b.anotherblock.c",
- bigm.get_transformed_constraints,
- m.evil[1].b.anotherblock.c,
- )
- self.assertRegex(
- out.getvalue(),
- r".*Constraint 'evil\[1\].b.anotherblock.c' has not been transformed.",
- )
+ with self.assertRaisesRegex(
+ GDP_Error,
+ r"Constraint 'evil\[1\].b.anotherblock.c' has not been transformed.",
+ ):
+ bigm.get_transformed_constraints(m.evil[1].b.anotherblock.c)
+
evil1 = bigm.get_transformed_constraints(m.evil[1].bb[1].c)
self.assertEqual(len(evil1), 2)
self.assertIs(evil1[0].parent_block(), disjBlock[1])
diff --git a/pyomo/gdp/tests/test_binary_multiplication.py b/pyomo/gdp/tests/test_binary_multiplication.py
index 5f4c4f90ab6..ae2c44b899e 100644
--- a/pyomo/gdp/tests/test_binary_multiplication.py
+++ b/pyomo/gdp/tests/test_binary_multiplication.py
@@ -18,6 +18,7 @@
ConcreteModel,
Var,
Any,
+ SolverFactory,
)
from pyomo.gdp import Disjunct, Disjunction
from pyomo.core.expr.compare import assertExpressionsEqual
@@ -30,6 +31,11 @@
import random
+gurobi_available = (
+ SolverFactory('gurobi').available(exception_flag=False)
+ and SolverFactory('gurobi').license_is_valid()
+)
+
class CommonTests:
def diff_apply_to_and_create_using(self, model):
@@ -140,10 +146,7 @@ def test_or_constraints(self):
self,
orcons.body,
EXPR.LinearExpression(
- [
- EXPR.MonomialTermExpression((1, m.d[0].binary_indicator_var)),
- EXPR.MonomialTermExpression((1, m.d[1].binary_indicator_var)),
- ]
+ [m.d[0].binary_indicator_var, m.d[1].binary_indicator_var]
),
)
self.assertEqual(orcons.lower, 1)
@@ -297,5 +300,13 @@ def test_local_var(self):
self.assertEqual(eq.ub, 0)
+class TestNestedGDP(unittest.TestCase):
+ @unittest.skipUnless(gurobi_available, "Gurobi is not available")
+ def test_do_not_assume_nested_indicators_local(self):
+ ct.check_do_not_assume_nested_indicators_local(
+ self, 'gdp.binary_multiplication'
+ )
+
+
if __name__ == '__main__':
unittest.main()
diff --git a/pyomo/gdp/tests/test_disjunct.py b/pyomo/gdp/tests/test_disjunct.py
index d969b245ee7..f93ac31fb0f 100644
--- a/pyomo/gdp/tests/test_disjunct.py
+++ b/pyomo/gdp/tests/test_disjunct.py
@@ -632,19 +632,13 @@ def test_cast_to_binary(self):
out = StringIO()
with LoggingIntercept(out):
e = m.iv + 1
- assertExpressionsEqual(
- self, e, EXPR.LinearExpression([EXPR.MonomialTermExpression((1, m.biv)), 1])
- )
+ assertExpressionsEqual(self, e, EXPR.LinearExpression([m.biv, 1]))
self.assertIn(deprecation_msg, out.getvalue())
out = StringIO()
with LoggingIntercept(out):
e = m.iv - 1
- assertExpressionsEqual(
- self,
- e,
- EXPR.LinearExpression([EXPR.MonomialTermExpression((1, m.biv)), -1]),
- )
+ assertExpressionsEqual(self, e, EXPR.LinearExpression([m.biv, -1]))
self.assertIn(deprecation_msg, out.getvalue())
out = StringIO()
@@ -665,9 +659,7 @@ def test_cast_to_binary(self):
out = StringIO()
with LoggingIntercept(out):
e = 1 + m.iv
- assertExpressionsEqual(
- self, e, EXPR.LinearExpression([1, EXPR.MonomialTermExpression((1, m.biv))])
- )
+ assertExpressionsEqual(self, e, EXPR.LinearExpression([1, m.biv]))
self.assertIn(deprecation_msg, out.getvalue())
out = StringIO()
@@ -699,20 +691,14 @@ def test_cast_to_binary(self):
with LoggingIntercept(out):
a = m.iv
a += 1
- assertExpressionsEqual(
- self, a, EXPR.LinearExpression([EXPR.MonomialTermExpression((1, m.biv)), 1])
- )
+ assertExpressionsEqual(self, a, EXPR.LinearExpression([m.biv, 1]))
self.assertIn(deprecation_msg, out.getvalue())
out = StringIO()
with LoggingIntercept(out):
a = m.iv
a -= 1
- assertExpressionsEqual(
- self,
- a,
- EXPR.LinearExpression([EXPR.MonomialTermExpression((1, m.biv)), -1]),
- )
+ assertExpressionsEqual(self, a, EXPR.LinearExpression([m.biv, -1]))
self.assertIn(deprecation_msg, out.getvalue())
out = StringIO()
diff --git a/pyomo/gdp/tests/test_hull.py b/pyomo/gdp/tests/test_hull.py
index cf0ce3234af..07876a9d213 100644
--- a/pyomo/gdp/tests/test_hull.py
+++ b/pyomo/gdp/tests/test_hull.py
@@ -41,6 +41,7 @@
import pyomo.core.expr as EXPR
from pyomo.core.base import constraint
from pyomo.repn import generate_standard_repn
+from pyomo.repn.linear import LinearRepnVisitor
from pyomo.gdp import Disjunct, Disjunction, GDP_Error
import pyomo.gdp.tests.models as models
@@ -51,6 +52,7 @@
import os
from os.path import abspath, dirname, join
+
currdir = dirname(abspath(__file__))
from filecmp import cmp
@@ -402,19 +404,13 @@ def test_error_for_or(self):
self.assertRaisesRegex(
GDP_Error,
"Cannot do hull reformulation for Disjunction "
- "'disjunction' with OR constraint. Must be an XOR!*",
+ "'disjunction' with OR constraint. Must be an XOR!*",
TransformationFactory('gdp.hull').apply_to,
m,
)
def check_disaggregation_constraint(self, cons, var, disvar1, disvar2):
- repn = generate_standard_repn(cons.body)
- self.assertEqual(cons.lower, 0)
- self.assertEqual(cons.upper, 0)
- self.assertEqual(len(repn.linear_vars), 3)
- ct.check_linear_coef(self, repn, var, 1)
- ct.check_linear_coef(self, repn, disvar1, -1)
- ct.check_linear_coef(self, repn, disvar2, -1)
+ assertExpressionsEqual(self, cons.expr, var == disvar1 + disvar2)
def test_disaggregation_constraint(self):
m = models.makeTwoTermDisj_Nonlinear()
@@ -426,8 +422,8 @@ def test_disaggregation_constraint(self):
self.check_disaggregation_constraint(
hull.get_disaggregation_constraint(m.w, m.disjunction),
m.w,
- disjBlock[1].disaggregatedVars.w,
transBlock._disaggregatedVars[1],
+ disjBlock[1].disaggregatedVars.w,
)
self.check_disaggregation_constraint(
hull.get_disaggregation_constraint(m.x, m.disjunction),
@@ -438,8 +434,8 @@ def test_disaggregation_constraint(self):
self.check_disaggregation_constraint(
hull.get_disaggregation_constraint(m.y, m.disjunction),
m.y,
- disjBlock[0].disaggregatedVars.y,
transBlock._disaggregatedVars[0],
+ disjBlock[0].disaggregatedVars.y,
)
def test_xor_constraint_mapping(self):
@@ -510,10 +506,10 @@ def test_disaggregatedVar_mappings(self):
for i in [0, 1]:
mappings = ComponentMap()
mappings[m.x] = disjBlock[i].disaggregatedVars.x
- if i == 1: # this disjunct as x, w, and no y
+ if i == 1: # this disjunct has x, w, and no y
mappings[m.w] = disjBlock[i].disaggregatedVars.w
mappings[m.y] = transBlock._disaggregatedVars[0]
- elif i == 0: # this disjunct as x, y, and no w
+ elif i == 0: # this disjunct has x, y, and no w
mappings[m.y] = disjBlock[i].disaggregatedVars.y
mappings[m.w] = transBlock._disaggregatedVars[1]
@@ -668,17 +664,38 @@ def test_global_vars_local_to_a_disjunction_disaggregated(self):
self.assertIs(hull.get_src_var(x), m.disj1.x)
# there is a spare x on disjunction1's block
- x2 = m.disjunction1.algebraic_constraint.parent_block()._disaggregatedVars[2]
+ x2 = m.disjunction1.algebraic_constraint.parent_block()._disaggregatedVars[0]
self.assertIs(hull.get_disaggregated_var(m.disj1.x, m.disj2), x2)
self.assertIs(hull.get_src_var(x2), m.disj1.x)
+ # What really matters is that the above matches this:
+ agg_cons = hull.get_disaggregation_constraint(m.disj1.x, m.disjunction1)
+ assertExpressionsEqual(
+ self,
+ agg_cons.expr,
+ m.disj1.x == x2 + hull.get_disaggregated_var(m.disj1.x, m.disj1),
+ )
# and both a spare x and y on disjunction2's block
- x2 = m.disjunction2.algebraic_constraint.parent_block()._disaggregatedVars[0]
- y1 = m.disjunction2.algebraic_constraint.parent_block()._disaggregatedVars[1]
+ x2 = m.disjunction2.algebraic_constraint.parent_block()._disaggregatedVars[1]
+ y1 = m.disjunction2.algebraic_constraint.parent_block()._disaggregatedVars[2]
self.assertIs(hull.get_disaggregated_var(m.disj1.x, m.disj4), x2)
self.assertIs(hull.get_src_var(x2), m.disj1.x)
self.assertIs(hull.get_disaggregated_var(m.disj1.y, m.disj3), y1)
self.assertIs(hull.get_src_var(y1), m.disj1.y)
+ # and again what really matters is that these align with the
+ # disaggregation constraints:
+ agg_cons = hull.get_disaggregation_constraint(m.disj1.x, m.disjunction2)
+ assertExpressionsEqual(
+ self,
+ agg_cons.expr,
+ m.disj1.x == x2 + hull.get_disaggregated_var(m.disj1.x, m.disj3),
+ )
+ agg_cons = hull.get_disaggregation_constraint(m.disj1.y, m.disjunction2)
+ assertExpressionsEqual(
+ self,
+ agg_cons.expr,
+ m.disj1.y == y1 + hull.get_disaggregated_var(m.disj1.y, m.disj4),
+ )
def check_name_collision_disaggregated_vars(self, m, disj):
hull = TransformationFactory('gdp.hull')
@@ -880,18 +897,10 @@ def test_do_not_transform_deactivated_constraintDatas(self):
hull = TransformationFactory('gdp.hull')
hull.apply_to(m)
# can't ask for simpledisj1.c[1]: it wasn't transformed
- log = StringIO()
- with LoggingIntercept(log, 'pyomo.gdp', logging.ERROR):
- self.assertRaisesRegex(
- KeyError,
- r".*b.simpledisj1.c\[1\]",
- hull.get_transformed_constraints,
- m.b.simpledisj1.c[1],
- )
- self.assertRegex(
- log.getvalue(),
- r".*Constraint 'b.simpledisj1.c\[1\]' has not been transformed.",
- )
+ with self.assertRaisesRegex(
+ GDP_Error, r"Constraint 'b.simpledisj1.c\[1\]' has not been transformed."
+ ):
+ hull.get_transformed_constraints(m.b.simpledisj1.c[1])
# this fixes a[2] to 0, so we should get the disggregated var
transformed = hull.get_transformed_constraints(m.b.simpledisj1.c[2])
@@ -1101,7 +1110,7 @@ def check_trans_block_disjunctions_of_disjunct_datas(self, m):
self.assertEqual(len(transBlock1.relaxedDisjuncts), 4)
hull = TransformationFactory('gdp.hull')
- firstTerm2 = transBlock1.relaxedDisjuncts[0]
+ firstTerm2 = transBlock1.relaxedDisjuncts[2]
self.assertIs(firstTerm2, m.firstTerm[2].transformation_block)
self.assertIsInstance(firstTerm2.disaggregatedVars.component("x"), Var)
constraints = hull.get_transformed_constraints(m.firstTerm[2].cons)
@@ -1115,7 +1124,7 @@ def check_trans_block_disjunctions_of_disjunct_datas(self, m):
self.assertIs(cons.parent_block(), firstTerm2)
self.assertEqual(len(cons), 2)
- secondTerm2 = transBlock1.relaxedDisjuncts[1]
+ secondTerm2 = transBlock1.relaxedDisjuncts[3]
self.assertIs(secondTerm2, m.secondTerm[2].transformation_block)
self.assertIsInstance(secondTerm2.disaggregatedVars.component("x"), Var)
constraints = hull.get_transformed_constraints(m.secondTerm[2].cons)
@@ -1129,7 +1138,7 @@ def check_trans_block_disjunctions_of_disjunct_datas(self, m):
self.assertIs(cons.parent_block(), secondTerm2)
self.assertEqual(len(cons), 2)
- firstTerm1 = transBlock1.relaxedDisjuncts[2]
+ firstTerm1 = transBlock1.relaxedDisjuncts[0]
self.assertIs(firstTerm1, m.firstTerm[1].transformation_block)
self.assertIsInstance(firstTerm1.disaggregatedVars.component("x"), Var)
self.assertTrue(firstTerm1.disaggregatedVars.x.is_fixed())
@@ -1147,7 +1156,7 @@ def check_trans_block_disjunctions_of_disjunct_datas(self, m):
self.assertIs(cons.parent_block(), firstTerm1)
self.assertEqual(len(cons), 2)
- secondTerm1 = transBlock1.relaxedDisjuncts[3]
+ secondTerm1 = transBlock1.relaxedDisjuncts[1]
self.assertIs(secondTerm1, m.secondTerm[1].transformation_block)
self.assertIsInstance(secondTerm1.disaggregatedVars.component("x"), Var)
constraints = hull.get_transformed_constraints(m.secondTerm[1].cons)
@@ -1243,12 +1252,10 @@ def check_second_iteration(self, model):
orig = model.component("_pyomo_gdp_hull_reformulation")
self.assertIsInstance(
- model.disjunctionList[1].algebraic_constraint,
- constraint._GeneralConstraintData,
+ model.disjunctionList[1].algebraic_constraint, constraint.ConstraintData
)
self.assertIsInstance(
- model.disjunctionList[0].algebraic_constraint,
- constraint._GeneralConstraintData,
+ model.disjunctionList[0].algebraic_constraint, constraint.ConstraintData
)
self.assertFalse(model.disjunctionList[1].active)
self.assertFalse(model.disjunctionList[0].active)
@@ -1375,9 +1382,8 @@ def test_deactivated_disjunct_leaves_nested_disjuncts_active(self):
ct.check_deactivated_disjunct_leaves_nested_disjunct_active(self, 'hull')
def test_mappings_between_disjunctions_and_xors(self):
- # This test is nearly identical to the one in bigm, but because of
- # different transformation orders, the name conflict gets resolved in
- # the opposite way.
+ # Tests that the XOR constraints are put on the parent block of the
+ # disjunction, and checks the mappings.
m = models.makeNestedDisjunctions()
transform = TransformationFactory('gdp.hull')
transform.apply_to(m)
@@ -1386,8 +1392,17 @@ def test_mappings_between_disjunctions_and_xors(self):
disjunctionPairs = [
(m.disjunction, transBlock.disjunction_xor),
- (m.disjunct[1].innerdisjunction[0], transBlock.innerdisjunction_xor[0]),
- (m.simpledisjunct.innerdisjunction, transBlock.innerdisjunction_xor_4),
+ (
+ m.disjunct[1].innerdisjunction[0],
+ m.disjunct[1]
+ .innerdisjunction[0]
+ .algebraic_constraint.parent_block()
+ .innerdisjunction_xor[0],
+ ),
+ (
+ m.simpledisjunct.innerdisjunction,
+ m.simpledisjunct.innerdisjunction.algebraic_constraint.parent_block().innerdisjunction_xor,
+ ),
]
# check disjunction mappings
@@ -1427,16 +1442,16 @@ def test_relaxation_feasibility(self):
solver = SolverFactory(linear_solvers[0])
cases = [
- (1, 1, 1, 1, None),
- (0, 0, 0, 0, None),
- (1, 0, 0, 0, None),
- (0, 1, 0, 0, 1.1),
- (0, 0, 1, 0, None),
- (0, 0, 0, 1, None),
- (1, 1, 0, 0, None),
- (1, 0, 1, 0, 1.2),
- (1, 0, 0, 1, 1.3),
- (1, 0, 1, 1, None),
+ (True, True, True, True, None),
+ (False, False, False, False, None),
+ (True, False, False, False, None),
+ (False, True, False, False, 1.1),
+ (False, False, True, False, None),
+ (False, False, False, True, None),
+ (True, True, False, False, None),
+ (True, False, True, False, 1.2),
+ (True, False, False, True, 1.3),
+ (True, False, True, True, None),
]
for case in cases:
m.d1.indicator_var.fix(case[0])
@@ -1468,16 +1483,16 @@ def test_relaxation_feasibility_transform_inner_first(self):
solver = SolverFactory(linear_solvers[0])
cases = [
- (1, 1, 1, 1, None),
- (0, 0, 0, 0, None),
- (1, 0, 0, 0, None),
- (0, 1, 0, 0, 1.1),
- (0, 0, 1, 0, None),
- (0, 0, 0, 1, None),
- (1, 1, 0, 0, None),
- (1, 0, 1, 0, 1.2),
- (1, 0, 0, 1, 1.3),
- (1, 0, 1, 1, None),
+ (True, True, True, True, None),
+ (False, False, False, False, None),
+ (True, False, False, False, None),
+ (False, True, False, False, 1.1),
+ (False, False, True, False, None),
+ (False, False, False, True, None),
+ (True, True, False, False, None),
+ (True, False, True, False, 1.2),
+ (True, False, False, True, 1.3),
+ (True, False, True, True, None),
]
for case in cases:
m.d1.indicator_var.fix(case[0])
@@ -1550,149 +1565,190 @@ def check_transformed_constraint(self, cons, dis, lb, ind_var):
def test_transformed_model_nestedDisjuncts(self):
# This test tests *everything* for a simple nested disjunction case.
m = models.makeNestedDisjunctions_NestedDisjuncts()
+ m.LocalVars = Suffix(direction=Suffix.LOCAL)
+ m.LocalVars[m.d1] = [
+ m.d1.binary_indicator_var,
+ m.d1.d3.binary_indicator_var,
+ m.d1.d4.binary_indicator_var,
+ ]
hull = TransformationFactory('gdp.hull')
hull.apply_to(m)
+ self.check_transformed_model_nestedDisjuncts(
+ m, m.d1.d3.binary_indicator_var, m.d1.d4.binary_indicator_var
+ )
+
+ # Last, check that there aren't things we weren't expecting
+ all_cons = list(
+ m.component_data_objects(Constraint, active=True, descend_into=Block)
+ )
+ # 2 disaggregation constraints for x 0,3
+ # + 6 bounds constraints for x 6,8,9,13,14,16
+ # + 2 bounds constraints for inner indicator vars 11, 12
+ # + 2 exactly-one constraints 1,4
+ # + 4 transformed constraints 2,5,7,15
+ self.assertEqual(len(all_cons), 16)
+
+ def check_transformed_model_nestedDisjuncts(self, m, d3, d4):
+ # This function checks all of the 16 constraint expressions from
+ # transforming models.makeNestedDisjunction_NestedDisjuncts when
+ # declaring the inner indicator vars (d3 and d4) as local. Note that it
+ # also is a correct test for the case where the inner indicator vars are
+ # *not* declared as local, but not a complete one, since there are
+ # additional constraints in that case (see
+ # check_transformation_blocks_nestedDisjunctions in common_tests.py).
+ hull = TransformationFactory('gdp.hull')
transBlock = m._pyomo_gdp_hull_reformulation
self.assertTrue(transBlock.active)
- # outer xor should be on this block
+ # check outer xor
xor = transBlock.disj_xor
self.assertIsInstance(xor, Constraint)
- self.assertTrue(xor.active)
- self.assertEqual(xor.lower, 1)
- self.assertEqual(xor.upper, 1)
- repn = generate_standard_repn(xor.body)
- self.assertTrue(repn.is_linear())
- self.assertEqual(repn.constant, 0)
- ct.check_linear_coef(self, repn, m.d1.binary_indicator_var, 1)
- ct.check_linear_coef(self, repn, m.d2.binary_indicator_var, 1)
+ ct.check_obj_in_active_tree(self, xor)
+ assertExpressionsEqual(
+ self, xor.expr, m.d1.binary_indicator_var + m.d2.binary_indicator_var == 1
+ )
self.assertIs(xor, m.disj.algebraic_constraint)
self.assertIs(m.disj, hull.get_src_disjunction(xor))
- # inner xor should be on this block
+ # check inner xor
xor = m.d1.disj2.algebraic_constraint
- self.assertIs(xor.parent_block(), transBlock)
- self.assertIsInstance(xor, Constraint)
- self.assertTrue(xor.active)
- self.assertEqual(xor.lower, 0)
- self.assertEqual(xor.upper, 0)
- repn = generate_standard_repn(xor.body)
- self.assertTrue(repn.is_linear())
- self.assertEqual(repn.constant, 0)
- ct.check_linear_coef(self, repn, m.d1.d3.binary_indicator_var, 1)
- ct.check_linear_coef(self, repn, m.d1.d4.binary_indicator_var, 1)
- ct.check_linear_coef(self, repn, m.d1.binary_indicator_var, -1)
self.assertIs(m.d1.disj2, hull.get_src_disjunction(xor))
-
- # so should both disaggregation constraints
- dis = transBlock.disaggregationConstraints
- self.assertIsInstance(dis, Constraint)
- self.assertTrue(dis.active)
- self.assertEqual(len(dis), 2)
- self.check_outer_disaggregation_constraint(dis[0], m.x, m.d1, m.d2)
- self.assertIs(hull.get_disaggregation_constraint(m.x, m.disj), dis[0])
- self.check_outer_disaggregation_constraint(
- dis[1], m.x, m.d1.d3, m.d1.d4, rhs=hull.get_disaggregated_var(m.x, m.d1)
- )
- self.assertIs(hull.get_disaggregation_constraint(m.x, m.d1.disj2), dis[1])
-
- # we should have four disjunct transformation blocks
- disjBlocks = transBlock.relaxedDisjuncts
- self.assertTrue(disjBlocks.active)
- self.assertEqual(len(disjBlocks), 4)
-
- ## d1's transformation block
-
- disj1 = disjBlocks[0]
- self.assertTrue(disj1.active)
- self.assertIs(disj1, m.d1.transformation_block)
- self.assertIs(m.d1, hull.get_src_disjunct(disj1))
- # check the disaggregated x is here
- self.assertIsInstance(disj1.disaggregatedVars.x, Var)
- self.assertEqual(disj1.disaggregatedVars.x.lb, 0)
- self.assertEqual(disj1.disaggregatedVars.x.ub, 2)
- self.assertIs(disj1.disaggregatedVars.x, hull.get_disaggregated_var(m.x, m.d1))
- self.assertIs(m.x, hull.get_src_var(disj1.disaggregatedVars.x))
- # check the bounds constraints
- self.check_bounds_constraint_ub(
- disj1.x_bounds, 2, disj1.disaggregatedVars.x, m.d1.indicator_var
- )
- # transformed constraint x >= 1
- cons = hull.get_transformed_constraints(m.d1.c)
- self.check_transformed_constraint(
- cons, disj1.disaggregatedVars.x, 1, m.d1.indicator_var
+ xor = hull.get_transformed_constraints(xor)
+ self.assertEqual(len(xor), 1)
+ xor = xor[0]
+ ct.check_obj_in_active_tree(self, xor)
+ xor_expr = self.simplify_cons(xor)
+ assertExpressionsEqual(
+ self, xor_expr, d3 + d4 - m.d1.binary_indicator_var == 0.0
)
- ## d2's transformation block
+ # check disaggregation constraints
+ x_d3 = hull.get_disaggregated_var(m.x, m.d1.d3)
+ x_d4 = hull.get_disaggregated_var(m.x, m.d1.d4)
+ x_d1 = hull.get_disaggregated_var(m.x, m.d1)
+ x_d2 = hull.get_disaggregated_var(m.x, m.d2)
+ for x in [x_d1, x_d2, x_d3, x_d4]:
+ self.assertEqual(x.lb, 0)
+ self.assertEqual(x.ub, 2)
+ # Inner disjunction
+ cons = hull.get_disaggregation_constraint(m.x, m.d1.disj2)
+ ct.check_obj_in_active_tree(self, cons)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(self, cons_expr, x_d1 - x_d3 - x_d4 == 0.0)
+ # Outer disjunction
+ cons = hull.get_disaggregation_constraint(m.x, m.disj)
+ ct.check_obj_in_active_tree(self, cons)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(self, cons_expr, m.x - x_d1 - x_d2 == 0.0)
- disj2 = disjBlocks[1]
- self.assertTrue(disj2.active)
- self.assertIs(disj2, m.d2.transformation_block)
- self.assertIs(m.d2, hull.get_src_disjunct(disj2))
- # disaggregated var
- x2 = disj2.disaggregatedVars.x
- self.assertIsInstance(x2, Var)
- self.assertEqual(x2.lb, 0)
- self.assertEqual(x2.ub, 2)
- self.assertIs(hull.get_disaggregated_var(m.x, m.d2), x2)
- self.assertIs(hull.get_src_var(x2), m.x)
- # bounds constraint
- x_bounds = disj2.x_bounds
- self.check_bounds_constraint_ub(x_bounds, 2, x2, m.d2.binary_indicator_var)
- # transformed constraint x >= 1.1
- cons = hull.get_transformed_constraints(m.d2.c)
- self.check_transformed_constraint(cons, x2, 1.1, m.d2.binary_indicator_var)
-
- ## d1.d3's transformation block
-
- disj3 = disjBlocks[2]
- self.assertTrue(disj3.active)
- self.assertIs(disj3, m.d1.d3.transformation_block)
- self.assertIs(m.d1.d3, hull.get_src_disjunct(disj3))
- # disaggregated var
- x3 = disj3.disaggregatedVars.x
- self.assertIsInstance(x3, Var)
- self.assertEqual(x3.lb, 0)
- self.assertEqual(x3.ub, 2)
- self.assertIs(hull.get_disaggregated_var(m.x, m.d1.d3), x3)
- self.assertIs(hull.get_src_var(x3), m.x)
- # bounds constraints
- self.check_bounds_constraint_ub(
- disj3.x_bounds, 2, x3, m.d1.d3.binary_indicator_var
- )
- # transformed x >= 1.2
+ ## Transformed constraints
cons = hull.get_transformed_constraints(m.d1.d3.c)
- self.check_transformed_constraint(cons, x3, 1.2, m.d1.d3.binary_indicator_var)
-
- ## d1.d4's transformation block
-
- disj4 = disjBlocks[3]
- self.assertTrue(disj4.active)
- self.assertIs(disj4, m.d1.d4.transformation_block)
- self.assertIs(m.d1.d4, hull.get_src_disjunct(disj4))
- # disaggregated var
- x4 = disj4.disaggregatedVars.x
- self.assertIsInstance(x4, Var)
- self.assertEqual(x4.lb, 0)
- self.assertEqual(x4.ub, 2)
- self.assertIs(hull.get_disaggregated_var(m.x, m.d1.d4), x4)
- self.assertIs(hull.get_src_var(x4), m.x)
- # bounds constraints
- self.check_bounds_constraint_ub(
- disj4.x_bounds, 2, x4, m.d1.d4.binary_indicator_var
- )
- # transformed x >= 1.3
+ self.assertEqual(len(cons), 1)
+ cons = cons[0]
+ ct.check_obj_in_active_tree(self, cons)
+ cons_expr = self.simplify_leq_cons(cons)
+ assertExpressionsEqual(self, cons_expr, 1.2 * d3 - x_d3 <= 0.0)
+
cons = hull.get_transformed_constraints(m.d1.d4.c)
- self.check_transformed_constraint(cons, x4, 1.3, m.d1.d4.binary_indicator_var)
+ self.assertEqual(len(cons), 1)
+ cons = cons[0]
+ ct.check_obj_in_active_tree(self, cons)
+ cons_expr = self.simplify_leq_cons(cons)
+ assertExpressionsEqual(self, cons_expr, 1.3 * d4 - x_d4 <= 0.0)
+
+ cons = hull.get_transformed_constraints(m.d1.c)
+ self.assertEqual(len(cons), 1)
+ cons = cons[0]
+ ct.check_obj_in_active_tree(self, cons)
+ cons_expr = self.simplify_leq_cons(cons)
+ assertExpressionsEqual(
+ self, cons_expr, 1.0 * m.d1.binary_indicator_var - x_d1 <= 0.0
+ )
+
+ cons = hull.get_transformed_constraints(m.d2.c)
+ self.assertEqual(len(cons), 1)
+ cons = cons[0]
+ ct.check_obj_in_active_tree(self, cons)
+ cons_expr = self.simplify_leq_cons(cons)
+ assertExpressionsEqual(
+ self, cons_expr, 1.1 * m.d2.binary_indicator_var - x_d2 <= 0.0
+ )
+
+ ## Bounds constraints
+ cons = hull.get_var_bounds_constraint(x_d1)
+ # the lb is trivial in this case, so we just have 1
+ self.assertEqual(len(cons), 1)
+ ct.check_obj_in_active_tree(self, cons['ub'])
+ cons_expr = self.simplify_leq_cons(cons['ub'])
+ assertExpressionsEqual(
+ self, cons_expr, x_d1 - 2 * m.d1.binary_indicator_var <= 0.0
+ )
+ cons = hull.get_var_bounds_constraint(x_d2)
+ # the lb is trivial in this case, so we just have 1
+ self.assertEqual(len(cons), 1)
+ ct.check_obj_in_active_tree(self, cons['ub'])
+ cons_expr = self.simplify_leq_cons(cons['ub'])
+ assertExpressionsEqual(
+ self, cons_expr, x_d2 - 2 * m.d2.binary_indicator_var <= 0.0
+ )
+ cons = hull.get_var_bounds_constraint(x_d3, m.d1.d3)
+ # the lb is trivial in this case, so we just have 1
+ self.assertEqual(len(cons), 1)
+ # And we know it has actually been transformed again, so get that one
+ cons = hull.get_transformed_constraints(cons['ub'])
+ self.assertEqual(len(cons), 1)
+ ub = cons[0]
+ ct.check_obj_in_active_tree(self, ub)
+ cons_expr = self.simplify_leq_cons(ub)
+ assertExpressionsEqual(self, cons_expr, x_d3 - 2 * d3 <= 0.0)
+ cons = hull.get_var_bounds_constraint(x_d4, m.d1.d4)
+ # the lb is trivial in this case, so we just have 1
+ self.assertEqual(len(cons), 1)
+ # And we know it has actually been transformed again, so get that one
+ cons = hull.get_transformed_constraints(cons['ub'])
+ self.assertEqual(len(cons), 1)
+ ub = cons[0]
+ ct.check_obj_in_active_tree(self, ub)
+ cons_expr = self.simplify_leq_cons(ub)
+ assertExpressionsEqual(self, cons_expr, x_d4 - 2 * d4 <= 0.0)
+ cons = hull.get_var_bounds_constraint(x_d3, m.d1)
+ self.assertEqual(len(cons), 1)
+ ub = cons['ub']
+ ct.check_obj_in_active_tree(self, ub)
+ cons_expr = self.simplify_leq_cons(ub)
+ assertExpressionsEqual(
+ self, cons_expr, x_d3 - 2 * m.d1.binary_indicator_var <= 0.0
+ )
+ cons = hull.get_var_bounds_constraint(x_d4, m.d1)
+ self.assertEqual(len(cons), 1)
+ ub = cons['ub']
+ ct.check_obj_in_active_tree(self, ub)
+ cons_expr = self.simplify_leq_cons(ub)
+ assertExpressionsEqual(
+ self, cons_expr, x_d4 - 2 * m.d1.binary_indicator_var <= 0.0
+ )
+
+ # Bounds constraints for local vars
+ cons = hull.get_var_bounds_constraint(d3)
+ ct.check_obj_in_active_tree(self, cons['ub'])
+ assertExpressionsEqual(self, cons['ub'].expr, d3 <= m.d1.binary_indicator_var)
+ cons = hull.get_var_bounds_constraint(d4)
+ ct.check_obj_in_active_tree(self, cons['ub'])
+ assertExpressionsEqual(self, cons['ub'].expr, d4 <= m.d1.binary_indicator_var)
@unittest.skipIf(not linear_solvers, "No linear solver available")
def test_solve_nested_model(self):
# This is really a test that our variable references have all been moved
# up correctly.
m = models.makeNestedDisjunctions_NestedDisjuncts()
-
+ m.LocalVars = Suffix(direction=Suffix.LOCAL)
+ m.LocalVars[m.d1] = [
+ m.d1.binary_indicator_var,
+ m.d1.d3.binary_indicator_var,
+ m.d1.d4.binary_indicator_var,
+ ]
hull = TransformationFactory('gdp.hull')
m_hull = hull.create_using(m)
@@ -1722,10 +1778,10 @@ def test_disaggregated_vars_are_set_to_0_correctly(self):
hull.apply_to(m)
# this should be a feasible integer solution
- m.d1.indicator_var.fix(0)
- m.d2.indicator_var.fix(1)
- m.d3.indicator_var.fix(0)
- m.d4.indicator_var.fix(0)
+ m.d1.indicator_var.fix(False)
+ m.d2.indicator_var.fix(True)
+ m.d3.indicator_var.fix(False)
+ m.d4.indicator_var.fix(False)
results = SolverFactory(linear_solvers[0]).solve(m)
self.assertEqual(
@@ -1739,10 +1795,10 @@ def test_disaggregated_vars_are_set_to_0_correctly(self):
self.assertEqual(value(hull.get_disaggregated_var(m.x, m.d4)), 0)
# and what if one of the inner disjuncts is true?
- m.d1.indicator_var.fix(1)
- m.d2.indicator_var.fix(0)
- m.d3.indicator_var.fix(1)
- m.d4.indicator_var.fix(0)
+ m.d1.indicator_var.fix(True)
+ m.d2.indicator_var.fix(False)
+ m.d3.indicator_var.fix(True)
+ m.d4.indicator_var.fix(False)
results = SolverFactory(linear_solvers[0]).solve(m)
self.assertEqual(
@@ -1787,6 +1843,11 @@ def d_r(e):
e.c1 = Constraint(expr=e.lambdas[1] + e.lambdas[2] == 1)
e.c2 = Constraint(expr=m.x == 2 * e.lambdas[1] + 3 * e.lambdas[2])
+ d.LocalVars = Suffix(direction=Suffix.LOCAL)
+ d.LocalVars[d] = [
+ d.d_l.indicator_var.get_associated_binary(),
+ d.d_r.indicator_var.get_associated_binary(),
+ ]
d.inner_disj = Disjunction(expr=[d.d_l, d.d_r])
m.disj = Disjunction(expr=[m.d_l, m.d_r])
@@ -1809,28 +1870,159 @@ def d_r(e):
cons = hull.get_transformed_constraints(d.c1)
self.assertEqual(len(cons), 1)
convex_combo = cons[0]
+ convex_combo_expr = self.simplify_cons(convex_combo)
assertExpressionsEqual(
self,
- convex_combo.expr,
- lambda1 + lambda2 - (1 - d.indicator_var.get_associated_binary()) * 0.0
- == d.indicator_var.get_associated_binary(),
+ convex_combo_expr,
+ lambda1 + lambda2 - d.indicator_var.get_associated_binary() == 0.0,
)
cons = hull.get_transformed_constraints(d.c2)
self.assertEqual(len(cons), 1)
get_x = cons[0]
+ get_x_expr = self.simplify_cons(get_x)
assertExpressionsEqual(
- self,
- get_x.expr,
- x
- - (2 * lambda1 + 3 * lambda2)
- - (1 - d.indicator_var.get_associated_binary()) * 0.0
- == 0.0 * d.indicator_var.get_associated_binary(),
+ self, get_x_expr, x - 2 * lambda1 - 3 * lambda2 == 0.0
)
cons = hull.get_disaggregation_constraint(m.x, m.disj)
assertExpressionsEqual(self, cons.expr, m.x == x1 + x2)
cons = hull.get_disaggregation_constraint(m.x, m.d_r.inner_disj)
- assertExpressionsEqual(self, cons.expr, x2 == x3 + x4)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(self, cons_expr, x2 - x3 - x4 == 0.0)
+
+ def test_nested_with_var_that_does_not_appear_in_every_disjunct(self):
+ m = ConcreteModel()
+ m.x = Var(bounds=(0, 10))
+ m.y = Var(bounds=(-4, 5))
+ m.parent1 = Disjunct()
+ m.parent2 = Disjunct()
+ m.parent2.c = Constraint(expr=m.x == 0)
+ m.parent_disjunction = Disjunction(expr=[m.parent1, m.parent2])
+ m.child1 = Disjunct()
+ m.child1.c = Constraint(expr=m.x <= 8)
+ m.child2 = Disjunct()
+ m.child2.c = Constraint(expr=m.x + m.y <= 3)
+ m.child3 = Disjunct()
+ m.child3.c = Constraint(expr=m.x <= 7)
+ m.parent1.disjunction = Disjunction(expr=[m.child1, m.child2, m.child3])
+
+ hull = TransformationFactory('gdp.hull')
+ hull.apply_to(m)
+
+ y_c2 = hull.get_disaggregated_var(m.y, m.child2)
+ self.assertEqual(y_c2.bounds, (-4, 5))
+ other_y = hull.get_disaggregated_var(m.y, m.child1)
+ self.assertEqual(other_y.bounds, (-4, 5))
+ other_other_y = hull.get_disaggregated_var(m.y, m.child3)
+ self.assertIs(other_y, other_other_y)
+ y_p1 = hull.get_disaggregated_var(m.y, m.parent1)
+ self.assertEqual(y_p1.bounds, (-4, 5))
+ y_p2 = hull.get_disaggregated_var(m.y, m.parent2)
+ self.assertEqual(y_p2.bounds, (-4, 5))
+
+ y_cons = hull.get_disaggregation_constraint(m.y, m.parent1.disjunction)
+ # check that the disaggregated ys in the nested just sum to the original
+ y_cons_expr = self.simplify_cons(y_cons)
+ assertExpressionsEqual(self, y_cons_expr, y_p1 - other_y - y_c2 == 0.0)
+ y_cons = hull.get_disaggregation_constraint(m.y, m.parent_disjunction)
+ y_cons_expr = self.simplify_cons(y_cons)
+ assertExpressionsEqual(self, y_cons_expr, m.y - y_p2 - y_p1 == 0.0)
+
+ x_c1 = hull.get_disaggregated_var(m.x, m.child1)
+ x_c2 = hull.get_disaggregated_var(m.x, m.child2)
+ x_c3 = hull.get_disaggregated_var(m.x, m.child3)
+ x_p1 = hull.get_disaggregated_var(m.x, m.parent1)
+ x_p2 = hull.get_disaggregated_var(m.x, m.parent2)
+ x_cons_parent = hull.get_disaggregation_constraint(m.x, m.parent_disjunction)
+ assertExpressionsEqual(self, x_cons_parent.expr, m.x == x_p1 + x_p2)
+ x_cons_child = hull.get_disaggregation_constraint(m.x, m.parent1.disjunction)
+ x_cons_child_expr = self.simplify_cons(x_cons_child)
+ assertExpressionsEqual(
+ self, x_cons_child_expr, x_p1 - x_c1 - x_c2 - x_c3 == 0.0
+ )
+
+ def simplify_cons(self, cons):
+ visitor = LinearRepnVisitor({}, {}, {}, None)
+ lb = cons.lower
+ ub = cons.upper
+ self.assertEqual(cons.lb, cons.ub)
+ repn = visitor.walk_expression(cons.body)
+ self.assertIsNone(repn.nonlinear)
+ return repn.to_expression(visitor) == lb
+
+ def simplify_leq_cons(self, cons):
+ visitor = LinearRepnVisitor({}, {}, {}, None)
+ self.assertIsNone(cons.lower)
+ ub = cons.upper
+ repn = visitor.walk_expression(cons.body)
+ self.assertIsNone(repn.nonlinear)
+ return repn.to_expression(visitor) <= ub
+
+ def test_nested_with_var_that_skips_a_level(self):
+ m = ConcreteModel()
+
+ m.x = Var(bounds=(-2, 9))
+ m.y = Var(bounds=(-3, 8))
+
+ m.y1 = Disjunct()
+ m.y1.c1 = Constraint(expr=m.x >= 4)
+ m.y1.z1 = Disjunct()
+ m.y1.z1.c1 = Constraint(expr=m.y == 2)
+ m.y1.z1.w1 = Disjunct()
+ m.y1.z1.w1.c1 = Constraint(expr=m.x == 3)
+ m.y1.z1.w2 = Disjunct()
+ m.y1.z1.w2.c1 = Constraint(expr=m.x >= 1)
+ m.y1.z1.disjunction = Disjunction(expr=[m.y1.z1.w1, m.y1.z1.w2])
+ m.y1.z2 = Disjunct()
+ m.y1.z2.c1 = Constraint(expr=m.y == 1)
+ m.y1.disjunction = Disjunction(expr=[m.y1.z1, m.y1.z2])
+ m.y2 = Disjunct()
+ m.y2.c1 = Constraint(expr=m.x == 4)
+ m.disjunction = Disjunction(expr=[m.y1, m.y2])
+
+ hull = TransformationFactory('gdp.hull')
+ hull.apply_to(m)
+
+ x_y1 = hull.get_disaggregated_var(m.x, m.y1)
+ x_y2 = hull.get_disaggregated_var(m.x, m.y2)
+ x_z1 = hull.get_disaggregated_var(m.x, m.y1.z1)
+ x_z2 = hull.get_disaggregated_var(m.x, m.y1.z2)
+ x_w1 = hull.get_disaggregated_var(m.x, m.y1.z1.w1)
+ x_w2 = hull.get_disaggregated_var(m.x, m.y1.z1.w2)
+
+ y_z1 = hull.get_disaggregated_var(m.y, m.y1.z1)
+ y_z2 = hull.get_disaggregated_var(m.y, m.y1.z2)
+ y_y1 = hull.get_disaggregated_var(m.y, m.y1)
+ y_y2 = hull.get_disaggregated_var(m.y, m.y2)
+
+ cons = hull.get_disaggregation_constraint(m.x, m.y1.z1.disjunction)
+ self.assertTrue(cons.active)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(self, cons_expr, x_z1 - x_w1 - x_w2 == 0.0)
+ cons = hull.get_disaggregation_constraint(m.x, m.y1.disjunction)
+ self.assertTrue(cons.active)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(self, cons_expr, x_y1 - x_z2 - x_z1 == 0.0)
+ cons = hull.get_disaggregation_constraint(m.x, m.disjunction)
+ self.assertTrue(cons.active)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(self, cons_expr, m.x - x_y1 - x_y2 == 0.0)
+ cons = hull.get_disaggregation_constraint(
+ m.y, m.y1.z1.disjunction, raise_exception=False
+ )
+ self.assertIsNone(cons)
+ cons = hull.get_disaggregation_constraint(m.y, m.y1.disjunction)
+ self.assertTrue(cons.active)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(self, cons_expr, y_y1 - y_z1 - y_z2 == 0.0)
+ cons = hull.get_disaggregation_constraint(m.y, m.disjunction)
+ self.assertTrue(cons.active)
+ cons_expr = self.simplify_cons(cons)
+ assertExpressionsEqual(self, cons_expr, m.y - y_y2 - y_y1 == 0.0)
+
+ @unittest.skipUnless(gurobi_available, "Gurobi is not available")
+ def test_do_not_assume_nested_indicators_local(self):
+ ct.check_do_not_assume_nested_indicators_local(self, 'gdp.hull')
class TestSpecialCases(unittest.TestCase):
@@ -2100,27 +2292,19 @@ def test_mapping_method_errors(self):
hull = TransformationFactory('gdp.hull')
hull.apply_to(m)
- log = StringIO()
- with LoggingIntercept(log, 'pyomo.gdp.hull', logging.ERROR):
- self.assertRaisesRegex(
- AttributeError,
- "'NoneType' object has no attribute 'parent_block'",
- hull.get_var_bounds_constraint,
- m.w,
- )
- self.assertRegex(
- log.getvalue(),
+ with self.assertRaisesRegex(
+ GDP_Error,
".*Either 'w' is not a disaggregated variable, "
"or the disjunction that disaggregates it has "
"not been properly transformed.",
- )
+ ):
+ hull.get_var_bounds_constraint(m.w)
log = StringIO()
with LoggingIntercept(log, 'pyomo.gdp.hull', logging.ERROR):
self.assertRaisesRegex(
KeyError,
- r".*_pyomo_gdp_hull_reformulation.relaxedDisjuncts\[1\]."
- r"disaggregatedVars.w",
+ r".*disjunction",
hull.get_disaggregation_constraint,
m.d[1].transformation_block.disaggregatedVars.w,
m.disjunction,
@@ -2134,36 +2318,22 @@ def test_mapping_method_errors(self):
r"Disjunction 'disjunction'",
)
- log = StringIO()
- with LoggingIntercept(log, 'pyomo.gdp.hull', logging.ERROR):
- self.assertRaisesRegex(
- AttributeError,
- "'NoneType' object has no attribute 'parent_block'",
- hull.get_src_var,
- m.w,
- )
- self.assertRegex(
- log.getvalue(), ".*'w' does not appear to be a disaggregated variable"
- )
+ with self.assertRaisesRegex(
+ GDP_Error, ".*'w' does not appear to be a disaggregated variable"
+ ):
+ hull.get_src_var(m.w)
- log = StringIO()
- with LoggingIntercept(log, 'pyomo.gdp.hull', logging.ERROR):
- self.assertRaisesRegex(
- KeyError,
- r".*_pyomo_gdp_hull_reformulation.relaxedDisjuncts\[1\]."
- r"disaggregatedVars.w",
- hull.get_disaggregated_var,
- m.d[1].transformation_block.disaggregatedVars.w,
- m.d[1],
- )
- self.assertRegex(
- log.getvalue(),
+ with self.assertRaisesRegex(
+ GDP_Error,
r".*It does not appear "
r"'_pyomo_gdp_hull_reformulation."
r"relaxedDisjuncts\[1\].disaggregatedVars.w' "
r"is a variable that appears in disjunct "
r"'d\[1\]'",
- )
+ ):
+ hull.get_disaggregated_var(
+ m.d[1].transformation_block.disaggregatedVars.w, m.d[1]
+ )
m.random_disjunction = Disjunction(expr=[m.w == 2, m.w >= 7])
self.assertRaisesRegex(
@@ -2398,12 +2568,12 @@ def OneCentroidPerPt(m, i):
TransformationFactory('gdp.hull').apply_to(m)
# fix an optimal solution
- m.AssignPoint[1, 1].indicator_var.fix(1)
- m.AssignPoint[1, 2].indicator_var.fix(0)
- m.AssignPoint[2, 1].indicator_var.fix(0)
- m.AssignPoint[2, 2].indicator_var.fix(1)
- m.AssignPoint[3, 1].indicator_var.fix(1)
- m.AssignPoint[3, 2].indicator_var.fix(0)
+ m.AssignPoint[1, 1].indicator_var.fix(True)
+ m.AssignPoint[1, 2].indicator_var.fix(False)
+ m.AssignPoint[2, 1].indicator_var.fix(False)
+ m.AssignPoint[2, 2].indicator_var.fix(True)
+ m.AssignPoint[3, 1].indicator_var.fix(True)
+ m.AssignPoint[3, 2].indicator_var.fix(False)
m.cluster_center[1].fix(0.3059)
m.cluster_center[2].fix(0.8043)
diff --git a/pyomo/gdp/tests/test_util.py b/pyomo/gdp/tests/test_util.py
index fd555fc2f59..fa8e953f9f7 100644
--- a/pyomo/gdp/tests/test_util.py
+++ b/pyomo/gdp/tests/test_util.py
@@ -13,7 +13,7 @@
from pyomo.core import ConcreteModel, Var, Expression, Block, RangeSet, Any
import pyomo.core.expr as EXPR
-from pyomo.core.base.expression import _ExpressionData
+from pyomo.core.base.expression import NamedExpressionData
from pyomo.gdp.util import (
clone_without_expression_components,
is_child_of,
@@ -40,7 +40,7 @@ def test_clone_without_expression_components(self):
test = clone_without_expression_components(base, {})
self.assertIsNot(base, test)
self.assertEqual(base(), test())
- self.assertIsInstance(base, _ExpressionData)
+ self.assertIsInstance(base, NamedExpressionData)
self.assertIsInstance(test, EXPR.SumExpression)
test = clone_without_expression_components(base, {id(m.x): m.y})
self.assertEqual(3**2 + 3 - 1, test())
@@ -51,7 +51,7 @@ def test_clone_without_expression_components(self):
self.assertEqual(base(), test())
self.assertIsInstance(base, EXPR.SumExpression)
self.assertIsInstance(test, EXPR.SumExpression)
- self.assertIsInstance(base.arg(0), _ExpressionData)
+ self.assertIsInstance(base.arg(0), NamedExpressionData)
self.assertIsInstance(test.arg(0), EXPR.SumExpression)
test = clone_without_expression_components(base, {id(m.x): m.y})
self.assertEqual(3**2 + 3 - 1 + 3, test())
diff --git a/pyomo/gdp/transformed_disjunct.py b/pyomo/gdp/transformed_disjunct.py
index 6cf60abf414..287d5ed1652 100644
--- a/pyomo/gdp/transformed_disjunct.py
+++ b/pyomo/gdp/transformed_disjunct.py
@@ -10,11 +10,11 @@
# ___________________________________________________________________________
from pyomo.common.autoslots import AutoSlots
-from pyomo.core.base.block import _BlockData, IndexedBlock
+from pyomo.core.base.block import BlockData, IndexedBlock
from pyomo.core.base.global_set import UnindexedComponent_index, UnindexedComponent_set
-class _TransformedDisjunctData(_BlockData):
+class _TransformedDisjunctData(BlockData):
__slots__ = ('_src_disjunct',)
__autoslot_mappers__ = {'_src_disjunct': AutoSlots.weakref_mapper}
@@ -23,7 +23,7 @@ def src_disjunct(self):
return None if self._src_disjunct is None else self._src_disjunct()
def __init__(self, component):
- _BlockData.__init__(self, component)
+ BlockData.__init__(self, component)
# pointer to the Disjunct whose transformation block this is.
self._src_disjunct = None
diff --git a/pyomo/gdp/util.py b/pyomo/gdp/util.py
index 343b2fd4f42..2fe8e9e1dee 100644
--- a/pyomo/gdp/util.py
+++ b/pyomo/gdp/util.py
@@ -10,10 +10,9 @@
# ___________________________________________________________________________
from pyomo.gdp import GDP_Error, Disjunction
-from pyomo.gdp.disjunct import _DisjunctData, Disjunct
+from pyomo.gdp.disjunct import DisjunctData, Disjunct
import pyomo.core.expr as EXPR
-from pyomo.core.base.component import _ComponentBase
from pyomo.core import (
Block,
Suffix,
@@ -22,7 +21,7 @@
LogicalConstraint,
value,
)
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.common.collections import ComponentMap, ComponentSet, OrderedSet
from pyomo.opt import TerminationCondition, SolverStatus
@@ -144,13 +143,13 @@ def parent(self, u):
Arg:
u : A node in the tree
"""
+ if u in self._parent:
+ return self._parent[u]
if u not in self._vertices:
raise ValueError(
"'%s' is not a vertex in the GDP tree. Cannot "
"retrieve its parent." % u
)
- if u in self._parent:
- return self._parent[u]
else:
return None
@@ -169,7 +168,10 @@ def parent_disjunct(self, u):
Arg:
u : A node in the forest
"""
- return self.parent(self.parent(u))
+ if u.ctype is Disjunct:
+ return self.parent(self.parent(u))
+ else:
+ return self.parent(u)
def root_disjunct(self, u):
"""Returns the highest parent Disjunct in the hierarchy, or None if
@@ -183,7 +185,7 @@ def root_disjunct(self, u):
while True:
if parent is None:
return rootmost_disjunct
- if isinstance(parent, _DisjunctData) or parent.ctype is Disjunct:
+ if parent.ctype is Disjunct:
rootmost_disjunct = parent
parent = self.parent(parent)
@@ -243,7 +245,7 @@ def leaves(self):
@property
def disjunct_nodes(self):
for v in self._vertices:
- if isinstance(v, _DisjunctData) or v.ctype is Disjunct:
+ if v.ctype is Disjunct:
yield v
@@ -327,7 +329,7 @@ def get_gdp_tree(targets, instance, knownBlocks=None):
"Target '%s' is not a component on instance "
"'%s'!" % (t.name, instance.name)
)
- if t.ctype is Block or isinstance(t, _BlockData):
+ if t.ctype is Block or isinstance(t, BlockData):
_blocks = t.values() if t.is_indexed() else (t,)
for block in _blocks:
if not block.active:
@@ -384,7 +386,7 @@ def is_child_of(parent, child, knownBlocks=None):
if knownBlocks is None:
knownBlocks = {}
tmp = set()
- node = child if isinstance(child, (Block, _BlockData)) else child.parent_block()
+ node = child if isinstance(child, (Block, BlockData)) else child.parent_block()
while True:
known = knownBlocks.get(node)
if known:
@@ -449,7 +451,7 @@ def get_src_disjunct(transBlock):
Parameters
----------
- transBlock: _BlockData which is in the relaxedDisjuncts IndexedBlock
+ transBlock: BlockData which is in the relaxedDisjuncts IndexedBlock
on a transformation block.
"""
if (
@@ -474,22 +476,23 @@ def get_src_constraint(transformedConstraint):
a transformation block
"""
transBlock = transformedConstraint.parent_block()
+ src_constraints = transBlock.private_data('pyomo.gdp').src_constraint
# This should be our block, so if it's not, the user messed up and gave
# us the wrong thing. If they happen to also have a _constraintMap then
# the world is really against us.
- if not hasattr(transBlock, "_constraintMap"):
+ if transformedConstraint not in src_constraints:
raise GDP_Error(
"Constraint '%s' is not a transformed constraint"
% transformedConstraint.name
)
# if something goes wrong here, it's a bug in the mappings.
- return transBlock._constraintMap['srcConstraints'][transformedConstraint]
+ return src_constraints[transformedConstraint]
def _find_parent_disjunct(constraint):
# traverse up until we find the disjunct this constraint lives on
parent_disjunct = constraint.parent_block()
- while not isinstance(parent_disjunct, _DisjunctData):
+ while not isinstance(parent_disjunct, DisjunctData):
if parent_disjunct is None:
raise GDP_Error(
"Constraint '%s' is not on a disjunct and so was not "
@@ -521,24 +524,28 @@ def get_transformed_constraints(srcConstraint):
Parameters
----------
- srcConstraint: ScalarConstraint or _ConstraintData, which must be in
+ srcConstraint: ScalarConstraint or ConstraintData, which must be in
the subtree of a transformed Disjunct
"""
if srcConstraint.is_indexed():
raise GDP_Error(
"Argument to get_transformed_constraint should be "
- "a ScalarConstraint or _ConstraintData. (If you "
+ "a ScalarConstraint or ConstraintData. (If you "
"want the container for all transformed constraints "
"from an IndexedDisjunction, this is the parent "
"component of a transformed constraint originating "
- "from any of its _ComponentDatas.)"
+ "from any of its ComponentDatas.)"
)
transBlock = _get_constraint_transBlock(srcConstraint)
- try:
- return transBlock._constraintMap['transformedConstraints'][srcConstraint]
- except:
- logger.error("Constraint '%s' has not been transformed." % srcConstraint.name)
- raise
+ transformed_constraints = transBlock.private_data(
+ 'pyomo.gdp'
+ ).transformed_constraints
+ if srcConstraint in transformed_constraints:
+ return transformed_constraints[srcConstraint]
+ else:
+ raise GDP_Error(
+ "Constraint '%s' has not been transformed." % srcConstraint.name
+ )
def _warn_for_active_disjunct(innerdisjunct, outerdisjunct):
diff --git a/pyomo/mpec/complementarity.py b/pyomo/mpec/complementarity.py
index 79f76a9fc34..26968ef9fca 100644
--- a/pyomo/mpec/complementarity.py
+++ b/pyomo/mpec/complementarity.py
@@ -19,7 +19,7 @@
from pyomo.core import Constraint, Var, Block, Set
from pyomo.core.base.component import ModelComponentFactory
from pyomo.core.base.global_set import UnindexedComponent_index
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.core.base.disable_methods import disable_methods
from pyomo.core.base.initializer import (
Initializer,
@@ -43,7 +43,7 @@ def complements(a, b):
return ComplementarityTuple(a, b)
-class _ComplementarityData(_BlockData):
+class ComplementarityData(BlockData):
def _canonical_expression(self, e):
# Note: as the complimentarity component maintains references to
# the original expression (e), it is NOT safe or valid to bypass
@@ -179,9 +179,14 @@ def set_value(self, cc):
)
+class _ComplementarityData(metaclass=RenamedClass):
+ __renamed__new_class__ = ComplementarityData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register("Complementarity conditions.")
class Complementarity(Block):
- _ComponentDataClass = _ComplementarityData
+ _ComponentDataClass = ComplementarityData
def __new__(cls, *args, **kwds):
if cls != Complementarity:
@@ -298,9 +303,9 @@ def _conditional_block_printer(ostream, idx, data):
)
-class ScalarComplementarity(_ComplementarityData, Complementarity):
+class ScalarComplementarity(ComplementarityData, Complementarity):
def __init__(self, *args, **kwds):
- _ComplementarityData.__init__(self, self)
+ ComplementarityData.__init__(self, self)
Complementarity.__init__(self, *args, **kwds)
self._data[None] = self
self._index = UnindexedComponent_index
diff --git a/pyomo/network/arc.py b/pyomo/network/arc.py
index 42b7c6ea075..f2597b4c1bd 100644
--- a/pyomo/network/arc.py
+++ b/pyomo/network/arc.py
@@ -52,7 +52,7 @@ def _iterable_to_dict(vals, directed, name):
return vals
-class _ArcData(ActiveComponentData):
+class ArcData(ActiveComponentData):
"""
This class defines the data for a single Arc
@@ -246,6 +246,11 @@ def _validate_ports(self, source, destination, ports):
)
+class _ArcData(metaclass=RenamedClass):
+ __renamed__new_class__ = ArcData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register("Component used for connecting two Ports.")
class Arc(ActiveIndexedComponent):
"""
@@ -267,7 +272,7 @@ class Arc(ActiveIndexedComponent):
or a two-member iterable of ports
"""
- _ComponentDataClass = _ArcData
+ _ComponentDataClass = ArcData
def __new__(cls, *args, **kwds):
if cls != Arc:
@@ -373,9 +378,9 @@ def _pprint(self):
)
-class ScalarArc(_ArcData, Arc):
+class ScalarArc(ArcData, Arc):
def __init__(self, *args, **kwds):
- _ArcData.__init__(self, self)
+ ArcData.__init__(self, self)
Arc.__init__(self, *args, **kwds)
self.index = UnindexedComponent_index
diff --git a/pyomo/network/foqus_graph.py b/pyomo/network/foqus_graph.py
index e4cf3b92014..7c6c05256d9 100644
--- a/pyomo/network/foqus_graph.py
+++ b/pyomo/network/foqus_graph.py
@@ -358,9 +358,9 @@ def scc_calculation_order(self, sccNodes, ie, oe):
done = False
for i in range(len(sccNodes)):
for j in range(len(sccNodes)):
- for ine in ie[i]:
- for oute in oe[j]:
- if ine == oute:
+ for in_e in ie[i]:
+ for out_e in oe[j]:
+ if in_e == out_e:
adj[j].append(i)
adjR[i].append(j)
done = True
diff --git a/pyomo/network/port.py b/pyomo/network/port.py
index 26822d4fee9..f6706dce644 100644
--- a/pyomo/network/port.py
+++ b/pyomo/network/port.py
@@ -36,7 +36,7 @@
logger = logging.getLogger('pyomo.network')
-class _PortData(ComponentData):
+class PortData(ComponentData):
"""
This class defines the data for a single Port
@@ -285,6 +285,11 @@ def get_split_fraction(self, arc):
return res
+class _PortData(metaclass=RenamedClass):
+ __renamed__new_class__ = PortData
+ __renamed__version__ = '6.7.2'
+
+
@ModelComponentFactory.register(
"A bundle of variables that can be connected to other ports."
)
@@ -339,7 +344,7 @@ def __init__(self, *args, **kwd):
# IndexedComponent that support implicit definition
def _getitem_when_not_present(self, idx):
"""Returns the default component data value."""
- tmp = self._data[idx] = _PortData(component=self)
+ tmp = self._data[idx] = PortData(component=self)
tmp._index = idx
return tmp
@@ -357,7 +362,7 @@ def construct(self, data=None):
for _set in self._anonymous_sets:
_set.construct()
- # Construct _PortData objects for all index values
+ # Construct PortData objects for all index values
if self.is_indexed():
self._initialize_members(self._index_set)
else:
@@ -763,9 +768,9 @@ def _create_evar(member, name, eblock, index_set):
return evar
-class ScalarPort(Port, _PortData):
+class ScalarPort(Port, PortData):
def __init__(self, *args, **kwd):
- _PortData.__init__(self, component=self)
+ PortData.__init__(self, component=self)
Port.__init__(self, *args, **kwd)
self._index = UnindexedComponent_index
diff --git a/pyomo/opt/base/solvers.py b/pyomo/opt/base/solvers.py
index 68e719e3862..c0698165603 100644
--- a/pyomo/opt/base/solvers.py
+++ b/pyomo/opt/base/solvers.py
@@ -178,7 +178,11 @@ def __call__(self, _name=None, **kwds):
return opt
+LegacySolverFactory = SolverFactoryClass('solver type')
+
SolverFactory = SolverFactoryClass('solver type')
+SolverFactory._cls = LegacySolverFactory._cls
+SolverFactory._doc = LegacySolverFactory._doc
#
@@ -532,15 +536,15 @@ def solve(self, *args, **kwds):
# If the inputs are models, then validate that they have been
# constructed! Collect suffix names to try and import from solution.
#
- from pyomo.core.base.block import _BlockData
+ from pyomo.core.base.block import BlockData
import pyomo.core.base.suffix
from pyomo.core.kernel.block import IBlock
import pyomo.core.kernel.suffix
_model = None
for arg in args:
- if isinstance(arg, (_BlockData, IBlock)):
- if isinstance(arg, _BlockData):
+ if isinstance(arg, (BlockData, IBlock)):
+ if isinstance(arg, BlockData):
if not arg.is_constructed():
raise RuntimeError(
"Attempting to solve model=%s with unconstructed "
@@ -549,7 +553,7 @@ def solve(self, *args, **kwds):
_model = arg
# import suffixes must be on the top-level model
- if isinstance(arg, _BlockData):
+ if isinstance(arg, BlockData):
model_suffixes = list(
name
for (
diff --git a/pyomo/opt/results/problem.py b/pyomo/opt/results/problem.py
index 98f749f3aeb..a8eca1e3b41 100644
--- a/pyomo/opt/results/problem.py
+++ b/pyomo/opt/results/problem.py
@@ -12,19 +12,16 @@
import enum
from pyomo.opt.results.container import MapContainer
+from pyomo.common.enums import ExtendedEnumType, ObjectiveSense
-class ProblemSense(str, enum.Enum):
- unknown = 'unknown'
- minimize = 'minimize'
- maximize = 'maximize'
- # Overloading __str__ is needed to match the behavior of the old
- # pyutilib.enum class (removed June 2020). There are spots in the
- # code base that expect the string representation for items in the
- # enum to not include the class name. New uses of enum shouldn't
- # need to do this.
+class ProblemSense(enum.IntEnum, metaclass=ExtendedEnumType):
+ __base_enum__ = ObjectiveSense
+
+ unknown = 0
+
def __str__(self):
- return self.value
+ return self.name
class ProblemInformation(MapContainer):
diff --git a/pyomo/opt/solver/shellcmd.py b/pyomo/opt/solver/shellcmd.py
index 94117779237..baa0369e1d6 100644
--- a/pyomo/opt/solver/shellcmd.py
+++ b/pyomo/opt/solver/shellcmd.py
@@ -60,6 +60,7 @@ def __init__(self, **kwargs):
# a solver plugin may not report execution time.
self._last_solve_time = None
self._define_signal_handlers = None
+ self._version_timeout = 2
if executable is not None:
self.set_executable(name=executable, validate=validate)
diff --git a/pyomo/repn/beta/matrix.py b/pyomo/repn/beta/matrix.py
index 916b0daf755..0201c46eb18 100644
--- a/pyomo/repn/beta/matrix.py
+++ b/pyomo/repn/beta/matrix.py
@@ -24,7 +24,7 @@
Constraint,
IndexedConstraint,
ScalarConstraint,
- _ConstraintData,
+ ConstraintData,
)
from pyomo.core.expr.numvalue import native_numeric_types
from pyomo.repn import generate_standard_repn
@@ -247,7 +247,7 @@ def _get_bound(exp):
constraint_containers_removed += 1
for constraint, index in constraint_data_to_remove:
# Note that this del is not needed: assigning Constraint.Skip
- # above removes the _ConstraintData from the _data dict.
+ # above removes the ConstraintData from the _data dict.
# del constraint[index]
constraints_removed += 1
for block, constraint in constraint_containers_to_remove:
@@ -348,12 +348,12 @@ def _get_bound(exp):
)
-# class _LinearConstraintData(_ConstraintData,LinearCanonicalRepn):
+# class _LinearConstraintData(ConstraintData,LinearCanonicalRepn):
#
# This change breaks this class, but it's unclear whether this
# is being used...
#
-class _LinearConstraintData(_ConstraintData):
+class _LinearConstraintData(ConstraintData):
"""
This class defines the data for a single linear constraint
in canonical form.
@@ -393,7 +393,7 @@ def __init__(self, index, component=None):
#
# These lines represent in-lining of the
# following constructors:
- # - _ConstraintData,
+ # - ConstraintData,
# - ActiveComponentData
# - ComponentData
self._component = weakref_ref(component) if (component is not None) else None
@@ -442,7 +442,7 @@ def __init__(self, index, component=None):
# These lines represent in-lining of the
# following constructors:
# - _LinearConstraintData
- # - _ConstraintData,
+ # - ConstraintData,
# - ActiveComponentData
# - ComponentData
self._component = weakref_ref(component) if (component is not None) else None
@@ -584,7 +584,7 @@ def constant(self):
return sum(terms)
#
- # Abstract Interface (_ConstraintData)
+ # Abstract Interface (ConstraintData)
#
@property
diff --git a/pyomo/repn/linear.py b/pyomo/repn/linear.py
index 6ab4abfdaf5..6d084067511 100644
--- a/pyomo/repn/linear.py
+++ b/pyomo/repn/linear.py
@@ -31,8 +31,8 @@
MonomialTermExpression,
LinearExpression,
SumExpression,
- NPV_SumExpression,
ExternalFunctionExpression,
+ mutable_expression,
)
from pyomo.core.expr.relational_expr import (
EqualityExpression,
@@ -120,22 +120,14 @@ def to_expression(self, visitor):
ans = 0
if self.linear:
var_map = visitor.var_map
- if len(self.linear) == 1:
- vid, coef = next(iter(self.linear.items()))
- if coef == 1:
- ans += var_map[vid]
- elif coef:
- ans += MonomialTermExpression((coef, var_map[vid]))
- else:
- pass
- else:
- ans += LinearExpression(
- [
- MonomialTermExpression((coef, var_map[vid]))
- for vid, coef in self.linear.items()
- if coef
- ]
- )
+ with mutable_expression() as e:
+ for vid, coef in self.linear.items():
+ if coef:
+ e += coef * var_map[vid]
+ if e.nargs() > 1:
+ ans += e
+ elif e.nargs() == 1:
+ ans += e.arg(0)
if self.constant:
ans += self.constant
if self.multiplier != 1:
@@ -208,9 +200,8 @@ def _handle_negation_ANY(visitor, node, arg):
_exit_node_handlers[NegationExpression] = {
+ None: _handle_negation_ANY,
(_CONSTANT,): _handle_negation_constant,
- (_LINEAR,): _handle_negation_ANY,
- (_GENERAL,): _handle_negation_ANY,
}
#
@@ -219,20 +210,18 @@ def _handle_negation_ANY(visitor, node, arg):
def _handle_product_constant_constant(visitor, node, arg1, arg2):
- _, arg1 = arg1
- _, arg2 = arg2
- ans = arg1 * arg2
+ ans = arg1[1] * arg2[1]
if ans != ans:
- if not arg1 or not arg2:
+ if not arg1[1] or not arg2[1]:
deprecation_warning(
- f"Encountered {str(arg1)}*{str(arg2)} in expression tree. "
+ f"Encountered {str(arg1[1])}*{str(arg2[1])} in expression tree. "
"Mapping the NaN result to 0 for compatibility "
"with the lp_v1 writer. In the future, this NaN "
"will be preserved/emitted to comply with IEEE-754.",
version='6.6.0',
)
- return _, 0
- return _, arg1 * arg2
+ return _CONSTANT, 0
+ return _CONSTANT, ans
def _handle_product_constant_ANY(visitor, node, arg1, arg2):
@@ -284,15 +273,12 @@ def _handle_product_nonlinear(visitor, node, arg1, arg2):
_exit_node_handlers[ProductExpression] = {
+ None: _handle_product_nonlinear,
(_CONSTANT, _CONSTANT): _handle_product_constant_constant,
(_CONSTANT, _LINEAR): _handle_product_constant_ANY,
(_CONSTANT, _GENERAL): _handle_product_constant_ANY,
(_LINEAR, _CONSTANT): _handle_product_ANY_constant,
- (_LINEAR, _LINEAR): _handle_product_nonlinear,
- (_LINEAR, _GENERAL): _handle_product_nonlinear,
(_GENERAL, _CONSTANT): _handle_product_ANY_constant,
- (_GENERAL, _LINEAR): _handle_product_nonlinear,
- (_GENERAL, _GENERAL): _handle_product_nonlinear,
}
_exit_node_handlers[MonomialTermExpression] = _exit_node_handlers[ProductExpression]
@@ -306,7 +292,7 @@ def _handle_division_constant_constant(visitor, node, arg1, arg2):
def _handle_division_ANY_constant(visitor, node, arg1, arg2):
- arg1[1].multiplier /= arg2[1]
+ arg1[1].multiplier = apply_node_operation(node, (arg1[1].multiplier, arg2[1]))
return arg1
@@ -317,15 +303,10 @@ def _handle_division_nonlinear(visitor, node, arg1, arg2):
_exit_node_handlers[DivisionExpression] = {
+ None: _handle_division_nonlinear,
(_CONSTANT, _CONSTANT): _handle_division_constant_constant,
- (_CONSTANT, _LINEAR): _handle_division_nonlinear,
- (_CONSTANT, _GENERAL): _handle_division_nonlinear,
(_LINEAR, _CONSTANT): _handle_division_ANY_constant,
- (_LINEAR, _LINEAR): _handle_division_nonlinear,
- (_LINEAR, _GENERAL): _handle_division_nonlinear,
(_GENERAL, _CONSTANT): _handle_division_ANY_constant,
- (_GENERAL, _LINEAR): _handle_division_nonlinear,
- (_GENERAL, _GENERAL): _handle_division_nonlinear,
}
#
@@ -333,8 +314,7 @@ def _handle_division_nonlinear(visitor, node, arg1, arg2):
#
-def _handle_pow_constant_constant(visitor, node, *args):
- arg1, arg2 = args
+def _handle_pow_constant_constant(visitor, node, arg1, arg2):
ans = apply_node_operation(node, (arg1[1], arg2[1]))
if ans.__class__ in native_complex_types:
ans = complex_number_error(ans, visitor, node)
@@ -366,15 +346,10 @@ def _handle_pow_nonlinear(visitor, node, arg1, arg2):
_exit_node_handlers[PowExpression] = {
+ None: _handle_pow_nonlinear,
(_CONSTANT, _CONSTANT): _handle_pow_constant_constant,
- (_CONSTANT, _LINEAR): _handle_pow_nonlinear,
- (_CONSTANT, _GENERAL): _handle_pow_nonlinear,
(_LINEAR, _CONSTANT): _handle_pow_ANY_constant,
- (_LINEAR, _LINEAR): _handle_pow_nonlinear,
- (_LINEAR, _GENERAL): _handle_pow_nonlinear,
(_GENERAL, _CONSTANT): _handle_pow_ANY_constant,
- (_GENERAL, _LINEAR): _handle_pow_nonlinear,
- (_GENERAL, _GENERAL): _handle_pow_nonlinear,
}
#
@@ -397,9 +372,8 @@ def _handle_unary_nonlinear(visitor, node, arg):
_exit_node_handlers[UnaryFunctionExpression] = {
+ None: _handle_unary_nonlinear,
(_CONSTANT,): _handle_unary_constant,
- (_LINEAR,): _handle_unary_nonlinear,
- (_GENERAL,): _handle_unary_nonlinear,
}
_exit_node_handlers[AbsExpression] = _exit_node_handlers[UnaryFunctionExpression]
@@ -422,9 +396,8 @@ def _handle_named_ANY(visitor, node, arg1):
_exit_node_handlers[Expression] = {
+ None: _handle_named_ANY,
(_CONSTANT,): _handle_named_constant,
- (_LINEAR,): _handle_named_ANY,
- (_GENERAL,): _handle_named_ANY,
}
#
@@ -457,12 +430,7 @@ def _handle_expr_if_nonlinear(visitor, node, arg1, arg2, arg3):
return _GENERAL, ans
-_exit_node_handlers[Expr_ifExpression] = {
- (i, j, k): _handle_expr_if_nonlinear
- for i in (_LINEAR, _GENERAL)
- for j in (_CONSTANT, _LINEAR, _GENERAL)
- for k in (_CONSTANT, _LINEAR, _GENERAL)
-}
+_exit_node_handlers[Expr_ifExpression] = {None: _handle_expr_if_nonlinear}
for j in (_CONSTANT, _LINEAR, _GENERAL):
for k in (_CONSTANT, _LINEAR, _GENERAL):
_exit_node_handlers[Expr_ifExpression][_CONSTANT, j, k] = _handle_expr_if_const
@@ -495,11 +463,9 @@ def _handle_equality_general(visitor, node, arg1, arg2):
_exit_node_handlers[EqualityExpression] = {
- (i, j): _handle_equality_general
- for i in (_CONSTANT, _LINEAR, _GENERAL)
- for j in (_CONSTANT, _LINEAR, _GENERAL)
+ None: _handle_equality_general,
+ (_CONSTANT, _CONSTANT): _handle_equality_const,
}
-_exit_node_handlers[EqualityExpression][_CONSTANT, _CONSTANT] = _handle_equality_const
def _handle_inequality_const(visitor, node, arg1, arg2):
@@ -525,13 +491,9 @@ def _handle_inequality_general(visitor, node, arg1, arg2):
_exit_node_handlers[InequalityExpression] = {
- (i, j): _handle_inequality_general
- for i in (_CONSTANT, _LINEAR, _GENERAL)
- for j in (_CONSTANT, _LINEAR, _GENERAL)
+ None: _handle_inequality_general,
+ (_CONSTANT, _CONSTANT): _handle_inequality_const,
}
-_exit_node_handlers[InequalityExpression][
- _CONSTANT, _CONSTANT
-] = _handle_inequality_const
def _handle_ranged_const(visitor, node, arg1, arg2, arg3):
@@ -562,14 +524,9 @@ def _handle_ranged_general(visitor, node, arg1, arg2, arg3):
_exit_node_handlers[RangedExpression] = {
- (i, j, k): _handle_ranged_general
- for i in (_CONSTANT, _LINEAR, _GENERAL)
- for j in (_CONSTANT, _LINEAR, _GENERAL)
- for k in (_CONSTANT, _LINEAR, _GENERAL)
+ None: _handle_ranged_general,
+ (_CONSTANT, _CONSTANT, _CONSTANT): _handle_ranged_const,
}
-_exit_node_handlers[RangedExpression][
- _CONSTANT, _CONSTANT, _CONSTANT
-] = _handle_ranged_const
class LinearBeforeChildDispatcher(BeforeChildDispatcher):
@@ -704,6 +661,18 @@ def _before_linear(visitor, child):
linear[_id] = arg1
elif arg.__class__ in native_numeric_types:
const += arg
+ elif arg.is_variable_type():
+ _id = id(arg)
+ if _id not in var_map:
+ if arg.fixed:
+ const += visitor.check_constant(arg.value, arg)
+ continue
+ LinearBeforeChildDispatcher._record_var(visitor, arg)
+ linear[_id] = 1
+ elif _id in linear:
+ linear[_id] += 1
+ else:
+ linear[_id] = 1
else:
try:
const += visitor.check_constant(visitor.evaluate(arg), arg)
@@ -750,7 +719,10 @@ def _initialize_exit_node_dispatcher(exit_handlers):
exit_dispatcher = {}
for cls, handlers in exit_handlers.items():
for args, fcn in handlers.items():
- exit_dispatcher[(cls, *args)] = fcn
+ if args is None:
+ exit_dispatcher[cls] = fcn
+ else:
+ exit_dispatcher[(cls, *args)] = fcn
return exit_dispatcher
diff --git a/pyomo/repn/plugins/ampl/ampl_.py b/pyomo/repn/plugins/ampl/ampl_.py
index f422a085a3c..cc99e9cfdae 100644
--- a/pyomo/repn/plugins/ampl/ampl_.py
+++ b/pyomo/repn/plugins/ampl/ampl_.py
@@ -33,7 +33,7 @@
from pyomo.core.base import (
SymbolMap,
NameLabeler,
- _ExpressionData,
+ NamedExpressionData,
SortComponents,
var,
param,
@@ -168,11 +168,11 @@ def _build_op_template():
_op_template[EXPR.EqualityExpression] = "o24{C}\n"
_op_comment[EXPR.EqualityExpression] = "\t#eq"
- _op_template[var._VarData] = "v%d{C}\n"
- _op_comment[var._VarData] = "\t#%s"
+ _op_template[var.VarData] = "v%d{C}\n"
+ _op_comment[var.VarData] = "\t#%s"
- _op_template[param._ParamData] = "n%r{C}\n"
- _op_comment[param._ParamData] = ""
+ _op_template[param.ParamData] = "n%r{C}\n"
+ _op_comment[param.ParamData] = ""
_op_template[NumericConstant] = "n%r{C}\n"
_op_comment[NumericConstant] = ""
@@ -724,7 +724,7 @@ def _print_nonlinear_terms_NL(self, exp):
self._print_nonlinear_terms_NL(exp.arg(0))
self._print_nonlinear_terms_NL(exp.arg(1))
- elif isinstance(exp, (_ExpressionData, IIdentityExpression)):
+ elif isinstance(exp, (NamedExpressionData, IIdentityExpression)):
self._print_nonlinear_terms_NL(exp.expr)
else:
@@ -733,24 +733,24 @@ def _print_nonlinear_terms_NL(self, exp):
% (exp_type)
)
- elif isinstance(exp, (var._VarData, IVariable)) and (not exp.is_fixed()):
+ elif isinstance(exp, (var.VarData, IVariable)) and (not exp.is_fixed()):
# (self._output_fixed_variable_bounds or
if not self._symbolic_solver_labels:
OUTPUT.write(
- self._op_string[var._VarData]
+ self._op_string[var.VarData]
% (self.ampl_var_id[self._varID_map[id(exp)]])
)
else:
OUTPUT.write(
- self._op_string[var._VarData]
+ self._op_string[var.VarData]
% (
self.ampl_var_id[self._varID_map[id(exp)]],
self._name_labeler(exp),
)
)
- elif isinstance(exp, param._ParamData):
- OUTPUT.write(self._op_string[param._ParamData] % (value(exp)))
+ elif isinstance(exp, param.ParamData):
+ OUTPUT.write(self._op_string[param.ParamData] % (value(exp)))
elif isinstance(exp, NumericConstant) or exp.is_fixed():
OUTPUT.write(self._op_string[NumericConstant] % (value(exp)))
diff --git a/pyomo/repn/plugins/baron_writer.py b/pyomo/repn/plugins/baron_writer.py
index de19b5aad73..ab673b0c1c3 100644
--- a/pyomo/repn/plugins/baron_writer.py
+++ b/pyomo/repn/plugins/baron_writer.py
@@ -174,15 +174,26 @@ def _monomial_to_string(self, node):
return self.smap.getSymbol(var)
return ftoa(const, True) + '*' + self.smap.getSymbol(var)
+ def _var_to_string(self, node):
+ if node.is_fixed():
+ return ftoa(node.value, True)
+ self.variables.add(id(node))
+ return self.smap.getSymbol(node)
+
def _linear_to_string(self, node):
values = [
(
self._monomial_to_string(arg)
- if (
- arg.__class__ is EXPR.MonomialTermExpression
- and not arg.arg(1).is_fixed()
+ if arg.__class__ is EXPR.MonomialTermExpression
+ else (
+ ftoa(arg)
+ if arg.__class__ in native_numeric_types
+ else (
+ self._var_to_string(arg)
+ if arg.is_variable_type()
+ else ftoa(value(arg), True)
+ )
)
- else ftoa(value(arg))
)
for arg in node.args
]
diff --git a/pyomo/repn/plugins/cpxlp.py b/pyomo/repn/plugins/cpxlp.py
index 46e6b6d5265..45f4279f8fe 100644
--- a/pyomo/repn/plugins/cpxlp.py
+++ b/pyomo/repn/plugins/cpxlp.py
@@ -60,7 +60,7 @@ def __init__(self):
# The LP writer tracks which variables are
# referenced in constraints, so that a user does not end up with a
# zillion "unreferenced variables" warning messages.
- # This dictionary maps id(_VarData) -> _VarData.
+ # This dictionary maps id(VarData) -> VarData.
self._referenced_variable_ids = {}
# Per ticket #4319, we are using %.17g, which mocks the
@@ -374,7 +374,7 @@ def _print_expr_canonical(
def printSOS(self, symbol_map, labeler, variable_symbol_map, soscondata, output):
"""
- Prints the SOS constraint associated with the _SOSConstraintData object
+ Prints the SOS constraint associated with the SOSConstraintData object
"""
sos_template_string = self.sos_template_string
diff --git a/pyomo/repn/plugins/gams_writer.py b/pyomo/repn/plugins/gams_writer.py
index 5f94f176762..a0f407d7952 100644
--- a/pyomo/repn/plugins/gams_writer.py
+++ b/pyomo/repn/plugins/gams_writer.py
@@ -183,7 +183,16 @@ def _linear_to_string(self, node):
(
self._monomial_to_string(arg)
if arg.__class__ is EXPR.MonomialTermExpression
- else ftoa(arg, True)
+ else (
+ ftoa(arg, True)
+ if arg.__class__ in native_numeric_types
+ else (
+ self.smap.getSymbol(arg)
+ if arg.is_variable_type()
+ and (not arg.fixed or self.output_fixed_variables)
+ else ftoa(value(arg), True)
+ )
+ )
)
for arg in node.args
]
diff --git a/pyomo/repn/plugins/mps.py b/pyomo/repn/plugins/mps.py
index ba26783eea1..e1a0d2187fc 100644
--- a/pyomo/repn/plugins/mps.py
+++ b/pyomo/repn/plugins/mps.py
@@ -62,7 +62,7 @@ def __init__(self, int_marker=False):
# referenced in constraints, so that one doesn't end up with a
# zillion "unreferenced variables" warning messages. stored at
# the object level to avoid additional method arguments.
- # dictionary of id(_VarData)->_VarData.
+ # dictionary of id(VarData)->VarData.
self._referenced_variable_ids = {}
# Keven Hunter made a nice point about using %.16g in his attachment
diff --git a/pyomo/repn/plugins/nl_writer.py b/pyomo/repn/plugins/nl_writer.py
index 5c0b505a2be..43fd2fade68 100644
--- a/pyomo/repn/plugins/nl_writer.py
+++ b/pyomo/repn/plugins/nl_writer.py
@@ -11,10 +11,12 @@
import ctypes
import logging
+import math
+import operator
import os
from collections import deque, defaultdict, namedtuple
from contextlib import nullcontext
-from itertools import filterfalse, product
+from itertools import filterfalse, product, chain
from math import log10 as _log10
from operator import itemgetter, attrgetter, setitem
@@ -69,15 +71,11 @@
minimize,
)
from pyomo.core.base.component import ActiveComponent
-from pyomo.core.base.constraint import _ConstraintData
-from pyomo.core.base.expression import ScalarExpression, _GeneralExpressionData
-from pyomo.core.base.objective import (
- ScalarObjective,
- _GeneralObjectiveData,
- _ObjectiveData,
-)
+from pyomo.core.base.constraint import ConstraintData
+from pyomo.core.base.expression import ScalarExpression, ExpressionData
+from pyomo.core.base.objective import ScalarObjective, ObjectiveData
from pyomo.core.base.suffix import SuffixFinder
-from pyomo.core.base.var import _VarData
+from pyomo.core.base.var import VarData
import pyomo.core.kernel as kernel
from pyomo.core.pyomoobject import PyomoObject
from pyomo.opt import WriterFactory
@@ -113,6 +111,7 @@
TOL = 1e-8
inf = float('inf')
minus_inf = -inf
+allowable_binary_var_bounds = {(0, 0), (0, 1), (1, 1)}
_CONSTANT = ExprType.CONSTANT
_MONOMIAL = ExprType.MONOMIAL
@@ -129,17 +128,17 @@ class NLWriterInfo(object):
Attributes
----------
- variables: List[_VarData]
+ variables: List[VarData]
The list of (unfixed) Pyomo model variables in the order written
to the NL file
- constraints: List[_ConstraintData]
+ constraints: List[ConstraintData]
The list of (active) Pyomo model constraints in the order written
to the NL file
- objectives: List[_ObjectiveData]
+ objectives: List[ObjectiveData]
The list of (active) Pyomo model objectives in the order written
to the NL file
@@ -162,10 +161,10 @@ class NLWriterInfo(object):
file in the same order as the :py:attr:`variables` and generated
.col file.
- eliminated_vars: List[Tuple[_VarData, NumericExpression]]
+ eliminated_vars: List[Tuple[VarData, NumericExpression]]
The list of variables in the model that were eliminated by the
- presolve. Each entry is a 2-tuple of (:py:class:`_VarData`,
+ presolve. Each entry is a 2-tuple of (:py:class:`VarData`,
:py:class`NumericExpression`|`float`). The list is in the
necessary order for correct evaluation (i.e., all variables
appearing in the expression must either have been sent to the
@@ -214,7 +213,7 @@ class NLWriter(object):
CONFIG.declare(
'skip_trivial_constraints',
ConfigValue(
- default=False,
+ default=True,
domain=bool,
description='Skip writing constraints whose body is constant',
),
@@ -338,6 +337,9 @@ def __call__(self, model, filename, solver_capability, io_options):
config.scale_model = False
config.linear_presolve = False
+ # just for backwards compatibility
+ config.skip_trivial_constraints = False
+
if config.symbolic_solver_labels:
_open = lambda fname: open(fname, 'w')
else:
@@ -369,7 +371,9 @@ def __call__(self, model, filename, solver_capability, io_options):
return filename, symbol_map
@document_kwargs_from_configdict(CONFIG)
- def write(self, model, ostream, rowstream=None, colstream=None, **options):
+ def write(
+ self, model, ostream, rowstream=None, colstream=None, **options
+ ) -> NLWriterInfo:
"""Write a model in NL format.
Returns
@@ -436,6 +440,7 @@ def store(self, obj, val):
self.values[obj] = val
def compile(self, column_order, row_order, obj_order, model_id):
+ var_con_obj = {Var, Constraint, Objective}
missing_component_data = ComponentSet()
unknown_data = ComponentSet()
queue = [self.values.items()]
@@ -461,18 +466,20 @@ def compile(self, column_order, row_order, obj_order, model_id):
self.obj[obj_order[_id]] = val
elif _id == model_id:
self.prob[0] = val
- elif isinstance(obj, (_VarData, _ConstraintData, _ObjectiveData)):
- missing_component_data.add(obj)
- elif isinstance(obj, (Var, Constraint, Objective)):
- # Expand this indexed component to store the
- # individual ComponentDatas, but ONLY if the
- # component data is not in the original dictionary
- # of values that we extracted from the Suffixes
- queue.append(
- product(
- filterfalse(self.values.__contains__, obj.values()), (val,)
+ elif getattr(obj, 'ctype', None) in var_con_obj:
+ if obj.is_indexed():
+ # Expand this indexed component to store the
+ # individual ComponentDatas, but ONLY if the
+ # component data is not in the original dictionary
+ # of values that we extracted from the Suffixes
+ queue.append(
+ product(
+ filterfalse(self.values.__contains__, obj.values()),
+ (val,),
+ )
)
- )
+ else:
+ missing_component_data.add(obj)
else:
unknown_data.add(obj)
if missing_component_data:
@@ -537,15 +544,15 @@ def __init__(self, ostream, rowstream, colstream, config):
else:
self.template = text_nl_template
self.subexpression_cache = {}
- self.subexpression_order = []
+ self.subexpression_order = None # set to [] later
self.external_functions = {}
self.used_named_expressions = set()
self.var_map = {}
+ self.var_id_to_nl_map = {}
self.sorter = FileDeterminism_to_SortComponents(config.file_determinism)
self.visitor = AMPLRepnVisitor(
self.template,
self.subexpression_cache,
- self.subexpression_order,
self.external_functions,
self.var_map,
self.used_named_expressions,
@@ -615,6 +622,7 @@ def write(self, model):
ostream = self.ostream
linear_presolve = self.config.linear_presolve
+ nl_map = self.var_id_to_nl_map
var_map = self.var_map
initialize_var_map_from_column_order(model, self.config, var_map)
timer.toc('Initialized column order', level=logging.DEBUG)
@@ -695,8 +703,7 @@ def write(self, model):
objectives.extend(linear_objs)
n_objs = len(objectives)
- constraints = []
- linear_cons = []
+ all_constraints = []
n_ranges = 0
n_equality = 0
n_complementarity_nonlin = 0
@@ -733,22 +740,7 @@ def write(self, model):
ub = ub * scale
if scale < 0:
lb, ub = ub, lb
- if expr_info.nonlinear:
- constraints.append((con, expr_info, lb, ub))
- elif expr_info.linear:
- linear_cons.append((con, expr_info, lb, ub))
- elif not self.config.skip_trivial_constraints:
- linear_cons.append((con, expr_info, lb, ub))
- else: # constant constraint and skip_trivial_constraints
- c = expr_info.const
- if (lb is not None and lb - c > TOL) or (
- ub is not None and ub - c < -TOL
- ):
- raise InfeasibleConstraintException(
- "model contains a trivially infeasible "
- f"constraint '{con.name}' (fixed body value "
- f"{c} outside bounds [{lb}, {ub}])."
- )
+ all_constraints.append((con, expr_info, lb, ub))
if linear_presolve:
con_id = id(con)
if not expr_info.nonlinear and lb == ub and lb is not None:
@@ -759,28 +751,68 @@ def write(self, model):
# report the last constraint
timer.toc('Constraint %s', last_parent, level=logging.DEBUG)
else:
- timer.toc('Processed %s constraints', len(constraints))
+ timer.toc('Processed %s constraints', len(all_constraints))
+
+ # We have identified all the external functions (resolving them
+ # by name). Now we may need to resolve the function by the
+ # (local) FID, which we know is indexed by integers starting at
+ # 0. We will convert the dict to a list for efficient lookup.
+ self.external_functions = list(self.external_functions.values())
# This may fetch more bounds than needed, but only in the cases
# where variables were completely eliminated while walking the
# expressions, or when users provide superfluous variables in
# the column ordering.
var_bounds = {_id: v.bounds for _id, v in var_map.items()}
+ var_values = {_id: v.value for _id, v in var_map.items()}
eliminated_cons, eliminated_vars = self._linear_presolve(
- comp_by_linear_var, lcon_by_linear_nnz, var_bounds
+ comp_by_linear_var, lcon_by_linear_nnz, var_bounds, var_values
)
del comp_by_linear_var
del lcon_by_linear_nnz
- # Order the constraints, moving all nonlinear constraints to
- # the beginning
- n_nonlinear_cons = len(constraints)
+ # Note: defer categorizing constraints until after presolve, as
+ # the presolver could result in nonlinear constraints becoming
+ # linear (or trivial)
+ constraints = []
+ linear_cons = []
if eliminated_cons:
_removed = eliminated_cons.__contains__
- constraints.extend(filterfalse(lambda c: _removed(id(c[0])), linear_cons))
+ _constraints = filterfalse(lambda c: _removed(id(c[0])), all_constraints)
else:
- constraints.extend(linear_cons)
+ _constraints = all_constraints
+ for info in _constraints:
+ expr_info = info[1]
+ if expr_info.nonlinear:
+ nl, args = expr_info.nonlinear
+ if any(vid not in nl_map for vid in args):
+ constraints.append(info)
+ continue
+ expr_info.const += _evaluate_constant_nl(
+ nl % tuple(nl_map[i] for i in args), self.external_functions
+ )
+ expr_info.nonlinear = None
+ if expr_info.linear:
+ linear_cons.append(info)
+ elif not self.config.skip_trivial_constraints:
+ linear_cons.append(info)
+ else: # constant constraint and skip_trivial_constraints
+ c = expr_info.const
+ con, expr_info, lb, ub = info
+ if (lb is not None and lb - c > TOL) or (
+ ub is not None and ub - c < -TOL
+ ):
+ raise InfeasibleConstraintException(
+ "model contains a trivially infeasible "
+ f"constraint '{con.name}' (fixed body value "
+ f"{c} outside bounds [{lb}, {ub}])."
+ )
+
+ # Order the constraints, moving all nonlinear constraints to
+ # the beginning
+ n_nonlinear_cons = len(constraints)
+ constraints.extend(linear_cons)
n_cons = len(constraints)
#
@@ -793,7 +825,7 @@ def write(self, model):
# Filter out any unused named expressions
self.subexpression_order = list(
- filter(self.used_named_expressions.__contains__, self.subexpression_order)
+ filter(self.used_named_expressions.__contains__, self.subexpression_cache)
)
# linear contribution by (constraint, objective, variable) component.
@@ -815,10 +847,7 @@ def write(self, model):
# We need to categorize the named subexpressions first so that
# we know their linear / nonlinear vars when we encounter them
# in constraints / objectives
- self._categorize_vars(
- map(self.subexpression_cache.__getitem__, self.subexpression_order),
- linear_by_comp,
- )
+ self._categorize_vars(self.subexpression_cache.values(), linear_by_comp)
n_subexpressions = self._count_subexpression_occurrences()
obj_vars_linear, obj_vars_nonlinear, obj_nnz_by_var = self._categorize_vars(
objectives, linear_by_comp
@@ -842,6 +871,7 @@ def write(self, model):
if _id not in var_map:
var_map[_id] = _v
var_bounds[_id] = _v.bounds
+ var_values[_id] = _v.value
con_vars_nonlinear.add(_id)
con_nnz = sum(con_nnz_by_var.values())
@@ -877,7 +907,12 @@ def write(self, model):
elif v.is_binary():
binary_vars.add(_id)
elif v.is_integer():
- integer_vars.add(_id)
+ # Note: integer variables whose bounds are in {0, 1}
+ # should be classified as binary
+ if var_bounds[_id] in allowable_binary_var_bounds:
+ binary_vars.add(_id)
+ else:
+ integer_vars.add(_id)
else:
raise ValueError(
f"Variable '{v.name}' has a domain that is not Real, "
@@ -1031,8 +1066,8 @@ def write(self, model):
row_comments = [f'\t#{lbl}' for lbl in row_labels]
col_labels = [labeler(var_map[_id]) for _id in variables]
col_comments = [f'\t#{lbl}' for lbl in col_labels]
- self.var_id_to_nl = {
- _id: f'v{var_idx}{col_comments[var_idx]}'
+ id2nl = {
+ _id: f'v{var_idx}{col_comments[var_idx]}\n'
for var_idx, _id in enumerate(variables)
}
# Write out the .row and .col data
@@ -1045,11 +1080,12 @@ def write(self, model):
else:
row_labels = row_comments = [''] * (n_cons + n_objs)
col_labels = col_comments = [''] * len(variables)
- self.var_id_to_nl = {
- _id: f"v{var_idx}" for var_idx, _id in enumerate(variables)
- }
+ id2nl = {_id: f"v{var_idx}\n" for var_idx, _id in enumerate(variables)}
- _vmap = self.var_id_to_nl
+ if nl_map:
+ nl_map.update(id2nl)
+ else:
+ self.var_id_to_nl_map = nl_map = id2nl
if scale_model:
template = self.template
objective_scaling = [scaling_cache[id(info[0])] for info in objectives]
@@ -1069,16 +1105,42 @@ def write(self, model):
if ub is not None:
ub *= scale
var_bounds[_id] = lb, ub
- # Update _vmap to output scaled variables in NL expressions
- _vmap[_id] = (
- template.division + _vmap[_id] + '\n' + template.const % scale
- ).rstrip()
+ # Update nl_map to output scaled variables in NL expressions
+ nl_map[_id] = template.division + nl_map[_id] + template.const % scale
# Update any eliminated variables to point to the (potentially
# scaled) substituted variables
- for _id, expr_info in eliminated_vars.items():
+ for _id, expr_info in list(eliminated_vars.items()):
nl, args, _ = expr_info.compile_repn(visitor)
- _vmap[_id] = nl.rstrip() % tuple(_vmap[_id] for _id in args)
+ for _i in args:
+ # It is possible that the eliminated variable could
+ # reference another variable that is no longer part of
+ # the model and therefore does not have a nl_map entry.
+ # This can happen when there is an underdetermined
+ # independent linear subsystem and the presolve removed
+ # all the constraints from the subsystem. Because the
+ # free variables in the subsystem are not referenced
+ # anywhere else in the model, they are not part of the
+ # `variables` list. Implicitly "fix" it to an arbitrary
+ # valid value from the presolved domain (see #3192).
+ if _i not in nl_map:
+ lb, ub = var_bounds[_i]
+ if lb is None:
+ lb = -inf
+ if ub is None:
+ ub = inf
+ if lb <= 0 <= ub:
+ val = 0
+ else:
+ val = lb if abs(lb) < abs(ub) else ub
+ eliminated_vars[_i] = AMPLRepn(val, {}, None)
+ nl_map[_i] = expr_info.compile_repn(visitor)[0]
+ logger.warning(
+ "presolve identified an underdetermined independent "
+ "linear subsystem that was removed from the model. "
+ f"Setting '{var_map[_i]}' == {val}"
+ )
+ nl_map[_id] = nl % tuple(nl_map[_i] for _i in args)
r_lines = [None] * n_cons
for idx, (con, expr_info, lb, ub) in enumerate(constraints):
@@ -1244,8 +1306,8 @@ def write(self, model):
len(linear_binary_vars),
len(linear_integer_vars),
len(both_vars_nonlinear.intersection(discrete_vars)),
- len(con_vars_nonlinear.intersection(discrete_vars)),
- len(obj_vars_nonlinear.intersection(discrete_vars)),
+ len(con_only_nonlinear_vars.intersection(discrete_vars)),
+ len(obj_only_nonlinear_vars.intersection(discrete_vars)),
)
)
#
@@ -1277,7 +1339,7 @@ def write(self, model):
# "F" lines (external function definitions)
#
amplfunc_libraries = set()
- for fid, fcn in sorted(self.external_functions.values()):
+ for fid, fcn in self.external_functions:
amplfunc_libraries.add(fcn._library)
ostream.write("F%d 1 -1 %s\n" % (fid, fcn._function))
@@ -1431,7 +1493,7 @@ def write(self, model):
#
_init_lines = [
(var_idx, val if val.__class__ in int_float else float(val))
- for var_idx, val in enumerate(var_map[_id].value for _id in variables)
+ for var_idx, val in enumerate(map(var_values.__getitem__, variables))
if val is not None
]
if scale_model:
@@ -1652,12 +1714,13 @@ def _categorize_vars(self, comp_list, linear_by_comp):
expr_info.linear = dict.fromkeys(nonlinear_vars, 0)
all_nonlinear_vars.update(nonlinear_vars)
- # Update the count of components that each variable appears in
- for v in expr_info.linear:
- if v in nnz_by_var:
- nnz_by_var[v] += 1
- else:
- nnz_by_var[v] = 1
+ if expr_info.linear:
+ # Update the count of components that each variable appears in
+ for v in expr_info.linear:
+ if v in nnz_by_var:
+ nnz_by_var[v] += 1
+ else:
+ nnz_by_var[v] = 1
# Record all nonzero variable ids for this component
linear_by_comp[id(comp_info[0])] = expr_info.linear
# Linear models (or objectives) are common. Avoid the set
@@ -1697,7 +1760,9 @@ def _count_subexpression_occurrences(self):
n_subexpressions[0] += 1
return n_subexpressions
- def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
+ def _linear_presolve(
+ self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds, var_values
+ ):
eliminated_vars = {}
eliminated_cons = set()
if not self.config.linear_presolve:
@@ -1718,6 +1783,7 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
var_map = self.var_map
substitutions_by_linear_var = defaultdict(set)
template = self.template
+ nl_map = self.var_id_to_nl_map
one_var = lcon_by_linear_nnz[1]
two_var = lcon_by_linear_nnz[2]
while 1:
@@ -1727,6 +1793,7 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
b, _ = var_bounds[_id]
logger.debug("NL presolve: bounds fixed %s := %s", var_map[_id], b)
eliminated_vars[_id] = AMPLRepn(b, {}, None)
+ nl_map[_id] = template.const % b
elif one_var:
con_id, info = one_var.popitem()
expr_info, lb = info
@@ -1736,6 +1803,7 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
b = expr_info.const = (lb - expr_info.const) / coef
logger.debug("NL presolve: substituting %s := %s", var_map[_id], b)
eliminated_vars[_id] = expr_info
+ nl_map[_id] = template.const % b
lb, ub = var_bounds[_id]
if (lb is not None and lb - b > TOL) or (
ub is not None and ub - b < -TOL
@@ -1755,7 +1823,7 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
id2_isdiscrete = var_map[id2].domain.isdiscrete()
if var_map[_id].domain.isdiscrete() ^ id2_isdiscrete:
# if only one variable is discrete, then we need to
- # substiitute out the other
+ # substitute out the other
if id2_isdiscrete:
_id, id2 = id2, _id
coef, coef2 = coef2, coef
@@ -1770,7 +1838,7 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
):
_id, id2 = id2, _id
coef, coef2 = coef2, coef
- # substituting _id with a*x + b
+ # eliminating _id and replacing it with a*x + b
a = -coef2 / coef
x = id2
b = expr_info.const = (lb - expr_info.const) / coef
@@ -1800,9 +1868,28 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
var_bounds[x] = x_lb, x_ub
if x_lb == x_ub and x_lb is not None:
fixed_vars.append(x)
+ # Given that we are eliminating a variable, we want to
+ # attempt to sanely resolve the initial variable values.
+ y_init = var_values[_id]
+ if y_init is not None:
+ # Y has a value
+ x_init = var_values[x]
+ if x_init is None:
+ # X does not; just use the one calculated from Y
+ x_init = (y_init - b) / a
+ else:
+ # X does too, use the average of the two values
+ x_init = (x_init + (y_init - b) / a) / 2.0
+ # Ensure that the initial value respects the
+ # tightened bounds
+ if x_ub is not None and x_init > x_ub:
+ x_init = x_ub
+ if x_lb is not None and x_init < x_lb:
+ x_init = x_lb
+ var_values[x] = x_init
eliminated_cons.add(con_id)
else:
- return eliminated_cons, eliminated_vars
+ break
for con_id, expr_info in comp_by_linear_var[_id]:
# Note that if we were aggregating (i.e., _id was
# from two_var), then one of these info's will be
@@ -1815,10 +1902,15 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
# appropriately (that expr_info is persisting in the
# eliminated_vars dict - and we will use that to
# update other linear expressions later.)
+ old_nnz = len(expr_info.linear)
c = expr_info.linear.pop(_id, 0)
+ nnz = old_nnz - 1
expr_info.const += c * b
if x in expr_info.linear:
expr_info.linear[x] += c * a
+ if expr_info.linear[x] == 0:
+ nnz -= 1
+ coef = expr_info.linear.pop(x)
elif a:
expr_info.linear[x] = c * a
# replacing _id with x... NNZ is not changing,
@@ -1826,10 +1918,17 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
# this constraint
comp_by_linear_var[x].append((con_id, expr_info))
continue
- # NNZ has been reduced by 1
- nnz = len(expr_info.linear)
- _old = lcon_by_linear_nnz[nnz + 1]
+ _old = lcon_by_linear_nnz[old_nnz]
if con_id in _old:
+ if not nnz:
+ if abs(expr_info.const) > TOL:
+ # constraint is trivially infeasible
+ raise InfeasibleConstraintException(
+ "model contains a trivially infeasible constraint "
+ f"{expr_info.const} == {coef}*{var_map[x]}"
+ )
+ # constraint is trivially feasible
+ eliminated_cons.add(con_id)
lcon_by_linear_nnz[nnz][con_id] = _old.pop(con_id)
# If variables were replaced by the variable that
# we are currently eliminating, then we need to update
@@ -1842,6 +1941,42 @@ def _linear_presolve(self, comp_by_linear_var, lcon_by_linear_nnz, var_bounds):
expr_info.linear[x] += c * a
elif a:
expr_info.linear[x] = c * a
+ elif not expr_info.linear:
+ nl_map[resubst] = template.const % expr_info.const
+
+ # Note: the ASL will (silently) produce incorrect answers if the
+ # nonlinear portion of a defined variable is a constant
+ # expression. This may not be the case if all the variables in
+ # the original nonlinear expression have been fixed.
+ for _id, (expr, info, sub) in self.subexpression_cache.items():
+ if info.nonlinear:
+ nl, args = info.nonlinear
+ # Note: 'not args' skips string arguments
+ # Note: 'vid in nl_map' skips eliminated
+ # variables and defined variables reduced to constants
+ if not args or any(vid not in nl_map for vid in args):
+ continue
+ # Ideally, we would just evaluate the named expression.
+ # However, there might be a linear portion of the named
+ # expression that still has free variables, and there is no
+ # guarantee that the user actually initialized the
+ # variables. So, we will fall back on parsing the (now
+ # constant) nonlinear fragment and evaluating it.
+ info.nonlinear = None
+ info.const += _evaluate_constant_nl(
+ nl % tuple(nl_map[i] for i in args), self.external_functions
+ )
+ if not info.linear:
+ # This has resolved to a constant: the ASL will fail for
+ # defined variables containing ONLY a constant. We
+ # need to substitute the constant directly into the
+ # original constraint/objective expression(s)
+ info.linear = {}
+ self.used_named_expressions.discard(_id)
+ nl_map[_id] = template.const % info.const
+ self.subexpression_cache[_id] = (expr, info, [None, None, True])
+
+ return eliminated_cons, eliminated_vars
def _record_named_expression_usage(self, named_exprs, src, comp_type):
self.used_named_expressions.update(named_exprs)
@@ -1867,7 +2002,24 @@ def _write_nl_expression(self, repn, include_const):
# Add the constant to the NL expression. AMPL adds the
# constant as the second argument, so we will too.
nl = self.template.binary_sum + nl + self.template.const % repn.const
- self.ostream.write(nl % tuple(map(self.var_id_to_nl.__getitem__, args)))
+ try:
+ self.ostream.write(
+ nl % tuple(map(self.var_id_to_nl_map.__getitem__, args))
+ )
+ except KeyError:
+ final_args = []
+ for arg in args:
+ if arg in self.var_id_to_nl_map:
+ final_args.append(self.var_id_to_nl_map[arg])
+ else:
+ _nl, _ids, _ = self.subexpression_cache[arg][1].compile_repn(
+ self.visitor
+ )
+ final_args.append(
+ _nl % tuple(map(self.var_id_to_nl_map.__getitem__, _ids))
+ )
+ self.ostream.write(nl % tuple(final_args))
+
elif include_const:
self.ostream.write(self.template.const % repn.const)
else:
@@ -1881,7 +2033,7 @@ def _write_v_line(self, expr_id, k):
lbl = '\t#%s' % info[0].name
else:
lbl = ''
- self.var_id_to_nl[expr_id] = f"v{self.next_V_line_id}{lbl}"
+ self.var_id_to_nl_map[expr_id] = f"v{self.next_V_line_id}{lbl}\n"
# Do NOT write out 0 coefficients here: doing so fouls up the
# ASL's logic for calculating derivatives, leading to 'nan' in
# the Hessian results.
@@ -1964,7 +2116,7 @@ def duplicate(self):
ans.const = self.const
ans.linear = None if self.linear is None else dict(self.linear)
ans.nonlinear = self.nonlinear
- ans.named_exprs = self.named_exprs
+ ans.named_exprs = None if self.named_exprs is None else set(self.named_exprs)
return ans
def compile_repn(self, visitor, prefix='', args=None, named_exprs=None):
@@ -2209,7 +2361,9 @@ class text_nl_debug_template(object):
less_equal = 'o23\t# le\n'
equality = 'o24\t# eq\n'
external_fcn = 'f%d %d%s\n'
- var = '%s\n' # NOTE: to support scaling, we do NOT include the 'v' here
+ # NOTE: to support scaling and substitutions, we do NOT include the
+ # 'v' or the EOL here:
+ var = '%s'
const = 'n%r\n'
string = 'h%d:%s\n'
monomial = product + const + var.replace('%', '%%')
@@ -2218,8 +2372,45 @@ class text_nl_debug_template(object):
_create_strict_inequality_map(vars())
+nl_operators = {
+ 0: (2, operator.add),
+ 2: (2, operator.mul),
+ 3: (2, operator.truediv),
+ 5: (2, operator.pow),
+ 15: (1, operator.abs),
+ 16: (1, operator.neg),
+ 54: (None, lambda *x: sum(x)),
+ 35: (3, lambda a, b, c: b if a else c),
+ 21: (2, operator.and_),
+ 22: (2, operator.lt),
+ 23: (2, operator.le),
+ 24: (2, operator.eq),
+ 43: (1, math.log),
+ 42: (1, math.log10),
+ 41: (1, math.sin),
+ 46: (1, math.cos),
+ 38: (1, math.tan),
+ 40: (1, math.sinh),
+ 45: (1, math.cosh),
+ 37: (1, math.tanh),
+ 51: (1, math.asin),
+ 53: (1, math.acos),
+ 49: (1, math.atan),
+ 44: (1, math.exp),
+ 39: (1, math.sqrt),
+ 50: (1, math.asinh),
+ 52: (1, math.acosh),
+ 47: (1, math.atanh),
+ 14: (1, math.ceil),
+ 13: (1, math.floor),
+}
+
+
def _strip_template_comments(vars_, base_):
- vars_['unary'] = {k: v[: v.find('\t#')] + '\n' for k, v in base_.unary.items()}
+ vars_['unary'] = {
+ k: v[: v.find('\t#')] + '\n' if v[-1] == '\n' else ''
+ for k, v in base_.unary.items()
+ }
for k, v in base_.__dict__.items():
if type(v) is str and '\t#' in v:
v_lines = v.split('\n')
@@ -2470,6 +2661,15 @@ def handle_named_expression_node(visitor, node, arg1):
expression_source,
)
+ # As we will eventually need the compiled form of any nonlinear
+ # expression, we will go ahead and compile it here. We do not
+ # do the same for the linear component as we will only need the
+ # linear component compiled to a dict if we are emitting the
+ # original (linear + nonlinear) V line (which will not happen if
+ # the V line is part of a larger linear operator).
+ if repn.nonlinear.__class__ is list:
+ repn.compile_nonlinear_fragment(visitor)
+
if not visitor.use_named_exprs:
return _GENERAL, repn.duplicate()
@@ -2482,15 +2682,6 @@ def handle_named_expression_node(visitor, node, arg1):
repn.nl = (visitor.template.var, (_id,))
if repn.nonlinear:
- # As we will eventually need the compiled form of any nonlinear
- # expression, we will go ahead and compile it here. We do not
- # do the same for the linear component as we will only need the
- # linear component compiled to a dict if we are emitting the
- # original (linear + nonlinear) V line (which will not happen if
- # the V line is part of a larger linear operator).
- if repn.nonlinear.__class__ is list:
- repn.compile_nonlinear_fragment(visitor)
-
if repn.linear:
# If this expression has both linear and nonlinear
# components, we will follow the ASL convention and break
@@ -2513,8 +2704,10 @@ def handle_named_expression_node(visitor, node, arg1):
nl_info = list(expression_source)
visitor.subexpression_cache[sub_id] = (sub_node, sub_repn, nl_info)
# It is important that the NL subexpression comes before the
- # main named expression:
- visitor.subexpression_order.append(sub_id)
+ # main named expression: re-insert the original named
+ # expression (so that the nonlinear sub_node comes first
+ # when iterating over subexpression_cache)
+ visitor.subexpression_cache[_id] = visitor.subexpression_cache.pop(_id)
else:
nl_info = expression_source
else:
@@ -2553,15 +2746,11 @@ def handle_named_expression_node(visitor, node, arg1):
if expression_source[2]:
if repn.linear:
- return (_MONOMIAL, next(iter(repn.linear)), 1)
+ assert len(repn.linear) == 1 and not repn.const
+ return (_MONOMIAL,) + next(iter(repn.linear.items()))
else:
return (_CONSTANT, repn.const)
- # Defer recording this _id until after we know that this repn will
- # not be directly substituted (and to ensure that the NL fragment is
- # added to the order first).
- visitor.subexpression_order.append(_id)
-
return (_GENERAL, repn.duplicate())
@@ -2569,9 +2758,12 @@ def handle_external_function_node(visitor, node, *args):
func = node._fcn._function
# There is a special case for external functions: these are the only
# expressions that can accept string arguments. As we currently pass
- # these as 'precompiled' general NL fragments, the normal trap for
- # constant subexpressions will miss constant external function calls
- # that contain strings. We will catch that case here.
+ # these as 'precompiled' GENERAL AMPLRepns, the normal trap for
+ # constant subexpressions will miss string arguments. We will catch
+ # that case here by looking for NL fragments with no variable
+ # references. Note that the NL fragment is NOT the raw string
+ # argument that we want to evaluate: the raw string is in the
+ # `const` field.
if all(
arg[0] is _CONSTANT or (arg[0] is _GENERAL and arg[1].nl and not arg[1].nl[1])
for arg in args
@@ -2587,8 +2779,8 @@ def handle_external_function_node(visitor, node, *args):
"correctly."
% (
func,
- visitor.external_byFcn[func]._library,
- visitor.external_byFcn[func]._library.name,
+ visitor.external_functions[func]._library,
+ visitor.external_functions[func]._library.name,
node._fcn._library,
node._fcn.name,
)
@@ -2596,14 +2788,33 @@ def handle_external_function_node(visitor, node, *args):
else:
visitor.external_functions[func] = (len(visitor.external_functions), node._fcn)
comment = f'\t#{node.local_name}' if visitor.symbolic_solver_labels else ''
- nonlin = node_result_to_amplrepn(args[0]).compile_repn(
- visitor,
- visitor.template.external_fcn
- % (visitor.external_functions[func][0], len(args), comment),
+ nl = visitor.template.external_fcn % (
+ visitor.external_functions[func][0],
+ len(args),
+ comment,
+ )
+ arg_ids = []
+ named_exprs = set()
+ for arg in args:
+ _id = id(arg)
+ arg_ids.append(_id)
+ visitor.subexpression_cache[_id] = (
+ arg,
+ AMPLRepn(
+ 0,
+ None,
+ node_result_to_amplrepn(arg).compile_repn(
+ visitor, named_exprs=named_exprs
+ ),
+ ),
+ (None, None, True),
+ )
+ if not named_exprs:
+ named_exprs = None
+ return (
+ _GENERAL,
+ AMPLRepn(0, None, (nl + '%s' * len(arg_ids), arg_ids, named_exprs)),
)
- for arg in args[1:]:
- nonlin = node_result_to_amplrepn(arg).compile_repn(visitor, *nonlin)
- return (_GENERAL, AMPLRepn(0, None, nonlin))
_operator_handles = ExitNodeDispatcher(
@@ -2763,6 +2974,20 @@ def _before_linear(visitor, child):
linear[_id] = arg1
elif arg.__class__ in native_types:
const += arg
+ elif arg.is_variable_type():
+ _id = id(arg)
+ if _id not in var_map:
+ if arg.fixed:
+ if _id not in visitor.fixed_vars:
+ visitor.cache_fixed_var(_id, arg)
+ const += visitor.fixed_vars[_id]
+ continue
+ _before_child_handlers._record_var(visitor, arg)
+ linear[_id] = 1
+ elif _id in linear:
+ linear[_id] += 1
+ else:
+ linear[_id] = 1
else:
try:
const += visitor.check_constant(visitor.evaluate(arg), arg)
@@ -2797,7 +3022,6 @@ def __init__(
self,
template,
subexpression_cache,
- subexpression_order,
external_functions,
var_map,
used_named_expressions,
@@ -2808,7 +3032,6 @@ def __init__(
super().__init__()
self.template = template
self.subexpression_cache = subexpression_cache
- self.subexpression_order = subexpression_order
self.external_functions = external_functions
self.active_expression_source = None
self.var_map = var_map
@@ -2957,3 +3180,60 @@ def finalizeResult(self, result):
#
self.active_expression_source = None
return ans
+
+
+def _evaluate_constant_nl(nl, external_functions):
+ expr = nl.splitlines()
+ stack = []
+ while expr:
+ line = expr.pop()
+ tokens = line.split()
+ # remove tokens after the first comment
+ for i, t in enumerate(tokens):
+ if t.startswith('#'):
+ tokens = tokens[:i]
+ break
+ if len(tokens) != 1:
+ # skip blank lines
+ if not tokens:
+ continue
+ if tokens[0][0] == 'f':
+ # external function
+ fid, nargs = tokens
+ fid = int(fid[1:])
+ nargs = int(nargs)
+ fcn_id, ef = external_functions[fid]
+ assert fid == fcn_id
+ stack.append(ef.evaluate(tuple(stack.pop() for i in range(nargs))))
+ continue
+ raise DeveloperError(
+ f"Unsupported line format _evaluate_constant_nl() "
+ f"(we expect each line to contain a single token): '{line}'"
+ )
+ term = tokens[0]
+ # the "command" can be determined by the first character on the line
+ cmd = term[0]
+ # Note that we will unpack the line into the expected number of
+ # explicit arguments as a form of error checking
+ if cmd == 'n':
+ # numeric constant
+ stack.append(float(term[1:]))
+ elif cmd == 'o':
+ # operator
+ nargs, fcn = nl_operators[int(term[1:])]
+ if nargs is None:
+ nargs = int(stack.pop())
+ stack.append(fcn(*(stack.pop() for i in range(nargs))))
+ elif cmd in '1234567890':
+ # this is either a single int (e.g., the nargs in a nary
+ # sum) or a string argument. Preserve it as-is until later
+ # when we know which we are expecting.
+ stack.append(term)
+ elif cmd == 'h':
+ stack.append(term.split(':', 1)[1])
+ else:
+ raise DeveloperError(
+ f"Unsupported NL operator in _evaluate_constant_nl(): '{line}'"
+ )
+ assert len(stack) == 1
+ return stack[0]
diff --git a/pyomo/repn/plugins/standard_form.py b/pyomo/repn/plugins/standard_form.py
index 239cd845930..e684829e2f4 100644
--- a/pyomo/repn/plugins/standard_form.py
+++ b/pyomo/repn/plugins/standard_form.py
@@ -20,6 +20,7 @@
document_kwargs_from_configdict,
)
from pyomo.common.dependencies import scipy, numpy as np
+from pyomo.common.enums import ObjectiveSense
from pyomo.common.gc_manager import PauseGC
from pyomo.common.timing import TicTocTimer
@@ -61,12 +62,16 @@ class LinearStandardFormInfo(object):
Attributes
----------
- c : scipy.sparse.csr_array
+ c : scipy.sparse.csc_array
The objective coefficients. Note that this is a sparse array
and may contain multiple rows (for multiobjective problems). The
objectives may be calculated by "c @ x"
+ c_offset : numpy.ndarray
+
+ The list of objective constant offsets
+
A : scipy.sparse.csc_array
The constraint coefficients. The constraint bodies may be
@@ -76,37 +81,43 @@ class LinearStandardFormInfo(object):
The constraint right-hand sides.
- rows : List[Tuple[_ConstraintData, int]]
+ rows : List[Tuple[ConstraintData, int]]
The list of Pyomo constraint objects corresponding to the rows
in `A`. Each element in the list is a 2-tuple of
- (_ConstraintData, row_multiplier). The `row_multiplier` will be
+ (ConstraintData, row_multiplier). The `row_multiplier` will be
+/- 1 indicating if the row was multiplied by -1 (corresponding
to a constraint lower bound) or +1 (upper bound).
- columns : List[_VarData]
+ columns : List[VarData]
The list of Pyomo variable objects corresponding to columns in
the `A` and `c` matrices.
- eliminated_vars: List[Tuple[_VarData, NumericExpression]]
+ objectives : List[ObjectiveData]
+
+ The list of Pyomo objective objects corresponding to the active objectives
+
+ eliminated_vars: List[Tuple[VarData, NumericExpression]]
The list of variables from the original model that do not appear
in the standard form (usually because they were replaced by
nonnegative variables). Each entry is a 2-tuple of
- (:py:class:`_VarData`, :py:class`NumericExpression`|`float`).
+ (:py:class:`VarData`, :py:class`NumericExpression`|`float`).
The list is in the necessary order for correct evaluation (i.e.,
all variables appearing in the expression must either have
appeared in the standard form, or appear *earlier* in this list.
"""
- def __init__(self, c, A, rhs, rows, columns, eliminated_vars):
+ def __init__(self, c, c_offset, A, rhs, rows, columns, objectives, eliminated_vars):
self.c = c
+ self.c_offset = c_offset
self.A = A
self.rhs = rhs
self.rows = rows
self.columns = columns
+ self.objectives = objectives
self.eliminated_vars = eliminated_vars
@property
@@ -139,6 +150,23 @@ class LinearStandardFormCompiler(object):
description='Add slack variables and return `min cTx s.t. Ax == b`',
),
)
+ CONFIG.declare(
+ 'mixed_form',
+ ConfigValue(
+ default=False,
+ domain=bool,
+ description='Return A in mixed form (the comparison operator is a '
+ 'mix of <=, ==, and >=)',
+ ),
+ )
+ CONFIG.declare(
+ 'set_sense',
+ ConfigValue(
+ default=ObjectiveSense.minimize,
+ domain=InEnum(ObjectiveSense),
+ description='If not None, map all objectives to the specified sense.',
+ ),
+ )
CONFIG.declare(
'show_section_timing',
ConfigValue(
@@ -296,21 +324,19 @@ def write(self, model):
#
# Process objective
#
- if not component_map[Objective]:
- objectives = [Objective(expr=1)]
- objectives[0].construct()
- else:
- objectives = []
- for blk in component_map[Objective]:
- objectives.extend(
- blk.component_data_objects(
- Objective, active=True, descend_into=False, sort=sorter
- )
+ set_sense = self.config.set_sense
+ objectives = []
+ for blk in component_map[Objective]:
+ objectives.extend(
+ blk.component_data_objects(
+ Objective, active=True, descend_into=False, sort=sorter
)
+ )
+ obj_offset = []
obj_data = []
obj_index = []
obj_index_ptr = [0]
- for i, obj in enumerate(objectives):
+ for obj in objectives:
repn = visitor.walk_expression(obj.expr)
if repn.nonlinear is not None:
raise ValueError(
@@ -319,8 +345,10 @@ def write(self, model):
)
N = len(repn.linear)
obj_data.append(np.fromiter(repn.linear.values(), float, N))
- if obj.sense == maximize:
+ obj_offset.append(repn.constant)
+ if set_sense is not None and set_sense != obj.sense:
obj_data[-1] *= -1
+ obj_offset[-1] *= -1
obj_index.append(
np.fromiter(map(var_order.__getitem__, repn.linear), float, N)
)
@@ -332,6 +360,9 @@ def write(self, model):
# Tabulate constraints
#
slack_form = self.config.slack_form
+ mixed_form = self.config.mixed_form
+ if slack_form and mixed_form:
+ raise ValueError("cannot specify both slack_form and mixed_form")
rows = []
rhs = []
con_data = []
@@ -372,7 +403,30 @@ def write(self, model):
f"model contains a trivially infeasible constraint, '{con.name}'"
)
- if slack_form:
+ if mixed_form:
+ N = len(repn.linear)
+ _data = np.fromiter(repn.linear.values(), float, N)
+ _index = np.fromiter(map(var_order.__getitem__, repn.linear), float, N)
+ if ub == lb:
+ rows.append(RowEntry(con, 0))
+ rhs.append(ub - offset)
+ con_data.append(_data)
+ con_index.append(_index)
+ con_index_ptr.append(con_index_ptr[-1] + N)
+ else:
+ if ub is not None:
+ rows.append(RowEntry(con, 1))
+ rhs.append(ub - offset)
+ con_data.append(_data)
+ con_index.append(_index)
+ con_index_ptr.append(con_index_ptr[-1] + N)
+ if lb is not None:
+ rows.append(RowEntry(con, -1))
+ rhs.append(lb - offset)
+ con_data.append(_data)
+ con_index.append(_index)
+ con_index_ptr.append(con_index_ptr[-1] + N)
+ elif slack_form:
_data = list(repn.linear.values())
_index = list(map(var_order.__getitem__, repn.linear))
if lb == ub: # TODO: add tolerance?
@@ -421,13 +475,17 @@ def write(self, model):
# Get the variable list
columns = list(var_map.values())
# Convert the compiled data to scipy sparse matrices
+ if obj_data:
+ obj_data = np.concatenate(obj_data)
+ obj_index = np.concatenate(obj_index)
c = scipy.sparse.csr_array(
- (np.concatenate(obj_data), np.concatenate(obj_index), obj_index_ptr),
- [len(obj_index_ptr) - 1, len(columns)],
+ (obj_data, obj_index, obj_index_ptr), [len(obj_index_ptr) - 1, len(columns)]
).tocsc()
+ if rows:
+ con_data = np.concatenate(con_data)
+ con_index = np.concatenate(con_index)
A = scipy.sparse.csr_array(
- (np.concatenate(con_data), np.concatenate(con_index), con_index_ptr),
- [len(rows), len(columns)],
+ (con_data, con_index, con_index_ptr), [len(rows), len(columns)]
).tocsc()
# Some variables in the var_map may not actually appear in the
@@ -437,24 +495,22 @@ def write(self, model):
# at the index pointer list (an O(num_var) operation).
c_ip = c.indptr
A_ip = A.indptr
- active_var_idx = list(
- filter(
- lambda i: A_ip[i] != A_ip[i + 1] or c_ip[i] != c_ip[i + 1],
- range(len(columns)),
- )
- )
- nCol = len(active_var_idx)
+ active_var_mask = (A_ip[1:] > A_ip[:-1]) | (c_ip[1:] > c_ip[:-1])
+
+ # Masks on NumPy arrays are very fast. Build the reduced A
+ # indptr and then check if we actually have to manipulate the
+ # columns
+ augmented_mask = np.concatenate((active_var_mask, [True]))
+ reduced_A_indptr = A.indptr[augmented_mask]
+ nCol = len(reduced_A_indptr) - 1
if nCol != len(columns):
- # Note that the indptr can't just use range() because a var
- # may only appear in the objectives or the constraints.
- columns = list(map(columns.__getitem__, active_var_idx))
- active_var_idx.append(c.indptr[-1])
+ columns = [v for k, v in zip(active_var_mask, columns) if k]
c = scipy.sparse.csc_array(
- (c.data, c.indices, c.indptr.take(active_var_idx)), [c.shape[0], nCol]
+ (c.data, c.indices, c.indptr[augmented_mask]), [c.shape[0], nCol]
)
- active_var_idx[-1] = A.indptr[-1]
+ # active_var_idx[-1] = len(columns)
A = scipy.sparse.csc_array(
- (A.data, A.indices, A.indptr.take(active_var_idx)), [A.shape[0], nCol]
+ (A.data, A.indices, reduced_A_indptr), [A.shape[0], nCol]
)
if self.config.nonnegative_vars:
@@ -462,7 +518,9 @@ def write(self, model):
else:
eliminated_vars = []
- info = LinearStandardFormInfo(c, A, rhs, rows, columns, eliminated_vars)
+ info = LinearStandardFormInfo(
+ c, np.array(obj_offset), A, rhs, rows, columns, objectives, eliminated_vars
+ )
timer.toc("Generated linear standard form representation", delta=False)
return info
diff --git a/pyomo/repn/quadratic.py b/pyomo/repn/quadratic.py
index c538d1efc7f..f6e0a43623d 100644
--- a/pyomo/repn/quadratic.py
+++ b/pyomo/repn/quadratic.py
@@ -98,22 +98,15 @@ def to_expression(self, visitor):
e += coef * (var_map[x1] * var_map[x2])
ans += e
if self.linear:
- if len(self.linear) == 1:
- vid, coef = next(iter(self.linear.items()))
- if coef == 1:
- ans += var_map[vid]
- elif coef:
- ans += MonomialTermExpression((coef, var_map[vid]))
- else:
- pass
- else:
- ans += LinearExpression(
- [
- MonomialTermExpression((coef, var_map[vid]))
- for vid, coef in self.linear.items()
- if coef
- ]
- )
+ var_map = visitor.var_map
+ with mutable_expression() as e:
+ for vid, coef in self.linear.items():
+ if coef:
+ e += coef * var_map[vid]
+ if e.nargs() > 1:
+ ans += e
+ elif e.nargs() == 1:
+ ans += e.arg(0)
if self.constant:
ans += self.constant
if self.multiplier != 1:
@@ -284,18 +277,11 @@ def _handle_product_nonlinear(visitor, node, arg1, arg2):
_exit_node_handlers[ProductExpression].update(
{
+ None: _handle_product_nonlinear,
(_CONSTANT, _QUADRATIC): linear._handle_product_constant_ANY,
- (_LINEAR, _QUADRATIC): _handle_product_nonlinear,
- (_QUADRATIC, _QUADRATIC): _handle_product_nonlinear,
- (_GENERAL, _QUADRATIC): _handle_product_nonlinear,
(_QUADRATIC, _CONSTANT): linear._handle_product_ANY_constant,
- (_QUADRATIC, _LINEAR): _handle_product_nonlinear,
- (_QUADRATIC, _GENERAL): _handle_product_nonlinear,
# Replace handler from the linear walker
(_LINEAR, _LINEAR): _handle_product_linear_linear,
- (_GENERAL, _GENERAL): _handle_product_nonlinear,
- (_GENERAL, _LINEAR): _handle_product_nonlinear,
- (_LINEAR, _GENERAL): _handle_product_nonlinear,
}
)
@@ -303,15 +289,7 @@ def _handle_product_nonlinear(visitor, node, arg1, arg2):
# DIVISION
#
_exit_node_handlers[DivisionExpression].update(
- {
- (_CONSTANT, _QUADRATIC): linear._handle_division_nonlinear,
- (_LINEAR, _QUADRATIC): linear._handle_division_nonlinear,
- (_QUADRATIC, _QUADRATIC): linear._handle_division_nonlinear,
- (_GENERAL, _QUADRATIC): linear._handle_division_nonlinear,
- (_QUADRATIC, _CONSTANT): linear._handle_division_ANY_constant,
- (_QUADRATIC, _LINEAR): linear._handle_division_nonlinear,
- (_QUADRATIC, _GENERAL): linear._handle_division_nonlinear,
- }
+ {(_QUADRATIC, _CONSTANT): linear._handle_division_ANY_constant}
)
@@ -319,84 +297,42 @@ def _handle_product_nonlinear(visitor, node, arg1, arg2):
# EXPONENTIATION
#
_exit_node_handlers[PowExpression].update(
- {
- (_CONSTANT, _QUADRATIC): linear._handle_pow_nonlinear,
- (_LINEAR, _QUADRATIC): linear._handle_pow_nonlinear,
- (_QUADRATIC, _QUADRATIC): linear._handle_pow_nonlinear,
- (_GENERAL, _QUADRATIC): linear._handle_pow_nonlinear,
- (_QUADRATIC, _CONSTANT): linear._handle_pow_ANY_constant,
- (_QUADRATIC, _LINEAR): linear._handle_pow_nonlinear,
- (_QUADRATIC, _GENERAL): linear._handle_pow_nonlinear,
- }
+ {(_QUADRATIC, _CONSTANT): linear._handle_pow_ANY_constant}
)
#
# ABS and UNARY handlers
#
-_exit_node_handlers[AbsExpression][(_QUADRATIC,)] = linear._handle_unary_nonlinear
-_exit_node_handlers[UnaryFunctionExpression][
- (_QUADRATIC,)
-] = linear._handle_unary_nonlinear
+# (no changes needed)
#
# NAMED EXPRESSION handlers
#
-_exit_node_handlers[Expression][(_QUADRATIC,)] = linear._handle_named_ANY
+# (no changes needed)
#
# EXPR_IF handlers
#
# Note: it is easier to just recreate the entire data structure, rather
# than update it
-_exit_node_handlers[Expr_ifExpression] = {
- (i, j, k): linear._handle_expr_if_nonlinear
- for i in (_LINEAR, _QUADRATIC, _GENERAL)
- for j in (_CONSTANT, _LINEAR, _QUADRATIC, _GENERAL)
- for k in (_CONSTANT, _LINEAR, _QUADRATIC, _GENERAL)
-}
-for j in (_CONSTANT, _LINEAR, _QUADRATIC, _GENERAL):
- for k in (_CONSTANT, _LINEAR, _QUADRATIC, _GENERAL):
- _exit_node_handlers[Expr_ifExpression][
- _CONSTANT, j, k
- ] = linear._handle_expr_if_const
-
-#
-# RELATIONAL handlers
-#
-_exit_node_handlers[EqualityExpression].update(
- {
- (_CONSTANT, _QUADRATIC): linear._handle_equality_general,
- (_LINEAR, _QUADRATIC): linear._handle_equality_general,
- (_QUADRATIC, _QUADRATIC): linear._handle_equality_general,
- (_GENERAL, _QUADRATIC): linear._handle_equality_general,
- (_QUADRATIC, _CONSTANT): linear._handle_equality_general,
- (_QUADRATIC, _LINEAR): linear._handle_equality_general,
- (_QUADRATIC, _GENERAL): linear._handle_equality_general,
- }
-)
-_exit_node_handlers[InequalityExpression].update(
+_exit_node_handlers[Expr_ifExpression].update(
{
- (_CONSTANT, _QUADRATIC): linear._handle_inequality_general,
- (_LINEAR, _QUADRATIC): linear._handle_inequality_general,
- (_QUADRATIC, _QUADRATIC): linear._handle_inequality_general,
- (_GENERAL, _QUADRATIC): linear._handle_inequality_general,
- (_QUADRATIC, _CONSTANT): linear._handle_inequality_general,
- (_QUADRATIC, _LINEAR): linear._handle_inequality_general,
- (_QUADRATIC, _GENERAL): linear._handle_inequality_general,
+ (_CONSTANT, i, _QUADRATIC): linear._handle_expr_if_const
+ for i in (_CONSTANT, _LINEAR, _QUADRATIC, _GENERAL)
}
)
-_exit_node_handlers[RangedExpression].update(
+_exit_node_handlers[Expr_ifExpression].update(
{
- (_CONSTANT, _QUADRATIC): linear._handle_ranged_general,
- (_LINEAR, _QUADRATIC): linear._handle_ranged_general,
- (_QUADRATIC, _QUADRATIC): linear._handle_ranged_general,
- (_GENERAL, _QUADRATIC): linear._handle_ranged_general,
- (_QUADRATIC, _CONSTANT): linear._handle_ranged_general,
- (_QUADRATIC, _LINEAR): linear._handle_ranged_general,
- (_QUADRATIC, _GENERAL): linear._handle_ranged_general,
+ (_CONSTANT, _QUADRATIC, i): linear._handle_expr_if_const
+ for i in (_CONSTANT, _LINEAR, _GENERAL)
}
)
+#
+# RELATIONAL handlers
+#
+# (no changes needed)
+
class QuadraticRepnVisitor(linear.LinearRepnVisitor):
Result = QuadraticRepn
diff --git a/pyomo/repn/standard_repn.py b/pyomo/repn/standard_repn.py
index 8700872f04f..b767ab727af 100644
--- a/pyomo/repn/standard_repn.py
+++ b/pyomo/repn/standard_repn.py
@@ -19,11 +19,15 @@
import pyomo.core.expr as EXPR
from pyomo.core.expr.numvalue import NumericConstant
-from pyomo.core.base.objective import _GeneralObjectiveData, ScalarObjective
-from pyomo.core.base import _ExpressionData, Expression
-from pyomo.core.base.expression import ScalarExpression, _GeneralExpressionData
-from pyomo.core.base.var import ScalarVar, Var, _GeneralVarData, value
-from pyomo.core.base.param import ScalarParam, _ParamData
+from pyomo.core.base.objective import ObjectiveData, ScalarObjective
+from pyomo.core.base import Expression
+from pyomo.core.base.expression import (
+ ScalarExpression,
+ NamedExpressionData,
+ ExpressionData,
+)
+from pyomo.core.base.var import ScalarVar, Var, VarData, value
+from pyomo.core.base.param import ScalarParam, ParamData
from pyomo.core.kernel.expression import expression, noclone
from pyomo.core.kernel.variable import IVariable, variable
from pyomo.core.kernel.objective import objective
@@ -321,6 +325,16 @@ def generate_standard_repn(
linear_vars[id_] = v
elif arg.__class__ in native_numeric_types:
C_ += arg
+ elif arg.is_variable_type():
+ if arg.fixed:
+ C_ += arg.value
+ continue
+ id_ = id(arg)
+ if id_ in linear_coefs:
+ linear_coefs[id_] += 1
+ else:
+ linear_coefs[id_] = 1
+ linear_vars[id_] = arg
else:
C_ += EXPR.evaluate_expression(arg)
else: # compute_values == False
@@ -336,6 +350,18 @@ def generate_standard_repn(
else:
linear_coefs[id_] = c
linear_vars[id_] = v
+ elif arg.__class__ in native_numeric_types:
+ C_ += arg
+ elif arg.is_variable_type():
+ if arg.fixed:
+ C_ += arg
+ continue
+ id_ = id(arg)
+ if id_ in linear_coefs:
+ linear_coefs[id_] += 1
+ else:
+ linear_coefs[id_] = 1
+ linear_vars[id_] = arg
else:
C_ += arg
@@ -1114,25 +1140,25 @@ def _collect_external_fn(exp, multiplier, idMap, compute_values, verbose, quadra
EXPR.RangedExpression: _collect_comparison,
EXPR.EqualityExpression: _collect_comparison,
EXPR.ExternalFunctionExpression: _collect_external_fn,
- # _ConnectorData : _collect_linear_connector,
+ # ConnectorData : _collect_linear_connector,
# ScalarConnector : _collect_linear_connector,
- _ParamData: _collect_const,
+ ParamData: _collect_const,
ScalarParam: _collect_const,
# param.Param : _collect_linear_const,
# parameter : _collect_linear_const,
NumericConstant: _collect_const,
- _GeneralVarData: _collect_var,
+ VarData: _collect_var,
ScalarVar: _collect_var,
Var: _collect_var,
variable: _collect_var,
IVariable: _collect_var,
- _GeneralExpressionData: _collect_identity,
+ ExpressionData: _collect_identity,
ScalarExpression: _collect_identity,
expression: _collect_identity,
noclone: _collect_identity,
- _ExpressionData: _collect_identity,
+ NamedExpressionData: _collect_identity,
Expression: _collect_identity,
- _GeneralObjectiveData: _collect_identity,
+ ObjectiveData: _collect_identity,
ScalarObjective: _collect_identity,
objective: _collect_identity,
}
@@ -1514,24 +1540,24 @@ def _linear_collect_pow(exp, multiplier, idMap, compute_values, verbose, coef):
#EXPR.EqualityExpression : _linear_collect_comparison,
#EXPR.ExternalFunctionExpression : _linear_collect_external_fn,
##EXPR.LinearSumExpression : _collect_linear_sum,
- ##_ConnectorData : _collect_linear_connector,
+ ##ConnectorData : _collect_linear_connector,
##ScalarConnector : _collect_linear_connector,
- ##param._ParamData : _collect_linear_const,
+ ##param.ParamData : _collect_linear_const,
##param.ScalarParam : _collect_linear_const,
##param.Param : _collect_linear_const,
##parameter : _collect_linear_const,
- _GeneralVarData : _linear_collect_var,
+ VarData : _linear_collect_var,
ScalarVar : _linear_collect_var,
Var : _linear_collect_var,
variable : _linear_collect_var,
IVariable : _linear_collect_var,
- _GeneralExpressionData : _linear_collect_identity,
+ ExpressionData : _linear_collect_identity,
ScalarExpression : _linear_collect_identity,
expression : _linear_collect_identity,
noclone : _linear_collect_identity,
- _ExpressionData : _linear_collect_identity,
+ NamedExpressionData : _linear_collect_identity,
Expression : _linear_collect_identity,
- _GeneralObjectiveData : _linear_collect_identity,
+ ObjectiveData : _linear_collect_identity,
ScalarObjective : _linear_collect_identity,
objective : _linear_collect_identity,
}
diff --git a/pyomo/repn/tests/ampl/test_nlv2.py b/pyomo/repn/tests/ampl/test_nlv2.py
index 8b95fc03bdb..b6bb5f6c074 100644
--- a/pyomo/repn/tests/ampl/test_nlv2.py
+++ b/pyomo/repn/tests/ampl/test_nlv2.py
@@ -25,6 +25,7 @@
from pyomo.common.dependencies import numpy, numpy_available
from pyomo.common.errors import MouseTrap
+from pyomo.common.gsl import find_GSL
from pyomo.common.log import LoggingIntercept
from pyomo.common.tee import capture_output
from pyomo.common.tempfiles import TempfileManager
@@ -42,6 +43,8 @@
Suffix,
Constraint,
Expression,
+ Binary,
+ Integers,
)
import pyomo.environ as pyo
@@ -55,7 +58,6 @@ def __init__(self, symbolic=False):
else:
self.template = nl_writer.text_nl_template
self.subexpression_cache = {}
- self.subexpression_order = []
self.external_functions = {}
self.var_map = {}
self.used_named_expressions = set()
@@ -64,7 +66,6 @@ def __init__(self, symbolic=False):
self.visitor = nl_writer.AMPLRepnVisitor(
self.template,
self.subexpression_cache,
- self.subexpression_order,
self.external_functions,
self.var_map,
self.used_named_expressions,
@@ -97,7 +98,7 @@ def test_divide(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear, ('o5\n%s\nn2\n', [id(m.x)]))
+ self.assertEqual(repn.nonlinear, ('o5\n%sn2\n', [id(m.x)]))
m.p = 2
@@ -149,7 +150,7 @@ def test_divide(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear, ('o2\nn0.5\no5\n%s\nn2\n', [id(m.x)]))
+ self.assertEqual(repn.nonlinear, ('o2\nn0.5\no5\n%sn2\n', [id(m.x)]))
info = INFO()
with LoggingIntercept() as LOG:
@@ -159,7 +160,7 @@ def test_divide(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear, ('o3\no43\n%s\n%s\n', [id(m.x), id(m.x)]))
+ self.assertEqual(repn.nonlinear, ('o3\no43\n%s%s', [id(m.x), id(m.x)]))
def test_errors_divide_by_0(self):
m = ConcreteModel()
@@ -254,7 +255,7 @@ def test_pow(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear, ('o5\n%s\nn2\n', [id(m.x)]))
+ self.assertEqual(repn.nonlinear, ('o5\n%sn2\n', [id(m.x)]))
m.p = 1
info = INFO()
@@ -541,7 +542,7 @@ def test_errors_propagate_nan(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, InvalidNumber(None))
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear[0], 'o16\no2\no2\n%s\n%s\n%s\n')
+ self.assertEqual(repn.nonlinear[0], 'o16\no2\no2\n%s%s%s')
self.assertEqual(repn.nonlinear[1], [id(m.z[2]), id(m.z[3]), id(m.z[4])])
m.z[3].fix(float('nan'))
@@ -591,7 +592,7 @@ def test_eval_pow(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear, ('o5\n%s\nn0.5\n', [id(m.x)]))
+ self.assertEqual(repn.nonlinear, ('o5\n%sn0.5\n', [id(m.x)]))
m.x.fix()
info = INFO()
@@ -616,7 +617,7 @@ def test_eval_abs(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear, ('o15\n%s\n', [id(m.x)]))
+ self.assertEqual(repn.nonlinear, ('o15\n%s', [id(m.x)]))
m.x.fix()
info = INFO()
@@ -641,7 +642,7 @@ def test_eval_unary_func(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear, ('o43\n%s\n', [id(m.x)]))
+ self.assertEqual(repn.nonlinear, ('o43\n%s', [id(m.x)]))
m.x.fix()
info = INFO()
@@ -670,7 +671,7 @@ def test_eval_expr_if_lessEq(self):
self.assertEqual(repn.linear, {})
self.assertEqual(
repn.nonlinear,
- ('o35\no23\n%s\nn4\no5\n%s\nn2\n%s\n', [id(m.x), id(m.x), id(m.y)]),
+ ('o35\no23\n%sn4\no5\n%sn2\n%s', [id(m.x), id(m.x), id(m.y)]),
)
m.x.fix()
@@ -711,7 +712,7 @@ def test_eval_expr_if_Eq(self):
self.assertEqual(repn.linear, {})
self.assertEqual(
repn.nonlinear,
- ('o35\no24\n%s\nn4\no5\n%s\nn2\n%s\n', [id(m.x), id(m.x), id(m.y)]),
+ ('o35\no24\n%sn4\no5\n%sn2\n%s', [id(m.x), id(m.x), id(m.y)]),
)
m.x.fix()
@@ -753,7 +754,7 @@ def test_eval_expr_if_ranged(self):
self.assertEqual(
repn.nonlinear,
(
- 'o35\no21\no23\nn1\n%s\no23\n%s\nn4\no5\n%s\nn2\n%s\n',
+ 'o35\no21\no23\nn1\n%so23\n%sn4\no5\n%sn2\n%s',
[id(m.x), id(m.x), id(m.x), id(m.y)],
),
)
@@ -814,7 +815,7 @@ class CustomExpression(ScalarExpression):
self.assertEqual(len(info.subexpression_cache), 1)
obj, repn, info = info.subexpression_cache[id(m.e)]
self.assertIs(obj, m.e)
- self.assertEqual(repn.nl, ('%s\n', (id(m.e),)))
+ self.assertEqual(repn.nl, ('%s', (id(m.e),)))
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 3)
self.assertEqual(repn.linear, {id(m.x): 1})
@@ -841,7 +842,7 @@ def test_nested_operator_zero_arg(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {})
- self.assertEqual(repn.nonlinear, ('o24\no3\nn1\n%s\nn0\n', [id(m.x)]))
+ self.assertEqual(repn.nonlinear, ('o24\no3\nn1\n%sn0\n', [id(m.x)]))
def test_duplicate_shared_linear_expressions(self):
# This tests an issue where AMPLRepn.duplicate() was not copying
@@ -928,7 +929,7 @@ def test_AMPLRepn_to_expr(self):
self.assertEqual(repn.mult, 1)
self.assertEqual(repn.const, 0)
self.assertEqual(repn.linear, {id(m.x[2]): 4, id(m.x[3]): 9, id(m.x[4]): 16})
- self.assertEqual(repn.nonlinear, ('o5\n%s\nn2\n', [id(m.x[2])]))
+ self.assertEqual(repn.nonlinear, ('o5\n%sn2\n', [id(m.x[2])]))
with self.assertRaisesRegex(
MouseTrap, "Cannot convert nonlinear AMPLRepn to Pyomo Expression"
):
@@ -1096,7 +1097,6 @@ def test_log_timing(self):
m.c1 = Constraint([1, 2], rule=lambda m, i: sum(m.x.values()) == 1)
m.c2 = Constraint(expr=m.p * m.x[1] ** 2 + m.x[2] ** 3 <= 100)
- self.maxDiff = None
OUT = io.StringIO()
with capture_output() as LOG:
with report_timing(level=logging.DEBUG):
@@ -1267,7 +1267,7 @@ def test_nonfloat_constants(self):
0 0 #network constraints: nonlinear, linear
0 0 0 #nonlinear vars in constraints, objectives, both
0 0 0 1 #linear network variables; functions; arith, flags
- 0 4 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 4 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
4 4 #nonzeros in Jacobian, obj. gradient
6 4 #max name lengths: constraints, variables
0 0 0 0 0 #common exprs: b,c,o,c1,o1
@@ -1688,6 +1688,257 @@ def test_presolve_named_expressions(self):
)
)
+ def test_presolve_zero_coef(self):
+ m = ConcreteModel()
+ m.x = Var()
+ m.y = Var()
+ m.z = Var()
+ m.obj = Objective(expr=m.x**2 + m.y**2 + m.z**2)
+ m.c1 = Constraint(expr=m.x == m.y + m.z + 1.5)
+ m.c2 = Constraint(expr=m.z == -m.y)
+
+ OUT = io.StringIO()
+ with LoggingIntercept() as LOG:
+ nlinfo = nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=True
+ )
+ self.assertEqual(LOG.getvalue(), "")
+
+ self.assertEqual(nlinfo.eliminated_vars[0], (m.x, 1.5))
+ self.assertIs(nlinfo.eliminated_vars[1][0], m.y)
+ self.assertExpressionsEqual(
+ nlinfo.eliminated_vars[1][1], LinearExpression([-1.0 * m.z])
+ )
+
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 # problem unknown
+ 1 0 1 0 0 #vars, constraints, objectives, ranges, eqns
+ 0 1 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 0 1 0 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 0 1 #nonzeros in Jacobian, obj. gradient
+ 3 1 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+O0 0 #obj
+o54 #sumlist
+3 #(n)
+o5 #^
+n1.5
+n2
+o5 #^
+o16 #-
+v0 #z
+n2
+o5 #^
+v0 #z
+n2
+x0 #initial guess
+r #0 ranges (rhs's)
+b #1 bounds (on variables)
+3 #z
+k0 #intermediate Jacobian column lengths
+G0 1 #obj
+0 0
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ m.c3 = Constraint(expr=m.x == 2)
+ OUT = io.StringIO()
+ with LoggingIntercept() as LOG:
+ with self.assertRaisesRegex(
+ nl_writer.InfeasibleConstraintException,
+ r"model contains a trivially infeasible constraint 0.5 == 0.0\*y",
+ ):
+ nlinfo = nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=True
+ )
+ self.assertEqual(LOG.getvalue(), "")
+
+ m.c1.set_value(m.x >= m.y + m.z + 1.5)
+ OUT = io.StringIO()
+ with LoggingIntercept() as LOG:
+ nlinfo = nl_writer.NLWriter().write(
+ m,
+ OUT,
+ symbolic_solver_labels=True,
+ linear_presolve=True,
+ skip_trivial_constraints=False,
+ )
+ self.assertEqual(LOG.getvalue(), "")
+
+ self.assertIs(nlinfo.eliminated_vars[0][0], m.y)
+ self.assertExpressionsEqual(
+ nlinfo.eliminated_vars[0][1], LinearExpression([-1.0 * m.z])
+ )
+ self.assertEqual(nlinfo.eliminated_vars[1], (m.x, 2))
+
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 # problem unknown
+ 1 1 1 0 0 #vars, constraints, objectives, ranges, eqns
+ 0 1 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 0 1 0 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 0 1 #nonzeros in Jacobian, obj. gradient
+ 3 1 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+C0 #c1
+n0
+O0 0 #obj
+o54 #sumlist
+3 #(n)
+o5 #^
+n2
+n2
+o5 #^
+o16 #-
+v0 #z
+n2
+o5 #^
+v0 #z
+n2
+x0 #initial guess
+r #1 ranges (rhs's)
+1 0.5 #c1
+b #1 bounds (on variables)
+3 #z
+k0 #intermediate Jacobian column lengths
+G0 1 #obj
+0 0
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ OUT = io.StringIO()
+ with LoggingIntercept() as LOG:
+ nlinfo = nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=True
+ )
+ self.assertEqual(LOG.getvalue(), "")
+
+ self.assertIs(nlinfo.eliminated_vars[0][0], m.y)
+ self.assertExpressionsEqual(
+ nlinfo.eliminated_vars[0][1], LinearExpression([-1.0 * m.z])
+ )
+ self.assertEqual(nlinfo.eliminated_vars[1], (m.x, 2))
+
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 # problem unknown
+ 1 0 1 0 0 #vars, constraints, objectives, ranges, eqns
+ 0 1 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 0 1 0 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 0 1 #nonzeros in Jacobian, obj. gradient
+ 3 1 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+O0 0 #obj
+o54 #sumlist
+3 #(n)
+o5 #^
+n2
+n2
+o5 #^
+o16 #-
+v0 #z
+n2
+o5 #^
+v0 #z
+n2
+x0 #initial guess
+r #1 ranges (rhs's)
+b #1 bounds (on variables)
+3 #z
+k0 #intermediate Jacobian column lengths
+G0 1 #obj
+0 0
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ def test_presolve_independent_subsystem(self):
+ # This is derived from the example in #3192
+ m = ConcreteModel()
+ m.x = Var()
+ m.y = Var()
+ m.z = Var()
+ m.d = Constraint(expr=m.z == m.y)
+ m.c = Constraint(expr=m.y == m.x)
+ m.o = Objective(expr=0)
+
+ ref = """g3 1 1 0 #problem unknown
+ 0 0 1 0 0 #vars, constraints, objectives, ranges, eqns
+ 0 0 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 0 0 0 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 0 0 #nonzeros in Jacobian, obj. gradient
+ 1 0 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+O0 0 #o
+n0
+x0 #initial guess
+r #0 ranges (rhs's)
+b #0 bounds (on variables)
+k-1 #intermediate Jacobian column lengths
+"""
+
+ OUT = io.StringIO()
+ with LoggingIntercept() as LOG:
+ nlinfo = nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=True
+ )
+ self.assertEqual(
+ LOG.getvalue(),
+ "presolve identified an underdetermined independent linear subsystem "
+ "that was removed from the model. Setting 'z' == 0\n",
+ )
+
+ self.assertEqual(*nl_diff(ref, OUT.getvalue()))
+
+ m.x.lb = 5.0
+
+ OUT = io.StringIO()
+ with LoggingIntercept() as LOG:
+ nlinfo = nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=True
+ )
+ self.assertEqual(
+ LOG.getvalue(),
+ "presolve identified an underdetermined independent linear subsystem "
+ "that was removed from the model. Setting 'z' == 5.0\n",
+ )
+
+ self.assertEqual(*nl_diff(ref, OUT.getvalue()))
+
+ m.x.lb = -5.0
+ m.z.ub = -2.0
+
+ OUT = io.StringIO()
+ with LoggingIntercept() as LOG:
+ nlinfo = nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=True
+ )
+ self.assertEqual(
+ LOG.getvalue(),
+ "presolve identified an underdetermined independent linear subsystem "
+ "that was removed from the model. Setting 'z' == -2.0\n",
+ )
+
+ self.assertEqual(*nl_diff(ref, OUT.getvalue()))
+
def test_scaling(self):
m = pyo.ConcreteModel()
m.x = pyo.Var(initialize=0)
@@ -1973,3 +2224,482 @@ def test_named_expressions(self):
OUT.getvalue(),
)
)
+
+ def test_discrete_var_tabulation(self):
+ # This tests an error reported in #3235
+ #
+ # Among other issues, this verifies that nonlinear discrete
+ # variables are tabulated correctly (header line 7), and that
+ # integer variables with bounds in {0, 1} are mapped to binary
+ # variables.
+ m = ConcreteModel()
+ m.p1 = Var(bounds=(0.85, 1.15))
+ m.p2 = Var(bounds=(0.68, 0.92))
+ m.c1 = Var(bounds=(-0.0, 0.7))
+ m.c2 = Var(bounds=(-0.0, 0.7))
+ m.t1 = Var(within=Binary, bounds=(0, 1))
+ m.t2 = Var(within=Binary, bounds=(0, 1))
+ m.t3 = Var(within=Binary, bounds=(0, 1))
+ m.t4 = Var(within=Binary, bounds=(0, 1))
+ m.t5 = Var(within=Integers, bounds=(0, None))
+ m.t6 = Var(within=Integers, bounds=(0, None))
+ m.x1 = Var(within=Binary)
+ m.x2 = Var(within=Integers, bounds=(0, 1))
+ m.x3 = Var(within=Integers, bounds=(0, None))
+ m.const = Constraint(
+ expr=(
+ (0.7 - (m.c1 * m.t1 + m.c2 * m.t2))
+ <= (m.p1 * m.t1 + m.p2 * m.t2 + m.p1 * m.t4 + m.t6 * m.t5)
+ )
+ )
+ m.OBJ = Objective(
+ expr=(m.p1 * m.t1 + m.p2 * m.t2 + m.p2 * m.t3 + m.x1 + m.x2 + m.x3)
+ )
+
+ OUT = io.StringIO()
+ nl_writer.NLWriter().write(m, OUT, symbolic_solver_labels=True)
+
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 # problem unknown
+ 13 1 1 0 0 #vars, constraints, objectives, ranges, eqns
+ 1 1 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 9 10 4 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 2 1 2 3 1 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 9 8 #nonzeros in Jacobian, obj. gradient
+ 5 2 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+C0 #const
+o0 #+
+o16 #-
+o0 #+
+o2 #*
+v4 #c1
+v2 #t1
+o2 #*
+v5 #c2
+v3 #t2
+o16 #-
+o54 #sumlist
+4 #(n)
+o2 #*
+v0 #p1
+v2 #t1
+o2 #*
+v1 #p2
+v3 #t2
+o2 #*
+v0 #p1
+v6 #t4
+o2 #*
+v7 #t6
+v8 #t5
+O0 0 #OBJ
+o54 #sumlist
+3 #(n)
+o2 #*
+v0 #p1
+v2 #t1
+o2 #*
+v1 #p2
+v3 #t2
+o2 #*
+v1 #p2
+v9 #t3
+x0 #initial guess
+r #1 ranges (rhs's)
+1 -0.7 #const
+b #13 bounds (on variables)
+0 0.85 1.15 #p1
+0 0.68 0.92 #p2
+0 0 1 #t1
+0 0 1 #t2
+0 -0.0 0.7 #c1
+0 -0.0 0.7 #c2
+0 0 1 #t4
+2 0 #t6
+2 0 #t5
+0 0 1 #t3
+0 0 1 #x1
+0 0 1 #x2
+2 0 #x3
+k12 #intermediate Jacobian column lengths
+1
+2
+3
+4
+5
+6
+7
+8
+9
+9
+9
+9
+J0 9 #const
+0 0
+1 0
+2 0
+3 0
+4 0
+5 0
+6 0
+7 0
+8 0
+G0 8 #OBJ
+0 0
+1 0
+2 0
+3 0
+9 0
+10 1
+11 1
+12 1
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ def test_presolve_fixes_nl_defined_variables(self):
+ # This tests a workaround for a bug in the ASL where defined
+ # variables with constant expressions in the NL portion are not
+ # evaluated correctly.
+ m = ConcreteModel()
+ m.x = Var()
+ m.y = Var(bounds=(3, None))
+ m.z = Var(bounds=(None, 3))
+ m.e = Expression(expr=m.x + m.y * m.z + m.y**2 + 3 / m.z)
+ m.c1 = Constraint(expr=m.y * m.e + m.x >= 0)
+ m.c2 = Constraint(expr=m.y == m.z)
+
+ OUT = io.StringIO()
+ nl_writer.NLWriter().write(
+ m,
+ OUT,
+ symbolic_solver_labels=True,
+ linear_presolve=True,
+ export_defined_variables=True,
+ )
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 # problem unknown
+ 1 1 0 0 0 #vars, constraints, objectives, ranges, eqns
+ 1 0 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 1 0 0 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 1 0 #nonzeros in Jacobian, obj. gradient
+ 2 1 #max name lengths: constraints, variables
+ 0 0 0 1 0 #common exprs: b,c,o,c1,o1
+V1 1 1 #e
+0 1
+n19
+C0 #c1
+o2 #*
+n3
+v1 #e
+x0 #initial guess
+r #1 ranges (rhs's)
+2 0 #c1
+b #1 bounds (on variables)
+3 #x
+k0 #intermediate Jacobian column lengths
+J0 1 #c1
+0 1
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ OUT = io.StringIO()
+ nl_writer.NLWriter().write(
+ m,
+ OUT,
+ symbolic_solver_labels=True,
+ linear_presolve=True,
+ export_defined_variables=False,
+ )
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 # problem unknown
+ 1 1 0 0 0 #vars, constraints, objectives, ranges, eqns
+ 1 0 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 1 0 0 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 1 0 #nonzeros in Jacobian, obj. gradient
+ 2 1 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+C0 #c1
+o2 #*
+n3
+o0 #+
+v0 #x
+o54 #sumlist
+3 #(n)
+o2 #*
+n3
+n3
+o5 #^
+n3
+n2
+o3 #/
+n3
+n3
+x0 #initial guess
+r #1 ranges (rhs's)
+2 0 #c1
+b #1 bounds (on variables)
+3 #x
+k0 #intermediate Jacobian column lengths
+J0 1 #c1
+0 1
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ OUT = io.StringIO()
+ nl_writer.NLWriter().write(
+ m,
+ OUT,
+ symbolic_solver_labels=True,
+ linear_presolve=False,
+ export_defined_variables=True,
+ )
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 # problem unknown
+ 3 2 0 0 1 #vars, constraints, objectives, ranges, eqns
+ 1 0 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 3 0 0 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 5 0 #nonzeros in Jacobian, obj. gradient
+ 2 1 #max name lengths: constraints, variables
+ 0 0 0 2 0 #common exprs: b,c,o,c1,o1
+V3 0 1 #nl(e)
+o54 #sumlist
+3 #(n)
+o2 #*
+v0 #y
+v2 #z
+o5 #^
+v0 #y
+n2
+o3 #/
+n3
+v2 #z
+V4 1 1 #e
+1 1
+v3 #nl(e)
+C0 #c1
+o2 #*
+v0 #y
+v4 #e
+C1 #c2
+n0
+x0 #initial guess
+r #2 ranges (rhs's)
+2 0 #c1
+4 0 #c2
+b #3 bounds (on variables)
+2 3 #y
+3 #x
+1 3 #z
+k2 #intermediate Jacobian column lengths
+2
+3
+J0 3 #c1
+0 0
+1 1
+2 0
+J1 2 #c2
+0 1
+2 -1
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ def test_presolve_fixes_nl_external_function(self):
+ # This tests a workaround for a bug in the ASL where external
+ # functions with constant argument expressions are not
+ # evaluated correctly.
+ DLL = find_GSL()
+ if not DLL:
+ self.skipTest("Could not find the amplgsl.dll library")
+
+ m = ConcreteModel()
+ m.hypot = ExternalFunction(library=DLL, function="gsl_hypot")
+ m.p = Param(initialize=1, mutable=True)
+ m.x = Var(bounds=(None, 3))
+ m.y = Var(bounds=(3, None))
+ m.z = Var(initialize=1)
+ m.o = Objective(expr=m.z**2 * m.hypot(m.p * m.x, m.p + m.y) ** 2)
+ m.c = Constraint(expr=m.x == m.y)
+
+ OUT = io.StringIO()
+ nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=False
+ )
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 #problem unknown
+ 3 1 1 0 1 #vars, constraints, objectives, ranges, eqns
+ 0 1 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 0 3 0 #nonlinear vars in constraints, objectives, both
+ 0 1 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 2 3 #nonzeros in Jacobian, obj. gradient
+ 1 1 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+F0 1 -1 gsl_hypot
+C0 #c
+n0
+O0 0 #o
+o2 #*
+o5 #^
+v0 #z
+n2
+o5 #^
+f0 2 #hypot
+v1 #x
+o0 #+
+v2 #y
+n1
+n2
+x1 #initial guess
+0 1 #z
+r #1 ranges (rhs's)
+4 0 #c
+b #3 bounds (on variables)
+3 #z
+1 3 #x
+2 3 #y
+k2 #intermediate Jacobian column lengths
+0
+1
+J0 2 #c
+1 1
+2 -1
+G0 3 #o
+0 0
+1 0
+2 0
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ OUT = io.StringIO()
+ nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=True
+ )
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 #problem unknown
+ 1 0 1 0 0 #vars, constraints, objectives, ranges, eqns
+ 0 1 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 0 1 0 #nonlinear vars in constraints, objectives, both
+ 0 1 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 0 1 #nonzeros in Jacobian, obj. gradient
+ 1 1 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+F0 1 -1 gsl_hypot
+O0 0 #o
+o2 #*
+o5 #^
+v0 #z
+n2
+o5 #^
+f0 2 #hypot
+n3
+n4
+n2
+x1 #initial guess
+0 1 #z
+r #0 ranges (rhs's)
+b #1 bounds (on variables)
+3 #z
+k0 #intermediate Jacobian column lengths
+G0 1 #o
+0 0
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ def test_presolve_defined_var_to_const(self):
+ # This test is derived from a step in an IDAES initialization
+ # where the presolver is able to fix enough variables to cause
+ # the defined variable to be reduced to a constant. We must not
+ # emit the defined variable (because doing so generates an error
+ # in the ASL)
+ m = ConcreteModel()
+ m.eq = Var(initialize=100)
+ m.co2 = Var()
+ m.n2 = Var()
+ m.E = Expression(expr=60 / (3 * m.co2 - 4 * m.n2 - 5))
+ m.con1 = Constraint(expr=m.co2 == 6)
+ m.con2 = Constraint(expr=m.n2 == 7)
+ m.con3 = Constraint(expr=8 / m.E == m.eq)
+
+ OUT = io.StringIO()
+ nl_writer.NLWriter().write(
+ m, OUT, symbolic_solver_labels=True, linear_presolve=True
+ )
+ # Note that the presolve will end up recognizing con3 as a
+ # linear constraint; however, it does not do so until processing
+ # the constraints after presolve (so the constraint is not
+ # actually removed and the eq variable still appears in the model)
+ self.assertEqual(
+ *nl_diff(
+ """g3 1 1 0 #problem unknown
+ 1 1 0 0 1 #vars, constraints, objectives, ranges, eqns
+ 0 0 0 0 0 0 #nonlinear constrs, objs; ccons: lin, nonlin, nd, nzlb
+ 0 0 #network constraints: nonlinear, linear
+ 0 0 0 #nonlinear vars in constraints, objectives, both
+ 0 0 0 1 #linear network variables; functions; arith, flags
+ 0 0 0 0 0 #discrete variables: binary, integer, nonlinear (b,c,o)
+ 1 0 #nonzeros in Jacobian, obj. gradient
+ 4 2 #max name lengths: constraints, variables
+ 0 0 0 0 0 #common exprs: b,c,o,c1,o1
+C0 #con3
+n0
+x1 #initial guess
+0 100 #eq
+r #1 ranges (rhs's)
+4 2.0 #con3
+b #1 bounds (on variables)
+3 #eq
+k0 #intermediate Jacobian column lengths
+J0 1 #con3
+0 -1
+""",
+ OUT.getvalue(),
+ )
+ )
+
+ def test_presolve_check_invalid_monomial_constraints(self):
+ # This checks issue #3272
+ m = ConcreteModel()
+ m.x = Var()
+ m.c = Constraint(expr=m.x == 5)
+ m.d = Constraint(expr=m.x >= 10)
+
+ OUT = io.StringIO()
+ with self.assertRaisesRegex(
+ nl_writer.InfeasibleConstraintException,
+ r"model contains a trivially infeasible constraint 'd' "
+ r"\(fixed body value 5.0 outside bounds \[10, None\]\)\.",
+ ):
+ nl_writer.NLWriter().write(m, OUT, linear_presolve=True)
diff --git a/pyomo/repn/tests/test_linear.py b/pyomo/repn/tests/test_linear.py
index 6843650d0c2..861fecc7888 100644
--- a/pyomo/repn/tests/test_linear.py
+++ b/pyomo/repn/tests/test_linear.py
@@ -1436,6 +1436,22 @@ def test_errors_propagate_nan(self):
m.z = Var()
m.y.fix(1)
+ expr = (m.x + 1) / m.p
+ cfg = VisitorConfig()
+ with LoggingIntercept() as LOG:
+ repn = LinearRepnVisitor(*cfg).walk_expression(expr)
+ self.assertEqual(
+ LOG.getvalue(),
+ "Exception encountered evaluating expression 'div(1, 0)'\n"
+ "\tmessage: division by zero\n"
+ "\texpression: (x + 1)/p\n",
+ )
+ self.assertEqual(repn.multiplier, 1)
+ self.assertEqual(str(repn.constant), 'InvalidNumber(nan)')
+ self.assertEqual(len(repn.linear), 1)
+ self.assertEqual(str(repn.linear[id(m.x)]), 'InvalidNumber(nan)')
+ self.assertEqual(repn.nonlinear, None)
+
expr = m.y + m.x + m.z + ((3 * m.x) / m.p) / m.y
cfg = VisitorConfig()
with LoggingIntercept() as LOG:
@@ -1589,7 +1605,7 @@ def test_to_expression(self):
expr.constant = 0
expr.linear[id(m.x)] = 0
expr.linear[id(m.y)] = 0
- assertExpressionsEqual(self, expr.to_expression(visitor), LinearExpression())
+ assertExpressionsEqual(self, expr.to_expression(visitor), 0)
@unittest.skipUnless(numpy_available, "Test requires numpy")
def test_nonnumeric(self):
diff --git a/pyomo/repn/tests/test_standard_form.py b/pyomo/repn/tests/test_standard_form.py
index e24195edfde..4c66ae87c41 100644
--- a/pyomo/repn/tests/test_standard_form.py
+++ b/pyomo/repn/tests/test_standard_form.py
@@ -42,6 +42,23 @@ def test_linear_model(self):
self.assertTrue(np.all(repn.c == np.array([0, 0, 0])))
self.assertTrue(np.all(repn.A == np.array([[-1, -2, 0], [0, 1, 4]])))
self.assertTrue(np.all(repn.rhs == np.array([-3, 5])))
+ self.assertEqual(repn.rows, [(m.c, -1), (m.d, 1)])
+ self.assertEqual(repn.columns, [m.x, m.y[1], m.y[3]])
+
+ def test_almost_dense_linear_model(self):
+ m = pyo.ConcreteModel()
+ m.x = pyo.Var()
+ m.y = pyo.Var([1, 2, 3])
+ m.c = pyo.Constraint(expr=m.x + 2 * m.y[1] + 4 * m.y[3] >= 10)
+ m.d = pyo.Constraint(expr=5 * m.x + 6 * m.y[1] + 8 * m.y[3] <= 20)
+
+ repn = LinearStandardFormCompiler().write(m)
+
+ self.assertTrue(np.all(repn.c == np.array([0, 0, 0])))
+ self.assertTrue(np.all(repn.A == np.array([[-1, -2, -4], [5, 6, 8]])))
+ self.assertTrue(np.all(repn.rhs == np.array([-10, 20])))
+ self.assertEqual(repn.rows, [(m.c, -1), (m.d, 1)])
+ self.assertEqual(repn.columns, [m.x, m.y[1], m.y[3]])
def test_linear_model_row_col_order(self):
m = pyo.ConcreteModel()
@@ -57,6 +74,8 @@ def test_linear_model_row_col_order(self):
self.assertTrue(np.all(repn.c == np.array([0, 0, 0])))
self.assertTrue(np.all(repn.A == np.array([[4, 0, 1], [0, -1, -2]])))
self.assertTrue(np.all(repn.rhs == np.array([5, -3])))
+ self.assertEqual(repn.rows, [(m.d, 1), (m.c, -1)])
+ self.assertEqual(repn.columns, [m.y[3], m.x, m.y[1]])
def test_suffix_warning(self):
m = pyo.ConcreteModel()
@@ -222,6 +241,28 @@ def test_alternative_forms(self):
)
self._verify_solution(soln, repn, True)
+ repn = LinearStandardFormCompiler().write(
+ m, mixed_form=True, column_order=col_order
+ )
+
+ self.assertEqual(
+ repn.rows, [(m.c, -1), (m.d, 1), (m.e, 1), (m.e, -1), (m.f, 0)]
+ )
+ self.assertEqual(list(map(str, repn.x)), ['x', 'y[0]', 'y[1]', 'y[3]'])
+ self.assertEqual(
+ list(v.bounds for v in repn.x), [(None, None), (0, 10), (-5, 10), (-5, -2)]
+ )
+ ref = np.array(
+ [[1, 0, 2, 0], [0, 0, 1, 4], [0, 1, 6, 0], [0, 1, 6, 0], [1, 1, 0, 0]]
+ )
+ self.assertTrue(np.all(repn.A == ref))
+ self.assertTrue(np.all(repn.b == np.array([3, 5, 6, -3, 8])))
+ self.assertTrue(np.all(repn.c == np.array([[-1, 0, -5, 0], [1, 0, 0, 15]])))
+ # Note that the mixed_form solution is a mix of inequality and
+ # equality constraints, so we cannot (easily) reuse the
+ # _verify_solutions helper (as in the above cases):
+ # self._verify_solution(soln, repn, False)
+
repn = LinearStandardFormCompiler().write(
m, slack_form=True, nonnegative_vars=True, column_order=col_order
)
diff --git a/pyomo/repn/tests/test_util.py b/pyomo/repn/tests/test_util.py
index b5e4cc4facf..e0fea0fb45c 100644
--- a/pyomo/repn/tests/test_util.py
+++ b/pyomo/repn/tests/test_util.py
@@ -718,16 +718,14 @@ class UnknownExpression(NumericExpression):
DeveloperError, r".*Unexpected expression node type 'UnknownExpression'"
):
end[node.__class__](None, node, *node.args)
- self.assertEqual(len(end), 9)
- self.assertIn(UnknownExpression, end)
+ self.assertEqual(len(end), 8)
node = UnknownExpression((6, 7))
with self.assertRaisesRegex(
DeveloperError, r".*Unexpected expression node type 'UnknownExpression'"
):
end[node.__class__, 6, 7](None, node, *node.args)
- self.assertEqual(len(end), 10)
- self.assertIn((UnknownExpression, 6, 7), end)
+ self.assertEqual(len(end), 8)
def test_BeforeChildDispatcher_registration(self):
class BeforeChildDispatcherTester(BeforeChildDispatcher):
diff --git a/pyomo/repn/util.py b/pyomo/repn/util.py
index 49cca32eaf9..8d902d0f99a 100644
--- a/pyomo/repn/util.py
+++ b/pyomo/repn/util.py
@@ -40,7 +40,7 @@
SortComponents,
)
from pyomo.core.base.component import ActiveComponent
-from pyomo.core.base.expression import _ExpressionData
+from pyomo.core.base.expression import NamedExpressionData
from pyomo.core.expr.numvalue import is_fixed, value
import pyomo.core.expr as EXPR
import pyomo.core.kernel as kernel
@@ -55,7 +55,7 @@
EXPR.NPV_SumExpression,
}
_named_subexpression_types = (
- _ExpressionData,
+ NamedExpressionData,
kernel.expression.expression,
kernel.objective.objective,
)
@@ -400,7 +400,15 @@ def __init__(self, *args, **kwargs):
def __missing__(self, key):
if type(key) is tuple:
- node_class = key[0]
+ # Only lookup/cache argument-specific handlers for unary,
+ # binary and ternary operators
+ if len(key) <= 3:
+ node_class = key[0]
+ node_args = key[1:]
+ else:
+ node_class = key = key[0]
+ if node_class in self:
+ return self[node_class]
else:
node_class = key
bases = node_class.__mro__
@@ -412,30 +420,31 @@ def __missing__(self, key):
bases = [Expression]
fcn = None
for base_type in bases:
- if isinstance(key, tuple):
- base_key = (base_type,) + key[1:]
- # Only cache handlers for unary, binary and ternary operators
- cache = len(key) <= 4
- else:
- base_key = base_type
- cache = True
- if base_key in self:
- fcn = self[base_key]
- elif base_type in self:
+ if key is not node_class:
+ if (base_type,) + node_args in self:
+ fcn = self[(base_type,) + node_args]
+ break
+ if base_type in self:
fcn = self[base_type]
- elif any((k[0] if type(k) is tuple else k) is base_type for k in self):
- raise DeveloperError(
- f"Base expression key '{base_key}' not found when inserting "
- f"dispatcher for node '{node_class.__name__}' while walking "
- "expression tree."
- )
+ break
if fcn is None:
- fcn = self.unexpected_expression_type
- if cache:
- self[key] = fcn
+ partial_matches = set(
+ k[0] for k in self if type(k) is tuple and issubclass(node_class, k[0])
+ )
+ for base_type in node_class.__mro__:
+ if node_class is not key:
+ key = (base_type,) + node_args
+ if base_type in partial_matches:
+ raise DeveloperError(
+ f"Base expression key '{key}' not found when inserting "
+ f"dispatcher for node '{node_class.__name__}' while walking "
+ "expression tree."
+ )
+ return self.unexpected_expression_type
+ self[key] = fcn
return fcn
- def unexpected_expression_type(self, visitor, node, *arg):
+ def unexpected_expression_type(self, visitor, node, *args):
raise DeveloperError(
f"Unexpected expression node type '{type(node).__name__}' "
f"found while walking expression tree in {type(visitor).__name__}."
@@ -486,7 +495,7 @@ def categorize_valid_components(
Parameters
----------
- model: _BlockData
+ model: BlockData
The model tree to walk
active: True or None
@@ -507,7 +516,7 @@ def categorize_valid_components(
Returns
-------
- component_map: Dict[type, List[_BlockData]]
+ component_map: Dict[type, List[BlockData]]
A dict mapping component type to a list of block data
objects that contain declared component of that type.
diff --git a/pyomo/scripting/plugins/download.py b/pyomo/scripting/plugins/download.py
index eea858a737f..afe56988009 100644
--- a/pyomo/scripting/plugins/download.py
+++ b/pyomo/scripting/plugins/download.py
@@ -38,9 +38,9 @@ def _call_impl(self, args, unparsed, logger):
self.downloader.cacert = args.cacert
self.downloader.insecure = args.insecure
logger.info(
- "As of February 9, 2023, AMPL GSL can no longer be downloaded\
- through download-extensions. Visit https://portal.ampl.com/\
- to download the AMPL GSL binaries."
+ "As of February 9, 2023, AMPL GSL can no longer be downloaded \
+ through download-extensions. Visit https://portal.ampl.com/ \
+ to download the AMPL GSL binaries."
)
for target in DownloadFactory:
try:
diff --git a/pyomo/solvers/amplfunc_merge.py b/pyomo/solvers/amplfunc_merge.py
new file mode 100644
index 00000000000..e49fd20e20f
--- /dev/null
+++ b/pyomo/solvers/amplfunc_merge.py
@@ -0,0 +1,32 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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.
+# ___________________________________________________________________________
+
+
+def amplfunc_string_merge(amplfunc, pyomo_amplfunc):
+ """Merge two AMPLFUNC variable strings eliminating duplicate lines"""
+ # Assume that the strings amplfunc and pyomo_amplfunc don't contain duplicates
+ # Assume that the path separator is correct for the OS so we don't need to
+ # worry about comparing Unix and Windows paths.
+ amplfunc_lines = amplfunc.split("\n")
+ existing = set(amplfunc_lines)
+ for line in pyomo_amplfunc.split("\n"):
+ # Skip lines we already have
+ if line not in existing:
+ amplfunc_lines.append(line)
+ # Remove empty lines which could happen if one or both of the strings is
+ # empty or there are two new lines in a row for whatever reason.
+ amplfunc_lines = [s for s in amplfunc_lines if s != ""]
+ return "\n".join(amplfunc_lines)
+
+
+def amplfunc_merge(env):
+ """Merge AMPLFUNC and PYOMO_AMPLFUNC in an environment var dict"""
+ return amplfunc_string_merge(env.get("AMPLFUNC", ""), env.get("PYOMO_AMPLFUNC", ""))
diff --git a/pyomo/solvers/plugins/solvers/ASL.py b/pyomo/solvers/plugins/solvers/ASL.py
index ae7ad82c870..bb8174a013e 100644
--- a/pyomo/solvers/plugins/solvers/ASL.py
+++ b/pyomo/solvers/plugins/solvers/ASL.py
@@ -23,6 +23,7 @@
from pyomo.opt.solver import SystemCallSolver
from pyomo.core.kernel.block import IBlock
from pyomo.solvers.mockmip import MockMIP
+from pyomo.solvers.amplfunc_merge import amplfunc_merge
from pyomo.core import TransformationFactory
import logging
@@ -158,11 +159,9 @@ def create_command_line(self, executable, problem_files):
# Pyomo/Pyomo) with any user-specified external function
# libraries
#
- if 'PYOMO_AMPLFUNC' in env:
- if 'AMPLFUNC' in env:
- env['AMPLFUNC'] += "\n" + env['PYOMO_AMPLFUNC']
- else:
- env['AMPLFUNC'] = env['PYOMO_AMPLFUNC']
+ amplfunc = amplfunc_merge(env)
+ if amplfunc:
+ env['AMPLFUNC'] = amplfunc
cmd = [executable, problem_files[0], '-AMPL']
if self._timer:
diff --git a/pyomo/solvers/plugins/solvers/CBCplugin.py b/pyomo/solvers/plugins/solvers/CBCplugin.py
index eb6c2c2e1bd..20876b07331 100644
--- a/pyomo/solvers/plugins/solvers/CBCplugin.py
+++ b/pyomo/solvers/plugins/solvers/CBCplugin.py
@@ -16,6 +16,7 @@
import subprocess
from pyomo.common import Executable
+from pyomo.common.enums import maximize, minimize
from pyomo.common.errors import ApplicationError
from pyomo.common.collections import Bunch
from pyomo.common.tempfiles import TempfileManager
@@ -29,7 +30,6 @@
SolverStatus,
TerminationCondition,
SolutionStatus,
- ProblemSense,
Solution,
)
from pyomo.opt.solver import SystemCallSolver
@@ -443,7 +443,7 @@ def process_logfile(self):
#
# Parse logfile lines
#
- results.problem.sense = ProblemSense.minimize
+ results.problem.sense = minimize
results.problem.name = None
optim_value = float('inf')
lower_bound = None
@@ -455,7 +455,7 @@ def process_logfile(self):
tokens = tuple(re.split('[ \t]+', line.strip()))
n_tokens = len(tokens)
if n_tokens > 1:
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L3769
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L3769
if n_tokens > 4 and tokens[:4] == (
'Continuous',
'objective',
@@ -539,7 +539,7 @@ def process_logfile(self):
results.problem.name = results.problem.name.split('/')[-1]
if '\\' in results.problem.name:
results.problem.name = results.problem.name.split('\\')[-1]
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L10840
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L10840
elif tokens[0] == 'Presolve':
if n_tokens > 9 and tokens[3] == 'rows,' and tokens[6] == 'columns':
results.problem.number_of_variables = int(tokens[4]) - int(
@@ -551,7 +551,7 @@ def process_logfile(self):
results.problem.number_of_objectives = 1
elif n_tokens > 6 and tokens[6] == 'infeasible':
soln.status = SolutionStatus.infeasible
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L11105
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L11105
elif (
n_tokens > 11
and tokens[:2] == ('Problem', 'has')
@@ -563,7 +563,7 @@ def process_logfile(self):
results.problem.number_of_constraints = int(tokens[2])
results.problem.number_of_nonzeros = int(tokens[6][1:])
results.problem.number_of_objectives = 1
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L10814
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L10814
elif (
n_tokens > 8
and tokens[:3] == ('Original', 'problem', 'has')
@@ -578,8 +578,8 @@ def process_logfile(self):
'CoinLpIO::readLp(): Maximization problem reformulated as minimization'
in ' '.join(tokens)
):
- results.problem.sense = ProblemSense.maximize
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L3047
+ results.problem.sense = maximize
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L3047
elif n_tokens > 3 and tokens[:2] == ('Result', '-'):
if tokens[2:4] in [('Run', 'abandoned'), ('User', 'ctrl-c')]:
results.solver.termination_condition = (
@@ -609,15 +609,15 @@ def process_logfile(self):
'solution': TerminationCondition.other,
'iterations': TerminationCondition.maxIterations,
}.get(tokens[4], TerminationCondition.other)
- # perhaps from https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L12318
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L12318
elif n_tokens > 3 and tokens[2] == "Finished":
soln.status = SolutionStatus.optimal
optim_value = _float(tokens[4])
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L7904
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L7904
elif n_tokens >= 3 and tokens[:2] == ('Objective', 'value:'):
# parser for log file generetated with discrete variable
optim_value = _float(tokens[2])
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L7904
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L7904
elif n_tokens >= 4 and tokens[:4] == (
'No',
'feasible',
@@ -630,25 +630,25 @@ def process_logfile(self):
lower_bound is None
): # Only use if not already found since this is to less decimal places
results.problem.lower_bound = _float(tokens[2])
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L7918
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L7918
elif tokens[0] == 'Gap:':
# This is relative and only to 2 decimal places - could calculate explicitly using lower bound
gap = _float(tokens[1])
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L7923
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L7923
elif n_tokens > 2 and tokens[:2] == ('Enumerated', 'nodes:'):
nodes = int(tokens[2])
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L7926
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L7926
elif n_tokens > 2 and tokens[:2] == ('Total', 'iterations:'):
results.solver.statistics.black_box.number_of_iterations = int(
tokens[2]
)
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L7930
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L7930
elif n_tokens > 3 and tokens[:3] == ('Time', '(CPU', 'seconds):'):
results.solver.system_time = _float(tokens[3])
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L7933
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L7933
elif n_tokens > 3 and tokens[:3] == ('Time', '(Wallclock', 'Seconds):'):
results.solver.wallclock_time = _float(tokens[3])
- # https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp?rev=2497#L10477
+ # https://github.com/coin-or/Cbc/blob/cb6bf98/Cbc/src/CbcSolver.cpp#L10477
elif n_tokens > 4 and tokens[:4] == (
'Total',
'time',
@@ -752,9 +752,9 @@ def process_logfile(self):
"maxIterations parameter."
)
soln.gap = gap
- if results.problem.sense == ProblemSense.minimize:
+ if results.problem.sense == minimize:
upper_bound = optim_value
- elif results.problem.sense == ProblemSense.maximize:
+ elif results.problem.sense == maximize:
_ver = self.version()
if _ver and _ver[:3] < (2, 10, 2):
optim_value *= -1
@@ -824,7 +824,7 @@ def process_soln_file(self, results):
INPUT = []
_ver = self.version()
- invert_objective_sense = results.problem.sense == ProblemSense.maximize and (
+ invert_objective_sense = results.problem.sense == maximize and (
_ver and _ver[:3] < (2, 10, 2)
)
@@ -832,11 +832,15 @@ def process_soln_file(self, results):
tokens = tuple(re.split('[ \t]+', line.strip()))
n_tokens = len(tokens)
#
- # These are the only header entries CBC will generate (identified via browsing CbcSolver.cpp)
- # See https://projects.coin-or.org/Cbc/browser/trunk/Cbc/src/CbcSolver.cpp
- # Search for (no integer solution - continuous used) Currently line 9912 as of rev2497
- # Note that since this possibly also covers old CBC versions, we shall not be removing any functionality,
- # even if it is not seen in the current revision
+ # These are the only header entries CBC will generate
+ # (identified via browsing CbcSolver.cpp). See
+ # https://github.com/coin-or/Cbc/tree/master/src/CbcSolver.cpp
+ # Search for "(no integer solution - continuous used)"
+ # (L10796 as of cb855c7)
+ #
+ # Note that since this possibly also supports old CBC
+ # versions, we shall not be removing any functionality, even
+ # if it is not seen in the current revision
#
if not header_processed:
if tokens[0] == 'Optimal':
diff --git a/pyomo/solvers/plugins/solvers/CONOPT.py b/pyomo/solvers/plugins/solvers/CONOPT.py
index 89ee3848805..3455eede67b 100644
--- a/pyomo/solvers/plugins/solvers/CONOPT.py
+++ b/pyomo/solvers/plugins/solvers/CONOPT.py
@@ -79,7 +79,7 @@ def _get_version(self):
return _extract_version('')
results = subprocess.run(
[solver_exec],
- timeout=1,
+ timeout=self._version_timeout,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True,
diff --git a/pyomo/solvers/plugins/solvers/CPLEX.py b/pyomo/solvers/plugins/solvers/CPLEX.py
index b2b8c5e988d..3a08257c87c 100644
--- a/pyomo/solvers/plugins/solvers/CPLEX.py
+++ b/pyomo/solvers/plugins/solvers/CPLEX.py
@@ -17,6 +17,7 @@
import subprocess
from pyomo.common import Executable
+from pyomo.common.enums import maximize, minimize
from pyomo.common.errors import ApplicationError
from pyomo.common.tempfiles import TempfileManager
@@ -28,7 +29,6 @@
SolverStatus,
TerminationCondition,
SolutionStatus,
- ProblemSense,
Solution,
)
from pyomo.opt.solver import ILMLicensedSystemCallSolver
@@ -404,7 +404,7 @@ def _get_version(self):
return _extract_version('')
results = subprocess.run(
[solver_exec, '-c', 'quit'],
- timeout=1,
+ timeout=self._version_timeout,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True,
@@ -547,9 +547,9 @@ def process_logfile(self):
): # CPLEX 11.2 and subsequent has two Nonzeros sections.
results.problem.number_of_nonzeros = int(tokens[2])
elif len(tokens) >= 5 and tokens[4] == "MINIMIZE":
- results.problem.sense = ProblemSense.minimize
+ results.problem.sense = minimize
elif len(tokens) >= 5 and tokens[4] == "MAXIMIZE":
- results.problem.sense = ProblemSense.maximize
+ results.problem.sense = maximize
elif (
len(tokens) >= 4
and tokens[0] == "Solution"
@@ -859,9 +859,9 @@ def process_soln_file(self, results):
else:
sense = tokens[0].lower()
if sense in ['max', 'maximize']:
- results.problem.sense = ProblemSense.maximize
+ results.problem.sense = maximize
if sense in ['min', 'minimize']:
- results.problem.sense = ProblemSense.minimize
+ results.problem.sense = minimize
break
tINPUT.close()
@@ -952,7 +952,7 @@ def process_soln_file(self, results):
)
if primal_feasible == 1:
soln.status = SolutionStatus.feasible
- if results.problem.sense == ProblemSense.minimize:
+ if results.problem.sense == minimize:
results.problem.upper_bound = soln.objective[
'__default_objective__'
]['Value']
@@ -964,7 +964,7 @@ def process_soln_file(self, results):
soln.status = SolutionStatus.infeasible
if self._best_bound is not None:
- if results.problem.sense == ProblemSense.minimize:
+ if results.problem.sense == minimize:
results.problem.lower_bound = self._best_bound
else:
results.problem.upper_bound = self._best_bound
diff --git a/pyomo/solvers/plugins/solvers/GAMS.py b/pyomo/solvers/plugins/solvers/GAMS.py
index e84cbdb441d..035bd0b7603 100644
--- a/pyomo/solvers/plugins/solvers/GAMS.py
+++ b/pyomo/solvers/plugins/solvers/GAMS.py
@@ -36,12 +36,11 @@
Solution,
SolutionStatus,
TerminationCondition,
- ProblemSense,
)
from pyomo.common.dependencies import attempt_import
-gdxcc, gdxcc_available = attempt_import('gdxcc', defer_check=True)
+gdxcc, gdxcc_available = attempt_import('gdxcc')
logger = logging.getLogger('pyomo.solvers')
@@ -198,8 +197,8 @@ def _get_version(self):
return _extract_version('')
from gams import GamsWorkspace
- ws = GamsWorkspace()
- version = tuple(int(i) for i in ws._version.split('.')[:4])
+ workspace = GamsWorkspace()
+ version = tuple(int(i) for i in workspace._version.split('.')[:4])
while len(version) < 4:
version += (0,)
return version
@@ -209,8 +208,8 @@ def _run_simple_model(self, n):
try:
from gams import GamsWorkspace, DebugLevel
- ws = GamsWorkspace(debug=DebugLevel.Off, working_directory=tmpdir)
- t1 = ws.add_job_from_string(self._simple_model(n))
+ workspace = GamsWorkspace(debug=DebugLevel.Off, working_directory=tmpdir)
+ t1 = workspace.add_job_from_string(self._simple_model(n))
t1.run()
return True
except:
@@ -330,12 +329,12 @@ def solve(self, *args, **kwds):
if tmpdir is not None and os.path.exists(tmpdir):
newdir = False
- ws = GamsWorkspace(
+ workspace = GamsWorkspace(
debug=DebugLevel.KeepFiles if keepfiles else DebugLevel.Off,
working_directory=tmpdir,
)
- t1 = ws.add_job_from_string(output_file.getvalue())
+ t1 = workspace.add_job_from_string(output_file.getvalue())
try:
with OutputStream(tee=tee, logfile=logfile) as output_stream:
@@ -349,7 +348,9 @@ def solve(self, *args, **kwds):
# Always name working directory or delete files,
# regardless of any errors.
if keepfiles:
- print("\nGAMS WORKING DIRECTORY: %s\n" % ws.working_directory)
+ print(
+ "\nGAMS WORKING DIRECTORY: %s\n" % workspace.working_directory
+ )
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
@@ -359,7 +360,7 @@ def solve(self, *args, **kwds):
except:
# Catch other errors and remove files first
if keepfiles:
- print("\nGAMS WORKING DIRECTORY: %s\n" % ws.working_directory)
+ print("\nGAMS WORKING DIRECTORY: %s\n" % workspace.working_directory)
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
@@ -398,7 +399,9 @@ def solve(self, *args, **kwds):
extract_rc = 'rc' in model_suffixes
results = SolverResults()
- results.problem.name = os.path.join(ws.working_directory, t1.name + '.gms')
+ results.problem.name = os.path.join(
+ workspace.working_directory, t1.name + '.gms'
+ )
results.problem.lower_bound = t1.out_db["OBJEST"].find_record().value
results.problem.upper_bound = t1.out_db["OBJEST"].find_record().value
results.problem.number_of_variables = t1.out_db["NUMVAR"].find_record().value
@@ -418,11 +421,10 @@ def solve(self, *args, **kwds):
assert len(obj) == 1, 'Only one objective is allowed.'
obj = obj[0]
objctvval = t1.out_db["OBJVAL"].find_record().value
+ results.problem.sense = obj.sense
if obj.is_minimizing():
- results.problem.sense = ProblemSense.minimize
results.problem.upper_bound = objctvval
else:
- results.problem.sense = ProblemSense.maximize
results.problem.lower_bound = objctvval
results.solver.name = "GAMS " + str(self.version())
@@ -587,7 +589,7 @@ def solve(self, *args, **kwds):
results.solution.insert(soln)
if keepfiles:
- print("\nGAMS WORKING DIRECTORY: %s\n" % ws.working_directory)
+ print("\nGAMS WORKING DIRECTORY: %s\n" % workspace.working_directory)
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
@@ -980,11 +982,10 @@ def solve(self, *args, **kwds):
assert len(obj) == 1, 'Only one objective is allowed.'
obj = obj[0]
objctvval = stat_vars["OBJVAL"]
+ results.problem.sense = obj.sense
if obj.is_minimizing():
- results.problem.sense = ProblemSense.minimize
results.problem.upper_bound = objctvval
else:
- results.problem.sense = ProblemSense.maximize
results.problem.lower_bound = objctvval
results.solver.name = "GAMS " + str(self.version())
diff --git a/pyomo/solvers/plugins/solvers/GLPK.py b/pyomo/solvers/plugins/solvers/GLPK.py
index 39948d465f4..c8d5bc14237 100644
--- a/pyomo/solvers/plugins/solvers/GLPK.py
+++ b/pyomo/solvers/plugins/solvers/GLPK.py
@@ -19,6 +19,8 @@
from pyomo.common import Executable
from pyomo.common.collections import Bunch
+from pyomo.common.enums import maximize, minimize
+from pyomo.common.errors import ApplicationError
from pyomo.opt import (
SolverFactory,
OptSolver,
@@ -27,7 +29,6 @@
SolverResults,
TerminationCondition,
SolutionStatus,
- ProblemSense,
)
from pyomo.opt.base.solvers import _extract_version
from pyomo.opt.solver import SystemCallSolver
@@ -137,7 +138,7 @@ def _get_version(self, executable=None):
[executable, "--version"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
- timeout=1,
+ timeout=self._version_timeout,
universal_newlines=True,
)
return _extract_version(result.stdout)
@@ -307,10 +308,8 @@ def process_soln_file(self, results):
):
raise ValueError
- self.is_integer = 'mip' == ptype and True or False
- prob.sense = (
- 'min' == psense and ProblemSense.minimize or ProblemSense.maximize
- )
+ self.is_integer = 'mip' == ptype
+ prob.sense = minimize if 'min' == psense else maximize
prob.number_of_constraints = prows
prob.number_of_nonzeros = pnonz
prob.number_of_variables = pcols
diff --git a/pyomo/solvers/plugins/solvers/GUROBI.py b/pyomo/solvers/plugins/solvers/GUROBI.py
index c8b0912970e..3a3a4d52322 100644
--- a/pyomo/solvers/plugins/solvers/GUROBI.py
+++ b/pyomo/solvers/plugins/solvers/GUROBI.py
@@ -18,6 +18,7 @@
from pyomo.common import Executable
from pyomo.common.collections import Bunch
+from pyomo.common.enums import maximize, minimize
from pyomo.common.fileutils import this_file_dir
from pyomo.common.tee import capture_output
from pyomo.common.tempfiles import TempfileManager
@@ -28,7 +29,6 @@
SolverStatus,
TerminationCondition,
SolutionStatus,
- ProblemSense,
Solution,
)
from pyomo.opt.solver import ILMLicensedSystemCallSolver
@@ -472,7 +472,7 @@ def process_soln_file(self, results):
soln.objective['__default_objective__'] = {
'Value': float(tokens[1])
}
- if results.problem.sense == ProblemSense.minimize:
+ if results.problem.sense == minimize:
results.problem.upper_bound = float(tokens[1])
else:
results.problem.lower_bound = float(tokens[1])
@@ -514,9 +514,9 @@ def process_soln_file(self, results):
elif section == 1:
if tokens[0] == 'sense':
if tokens[1] == 'minimize':
- results.problem.sense = ProblemSense.minimize
+ results.problem.sense = minimize
elif tokens[1] == 'maximize':
- results.problem.sense = ProblemSense.maximize
+ results.problem.sense = maximize
else:
try:
val = eval(tokens[1])
diff --git a/pyomo/solvers/plugins/solvers/IPOPT.py b/pyomo/solvers/plugins/solvers/IPOPT.py
index deda4314a52..21045cb7b4f 100644
--- a/pyomo/solvers/plugins/solvers/IPOPT.py
+++ b/pyomo/solvers/plugins/solvers/IPOPT.py
@@ -21,6 +21,8 @@
from pyomo.opt.results import SolverStatus, SolverResults, TerminationCondition
from pyomo.opt.solver import SystemCallSolver
+from pyomo.solvers.amplfunc_merge import amplfunc_merge
+
import logging
logger = logging.getLogger('pyomo.solvers')
@@ -79,7 +81,7 @@ def _get_version(self):
return _extract_version('')
results = subprocess.run(
[solver_exec, "-v"],
- timeout=1,
+ timeout=self._version_timeout,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True,
@@ -119,11 +121,9 @@ def create_command_line(self, executable, problem_files):
# Pyomo/Pyomo) with any user-specified external function
# libraries
#
- if 'PYOMO_AMPLFUNC' in env:
- if 'AMPLFUNC' in env:
- env['AMPLFUNC'] += "\n" + env['PYOMO_AMPLFUNC']
- else:
- env['AMPLFUNC'] = env['PYOMO_AMPLFUNC']
+ amplfunc = amplfunc_merge(env)
+ if amplfunc:
+ env['AMPLFUNC'] = amplfunc
cmd = [executable, problem_files[0], '-AMPL']
if self._timer:
diff --git a/pyomo/solvers/plugins/solvers/SCIPAMPL.py b/pyomo/solvers/plugins/solvers/SCIPAMPL.py
index be7415a19ef..98dad4ca5fd 100644
--- a/pyomo/solvers/plugins/solvers/SCIPAMPL.py
+++ b/pyomo/solvers/plugins/solvers/SCIPAMPL.py
@@ -20,12 +20,7 @@
from pyomo.opt.base import ProblemFormat, ResultsFormat
from pyomo.opt.base.solvers import _extract_version, SolverFactory
-from pyomo.opt.results import (
- SolverStatus,
- TerminationCondition,
- SolutionStatus,
- ProblemSense,
-)
+from pyomo.opt.results import SolverStatus, TerminationCondition, SolutionStatus
from pyomo.opt.solver import SystemCallSolver
import logging
@@ -103,7 +98,7 @@ def _get_version(self, solver_exec=None):
return _extract_version('')
results = subprocess.run(
[solver_exec, "--version"],
- timeout=1,
+ timeout=self._version_timeout,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True,
@@ -374,9 +369,11 @@ def _postsolve(self):
if len(results.solution) > 0:
results.solution(0).status = SolutionStatus.optimal
try:
- if results.problem.sense == ProblemSense.minimize:
+ if results.solver.primal_bound < results.solver.dual_bound:
results.problem.lower_bound = results.solver.primal_bound
+ results.problem.upper_bound = results.solver.dual_bound
else:
+ results.problem.lower_bound = results.solver.dual_bound
results.problem.upper_bound = results.solver.primal_bound
except AttributeError:
"""
@@ -455,7 +452,7 @@ def read_scip_log(filename: str):
solver_status = scip_lines[0][colon_position + 2 : scip_lines[0].index('\n')]
solving_time = float(
- scip_lines[1][colon_position + 2 : scip_lines[1].index('\n')]
+ scip_lines[1][colon_position + 2 : scip_lines[1].index('\n')].split(' ')[0]
)
try:
diff --git a/pyomo/solvers/plugins/solvers/cplex_persistent.py b/pyomo/solvers/plugins/solvers/cplex_persistent.py
index fd396a8c87f..754dadc09e2 100644
--- a/pyomo/solvers/plugins/solvers/cplex_persistent.py
+++ b/pyomo/solvers/plugins/solvers/cplex_persistent.py
@@ -82,7 +82,7 @@ def update_var(self, var):
Parameters
----------
- var: Var (scalar Var or single _VarData)
+ var: Var (scalar Var or single VarData)
"""
# see PR #366 for discussion about handling indexed
@@ -130,7 +130,7 @@ def _add_column(self, var, obj_coef, constraints, coefficients):
Parameters
----------
- var: Var (scalar Var or single _VarData)
+ var: Var (scalar Var or single VarData)
obj_coef: float
constraints: list of solver constraints
coefficients: list of coefficients to put on var in the associated constraint
diff --git a/pyomo/solvers/plugins/solvers/direct_or_persistent_solver.py b/pyomo/solvers/plugins/solvers/direct_or_persistent_solver.py
index c131b8ad10a..de38a0372d0 100644
--- a/pyomo/solvers/plugins/solvers/direct_or_persistent_solver.py
+++ b/pyomo/solvers/plugins/solvers/direct_or_persistent_solver.py
@@ -10,7 +10,7 @@
# ___________________________________________________________________________
from pyomo.core.base.PyomoModel import Model
-from pyomo.core.base.block import Block, _BlockData
+from pyomo.core.base.block import Block, BlockData
from pyomo.core.kernel.block import IBlock
from pyomo.opt.base.solvers import OptSolver
from pyomo.core.base import SymbolMap, NumericLabeler, TextLabeler
@@ -177,7 +177,7 @@ def _postsolve(self):
""" This method should be implemented by subclasses."""
def _set_instance(self, model, kwds={}):
- if not isinstance(model, (Model, IBlock, Block, _BlockData)):
+ if not isinstance(model, (Model, IBlock, Block, BlockData)):
msg = (
"The problem instance supplied to the {0} plugin "
"'_presolve' method must be a Model or a Block".format(type(self))
diff --git a/pyomo/solvers/plugins/solvers/direct_solver.py b/pyomo/solvers/plugins/solvers/direct_solver.py
index 3eab658391c..609a81b2018 100644
--- a/pyomo/solvers/plugins/solvers/direct_solver.py
+++ b/pyomo/solvers/plugins/solvers/direct_solver.py
@@ -15,7 +15,7 @@
from pyomo.solvers.plugins.solvers.direct_or_persistent_solver import (
DirectOrPersistentSolver,
)
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.core.kernel.block import IBlock
from pyomo.core.base.suffix import active_import_suffix_generator
from pyomo.core.kernel.suffix import import_suffix_generator
@@ -79,8 +79,8 @@ def solve(self, *args, **kwds):
#
_model = None
for arg in args:
- if isinstance(arg, (_BlockData, IBlock)):
- if isinstance(arg, _BlockData):
+ if isinstance(arg, (BlockData, IBlock)):
+ if isinstance(arg, BlockData):
if not arg.is_constructed():
raise RuntimeError(
"Attempting to solve model=%s with unconstructed "
@@ -89,7 +89,7 @@ def solve(self, *args, **kwds):
_model = arg
# import suffixes must be on the top-level model
- if isinstance(arg, _BlockData):
+ if isinstance(arg, BlockData):
model_suffixes = list(
name for (name, comp) in active_import_suffix_generator(arg)
)
diff --git a/pyomo/solvers/plugins/solvers/gurobi_direct.py b/pyomo/solvers/plugins/solvers/gurobi_direct.py
index 1d88eced629..ed66a4e0e7b 100644
--- a/pyomo/solvers/plugins/solvers/gurobi_direct.py
+++ b/pyomo/solvers/plugins/solvers/gurobi_direct.py
@@ -493,9 +493,8 @@ def _add_constraint(self, con):
if not con.active:
return None
- if is_fixed(con.body):
- if self._skip_trivial_constraints:
- return None
+ if self._skip_trivial_constraints and is_fixed(con.body):
+ return None
conname = self._symbol_map.getSymbol(con, self._labeler)
diff --git a/pyomo/solvers/plugins/solvers/gurobi_persistent.py b/pyomo/solvers/plugins/solvers/gurobi_persistent.py
index 4522a2151c3..94a2ac6b734 100644
--- a/pyomo/solvers/plugins/solvers/gurobi_persistent.py
+++ b/pyomo/solvers/plugins/solvers/gurobi_persistent.py
@@ -111,7 +111,7 @@ def update_var(self, var):
Parameters
----------
- var: Var (scalar Var or single _VarData)
+ var: Var (scalar Var or single VarData)
"""
# see PR #366 for discussion about handling indexed
@@ -157,7 +157,7 @@ def set_linear_constraint_attr(self, con, attr, val):
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The pyomo constraint for which the corresponding gurobi constraint attribute
should be modified.
attr: str
@@ -192,7 +192,7 @@ def set_var_attr(self, var, attr, val):
Parameters
----------
- con: pyomo.core.base.var._GeneralVarData
+ con: pyomo.core.base.var.VarData
The pyomo var for which the corresponding gurobi var attribute
should be modified.
attr: str
@@ -342,7 +342,7 @@ def get_var_attr(self, var, attr):
Parameters
----------
- var: pyomo.core.base.var._GeneralVarData
+ var: pyomo.core.base.var.VarData
The pyomo var for which the corresponding gurobi var attribute
should be retrieved.
attr: str
@@ -384,7 +384,7 @@ def get_linear_constraint_attr(self, con, attr):
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The pyomo constraint for which the corresponding gurobi constraint attribute
should be retrieved.
attr: str
@@ -413,7 +413,7 @@ def get_sos_attr(self, con, attr):
Parameters
----------
- con: pyomo.core.base.sos._SOSConstraintData
+ con: pyomo.core.base.sos.SOSConstraintData
The pyomo SOS constraint for which the corresponding gurobi SOS constraint attribute
should be retrieved.
attr: str
@@ -431,7 +431,7 @@ def get_quadratic_constraint_attr(self, con, attr):
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The pyomo constraint for which the corresponding gurobi constraint attribute
should be retrieved.
attr: str
@@ -569,7 +569,7 @@ def cbCut(self, con):
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The cut to add
"""
if not con.active:
@@ -647,7 +647,7 @@ def cbLazy(self, con):
"""
Parameters
----------
- con: pyomo.core.base.constraint._GeneralConstraintData
+ con: pyomo.core.base.constraint.ConstraintData
The lazy constraint to add
"""
if not con.active:
@@ -710,7 +710,7 @@ def _add_column(self, var, obj_coef, constraints, coefficients):
Parameters
----------
- var: Var (scalar Var or single _VarData)
+ var: Var (scalar Var or single VarData)
obj_coef: float
constraints: list of solver constraints
coefficients: list of coefficients to put on var in the associated constraint
diff --git a/pyomo/solvers/plugins/solvers/mosek_direct.py b/pyomo/solvers/plugins/solvers/mosek_direct.py
index 5000a2f35c4..025c71d36f0 100644
--- a/pyomo/solvers/plugins/solvers/mosek_direct.py
+++ b/pyomo/solvers/plugins/solvers/mosek_direct.py
@@ -492,13 +492,10 @@ def _add_constraints(self, con_seq):
ptrb = (0,) + ptre[:-1]
asubs = tuple(itertools.chain.from_iterable(l_ids))
avals = tuple(itertools.chain.from_iterable(l_coefs))
- qcsubi = tuple(itertools.chain.from_iterable(q_is))
- qcsubj = tuple(itertools.chain.from_iterable(q_js))
- qcval = tuple(itertools.chain.from_iterable(q_vals))
- qcsubk = tuple(i for i in sub for j in range(len(q_is[i - con_num])))
self._solver_model.appendcons(num_lq)
self._solver_model.putarowlist(sub, ptrb, ptre, asubs, avals)
- self._solver_model.putqcon(qcsubk, qcsubi, qcsubj, qcval)
+ for k, i, j, v in zip(sub, q_is, q_js, q_vals):
+ self._solver_model.putqconk(k, i, j, v)
self._solver_model.putconboundlist(sub, bound_types, lbs, ubs)
for i, s_n in enumerate(sub_names):
self._solver_model.putconname(sub[i], s_n)
@@ -558,7 +555,7 @@ def _add_block(self, block):
Parameters
----------
- block: Block (scalar Block or single _BlockData)
+ block: Block (scalar Block or single BlockData)
"""
var_seq = tuple(
block.component_data_objects(
diff --git a/pyomo/solvers/plugins/solvers/mosek_persistent.py b/pyomo/solvers/plugins/solvers/mosek_persistent.py
index 97f88e0cb9a..efcbb7dd9dd 100644
--- a/pyomo/solvers/plugins/solvers/mosek_persistent.py
+++ b/pyomo/solvers/plugins/solvers/mosek_persistent.py
@@ -85,7 +85,7 @@ def add_constraints(self, con_seq):
Parameters
----------
- con_seq: tuple/list of Constraint (scalar Constraint or single _ConstraintData)
+ con_seq: tuple/list of Constraint (scalar Constraint or single ConstraintData)
"""
self._add_constraints(con_seq)
@@ -95,7 +95,7 @@ def remove_var(self, solver_var):
This will keep any other model components intact.
Parameters
----------
- solver_var: Var (scalar Var or single _VarData)
+ solver_var: Var (scalar Var or single VarData)
"""
self.remove_vars(solver_var)
@@ -106,7 +106,7 @@ def remove_vars(self, *solver_vars):
This will keep any other model components intact.
Parameters
----------
- *solver_var: Var (scalar Var or single _VarData)
+ *solver_var: Var (scalar Var or single VarData)
"""
try:
var_ids = []
@@ -137,7 +137,7 @@ def remove_constraint(self, solver_con):
To remove a conic-domain, you should use the remove_block method.
Parameters
----------
- solver_con: Constraint (scalar Constraint or single _ConstraintData)
+ solver_con: Constraint (scalar Constraint or single ConstraintData)
"""
self.remove_constraints(solver_con)
@@ -151,7 +151,7 @@ def remove_constraints(self, *solver_cons):
Parameters
----------
- *solver_cons: Constraint (scalar Constraint or single _ConstraintData)
+ *solver_cons: Constraint (scalar Constraint or single ConstraintData)
"""
lq_cons = tuple(
itertools.filterfalse(lambda x: isinstance(x, _ConicBase), solver_cons)
@@ -205,7 +205,7 @@ def update_vars(self, *solver_vars):
changing variable types and bounds.
Parameters
----------
- *solver_var: Constraint (scalar Constraint or single _ConstraintData)
+ *solver_var: Constraint (scalar Constraint or single ConstraintData)
"""
try:
var_ids = []
diff --git a/pyomo/solvers/plugins/solvers/persistent_solver.py b/pyomo/solvers/plugins/solvers/persistent_solver.py
index 29aa3f2bbf5..3c2a9e52eab 100644
--- a/pyomo/solvers/plugins/solvers/persistent_solver.py
+++ b/pyomo/solvers/plugins/solvers/persistent_solver.py
@@ -12,7 +12,7 @@
from pyomo.solvers.plugins.solvers.direct_or_persistent_solver import (
DirectOrPersistentSolver,
)
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.core.kernel.block import IBlock
from pyomo.core.base.suffix import active_import_suffix_generator
from pyomo.core.kernel.suffix import import_suffix_generator
@@ -96,7 +96,7 @@ def add_block(self, block):
Parameters
----------
- block: Block (scalar Block or single _BlockData)
+ block: Block (scalar Block or single BlockData)
"""
if self._pyomo_model is None:
@@ -132,7 +132,7 @@ def add_constraint(self, con):
Parameters
----------
- con: Constraint (scalar Constraint or single _ConstraintData)
+ con: Constraint (scalar Constraint or single ConstraintData)
"""
if self._pyomo_model is None:
@@ -206,9 +206,9 @@ def add_column(self, model, var, obj_coef, constraints, coefficients):
Parameters
----------
model: pyomo ConcreteModel to which the column will be added
- var: Var (scalar Var or single _VarData)
+ var: Var (scalar Var or single VarData)
obj_coef: float, pyo.Param
- constraints: list of scalar Constraints of single _ConstraintDatas
+ constraints: list of scalar Constraints of single ConstraintDatas
coefficients: list of the coefficient to put on var in the associated constraint
"""
@@ -295,7 +295,7 @@ def remove_block(self, block):
Parameters
----------
- block: Block (scalar Block or a single _BlockData)
+ block: Block (scalar Block or a single BlockData)
"""
# see PR #366 for discussion about handling indexed
@@ -328,7 +328,7 @@ def remove_constraint(self, con):
Parameters
----------
- con: Constraint (scalar Constraint or single _ConstraintData)
+ con: Constraint (scalar Constraint or single ConstraintData)
"""
# see PR #366 for discussion about handling indexed
@@ -380,7 +380,7 @@ def remove_var(self, var):
Parameters
----------
- var: Var (scalar Var or single _VarData)
+ var: Var (scalar Var or single VarData)
"""
# see PR #366 for discussion about handling indexed
@@ -455,7 +455,7 @@ def solve(self, *args, **kwds):
self.available(exception_flag=True)
# Collect suffix names to try and import from solution.
- if isinstance(self._pyomo_model, _BlockData):
+ if isinstance(self._pyomo_model, BlockData):
model_suffixes = list(
name
for (name, comp) in active_import_suffix_generator(self._pyomo_model)
diff --git a/pyomo/solvers/plugins/solvers/xpress_direct.py b/pyomo/solvers/plugins/solvers/xpress_direct.py
index 75cf8f921df..c62f76d85ce 100644
--- a/pyomo/solvers/plugins/solvers/xpress_direct.py
+++ b/pyomo/solvers/plugins/solvers/xpress_direct.py
@@ -667,9 +667,8 @@ def _add_constraint(self, con):
if not con.active:
return None
- if is_fixed(con.body):
- if self._skip_trivial_constraints:
- return None
+ if self._skip_trivial_constraints and is_fixed(con.body):
+ return None
conname = self._symbol_map.getSymbol(con, self._labeler)
diff --git a/pyomo/solvers/plugins/solvers/xpress_persistent.py b/pyomo/solvers/plugins/solvers/xpress_persistent.py
index 513a7fbc257..fbdc2866dcf 100644
--- a/pyomo/solvers/plugins/solvers/xpress_persistent.py
+++ b/pyomo/solvers/plugins/solvers/xpress_persistent.py
@@ -90,7 +90,7 @@ def update_var(self, var):
Parameters
----------
- var: Var (scalar Var or single _VarData)
+ var: Var (scalar Var or single VarData)
"""
# see PR #366 for discussion about handling indexed
@@ -124,7 +124,7 @@ def _add_column(self, var, obj_coef, constraints, coefficients):
Parameters
----------
- var: Var (scalar Var or single _VarData)
+ var: Var (scalar Var or single VarData)
obj_coef: float
constraints: list of solver constraints
coefficients: list of coefficients to put on var in the associated constraint
diff --git a/pyomo/solvers/tests/checks/test_CBCplugin.py b/pyomo/solvers/tests/checks/test_CBCplugin.py
index 2ea0e55c5f4..ad8846509ea 100644
--- a/pyomo/solvers/tests/checks/test_CBCplugin.py
+++ b/pyomo/solvers/tests/checks/test_CBCplugin.py
@@ -29,7 +29,7 @@
maximize,
minimize,
)
-from pyomo.opt import SolverFactory, ProblemSense, TerminationCondition, SolverStatus
+from pyomo.opt import SolverFactory, TerminationCondition, SolverStatus
from pyomo.solvers.plugins.solvers.CBCplugin import CBCSHELL
cbc_available = SolverFactory('cbc', solver_io='lp').available(exception_flag=False)
@@ -62,7 +62,7 @@ def test_infeasible_lp(self):
results = self.opt.solve(self.model)
- self.assertEqual(ProblemSense.minimize, results.problem.sense)
+ self.assertEqual(minimize, results.problem.sense)
self.assertEqual(
TerminationCondition.infeasible, results.solver.termination_condition
)
@@ -81,7 +81,7 @@ def test_unbounded_lp(self):
results = self.opt.solve(self.model)
- self.assertEqual(ProblemSense.maximize, results.problem.sense)
+ self.assertEqual(maximize, results.problem.sense)
self.assertEqual(
TerminationCondition.unbounded, results.solver.termination_condition
)
@@ -99,7 +99,7 @@ def test_optimal_lp(self):
self.assertEqual(0.0, results.problem.lower_bound)
self.assertEqual(0.0, results.problem.upper_bound)
- self.assertEqual(ProblemSense.minimize, results.problem.sense)
+ self.assertEqual(minimize, results.problem.sense)
self.assertEqual(
TerminationCondition.optimal, results.solver.termination_condition
)
@@ -118,7 +118,7 @@ def test_infeasible_mip(self):
results = self.opt.solve(self.model)
- self.assertEqual(ProblemSense.minimize, results.problem.sense)
+ self.assertEqual(minimize, results.problem.sense)
self.assertEqual(
TerminationCondition.infeasible, results.solver.termination_condition
)
@@ -134,7 +134,7 @@ def test_unbounded_mip(self):
results = self.opt.solve(self.model)
- self.assertEqual(ProblemSense.minimize, results.problem.sense)
+ self.assertEqual(minimize, results.problem.sense)
self.assertEqual(
TerminationCondition.unbounded, results.solver.termination_condition
)
@@ -159,7 +159,7 @@ def test_optimal_mip(self):
self.assertEqual(1.0, results.problem.upper_bound)
self.assertEqual(results.problem.number_of_binary_variables, 2)
self.assertEqual(results.problem.number_of_integer_variables, 4)
- self.assertEqual(ProblemSense.maximize, results.problem.sense)
+ self.assertEqual(maximize, results.problem.sense)
self.assertEqual(
TerminationCondition.optimal, results.solver.termination_condition
)
diff --git a/pyomo/solvers/tests/checks/test_CPLEXPersistent.py b/pyomo/solvers/tests/checks/test_CPLEXPersistent.py
index 91a60eee9dd..442212d4fbb 100644
--- a/pyomo/solvers/tests/checks/test_CPLEXPersistent.py
+++ b/pyomo/solvers/tests/checks/test_CPLEXPersistent.py
@@ -101,7 +101,7 @@ def test_add_column_exceptions(self):
# add indexed constraint
self.assertRaises(AttributeError, opt.add_column, m, m.y, -2, [m.ci], [1])
- # add something not a _ConstraintData
+ # add something not a ConstraintData
self.assertRaises(AttributeError, opt.add_column, m, m.y, -2, [m.x], [1])
# constraint not on solver model
diff --git a/pyomo/solvers/tests/checks/test_amplfunc_merge.py b/pyomo/solvers/tests/checks/test_amplfunc_merge.py
new file mode 100644
index 00000000000..2c819404d2f
--- /dev/null
+++ b/pyomo/solvers/tests/checks/test_amplfunc_merge.py
@@ -0,0 +1,162 @@
+# ___________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2008-2024
+# 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 pyomo.common.unittest as unittest
+from pyomo.solvers.amplfunc_merge import amplfunc_string_merge, amplfunc_merge
+
+
+class TestAMPLFUNCStringMerge(unittest.TestCase):
+ def test_merge_no_dup(self):
+ s1 = "my/place/l1.so\nanother/place/l1.so"
+ s2 = "my/place/l2.so"
+ sm = amplfunc_string_merge(s1, s2)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 3)
+ # The order of lines should be maintained with the second string
+ # following the first
+ self.assertEqual(sm_list[0], "my/place/l1.so")
+ self.assertEqual(sm_list[1], "another/place/l1.so")
+ self.assertEqual(sm_list[2], "my/place/l2.so")
+
+ def test_merge_empty1(self):
+ s1 = ""
+ s2 = "my/place/l2.so"
+ sm = amplfunc_string_merge(s1, s2)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 1)
+ self.assertEqual(sm_list[0], "my/place/l2.so")
+
+ def test_merge_empty2(self):
+ s1 = "my/place/l2.so"
+ s2 = ""
+ sm = amplfunc_string_merge(s1, s2)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 1)
+ self.assertEqual(sm_list[0], "my/place/l2.so")
+
+ def test_merge_empty_both(self):
+ s1 = ""
+ s2 = ""
+ sm = amplfunc_string_merge(s1, s2)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 1)
+ self.assertEqual(sm_list[0], "")
+
+ def test_merge_bad_type(self):
+ self.assertRaises(AttributeError, amplfunc_string_merge, "", 3)
+ self.assertRaises(AttributeError, amplfunc_string_merge, 3, "")
+ self.assertRaises(AttributeError, amplfunc_string_merge, 3, 3)
+ self.assertRaises(AttributeError, amplfunc_string_merge, None, "")
+ self.assertRaises(AttributeError, amplfunc_string_merge, "", None)
+ self.assertRaises(AttributeError, amplfunc_string_merge, 2.3, "")
+ self.assertRaises(AttributeError, amplfunc_string_merge, "", 2.3)
+
+ def test_merge_duplicate1(self):
+ s1 = "my/place/l1.so\nanother/place/l1.so"
+ s2 = "my/place/l1.so\nanother/place/l1.so"
+ sm = amplfunc_string_merge(s1, s2)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 2)
+ # The order of lines should be maintained with the second string
+ # following the first
+ self.assertEqual(sm_list[0], "my/place/l1.so")
+ self.assertEqual(sm_list[1], "another/place/l1.so")
+
+ def test_merge_duplicate2(self):
+ s1 = "my/place/l1.so\nanother/place/l1.so"
+ s2 = "my/place/l1.so"
+ sm = amplfunc_string_merge(s1, s2)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 2)
+ # The order of lines should be maintained with the second string
+ # following the first
+ self.assertEqual(sm_list[0], "my/place/l1.so")
+ self.assertEqual(sm_list[1], "another/place/l1.so")
+
+ def test_merge_extra_linebreaks(self):
+ s1 = "\nmy/place/l1.so\nanother/place/l1.so\n"
+ s2 = "\nmy/place/l1.so\n\n"
+ sm = amplfunc_string_merge(s1, s2)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 2)
+ # The order of lines should be maintained with the second string
+ # following the first
+ self.assertEqual(sm_list[0], "my/place/l1.so")
+ self.assertEqual(sm_list[1], "another/place/l1.so")
+
+
+class TestAMPLFUNCMerge(unittest.TestCase):
+ def test_merge_no_dup(self):
+ env = {
+ "AMPLFUNC": "my/place/l1.so\nanother/place/l1.so",
+ "PYOMO_AMPLFUNC": "my/place/l2.so",
+ }
+ sm = amplfunc_merge(env)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 3)
+ self.assertEqual(sm_list[0], "my/place/l1.so")
+ self.assertEqual(sm_list[1], "another/place/l1.so")
+ self.assertEqual(sm_list[2], "my/place/l2.so")
+
+ def test_merge_empty1(self):
+ env = {"AMPLFUNC": "", "PYOMO_AMPLFUNC": "my/place/l2.so"}
+ sm = amplfunc_merge(env)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 1)
+ self.assertEqual(sm_list[0], "my/place/l2.so")
+
+ def test_merge_empty2(self):
+ env = {"AMPLFUNC": "my/place/l2.so", "PYOMO_AMPLFUNC": ""}
+ sm = amplfunc_merge(env)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 1)
+ self.assertEqual(sm_list[0], "my/place/l2.so")
+
+ def test_merge_empty_both(self):
+ env = {"AMPLFUNC": "", "PYOMO_AMPLFUNC": ""}
+ sm = amplfunc_merge(env)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 1)
+ self.assertEqual(sm_list[0], "")
+
+ def test_merge_duplicate1(self):
+ env = {
+ "AMPLFUNC": "my/place/l1.so\nanother/place/l1.so",
+ "PYOMO_AMPLFUNC": "my/place/l1.so\nanother/place/l1.so",
+ }
+ sm = amplfunc_merge(env)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 2)
+ self.assertEqual(sm_list[0], "my/place/l1.so")
+ self.assertEqual(sm_list[1], "another/place/l1.so")
+
+ def test_merge_no_pyomo(self):
+ env = {"AMPLFUNC": "my/place/l1.so\nanother/place/l1.so"}
+ sm = amplfunc_merge(env)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 2)
+ self.assertEqual(sm_list[0], "my/place/l1.so")
+ self.assertEqual(sm_list[1], "another/place/l1.so")
+
+ def test_merge_no_user(self):
+ env = {"PYOMO_AMPLFUNC": "my/place/l1.so\nanother/place/l1.so"}
+ sm = amplfunc_merge(env)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 2)
+ self.assertEqual(sm_list[0], "my/place/l1.so")
+ self.assertEqual(sm_list[1], "another/place/l1.so")
+
+ def test_merge_nothing(self):
+ env = {}
+ sm = amplfunc_merge(env)
+ sm_list = sm.split("\n")
+ self.assertEqual(len(sm_list), 1)
+ self.assertEqual(sm_list[0], "")
diff --git a/pyomo/solvers/tests/checks/test_gurobi_persistent.py b/pyomo/solvers/tests/checks/test_gurobi_persistent.py
index a2c089207e5..812390c23a4 100644
--- a/pyomo/solvers/tests/checks/test_gurobi_persistent.py
+++ b/pyomo/solvers/tests/checks/test_gurobi_persistent.py
@@ -382,7 +382,7 @@ def test_add_column_exceptions(self):
# add indexed constraint
self.assertRaises(AttributeError, opt.add_column, m, m.y, -2, [m.ci], [1])
- # add something not a _ConstraintData
+ # add something not a ConstraintData
self.assertRaises(AttributeError, opt.add_column, m, m.y, -2, [m.x], [1])
# constraint not on solver model
diff --git a/pyomo/solvers/tests/checks/test_xpress_persistent.py b/pyomo/solvers/tests/checks/test_xpress_persistent.py
index ddae860cd92..dcd36780f62 100644
--- a/pyomo/solvers/tests/checks/test_xpress_persistent.py
+++ b/pyomo/solvers/tests/checks/test_xpress_persistent.py
@@ -262,7 +262,7 @@ def test_add_column_exceptions(self):
# add indexed constraint
self.assertRaises(AttributeError, opt.add_column, m, m.y, -2, [m.ci], [1])
- # add something not a _ConstraintData
+ # add something not a ConstraintData
self.assertRaises(AttributeError, opt.add_column, m, m.y, -2, [m.x], [1])
# constraint not on solver model
diff --git a/pyomo/solvers/tests/mip/test_scip.py b/pyomo/solvers/tests/mip/test_scip.py
index 01de0d16826..ad54daeddc0 100644
--- a/pyomo/solvers/tests/mip/test_scip.py
+++ b/pyomo/solvers/tests/mip/test_scip.py
@@ -106,6 +106,12 @@ def test_scip_solve_from_instance_options(self):
results.write(filename=_out, times=False, format='json')
self.compare_json(_out, join(currdir, "test_scip_solve_from_instance.baseline"))
+ def test_scip_solve_from_instance_with_reoptimization(self):
+ # Test scip with re-optimization option enabled
+ # This case changes the Scip output results which may break the results parser
+ self.scip.options['reoptimization/enable'] = True
+ self.test_scip_solve_from_instance()
+
if __name__ == "__main__":
deleteFiles = False
diff --git a/pyomo/solvers/tests/mip/test_scip_solve_from_instance.baseline b/pyomo/solvers/tests/mip/test_scip_solve_from_instance.baseline
index a3eb9ffacec..976e4a1b82e 100644
--- a/pyomo/solvers/tests/mip/test_scip_solve_from_instance.baseline
+++ b/pyomo/solvers/tests/mip/test_scip_solve_from_instance.baseline
@@ -1,7 +1,7 @@
{
"Problem": [
{
- "Lower bound": -Infinity,
+ "Lower bound": 1.0,
"Number of constraints": 0,
"Number of objectives": 1,
"Number of variables": 1,
diff --git a/pyomo/util/calc_var_value.py b/pyomo/util/calc_var_value.py
index b5e620fea07..42ee3119361 100644
--- a/pyomo/util/calc_var_value.py
+++ b/pyomo/util/calc_var_value.py
@@ -12,7 +12,7 @@
from pyomo.common.errors import IterationLimitError
from pyomo.common.numeric_types import native_numeric_types, native_complex_types, value
from pyomo.core.expr.calculus.derivatives import differentiate
-from pyomo.core.base.constraint import Constraint, _ConstraintData
+from pyomo.core.base.constraint import Constraint
import logging
@@ -53,9 +53,9 @@ def calculate_variable_from_constraint(
Parameters:
-----------
- variable: :py:class:`_VarData`
+ variable: :py:class:`VarData`
The variable to solve for
- constraint: :py:class:`_ConstraintData` or relational expression or `tuple`
+ constraint: :py:class:`ConstraintData` or relational expression or `tuple`
The equality constraint to use to solve for the variable value.
May be a `ConstraintData` object or any valid argument for
``Constraint(expr=<>)`` (i.e., a relational expression or 2- or
@@ -81,10 +81,17 @@ def calculate_variable_from_constraint(
"""
# Leverage all the Constraint logic to process the incoming tuple/expression
- if not isinstance(constraint, _ConstraintData):
+ if not getattr(constraint, 'ctype', None) is Constraint:
constraint = Constraint(expr=constraint, name=type(constraint).__name__)
constraint.construct()
+ if constraint.is_indexed():
+ raise ValueError(
+ 'calculate_variable_from_constraint(): constraint must be a '
+ 'scalar constraint or a single ConstraintData. Received '
+ f'{constraint.__class__.__name__} ("{constraint.name}")'
+ )
+
body = constraint.body
lower = constraint.lb
upper = constraint.ub
diff --git a/pyomo/util/report_scaling.py b/pyomo/util/report_scaling.py
index 201319ea92a..02b3710c334 100644
--- a/pyomo/util/report_scaling.py
+++ b/pyomo/util/report_scaling.py
@@ -11,9 +11,9 @@
import pyomo.environ as pyo
import math
-from pyomo.core.base.block import _BlockData
+from pyomo.core.base.block import BlockData
from pyomo.common.collections import ComponentSet
-from pyomo.core.base.var import _GeneralVarData
+from pyomo.core.base.var import Var
from pyomo.contrib.fbbt.fbbt import compute_bounds_on_expr
from pyomo.core.expr.calculus.diff_with_pyomo import reverse_sd
import logging
@@ -42,7 +42,7 @@ def _print_var_set(var_set):
return s
-def _check_var_bounds(m: _BlockData, too_large: float):
+def _check_var_bounds(m: BlockData, too_large: float):
vars_without_bounds = ComponentSet()
vars_with_large_bounds = ComponentSet()
for v in m.component_data_objects(pyo.Var, descend_into=True):
@@ -73,7 +73,7 @@ def _check_coefficients(
):
ders = reverse_sd(expr)
for _v, _der in ders.items():
- if isinstance(_v, _GeneralVarData):
+ if getattr(_v, 'ctype', None) is Var:
if _v.is_fixed():
continue
der_lb, der_ub = compute_bounds_on_expr(_der)
@@ -90,7 +90,7 @@ def _check_coefficients(
def report_scaling(
- m: _BlockData, too_large: float = 5e4, too_small: float = 1e-6
+ m: BlockData, too_large: float = 5e4, too_small: float = 1e-6
) -> bool:
"""
This function logs potentially poorly scaled parts of the model.
@@ -107,7 +107,7 @@ def report_scaling(
Parameters
----------
- m: _BlockData
+ m: BlockData
The pyomo model or block
too_large: float
Values above too_large will generate a log entry
diff --git a/pyomo/util/slices.py b/pyomo/util/slices.py
index 53f6d364219..d85aa3fa926 100644
--- a/pyomo/util/slices.py
+++ b/pyomo/util/slices.py
@@ -98,7 +98,7 @@ def slice_component_along_sets(comp, sets, context=None):
sets: `pyomo.common.collections.ComponentSet`
Contains the sets to replace with slices
context: `pyomo.core.base.block.Block` or
- `pyomo.core.base.block._BlockData`
+ `pyomo.core.base.block.BlockData`
Block below which to search for sets
Returns:
diff --git a/pyomo/util/subsystems.py b/pyomo/util/subsystems.py
index 70a0af1b2a7..00c3b85ce47 100644
--- a/pyomo/util/subsystems.py
+++ b/pyomo/util/subsystems.py
@@ -14,21 +14,38 @@
from pyomo.core.expr.visitor import identify_variables
from pyomo.common.collections import ComponentSet, ComponentMap
from pyomo.common.modeling import unique_component_name
-
+from pyomo.util.vars_from_expressions import get_vars_from_components
from pyomo.core.base.constraint import Constraint
from pyomo.core.base.expression import Expression
+from pyomo.core.base.objective import Objective
from pyomo.core.base.external import ExternalFunction
from pyomo.core.expr.visitor import StreamBasedExpressionVisitor
from pyomo.core.expr.numeric_expr import ExternalFunctionExpression
-from pyomo.core.expr.numvalue import native_types
+from pyomo.core.expr.numvalue import native_types, NumericValue
class _ExternalFunctionVisitor(StreamBasedExpressionVisitor):
+ def __init__(self, descend_into_named_expressions=True):
+ super().__init__()
+ self._descend_into_named_expressions = descend_into_named_expressions
+ self.named_expressions = []
+
def initializeWalker(self, expr):
self._functions = []
self._seen = set()
return True, None
+ def beforeChild(self, parent, child, index):
+ if child.__class__ in native_types:
+ return False, None
+ elif (
+ not self._descend_into_named_expressions
+ and child.is_named_expression_type()
+ ):
+ self.named_expressions.append(child)
+ return False, None
+ return True, None
+
def exitNode(self, node, data):
if type(node) is ExternalFunctionExpression:
if id(node) not in self._seen:
@@ -38,17 +55,6 @@ def exitNode(self, node, data):
def finalizeResult(self, result):
return self._functions
- def enterNode(self, node):
- pass
-
- def acceptChildResult(self, node, data, child_result, child_idx):
- pass
-
- def acceptChildResult(self, node, data, child_result, child_idx):
- if child_result.__class__ in native_types:
- return False, None
- return child_result.is_expression_type(), None
-
def identify_external_functions(expr):
yield from _ExternalFunctionVisitor().walk_expression(expr)
@@ -56,8 +62,28 @@ def identify_external_functions(expr):
def add_local_external_functions(block):
ef_exprs = []
- for comp in block.component_data_objects((Constraint, Expression), active=True):
- ef_exprs.extend(identify_external_functions(comp.expr))
+ named_expressions = []
+ visitor = _ExternalFunctionVisitor(descend_into_named_expressions=False)
+ for comp in block.component_data_objects(
+ (Constraint, Expression, Objective), active=True
+ ):
+ ef_exprs.extend(visitor.walk_expression(comp.expr))
+ named_expr_set = ComponentSet(visitor.named_expressions)
+ # List of unique named expressions
+ named_expressions = list(named_expr_set)
+ while named_expressions:
+ expr = named_expressions.pop()
+ # Clear named expression cache so we don't re-check named expressions
+ # we've seen before.
+ visitor.named_expressions.clear()
+ ef_exprs.extend(visitor.walk_expression(expr))
+ # Only add to the stack named expressions that we have
+ # not encountered yet.
+ for local_expr in visitor.named_expressions:
+ if local_expr not in named_expr_set:
+ named_expressions.append(local_expr)
+ named_expr_set.add(local_expr)
+
unique_functions = []
fcn_set = set()
for expr in ef_exprs:
@@ -106,11 +132,9 @@ def create_subsystem_block(constraints, variables=None, include_fixed=False):
block.cons = Reference(constraints)
var_set = ComponentSet(variables)
input_vars = []
- for con in constraints:
- for var in identify_variables(con.expr, include_fixed=include_fixed):
- if var not in var_set:
- input_vars.append(var)
- var_set.add(var)
+ for var in get_vars_from_components(block, Constraint, include_fixed=include_fixed):
+ if var not in var_set:
+ input_vars.append(var)
block.input_vars = Reference(input_vars)
add_local_external_functions(block)
return block
@@ -148,7 +172,14 @@ class TemporarySubsystemManager(object):
"""
- def __init__(self, to_fix=None, to_deactivate=None, to_reset=None, to_unfix=None):
+ def __init__(
+ self,
+ to_fix=None,
+ to_deactivate=None,
+ to_reset=None,
+ to_unfix=None,
+ remove_bounds_on_fix=False,
+ ):
"""
Arguments
---------
@@ -168,6 +199,8 @@ def __init__(self, to_fix=None, to_deactivate=None, to_reset=None, to_unfix=None
List of var data objects to be temporarily unfixed. These are
restored to their original status on exit from this object's
context manager.
+ remove_bounds_on_fix: Bool
+ Whether bounds should be removed temporarily for fixed variables
"""
if to_fix is None:
@@ -194,6 +227,8 @@ def __init__(self, to_fix=None, to_deactivate=None, to_reset=None, to_unfix=None
self._con_was_active = None
self._comp_original_value = None
self._var_was_unfixed = None
+ self._remove_bounds_on_fix = remove_bounds_on_fix
+ self._fixed_var_bounds = None
def __enter__(self):
to_fix = self._vars_to_fix
@@ -203,8 +238,13 @@ def __enter__(self):
self._var_was_fixed = [(var, var.fixed) for var in to_fix + to_unfix]
self._con_was_active = [(con, con.active) for con in to_deactivate]
self._comp_original_value = [(comp, comp.value) for comp in to_set]
+ self._fixed_var_bounds = [(var.lb, var.ub) for var in to_fix]
for var in self._vars_to_fix:
+ if self._remove_bounds_on_fix:
+ # TODO: Potentially override var.domain as well?
+ var.setlb(None)
+ var.setub(None)
var.fix()
for con in self._cons_to_deactivate:
@@ -223,6 +263,11 @@ def __exit__(self, ex_type, ex_val, ex_bt):
var.fix()
else:
var.unfix()
+ if self._remove_bounds_on_fix:
+ for var, (lb, ub) in zip(self._vars_to_fix, self._fixed_var_bounds):
+ var.setlb(lb)
+ var.setub(ub)
+
for con, was_active in self._con_was_active:
if was_active:
con.activate()
diff --git a/pyomo/util/tests/test_calc_var_value.py b/pyomo/util/tests/test_calc_var_value.py
index a02d7a7d838..4bed4d5c843 100644
--- a/pyomo/util/tests/test_calc_var_value.py
+++ b/pyomo/util/tests/test_calc_var_value.py
@@ -101,6 +101,15 @@ def test_initialize_value(self):
):
calculate_variable_from_constraint(m.x, m.lt)
+ m.indexed = Constraint([1, 2], rule=lambda m, i: m.x <= i)
+ with self.assertRaisesRegex(
+ ValueError,
+ r"calculate_variable_from_constraint\(\): constraint must be a scalar "
+ r"constraint or a single ConstraintData. Received IndexedConstraint "
+ r'\("indexed"\)',
+ ):
+ calculate_variable_from_constraint(m.x, m.indexed)
+
def test_linear(self):
m = ConcreteModel()
m.x = Var()
diff --git a/pyomo/util/tests/test_subsystems.py b/pyomo/util/tests/test_subsystems.py
index 87a4fb3cf28..089888bd6a9 100644
--- a/pyomo/util/tests/test_subsystems.py
+++ b/pyomo/util/tests/test_subsystems.py
@@ -292,7 +292,7 @@ def test_generate_dont_fix_inputs_with_fixed_var(self):
self.assertFalse(m.v3.fixed)
self.assertTrue(m.v4.fixed)
- def _make_model_with_external_functions(self):
+ def _make_model_with_external_functions(self, named_expressions=False):
m = pyo.ConcreteModel()
gsl = find_GSL()
m.bessel = pyo.ExternalFunction(library=gsl, function="gsl_sf_bessel_J0")
@@ -300,9 +300,21 @@ def _make_model_with_external_functions(self):
m.v1 = pyo.Var(initialize=1.0)
m.v2 = pyo.Var(initialize=2.0)
m.v3 = pyo.Var(initialize=3.0)
+ if named_expressions:
+ m.subexpr = pyo.Expression(pyo.PositiveIntegers)
+ m.subexpr[1] = 2 * m.fermi(m.v1)
+ m.subexpr[2] = m.bessel(m.v1) - m.bessel(m.v2)
+ m.subexpr[3] = m.subexpr[2] + m.v3**2
+ subexpr1 = m.subexpr[1]
+ subexpr2 = m.subexpr[2]
+ subexpr3 = m.subexpr[3]
+ else:
+ subexpr1 = 2 * m.fermi(m.v1)
+ subexpr2 = m.bessel(m.v1) - m.bessel(m.v2)
+ subexpr3 = subexpr2 + m.v3**2
m.con1 = pyo.Constraint(expr=m.v1 == 0.5)
- m.con2 = pyo.Constraint(expr=2 * m.fermi(m.v1) + m.v2**2 - m.v3 == 1.0)
- m.con3 = pyo.Constraint(expr=m.bessel(m.v1) - m.bessel(m.v2) + m.v3**2 == 2.0)
+ m.con2 = pyo.Constraint(expr=subexpr1 + m.v2**2 - m.v3 == 1.0)
+ m.con3 = pyo.Constraint(expr=subexpr3 == 2.0)
return m
@unittest.skipUnless(find_GSL(), "Could not find the AMPL GSL library")
@@ -329,6 +341,15 @@ def test_identify_external_functions(self):
pred_fcn_data = {(gsl, "gsl_sf_bessel_J0"), (gsl, "gsl_sf_fermi_dirac_m1")}
self.assertEqual(fcn_data, pred_fcn_data)
+ @unittest.skipUnless(find_GSL(), "Could not find the AMPL GSL library")
+ def test_local_external_functions_with_named_expressions(self):
+ m = self._make_model_with_external_functions(named_expressions=True)
+ variables = list(m.component_data_objects(pyo.Var))
+ constraints = list(m.component_data_objects(pyo.Constraint, active=True))
+ b = create_subsystem_block(constraints, variables)
+ self.assertTrue(isinstance(b._gsl_sf_bessel_J0, pyo.ExternalFunction))
+ self.assertTrue(isinstance(b._gsl_sf_fermi_dirac_m1, pyo.ExternalFunction))
+
def _solve_ef_model_with_ipopt(self):
m = self._make_model_with_external_functions()
ipopt = pyo.SolverFactory("ipopt")
@@ -362,6 +383,33 @@ def test_with_external_function(self):
self.assertAlmostEqual(m.v2.value, m_full.v2.value)
self.assertAlmostEqual(m.v3.value, m_full.v3.value)
+ @unittest.skipUnless(find_GSL(), "Could not find the AMPL GSL library")
+ @unittest.skipUnless(
+ pyo.SolverFactory("ipopt").available(), "ipopt is not available"
+ )
+ def test_with_external_function_in_named_expression(self):
+ m = self._make_model_with_external_functions(named_expressions=True)
+ subsystem = ([m.con2, m.con3], [m.v2, m.v3])
+
+ m.v1.set_value(0.5)
+ block = create_subsystem_block(*subsystem)
+ ipopt = pyo.SolverFactory("ipopt")
+ with TemporarySubsystemManager(to_fix=list(block.input_vars.values())):
+ ipopt.solve(block)
+
+ # Correct values obtained by solving with Ipopt directly
+ # in another script.
+ self.assertEqual(m.v1.value, 0.5)
+ self.assertFalse(m.v1.fixed)
+ self.assertAlmostEqual(m.v2.value, 1.04816, delta=1e-5)
+ self.assertAlmostEqual(m.v3.value, 1.34356, delta=1e-5)
+
+ # Result obtained by solving the full system
+ m_full = self._solve_ef_model_with_ipopt()
+ self.assertAlmostEqual(m.v1.value, m_full.v1.value)
+ self.assertAlmostEqual(m.v2.value, m_full.v2.value)
+ self.assertAlmostEqual(m.v3.value, m_full.v3.value)
+
@unittest.skipUnless(find_GSL(), "Could not find the AMPL GSL library")
def test_external_function_with_potential_name_collision(self):
m = self._make_model_with_external_functions()
diff --git a/pyomo/util/vars_from_expressions.py b/pyomo/util/vars_from_expressions.py
index f9b3f1ab8ae..878a1a13b58 100644
--- a/pyomo/util/vars_from_expressions.py
+++ b/pyomo/util/vars_from_expressions.py
@@ -43,6 +43,7 @@ def get_vars_from_components(
descent_order: Traversal strategy for finding the objects of type ctype
"""
seen = set()
+ named_expression_cache = {}
for constraint in block.component_data_objects(
ctype,
active=active,
@@ -51,7 +52,9 @@ def get_vars_from_components(
descent_order=descent_order,
):
for var in EXPR.identify_variables(
- constraint.expr, include_fixed=include_fixed
+ constraint.expr,
+ include_fixed=include_fixed,
+ named_expression_cache=named_expression_cache,
):
if id(var) not in seen:
seen.add(id(var))
diff --git a/pyomo/version/info.py b/pyomo/version/info.py
index 0db00ac240f..825483a70a0 100644
--- a/pyomo/version/info.py
+++ b/pyomo/version/info.py
@@ -26,7 +26,7 @@
# main and needs a hard reference to "suitably new" development.
major = 6
minor = 7
-micro = 1
+micro = 4
releaselevel = 'invalid'
# releaselevel = 'final'
serial = 0
diff --git a/setup.cfg b/setup.cfg
index b606138f38c..f670cef8f68 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -22,3 +22,4 @@ markers =
lp: marks lp tests
gams: marks gams tests
bar: marks bar tests
+ builders: tests that should be run when testing custom (extension) builders
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 0bbcb6a8390..6d28e4d184b 100644
--- a/setup.py
+++ b/setup.py
@@ -253,6 +253,9 @@ def __ne__(self, other):
'sphinx_rtd_theme>0.5',
'sphinxcontrib-jsmath',
'sphinxcontrib-napoleon',
+ 'sphinx-toolbox>=2.16.0',
+ 'sphinx-jinja2-compat>=0.1.1',
+ 'enum_tools',
'numpy', # Needed by autodoc for pynumero
'scipy', # Needed by autodoc for pynumero
],
@@ -261,7 +264,9 @@ def __ne__(self, other):
'ipython', # contrib.viewer
# Note: matplotlib 3.6.1 has bug #24127, which breaks
# seaborn's histplot (triggering parmest failures)
- 'matplotlib!=3.6.1',
+ # Note: minimum version from community_detection use of
+ # matplotlib.pyplot.get_cmap()
+ 'matplotlib>=3.6.0,!=3.6.1',
# network, incidence_analysis, community_detection
# Note: networkx 3.2 is Python>-3.9, but there is a broken
# 3.2 package on conda-forge that will get implicitly
@@ -303,6 +308,7 @@ def __ne__(self, other):
"pyomo.contrib.mcpp": ["*.cpp"],
"pyomo.contrib.pynumero": ['src/*', 'src/tests/*'],
"pyomo.contrib.viewer": ["*.ui"],
+ "pyomo.contrib.simplification.ginac": ["src/*.cpp", "src/*.hpp"],
},
ext_modules=ext_modules,
entry_points="""