def test_solution_carbonic_acid(self, carbonic_acid_model):
model = carbonic_acid_model
pH = -log10(value(model.fs.unit.control_volume.properties_out[0.0].act_phase_comp["Liq","H_+"])*55.2)
pOH = -log10(value(model.fs.unit.control_volume.properties_out[0.0].act_phase_comp["Liq","OH_-"])*55.2)
assert pytest.approx(8.28, rel=1e-2) == pH
assert pytest.approx(5.72, rel=1e-2) == pOH
assert pytest.approx(14.00, rel=1e-2) == pH + pOH
gamma = {}
for index in model.fs.unit.control_volume.properties_out[0.0].conc_mol_phase_comp:
gamma[index] = value(model.fs.unit.control_volume.properties_out[0.0].act_phase_comp[index])/value(model.fs.unit.outlet.mole_frac_comp[0,index[1]])
assert pytest.approx(0.95075, rel=1e-5) == gamma[('Liq', 'OH_-')]
assert pytest.approx(0.95075, rel=1e-5) == gamma[('Liq', 'H_+')]
assert pytest.approx(0.95075, rel=1e-5) == gamma[('Liq', 'Na_+')]
assert pytest.approx(0.95075, rel=1e-5) == gamma[('Liq', 'HCO3_-')]
assert pytest.approx(0.81710, rel=1e-5) == gamma[('Liq', 'CO3_2-')]
assert pytest.approx(1.00000, rel=1e-5) == gamma[('Liq', 'H2O')]
assert pytest.approx(1.00000, rel=1e-5) == gamma[('Liq', 'H2CO3')]
total_acid = value(model.fs.unit.control_volume.properties_out[0.0].conc_mol_phase_comp["Liq","H2CO3"])/1000
total_acid += value(model.fs.unit.control_volume.properties_out[0.0].conc_mol_phase_comp["Liq","HCO3_-"])/1000
total_acid += value(model.fs.unit.control_volume.properties_out[0.0].conc_mol_phase_comp["Liq","CO3_2-"])/1000
assert pytest.approx(0.002061178349769601, rel=1e-5) == total_acid
def test_solution(self, model_solve):
model, _ = model_solve
assert pytest.approx(298, rel=1e-5) == value(
model.fs.unit.outlet.temperature[0])
assert pytest.approx(10, rel=1e-5) == value(
model.fs.unit.outlet.flow_mol[0])
assert pytest.approx(101325, rel=1e-5) == value(
model.fs.unit.outlet.pressure[0])
total_molar_density = (
value(model.fs.unit.control_volume.properties_out[0.0].
dens_mol_phase["Liq"]) / 1000)
assert pytest.approx(55.2336, rel=1e-5) == total_molar_density
pH = -value(
log10(model.fs.unit.outlet.mole_frac_comp[0, "H_+"] *
total_molar_density))
pOH = -value(
log10(model.fs.unit.outlet.mole_frac_comp[0, "OH_-"] *
total_molar_density))
assert pytest.approx(6.9997414, rel=1e-5) == pH
assert pytest.approx(6.9997414, rel=1e-5) == pOH
assert pytest.approx(0.99999, rel=1e-5) == value(
model.fs.unit.outlet.mole_frac_comp[0.0, "H2O"])
def test_solution_equilibrium(self, equilibrium_config):
model = equilibrium_config
assert pytest.approx(298.2, rel=1e-4) == value(
model.fs.unit.outlet.temperature[0])
assert pytest.approx(101325, rel=1e-4) == value(
model.fs.unit.outlet.pressure[0])
total_molar_density = (
value(model.fs.unit.control_volume.properties_out[0.0].
dens_mol_phase["Liq"]) / 1000)
assert pytest.approx(55.165246, rel=1e-4) == total_molar_density
pH = -value(
log10(
value(model.fs.unit.control_volume.properties_out[0.0].
mole_frac_phase_comp["Liq", "H_+"]) *
total_molar_density))
pOH = -value(
log10(
value(model.fs.unit.control_volume.properties_out[0.0].
mole_frac_phase_comp["Liq", "OH_-"]) *
total_molar_density))
assert pytest.approx(5.339891, rel=1e-4) == pH
assert pytest.approx(8.660655, rel=1e-4) == pOH
CO2_sorbed = value(model.fs.unit.control_volume.properties_out[0.0].
conc_mol_phase_comp[("Liq", "CO2")])
assert pytest.approx(27.531571, rel=1e-4) == CO2_sorbed
def test_intrinsic_functions5(self):
m = ConcreteModel()
m.x = Var()
e = differentiate(log10(log10(m.x)), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(m.x**-1.0 * (1.0/log(10)) * log(m.x)**-1.0))
def test_solution_water(self, water_model):
model = water_model
pH = -log10(value(model.fs.unit.control_volume.properties_out[0.0].act_phase_comp["Liq","H_+"])*55.2)
pOH = -log10(value(model.fs.unit.control_volume.properties_out[0.0].act_phase_comp["Liq","OH_-"])*55.2)
assert pytest.approx(7.0001611, rel=1e-4) == pH
assert pytest.approx(7.0001611, rel=1e-4) == pOH
def test_solution_equilibrium(self, equilibrium_reactions_config):
model = equilibrium_reactions_config
assert pytest.approx(297.9, rel=1e-5) == value(
model.fs.unit.outlet.temperature[0])
assert pytest.approx(10.0002, rel=1e-5) == value(
model.fs.unit.outlet.flow_mol[0])
assert pytest.approx(101325, rel=1e-5) == value(
model.fs.unit.outlet.pressure[0])
total_molar_density = \
value(model.fs.unit.control_volume.properties_out[0.0].dens_mol_phase['Liq'])/1000
assert pytest.approx(54.612040964248116,
rel=1e-5) == total_molar_density
total_salt = value(model.fs.unit.outlet.mole_frac_comp[
0, "Na_+"]) * total_molar_density * 23
total_salt += value(model.fs.unit.outlet.mole_frac_comp[
0, "Cl_-"]) * total_molar_density * 35.44
total_salt += value(model.fs.unit.outlet.mole_frac_comp[
0, "NaHCO3"]) * total_molar_density * 84
psu = total_salt / (total_molar_density * 18) * 1000
assert pytest.approx(32.66105, rel=1e-5) == psu
total_carbonate = value(model.fs.unit.outlet.mole_frac_comp[
0, "NaHCO3"]) * total_molar_density
total_carbonate += value(
model.fs.unit.outlet.mole_frac_comp[0,
"H2CO3"]) * total_molar_density
total_carbonate += value(model.fs.unit.outlet.mole_frac_comp[
0, "HCO3_-"]) * total_molar_density
total_carbonate += value(model.fs.unit.outlet.mole_frac_comp[
0, "CO3_2-"]) * total_molar_density
assert pytest.approx(0.0020528746175810923,
rel=1e-5) == total_carbonate
carbonate_alk = value(model.fs.unit.outlet.mole_frac_comp[
0, "HCO3_-"]) * total_molar_density
carbonate_alk += 2 * value(model.fs.unit.outlet.mole_frac_comp[
0, "CO3_2-"]) * total_molar_density
carbonate_alk += value(
model.fs.unit.outlet.mole_frac_comp[0,
"OH_-"]) * total_molar_density
carbonate_alk -= value(
model.fs.unit.outlet.mole_frac_comp[0,
"H_+"]) * total_molar_density
carbonate_alk = carbonate_alk * 50000
assert pytest.approx(79.389737, rel=1e-4) == carbonate_alk
pH = -value(
log10(model.fs.unit.outlet.mole_frac_comp[0, "H_+"] *
total_molar_density))
pOH = -value(
log10(model.fs.unit.outlet.mole_frac_comp[0, "OH_-"] *
total_molar_density))
assert pytest.approx(8.31763834, rel=1e-4) == pH
assert pytest.approx(5.6916662, rel=1e-4) == pOH
def display_results_of_chlorination_unit(unit):
print()
print("=========== Chlorination Results ============")
print("Outlet Temperature: \t" +
str(unit.outlet.temperature[0].value))
print("Outlet Pressure: \t" + str(unit.outlet.pressure[0].value))
print("Outlet FlowMole: \t" + str(unit.outlet.flow_mol[0].value))
print()
total_molar_density = \
value(unit.control_volume.properties_out[0.0].dens_mol_phase['Liq'])/1000
pH = -value(
log10(unit.outlet.mole_frac_comp[0, "H_+"] * total_molar_density))
print("pH at Outlet: \t" + str(pH))
total_salt = value(
unit.outlet.mole_frac_comp[0, "Na_+"]) * total_molar_density * 23
total_salt += value(
unit.outlet.mole_frac_comp[0, "Cl_-"]) * total_molar_density * 35.4
psu = total_salt / (total_molar_density * 18) * 1000
print("Salinity (PSU): \t" + str(psu))
print("Free Chlorine (mg/L): \t" + str(unit.free_chlorine.value))
print("\tDistribution:")
hocl = (value(unit.control_volume.properties_out[0.0].conc_mol_phase_comp[
"Liq", "HOCl"]) / 1000) / (unit.free_chlorine.value / 70900)
print("\t % HOCl: \t" + str(hocl * 100))
ocl = (value(unit.control_volume.properties_out[0.0].conc_mol_phase_comp[
"Liq", "OCl_-"]) / 1000) / (unit.free_chlorine.value / 70900)
print("\t % OCl-: \t" + str(ocl * 100))
print("-------------------------------------------")
print()
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))
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 _relax_leaf_to_root_log10(node, values, aux_var_map, degree_map, parent_block, relaxation_side_map, counter):
arg = values[0]
degree = degree_map[arg]
if degree == 0:
res = pe.exp(arg)
degree_map[res] = 0
return res
elif (id(arg), 'log10') in aux_var_map:
_aux_var, relaxation = aux_var_map[id(arg), 'log10']
relaxation_side = relaxation_side_map[node]
if relaxation_side != relaxation.relaxation_side:
relaxation.relaxation_side = RelaxationSide.BOTH
degree_map[_aux_var] = 1
return _aux_var
else:
_aux_var = _get_aux_var(parent_block, pe.log10(arg))
arg = replace_sub_expression_with_aux_var(arg, parent_block)
relaxation_side = relaxation_side_map[node]
degree_map[_aux_var] = 1
relaxation = PWUnivariateRelaxation()
relaxation.set_input(x=arg, aux_var=_aux_var, relaxation_side=relaxation_side, f_x_expr=pe.log10(arg),
shape=FunctionShape.CONCAVE)
aux_var_map[id(arg), 'log10'] = (_aux_var, relaxation)
setattr(parent_block.relaxations, 'rel'+str(counter), relaxation)
counter.increment()
return _aux_var
def test_log10(self):
m = pyo.ConcreteModel()
m.x = pyo.Var(initialize=2.0)
e = pyo.log10(m.x)
derivs = reverse_ad(e)
symbolic = reverse_sd(e)
self.assertAlmostEqual(derivs[m.x], pyo.value(symbolic[m.x]), tol + 3)
self.assertAlmostEqual(derivs[m.x], approx_deriv(e, m.x), tol)
def _eval(node):
name = _tag_name(node)
cs = list(node)
if name == 'negate':
assert len(cs) == 1
return -_eval(cs[0])
elif name == 'number':
return float(node.attrib['value'])
elif name == 'variable':
c = float(node.attrib.get('coef', 1))
return c * self._v(int(node.attrib['idx']))
elif name == 'power':
assert len(cs) == 2
b = _eval(cs[0])
e = _eval(cs[1])
return b**e
elif name == 'square':
assert len(cs) == 1
return _eval(cs[0])**2
elif name == 'sqrt':
assert len(cs) == 1
return aml.sqrt(_eval(cs[0]))
elif name == 'product':
return reduce(op.mul, [_eval(c) for c in cs])
elif name == 'divide':
assert len(cs) == 2
return _eval(cs[0]) / _eval(cs[1])
elif name == 'times':
assert len(cs) == 2
return _eval(cs[0]) * _eval(cs[1])
elif name == 'plus':
assert len(cs) == 2
return _eval(cs[0]) + _eval(cs[1])
elif name == 'sum':
return sum([_eval(c) for c in cs])
elif name == 'minus':
assert len(cs) == 2
return _eval(cs[0]) - _eval(cs[1])
elif name == 'abs':
assert len(cs) == 1
return abs(_eval(cs[0]))
elif name == 'exp':
assert len(cs) == 1
return aml.exp(_eval(cs[0]))
elif name == 'ln':
assert len(cs) == 1
return aml.log(_eval(cs[0]))
elif name == 'sin':
assert len(cs) == 1
return aml.sin(_eval(cs[0]))
elif name == 'cos':
assert len(cs) == 1
return aml.cos(_eval(cs[0]))
elif name == 'log10':
assert len(cs) == 1
return aml.log10(_eval(cs[0]))
raise RuntimeError('unhandled tag {}'.format(name))
def test_solution(self, chlorination_obj):
model = chlorination_obj
assert pytest.approx(300.002, rel=1e-5) == value(
model.fs.unit.outlet.temperature[0])
assert pytest.approx(10.0000, rel=1e-5) == value(
model.fs.unit.outlet.flow_mol[0])
assert pytest.approx(101325.0, rel=1e-5) == value(
model.fs.unit.outlet.pressure[0])
total_molar_density = (
value(model.fs.unit.control_volume.properties_out[0.0].
dens_mol_phase["Liq"]) / 1000)
assert pytest.approx(55.2044, rel=1e-5) == total_molar_density
pH = -value(
log10(model.fs.unit.outlet.mole_frac_comp[0, "H_+"] *
total_molar_density))
pOH = -value(
log10(model.fs.unit.outlet.mole_frac_comp[0, "OH_-"] *
total_molar_density))
assert pytest.approx(6.0522001, rel=1e-4) == pH
assert pytest.approx(7.9476201, rel=1e-4) == pOH
hypo_remaining = (
value(model.fs.unit.control_volume.properties_out[0.0].
conc_mol_phase_comp["Liq", "HOCl"]) / 1000)
hypo_remaining += (
value(model.fs.unit.control_volume.properties_out[0.0].
conc_mol_phase_comp["Liq", "OCl_-"]) / 1000)
combined_chlorine = 0
combined_chlorine += (
value(model.fs.unit.control_volume.properties_out[0.0].
conc_mol_phase_comp["Liq", "NH2Cl"]) / 1000)
combined_chlorine += (
2 * value(model.fs.unit.control_volume.properties_out[0.0].
conc_mol_phase_comp["Liq", "NHCl2"]) / 1000)
combined_chlorine += (
3 * value(model.fs.unit.control_volume.properties_out[0.0].
conc_mol_phase_comp["Liq", "NCl3"]) / 1000)
hypo_remaining = hypo_remaining * 70900
combined_chlorine = combined_chlorine * 70900
assert pytest.approx(2.50902829, rel=1e-3) == hypo_remaining
assert pytest.approx(12.607332, rel=1e-3) == combined_chlorine
def compute_constants(m):
for i in m.LINK:
m.lam[i] = (2.0*aml.log10(3.7*m.ldiam[i]/(m.eps*m.dfac)))**(-2.0)
m.A[i] = (1.0/4.0)*m.pi*m.ldiam[i]*m.ldiam[i]
m.nu2 = m.gam*m.z*m.R*m.Tgas/m.M
m.c1[i] = (m.pfac2/m.ffac2)*(m.nu2/m.A[i])
m.c2[i] = m.A[i]*(m.ffac2/m.pfac2)
m.c3[i] = m.A[i]*(m.pfac2/m.ffac2)*(8.0*m.lam[i]*m.nu2)/(m.pi*m.pi*(m.ldiam[i]**5.0))
m.c4 = (1/m.ffac2)*(m.Cp*m.Tgas)
def _darcy_weisbach(m, t):
epsilon = 0.005 # pipe roughness factor
d = 2 * m.R # diameter in m
v_flow = m.q[t] * 1e18 * 16 / (1000 * 157.77) # volumetric flow rate in m3/day
u = v_flow / (3.14159 * m.R ** 2) # mean flow velocity in m/day
re = m.rho * u * d / m.mu / 1e6 # Reynold's number
""" Darcy friction factor, predicted by the Swamee-Jain equation """
f = 0.25 / (po.log10(epsilon / (d * 3.7) + 5.74 / (re ** 0.9))) ** 2
return (m.p[t] - m.p_vac) / m.L == f * m.rho / 2 * u ** 2 / d
def test_check_expr_eval_py(self):
with SolverFactory("gams", solver_io="python") as opt:
m = ConcreteModel()
m.x = Var()
m.e = Expression(expr=log10(m.x) + 5)
m.c = Constraint(expr=m.x >= 10)
m.o = Objective(expr=m.e)
self.assertRaises(GamsExceptionExecution, opt.solve, m)
def test_check_expr_eval_gms(self):
with SolverFactory("gams", solver_io="gms") as opt:
m = ConcreteModel()
m.x = Var()
m.e = Expression(expr=log10(m.x) + 5)
m.c = Constraint(expr=m.x >= 10)
m.o = Objective(expr=m.e)
self.assertRaises(ValueError, opt.solve, m)
def test_log10(self):
# Tests the special transformation for log10
with SolverFactory("baron") as opt:
m = ConcreteModel()
m.x = Var()
m.c = Constraint(expr=log10(m.x) >= 2)
m.obj = Objective(expr=m.x, sense=minimize)
results = opt.solve(m)
self.assertEqual(results.solver.termination_condition,
TerminationCondition.optimal)
def test_log10(self):
# Tests the special transformation for log10
with SolverFactory("baron") as opt:
m = ConcreteModel()
m.x = Var()
m.c = Constraint(expr=log10(m.x) >= 2)
m.obj = Objective(expr=m.x, sense=minimize)
results = opt.solve(m)
self.assertEqual(results.solver.termination_condition,
TerminationCondition.optimal)
def test_solution_equilibrium(self, equilibrium_reactions_config):
model = equilibrium_reactions_config
assert pytest.approx(298, rel=1e-3) == value(
model.fs.unit.outlet.temperature[0])
assert pytest.approx(10, rel=1e-3) == value(
model.fs.unit.outlet.flow_mol[0])
assert pytest.approx(101325, rel=1e-3) == value(
model.fs.unit.outlet.pressure[0])
total_molar_density = \
value(model.fs.unit.control_volume.properties_out[0.0].dens_mol_phase['Liq'])/1000
assert pytest.approx(55.2336, rel=1e-3) == total_molar_density
pH = -value(
log10(model.fs.unit.outlet.mole_frac_comp[0, "H_+"] *
total_molar_density))
pOH = -value(
log10(model.fs.unit.outlet.mole_frac_comp[0, "OH_-"] *
total_molar_density))
assert pytest.approx(7, rel=1e-3) == pH
assert pytest.approx(7, rel=1e-3) == pOH
assert pytest.approx(0.9999, rel=1e-3) == value(
model.fs.unit.outlet.mole_frac_comp[0.0, 'H2O'])
def test_log10(self):
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 = pe.Block(concrete=True)
m.x = pe.Var()
m.c = pe.Constraint(
expr=pe.inequality(body=pe.log10(m.x), lower=cl, upper=cu))
fbbt(m)
z = np.linspace(pe.value(m.c.lower), pe.value(m.c.upper), 100)
if m.x.lb is None:
xl = -np.inf
else:
xl = pe.value(m.x.lb)
if m.x.ub is None:
xu = np.inf
else:
xu = pe.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))
def h_in_eqn(b, t):
return b.h_in[t] == 2178.6*(b.control_volume.properties_out[t].pressure/2.2048e7)**0.36\
/(-log10(b.control_volume.properties_out[t].pressure/2.2048e7))**1.65 *\
(0.1+(b.control_volume.properties_out[t].temperature-b.T[t,b.r.first()])**2)*b.frac_wet_area[t]
def test_get_check_units_on_all_expressions(self):
# this method is going to test all the expression types that should work
# to be defensive, we will also test that we actually have the expected expression type
# therefore, if the expression system changes and we get a different expression type,
# we will know we need to change these tests
uc = units
kg = uc.kg
m = uc.m
model = ConcreteModel()
model.x = Var()
model.y = Var()
model.z = Var()
model.p = Param(initialize=42.0, mutable=True)
model.xkg = Var(units=kg)
model.ym = Var(units=m)
# test equality
self._get_check_units_ok(3.0*kg == 1.0*kg, uc, 'kg', EXPR.EqualityExpression)
self._get_check_units_fail(3.0*kg == 2.0*m, uc, EXPR.EqualityExpression)
# test inequality
self._get_check_units_ok(3.0*kg <= 1.0*kg, uc, 'kg', EXPR.InequalityExpression)
self._get_check_units_fail(3.0*kg <= 2.0*m, uc, EXPR.InequalityExpression)
self._get_check_units_ok(3.0*kg >= 1.0*kg, uc, 'kg', EXPR.InequalityExpression)
self._get_check_units_fail(3.0*kg >= 2.0*m, uc, EXPR.InequalityExpression)
# test RangedExpression
self._get_check_units_ok(inequality(3.0*kg, 4.0*kg, 5.0*kg), uc, 'kg', EXPR.RangedExpression)
self._get_check_units_fail(inequality(3.0*m, 4.0*kg, 5.0*kg), uc, EXPR.RangedExpression)
self._get_check_units_fail(inequality(3.0*kg, 4.0*m, 5.0*kg), uc, EXPR.RangedExpression)
self._get_check_units_fail(inequality(3.0*kg, 4.0*kg, 5.0*m), uc, EXPR.RangedExpression)
# test SumExpression, NPV_SumExpression
self._get_check_units_ok(3.0*model.x*kg + 1.0*model.y*kg + 3.65*model.z*kg, uc, 'kg', EXPR.SumExpression)
self._get_check_units_fail(3.0*model.x*kg + 1.0*model.y*m + 3.65*model.z*kg, uc, EXPR.SumExpression)
self._get_check_units_ok(3.0*kg + 1.0*kg + 2.0*kg, uc, 'kg', EXPR.NPV_SumExpression)
self._get_check_units_fail(3.0*kg + 1.0*kg + 2.0*m, uc, EXPR.NPV_SumExpression)
# test ProductExpression, NPV_ProductExpression
self._get_check_units_ok(model.x*kg * model.y*m, uc, 'kg*m', EXPR.ProductExpression)
self._get_check_units_ok(3.0*kg * 1.0*m, uc, 'kg*m', EXPR.NPV_ProductExpression)
self._get_check_units_ok(3.0*kg*m, uc, 'kg*m', EXPR.NPV_ProductExpression)
# I don't think that there are combinations that can "fail" for products
# test MonomialTermExpression
self._get_check_units_ok(model.x*kg, uc, 'kg', EXPR.MonomialTermExpression)
# test DivisionExpression, NPV_DivisionExpression
self._get_check_units_ok(1.0/(model.x*kg), uc, '1/kg', EXPR.DivisionExpression)
self._get_check_units_ok(2.0/kg, uc, '1/kg', EXPR.NPV_DivisionExpression)
self._get_check_units_ok((model.x*kg)/1.0, uc, 'kg', EXPR.MonomialTermExpression)
self._get_check_units_ok(kg/2.0, uc, 'kg', EXPR.NPV_DivisionExpression)
self._get_check_units_ok(model.y*m/(model.x*kg), uc, 'm/kg', EXPR.DivisionExpression)
self._get_check_units_ok(m/kg, uc, 'm/kg', EXPR.NPV_DivisionExpression)
# I don't think that there are combinations that can "fail" for products
# test PowExpression, NPV_PowExpression
# ToDo: fix the str representation to combine the powers or the expression system
self._get_check_units_ok((model.x*kg**2)**3, uc, 'kg**6', EXPR.PowExpression) # would want this to be kg**6
self._get_check_units_fail(kg**model.x, uc, EXPR.PowExpression, UnitsError)
self._get_check_units_fail(model.x**kg, uc, EXPR.PowExpression, UnitsError)
self._get_check_units_ok(kg**2, uc, 'kg**2', EXPR.NPV_PowExpression)
self._get_check_units_fail(3.0**kg, uc, EXPR.NPV_PowExpression, UnitsError)
# test NegationExpression, NPV_NegationExpression
self._get_check_units_ok(-(kg*model.x*model.y), uc, 'kg', EXPR.NegationExpression)
self._get_check_units_ok(-kg, uc, 'kg', EXPR.NPV_NegationExpression)
# don't think there are combinations that fan "fail" for negation
# test AbsExpression, NPV_AbsExpression
self._get_check_units_ok(abs(kg*model.x), uc, 'kg', EXPR.AbsExpression)
self._get_check_units_ok(abs(kg), uc, 'kg', EXPR.NPV_AbsExpression)
# don't think there are combinations that fan "fail" for abs
# test the different UnaryFunctionExpression / NPV_UnaryFunctionExpression types
# log
self._get_check_units_ok(log(3.0*model.x), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(log(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(log(3.0*model.p), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(log(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# log10
self._get_check_units_ok(log10(3.0*model.x), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(log10(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(log10(3.0*model.p), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(log10(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# sin
self._get_check_units_ok(sin(3.0*model.x*uc.radians), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(sin(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_fail(sin(3.0*kg*model.x*uc.kg), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(sin(3.0*model.p*uc.radians), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(sin(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# cos
self._get_check_units_ok(cos(3.0*model.x*uc.radians), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(cos(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_fail(cos(3.0*kg*model.x*uc.kg), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(cos(3.0*model.p*uc.radians), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(cos(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# tan
self._get_check_units_ok(tan(3.0*model.x*uc.radians), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(tan(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_fail(tan(3.0*kg*model.x*uc.kg), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(tan(3.0*model.p*uc.radians), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(tan(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# sin
self._get_check_units_ok(sinh(3.0*model.x*uc.radians), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(sinh(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_fail(sinh(3.0*kg*model.x*uc.kg), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(sinh(3.0*model.p*uc.radians), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(sinh(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# cos
self._get_check_units_ok(cosh(3.0*model.x*uc.radians), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(cosh(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_fail(cosh(3.0*kg*model.x*uc.kg), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(cosh(3.0*model.p*uc.radians), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(cosh(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# tan
self._get_check_units_ok(tanh(3.0*model.x*uc.radians), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(tanh(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_fail(tanh(3.0*kg*model.x*uc.kg), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(tanh(3.0*model.p*uc.radians), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(tanh(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# asin
self._get_check_units_ok(asin(3.0*model.x), uc, 'rad', EXPR.UnaryFunctionExpression)
self._get_check_units_fail(asin(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(asin(3.0*model.p), uc, 'rad', EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(asin(3.0*model.p*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# acos
self._get_check_units_ok(acos(3.0*model.x), uc, 'rad', EXPR.UnaryFunctionExpression)
self._get_check_units_fail(acos(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(acos(3.0*model.p), uc, 'rad', EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(acos(3.0*model.p*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# atan
self._get_check_units_ok(atan(3.0*model.x), uc, 'rad', EXPR.UnaryFunctionExpression)
self._get_check_units_fail(atan(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(atan(3.0*model.p), uc, 'rad', EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(atan(3.0*model.p*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# exp
self._get_check_units_ok(exp(3.0*model.x), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_fail(exp(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(exp(3.0*model.p), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(exp(3.0*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# sqrt
self._get_check_units_ok(sqrt(3.0*model.x), uc, None, EXPR.UnaryFunctionExpression)
self._get_check_units_ok(sqrt(3.0*model.x*kg**2), uc, 'kg', EXPR.UnaryFunctionExpression)
self._get_check_units_ok(sqrt(3.0*model.x*kg), uc, 'kg**0.5', EXPR.UnaryFunctionExpression)
self._get_check_units_ok(sqrt(3.0*model.p), uc, None, EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_ok(sqrt(3.0*model.p*kg**2), uc, 'kg', EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_ok(sqrt(3.0*model.p*kg), uc, 'kg**0.5', EXPR.NPV_UnaryFunctionExpression)
# asinh
self._get_check_units_ok(asinh(3.0*model.x), uc, 'rad', EXPR.UnaryFunctionExpression)
self._get_check_units_fail(asinh(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(asinh(3.0*model.p), uc, 'rad', EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(asinh(3.0*model.p*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# acosh
self._get_check_units_ok(acosh(3.0*model.x), uc, 'rad', EXPR.UnaryFunctionExpression)
self._get_check_units_fail(acosh(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(acosh(3.0*model.p), uc, 'rad', EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(acosh(3.0*model.p*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# atanh
self._get_check_units_ok(atanh(3.0*model.x), uc, 'rad', EXPR.UnaryFunctionExpression)
self._get_check_units_fail(atanh(3.0*kg*model.x), uc, EXPR.UnaryFunctionExpression, UnitsError)
self._get_check_units_ok(atanh(3.0*model.p), uc, 'rad', EXPR.NPV_UnaryFunctionExpression)
self._get_check_units_fail(atanh(3.0*model.p*kg), uc, EXPR.NPV_UnaryFunctionExpression, UnitsError)
# ceil
self._get_check_units_ok(ceil(kg*model.x), uc, 'kg', EXPR.UnaryFunctionExpression)
self._get_check_units_ok(ceil(kg), uc, 'kg', EXPR.NPV_UnaryFunctionExpression)
# don't think there are combinations that fan "fail" for ceil
# floor
self._get_check_units_ok(floor(kg*model.x), uc, 'kg', EXPR.UnaryFunctionExpression)
self._get_check_units_ok(floor(kg), uc, 'kg', EXPR.NPV_UnaryFunctionExpression)
# don't think there are combinations that fan "fail" for floor
# test Expr_ifExpression
# consistent if, consistent then/else
self._get_check_units_ok(EXPR.Expr_if(IF=model.x*kg + kg >= 2.0*kg, THEN=model.x*kg, ELSE=model.y*kg),
uc, 'kg', EXPR.Expr_ifExpression)
# unitless if, consistent then/else
self._get_check_units_ok(EXPR.Expr_if(IF=model.x >= 2.0, THEN=model.x*kg, ELSE=model.y*kg),
uc, 'kg', EXPR.Expr_ifExpression)
# consistent if, unitless then/else
self._get_check_units_ok(EXPR.Expr_if(IF=model.x*kg + kg >= 2.0*kg, THEN=model.x, ELSE=model.x),
uc, None, EXPR.Expr_ifExpression)
# inconsistent then/else
self._get_check_units_fail(EXPR.Expr_if(IF=model.x >= 2.0, THEN=model.x*m, ELSE=model.y*kg),
uc, EXPR.Expr_ifExpression)
# inconsistent then/else NPV
self._get_check_units_fail(EXPR.Expr_if(IF=model.x >= 2.0, THEN=model.p*m, ELSE=model.p*kg),
uc, EXPR.Expr_ifExpression)
# inconsistent then/else NPV units only
self._get_check_units_fail(EXPR.Expr_if(IF=model.x >= 2.0, THEN=m, ELSE=kg),
uc, EXPR.Expr_ifExpression)
# test EXPR.IndexTemplate and GetItemExpression
model.S = Set()
i = EXPR.IndexTemplate(model.S)
j = EXPR.IndexTemplate(model.S)
self._get_check_units_ok(i, uc, None, EXPR.IndexTemplate)
model.mat = Var(model.S, model.S)
self._get_check_units_ok(model.mat[i,j+1], uc, None, EXPR.GetItemExpression)
# test ExternalFunctionExpression, NPV_ExternalFunctionExpression
model.ef = ExternalFunction(python_callback_function)
self._get_check_units_ok(model.ef(model.x, model.y), uc, None, EXPR.ExternalFunctionExpression)
self._get_check_units_ok(model.ef(1.0, 2.0), uc, None, EXPR.NPV_ExternalFunctionExpression)
self._get_check_units_fail(model.ef(model.x*kg, model.y), uc, EXPR.ExternalFunctionExpression, UnitsError)
self._get_check_units_fail(model.ef(2.0*kg, 1.0), uc, EXPR.NPV_ExternalFunctionExpression, UnitsError)
# test ExternalFunctionExpression, NPV_ExternalFunctionExpression
model.ef2 = ExternalFunction(python_callback_function, units=uc.kg)
self._get_check_units_ok(model.ef2(model.x, model.y), uc, 'kg', EXPR.ExternalFunctionExpression)
self._get_check_units_ok(model.ef2(1.0, 2.0), uc, 'kg', EXPR.NPV_ExternalFunctionExpression)
self._get_check_units_fail(model.ef2(model.x*kg, model.y), uc, EXPR.ExternalFunctionExpression, UnitsError)
self._get_check_units_fail(model.ef2(2.0*kg, 1.0), uc, EXPR.NPV_ExternalFunctionExpression, UnitsError)
# test ExternalFunctionExpression, NPV_ExternalFunctionExpression
model.ef3 = ExternalFunction(python_callback_function, units=uc.kg, arg_units=[uc.kg, uc.m])
self._get_check_units_fail(model.ef3(model.x, model.y), uc, EXPR.ExternalFunctionExpression)
self._get_check_units_fail(model.ef3(1.0, 2.0), uc, EXPR.NPV_ExternalFunctionExpression)
self._get_check_units_fail(model.ef3(model.x*kg, model.y), uc, EXPR.ExternalFunctionExpression, UnitsError)
self._get_check_units_fail(model.ef3(2.0*kg, 1.0), uc, EXPR.NPV_ExternalFunctionExpression, UnitsError)
self._get_check_units_ok(model.ef3(2.0*kg, 1.0*uc.m), uc, 'kg', EXPR.NPV_ExternalFunctionExpression)
self._get_check_units_ok(model.ef3(model.x*kg, model.y*m), uc, 'kg', EXPR.ExternalFunctionExpression)
self._get_check_units_ok(model.ef3(model.xkg, model.ym), uc, 'kg', EXPR.ExternalFunctionExpression)
self._get_check_units_fail(model.ef3(model.ym, model.xkg), uc, EXPR.ExternalFunctionExpression, InconsistentUnitsError)
def radiativeForcing(model, t):
return (model.FORC[t] == kwargs['fco22x'] *
(pe.log10(model.MAT[t] / 588.000) / pe.log10(2)) +
kwargs['forcoth'][t])
def rule_P_sat(b, j):
return ((log10(b.pressure_sat[j] * 1e-5) -
b._params.pressure_sat_coeff[j, "A"]) *
(b._teq + b._params.pressure_sat_coeff[j, "C"])
) == -b._params.pressure_sat_coeff[j, "B"]
def radiativeForcing(model,t): return (model.FORC[t] == kwargs['fco22x'] * (pe.log10(model.MAT[t]/588.000)/pe.log10(2)) + kwargs['forcoth'][t])
def hpool_eqn(b, t):
return 1e-4*b.hpool[t] \
* sqrt(b.control_volume.properties_in[0].mw*1000.0) * \
(-log10(b.reduced_pressure[t]))**(0.55) == 1e-4 * \
55.0 * b.reduced_pressure[t]**0.12 * b.heat_flux_conv[t]**0.67
# This software is distributed under the 3-clause BSD License. # ___________________________________________________________________________ from pyomo.environ import ConcreteModel, Var, Objective, Constraint, log, log10, sin, cos, tan, sinh, cosh, tanh, asin, acos, atan, asinh, acosh, atanh, exp, sqrt, ceil, floor from math import e, pi model = ConcreteModel() # pick a value in the domain of all of these functions model.ONE = Var(initialize=1) model.ZERO = Var(initialize=0) model.obj = Objective(expr=model.ONE + model.ZERO) model.c_log = Constraint(expr=log(model.ONE) == 0) model.c_log10 = Constraint(expr=log10(model.ONE) == 0) model.c_sin = Constraint(expr=sin(model.ZERO) == 0) model.c_cos = Constraint(expr=cos(model.ZERO) == 1) model.c_tan = Constraint(expr=tan(model.ZERO) == 0) model.c_sinh = Constraint(expr=sinh(model.ZERO) == 0) model.c_cosh = Constraint(expr=cosh(model.ZERO) == 1) model.c_tanh = Constraint(expr=tanh(model.ZERO) == 0) model.c_asin = Constraint(expr=asin(model.ZERO) == 0) model.c_acos = Constraint(expr=acos(model.ZERO) == pi / 2) model.c_atan = Constraint(expr=atan(model.ZERO) == 0) model.c_asinh = Constraint(expr=asinh(model.ZERO) == 0) model.c_acosh = Constraint(expr=acosh((e**2 + model.ONE) / (2 * e)) == 0)
def outlet_pOH(self, time=0):
return -log10(value(self.conc_mol_OH[time]) / 1000)
def rule_P_sat(b, j):
return ((log10(b.pressure_sat[j]*1e-5) -
b._params.pressure_sat_coeff[j, 'A']) *
(b._teq + b._params.pressure_sat_coeff[j, 'C'])) == \
-b._params.pressure_sat_coeff[j, 'B']
def initialize_kaibel():
m = get_model_with_properties()
## Operating conditions
m.Preb = 1.2 # Reboiler pressure in bar
m.Pcon = 1.05 # Condenser pressure in bar
m.Pf = 1.02
Pnmin = {} # Pressure in bars
Pnmin[1] = m.Preb # Reboiler pressure in bars
Pnmin[3] = m.Pcon # Distillate pressure in bars
Pnmin[2] = m.Pf # Side feed pressure in bars
xi_nmin = {} # Initial liquid composition: first number = column and
# second number = 1 reboiler, 2 side feed, and
# 3 for condenser
## Column 1
c_c1 = 4 # Components in Column 1
lc_c1 = 3 # Ligh component in Column 1
hc_c1 = 4 # Heavy component in Column 1
inter1_c1 = 1 # Intermediate component in Column 1
inter2_c1 = 2 # Intermediate component in Column 1
xi_nmin[1, 1, hc_c1] = 0.999
xi_nmin[1, 1, lc_c1] = (1 - xi_nmin[1, 1, hc_c1]) / (c_c1 - 1)
xi_nmin[1, 1, inter1_c1] = (1 - xi_nmin[1, 1, hc_c1]) / (c_c1 - 1)
xi_nmin[1, 1, inter2_c1] = (1 - xi_nmin[1, 1, hc_c1]) / (c_c1 - 1)
xi_nmin[1, 3, lc_c1] = 0.33
xi_nmin[1, 3, inter1_c1] = 0.33
xi_nmin[1, 3, inter2_c1] = 0.33
xi_nmin[1, 3,
hc_c1] = 1 - (xi_nmin[1, 3, lc_c1] + xi_nmin[1, 3, inter1_c1] +
xi_nmin[1, 3, inter2_c1])
xi_nmin[1, 2, lc_c1] = 1 / c_c1
xi_nmin[1, 2, inter1_c1] = 1 / c_c1
xi_nmin[1, 2, inter2_c1] = 1 / c_c1
xi_nmin[1, 2, hc_c1] = 1 / c_c1
## Column 2
c_c2 = 3 # Light components in Column 2
lc_c2 = 2 # Light component in Column 2
hc_c2 = 3 # Heavy component in Column 2
inter_c2 = 1 # Intermediate component in Column 2
xi_nmin[2, 1, hc_c2] = 0.999
xi_nmin[2, 1, lc_c2] = (1 - xi_nmin[2, 1, hc_c2]) / (c_c2 - 1)
xi_nmin[2, 1, inter_c2] = (1 - xi_nmin[2, 1, hc_c2]) / (c_c2 - 1)
xi_nmin[2, 3, lc_c2] = 0.499
xi_nmin[2, 3, inter_c2] = 0.499
xi_nmin[2, 3, hc_c2] = 1 - (xi_nmin[2, 3, lc_c2] + xi_nmin[2, 3, inter_c2])
xi_nmin[2, 2, lc_c2] = 1 / c_c2
xi_nmin[2, 2, inter_c2] = 1 / c_c2
xi_nmin[2, 2, hc_c2] = 1 / c_c2
## Column 3
c_c3 = 2 # Components in Column 3
lc_c3 = 1 # Light component in Column 3
hc_c3 = 2 # Heavy component in Column 3
xi_nmin[3, 1, hc_c3] = 0.999
xi_nmin[3, 1, lc_c3] = 1 - xi_nmin[3, 1, hc_c3]
xi_nmin[3, 3, lc_c3] = 0.999
xi_nmin[3, 3, hc_c3] = 1 - xi_nmin[3, 3, lc_c3]
xi_nmin[3, 2, lc_c3] = 0.50
xi_nmin[3, 2, hc_c3] = 0.50
####
mn = m.clone()
mn.name = "Initialization Code"
mn.cols = RangeSet(3, doc='Number of columns ')
mn.sec = RangeSet(3, doc='Sections in column: 1 reb, 2 side feed, 3 cond')
mn.nc1 = RangeSet(c_c1, doc='Number of components in Column 1')
mn.nc2 = RangeSet(c_c2, doc='Number of components in Column 2')
mn.nc3 = RangeSet(c_c3, doc='Number of components in Column 3')
mn.Tnmin = Var(mn.cols,
mn.sec,
doc='Temperature in K',
bounds=(0, 500),
domain=NonNegativeReals)
mn.Tr1nmin = Var(mn.cols,
mn.sec,
mn.nc1,
doc='Temperature term for vapor pressure',
domain=NonNegativeReals,
bounds=(0, None))
mn.Tr2nmin = Var(mn.cols,
mn.sec,
mn.nc2,
doc='Temperature term for vapor pressure',
domain=NonNegativeReals,
bounds=(0, None))
mn.Tr3nmin = Var(mn.cols,
mn.sec,
mn.nc3,
doc='Temperature term for vapor pressure',
domain=NonNegativeReals,
bounds=(0, None))
@mn.Constraint(mn.cols,
mn.sec,
mn.nc1,
doc="Temperature term for vapor pressure")
def _column1_reduced_temperature(mn, col, sec, nc):
return mn.Tr1nmin[col, sec, nc] * mn.Tnmin[col, sec] == mn.prop[nc,
'TC']
@mn.Constraint(mn.cols,
mn.sec,
mn.nc2,
doc="Temperature term for vapor pressure")
def _column2_reduced_temperature(mn, col, sec, nc):
return mn.Tr2nmin[col, sec, nc] * mn.Tnmin[col, sec] == mn.prop[nc,
'TC']
@mn.Constraint(mn.cols,
mn.sec,
mn.nc3,
doc="Temperature term for vapor pressure")
def _column3_reduced_temperature(mn, col, sec, nc):
return mn.Tr3nmin[col, sec, nc] * mn.Tnmin[col, sec] == mn.prop[nc,
'TC']
@mn.Constraint(mn.cols, mn.sec, doc="Boiling point temperature")
def _equilibrium_equation(mn, col, sec):
if col == 1:
a = mn.Tr1nmin
b = mn.nc1
elif col == 2:
a = mn.Tr2nmin
b = mn.nc2
elif col == 3:
a = mn.Tr3nmin
b = mn.nc3
return sum(
xi_nmin[col, sec, nc] * mn.prop[nc, 'PC'] * exp(
a[col, sec, nc] * (
mn.prop[nc, 'vpA'] * \
(1 - mn.Tnmin[col, sec] / mn.prop[nc, 'TC'])
+ mn.prop[nc, 'vpB'] * \
(1 - mn.Tnmin[col, sec] / mn.prop[nc, 'TC'])**1.5
+ mn.prop[nc, 'vpC'] * \
(1 - mn.Tnmin[col, sec] / mn.prop[nc, 'TC'])**3
+ mn.prop[nc, 'vpD'] * \
(1 - mn.Tnmin[col, sec] / mn.prop[nc, 'TC'])**6
)
) / Pnmin[sec] for nc in b
) == 1
mn.OBJ = Objective(expr=1, sense=minimize)
####
SolverFactory('ipopt').solve(mn)
yc = {} # Vapor composition
kl = {} # Light key component
kh = {} # Heavy key component
alpha = {} # Relative volatility of kl
ter = {} # Term to calculate the minimum number of trays
Nmin = {} # Minimum number of stages
Nminopt = {} # Total optimal minimum number of trays
Nfeed = {} # Side feed optimal location using Kirkbride's method:
# 1 = number of trays in rectifying section and
# 2 = number of trays in stripping section
side_feed = {} # Side feed location
av_alpha = {} # Average relative volatilities
xi_lhc = {} # Liquid composition in columns
rel = mn.Bdes / mn.Ddes # Ratio between products flowrates
ln = {} # Light component for the different columns
hn = {} # Heavy component for the different columns
ln[1] = lc_c1
ln[2] = lc_c2
ln[3] = lc_c3
hn[1] = hc_c1
hn[2] = hc_c2
hn[3] = hc_c3
for col in mn.cols:
if col == 1:
b = mn.nc1
elif col == 2:
b = mn.nc2
else:
b = mn.nc3
for sec in mn.sec:
for nc in b:
yc[col, sec, nc] = xi_nmin[col, sec, nc] * mn.prop[nc, 'PC'] * exp(
mn.prop[nc, 'TC'] / value(mn.Tnmin[col, sec]) * (
mn.prop[nc, 'vpA'] * \
(1 - value(mn.Tnmin[col, sec]) / mn.prop[nc, 'TC'])
+ mn.prop[nc, 'vpB'] * \
(1 - value(mn.Tnmin[col, sec]) / mn.prop[nc, 'TC'])**1.5
+ mn.prop[nc, 'vpC'] * \
(1 - value(mn.Tnmin[col, sec]) / mn.prop[nc, 'TC'])**3
+ mn.prop[nc, 'vpD'] * \
(1 - value(mn.Tnmin[col, sec]) / mn.prop[nc, 'TC'])**6
)
) / Pnmin[sec]
for col in mn.cols:
xi_lhc[col, 4] = xi_nmin[col, 1, ln[col]] / \
xi_nmin[col, 3, hn[col]]
for sec in mn.sec:
kl[col, sec] = yc[col, sec, ln[col]] / \
xi_nmin[col, sec, ln[col]]
kh[col, sec] = yc[col, sec, hn[col]] / \
xi_nmin[col, sec, hn[col]]
xi_lhc[col, sec] = xi_nmin[col, sec, hn[col]] / \
xi_nmin[col, sec, ln[col]]
alpha[col, sec] = kl[col, sec] / kh[col, sec]
for col in mn.cols:
av_alpha[col] = (alpha[col, 1] * alpha[col, 2] * alpha[col, 3])**(1 /
3)
Nmin[col] = log10(
(1 / xi_lhc[col, 3]) * xi_lhc[col, 1]) / log10(av_alpha[col])
ter[col] = (rel * xi_lhc[col, 2] * (xi_lhc[col, 4]**2))**0.206
Nfeed[1, col] = ter[col] * Nmin[col] / (1 + ter[col])
Nfeed[2, col] = Nfeed[1, col] / ter[col]
side_feed[col] = Nfeed[2, col]
m.Nmintot = sum(Nmin[col] for col in mn.cols)
m.Knmin = int(m.Nmintot) + 1
m.TB0 = value(mn.Tnmin[1, 1])
m.Tf0 = value(mn.Tnmin[1, 2])
m.TD0 = value(mn.Tnmin[2, 3])
return m
