GDPopt logicbased solver
The GDPopt solver in Pyomo allows users to solve nonlinear Generalized Disjunctive Programming (GDP) models using logicbased decomposition approaches, as opposed to the conventional approach via reformulation to a Mixed Integer Nonlinear Programming (MINLP) model.
The main advantage of these techniques is their ability to solve subproblems
in a reduced space, including nonlinear constraints only for True
logical blocks.
As a result, GDPopt is most effective for nonlinear GDP models.
Three algorithms are available in GDPopt:
 Logicbased outer approximation (LOA) [Turkay & Grossmann, 1996]
 Global logicbased outer approximation (GLOA) [Lee & Grossmann, 2001]
 Logicbased branchandbound (LBB) [Lee & Grossmann, 2001]
Usage and implementation details for GDPopt can be found in the PSE 2018 paper (Chen et al., 2018), or via its preprint.
Credit for prototyping and development can be found in the GDPopt
class documentation, below.
GDPopt can be used to solve a Pyomo.GDP concrete model in two ways.
The simplest is to instantiate the generic GDPopt solver and specify the desired algorithm as an argument to the solve
method:
>>> SolverFactory('gdpopt').solve(model, algorithm='LOA')
The alternative is to instantiate an algorithmspecific GDPopt solver:
>>> SolverFactory('gdpopt.loa').solve(model)
In the above examples, GDPopt uses the GDPoptLOA algorithm.
Other algorithms may be used by specifying them in the algorithm
argument when using the generic solver or by instantiating the algorithmspecific GDPopt solvers. All GDPopt options are listed below.
Note
The generic GDPopt solver allows minimal configuration outside of the arguments to the solve
method. To avoid repeatedly specifying the same configuration options to the solve
method, use the algorithmspecific solvers.
Logicbased Outer Approximation (LOA)
Chen et al., 2018 contains the following flowchart, taken from the preprint version:
An example that includes the modeling approach may be found below.
Required imports
>>> from pyomo.environ import *
>>> from pyomo.gdp import *
Create a simple model
>>> model = ConcreteModel(name='LOA example')
>>> model.x = Var(bounds=(1.2, 2))
>>> model.y = Var(bounds=(10,10))
>>> model.c = Constraint(expr= model.x + model.y == 1)
>>> model.fix_x = Disjunct()
>>> model.fix_x.c = Constraint(expr=model.x == 0)
>>> model.fix_y = Disjunct()
>>> model.fix_y.c = Constraint(expr=model.y == 0)
>>> model.d = Disjunction(expr=[model.fix_x, model.fix_y])
>>> model.objective = Objective(expr=model.x + 0.1*model.y, sense=minimize)
Solve the model using GDPopt
>>> results = SolverFactory('gdpopt.loa').solve(
... model, mip_solver='glpk')
Display the final solution
>>> model.display()
Model LOA example
Variables:
x : Size=1, Index=None
Key : Lower : Value : Upper : Fixed : Stale : Domain
None : 1.2 : 0.0 : 2 : False : False : Reals
y : Size=1, Index=None
Key : Lower : Value : Upper : Fixed : Stale : Domain
None : 10 : 1.0 : 10 : False : False : Reals
Objectives:
objective : Size=1, Index=None, Active=True
Key : Active : Value
None : True : 0.1
Constraints:
c : Size=1
Key : Lower : Body : Upper
None : 1.0 : 1.0 : 1.0
Note
When troubleshooting, it can often be helpful to turn on verbose
output using the tee
flag.
>>> SolverFactory('gdpopt.loa').solve(model, tee=True)
Global Logicbased Outer Approximation (GLOA)
The same algorithm can be used to solve GDPs involving nonconvex nonlinear constraints by solving the subproblems globally:
>>> SolverFactory('gdpopt.gloa').solve(model)
Warning
The nlp_solver
option must be set to a global solver for the solution returned by GDPopt to also be globally optimal.
Relaxation with Integer Cuts (RIC)
Instead of outer approximation, GDPs can be solved using the same MILP relaxation as in the previous two algorithms, but instead of using the subproblems to generate outerapproximation cuts, the algorithm adds only nogood cuts for every discrete solution encountered:
>>> SolverFactory('gdpopt.ric').solve(model)
Again, this is a global algorithm if the subproblems are solved globally, and is not otherwise.
Note
The RIC algorithm will not necessarily enumerate all discrete solutions as it is possible for the bounds to converge first. However, full enumeration is not uncommon.
Logicbased BranchandBound (LBB)
The GDPoptLBB solver branches through relaxed subproblems with inactive disjunctions. It explores the possibilities based on best lower bound, eventually activating all disjunctions and presenting the globally optimal solution.
To use the GDPoptLBB solver, define your Pyomo GDP model as usual:
Required imports
>>> from pyomo.environ import *
>>> from pyomo.gdp import Disjunct, Disjunction
Create a simple model
>>> m = ConcreteModel()
>>> m.x1 = Var(bounds = (0,8))
>>> m.x2 = Var(bounds = (0,8))
>>> m.obj = Objective(expr=m.x1 + m.x2, sense=minimize)
>>> m.y1 = Disjunct()
>>> m.y2 = Disjunct()
>>> m.y1.c1 = Constraint(expr=m.x1 >= 2)
>>> m.y1.c2 = Constraint(expr=m.x2 >= 2)
>>> m.y2.c1 = Constraint(expr=m.x1 >= 3)
>>> m.y2.c2 = Constraint(expr=m.x2 >= 3)
>>> m.djn = Disjunction(expr=[m.y1, m.y2])
Invoke the GDPoptLBB solver
>>> results = SolverFactory('gdpopt.lbb').solve(m)
>>> print(results)
>>> print(results.solver.status)
ok
>>> print(results.solver.termination_condition)
optimal
>>> print([value(m.y1.indicator_var), value(m.y2.indicator_var)])
[True, False]
GDPopt implementation and optional arguments
Warning
GDPopt optional arguments should be considered beta code and are subject to change.

