def test_costing_FH_solve():
m = pyo.ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.get_costing()
m.fs.costing.CE_index = 550 # for testing only
m.fs.unit = pyo.Block()
m.fs.unit.heat_duty = pyo.Var(initialize=1e6,
units=pyo.units.BTU / pyo.units.hr)
m.fs.unit.pressure = pyo.Var(initialize=1e5, units=pyo.units.psi)
m.fs.unit.costing = pyo.Block()
m.fs.unit.heat_duty.fix(18390000) # Btu/hr
m.fs.unit.pressure.fix(700) # psig
cs.fired_heater_costing(m.fs.unit.costing,
fired_type='fuel',
Mat_factor='stain_steel',
ref_parameter_pressure=m.fs.unit.pressure,
ref_parameter_heat_duty=m.fs.unit.heat_duty)
assert degrees_of_freedom(m) == 0
# Check unit config arguments
assert isinstance(m.fs.unit.costing.purchase_cost, pyo.Var)
assert isinstance(m.fs.unit.costing.base_cost_per_unit, pyo.Var)
# initialize costing block
costing.initialize(m.fs.unit.costing)
assert (pytest.approx(pyo.value(m.fs.unit.costing.purchase_cost),
abs=1e-2) == 962795.521)
results = solver.solve(m, tee=False)
# Check for optimal solution
assert results.solver.termination_condition == \
pyo.TerminationCondition.optimal
assert results.solver.status == pyo.SolverStatus.ok
assert (pytest.approx(pyo.value(m.fs.unit.costing.purchase_cost),
abs=1e-2) == 962795.521) # Example 22.1 Ref Book
def test_stochastic_objective(self):
m = aml.ConcreteModel()
self._populate_block_with_objectives(m)
m.b = aml.Block()
self._populate_block_with_objectives(m.b)
m.b_inactive = aml.Block()
self._populate_block_with_objectives(m.b_inactive)
m.b_inactive.deactivate()
m.B = aml.Block([1],
rule=lambda b: \
self._populate_block_with_objectives(b))
a = StochasticObjectiveAnnotation()
self.assertEqual(a.default, (None, True))
self.assertEqual(a.has_declarations, False)
a.declare(m.o)
self.assertEqual(a.has_declarations, True)
a.declare(m.O1)
a.declare(m.O2[1])
a.declare(m.b)
a.declare(m.b_inactive)
a.declare(m.B, variables=1, include_constant=False)
with self.assertRaises(TypeError):
a.declare(None, 1)
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries()]),
set([('o', (None,True)), ('O1[1]', (None,True)), ('O2[1]', (None,True)),
('b.o', (None,True)), ('b.O1[1]', (None,True)), ('b.O2[1]', (None,True)),
('B[1].o', (1,False)), ('B[1].O1[1]', (1,False)), ('B[1].O2[1]', (1,False))]))
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries(expand_containers=False)]),
set([('o', (None,True)), ('O1', (None,True)), ('O2[1]', (None,True)),
('b.o', (None,True)), ('b.O1', (None,True)), ('b.O2', (None,True)),
('B[1].o', (1,False)), ('B[1].O1', (1,False)), ('B[1].O2', (1,False))]))
def setUp(self):
m = pe.ConcreteModel()
m.x = pe.Var(bounds=(0.5, 1.5))
m.y = pe.Var()
m.c1 = pe.Constraint(expr=m.y == m.x)
m.r1 = coramin.relaxations.PWUnivariateRelaxation()
m.r1.set_input(x=m.x,
aux_var=m.y,
shape=coramin.utils.FunctionShape.CONCAVE,
f_x_expr=pe.log(m.x))
m.r1.add_partition_point(value=1)
m.r1.rebuild()
m.b1 = pe.Block()
m.b1.x = pe.Var(bounds=(0.5, 1.5))
m.b1.y = pe.Var()
m.b1.c1 = pe.Constraint(expr=m.b1.y == m.b1.x)
m.b1.r1 = coramin.relaxations.PWUnivariateRelaxation()
m.b1.r1.set_input(x=m.b1.x,
aux_var=m.b1.y,
shape=coramin.utils.FunctionShape.CONCAVE,
f_x_expr=pe.log(m.b1.x))
m.b1.r1.add_partition_point(value=1)
m.b1.r1.rebuild()
m.b1.b1 = pe.Block()
self.m = m
def add_blocks(self, TIMEs, TIMEp, decisionrule="continuous", **kwargs):
stn = self.stn
m = self.model
available_rules = ["continuous", "integer"]
assert decisionrule in available_rules, ("Unknown decision rule %s" %
decisionrule)
# scheduling and planning block
m.sb = pyomo.Block()
m.pb = pyomo.Block()
self.sb = blockSchedulingRobust(stn,
np.array([t for t in TIMEs]),
self.Demand,
decisionrule=decisionrule,
prfx=self.prfx,
**kwargs)
self.sb.define_block(m.sb, decisionrule=decisionrule, **kwargs)
self.pb = blockPlanningRobust(stn,
np.array([t for t in TIMEp]),
self.Demand,
decisionrule=decisionrule,
prfx=self.prfx,
**kwargs)
self.pb.define_block(m.pb, decisionrule=decisionrule, **kwargs)
def _create_pyomo_model(self, repn):
#
# Create Pyomo model
#
M = pe.ConcreteModel()
M.U = pe.Block()
M.L = pe.Block()
M.dual = pe.Block()
# upper- and lower-level variables
pyomo_util._create_variables(repn.U, M.U)
pyomo_util._create_variables(repn.L, M.L)
M.dual.z = pe.Var()
# upper- and lower-level constraints
pyomo_util.add_linear_constraints(M.U, repn.U.A, repn.U, repn.L,
repn.U.b, M.U.inequalities)
pyomo_util.add_linear_constraints(M.L, repn.L.A, repn.U, repn.L,
repn.L.b, M.L.inequalities)
# objective
e = pyomo_util.dot(repn.U.c.U, repn.U, num=1) + pyomo_util.dot(
repn.U.c.L, repn.L, num=1) + repn.U.d
M.o = pe.Objective(expr=e)
# dual variables for primal constraints
M.Dual.dual_c = Var(range(len(M.L.c)))
# duality gap
e = pyomo_util._linear_expression(1, repn.c.L, repn.L)
M.lower_gap = Constraint(expr=e[0] == M.z)
return M
def test_costing_distillation_solve():
m = pyo.ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.get_costing()
m.fs.costing.CE_index = 550
# create a unit model and variables
m.fs.unit = pyo.Block()
m.fs.unit.heat_duty = pyo.Var(initialize=1e6)
m.fs.unit.pressure = pyo.Var(initialize=1e5)
m.fs.unit.diameter = pyo.Var(initialize=10,
domain=pyo.NonNegativeReals,
doc='unit diameter in m')
m.fs.unit.length = pyo.Var(initialize=10,
domain=pyo.NonNegativeReals,
doc='unit length in m')
# create costing block
m.fs.unit.costing = pyo.Block()
cs.vessel_costing(m.fs.unit.costing,
alignment='vertical',
weight_limit='option2',
L_D_range='option2',
PL=True,
plates=True,
number_tray=100,
ref_parameter_diameter=m.fs.unit.diameter,
ref_parameter_length=m.fs.unit.length)
# pressure design and shell thickness from Example 22.13 Product and
# Process Design Principless
m.fs.unit.heat_duty.fix(18390000) # Btu/hr
m.fs.unit.pressure.fix(123) # psig
# pressure design minimum thickness tp = 0.582 in
# vessel is vertical + quite tall the tower is subject to wind load,
# and earthquake. Assume wall thickness of 1.25 in.
# The additional wall thickness at the bottom of the tower is 0.889 in
# average thickness is 1.027, plus corrosion allowance of 1/8
# 1.152 in, therefore steel plate thickness is 1.250 (ts)
m.fs.unit.costing.shell_thickness = 1.250 # inches
m.fs.unit.diameter.fix(10) # ft
m.fs.unit.length.fix(212) # ft
m.fs.unit.costing.number_trays = 100
assert degrees_of_freedom(m) == 0
# Check unit config arguments
assert isinstance(m.fs.unit.costing.purchase_cost, pyo.Var)
assert isinstance(m.fs.unit.costing.base_cost, pyo.Var)
results = solver.solve(m, tee=False)
# Check for optimal solution
assert results.solver.termination_condition == \
pyo.TerminationCondition.optimal
assert results.solver.status == pyo.SolverStatus.ok
assert (pytest.approx(pyo.value(m.fs.unit.costing.base_cost),
abs=1e-2) == 636959.6929) # Example 22.13 Ref Book
assert (pytest.approx(pyo.value(m.fs.unit.costing.base_cost_platf_ladders),
abs=1e-2) == 97542.9005) # Example 22.13 Ref Book
assert (pytest.approx(pyo.value(m.fs.unit.costing.purchase_cost_trays),
abs=1e-2) == 293006.086) # Example 22.13 Ref Book
assert (pytest.approx(pyo.value(m.fs.unit.costing.purchase_cost),
abs=1e-2) == 1100958.9396) # Example 22.13 Ref Book
def test_stochastic_variable_bounds(self):
m = aml.ConcreteModel()
self._populate_block_with_vars(m)
m.b = aml.Block()
self._populate_block_with_vars(m.b)
m.b_inactive = aml.Block()
self._populate_block_with_vars(m.b_inactive)
m.b_inactive.deactivate()
m.B = aml.Block([1],
rule=lambda b: \
self._populate_block_with_vars(b))
a = StochasticVariableBoundsAnnotation()
self.assertEqual(a.default, (True, True))
self.assertEqual(a.has_declarations, False)
a.declare(m.x)
self.assertEqual(a.has_declarations, True)
a.declare(m.X1)
a.declare(m.X2[1])
a.declare(m.b)
a.declare(m.b_inactive)
a.declare(m.B, lb=False, ub=True)
with self.assertRaises(TypeError):
a.declare(None, 1)
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries()]),
set([('x', (True,True)), ('X1[1]', (True,True)), ('X2[1]', (True,True)),
('b.x', (True,True)), ('b.X1[1]', (True,True)), ('b.X2[1]', (True,True)),
('B[1].x', (False,True)), ('B[1].X1[1]', (False,True)), ('B[1].X2[1]', (False,True))]))
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries(expand_containers=False)]),
set([('x', (True,True)), ('X1', (True,True)), ('X2[1]', (True,True)),
('b.x', (True,True)), ('b.X1', (True,True)), ('b.X2', (True,True)),
('B[1].x', (False,True)), ('B[1].X1', (False,True)), ('B[1].X2', (False,True))]))
def test_stochastic_data(self):
m = pyo.ConcreteModel()
self._populate_block_with_params(m)
m.b = pyo.Block()
self._populate_block_with_params(m.b)
m.b_inactive = pyo.Block()
self._populate_block_with_params(m.b_inactive)
m.b_inactive.deactivate()
m.B = pyo.Block([1],
rule=lambda b: \
self._populate_block_with_params(b))
a = StochasticDataAnnotation()
self.assertEqual(a.default, None)
self.assertEqual(a.has_declarations, False)
a.declare(m.p, 1)
self.assertEqual(a.has_declarations, True)
a.declare(m.P1, 1)
a.declare(m.P2[1], 1)
a.declare(m.b, 1)
a.declare(m.b_inactive, 1)
a.declare(m.B, 2)
with self.assertRaises(TypeError):
a.declare(None, 1)
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries()]),
set([('p', 1), ('P1[1]', 1), ('P2[1]', 1), ('b.p', 1),
('b.P1[1]', 1), ('b.P2[1]', 1), ('B[1].p', 2),
('B[1].P1[1]', 2), ('B[1].P2[1]', 2)]))
self.assertEqual(
set([(v[0].name, v[1])
for v in a.expand_entries(expand_containers=False)]),
set([('p', 1), ('P1', 1), ('P2[1]', 1), ('b.p', 1), ('b.P1', 1),
('b.P2', 1), ('B[1].p', 2), ('B[1].P1', 2), ('B[1].P2', 2)]))
def test_stochastic_constraint_body(self):
m = aml.ConcreteModel()
self._populate_block_with_constraints(m)
m.b = aml.Block()
self._populate_block_with_constraints(m.b)
m.b_inactive = aml.Block()
self._populate_block_with_constraints(m.b_inactive)
m.b_inactive.deactivate()
m.B = aml.Block([1],
rule=lambda b: \
self._populate_block_with_constraints(b))
a = StochasticConstraintBodyAnnotation()
self.assertEqual(a.default, None)
self.assertEqual(a.has_declarations, False)
a.declare(m.c)
self.assertEqual(a.has_declarations, True)
a.declare(m.C1)
a.declare(m.C2[1])
a.declare(m.C3)
a.declare(m.b)
a.declare(m.b_inactive)
a.declare(m.B, variables=2)
with self.assertRaises(TypeError):
a.declare(None, 1)
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries()]),
set([('c', None), ('C1[1]', None), ('C2[1]', None), ('C3[1]', None),
('b.c', None), ('b.C1[1]', None), ('b.C2[1]', None), ('b.C3[1]', None),
('B[1].c', 2), ('B[1].C1[1]', 2), ('B[1].C2[1]', 2), ('B[1].C3[1]', 2)]))
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries(expand_containers=False)]),
set([('c', None), ('C1', None), ('C2[1]', None), ('C3', None),
('b.c', None), ('b.C1', None), ('b.C2', None), ('b.C3', None),
('B[1].c', 2), ('B[1].C1', 2), ('B[1].C2', 2), ('B[1].C3', 2)]))
def test_units1_costing(build_costing):
m = build_costing
# Accounts with Feedwater Flow to HP section of HRSG, as the
# reference/scaling parameter - Exhibit 5-15
FW_accounts = ['3.1', '3.3', '8.4']
# Accounts with Raw water withdrawal as the reference/scaling parameter
# Exhibit 5-14
RW_withdraw_accounts = ['3.2', '3.4', '3.5', '9.5', '14.6']
m.fs.b2 = pyo.Block()
m.fs.b2.raw_water_withdrawal = pyo.Var(initialize=2902) # gpm
m.fs.b2.raw_water_withdrawal.fix()
get_PP_costing(m.fs.b2, RW_withdraw_accounts, m.fs.b2.raw_water_withdrawal,
'gpm', 6)
# Accounts with fuel gas flowrate as the reference/scaling parameter
# Exhibit 5-15 stream 2, Exhibit 5-8
FuelG_accounts = ['3.6', '3.9', '6.1', '6.3', '6.4']
m.fs.b3 = pyo.Block()
# Obtain Fuel gas flowrate in acm
fuelgas_value = 205630 # lb/hr
m.fs.b3.fg_flowrate = pyo.Var(initialize=fuelgas_value) # lb/hr
m.fs.b3.fg_flowrate.fix()
get_PP_costing(m.fs.b3, FuelG_accounts, m.fs.b3.fg_flowrate, 'lb/hr', 6)
# Accounts with process water discharge as the reference/scaling parameter
# Exhibit 5-14
PW_discharge_accounts = ['3.7']
m.fs.b4 = pyo.Block()
m.fs.b4.process_water_discharge = pyo.Var(initialize=657) # gpm
m.fs.b4.process_water_discharge.fix()
get_PP_costing(m.fs.b4, PW_discharge_accounts,
m.fs.b4.process_water_discharge, 'gpm', 6)
# Initialize costing
costing_initialization(m.fs)
assert degrees_of_freedom(m) == 0
# Solve the model
results = solver.solve(m, tee=True)
assert pyo.check_optimal_termination(results)
# Accounts with raw water withdrawal as reference parameter
assert pytest.approx(26.435, abs=0.5) \
== sum(pyo.value(m.fs.b2.costing.total_plant_cost[ac])
for ac in RW_withdraw_accounts)
# Accounts with fuel gas as reference parameter
assert pytest.approx(158.415, abs=0.5) \
== sum(pyo.value(m.fs.b3.costing.total_plant_cost[ac])
for ac in FuelG_accounts)
# Accounts with process water discharge as reference parameter
assert pytest.approx(11.608, abs=0.5) \
== sum(pyo.value(m.fs.b4.costing.total_plant_cost[ac])
for ac in PW_discharge_accounts)
def test_8():
# Test replace indexed by indexed var that doesn't have enough/right indexes
rp = pyo.TransformationFactory("replace_variables")
m = pyo.ConcreteModel()
m.b1 = pyo.Block()
m.b1.b2 = pyo.Block()
x = m.b1.b2.x = pyo.Var(["a", "b", "c"], [1,2,3], initialize=2)
m.y = pyo.Var(["a", "b", "d"], [1,2,3], initialize=3)
with pytest.raises(ValueError):
rp.apply_to(m, substitute=[(x, m.y)])
def test_variable_stage(self):
m = pyo.ConcreteModel()
self._populate_block_with_vars_expressions(m)
m.b = pyo.Block()
self._populate_block_with_vars_expressions(m.b)
m.b_inactive = pyo.Block()
self._populate_block_with_vars_expressions(m.b_inactive)
m.b_inactive.deactivate()
m.B = pyo.Block([1],
rule=lambda b: \
self._populate_block_with_vars_expressions(b))
a = VariableStageAnnotation()
self.assertEqual(a.default, None)
self.assertEqual(a.has_declarations, False)
a.declare(m.x, 1)
self.assertEqual(a.has_declarations, True)
a.declare(m.X1, 1)
a.declare(m.X2[1], 1)
a.declare(m.e, 1)
a.declare(m.E1, 1)
a.declare(m.E2[1], 1)
with self.assertRaises(TypeError):
a.declare(m.b, None)
a.declare(m.b, 1)
a.declare(m.b_inactive, 1)
a.declare(m.B, 2, derived=True)
with self.assertRaises(TypeError):
a.declare(None, 1)
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries()]),
set([('x', (1, False)), ('X1[1]', (1, False)),
('X2[1]', (1, False)), ('e', (1, False)),
('E1[1]', (1, False)), ('E2[1]', (1, False)),
('b.x', (1, False)), ('b.X1[1]', (1, False)),
('b.X2[1]', (1, False)), ('b.e', (1, False)),
('b.E1[1]', (1, False)), ('b.E2[1]', (1, False)),
('B[1].x', (2, True)), ('B[1].X1[1]', (2, True)),
('B[1].X2[1]', (2, True)), ('B[1].e', (2, True)),
('B[1].E1[1]', (2, True)), ('B[1].E2[1]', (2, True))]))
self.assertEqual(
set([(v[0].name, v[1])
for v in a.expand_entries(expand_containers=False)]),
set([('x', (1, False)), ('X1', (1, False)), ('X2[1]', (1, False)),
('e', (1, False)), ('E1', (1, False)), ('E2[1]', (1, False)),
('b.x', (1, False)), ('b.X1', (1, False)),
('b.X2', (1, False)), ('b.e', (1, False)),
('b.E1', (1, False)), ('b.E2', (1, False)),
('B[1].x', (2, True)), ('B[1].X1', (2, True)),
('B[1].X2', (2, True)), ('B[1].e', (2, True)),
('B[1].E1', (2, True)), ('B[1].E2', (2, True))]))
def test_cos(self):
m = pyo.Block(concrete=True)
m.x = pyo.Var(bounds=(0, math.pi))
m.c = pyo.Constraint(expr=pyo.inequality(body=pyo.cos(m.x), lower=-0.5, upper=0.5))
self.tightener(m)
self.assertAlmostEqual(pyo.value(m.x.lb), math.acos(0.5))
self.assertAlmostEqual(pyo.value(m.x.ub), math.acos(-0.5))
m = pyo.Block(concrete=True)
m.x = pyo.Var()
m.c = pyo.Constraint(expr=pyo.inequality(body=pyo.cos(m.x), lower=-0.5, upper=0.5))
self.tightener(m)
self.assertEqual(m.x.lb, None)
self.assertEqual(m.x.ub, None)
def test_6():
# Test non-variable exception
rp = pyo.TransformationFactory("replace_variables")
m = pyo.ConcreteModel()
m.b1 = pyo.Block()
m.b1.b2 = pyo.Block()
x = m.b1.b2.x = pyo.Var(["a", "b", "c"], [1,2,3], initialize=2)
m.y = pyo.Var(["a", "b", "c", "d"], [1,2,3], initialize=3)
m.z = pyo.Var(initialize=0)
with pytest.raises(TypeError):
rp.apply_to(m, substitute=[(x, m.b1)])
with pytest.raises(TypeError):
rp.apply_to(m, substitute=[(m.b1, x)])
def test_tan(self):
m = pe.Block(concrete=True)
m.x = pe.Var(bounds=(-math.pi/2, math.pi/2))
m.c = pe.Constraint(expr=pe.inequality(body=pe.tan(m.x), lower=-0.5, upper=0.5))
fbbt(m)
self.assertAlmostEqual(pe.value(m.x.lb), math.atan(-0.5))
self.assertAlmostEqual(pe.value(m.x.ub), math.atan(0.5))
m = pe.Block(concrete=True)
m.x = pe.Var()
m.c = pe.Constraint(expr=pe.inequality(body=pe.tan(m.x), lower=-0.5, upper=0.5))
fbbt(m)
self.assertEqual(m.x.lb, None)
self.assertEqual(m.x.ub, None)
def test_7():
# Test replace indexed by non-indexed
rp = pyo.TransformationFactory("replace_variables")
m = pyo.ConcreteModel()
m.b1 = pyo.Block()
m.b1.b2 = pyo.Block()
x = m.b1.b2.x = pyo.Var(["a", "b", "c"], [1,2,3], initialize=2)
m.y = pyo.Var(["a", "b", "c", "d"], [1,2,3], initialize=3)
m.z = pyo.Var(initialize=0)
assert x.is_indexed()
assert not m.z.is_indexed()
with pytest.raises(TypeError):
rp.apply_to(m, substitute=[(x, m.z)])
def test_rename_components(self):
model = pyo.ConcreteModel()
model.x = pyo.Var([1, 2, 3], bounds=(-10, 10), initialize=5.0)
model.z = pyo.Var(bounds=(10, 20))
model.obj = pyo.Objective(expr=model.z + model.x[1])
def con_rule(m, i):
return m.x[i] + m.z == i
model.con = pyo.Constraint([1, 2, 3], rule=con_rule)
model.zcon = pyo.Constraint(expr=model.z >= model.x[2])
model.b = pyo.Block()
model.b.bx = pyo.Var([1, 2, 3], initialize=42)
model.b.bz = pyo.Var(initialize=42)
c_list = list(
model.component_objects(
ctype=[pyo.Var, pyo.Constraint, pyo.Objective]))
name_map = rename_components(model=model,
component_list=c_list,
prefix='scaled_')
self.assertEqual(name_map[model.scaled_obj], 'obj')
self.assertEqual(name_map[model.scaled_x], 'x')
self.assertEqual(name_map[model.scaled_con], 'con')
self.assertEqual(name_map[model.scaled_zcon], 'zcon')
self.assertEqual(name_map[model.b.scaled_bz], 'b.bz')
self.assertEqual(model.scaled_obj.name, 'scaled_obj')
self.assertEqual(model.scaled_x.name, 'scaled_x')
self.assertEqual(model.scaled_con.name, 'scaled_con')
self.assertEqual(model.scaled_zcon.name, 'scaled_zcon')
self.assertEqual(model.b.name, 'b')
self.assertEqual(model.b.scaled_bz.name, 'b.scaled_bz')
def test_pow2(self):
x_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
c_bounds = [(-2.5, 2.8), (0.5, 2.8), (0, 2.8), (1, 2.8), (0.5, 1)]
for xl, xu in x_bounds:
for cl, cu in c_bounds:
m = pe.Block(concrete=True)
m.x = pe.Var(bounds=(xl, xu))
m.y = pe.Var()
m.c = pe.Constraint(
expr=pe.inequality(body=m.y**m.x, lower=cl, upper=cu))
fbbt(m)
x = np.linspace(pe.value(m.x.lb) + 1e-6,
pe.value(m.x.ub),
100,
endpoint=False)
z = np.linspace(pe.value(m.c.lower) + 1e-6,
pe.value(m.c.upper),
100,
endpoint=False)
if m.y.lb is None:
yl = -np.inf
else:
yl = m.y.lb
if m.y.ub is None:
yu = np.inf
else:
yu = m.y.ub
for _x in x:
_y = np.exp(np.log(abs(z)) / _x)
self.assertTrue(np.all(yl <= _y))
self.assertTrue(np.all(yu >= _y))
def test_ASU_costing():
# Create a Concrete Model as the top level object
m = pyo.ConcreteModel()
# Add a flowsheet object to the model
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.get_costing(year='2017')
m.fs.ASU = pyo.Block()
m.fs.ASU.O2_flow = pyo.Var()
m.fs.ASU.O2_flow.fix(13078) # TPD
get_ASU_cost(m.fs.ASU, m.fs.ASU.O2_flow)
# try solving
solver = get_solver()
results = solver.solve(m, tee=True)
assert results.solver.termination_condition == \
pyo.TerminationCondition.optimal
m.fs.ASU.costing.bare_erected_cost.display()
assert pytest.approx(pyo.value(m.fs.ASU.costing.bare_erected_cost),
abs=1) == 3.2675e6 / 1e3
return m
def test_sub1(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
x_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
c_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
for xl, xu in x_bounds:
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var(bounds=(xl, xu))
m.y = pyo.Var()
m.c = pyo.Constraint(
expr=pyo.inequality(body=m.x - m.y, lower=cl, upper=cu))
self.tightener(m)
x = np.linspace(pyo.value(m.x.lb), pyo.value(m.x.ub), 100)
z = np.linspace(pyo.value(m.c.lower), pyo.value(m.c.upper),
100)
if m.y.lb is None:
yl = -np.inf
else:
yl = m.y.lb
if m.y.ub is None:
yu = np.inf
else:
yu = m.y.ub
for _x in x:
_y = _x - z
self.assertTrue(np.all(yl <= _y))
self.assertTrue(np.all(yu >= _y))
def test_sub2(self):
x_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
c_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
for xl, xu in x_bounds:
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var(bounds=(xl, xu))
m.y = pyo.Var()
m.c = pyo.Constraint(
expr=pyo.inequality(body=m.y - m.x, lower=cl, upper=cu))
fbbt(m)
x = np.linspace(pyo.value(m.x.lb), pyo.value(m.x.ub), 100)
z = np.linspace(pyo.value(m.c.lower), pyo.value(m.c.upper),
100)
if m.y.lb is None:
yl = -np.inf
else:
yl = m.y.lb
if m.y.ub is None:
yu = np.inf
else:
yu = m.y.ub
for _x in x:
_y = z + _x
self.assertTrue(np.all(yl <= _y))
self.assertTrue(np.all(yu >= _y))
def test_asin(self):
m = pe.Block(concrete=True)
m.x = pe.Var()
m.c = pe.Constraint(expr=pe.inequality(body=pe.asin(m.x), lower=-0.5, upper=0.5))
fbbt(m)
self.assertAlmostEqual(pe.value(m.x.lb), math.sin(-0.5))
self.assertAlmostEqual(pe.value(m.x.ub), math.sin(0.5))
def reconstruct_envelopes(self):
self.del_component('lin_cuts')
self.lin_cuts = pe.Block()
for unit in itervalues(self.units):
unit.reconstruct_envelopes()
self.apply_linear_relaxations(nsegs=self._lin_cuts_nsegs,
recurse=False)
def test_exp(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
c_bounds = [(-2.5, 2.8), (0.5, 2.8), (0, 2.8), (1, 2.8), (0.5, 1)]
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var()
m.c = pyo.Constraint(
expr=pyo.inequality(body=pyo.exp(m.x), lower=cl, upper=cu))
self.tightener(m)
if pyo.value(m.c.lower) <= 0:
_cl = 1e-6
else:
_cl = pyo.value(m.c.lower)
z = np.linspace(_cl, pyo.value(m.c.upper), 100)
if m.x.lb is None:
xl = -np.inf
else:
xl = pyo.value(m.x.lb)
if m.x.ub is None:
xu = np.inf
else:
xu = pyo.value(m.x.ub)
x = np.log(z)
self.assertTrue(np.all(xl <= x))
self.assertTrue(np.all(xu >= x))
def test_find_badly_scaled_vars():
m = pyo.ConcreteModel()
m.x = pyo.Var(initialize=1e6)
m.y = pyo.Var(initialize=1e-8)
m.z = pyo.Var(initialize=1e-20)
m.b = pyo.Block()
m.b.w = pyo.Var(initialize=1e10)
a = [id(v) for v, sv in sc.badly_scaled_var_generator(m)]
assert id(m.x) in a
assert id(m.y) in a
assert id(m.b.w) in a
assert id(m.z) not in a
m.scaling_factor = pyo.Suffix(direction=pyo.Suffix.EXPORT)
m.b.scaling_factor = pyo.Suffix(direction=pyo.Suffix.EXPORT)
m.scaling_factor[m.x] = 1e-6
m.scaling_factor[m.y] = 1e6
m.scaling_factor[m.z] = 1
m.b.scaling_factor[m.b.w] = 1e-5
a = [id(v) for v, sv in sc.badly_scaled_var_generator(m)]
assert id(m.x) not in a
assert id(m.y) not in a
assert id(m.b.w) in a
assert id(m.z) not in a
def test_add(self):
x_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
c_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
for xl, xu in x_bounds:
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var(bounds=(xl, xu))
m.y = pyo.Var()
m.p = pyo.Param(mutable=True)
m.p.value = 1
m.c = pyo.Constraint(expr=pyo.inequality(
body=m.x + m.y + (m.p + 1), lower=cl, upper=cu))
new_bounds = fbbt(m)
self.assertEqual(new_bounds[m.x],
(pyo.value(m.x.lb), pyo.value(m.x.ub)))
self.assertEqual(new_bounds[m.y],
(pyo.value(m.y.lb), pyo.value(m.y.ub)))
x = np.linspace(pyo.value(m.x.lb), pyo.value(m.x.ub), 100)
z = np.linspace(pyo.value(m.c.lower), pyo.value(m.c.upper),
100)
if m.y.lb is None:
yl = -np.inf
else:
yl = m.y.lb
if m.y.ub is None:
yu = np.inf
else:
yu = m.y.ub
for _x in x:
_y = z - _x - m.p.value - 1
self.assertTrue(np.all(yl <= _y))
self.assertTrue(np.all(yu >= _y))
def test_pow4(self):
y_bounds = [(0.5, 2.8), (0, 2.8), (1, 2.8), (0.5, 1), (0, 0.5)]
exp_vals = [-3, -2.5, -2, -1.5, -1, -0.5, 0.5, 1, 1.5, 2, 2.5, 3]
for yl, yu in y_bounds:
for _exp_val in exp_vals:
m = pyo.Block(concrete=True)
m.x = pyo.Var()
m.y = pyo.Var(bounds=(yl, yu))
m.c = pyo.Constraint(expr=m.x**_exp_val == m.y)
fbbt(m)
y = np.linspace(pyo.value(m.y.lb) + 1e-6,
pyo.value(m.y.ub),
100,
endpoint=True)
if m.x.lb is None:
xl = -np.inf
else:
xl = m.x.lb
if m.x.ub is None:
xu = np.inf
else:
xu = m.x.ub
_x = np.exp(np.log(y) / _exp_val)
self.assertTrue(np.all(xl <= _x))
self.assertTrue(np.all(xu >= _x))
def test_acos(self):
m = pe.Block(concrete=True)
m.x = pe.Var()
m.c = pe.Constraint(expr=pe.inequality(body=pe.acos(m.x), lower=1, upper=2))
fbbt(m)
self.assertAlmostEqual(pe.value(m.x.lb), math.cos(2))
self.assertAlmostEqual(pe.value(m.x.ub), math.cos(1))
def model(self):
m = pyo.ConcreteModel()
m.fs = fs = pyo.Block()
fs.input = pyo.Var(['a', 'b'], within=pyo.UnitInterval, initialize=0.5)
fs.output = pyo.Var(['c', 'd'],
within=pyo.UnitInterval,
initialize=0.5)
fs.slack = pyo.Var(['ab_slack', 'cd_slack'],
bounds=(0, 0),
initialize=0.0)
fs.slack_penalty = pyo.Param(default=1000.,
mutable=True,
within=pyo.PositiveReals)
fs.ab_constr = pyo.Constraint(
expr=(fs.output['c'] + fs.slack['ab_slack'] == 2 * fs.input['a']))
fs.cd_constr = pyo.Constraint(
expr=(fs.output['d'] + fs.slack['cd_slack'] == 3 * fs.input['b']))
fs.performance = pyo.Expression(expr=pyo.summation(fs.output))
m.objective = pyo.Objective(
expr=m.fs.performance -
m.fs.slack_penalty * pyo.summation(m.fs.slack),
sense=pyo.maximize)
return m
def test_log10(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
c_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var()
m.c = pyo.Constraint(
expr=pyo.inequality(body=pyo.log10(m.x), lower=cl, upper=cu))
self.tightener(m)
z = np.linspace(pyo.value(m.c.lower), pyo.value(m.c.upper), 100)
if m.x.lb is None:
xl = -np.inf
else:
xl = pyo.value(m.x.lb)
if m.x.ub is None:
xu = np.inf
else:
xu = pyo.value(m.x.ub)
x = 10**z
print(xl, xu, cl, cu)
print(x)
self.assertTrue(np.all(xl <= x))
self.assertTrue(np.all(xu >= x))
