def setUp(self):
self.m = ConcreteModel()
self.m.z = Var(range(3), domain=Reals, initialize=2.)
self.m.x = Var(range(2), initialize=2.)
self.m.x[1] = 1.0
def blackbox(a, b):
return sin(a - b)
def grad_blackbox(args, fixed):
a, b = args[:2]
return [cos(a - b), -cos(a - b)]
self.m.bb = ExternalFunction(blackbox, grad_blackbox)
self.m.obj = Objective(expr=(self.m.z[0] - 1.0)**2 +
(self.m.z[0] - self.m.z[1])**2 +
(self.m.z[2] - 1.0)**2 +
(self.m.x[0] - 1.0)**4 + (self.m.x[1] - 1.0)**6)
self.m.c1 = Constraint(expr=(self.m.x[0] * self.m.z[0]**2 +
self.m.bb(self.m.x[0], self.m.x[1]) == 2 *
sqrt(2.0)))
self.m.c2 = Constraint(expr=self.m.z[2]**4 * self.m.z[1]**2 +
self.m.z[1] == 8 + sqrt(2.0))
self.config = _trf_config()
self.ext_fcn_surrogate_map_rule = lambda comp, ef: 0
self.interface = TRFInterface(self.m,
[self.m.z[0], self.m.z[1], self.m.z[2]],
self.ext_fcn_surrogate_map_rule,
self.config)
def log_fug_phase_comp_Tdew(blk, p, j, pp):
pobj = blk.params.get_phase(p)
ctype = pobj._cubic_type
cname = pobj.config.equation_of_state_options["type"].name
if pobj.is_liquid_phase():
x = blk._mole_frac_tdew
xidx = pp
elif pobj.is_vapor_phase():
x = blk.mole_frac_comp
xidx = ()
else:
raise BurntToast("{} non-vapor or liquid phase called for bubble "
"temperature calculation. This should never "
"happen, so please contact the IDAES developers "
"with this bug.".format(blk.name))
def a(k):
cobj = blk.params.get_component(k)
fw = getattr(blk, cname + "_fw")[k]
return (
EoS_param[ctype]['omegaA'] *
((Cubic.gas_constant(blk) * cobj.temperature_crit)**2 /
cobj.pressure_crit) *
((1 + fw *
(1 - sqrt(blk.temperature_dew[pp] / cobj.temperature_crit)))
**2))
kappa = getattr(blk.params, cname + "_kappa")
am = sum(
sum(x[xidx, i] * x[xidx, j] * sqrt(a(i) * a(j)) * (1 - kappa[i, j])
for j in blk.component_list) for i in blk.component_list)
b = getattr(blk, cname + "_b")
bm = sum(x[xidx, i] * b[i] for i in blk.component_list)
A = am * blk.pressure / (Cubic.gas_constant(blk) *
blk.temperature_dew[pp])**2
B = bm * blk.pressure / (Cubic.gas_constant(blk) *
blk.temperature_dew[pp])
delta = (2 * sqrt(a(j)) / am * sum(x[xidx, i] * sqrt(a(i)) *
(1 - kappa[j, i])
for i in blk.component_list))
f = getattr(blk, "_" + cname + "_ext_func_param")
if pobj.is_vapor_phase():
proc = getattr(blk, "_" + cname + "_proc_Z_vap")
elif pobj.is_liquid_phase():
proc = getattr(blk, "_" + cname + "_proc_Z_liq")
Z = proc(f, A, B)
if pobj.is_vapor_phase():
mole_frac = blk.mole_frac_comp[j]
else:
mole_frac = blk._mole_frac_tdew[pp[0], pp[1], j]
return (_log_fug_coeff_method(A, b[j], bm, B, delta, Z, ctype) +
log(mole_frac) + log(blk.pressure / blk.pressure._units))
def setUp(self):
# 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)
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))
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
self.m = m.clone()
def test_nested_disjunctions_max_binary(self):
m = models.makeNestedNonlinearModel()
SolverFactory('gdpopt').solve(m, strategy='LOA', mip_solver=mip_solver,
nlp_solver=nlp_solver,
init_strategy='max_binary')
self.assertAlmostEqual(value(m.x), sqrt(2)/2)
self.assertAlmostEqual(value(m.y), sqrt(2)/2)
def rule_heat_below_pinch(blk, p):
return (blk.QAc[p] == sum(
blk.Theta[i] * (0.5 * ((blk.Tout[i] - blk.T_[p] + DTmin) + sqrt(
(blk.Tout[i] - blk.T_[p] + DTmin)**2 + eps)) - 0.5 *
((blk.Tin[i] - blk.T_[p] + DTmin) + sqrt(
(blk.Tin[i] - blk.T_[p] + DTmin)**2 + eps)))
for i in heatingdict.keys()))
def setUp(self):
self.m = ConcreteModel()
self.m.z = Var(range(3), domain=Reals, initialize=2.)
self.m.x = Var(range(2), initialize=2.)
self.m.x[1] = 1.0
def blackbox(a, b):
return sin(a - b)
def grad_blackbox(args, fixed):
a, b = args[:2]
return [cos(a - b), -cos(a - b)]
self.m.bb = ExternalFunction(blackbox, grad_blackbox)
self.m.obj = Objective(expr=(self.m.z[0] - 1.0)**2 +
(self.m.z[0] - self.m.z[1])**2 +
(self.m.z[2] - 1.0)**2 +
(self.m.x[0] - 1.0)**4 + (self.m.x[1] - 1.0)**6)
self.m.c1 = Constraint(expr=(self.m.x[0] * self.m.z[0]**2 +
self.m.bb(self.m.x[0], self.m.x[1]) == 2 *
sqrt(2.0)))
self.m.c2 = Constraint(expr=self.m.z[2]**4 * self.m.z[1]**2 +
self.m.z[1] == 8 + sqrt(2.0))
self.decision_variables = [self.m.z[0], self.m.z[1], self.m.z[2]]
def rule_heat_above_pinch(blk, p):
return (blk.QAh[p] == sum(
blk.Theta[i] * (0.5 * ((blk.Tin[i] - blk.T_[p]) + sqrt(
(blk.Tin[i] - blk.T_[p])**2 + eps)) - 0.5 *
((blk.Tout[i] - blk.T_[p]) + sqrt(
(blk.Tout[i] - blk.T_[p])**2 + eps)))
for i in coolingdict.keys()))
def test_fix_then_solve(self):
# This is a test of the expected use case. We have a (square)
# subsystem that we can solve easily after fixing and deactivating
# certain variables and constraints.
m = _make_simple_model()
ipopt = pyo.SolverFactory("ipopt")
# Initialize to avoid converging infeasible due to bad pivots
m.v1.set_value(1.0)
m.v2.set_value(1.0)
m.v3.set_value(1.0)
m.v4.set_value(2.0)
with TemporarySubsystemManager(to_fix=[m.v3, m.v4],
to_deactivate=[m.con1]):
# Solve the subsystem with m.v1, m.v2 unfixed and
# m.con2, m.con3 inactive.
ipopt.solve(m)
# Have solved model to expected values
self.assertAlmostEqual(m.v1.value, pyo.sqrt(7.0), delta=1e-8)
self.assertAlmostEqual(m.v2.value,
pyo.sqrt(4.0 - pyo.sqrt(7.0)),
delta=1e-8)
def test_solve_subsystem(self):
# This is a test of this function's intended use. We extract a
# subsystem then solve it without altering the rest of the model.
m = _make_simple_model()
ipopt = pyo.SolverFactory("ipopt")
m.v5 = pyo.Var(initialize=1.0)
m.c4 = pyo.Constraint(expr=m.v5 == 5.0)
cons = [m.con2, m.con3]
vars = [m.v1, m.v2]
block = create_subsystem_block(cons, vars)
m.v3.fix(1.0)
m.v4.fix(2.0)
# Initialize to avoid converging infeasible due to bad pivots
m.v1.set_value(1.0)
m.v2.set_value(1.0)
ipopt.solve(block)
# Have solved model to expected values
self.assertAlmostEqual(m.v1.value, pyo.sqrt(7.0), delta=1e-8)
self.assertAlmostEqual(m.v2.value, pyo.sqrt(4.0-pyo.sqrt(7.0)),
delta=1e-8)
# Rest of model has not changed
self.assertEqual(m.v5.value, 1.0)
def add_data_match_obj(model, df_meta, bin_stdev):
@model.Expression(model.data_param.index_set())
def err_abs(b, tag):
return df_meta[tag]["reference"][0] - model.data_param[tag]
@model.Expression(model.data_param.index_set())
def err_rel(b, tag):
return model.err_abs[tag] / model.data_param[tag]
@model.Expression(model.data_param.index_set())
def err_pct(b, tag):
return model.err_rel[tag] * 100
@model.Expression(model.data_param.index_set())
def err_stdev(b, tag):
return model.err_abs[tag] / bin_stdev[model.data_bin][tag]
model.obj_weight = pyo.Param(model.data_param.index_set(),
initialize=1,
mutable=True)
n = len(model.data_param.index_set())
model.obj_datarec = pyo.Objective(expr=pyo.sqrt(
sum(model.obj_weight[t] * (model.err_stdev[t])**2
for t in model.data_param) / n))
model.obj_expr = pyo.Expression(expr=pyo.sqrt(
sum(model.obj_weight[t] * (model.err_stdev[t])**2
for t in model.data_param) / n))
def rule_delta(m, p, i):
# See pg. 145 in Properties of Gases and Liquids
a = getattr(m, cname + "_a")
am = getattr(m, cname + "_am")
kappa = getattr(m.params, cname + "_kappa")
return (2 * sqrt(a[i]) / am[p] *
sum(m.mole_frac_phase_comp[p, j] * sqrt(a[j]) *
(1 - kappa[i, j]) for j in b.components_in_phase(p)))
def test_with_solve(self):
m = _make_simple_model()
ipopt = pyo.SolverFactory("ipopt")
n_scenario = 2
input_values = ComponentMap([
(m.v3, [1.3, 2.3]),
(m.v4, [1.4, 2.4]),
])
_v1_val_1 = pyo.sqrt(3*1.4+1.3)
_v1_val_2 = pyo.sqrt(3*2.4+2.3)
_v2_val_1 = pyo.sqrt(2*1.4 - _v1_val_1)
_v2_val_2 = pyo.sqrt(2*2.4 - _v1_val_2)
output_values = ComponentMap([
(m.v1, [_v1_val_1, _v1_val_2]),
(m.v2, [_v2_val_1, _v2_val_2]),
])
to_fix = [m.v3, m.v4]
to_deactivate = [m.con1]
to_reset = [m.v1, m.v2]
# Initialize values so we don't fail due to bad initialization
m.v1.set_value(1.0)
m.v2.set_value(1.0)
with ParamSweeper(n_scenario, input_values, output_values,
to_fix=to_fix,
to_deactivate=to_deactivate,
to_reset=to_reset,
) as sweeper:
self.assertFalse(m.v1.fixed)
self.assertFalse(m.v2.fixed)
self.assertTrue(m.v3.fixed)
self.assertTrue(m.v4.fixed)
self.assertFalse(m.con1.active)
self.assertTrue(m.con2.active)
self.assertTrue(m.con3.active)
for i, (inputs, outputs) in enumerate(sweeper):
ipopt.solve(m)
for var, val in inputs.items():
# These values should not have been altered.
# I believe exact equality should be appropriate here.
self.assertEqual(var.value, val)
self.assertEqual(var.value, input_values[var][i])
for var, val in outputs.items():
self.assertAlmostEqual(var.value, val, delta=1e-8)
self.assertAlmostEqual(var.value, output_values[var][i],
delta=1e-8)
# Values have been reset after exit.
self.assertIs(m.v1.value, 1.0)
self.assertIs(m.v2.value, 1.0)
self.assertIs(m.v3.value, None)
self.assertIs(m.v4.value, None)
def rule_delta_eq(m, p1, p2, p3, i):
# See pg. 145 in Properties of Gases and Liquids
a = getattr(m, "_" + cname + "_a_eq")
am = getattr(m, "_" + cname + "_am_eq")
kappa = getattr(m.params, cname + "_kappa")
return (
2 * sqrt(a[p1, p2, i]) / am[p1, p2, p3] *
sum(m.mole_frac_phase_comp[p3, j] * sqrt(a[p1, p2, j]) *
(1 - kappa[i, j]) for j in m.components_in_phase(p3)))
def Theta_(blk, i):
if i in heatingdict.keys():
return (Q[i] / (0.5 * ((blk.Tout[i] - blk.Tin[i] +
(EpsT)) + sqrt((blk.Tout[i] - blk.Tin[i] -
(EpsT))**2 + eps))))
else:
return (Q[i] /
(-0.5 * ((-(blk.Tout[i] - blk.Tin[i]) - (-EpsT)) + sqrt((
(-EpsT) - (blk.Tout[i] - blk.Tin[i]))**2 + eps))))
def get_pyomo_model():
m = aml.ConcreteModel()
m.x = aml.Var(initialize=10.0)
m.y = aml.Var(initialize=0.0)
m.z = aml.Var(initialize=-10.0)
m.c0 = aml.Constraint(expr=aml.sqrt(m.x) >= 0)
m.c1 = aml.Constraint(expr=aml.sqrt(m.y) >= 0)
m.c2 = aml.Constraint(expr=aml.sqrt(m.z) >= 0)
m.o = aml.Objective(expr=aml.sqrt(m.x))
return m
def get_pyomo_model():
m = aml.ConcreteModel()
N = 4
NP = 100
PI_2 = 2.0 * math.atan(1.0)
X = [1.0, 0.0, 0.0, 0.5]
Y = [0.0, 1.0, -1.0, 0.0]
m.I = range(N)
m.v1 = aml.Var(initialize=-40.0)
m.w1 = aml.Var(initialize=5.0)
m.d = aml.Var(bounds=(1e-8, None), initialize=1.0)
m.a = aml.Var(bounds=(1.0, None), initialize=2.0)
m.t = aml.Var(bounds=(0.0, 6.2831852), initialize=1.5)
m.r = aml.Var(bounds=(0.39, None), initialize=0.75)
m.f = aml.Var()
m.s1 = aml.Var(bounds=(-0.99, 0.99))
m.s2 = aml.Var(bounds=(-0.99, 0.99))
def eq_1(m, i):
return ((m.v1 + m.a * m.d * aml.cos(m.t) - X[i])**2 +
(m.w1 + m.a * m.d * aml.sin(m.t) - Y[i])**2 -
(m.d + m.r)**2 <= 0)
m.eq_1 = aml.Constraint(m.I, rule=eq_1)
def eq_2(m, i):
return (m.v1 - X[i])**2 + (m.w1 - Y[i])**2 - (m.a * m.d +
m.r)**2 >= 0.0
m.eq_2 = aml.Constraint(m.I, rule=eq_2)
m.add_1 = aml.Constraint(
expr=(m.s1 == -((m.a + m.d)**2 - (m.a * m.d + m.r)**2 +
(m.d + m.r)**2) / (2 * (m.d + m.r) * m.a * m.d)))
m.add_2 = aml.Constraint(
expr=(m.s2 == ((m.a + m.d)**2 + (m.a * m.d + m.r)**2 -
(m.d + m.r)**2) / (2 * (m.a * m.d + m.r) * m.a * m.d)))
m.obj = aml.Objective(
expr=((m.d + m.r) * (m.d + m.r) *
(PI_2 - aml.atan(m.s1 / (aml.sqrt(1 - m.s1 * m.s1)))) -
(m.a * m.d + m.r) * (m.a * m.d + m.r) *
(PI_2 - aml.atan(m.s2 / (aml.sqrt(1 - m.s2 * m.s2)))) +
(m.d + m.r) * m.a * m.d *
aml.sin((PI_2 - aml.atan(m.s1 / (aml.sqrt(1 - m.s1 * m.s1)))))))
return m
def test_nested_disjunctions_set_covering(self):
# This test triggers the InfeasibleConstraintException in
# deactivate_trivial_constraints in one of the subproblem solves during
# initialization. This makes sure we get the correct answer anyway, as
# there is a feasible solution.
m = models.makeNestedNonlinearModel()
SolverFactory('gdpopt').solve(m, strategy='LOA', mip_solver=mip_solver,
nlp_solver=nlp_solver,
init_strategy='set_covering')
self.assertAlmostEqual(value(m.x), sqrt(2)/2)
self.assertAlmostEqual(value(m.y), sqrt(2)/2)
self.assertTrue(value(m.disj.disjuncts[1].indicator_var))
self.assertFalse(value(m.disj.disjuncts[0].indicator_var))
self.assertTrue(value(m.d1.indicator_var))
self.assertFalse(value(m.d2.indicator_var))
def __init__(self, *args, **kwargs):
"""Create the problem."""
kwargs.setdefault('name', 'SimpleMINLP4')
super(SimpleMINLP4, self).__init__(*args, **kwargs)
m = self
m.x = Var(domain=Reals, bounds=(1, 20), initialize=5.29)
m.y = Var(domain=Integers, bounds=(1, 20), initialize=3)
m.c1 = Constraint(expr=0.3 * (m.x - 8)**2 + 0.04 *
(m.y - 6)**4 + 0.1 * exp(2 * m.x) *
((m.y)**(-4)) <= 56)
m.c2 = Constraint(expr=1 / m.x + 1 / m.y - sqrt(m.x) * sqrt(m.y) <= -1)
m.c3 = Constraint(expr=2 * m.x - 5 * m.y <= -1)
m.obj = Objective(expr=-6 * m.x - m.y, sense=minimize)
def rule_am_default(m, cname, a, p, pp=()):
k = getattr(m.params, cname + "_kappa")
return sum(
sum(m.mole_frac_phase_comp[p, i] * m.mole_frac_phase_comp[p, j] *
sqrt(a[pp, i] * a[pp, j]) * (1 - k[i, j])
for j in m.components_in_phase(p))
for i in m.components_in_phase(p))
def entr_mol_phase_comp(blk, p, j):
pobj = blk.params.get_phase(p)
if not (pobj.is_vapor_phase() or pobj.is_liquid_phase()):
raise PropertyNotSupportedError(_invalid_phase_msg(blk.name, p))
cname = pobj._cubic_type.name
bm = getattr(blk, cname + "_bm")[p]
B = getattr(blk, cname + "_B")[p]
dadT = getattr(blk, cname + "_dadT")[p]
Z = blk.compress_fact_phase[p]
EoS_u = EoS_param[pobj._cubic_type]['u']
EoS_w = EoS_param[pobj._cubic_type]['w']
EoS_p = sqrt(EoS_u**2 - 4 * EoS_w)
# See pg. 102 in Properties of Gases and Liquids
return (((Cubic.gas_constant(blk) * safe_log(
(Z - B) / Z, eps=1e-6) * bm * EoS_p + Cubic.gas_constant(blk) *
safe_log(Z * blk.params.pressure_ref /
(blk.mole_frac_phase_comp[p, j] * blk.pressure),
eps=1e-6) * bm * EoS_p + dadT * safe_log(
(2 * Z + B * (EoS_u + EoS_p)) /
(2 * Z + B * (EoS_u - EoS_p)),
eps=1e-6)) / (bm * EoS_p)) +
get_method(blk, "entr_mol_ig_comp", j)(blk, cobj(blk, j),
blk.temperature))
def enth_mol_phase(blk, p):
pobj = blk.params.get_phase(p)
if not (pobj.is_vapor_phase() or pobj.is_liquid_phase()):
raise PropertyNotSupportedError(_invalid_phase_msg(blk.name, p))
cname = pobj._cubic_type.name
am = getattr(blk, cname + "_am")[p]
bm = getattr(blk, cname + "_bm")[p]
B = getattr(blk, cname + "_B")[p]
dadT = getattr(blk, cname + "_dadT")[p]
Z = blk.compress_fact_phase[p]
EoS_u = EoS_param[pobj._cubic_type]['u']
EoS_w = EoS_param[pobj._cubic_type]['w']
EoS_p = sqrt(EoS_u**2 - 4 * EoS_w)
# Derived from equation on pg. 120 in Properties of Gases and Liquids
return (((blk.temperature * dadT - am) * safe_log(
(2 * Z + B * (EoS_u + EoS_p)) / (2 * Z + B * (EoS_u - EoS_p)),
eps=1e-6) + Cubic.gas_constant(blk) * blk.temperature *
(Z - 1) * bm * EoS_p) / (bm * EoS_p) +
sum(blk.mole_frac_phase_comp[p, j] *
get_method(blk, "enth_mol_ig_comp", j)
(blk, cobj(blk, j), blk.temperature)
for j in blk.components_in_phase(p)))
def return_expression(blk, phase):
pobj = blk.params.get_phase(phase)
theta_ij = {}
o = dict()
for (i, j) in enumerate(blk.component_list, 1):
o[i] = j
for i in range(1, len(blk.component_list)):
for j in range(i + 1, len(blk.component_list) + 1):
theta_ij[o[i], o[j]] = (
(1 +
2*sqrt(visc_d_comp(blk, pobj, o[i]) /
visc_d_comp(blk, pobj, o[j])) *
(blk.mw_comp[o[j]]/blk.mw_comp[o[i]])**0.25 +
visc_d_comp(blk, pobj, o[i]) /
visc_d_comp(blk, pobj, o[j]) *
(blk.mw_comp[o[j]]/blk.mw_comp[o[i]])**0.5) /
(8 + 8*blk.mw_comp[o[i]]/blk.mw_comp[o[j]])**0.5)
theta_ij[o[j], o[i]] = (
visc_d_comp(blk, pobj, o[j])/visc_d_comp(blk, pobj, o[i]) *
blk.mw_comp[o[i]]/blk.mw_comp[o[j]] *
theta_ij[o[i], o[j]])
for i in blk.component_list:
for j in blk.component_list:
if i == j:
theta_ij[i, j] = 1
return sum(blk.mole_frac_comp[i]*visc_d_comp(blk, pobj, i) /
sum(blk.mole_frac_comp[j]*theta_ij[i, j]
for j in blk.component_list)
for i in blk.component_list)
def below_threshold(x, i, t, mean=True):
"""Compute the CDF of the lognormal distribution at x using an approximation of
the error function:
.. math::
erf(x) \approx \tanh(\sqrt \pi \log x)
Parameters
----------
x : numeric
threshold income
i : numeric
mean income (per capita)
t : numeric or Pyomo variable
theil coefficient
mean : bool, default: True
treat income as mean income
"""
# see
# https://math.stackexchange.com/questions/321569/approximating-the-error-function-erf-by-analytical-functions
sigma2 = 2 * t # t is var
# f(var), adjust for mean income vs. median
mu = math.log(i)
if mean:
mu -= sigma2 / 2
# f(var), argument for error function
arg = (math.log(x) - mu) / mo.sqrt(2 * sigma2)
# coefficient for erf approximation
k = math.pi**0.5 * math.log(2)
# definition of cdf with tanh(kx) approximating erf(x)
return 0.5 + 0.5 * mo.tanh(k * arg)
def enth_mol_phase(blk, p):
pobj = blk.params.get_phase(p)
cname = pobj._cubic_type.name
am = getattr(blk, cname + "_am")[p]
bm = getattr(blk, cname + "_bm")[p]
B = getattr(blk, cname + "_B")[p]
dam_dT = getattr(blk, cname + "_dam_dT")[p]
Z = blk.compress_fact_phase[p]
R = Cubic.gas_constant(blk)
T = blk.temperature
EoS_u = EoS_param[pobj._cubic_type]['u']
EoS_w = EoS_param[pobj._cubic_type]['w']
EoS_p = sqrt(EoS_u**2 - 4 * EoS_w)
enth_ideal = sum(blk.mole_frac_phase_comp[p, j] *
get_method(blk, "enth_mol_ig_comp", j)
(blk, cobj(blk, j), blk.temperature)
for j in blk.components_in_phase(p))
# Derived from equation on pg. 120 in Properties of Gases and Liquids
enth_departure = (R * T * (Z - 1) + (T * dam_dT - am) /
(bm * EoS_p) * safe_log(
(2 * Z + B * (EoS_u + EoS_p)) /
(2 * Z + B * (EoS_u - EoS_p)),
eps=eps_SL))
return enth_ideal + enth_departure
def hpool_eqn(b, t):
return (1e-4*b.hpool[t]*sqrt(pyunits.convert(
b.control_volume.properties_in[0].mw,
to_units=pyunits.g/pyunits.mol)) *
(-log10(b.reduced_pressure[t]))**(0.55) ==
1e-4*55.0*b.reduced_pressure[t]**0.12 *
b.heat_flux_conv[t]**0.67)
def entr_mol_phase(blk, p):
pobj = blk.params.get_phase(p)
cname = pobj._cubic_type.name
bm = getattr(blk, cname + "_bm")[p]
B = getattr(blk, cname + "_B")[p]
dam_dT = getattr(blk, cname + "_dam_dT")[p]
Z = blk.compress_fact_phase[p]
EoS_u = EoS_param[pobj._cubic_type]['u']
EoS_w = EoS_param[pobj._cubic_type]['w']
EoS_p = sqrt(EoS_u**2 - 4 * EoS_w)
R = Cubic.gas_constant(blk)
entr_ideal_gas = -R * safe_log(blk.pressure / blk.params.pressure_ref,
eps=eps_SL)
for j in blk.components_in_phase(p):
entr_j = get_method(blk, "entr_mol_ig_comp", j)(blk, cobj(blk, j),
blk.temperature)
xj = blk.mole_frac_phase_comp[p, j]
log_xj = blk.log_mole_frac_phase_comp[p, j]
entr_ideal_gas += xj * (entr_j - R * log_xj)
# See pg. 102 in Properties of Gases and Liquids
# or pg. 208 of Sandler, 4th Ed.
entr_departure = (R * safe_log(
(Z - B), eps=eps_SL) + dam_dT / (bm * EoS_p) * safe_log(
(2 * Z + B * (EoS_u + EoS_p)) / (2 * Z + B * (EoS_u - EoS_p)),
eps=eps_SL))
return entr_ideal_gas + entr_departure
def steam_entering_velocity(b, t):
# 1.414 = 44.72/sqrt(1000) for SI if comparing to Liese (2014)
# b.delta_enth_isentropic[t] = -(hin - hiesn), the mw converts
# enthalpy to a mass basis
return 1.414 * sqrt(
-(1 - b.blade_reaction) * b.delta_enth_isentropic[t] /
b.control_volume.properties_in[t].mw * self.eff_nozzle)
def test_sqrt_function(self):
m = ConcreteModel()
m.x = Var()
e = differentiate(sqrt(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(0.5 * m.x**-0.5))
def rule_tc(b, p):
L0 = self.config.parameters.tc_L0
L1 = self.config.parameters.tc_L1
return (sqrt(1.0 / tau) / sum(L0[i] * tau**i for i in L0) *
exp(delta[p] * sum(
(tau - 1)**i * sum(L1[i, j] * (delta[p] - 1)**j
for j in range(0, 6))
for i in range(0, 5))))
def rule_mu(b, p):
H0 = self.config.parameters.visc_H0
H1 = self.config.parameters.visc_H1
return (1e-4 * sqrt(1.0 / tau) / sum(H0[i] * tau**i for i in H0) *
exp(delta[p] * sum(
(tau - 1)**i * sum(H1[i, j] * (delta[p] - 1)**j
for j in range(0, 7))
for i in range(0, 6))))
def test_substitute_casadi_intrinsic2(self):
m = self.m
m.y = Var()
t = IndexTemplate(m.t)
e = sin(m.dv[t]) + log(m.v[t]) + sqrt(m.y) + m.v[t] + t
templatemap = {}
e3 = substitute_pyomo2casadi(e, templatemap)
self.assertIs(e3.arg(0)._fcn, casadi.sin)
self.assertIs(e3.arg(1)._fcn, casadi.log)
self.assertIs(e3.arg(2)._fcn, casadi.sqrt)
m.del_component('y')
def test_unary_expressions(self):
m = ConcreteModel()
m.x = Var()
m.y = Var()
m.z = Var()
m.a = Var()
m.b = Var()
m.c = Var()
m.d = Var()
m.c1 = Constraint(expr=0 <= sin(m.x))
m.c2 = Constraint(expr=0 <= cos(m.y))
m.c3 = Constraint(expr=0 <= tan(m.z))
m.c4 = Constraint(expr=0 <= asin(m.a))
m.c5 = Constraint(expr=0 <= acos(m.b))
m.c6 = Constraint(expr=0 <= atan(m.c))
m.c7 = Constraint(expr=0 <= sqrt(m.d))
m.o = Objective(expr=m.x)
self.assertTrue(satisfiable(m) is not False)
def test_sqrt(self):
m = pe.ConcreteModel()
m.x = pe.Var()
m.y = pe.Var()
m.c = pe.Constraint(expr=pe.sqrt(m.x) == m.y)
fbbt(m)
self.assertEqual(m.x.lb, 0)
self.assertEqual(m.x.ub, None)
self.assertEqual(m.y.lb, 0)
self.assertEqual(m.y.ub, None)
m.x.setlb(None)
m.x.setub(None)
m.y.setlb(-5)
m.y.setub(-1)
with self.assertRaises(InfeasibleConstraintException):
fbbt(m)
m.x.setlb(None)
m.x.setub(None)
m.y.setub(0)
m.y.setlb(None)
fbbt(m)
self.assertAlmostEqual(m.x.lb, 0)
self.assertAlmostEqual(m.x.ub, 0)
m.x.setlb(None)
m.x.setub(None)
m.y.setub(2)
m.y.setlb(1)
fbbt(m)
self.assertAlmostEqual(m.x.lb, 1)
self.assertAlmostEqual(m.x.ub, 4)
m.x.setlb(None)
m.x.setub(0)
m.y.setlb(None)
m.y.setub(None)
fbbt(m)
self.assertAlmostEqual(m.y.lb, 0)
self.assertAlmostEqual(m.y.ub, 0)