class
pyomo.contrib.gdpopt.GDPopt.
GDPoptSolver
[source] Decomposition solver for Generalized Disjunctive Programming (GDP) problems.
The GDPopt (Generalized Disjunctive Programming optimizer) solver applies a variety of decompositionbased approaches to solve Generalized Disjunctive Programming (GDP) problems. GDP models can include nonlinear, continuous variables and constraints, as well as logical conditions.
These approaches include:
 Logicbased outer approximation (LOA)
 Logicbased branchandbound (LBB)
 Partial surrogate cuts [pending]
 Generalized Bender decomposition [pending]
This solver implementation was developed by Carnegie Mellon University in the research group of Ignacio Grossmann.
For nonconvex problems, LOA may not report rigorous lower/upper bounds.
Questions: Please make a post at StackOverflow and/or contact Qi Chen <https://github.com/qtothec> or David Bernal <https://github.com/bernalde>.
Several key GDPopt components were prototyped by BS and MS students:
 Logicbased branch and bound: Sunjeev Kale
 MC++ interface: Johnny Bates
 LOA setcovering initialization: Eloy Fernandez
 Logictolinear transformation: Romeo Valentin

available
(exception_flag=True)[source] Solver is always available. Though subsolvers may not be, they will raise an error when the time comes.

solve
(model, **kwds)[source] Solve the model.
Parameters: model (Block) – a Pyomo model or block to be solved
Keyword Arguments:  iterlim – Iteration limit.
 time_limit – Seconds allowed until terminated. Note that the time limit can currently only be enforced between subsolver invocations. You may need to set subsolver time limits as well.
 tee – Stream output to terminal.
 logger – The logger object or name to use for reporting.

class
pyomo.contrib.gdpopt.loa.
GDP_LOA_Solver
(**kwds)[source] The GDPopt (Generalized Disjunctive Programming optimizer) logicbased outer approximation (LOA) solver.
Accepts models that can include nonlinear, continuous variables and constraints, as well as logical conditions. For nonconvex problems, LOA may not report rigorous dual bounds.

class
pyomo.contrib.gdpopt.gloa.
GDP_GLOA_Solver
(**kwds)[source] The GDPopt (Generalized Disjunctive Programming optimizer) global logicbased outer approximation (GLOA) solver.
Accepts models that can include nonlinear, continuous variables and constraints, as well as logical conditions.

class
pyomo.contrib.gdpopt.ric.
GDP_RIC_Solver
(**kwds)[source] The GDPopt (Generalized Disjunctive Programming optimizer) relaxation with integer cuts (RIC) solver.
Accepts models that can include nonlinear, continuous variables and constraints, as well as logical conditions. For nonconvex problems, RIC will not be exact unless the NLP subproblems are solved globally.