def maximize_cb_outputs(show_solver_log=False):
# in this simple example, we will use an external grey box model representing
# a steady-state reactor, and solve for the space velocity that maximizes
# the concentration of component B coming out of the reactor
m = pyo.ConcreteModel()
# create a block to store the external reactor model
m.reactor = ExternalGreyBoxBlock(
external_model=ReactorConcentrationsOutputModel())
# The reaction rate constants and the feed concentration will
# be fixed for this example
m.k1con = pyo.Constraint(expr=m.reactor.inputs['k1'] == 5 / 6)
m.k2con = pyo.Constraint(expr=m.reactor.inputs['k2'] == 5 / 3)
m.k3con = pyo.Constraint(expr=m.reactor.inputs['k3'] == 1 / 6000)
m.cafcon = pyo.Constraint(expr=m.reactor.inputs['caf'] == 10000)
# add an objective function that maximizes the concentration
# of cb coming out of the reactor
m.obj = pyo.Objective(expr=m.reactor.outputs['cb'], sense=pyo.maximize)
solver = pyo.SolverFactory('cyipopt')
solver.config.options['hessian_approximation'] = 'limited-memory'
results = solver.solve(m, tee=show_solver_log)
pyo.assert_optimal_termination(results)
return m
def make_model(self):
m = pyo.ConcreteModel()
m.x = pyo.Var(initialize=1.0)
m.y = pyo.Var(initialize=1.0)
m.u = pyo.Var(initialize=1.0)
m.v = pyo.Var(initialize=1.0)
m.con_1 = pyo.Constraint(expr=m.x * m.y == m.u)
m.con_2 = pyo.Constraint(expr=m.x**2 * m.y**3 == m.v)
m.con_3 = pyo.Constraint(
expr=self.con_3_body(m.x, m.y, m.u, m.v) == self.con_3_rhs())
m.con_4 = pyo.Constraint(
expr=self.con_4_body(m.x, m.y, m.u, m.v) == self.con_4_rhs())
epm_model = pyo.ConcreteModel()
epm_model.x = pyo.Reference(m.x)
epm_model.y = pyo.Reference(m.y)
epm_model.u = pyo.Reference(m.u)
epm_model.v = pyo.Reference(m.v)
epm_model.epm = ExternalPyomoModel(
[m.u, m.v],
[m.x, m.y],
[m.con_3, m.con_4],
[m.con_1, m.con_2],
)
epm_model.obj = pyo.Objective(expr=m.x**2 + m.y**2 + m.u**2 + m.v**2)
epm_model.egb = ExternalGreyBoxBlock()
epm_model.egb.set_external_model(epm_model.epm, inputs=[m.u, m.v])
return epm_model
def test_cyipopt_unavailable(self):
try:
# HACK: Make external_pyomo_model.py think that cyipopt is not
# available.
epm_module.cyipopt_available = False
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
inner_solver = pyo.SolverFactory("ipopt")
msg = "Constructing an ExternalPyomoModel with CyIpopt unavailable"
with self.assertRaisesRegex(RuntimeError, msg):
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
use_cyipopt=True,
)
finally:
# HACK: Reset the global flag
epm_module.cyipopt_available = cyipopt_available
def maximize_cb_ratio_residuals_with_obj(show_solver_log=False,
additional_options={}):
# in this simple example, we will use an external grey box model representing
# a steady-state reactor, and solve for the space velocity that maximizes
# the ratio of B to the other components coming out of the reactor
# This example illustrates the use of "equality constraints" or residuals
# in the external grey box example as well as additional pyomo variables
# and constraints
m = pyo.ConcreteModel()
# create a block to store the external reactor model
m.reactor = ExternalGreyBoxBlock()
m.reactor.set_external_model(ReactorModelNoOutputs())
# The feed concentration will be fixed for this example
m.cafcon = pyo.Constraint(expr=m.reactor.inputs['caf'] == 10000)
# add an objective function that maximizes the concentration
# of cb coming out of the reactor
u = m.reactor.inputs
m.obj = pyo.Objective(expr=u['cb'] / (u['ca'] + u['cc'] + u['cd']),
sense=pyo.maximize)
solver = pyo.SolverFactory('cyipopt')
solver.config.options['hessian_approximation'] = 'limited-memory'
for k, v in additional_options.items():
solver.config.options[k] = v
results = solver.solve(m, tee=show_solver_log)
pyo.assert_optimal_termination(results)
return m
def _create_pressure_drop_model(self):
"""
Create a Pyomo model with pure ExternalGreyBoxModel embedded.
"""
m = pyo.ConcreteModel()
# Create variables that the external block will use
m.Pin = pyo.Var()
m.c = pyo.Var()
m.F = pyo.Var()
m.P2 = pyo.Var()
m.Pout = pyo.Var()
# Create some random constraints and objective. These variables
# need to appear somewhere other than the external block.
m.Pin_con = pyo.Constraint(expr=m.Pin == 5.0)
m.c_con = pyo.Constraint(expr=m.c == 1.0)
m.F_con = pyo.Constraint(expr=m.F == 10.0)
m.P2_con = pyo.Constraint(expr=m.P2 <= 5.0)
m.obj = pyo.Objective(expr=(m.Pout - 3.0)**2)
cons = [m.c_con, m.F_con, m.Pin_con, m.P2_con]
inputs = [m.Pin, m.c, m.F]
outputs = [m.P2, m.Pout]
# This is "model 3" from the external_grey_box_models.py file.
ex_model = PressureDropTwoOutputsWithHessian()
m.egb = ExternalGreyBoxBlock()
m.egb.set_external_model(
ex_model,
inputs=inputs,
outputs=outputs,
)
return m
def create_pyomo_external_grey_box_model(A1, A2, c1, c2, N, dt):
m2 = pyo.ConcreteModel()
m2.T = pyo.Set(initialize=list(range(N)), ordered=True)
m2.Tu = pyo.Set(initialize=list(range(N))[1:], ordered=True)
m2.egb = ExternalGreyBoxBlock()
m2.egb.set_external_model(TwoTanksSeries(A1, A2, c1, c2, N, dt))
# initialize the same as the pyomo model
for t in m2.Tu:
m2.egb.inputs['F1_{}'.format(t)].value = 1 + 0.1 * t
m2.egb.inputs['F2_{}'.format(t)].value = 2 + 0.1 * t
for t in m2.T:
m2.egb.inputs['h1_{}'.format(t)].value = 3 + 0.1 * t
m2.egb.inputs['h2_{}'.format(t)].value = 4 + 0.1 * t
m2.egb.outputs['F12_{}'.format(t)].value = 5 + 0.1 * t
m2.egb.outputs['Fo_{}'.format(t)].value = 6 + 0.1 * t
@m2.Constraint(m2.Tu)
def min_inflow(m, t):
F1_t = m.egb.inputs['F1_{}'.format(t)]
return 2 <= F1_t
@m2.Constraint(m2.T)
def max_outflow(m, t):
Fo_t = m.egb.outputs['Fo_{}'.format(t)]
return Fo_t <= 4.5
m2.h10 = pyo.Constraint(expr=m2.egb.inputs['h1_0'] == 1.5)
m2.h20 = pyo.Constraint(expr=m2.egb.inputs['h2_0'] == 0.5)
m2.obj = pyo.Objective(expr=sum(
(m2.egb.inputs['h1_{}'.format(t)] - 1.0)**2 +
(m2.egb.inputs['h2_{}'.format(t)] - 1.5)**2 for t in m2.T))
return m2
def test_optimize_no_cyipopt_for_inner_problem(self):
# Here we don't specify a solver for the inner problem.
# This is contrived, as clearly CyIpopt is available for the outer
# solve. This test exercises the part of the ExternalPyomoModel
# constructor that sets a default solver if CyIpopt is not available.
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block.set_external_model(ex_model)
a = m.ex_block.inputs["input_0"]
b = m.ex_block.inputs["input_1"]
r = m.ex_block.inputs["input_2"]
x = m.ex_block.inputs["input_3"]
y = m.ex_block.inputs["input_4"]
m.obj = pyo.Objective(expr=(x - 2.0)**2 + (y - 2.0)**2 + (a - 2.0)**2 +
(b - 2.0)**2 + (r - 2.0)**2)
# Solve with external model embedded
solver = pyo.SolverFactory("cyipopt")
solver.solve(m)
m_ex.obj = pyo.Objective(expr=(m_ex.x - 2.0)**2 + (m_ex.y - 2.0)**2 +
(m_ex.a - 2.0)**2 + (m_ex.b - 2.0)**2 +
(m_ex.r - 2.0)**2)
m_ex.a.set_value(0.0)
m_ex.b.set_value(0.0)
m_ex.r.set_value(0.0)
m_ex.y.set_value(0.0)
m_ex.x.set_value(0.0)
# Solve external model, now with same objective function
ipopt = pyo.SolverFactory("ipopt")
ipopt.solve(m_ex)
# Make sure full space and reduced space solves give same
# answers.
self.assertAlmostEqual(m_ex.a.value, a.value, delta=1e-8)
self.assertAlmostEqual(m_ex.b.value, b.value, delta=1e-8)
self.assertAlmostEqual(m_ex.r.value, r.value, delta=1e-8)
self.assertAlmostEqual(m_ex.x.value, x.value, delta=1e-8)
self.assertAlmostEqual(m_ex.y.value, y.value, delta=1e-8)
def test_optimize_with_ipopt_for_inner_problem(self):
# Use Ipopt, rather than the default CyIpopt, for the inner problem
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
inner_solver = pyo.SolverFactory("ipopt")
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
solver=inner_solver,
use_cyipopt=False,
)
block.set_external_model(ex_model)
a = m.ex_block.inputs["input_0"]
b = m.ex_block.inputs["input_1"]
r = m.ex_block.inputs["input_2"]
x = m.ex_block.inputs["input_3"]
y = m.ex_block.inputs["input_4"]
m.obj = pyo.Objective(expr=(x - 2.0)**2 + (y - 2.0)**2 + (a - 2.0)**2 +
(b - 2.0)**2 + (r - 2.0)**2)
# Solve with external model embedded
solver = pyo.SolverFactory("cyipopt")
solver.solve(m)
m_ex.obj = pyo.Objective(expr=(m_ex.x - 2.0)**2 + (m_ex.y - 2.0)**2 +
(m_ex.a - 2.0)**2 + (m_ex.b - 2.0)**2 +
(m_ex.r - 2.0)**2)
m_ex.a.set_value(0.0)
m_ex.b.set_value(0.0)
m_ex.r.set_value(0.0)
m_ex.y.set_value(0.0)
m_ex.x.set_value(0.0)
# Solve external model, now with same objective function
ipopt = pyo.SolverFactory("ipopt")
ipopt.solve(m_ex)
# Make sure full space and reduced space solves give same
# answers.
self.assertAlmostEqual(m_ex.a.value, a.value, delta=1e-8)
self.assertAlmostEqual(m_ex.b.value, b.value, delta=1e-8)
self.assertAlmostEqual(m_ex.r.value, r.value, delta=1e-8)
self.assertAlmostEqual(m_ex.x.value, x.value, delta=1e-8)
self.assertAlmostEqual(m_ex.y.value, y.value, delta=1e-8)
def maximize_cb_ratio_residuals_with_output_scaling(show_solver_log=False,
additional_options={}):
# in this simple example, we will use an external grey box model representing
# a steady-state reactor, and solve for the space velocity that maximizes
# the ratio of B to the other components coming out of the reactor
# This example illustrates the use of "equality constraints" or residuals
# in the external grey box example as well as outputs
# This example also shows how to do scaling.
# There are two things to scale, the "Pyomo" variables/constraints,
# and the external model residuals / output equations.
# The scaling factors for the external residuals and output equations
# are set in the derived ExternalGreyBoxModel class (see ReactorModelScaled
# for this example).
# The scaling factors for the Pyomo part of the model are set using suffixes
# - this requires that we declare the scaling suffix on the main model as
# shown below.
# - Then the scaling factors can be set directly on the Pyomo variables
# and constraints as also shown below.
# - Note: In this example, the scaling factors for the input and output
# variables from the grey box model are set in the finalize_block_construction
# callback (again, see ReactorModelScaled)
m = pyo.ConcreteModel()
# declare the scaling suffix on the model
m.scaling_factor = pyo.Suffix(direction=pyo.Suffix.EXPORT)
# create a block to store the external reactor model
m.reactor = ExternalGreyBoxBlock(external_model=ReactorModelScaled())
# The feed concentration will be fixed for this example
m.cafcon = pyo.Constraint(expr=m.reactor.inputs['caf'] == 10000)
# set a scaling factor for this constraint - if we had additional pyomo
# variables, we could set them the same way
m.scaling_factor[m.cafcon] = 42.0
# add an objective function that maximizes the concentration
# of cb coming out of the reactor
m.obj = pyo.Objective(expr=m.reactor.outputs['cb_ratio'],
sense=pyo.maximize)
solver = pyo.SolverFactory('cyipopt')
solver.config.options['hessian_approximation'] = 'limited-memory'
for k, v in additional_options.items():
solver.config.options[k] = v
results = solver.solve(m, tee=show_solver_log)
pyo.assert_optimal_termination(results)
return m
def test_solve_square(self):
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block.set_external_model(ex_model)
_add_linking_constraints(m)
m.a.fix(1)
m.b.fix(2)
m.r.fix(3)
m.obj = pyo.Objective(expr=0)
solver = pyo.SolverFactory("cyipopt")
solver.solve(m)
self.assertFalse(m_ex.a.fixed)
self.assertFalse(m_ex.b.fixed)
self.assertFalse(m_ex.r.fixed)
m_ex.a.fix(1)
m_ex.b.fix(2)
m_ex.r.fix(3)
ipopt = pyo.SolverFactory("ipopt")
ipopt.solve(m_ex)
x = m.ex_block.inputs["input_3"]
y = m.ex_block.inputs["input_4"]
self.assertAlmostEqual(m_ex.x.value, x.value, delta=1e-8)
self.assertAlmostEqual(m_ex.y.value, y.value, delta=1e-8)
def test_construct_indexed(self):
block = ExternalGreyBoxBlock([0, 1, 2], concrete=True)
self.assertIs(type(block), IndexedExternalGreyBoxBlock)
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
for i in block:
b = block[i]
b.set_external_model(ex_model)
self.assertEqual(len(b.inputs), len(input_vars))
self.assertEqual(len(b.outputs), 0)
self.assertEqual(len(b._equality_constraint_names), 2)
def test_construct_scalar(self):
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
self.assertIs(type(block), ScalarExternalGreyBoxBlock)
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block.set_external_model(ex_model)
self.assertEqual(len(block.inputs), len(input_vars))
self.assertEqual(len(block.outputs), 0)
self.assertEqual(len(block._equality_constraint_names), 2)
def test_solver_with_cyipopt(self):
# CyIpopt is required here just because we get a different error
# (see test below) if CyIpopt is unavailable.
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
inner_solver = pyo.SolverFactory("ipopt")
msg = "Please set use_cyipopt to False"
with self.assertRaisesRegex(RuntimeError, msg):
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
solver=inner_solver,
use_cyipopt=True,
)
def test_optimize_dynamic_references(self):
"""
When when pre-existing variables are attached to the EGBB
as references, linking constraints are no longer necessary.
"""
# Create the "external model"
m = make_dynamic_model()
time = m.time
t0 = m.time.first()
m.h[t0].fix(1.2)
m.flow_in[t0].fix(1.5)
m.obj = pyo.Objective(expr=sum(
(m.h[t] - 2.0)**2 for t in m.time if t != t0))
# Create the block that will hold the reduced space model.
reduced_space = pyo.Block(concrete=True)
reduced_space.diff_var = pyo.Reference(m.h)
reduced_space.deriv_var = pyo.Reference(m.dhdt)
reduced_space.input_var = pyo.Reference(m.flow_in)
reduced_space.disc_eq = pyo.Reference(m.dhdt_disc_eqn)
reduced_space.objective = pyo.Reference(m.obj)
reduced_space.external_block = ExternalGreyBoxBlock(time)
block = reduced_space.external_block
block[t0].deactivate()
for t in time:
# TODO: is skipping time.first() necessary?
if t != t0:
input_vars = [m.h[t], m.dhdt[t], m.flow_in[t]]
external_vars = [m.flow_out[t]]
residual_cons = [m.h_diff_eqn[t]]
external_cons = [m.flow_out_eqn[t]]
external_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block[t].set_external_model(external_model, inputs=input_vars)
solver = pyo.SolverFactory("cyipopt")
results = solver.solve(reduced_space)
# These values were obtained by solving this problem in the full
# space in a separate script.
h_target = [1.2, 2.0, 2.0]
dhdt_target = [-0.690890, 0.80, 0.0]
flow_in_target = [1.5, 3.628427, 2.828427]
flow_out_target = [2.190890, 2.828427, 2.828427]
for t in time:
if t == t0:
continue
values = [
m.h[t].value, m.dhdt[t].value, m.flow_out[t].value,
m.flow_in[t].value
]
target_values = [
h_target[t], dhdt_target[t], flow_out_target[t],
flow_in_target[t]
]
self.assertStructuredAlmostEqual(values, target_values, delta=1e-5)
def test_solve_square_dynamic(self):
# Create the "external model"
m = make_dynamic_model()
time = m.time
t0 = m.time.first()
m.h[t0].fix(1.2)
m.flow_in.fix(1.5)
# Create the block that will hold the reduced space model.
reduced_space = pyo.Block(concrete=True)
reduced_space.diff_var = pyo.Reference(m.h)
reduced_space.deriv_var = pyo.Reference(m.dhdt)
reduced_space.input_var = pyo.Reference(m.flow_in)
reduced_space.disc_eq = pyo.Reference(m.dhdt_disc_eqn)
reduced_space.external_block = ExternalGreyBoxBlock(time)
block = reduced_space.external_block
block[t0].deactivate()
for t in time:
# TODO: skipping time.first() necessary?
if t != t0:
input_vars = [m.h[t], m.dhdt[t]]
external_vars = [m.flow_out[t]]
residual_cons = [m.h_diff_eqn[t]]
external_cons = [m.flow_out_eqn[t]]
external_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block[t].set_external_model(external_model)
n_inputs = len(input_vars)
def linking_constraint_rule(m, i, t):
if t == t0:
return pyo.Constraint.Skip
if i == 0:
return m.diff_var[t] == m.external_block[t].inputs["input_0"]
elif i == 1:
return m.deriv_var[t] == m.external_block[t].inputs["input_1"]
reduced_space.linking_constraint = pyo.Constraint(
range(n_inputs),
time,
rule=linking_constraint_rule,
)
# Initialize new variables
for t in time:
if t != t0:
block[t].inputs["input_0"].set_value(m.h[t].value)
block[t].inputs["input_1"].set_value(m.dhdt[t].value)
reduced_space._obj = pyo.Objective(expr=0)
solver = pyo.SolverFactory("cyipopt")
results = solver.solve(reduced_space, tee=True)
# Full space square model was solved in a separate script
# to obtain these values.
h_target = [1.2, 0.852923, 0.690725]
dhdt_target = [-0.690890, -0.347077, -0.162198]
flow_out_target = [2.190980, 1.847077, 1.662198]
for t in time:
if t == t0:
continue
values = [m.h[t].value, m.dhdt[t].value, m.flow_out[t].value]
target_values = [h_target[t], dhdt_target[t], flow_out_target[t]]
self.assertStructuredAlmostEqual(values, target_values, delta=1e-5)
def test_construct_dynamic(self):
m = make_dynamic_model()
time = m.time
t0 = m.time.first()
inputs = [m.h, m.dhdt, m.flow_in]
ext_vars = [m.flow_out]
residuals = [m.h_diff_eqn]
ext_cons = [m.flow_out_eqn]
external_model_dict = {
t: ExternalPyomoModel(
[var[t] for var in inputs],
[var[t] for var in ext_vars],
[con[t] for con in residuals],
[con[t] for con in ext_cons],
)
for t in time
}
reduced_space = pyo.Block(concrete=True)
reduced_space.external_block = ExternalGreyBoxBlock(
time,
external_model=external_model_dict,
)
block = reduced_space.external_block
block[t0].deactivate()
self.assertIs(type(block), IndexedExternalGreyBoxBlock)
for t in time:
b = block[t]
self.assertEqual(len(b.inputs), len(inputs))
self.assertEqual(len(b.outputs), 0)
self.assertEqual(len(b._equality_constraint_names), len(residuals))
reduced_space.diff_var = pyo.Reference(m.h)
reduced_space.deriv_var = pyo.Reference(m.dhdt)
reduced_space.input_var = pyo.Reference(m.flow_in)
reduced_space.disc_eqn = pyo.Reference(m.dhdt_disc_eqn)
pyomo_vars = list(reduced_space.component_data_objects(pyo.Var))
pyomo_cons = list(reduced_space.component_data_objects(pyo.Constraint))
# NOTE: Variables in the EGBB are not found by component_data_objects
self.assertEqual(len(pyomo_vars), len(inputs) * len(time))
# "Constraints" defined by the EGBB are not found either, although
# this is expected.
self.assertEqual(len(pyomo_cons), len(time) - 1)
reduced_space._obj = pyo.Objective(expr=0)
# This is required to avoid a failure in the implicit function
# evaluation when "initializing" (?) the PNLPwGBB.
# Why exactly is function evaluation necessary for this
# initialization again?
block[:].inputs[:].set_value(1.0)
# This is necessary for these variables to appear in the PNLPwGBB.
# Otherwise they don't appear in any "real" constraints of the
# PyomoNLP.
reduced_space.const_input_eqn = pyo.Constraint(
expr=reduced_space.input_var[2] - reduced_space.input_var[1] == 0)
nlp = PyomoNLPWithGreyBoxBlocks(reduced_space)
self.assertEqual(
nlp.n_primals(),
# EGBB "inputs", dhdt, and flow_in exist for t != t0.
# h exists for all time.
(2 + len(inputs)) * (len(time) - 1) + len(time),
)
self.assertEqual(
nlp.n_constraints(),
# EGBB equality constraints and disc_eqn exist for t != t0.
# const_input_eqn is a single constraint
(len(residuals) + 1) * (len(time) - 1) + 1,
)
def test_optimize_dynamic(self):
# Create the "external model"
m = make_dynamic_model()
time = m.time
t0 = m.time.first()
m.h[t0].fix(1.2)
m.flow_in[t0].fix(1.5)
m.obj = pyo.Objective(expr=sum(
(m.h[t] - 2.0)**2 for t in m.time if t != t0))
# Create the block that will hold the reduced space model.
reduced_space = pyo.Block(concrete=True)
reduced_space.diff_var = pyo.Reference(m.h)
reduced_space.deriv_var = pyo.Reference(m.dhdt)
reduced_space.input_var = pyo.Reference(m.flow_in)
reduced_space.disc_eq = pyo.Reference(m.dhdt_disc_eqn)
reduced_space.objective = pyo.Reference(m.obj)
reduced_space.external_block = ExternalGreyBoxBlock(time)
block = reduced_space.external_block
block[t0].deactivate()
for t in time:
# TODO: skipping time.first() necessary?
if t != t0:
input_vars = [m.h[t], m.dhdt[t], m.flow_in[t]]
external_vars = [m.flow_out[t]]
residual_cons = [m.h_diff_eqn[t]]
external_cons = [m.flow_out_eqn[t]]
external_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block[t].set_external_model(external_model)
n_inputs = len(input_vars)
def linking_constraint_rule(m, i, t):
if t == t0:
return pyo.Constraint.Skip
if i == 0:
return m.diff_var[t] == m.external_block[t].inputs["input_0"]
elif i == 1:
return m.deriv_var[t] == m.external_block[t].inputs["input_1"]
elif i == 2:
return m.input_var[t] == m.external_block[t].inputs["input_2"]
reduced_space.linking_constraint = pyo.Constraint(
range(n_inputs),
time,
rule=linking_constraint_rule,
)
# Initialize new variables
for t in time:
if t != t0:
block[t].inputs["input_0"].set_value(m.h[t].value)
block[t].inputs["input_1"].set_value(m.dhdt[t].value)
block[t].inputs["input_2"].set_value(m.flow_in[t].value)
solver = pyo.SolverFactory("cyipopt")
results = solver.solve(reduced_space)
# These values were obtained by solving this problem in the full
# space in a separate script.
h_target = [1.2, 2.0, 2.0]
dhdt_target = [-0.690890, 0.80, 0.0]
flow_in_target = [1.5, 3.628427, 2.828427]
flow_out_target = [2.190890, 2.828427, 2.828427]
for t in time:
if t == t0:
continue
values = [
m.h[t].value, m.dhdt[t].value, m.flow_out[t].value,
m.flow_in[t].value
]
target_values = [
h_target[t], dhdt_target[t], flow_out_target[t],
flow_in_target[t]
]
self.assertStructuredAlmostEqual(values, target_values, delta=1e-5)
def test_set_and_evaluate(self):
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block.set_external_model(ex_model)
a = m.ex_block.inputs["input_0"]
b = m.ex_block.inputs["input_1"]
r = m.ex_block.inputs["input_2"]
x = m.ex_block.inputs["input_3"]
y = m.ex_block.inputs["input_4"]
m.obj = pyo.Objective(expr=(x - 2.0)**2 + (y - 2.0)**2 + (a - 2.0)**2 +
(b - 2.0)**2 + (r - 2.0)**2)
_add_linking_constraints(m)
nlp = PyomoNLPWithGreyBoxBlocks(m)
# Set primals in model, get primals in nlp
# set/get duals
# evaluate constraints
# evaluate Jacobian
# evaluate Hessian
self.assertEqual(nlp.n_primals(), 8)
# PyomoNLPWithGreyBoxBlocks sorts variables by name
primals_names = [
"a",
"b",
"ex_block.inputs[input_0]",
"ex_block.inputs[input_1]",
"ex_block.inputs[input_2]",
"ex_block.inputs[input_3]",
"ex_block.inputs[input_4]",
"r",
]
self.assertEqual(nlp.primals_names(), primals_names)
np.testing.assert_equal(np.zeros(8), nlp.get_primals())
primals = np.array([0, 1, 2, 3, 4, 5, 6, 7])
nlp.set_primals(primals)
np.testing.assert_equal(primals, nlp.get_primals())
nlp.load_state_into_pyomo()
for name, val in zip(primals_names, primals):
var = m.find_component(name)
self.assertEqual(var.value, val)
constraint_names = [
"linking_constraint[0]",
"linking_constraint[1]",
"linking_constraint[2]",
"ex_block.residual_0",
"ex_block.residual_1",
]
self.assertEqual(constraint_names, nlp.constraint_names())
residuals = np.array([
-2.0,
-2.0,
3.0,
# These values were obtained by solving the same system
# with Ipopt in another script. It may be better to do
# the solve in this test in case the system changes.
5.0 - (-3.03051522),
6.0 - 3.583839997,
])
np.testing.assert_allclose(residuals,
nlp.evaluate_constraints(),
rtol=1e-8)
duals = np.array([1, 2, 3, 4, 5])
nlp.set_duals(duals)
self.assertEqual(ex_model.residual_con_multipliers, [4, 5])
np.testing.assert_equal(nlp.get_duals(), duals)
def build_single_point_model_external(m):
ex_model = UAModelExternal()
m.egb = ExternalGreyBoxBlock()
m.egb.set_external_model(ex_model)
def test_jacobian(self):
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block.set_external_model(ex_model)
a = m.ex_block.inputs["input_0"]
b = m.ex_block.inputs["input_1"]
r = m.ex_block.inputs["input_2"]
x = m.ex_block.inputs["input_3"]
y = m.ex_block.inputs["input_4"]
m.obj = pyo.Objective(expr=(x - 2.0)**2 + (y - 2.0)**2 + (a - 2.0)**2 +
(b - 2.0)**2 + (r - 2.0)**2)
_add_linking_constraints(m)
nlp = PyomoNLPWithGreyBoxBlocks(m)
primals = np.array([0, 1, 2, 3, 4, 5, 6, 7])
nlp.set_primals(primals)
jac = nlp.evaluate_jacobian()
# Variable and constraint orders (verified by previous test):
# Rows:
# [
# "linking_constraint[0]",
# "linking_constraint[1]",
# "linking_constraint[2]",
# "ex_block.residual_0",
# "ex_block.residual_1",
# ]
# Cols:
# [
# "a",
# "b",
# "ex_block.inputs[input_0]",
# "ex_block.inputs[input_1]",
# "ex_block.inputs[input_2]",
# "ex_block.inputs[input_3]",
# "ex_block.inputs[input_4]",
# "r",
# ]
row = [
0,
0,
1,
1,
2,
2,
3,
3,
3,
3,
3,
4,
4,
4,
4,
4,
]
col = [
0,
2,
1,
3,
7,
4,
2,
3,
4,
5,
6,
2,
3,
4,
5,
6,
]
data = [
1,
-1,
1,
-1,
1,
-1,
-0.16747094,
-1.00068434,
1.72383729,
1,
0,
-0.30708535,
-0.28546127,
-0.25235924,
0,
1,
]
self.assertEqual(len(row), len(jac.row))
rcd_dict = dict(((i, j), val) for i, j, val in zip(row, col, data))
for i, j, val in zip(jac.row, jac.col, jac.data):
self.assertIn((i, j), rcd_dict)
self.assertAlmostEqual(rcd_dict[i, j], val, delta=1e-8)
def test_hessian_2(self):
# Test with duals different than vector of ones
m = pyo.ConcreteModel()
m.ex_block = ExternalGreyBoxBlock(concrete=True)
block = m.ex_block
m_ex = _make_external_model()
input_vars = [m_ex.a, m_ex.b, m_ex.r, m_ex.x_out, m_ex.y_out]
external_vars = [m_ex.x, m_ex.y]
residual_cons = [m_ex.c_out_1, m_ex.c_out_2]
external_cons = [m_ex.c_ex_1, m_ex.c_ex_2]
ex_model = ExternalPyomoModel(
input_vars,
external_vars,
residual_cons,
external_cons,
)
block.set_external_model(ex_model)
a = m.ex_block.inputs["input_0"]
b = m.ex_block.inputs["input_1"]
r = m.ex_block.inputs["input_2"]
x = m.ex_block.inputs["input_3"]
y = m.ex_block.inputs["input_4"]
m.obj = pyo.Objective(expr=(x - 2.0)**2 + (y - 2.0)**2 + (a - 2.0)**2 +
(b - 2.0)**2 + (r - 2.0)**2)
_add_nonlinear_linking_constraints(m)
nlp = PyomoNLPWithGreyBoxBlocks(m)
primals = np.array([0, 1, 2, 3, 4, 5, 6, 7])
duals = np.array([4.4, -3.3, 2.2, -1.1, 0.0])
nlp.set_primals(primals)
nlp.set_duals(duals)
hess = nlp.evaluate_hessian_lag()
# Variable order (verified by a previous test):
# [
# "a",
# "b",
# "ex_block.inputs[input_0]",
# "ex_block.inputs[input_1]",
# "ex_block.inputs[input_2]",
# "ex_block.inputs[input_3]",
# "ex_block.inputs[input_4]",
# "r",
# ]
row = [0, 1, 7]
col = [0, 1, 7]
# Data entries are influenced by multiplier values.
data = [4.4 * 2.0, -3.3 * 2.0, 2.2 * 2.0]
# ^ These variables only appear in linking constraints
rcd_dict = dict(((i, j), val) for i, j, val in zip(row, col, data))
# These are the coordinates of the Hessian corresponding to
# external variables with true nonzeros. The coordinates have
# terms due to objective, linking constraints, and external
# constraints. Values were extracted from the external model
# while writing this test, which is just meant to verify
# that the different Hessians combined properly.
ex_block_nonzeros = {
(2, 2): 2.0 + 4.4 * (-1.0) + -1.1 * (-0.10967928),
(2, 3): -1.1 * (-0.10684633),
(3, 2): -1.1 * (-0.10684633),
(2, 4): -1.1 * (0.19329898),
(4, 2): -1.1 * (0.19329898),
(3, 3): 2.0 + (-3.3) * (-1.0) + -1.1 * (-1.31592135),
(3, 4): -1.1 * (1.13920361),
(4, 3): -1.1 * (1.13920361),
(4, 4): 2.0 + 2.2 * (-1.0) + -1.1 * (-1.0891866),
(5, 5): 2.0,
(6, 6): 2.0,
}
rcd_dict.update(ex_block_nonzeros)
# Because "external Hessians" are computed by factorizing matrices,
# we have dense blocks in the Hessian for now.
ex_block_coords = [2, 3, 4, 5, 6]
for i, j in itertools.product(ex_block_coords, ex_block_coords):
row.append(i)
col.append(j)
if (i, j) not in rcd_dict:
rcd_dict[i, j] = 0.0
self.assertEqual(len(row), len(hess.row))
for i, j, val in zip(hess.row, hess.col, hess.data):
self.assertIn((i, j), rcd_dict)
self.assertAlmostEqual(rcd_dict[i, j], val, delta=1e-8)
