def test_subproblem_preprocessing_encounters_trivial_constraints(self):
m = ConcreteModel()
m.x = Var(bounds=(0, 10))
m.z = Var(bounds=(-10, 10))
m.disjunction = Disjunction(expr=[[m.x == 0, m.z >= 4],
[m.x + m.z <= 0]])
m.cons = Constraint(expr=m.x*m.z <= 0)
m.obj = Objective(expr=-m.z)
m.disjunction.disjuncts[0].indicator_var.fix(True)
m.disjunction.disjuncts[1].indicator_var.fix(False)
SolverFactory('gdpopt').solve(m, strategy='RIC', mip_solver=mip_solver,
nlp_solver=nlp_solver,
init_strategy='fix_disjuncts')
# The real test is that this doesn't throw an error when we preprocess
# to solve the first subproblem (in the initialization). The nonlinear
# constraint becomes trivial, which we need to make sure is handled
# correctly.
self.assertEqual(value(m.x), 0)
self.assertEqual(value(m.z), 10)
self.assertTrue(value(m.disjunction.disjuncts[0].indicator_var))
self.assertFalse(value(m.disjunction.disjuncts[1].indicator_var))
def setUp(self):
m = ConcreteModel()
m.z = Var(range(3), domain=Reals, initialize=2.)
m.x = Var(range(2), initialize=2.)
m.x[1] = 1.0
def blackbox(a, b):
return sin(a - b)
self.bb = ExternalFunction(blackbox)
m.obj = Objective(
expr=(m.z[0]-1.0)**2 + (m.z[0]-m.z[1])**2 + (m.z[2]-1.0)**2 \
+ (m.x[0]-1.0)**4 + (m.x[1]-1.0)**6 # + m.bb(m.x[0],m.x[1])
)
m.c1 = Constraint(expr=m.x[0] * m.z[0]**2 +
self.bb(m.x[0], m.x[1]) == 2 * sqrt(2.0))
m.c2 = Constraint(expr=m.z[2]**4 * m.z[1]**2 + m.z[1] == 8 + sqrt(2.0))
self.m = m.clone()
def test_expr5(self):
model = ConcreteModel()
model.A = Set(initialize=[1,2,3], doc='set A')
model.B = Param(model.A, initialize={1:100,2:200,3:300}, doc='param B', mutable=True)
model.C = Param(initialize=3, doc='param C', mutable=True)
model.x = Var(model.A, doc='var x')
model.y = Var(doc='var y')
model.o = Objective(expr=model.y, doc='obj o')
model.c1 = Constraint(expr=model.x[1] >= 0, doc='con c1')
def c2_rule(model, a):
return model.B[a] * model.x[a] <= 1
model.c2 = Constraint(model.A, doc='con c2', rule=c2_rule)
model.c3 = ConstraintList(doc='con c3')
model.c3.add(model.y <= 0)
#
OUTPUT=open(join(currdir, "test_expr5.out"), "w")
model.pprint(ostream=OUTPUT)
OUTPUT.close()
_out, _txt = join(currdir, "test_expr5.out"), join(currdir, "test_expr5.txt")
self.assertTrue(cmp(_out, _txt),
msg="Files %s and %s differ" % (_out, _txt))
def test_model_clone(self):
model = ConcreteModel()
model.x = Var(initialize=2.0)
model.y = Var(initialize=0.0)
model.ec = Expression(initialize=model.x**2 + 1)
model.obj = Objective(expr=model.y + model.ec)
self.assertEqual(model.obj.expr(), 5.0)
self.assertTrue(id(model.ec) in [id(e) for e in model.obj.expr.args])
inst = model.clone()
self.assertEqual(inst.obj.expr(), 5.0)
if not id(inst.ec) in [id(e) for e in inst.obj.expr.args]:
print("BUG?")
print(id(inst.ec))
print(inst.obj.expr.__class__)
print([id(e) for e in inst.obj.expr.args])
print([e.__class__ for e in inst.obj.expr.args])
print([id(e) for e in model.obj.expr.args])
print([e.__class__ for e in model.obj.expr.args])
self.assertTrue(id(inst.ec) in [id(e) for e in inst.obj.expr.args])
self.assertNotEqual(id(model.ec), id(inst.ec))
self.assertFalse(id(inst.ec) in [id(e) for e in model.obj.expr.args])
def test_pysmo_rbf(branin_dataset):
m, x, y = branin_dataset
pysmo_rbf_settings = {
'basis_function': 'gaussian',
'regularization': True,
'pyomo_vars': [m.x[1], m.x[2]]
}
modeler = Pysmo_rbf(**pysmo_rbf_settings)
modeler.regressed_data(x, y)
modeler.build_model()
m.obj = Objective(expr=modeler._model)
m.pprint()
modeler.save_results('results.pickle', overwrite=True)
check_metrics(modeler.get_results())
return True
def test_pysmo_krig(branin_dataset):
m, x, y = branin_dataset
pysmo_krg_settings = {
'numerical_gradients': True,
'regularization': True,
'pyomo_vars': [m.x[1], m.x[2]]
}
modeler = Pysmo_kriging(**pysmo_krg_settings)
modeler.regressed_data(x, y)
modeler.build_model()
m.obj = Objective(expr=modeler._model)
m.pprint()
modeler.save_results('results.pickle', overwrite=True)
check_metrics(modeler.get_results())
return True
def test_var_on_nonblock(self):
class Foo(Block().__class__):
def __init__(self, *args, **kwds):
kwds.setdefault('ctype', Foo)
super(Foo, self).__init__(*args, **kwds)
model = ConcreteModel()
model.x = Var()
model.other = Foo()
model.other.a = Var()
model.c = Constraint(expr=model.other.a + 2 * model.x <= 0)
model.obj = Objective(expr=model.x)
baseline_fname, test_fname = self._get_fnames()
self._cleanup(test_fname)
self.assertRaisesRegex(KeyError,
"'other.a' exists within Foo 'other'",
model.write,
test_fname,
format='nl')
self._cleanup(test_fname)
def test_replaceExternalFunctionsWithVariables(self):
# In running this method, we not only replace EFs
# with 'holder' vars; we also get useful information
# about inputs, outputs, basis expressions, etc.
self.interface.replaceExternalFunctionsWithVariables()
# Check the directly defined model vars against all_variables
for var in self.interface.model.component_data_objects(Var):
self.assertIn(var, ComponentSet(self.interface.data.all_variables))
# Check the output vars against all_variables
for i in self.interface.data.ef_outputs:
self.assertIn(self.interface.data.ef_outputs[i],
ComponentSet(self.interface.data.all_variables))
# The truth models should be a mapping from the EF to
# the replacement
for i, k in self.interface.data.truth_models.items():
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.assertEqual(i, self.interface.data.ef_outputs[1])
for i, k in self.interface.data.basis_expressions.items():
self.assertEqual(k, 0)
self.assertEqual(i, self.interface.data.ef_outputs[1])
self.assertEqual(1, list(self.interface.data.ef_inputs.keys())[0])
self.assertEqual(
self.interface.data.ef_inputs[1],
[self.interface.model.x[0], self.interface.model.x[1]])
# HACK: This was in response to a hack.
# Remove when NL writer re-write is complete.
# Make sure that EFs were removed from the cloned model.
self.assertEqual(
list(self.interface.model.component_objects(ExternalFunction)), [])
# TRF only supports one active Objective.
# Make sure that it fails if there are multiple objs.
self.m.obj2 = Objective(expr=(self.m.x[0]**2 - (self.m.z[1] - 3)**3))
interface = TRFInterface(self.m,
[self.m.z[0], self.m.z[1], self.m.z[2]],
self.ext_fcn_surrogate_map_rule, self.config)
with self.assertRaises(ValueError):
interface.replaceExternalFunctionsWithVariables()
def optimize_set_up(m):
# objective
m.fs.objective = Objective(expr=m.fs.costing.LCOW)
# unfix decision variables and add bounds
# pump 1 and pump 2
m.fs.P1.control_volume.properties_out[0].pressure.unfix()
m.fs.P1.control_volume.properties_out[0].pressure.setlb(10e5)
m.fs.P1.control_volume.properties_out[0].pressure.setub(80e5)
m.fs.P1.deltaP.setlb(0)
m.fs.P2.control_volume.properties_out[0].pressure.setlb(10e5)
m.fs.P2.control_volume.properties_out[0].pressure.setub(80e5)
m.fs.P2.deltaP.setlb(0)
# RO
m.fs.RO.area.setlb(1)
m.fs.RO.area.setub(150)
# additional specifications
m.fs.product_salinity = Param(
initialize=500e-6, mutable=True
) # product NaCl mass fraction [-]
m.fs.minimum_water_flux = Param(
initialize=1.0 / 3600.0, mutable=True
) # minimum water flux [kg/m2-s]
# additional constraints
m.fs.eq_product_quality = Constraint(
expr=m.fs.product.properties[0].mass_frac_phase_comp["Liq", "NaCl"]
<= m.fs.product_salinity
)
iscale.constraint_scaling_transform(
m.fs.eq_product_quality, 1e3
) # scaling constraint
m.fs.eq_minimum_water_flux = Constraint(
expr=m.fs.RO.flux_mass_phase_comp[0, 1, "Liq", "H2O"] >= m.fs.minimum_water_flux
)
# ---checking model---
assert_degrees_of_freedom(m, 1)
def test_solve_with_store5(self):
model = ConcreteModel()
model.A = RangeSet(1, 4)
model.b = Block()
model.b.x = Var(model.A, bounds=(-1, 1))
model.b.obj = Objective(expr=sum_product(model.b.x))
model.c = Constraint(expr=model.b.x[1] >= 0)
smanager = SolverManager_Serial()
ah = smanager.queue(model, solver='glpk', load_solutions=False)
results = smanager.wait_for(ah)
self.assertEqual(len(model.solutions), 0)
self.assertEqual(len(results.solution), 1)
model.solutions.load_from(results)
self.assertEqual(len(model.solutions), 1)
self.assertEqual(len(results.solution), 1)
#
model.solutions.store_to(results)
results.write(filename=join(currdir, 'solve_with_store8.out'),
format='json')
self.assertMatchesYamlBaseline(join(currdir, "solve_with_store8.out"),
join(currdir, "solve_with_store4.txt"))
def test_optimal_mip(self):
self.model.Idx = RangeSet(2)
self.model.X = Var(self.model.Idx, within=NonNegativeIntegers)
self.model.Y = Var(self.model.Idx, within=Binary)
self.model.C1 = Constraint(expr=self.model.X[1] == self.model.X[2] + 1)
self.model.Obj = Objective(expr=self.model.Y[1] + self.model.Y[2] -
self.model.X[1],
sense=maximize)
results = self.opt.solve(self.model)
self.assertEqual(1.0, results.problem.lower_bound)
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(TerminationCondition.optimal,
results.solver.termination_condition)
self.assertEqual(
'Model was solved to optimality (subject to tolerances), and an optimal solution is available.',
results.solver.termination_message)
self.assertEqual(SolverStatus.ok, results.solver.status)
def _construct_objective(self):
"""
Construction of the objectives.
When using Continuous Set, the implicit expression such as sum(x[t] for t in Time)
must be created after time discrimination. Otherwise, the expression will only consider
existing timeSteps.
To overcome this behaviour, this method allows to automatically redefine objectives after time discretization.
..note: should be used in some rare cases. Normally, the Integral object should be able to do the trick.
"""
for block in self.component_map(active=True, ctype=Block):
try:
block.construct_objective()
except OSError as err:
raise err
for obj in self.component_map(active=True, ctype=Objective):
rule = self.component(obj).rule
self.del_component(obj)
self.add_component(obj, Objective(rule=rule))
def test_solve4(self):
model = ConcreteModel()
model.A = RangeSet(1,4)
model.x = Var(model.A, bounds=(-1,1))
def obj_rule(model):
return sum_product(model.x)
model.obj = Objective(rule=obj_rule)
def c_rule(model):
expr = 0
for i in model.A:
expr += i*model.x[i]
return expr == 0
model.c = Constraint(rule=c_rule)
opt = SolverFactory('glpk')
results = opt.solve(model, symbolic_solver_labels=True)
model.solutions.store_to(results)
results.write(filename=join(currdir,'solve4.out'), format='json')
with open(join(currdir,"solve4.out"), 'r') as out, \
open(join(currdir,"solve1.txt"), 'r') as txt:
self.assertStructuredAlmostEqual(json.load(txt), json.load(out),
abstol=1e-4,
allow_second_superset=True)
def test_logical_constraints_transformed(self):
"""It is expected that the result of this transformation is a MI(N)LP,
so check that LogicalConstraints are handeled correctly"""
m = ConcreteModel()
m.x = Var(bounds=(0, 10))
m.d1 = Disjunct()
m.d2 = Disjunct()
m.d2.c = Constraint()
m.d = Disjunction(expr=[m.d1, m.d2])
m.another = Disjunction(expr=[[m.x == 3], [m.x == 0]])
m.Y = BooleanVar()
m.global_logical = LogicalConstraint(expr=m.Y.xor(m.d1.indicator_var))
m.d1.logical = LogicalConstraint(
expr=implies(~m.Y, m.another.disjuncts[0].indicator_var))
m.obj = Objective(expr=m.x)
m.d1.indicator_var.set_value(True)
m.d2.indicator_var.set_value(False)
m.another.disjuncts[0].indicator_var.set_value(True)
m.another.disjuncts[1].indicator_var.set_value(False)
TransformationFactory('gdp.fix_disjuncts').apply_to(m)
# Make sure there are no active LogicalConstraints
self.assertEqual(
len(
list(
m.component_data_objects(LogicalConstraint,
active=True,
descend_into=(Block, Disjunct)))),
0)
# See that it solves as expected
SolverFactory('gurobi').solve(m)
self.assertTrue(value(m.d1.indicator_var))
self.assertFalse(value(m.d2.indicator_var))
self.assertTrue(value(m.another.disjuncts[0].indicator_var))
self.assertFalse(value(m.another.disjuncts[1].indicator_var))
self.assertEqual(value(m.Y.get_associated_binary()), 0)
self.assertEqual(value(m.x), 3)
def test_pysmo_poly(branin_dataset):
m, x, y = branin_dataset
pysmo_pr_settings = {'maximum_polynomial_order':4,
'multinomials':1,
'pyomo_vars': [m.x[1], m.x[2]],
'training_split':0.9,
'number_of_crossvalidations': 5,
'additional_features_list': ['ft[0] * ft[0] * ft[1] * ft[1]', 'pyo.exp(ft[0])', 'pyo.exp(ft[1])']}
modeler = Pysmo_polyregression(**pysmo_pr_settings)
modeler.regressed_data(x, y)
modeler.build_model()
m.obj = Objective(expr=modeler._model)
m.pprint()
modeler.save_results('results.pickle', overwrite=True)
check_metrics(modeler.get_results())
return True
def test_solve_with_pickle(self):
model = ConcreteModel()
model.A = RangeSet(1, 4)
model.b = Block()
model.b.x = Var(model.A, bounds=(-1, 1))
model.b.obj = Objective(expr=sum_product(model.b.x))
model.c = Constraint(expr=model.b.x[1] >= 0)
opt = SolverFactory('glpk')
self.assertEqual(len(model.solutions), 0)
results = opt.solve(model, symbolic_solver_labels=True)
self.assertEqual(len(model.solutions), 1)
#
self.assertEqual(model.solutions[0].gap, 0.0)
#self.assertEqual(model.solutions[0].status, SolutionStatus.feasible)
self.assertEqual(model.solutions[0].message, None)
#
buf = pickle.dumps(model)
tmodel = pickle.loads(buf)
self.assertEqual(len(tmodel.solutions), 1)
self.assertEqual(tmodel.solutions[0].gap, 0.0)
#self.assertEqual(tmodel.solutions[0].status, SolutionStatus.feasible)
self.assertEqual(tmodel.solutions[0].message, None)
def __init__(self, *args, **kwargs):
"""Create the problem."""
kwargs.setdefault('name', 'DuranEx1')
super(SimpleMINLP, self).__init__(*args, **kwargs)
m = self
"""Set declarations"""
I = m.I = RangeSet(1, 4, doc="continuous variables")
J = m.J = RangeSet(1, 3, doc="discrete variables")
# initial point information for discrete variables
initY = {1: 1, 2: 0, 3: 1}
# initial point information for continuous variables
initX = {1: 0, 2: 0, 3: 0, 4: 0}
"""Variable declarations"""
# DISCRETE VARIABLES
Y = m.Y = Var(J, domain=Binary, initialize=initY)
# CONTINUOUS VARIABLES
X = m.X = Var(I, domain=NonNegativeReals, initialize=initX)
"""Constraint definitions"""
# CONSTRAINTS
m.const1 = Constraint(expr=0.8 * log(X[2] + 1) +
0.96 * log(X[1] - X[2] + 1) - 0.8 * X[3] >= 0)
m.const2 = Constraint(expr=log(X[2] + 1) + 1.2 * log(X[1] - X[2] + 1) -
X[3] - 2 * Y[3] >= -2)
m.const3 = Constraint(expr=10 * X[1] - 7 * X[3] - 18 * log(X[2] + 1) -
19.2 * log(X[1] - X[2] + 1) + 10 - X[4] <= 0)
m.const4 = Constraint(expr=X[2] - X[1] <= 0)
m.const5 = Constraint(expr=X[2] - 2 * Y[1] <= 0)
m.const6 = Constraint(expr=X[1] - X[2] - 2 * Y[2] <= 0)
m.const7 = Constraint(expr=Y[1] + Y[2] <= 1)
"""Cost (objective) function definition"""
m.cost = Objective(expr=-5 * Y[1] - 6 * Y[2] - 8 * Y[3] - X[4],
sense=maximize)
"""Bound definitions"""
# x (continuous) upper bounds
x_ubs = {1: 2, 2: 2, 3: 1, 4: 100}
for i, x_ub in iteritems(x_ubs):
X[i].setub(x_ub)
def test_clear_attribute(self):
# Test coverage of the _clear_attribute method
model = ConcreteModel()
obj = Set()
model.A = obj
self.assertEqual(model.A.local_name, "A")
self.assertEqual(obj.local_name, "A")
self.assertIs(obj, model.A)
obj = Var()
model.A = obj
self.assertEqual(model.A.local_name, "A")
self.assertEqual(obj.local_name, "A")
self.assertIs(obj, model.A)
obj = Param()
model.A = obj
self.assertEqual(model.A.local_name, "A")
self.assertEqual(obj.local_name, "A")
self.assertIs(obj, model.A)
obj = Objective()
model.A = obj
self.assertEqual(model.A.local_name, "A")
self.assertEqual(obj.local_name, "A")
self.assertIs(obj, model.A)
obj = Constraint()
model.A = obj
self.assertEqual(model.A.local_name, "A")
self.assertEqual(obj.local_name, "A")
self.assertIs(obj, model.A)
obj = Set()
model.A = obj
self.assertEqual(model.A.local_name, "A")
self.assertEqual(obj.local_name, "A")
self.assertIs(obj, model.A)
def test_solve_with_store4(self):
model = ConcreteModel()
model.A = RangeSet(1,4)
model.b = Block()
model.b.x = Var(model.A, bounds=(-1,1))
model.b.obj = Objective(expr=sum_product(model.b.x))
model.c = Constraint(expr=model.b.x[1] >= 0)
opt = SolverFactory('glpk')
results = opt.solve(model, load_solutions=False)
self.assertEqual(len(model.solutions), 0)
self.assertEqual(len(results.solution), 1)
model.solutions.load_from(results)
self.assertEqual(len(model.solutions), 1)
self.assertEqual(len(results.solution), 1)
#
model.solutions.store_to(results)
results.write(filename=join(currdir,'solve_with_store8.out'),
format='json')
with open(join(currdir,"solve_with_store8.out"), 'r') as out, \
open(join(currdir,"solve_with_store4.txt"), 'r') as txt:
self.assertStructuredAlmostEqual(yaml.full_load(txt),
yaml.full_load(out),
allow_second_superset=True)
def test_rule_option1(self):
"""Test rule option"""
model = self.create_model()
model.B = RangeSet(1,4)
def f(model, i, k):
ans=0
for j in model.B:
ans = ans + model.x[j]
ans *= i
return ans
model.x = Var(model.B, initialize=2)
model.obj = Objective(model.A,model.A, rule=f)
try:
self.assertEqual(model.obj(),None)
self.fail("Expected TypeError")
except TypeError:
pass
self.assertEqual(model.obj[1,1](), 8)
self.assertEqual(model.obj[2,1](), 16)
self.assertEqual(value(model.obj[1,1]), 8)
self.assertEqual(value(model.obj[2,1]), 16)
def test_blending(self):
""" The blending example from the PuLP documentation """
model = ConcreteModel()
model.x1 = Var(bounds=(0,None), doc="ChickenPercent")
model.x2 = Var(bounds=(0,None), doc="BeefPercent")
model.obj = Objective(expr=0.013*model.x1 + 0.008*model.x2, doc="Total Cost of Ingredients per can")
model.c0 = Constraint(expr=model.x1+model.x2 == 100.0, doc="Percentage Sum")
model.c1 = Constraint(expr=0.100*model.x1 + 0.200*model.x2 >= 8.0, doc="Protein Requirement")
model.c2 = Constraint(expr=0.080*model.x1 + 0.100*model.x2 >= 6.0, doc="Fat Requirement")
model.c3 = Constraint(expr=0.001*model.x1 + 0.005*model.x2 <= 2.0, doc="Fiber Requirement")
model.c4 = Constraint(expr=0.002*model.x1 + 0.005*model.x2 <= 0.4, doc="Salt Requirement")
opt = SolverFactory('glpk')
results = opt.solve(model)
model.solutions.store_to(results)
results.write(filename=join(currdir, "blend.out"), format='json')
with open(join(currdir,"blend.out"), 'r') as out, \
open(join(currdir,"blend.txt"), 'r') as txt:
self.assertStructuredAlmostEqual(json.load(txt), json.load(out),
abstol=1e-2,
allow_second_superset=True)
def Build_Model(model):
#******** OBJECTIVE FUNCTION *******#
model.OBJ = Objective(rule=Equations.Compute_NPC, sense=minimize)
#******** CONSTRAINTS ********#
model.ConstraintEnergyBalance = Constraint(model.TimeSteps,
rule=Equations.Balance_Energy)
model.ConstraintEquivalentLossFactorLimit = Constraint(
rule=Equations.Limit_EquivalentLossFactor)
#*** Battery-Related Constraints
model.ConstraintBatCharge = Constraint(model.TimeSteps,
rule=Equations.Update_BatCharge)
model.ConstraintBatChargeMin = Constraint(
model.TimeSteps, rule=Equations.Limit_BatChargeMin)
model.ConstraintBatChargeMax = Constraint(
model.TimeSteps, rule=Equations.Limit_BatChargeMax)
model.ConstraintMaxStorageOut = Constraint(model.TimeSteps,
rule=Equations.Limit_StorageOut)
model.ConstraintMaxStorageIn = Constraint(model.TimeSteps,
rule=Equations.Limit_StorageIn)
'''
def test_execute_TRF(self):
m = ConcreteModel()
m.z = Var(range(3), domain=Reals, initialize=2.)
m.x = Var(range(2), initialize=2.)
m.x[1] = 1.0
def blackbox(a,b):
return sin(a-b)
bb = ExternalFunction(blackbox)
m.obj = Objective(
expr=(m.z[0]-1.0)**2 + (m.z[0]-m.z[1])**2 + (m.z[2]-1.0)**2 \
+ (m.x[0]-1.0)**4 + (m.x[1]-1.0)**6 # + m.bb(m.x[0],m.x[1])
)
m.c1 = Constraint(
expr=m.x[0] * m.z[0]**2 + bb(m.x[0],m.x[1]) == 2*sqrt(2.0))
m.c2 = Constraint(expr=m.z[2]**4 * m.z[1]**2 + m.z[1] == 8+sqrt(2.0))
SolverFactory('trustregion').solve(m, [bb])
self.assertAlmostEqual(value(m.obj), 0.277044789315, places=4)
self.assertAlmostEqual(value(m.x[0]), 1.32193855369, places=4)
self.assertAlmostEqual(value(m.x[1]), 0.628744699822, places=4)
def test_keepfiles_py(self):
with SolverFactory("gams", solver_io="python") as opt:
m = ConcreteModel()
m.x = Var()
m.c = Constraint(expr=m.x >= 10)
m.o = Objective(expr=m.x)
tmpdir = mkdtemp()
results = opt.solve(m, tmpdir=tmpdir, keepfiles=True)
self.assertTrue(os.path.exists(tmpdir))
self.assertTrue(
os.path.exists(os.path.join(tmpdir, '_gams_py_gjo0.gms')))
self.assertTrue(
os.path.exists(os.path.join(tmpdir, '_gams_py_gjo0.lst')))
self.assertTrue(
os.path.exists(os.path.join(tmpdir, '_gams_py_gdb0.gdx')))
self.assertTrue(
os.path.exists(os.path.join(tmpdir, '_gams_py_gjo0.pf')))
shutil.rmtree(tmpdir)
def makeModel():
m = ConcreteModel()
m.x = Var(bounds=(0, 5))
m.y = Var(bounds=(0, 5))
def d_rule(disjunct, flag):
m = disjunct.model()
if flag:
disjunct.c1 = Constraint(expr=1 <= m.x <= 2)
disjunct.c2 = Constraint(expr=3 <= m.y <= 4)
else:
disjunct.c1 = Constraint(expr=3 <= m.x <= 4)
disjunct.c2 = Constraint(expr=1 <= m.y <= 2)
m.d = Disjunct([0, 1], rule=d_rule)
def disj_rule(m):
return [m.d[0], m.d[1]]
m.disjunction = Disjunction(rule=disj_rule)
m.obj = Objective(expr=m.x + 2 * m.y)
return m
def test_solve_linear_GDP_unbounded(self):
m = ConcreteModel()
m.GDPopt_utils = Block()
m.x = Var(bounds=(-1, 10))
m.y = Var(bounds=(2, 3))
m.z = Var()
m.d = Disjunction(expr=[[m.x + m.y >= 5], [m.x - m.y <= 3]])
m.o = Objective(expr=m.z)
m.GDPopt_utils.variable_list = [m.x, m.y, m.z]
m.GDPopt_utils.disjunct_list = [
m.d._autodisjuncts[0], m.d._autodisjuncts[1]
]
output = StringIO()
with LoggingIntercept(output, 'pyomo.contrib.gdpopt', logging.WARNING):
solver_data = GDPoptSolveData()
solver_data.timing = Container()
with time_code(solver_data.timing, 'main', is_main_timer=True):
solve_linear_GDP(
m, solver_data,
GDPoptSolver.CONFIG(dict(mip_solver=mip_solver)))
self.assertIn(
"Linear GDP was unbounded. Resolving with arbitrary bound values",
output.getvalue().strip())
def test_noscalers():
keras_folder_name = os.path.join(this_file_dir(), 'data', 'keras_models')
keras_model = load_keras_json_hd5(keras_folder_name,
'PT_data_2_10_10_2_sigmoid')
input_labels = ['Temperature_K', 'Pressure_Pa']
output_labels = ['EnthMol', 'VapFrac']
input_bounds = {'Temperature_K': (-3.0, 3.0), 'Pressure_Pa': (-3.0, 3.0)}
keras_surrogate = KerasSurrogate(keras_model=keras_model,
input_labels=input_labels,
output_labels=output_labels,
input_bounds=input_bounds)
# check solve with pyomo
x_test = pd.DataFrame({'Temperature_K': [0.5], 'Pressure_Pa': [0.5]})
y_test = keras_surrogate.evaluate_surrogate(x_test)
m = ConcreteModel()
m.obj = Objective(expr=1)
m.surrogate = SurrogateBlock()
m.surrogate.build_model(surrogate_object=keras_surrogate,
formulation=KerasSurrogate.Formulation.FULL_SPACE)
m.surrogate.inputs['Temperature_K'].fix(0.5)
m.surrogate.inputs['Pressure_Pa'].fix(0.5)
solver = SolverFactory('ipopt')
status = solver.solve(m, tee=True)
assert_optimal_termination(status)
y_test_pyomo = pd.DataFrame({
'EnthMol': [value(m.surrogate.outputs['EnthMol'])],
'VapFrac': [value(m.surrogate.outputs['VapFrac'])]
})
pd.testing.assert_frame_equal(y_test,
y_test_pyomo,
check_dtype=False,
rtol=rtol,
atol=atol)
def get_model():
# Borrowed this test model from the trust region tests
m = ConcreteModel()
m.z = Var(range(3), domain=Reals, initialize=2.)
m.x = Var(range(4), initialize=2.)
m.x[1] = 1.0
m.x[2] = 0.0
m.x[3] = None
m.b1 = Block()
m.b1.e1 = Expression(expr=m.x[0] + m.x[1])
m.b1.e2 = Expression(expr=m.x[0] / m.x[2])
m.b1.e3 = Expression(expr=m.x[3] * m.x[1])
m.b1.e4 = Expression(expr=log(m.x[2]))
m.b1.e5 = Expression(expr=log(m.x[2] - 2))
def blackbox(a, b):
return sin(a - b)
m.bb = ExternalFunction(blackbox)
m.obj = Objective(
expr=(m.z[0]-1.0)**2 + (m.z[0]-m.z[1])**2 + (m.z[2]-1.0)**2 \
+ (m.x[0]-1.0)**4 + (m.x[1]-1.0)**6 # + m.bb(m.x[0],m.x[1])
)
m.c1 = Constraint(expr=m.x[0] * m.z[0]**2 + m.bb(m.x[0], m.x[1]) == 2 *
sqrt(2.0))
m.c2 = Constraint(expr=m.z[2]**4 * m.z[1]**2 + m.z[1] == 8 + sqrt(2.0))
m.c3 = Constraint(expr=m.x[1] == 3)
m.c4 = Constraint(expr=0 == 3 / m.x[2])
m.c5 = Constraint(expr=0 == log(m.x[2]))
m.c6 = Constraint(expr=0 == log(m.x[2] - 4))
m.c7 = Constraint(expr=0 == log(m.x[3]))
m.p1 = Param(mutable=True, initialize=1)
m.c8 = Constraint(expr=m.x[1] <= 1 / m.p1)
m.p1 = 0
return m
def set_optimization_components(m, system_recovery, **kwargs):
"""
adds max_saturation_index and system_recovery_target
"""
m.fs.pump_RO.control_volume.properties_out[0].pressure.unfix()
m.fs.pump_RO.control_volume.properties_out[0].pressure.setlb(20e5)
m.fs.pump_RO.control_volume.properties_out[0].pressure.setub(75e5)
m.fs.RO.area.unfix()
m.fs.RO.area.setlb(10)
m.fs.RO.area.setub(300)
m.fs.RO.N_Re[0, 0].unfix()
# Set lower bound for water flux at the RO outlet, based on a minimum net driving pressure, NDPmin
m.fs.RO.NDPmin = Param(initialize=1e5, mutable=True, units=pyunits.Pa)
m.fs.RO.flux_mass_phase_comp[0, 1, "Liq", "H2O"].setlb(
value(m.fs.RO.A_comp[0, "H2O"] * m.fs.RO.dens_solvent *
m.fs.RO.NDPmin))
# saturation index
m.fs.max_saturation_index = Param(initialize=1.0, mutable=True)
m.fs.eq_max_saturation_index_desal = Constraint(
expr=m.fs.desal_saturation.saturation_index <=
m.fs.max_saturation_index)
m.fs.system_recovery_target = Param(initialize=system_recovery,
mutable=True)
m.fs.system_recovery_tol = Param(initialize=5e-3, mutable=True)
m.fs.eq_system_recovery = Constraint(expr=(
m.fs.system_recovery_target,
m.fs.system_recovery,
m.fs.system_recovery_target + m.fs.system_recovery_tol,
))
# set objective
m.fs.objective = Objective(expr=m.fs.costing.LCOW)
def simple_reaction_model(data):
# Create the concrete model
model = ConcreteModel()
model.x1 = Param(initialize=float(data['x1']))
model.x2 = Param(initialize=float(data['x2']))
# Rate constants
model.rxn = RangeSet(2)
initial_guess = {1: 750, 2: 1200}
model.k = Var(model.rxn, initialize=initial_guess, within=PositiveReals)
# reaction product
model.y = Expression(expr=exp(-model.k[1] *
model.x1 * exp(-model.k[2] / model.x2)))
# fix all of the regressed parameters
model.k.fix()
#===================================================================
# Stage-specific cost computations
def ComputeFirstStageCost_rule(model):
return 0
model.FirstStageCost = Expression(rule=ComputeFirstStageCost_rule)
def AllMeasurements(m):
return (float(data['y']) - m.y) ** 2
model.SecondStageCost = Expression(rule=AllMeasurements)
def total_cost_rule(m):
return m.FirstStageCost + m.SecondStageCost
model.Total_Cost_Objective = Objective(rule=total_cost_rule,
sense=minimize)
return model
