def _load_slacks(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'slack'):
self._pyomo_model.slack = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
reverse_con_map = self._solver_con_to_pyomo_con_map
slack = self._pyomo_model.slack
msk = self._mosek
if cons_to_load is None:
mosek_cons_to_load = range(self._solver_model.getnumcon())
else:
mosek_cons_to_load = set(
[con_map[pyomo_con] for pyomo_con in cons_to_load])
Ax = [0] * len(mosek_cons_to_load)
self._solver_model.getxc(self._whichsol, Ax)
for con in mosek_cons_to_load:
pyomo_con = reverse_con_map[con]
Us = Ls = 0
bk, lb, ub = self._solver_model.getconbound(con)
if bk in [msk.boundkey.fx, msk.boundkey.ra, msk.boundkey.up]:
Us = ub - Ax[con]
if bk in [msk.boundkey.fx, msk.boundkey.ra, msk.boundkey.lo]:
Ls = Ax[con] - lb
if Us > Ls:
slack[pyomo_con] = Us
else:
slack[pyomo_con] = -Ls
def _load_duals(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'dual'):
self._pyomo_model.dual = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
reverse_con_map = self._solver_con_to_pyomo_con_map
dual = self._pyomo_model.dual
if cons_to_load is None:
linear_cons_to_load = self._solver_model.getConstrs()
if self._version_major >= 5:
quadratic_cons_to_load = self._solver_model.getQConstrs()
else:
gurobi_cons_to_load = set(
[con_map[pyomo_con] for pyomo_con in cons_to_load])
linear_cons_to_load = gurobi_cons_to_load.intersection(
set(self._solver_model.getConstrs()))
if self._version_major >= 5:
quadratic_cons_to_load = gurobi_cons_to_load.intersection(
set(self._solver_model.getQConstrs()))
linear_vals = self._solver_model.getAttr("Pi", linear_cons_to_load)
if self._version_major >= 5:
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[gurobi_con]
dual[pyomo_con] = val
if self._version_major >= 5:
for gurobi_con, val in zip(quadratic_cons_to_load, quadratic_vals):
pyomo_con = reverse_con_map[gurobi_con]
dual[pyomo_con] = val
def _load_slacks(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'slack'):
self._pyomo_model.slack = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
slack = self._pyomo_model.slack
if cons_to_load is None:
cons_to_load = con_map.keys()
xpress_cons_to_load = [
con_map[pyomo_con] for pyomo_con in cons_to_load
]
vals = self._solver_model.getSlack(xpress_cons_to_load)
for pyomo_con, xpress_con, val in zip(cons_to_load,
xpress_cons_to_load, vals):
if xpress_con in self._range_constraints:
## for xpress, the slack on a range constraint
## is based on the upper bound
lb = con.lb
ub = con.ub
ub_s = val
expr_val = ub - ub_s
lb_s = lb - expr_val
if abs(ub_s) > abs(lb_s):
slack[pyomo_con] = ub_s
else:
slack[pyomo_con] = lb_s
else:
slack[pyomo_con] = val
def _apply_to(self, instance, tmp=False):
"""Apply the transformation.
Args:
instance (Block): the block on which to search for x == y
constraints. Note that variables may be located anywhere in
the model.
tmp (bool, optional): Whether the bound modifications will be
temporary
Returns:
None
"""
if tmp and not hasattr(instance, '_tmp_propagate_original_bounds'):
instance._tmp_propagate_original_bounds = Suffix(
direction=Suffix.LOCAL)
eq_var_map, relevant_vars = _build_equality_set(instance)
processed = ComponentSet()
# Go through each variable in an equality set to propagate the variable
# bounds to all equality-linked variables.
for var in relevant_vars:
# If we have already processed the variable, skip it.
if var in processed:
continue
var_equality_set = eq_var_map.get(var, ComponentSet([var]))
#: variable lower bounds in the equality set
lbs = [v.lb for v in var_equality_set if v.has_lb()]
max_lb = max(lbs) if len(lbs) > 0 else None
#: variable upper bounds in the equality set
ubs = [v.ub for v in var_equality_set if v.has_ub()]
min_ub = min(ubs) if len(ubs) > 0 else None
# Check for error due to bound cross-over
if max_lb is not None and min_ub is not None and max_lb > min_ub:
# the lower bound is above the upper bound. Raise a ValueError.
# get variable with the highest lower bound
v1 = next(v for v in var_equality_set if v.lb == max_lb)
# get variable with the lowest upper bound
v2 = next(v for v in var_equality_set if v.ub == min_ub)
raise ValueError(
'Variable {} has a lower bound {} '
' > the upper bound {} of variable {}, '
'but they are linked by equality constraints.'
.format(v1.name, value(v1.lb), value(v2.ub), v2.name))
for v in var_equality_set:
if tmp:
# TODO warn if overwriting
instance._tmp_propagate_original_bounds[v] = (
v.lb, v.ub)
v.setlb(max_lb)
v.setub(min_ub)
processed.update(var_equality_set)
def suffix(self, name):
"""
Declare a suffix with the specified name. Suffixes are values
returned by the solver, which are typically associated constraints.
Parameters
__________
suffix : str
The suffix that is returned from the solver.
"""
setattr(self.model, name, Suffix(direction=Suffix.IMPORT))
def _load_rc(self, vars_to_load=None):
if not hasattr(self._pyomo_model, 'rc'):
self._pyomo_model.rc = Suffix(direction=Suffix.IMPORT)
var_map = self._pyomo_var_to_solver_var_map
ref_vars = self._referenced_variables
rc = self._pyomo_model.rc
if vars_to_load is None:
vars_to_load = var_map.keys()
for var in vars_to_load:
if ref_vars[var] > 0:
rc[var] = var_map[var].Rc
def _load_duals(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'dual'):
self._pyomo_model.dual = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
dual = self._pyomo_model.dual
if cons_to_load is None:
cons_to_load = con_map.keys()
xpress_cons_to_load = [con_map[pyomo_con] for pyomo_con in cons_to_load]
vals = self._solver_model.getDual(xpress_cons_to_load)
for pyomo_con, val in zip(cons_to_load, vals):
dual[pyomo_con] = val
def _load_duals(self, objs_to_load=None):
if not hasattr(self._pyomo_model, 'dual'):
self._pyomo_model.dual = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
reverse_con_map = self._solver_con_to_pyomo_con_map
cone_map = self._pyomo_cone_to_solver_cone_map
#reverse_cone_map = self._solver_cone_to_pyomo_cone_map
dual = self._pyomo_model.dual
if objs_to_load is None:
# constraints
mosek_cons_to_load = range(self._solver_model.getnumcon())
vals = [0.0]*len(mosek_cons_to_load)
self._solver_model.gety(self._whichsol, vals)
for mosek_con, val in zip(mosek_cons_to_load, vals):
pyomo_con = reverse_con_map[mosek_con]
dual[pyomo_con] = val
"""TODO wrong length, needs to be getnumvars()
# cones
mosek_cones_to_load = range(self._solver_model.getnumcone())
vals = [0.0]*len(mosek_cones_to_load)
self._solver_model.getsnx(self._whichsol, vals)
for mosek_cone, val in zip(mosek_cones_to_load, vals):
pyomo_cone = reverse_cone_map[mosek_cone]
dual[pyomo_cone] = val
"""
else:
mosek_cons_to_load = []
mosek_cones_to_load = []
for obj in objs_to_load:
if obj in con_map:
mosek_cons_to_load.append(con_map[obj])
else:
# assume it is a cone
mosek_cones_to_load.append(cone_map[obj])
# constraints
mosek_cons_first = min(mosek_cons_to_load)
mosek_cons_last = max(mosek_cons_to_load)
vals = [0.0]*(mosek_cons_last - mosek_cons_first + 1)
self._solver_model.getyslice(self._whichsol,
mosek_cons_first,
mosek_cons_last,
vals)
for mosek_con in mosek_cons_to_load:
slice_index = mosek_con - mosek_cons_first
val = vals[slice_index]
pyomo_con = reverse_con_map[mosek_con]
dual[pyomo_con] = val
"""TODO wrong length, needs to be getnumvars()
def _load_rc(self, vars_to_load=None):
if not hasattr(self._pyomo_model, 'rc'):
self._pyomo_model.rc = Suffix(direction=Suffix.IMPORT)
var_map = self._pyomo_var_to_solver_var_map
ref_vars = self._referenced_variables
rc = self._pyomo_model.rc
if vars_to_load is None:
vars_to_load = var_map.keys()
gurobi_vars_to_load = [var_map[pyomo_var] for pyomo_var in vars_to_load]
vals = self._solver_model.getAttr("Rc", gurobi_vars_to_load)
for var, val in zip(vars_to_load, vals):
if ref_vars[var] > 0:
rc[var] = val
def _load_slacks(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'slack'):
self._pyomo_model.slack = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
reverse_con_map = self._solver_con_to_pyomo_con_map
slack = self._pyomo_model.slack
gurobi_range_con_vars = set(self._solver_model.getVars()) - set(
self._pyomo_var_to_solver_var_map.values())
if cons_to_load is None:
linear_cons_to_load = self._solver_model.getConstrs()
if self._version_major >= 5:
quadratic_cons_to_load = self._solver_model.getQConstrs()
else:
gurobi_cons_to_load = set(
[con_map[pyomo_con] for pyomo_con in cons_to_load])
linear_cons_to_load = gurobi_cons_to_load.intersection(
set(self._solver_model.getConstrs()))
if self._version_major >= 5:
quadratic_cons_to_load = gurobi_cons_to_load.intersection(
set(self._solver_model.getQConstrs()))
linear_vals = self._solver_model.getAttr("Slack", linear_cons_to_load)
if self._version_major >= 5:
quadratic_vals = self._solver_model.getAttr(
"QCSlack", quadratic_cons_to_load)
for gurobi_con, val in zip(linear_cons_to_load, linear_vals):
pyomo_con = reverse_con_map[gurobi_con]
if pyomo_con in self._range_constraints:
lin_expr = self._solver_model.getRow(gurobi_con)
for i in reversed(range(lin_expr.size())):
v = lin_expr.getVar(i)
if v in gurobi_range_con_vars:
Us_ = v.X
Ls_ = v.UB - v.X
if Us_ > Ls_:
slack[pyomo_con] = Us_
else:
slack[pyomo_con] = -Ls_
break
else:
slack[pyomo_con] = val
if self._version_major >= 5:
for gurobi_con, val in zip(quadratic_cons_to_load, quadratic_vals):
pyomo_con = reverse_con_map[gurobi_con]
slack[pyomo_con] = val
def _load_rc(self, vars_to_load=None):
if not hasattr(self._pyomo_model, 'rc'):
self._pyomo_model.rc = Suffix(direction=Suffix.IMPORT)
var_map = self._pyomo_var_to_solver_var_map
ref_vars = self._referenced_variables
rc = self._pyomo_model.rc
if vars_to_load is None:
vars_to_load = var_map.keys()
mosek_vars_to_load = [var_map[pyomo_var] for pyomo_var in vars_to_load]
vals = [0.0] * len(mosek_vars_to_load)
self._solver_model.getreducedcosts(self._whichsol, 0,
len(mosek_vars_to_load), vals)
for var, val in zip(vars_to_load, vals):
if ref_vars[var] > 0:
rc[var] = val
def _load_UnbdRay(self, vars_to_load=None):
if not hasattr(self._pyomo_model, 'UnbdRay'):
self._pyomo_model.UnbdRay = Suffix(direction=Suffix.IMPORT)
var_map = self._pyomo_var_to_solver_var_map
ref_vars = self._referenced_variables
UnbdRay = self._pyomo_model.UnbdRay
if vars_to_load is None:
vars_to_load = var_map.keys()
gurobi_vars_to_load = [
var_map[pyomo_var] for pyomo_var in vars_to_load
]
vals = self._solver_model.getAttr("UnbdRay", gurobi_vars_to_load)
for var, val in zip(vars_to_load, vals):
if ref_vars[var] > 0:
UnbdRay[var] = val
def _apply_to(self, instance, **kwds):
config = self.CONFIG(kwds)
if config.tmp and not hasattr(instance, '_tmp_propagate_original_bounds'):
instance._tmp_propagate_original_bounds = Suffix(
direction=Suffix.LOCAL)
eq_var_map, relevant_vars = _build_equality_set(instance)
processed = ComponentSet()
# Go through each variable in an equality set to propagate the variable
# bounds to all equality-linked variables.
for var in relevant_vars:
# If we have already processed the variable, skip it.
if var in processed:
continue
var_equality_set = eq_var_map.get(var, ComponentSet([var]))
#: variable lower bounds in the equality set
lbs = [v.lb for v in var_equality_set if v.has_lb()]
max_lb = max(lbs) if len(lbs) > 0 else None
#: variable upper bounds in the equality set
ubs = [v.ub for v in var_equality_set if v.has_ub()]
min_ub = min(ubs) if len(ubs) > 0 else None
# Check for error due to bound cross-over
if max_lb is not None and min_ub is not None and max_lb > min_ub:
# the lower bound is above the upper bound. Raise an exception.
# get variable with the highest lower bound
v1 = next(v for v in var_equality_set if v.lb == max_lb)
# get variable with the lowest upper bound
v2 = next(v for v in var_equality_set if v.ub == min_ub)
raise InfeasibleConstraintException(
'Variable {} has a lower bound {} '
'> the upper bound {} of variable {}, '
'but they are linked by equality constraints.'
.format(v1.name, value(v1.lb), value(v2.ub), v2.name))
for v in var_equality_set:
if config.tmp:
# TODO warn if overwriting
instance._tmp_propagate_original_bounds[v] = (
v.lb, v.ub)
v.setlb(max_lb)
v.setub(min_ub)
processed.update(var_equality_set)
def _load_duals(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'dual'):
self._pyomo_model.dual = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
reverse_con_map = self._solver_con_to_pyomo_con_map
dual = self._pyomo_model.dual
if cons_to_load is None:
mosek_cons_to_load = range(self._solver_model.getnumcon())
else:
mosek_cons_to_load = set(
[con_map[pyomo_con] for pyomo_con in cons_to_load])
vals = [0.0] * self._solver_model.getnumcon()
self._solver_model.gety(self._whichsol, vals)
for mosek_con, val in zip(mosek_cons_to_load, vals):
pyomo_con = reverse_con_map[mosek_con]
dual[pyomo_con] = val
def _load_slacks(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'slack'):
self._pyomo_model.slack = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
slack = self._pyomo_model.slack
if cons_to_load is None:
cons_to_load = ComponentSet(con_map.keys())
reverse_con_map = {}
for pyomo_con, con in con_map.items():
reverse_con_map[con] = pyomo_con
for gurobi_con in self._solver_model.getConstrs():
pyomo_con = reverse_con_map[gurobi_con]
if pyomo_con in cons_to_load:
slack[pyomo_con] = gurobi_con.Slack
if self._version_major >= 5:
for gurobi_con in self._solver_model.getQConstrs():
pyomo_con = reverse_con_map[gurobi_con]
if pyomo_con in cons_to_load:
slack[pyomo_con] = gurobi_con.QCSlack
def __init__(
self,
input_vars,
external_vars,
residual_cons,
external_cons,
use_cyipopt=None,
solver=None,
):
"""
Arguments:
----------
input_vars: list
List of variables sent to this system by the outer solver
external_vars: list
List of variables that are solved for internally by this system
residual_cons: list
List of equality constraints whose residuals are exposed to
the outer solver
external_cons: list
List of equality constraints used to solve for the external
variables
use_cyipopt: bool
Whether to use CyIpopt to solve strongly connected components of
the implicit function that have dimension greater than one.
solver: Pyomo solver object
Used to solve strongly connected components of the implicit function
that have dimension greater than one. Only used if use_cyipopt
is False.
"""
if use_cyipopt is None:
use_cyipopt = cyipopt_available
if use_cyipopt and not cyipopt_available:
raise RuntimeError(
"Constructing an ExternalPyomoModel with CyIpopt unavailable. "
"Please set the use_cyipopt argument to False.")
if solver is not None and use_cyipopt:
raise RuntimeError(
"Constructing an ExternalPyomoModel with a solver specified "
"and use_cyipopt set to True. Please set use_cyipopt to False "
"to use the desired solver.")
elif solver is None and not use_cyipopt:
solver = SolverFactory("ipopt")
# If use_cyipopt is True, this solver is None and will not be used.
self._solver = solver
self._use_cyipopt = use_cyipopt
# We only need this block to construct the NLP, which wouldn't
# be necessary if we could compute Hessians of Pyomo constraints.
self._block = create_subsystem_block(
residual_cons + external_cons,
input_vars + external_vars,
)
self._block._obj = Objective(expr=0.0)
self._nlp = PyomoNLP(self._block)
self._scc_list = list(
generate_strongly_connected_components(external_cons,
variables=external_vars))
if use_cyipopt:
# Using CyIpopt allows us to solve inner problems without
# costly rewriting of the nl file. It requires quite a bit
# of preprocessing, however, to construct the ProjectedNLP
# for each block of the decomposition.
# Get "vector-valued" SCCs, those of dimension > 0.
# We will solve these with a direct IPOPT interface, which requires
# some preprocessing.
self._vector_scc_list = [(scc, inputs)
for scc, inputs in self._scc_list
if len(scc.vars) > 1]
# Need a dummy objective to create an NLP
for scc, inputs in self._vector_scc_list:
scc._obj = Objective(expr=0.0)
# I need scaling_factor so Pyomo NLPs I create from these blocks
# don't break when ProjectedNLP calls get_primals_scaling
scc.scaling_factor = Suffix(direction=Suffix.EXPORT)
# HACK: scaling_factor just needs to be nonempty.
scc.scaling_factor[scc._obj] = 1.0
# These are the "original NLPs" that will be projected
self._vector_scc_nlps = [
PyomoNLP(scc) for scc, inputs in self._vector_scc_list
]
self._vector_scc_var_names = [[
var.name for var in scc.vars.values()
] for scc, inputs in self._vector_scc_list]
self._vector_proj_nlps = [
ProjectedNLP(nlp, names) for nlp, names in zip(
self._vector_scc_nlps, self._vector_scc_var_names)
]
# We will solve the ProjectedNLPs rather than the original NLPs
self._cyipopt_nlps = [
CyIpoptNLP(nlp) for nlp in self._vector_proj_nlps
]
self._cyipopt_solvers = [
CyIpoptSolver(nlp) for nlp in self._cyipopt_nlps
]
self._vector_scc_input_coords = [
nlp.get_primal_indices(inputs) for nlp, (scc, inputs) in zip(
self._vector_scc_nlps, self._vector_scc_list)
]
assert len(external_vars) == len(external_cons)
self.input_vars = input_vars
self.external_vars = external_vars
self.residual_cons = residual_cons
self.external_cons = external_cons
self.residual_con_multipliers = [None for _ in residual_cons]
self.residual_scaling_factors = None
