def test_units(self, btg):
assert_units_equivalent(btg.fs.unit.control_volume.heat,
pyunits.J / pyunits.s)
# Referecnes don;t have units at the moment, so these tests fail
# assert_units_equivalent(btg.fs.unit.heat_duty, pyunits.J/pyunits.s)
# assert_units_equivalent(btg.fs.unit.deltaP, pyunits.Pa)
assert_units_consistent(btg)
def test_constant_dh_rxn(model):
model.rparams.config.rate_reactions.r1.parameter_data = {
"dh_rxn_ref": 1}
model.rparams.config.equilibrium_reactions.e1.parameter_data = {
"dh_rxn_ref": 10}
constant_dh_rxn.build_parameters(
model.rparams.reaction_r1, model.rparams.config.rate_reactions["r1"])
constant_dh_rxn.build_parameters(
model.rparams.reaction_e1,
model.rparams.config.equilibrium_reactions["e1"])
# Check parameter construction
assert isinstance(model.rparams.reaction_r1.dh_rxn_ref, Var)
assert model.rparams.reaction_r1.dh_rxn_ref.value == 1
assert isinstance(model.rparams.reaction_e1.dh_rxn_ref, Var)
assert model.rparams.reaction_e1.dh_rxn_ref.value == 10
# Check expressions
rform = constant_dh_rxn.return_expression(
model.rxn[1], model.rparams.reaction_r1, "r1", 300)
assert str(rform) == str(model.rparams.reaction_r1.dh_rxn_ref)
rform = constant_dh_rxn.return_expression(
model.rxn[1], model.rparams.reaction_e1, "e1", 300)
assert str(rform) == str(model.rparams.reaction_e1.dh_rxn_ref)
assert_units_equivalent(rform, pyunits.J/pyunits.mol)
def test_Txy_dataclass():
TD = TXYDataClass('benzene', 'toluene',
pyunits.kg / pyunits.m / pyunits.s**2, pyunits.K, 101325)
TD.TBubb = [353.3205, 365.3478, 383.8817]
TD.TDew = [353.3237, 372.0203, 383.8845]
TD.x = [0.9999, 0.5, 0.01]
assert TD.Component_1 == 'benzene'
assert TD.Component_2 == 'toluene'
assert_units_equivalent(TD.Punits, pyunits.kg / pyunits.m / pyunits.s**2)
assert_units_equivalent(TD.Tunits, pyunits.K)
assert TD.P == 101325
assert TD.TBubb == [
pytest.approx(353.3205, abs=1e-4),
pytest.approx(365.3478, abs=1e-4),
pytest.approx(383.8817, abs=1e-4)
]
assert TD.TDew == [
pytest.approx(353.3237, abs=1e-4),
pytest.approx(372.0203, abs=1e-4),
pytest.approx(383.8845, abs=1e-4)
]
assert TD.x == [
pytest.approx(0.9999, abs=1e-4),
pytest.approx(0.5, abs=1e-4),
pytest.approx(0.01, abs=1e-4)
]
def test_arrhenius_molarity(model):
model.rparams.config.rate_reactions.r1.concentration_form = \
ConcentrationForm.molarity
model.rparams.config.rate_reactions.r1.parameter_data = {
"arrhenius_const": 1,
"energy_activation": 500
}
arrhenius.build_parameters(model.rparams.reaction_r1,
model.rparams.config.rate_reactions["r1"])
# Check parameter construction
assert isinstance(model.rparams.reaction_r1.arrhenius_const, Var)
assert model.rparams.reaction_r1.arrhenius_const.value == 1
assert isinstance(model.rparams.reaction_r1.energy_activation, Var)
assert model.rparams.reaction_r1.energy_activation.value == 500
# Check expressions
rform = arrhenius.return_expression(model.rxn[1],
model.rparams.reaction_r1, "r1",
300 * pyunits.K)
assert value(rform) == pytest.approx(0.81836, rel=1e-3)
assert_units_equivalent(rform, 1 / pyunits.s)
def test_unit_consistency(model):
assert_units_consistent(model)
for e in model.fs.state[0].flow_vol.values():
assert_units_equivalent(e, pyunits.m**3 / pyunits.s)
for e in model.fs.state[0].conc_mass_comp.values():
assert_units_equivalent(e, pyunits.kg / pyunits.m**3)
def test_pressure_sat_comp_dT(frame):
pressure_sat_comp.build_parameters(frame.params)
expr = pressure_sat_comp.dT_expression(frame.props[1], frame.params,
frame.props[1].temperature)
delta = 1e-4 * pyunits.K
val = pressure_sat_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
val_p = pressure_sat_comp.return_expression(
frame.props[1], frame.params, frame.props[1].temperature + delta)
dPdT = value((val - val_p) / -delta)
assert value(expr) == pytest.approx(dPdT, 1e-4)
frame.props[1].temperature.value = 373.15
val = pressure_sat_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
val_p = pressure_sat_comp.return_expression(
frame.props[1], frame.params, frame.props[1].temperature + delta)
dPdT = value((val - val_p) / -delta)
assert value(expr) == pytest.approx(dPdT, 1e-4)
assert_units_equivalent(expr, pyunits.Pa / pyunits.K)
def test_get_eos_properties(self):
omega = CoolPropWrapper._get_eos_property("Acetone", "acentric")
assert omega == (0.3071, pyunits.dimensionless)
mw = CoolPropWrapper._get_eos_property("Acetone", "molar_mass")
assert mw[0] == 0.05807914
assert_units_equivalent(mw[1], pyunits.kg/pyunits.mol)
def test_cp_mol_ig_comp(frame):
cp_mol_ig_comp.build_parameters(frame.params)
assert isinstance(frame.params.cp_mol_ig_comp_coeff_A, Var)
assert value(frame.params.cp_mol_ig_comp_coeff_A) == 30.09200
assert isinstance(frame.params.cp_mol_ig_comp_coeff_B, Var)
assert value(frame.params.cp_mol_ig_comp_coeff_B) == 6.832514
assert isinstance(frame.params.cp_mol_ig_comp_coeff_C, Var)
assert value(frame.params.cp_mol_ig_comp_coeff_C) == 6.793435
assert isinstance(frame.params.cp_mol_ig_comp_coeff_D, Var)
assert value(frame.params.cp_mol_ig_comp_coeff_D) == -2.534480
assert isinstance(frame.params.cp_mol_ig_comp_coeff_E, Var)
assert value(frame.params.cp_mol_ig_comp_coeff_E) == 0.082139
assert isinstance(frame.params.cp_mol_ig_comp_coeff_F, Var)
assert value(frame.params.cp_mol_ig_comp_coeff_F) == -250.8810
assert isinstance(frame.params.cp_mol_ig_comp_coeff_G, Var)
assert value(frame.params.cp_mol_ig_comp_coeff_G) == 223.3967
assert isinstance(frame.params.cp_mol_ig_comp_coeff_H, Var)
assert value(frame.params.cp_mol_ig_comp_coeff_H) == -241.8264
expr = cp_mol_ig_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == pytest.approx(35.22, abs=1e-2)
frame.props[1].temperature.value = 600
assert value(expr) == pytest.approx(36.32, abs=1e-2)
assert_units_equivalent(expr, pyunits.J / pyunits.mol / pyunits.K)
def test_van_t_hoff_molarity(self, model):
model.rparams.config.equilibrium_reactions.r1.concentration_form = \
ConcentrationForm.molarity
model.rparams.config.equilibrium_reactions.r1.parameter_data = {
"k_eq_ref": 1,
"T_eq_ref": 500
}
van_t_hoff.build_parameters(
model.rparams.reaction_r1,
model.rparams.config.equilibrium_reactions["r1"])
# Check parameter construction
assert isinstance(model.rparams.reaction_r1.k_eq_ref, Var)
assert model.rparams.reaction_r1.k_eq_ref.value == 1
assert isinstance(model.rparams.reaction_r1.T_eq_ref, Var)
assert model.rparams.reaction_r1.T_eq_ref.value == 500
# Check expression
rform = van_t_hoff.return_expression(model.rxn[1],
model.rparams.reaction_r1, "r1",
300 * pyunits.K)
assert value(rform) == pytest.approx(0.99984, rel=1e-3)
assert_units_equivalent(rform, pyunits.mol / pyunits.m**3)
def test_arrhenius_partial_pressure_convert(model):
model.rparams.config.rate_reactions.r1.concentration_form = \
ConcentrationForm.partialPressure
model.rparams.config.rate_reactions.r1.parameter_data = {
"arrhenius_const":
(1e-3, pyunits.kmol / pyunits.m**3 / pyunits.s / pyunits.Pa),
"energy_activation": (0.5, pyunits.kJ / pyunits.mol)
}
arrhenius.build_parameters(model.rparams.reaction_r1,
model.rparams.config.rate_reactions["r1"])
# Check parameter construction
assert isinstance(model.rparams.reaction_r1.arrhenius_const, Var)
assert model.rparams.reaction_r1.arrhenius_const.value == 1
assert isinstance(model.rparams.reaction_r1.energy_activation, Var)
assert model.rparams.reaction_r1.energy_activation.value == 500
# Check expressions
rform = arrhenius.return_expression(model.rxn[1],
model.rparams.reaction_r1, "r1",
300 * pyunits.K)
assert value(rform) == pytest.approx(0.81836, rel=1e-3)
assert_units_equivalent(
rform, pyunits.mol / pyunits.m**3 / pyunits.s / pyunits.Pa)
def test_van_t_hoff_partial_pressure_convert(self, model):
model.rparams.config.equilibrium_reactions.r1.concentration_form = \
ConcentrationForm.partialPressure
model.rparams.config.equilibrium_reactions.r1.parameter_data = {
"k_eq_ref": (1e-3, pyunits.kPa),
"T_eq_ref": (900, pyunits.degR)
}
van_t_hoff.build_parameters(
model.rparams.reaction_r1,
model.rparams.config.equilibrium_reactions["r1"])
# Check parameter construction
assert isinstance(model.rparams.reaction_r1.k_eq_ref, Var)
assert model.rparams.reaction_r1.k_eq_ref.value == 1
assert isinstance(model.rparams.reaction_r1.T_eq_ref, Var)
assert model.rparams.reaction_r1.T_eq_ref.value == 500
# Check expression
rform = van_t_hoff.return_expression(model.rxn[1],
model.rparams.reaction_r1, "r1",
300 * pyunits.K)
assert value(rform) == pytest.approx(0.99984, rel=1e-3)
assert_units_equivalent(rform, pyunits.Pa)
def test_units(self, sapon):
assert_units_consistent(sapon)
assert_units_equivalent(sapon.fs.unit.volume, units.m**3)
assert_units_equivalent(sapon.fs.unit.length, units.m)
assert_units_equivalent(sapon.fs.unit.area, units.m**2)
assert_units_equivalent(sapon.fs.unit.heat_duty[0, 0],
units.W / units.m)
assert_units_equivalent(sapon.fs.unit.deltaP[0, 0], units.Pa / units.m)
def test_units_metadata():
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = PropertyInterrogatorBlock()
units_meta = m.fs.params.get_metadata().get_derived_units
assert_units_equivalent(units_meta('length'), pyunits.m)
assert_units_equivalent(units_meta('pressure'), pyunits.Pa)
def test_enth_mol_ig_comp(frame):
enth_mol_ig_comp.build_parameters(frame.params)
expr = enth_mol_ig_comp.return_expression(
frame.props[1], frame.params, frame.props[1].temperature)
assert value(expr) == pytest.approx(6.92e3 - 241826.4, rel=1e-3) # value from NIST
frame.props[1].temperature.value = 600
assert value(expr) == pytest.approx(10.5e3 - 241826.4, rel=1e-3) # value from NIST
assert_units_equivalent(expr, pyunits.J/pyunits.mol)
def test_entr_mol_ig_comp(frame):
entr_mol_ig_comp.build_parameters(frame.params)
expr = entr_mol_ig_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == pytest.approx(206.5, rel=1e-3)
frame.props[1].temperature.value = 600
assert value(expr) == pytest.approx(213.1, rel=1e-3)
assert_units_equivalent(expr, pyunits.J / pyunits.mol / pyunits.K)
def test_entr_mol_ig_comp_no_formation(frame):
entr_mol_ig_comp.build_parameters(frame.params)
frame.params.config.include_entropy_of_formation = False
expr = entr_mol_ig_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == pytest.approx(206.5, rel=1e-3)
frame.props[1].temperature.value = 600
assert value(expr) == pytest.approx(213.1, rel=1e-3)
assert_units_equivalent(expr, pyunits.J / pyunits.mol / pyunits.K)
def test_pressure_osm_phase(self, model):
model.state[1].vol_mol_phase = Var(model.params.phase_list,
initialize=18e-6,
units=pyunits.m**3/pyunits.mol)
assert_units_equivalent(model.state[1].pressure_osm_phase["Liq"],
pyunits.Pa)
assert len(model.state[1].pressure_osm_phase) == 1
assert pytest.approx(value(
-Constants.gas_constant*300*log(0.1670306)/18e-6),
rel=1e-6) == value(
model.state[1].pressure_osm_phase["Liq"])
def test_enth_mol_ig_comp_no_formation(frame):
enth_mol_ig_comp.build_parameters(frame.params)
frame.params.config.include_enthalpy_of_formation = False
expr = enth_mol_ig_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == pytest.approx(6.92e3, rel=1e-3) # value from NIST
frame.props[1].temperature.value = 600
assert value(expr) == pytest.approx(10.5e3, rel=1e-3) # value from NIST
assert_units_equivalent(expr, pyunits.J / pyunits.mol)
def test_entr_mol_ig_comp(frame):
entr_mol_ig_comp.build_parameters(frame.params)
assert isinstance(frame.params.entr_mol_form_vap_comp_ref, Var)
assert value(frame.params.entr_mol_form_vap_comp_ref) == 45.13
expr = entr_mol_ig_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == pytest.approx(191.761, abs=1e-3)
frame.props[1].temperature.value = 400
assert value(expr) == pytest.approx(201.756, abs=1e-3)
assert_units_equivalent(expr, pyunits.J / pyunits.mol / pyunits.K)
def test_entr_mol_sol_comp(frame):
Constant.entr_mol_sol_comp.build_parameters(frame.params)
assert isinstance(frame.params.entr_mol_form_sol_comp_ref, Var)
assert value(frame.params.entr_mol_form_sol_comp_ref) == 50
expr = Constant.entr_mol_sol_comp.return_expression(
frame.props[1], frame.params, frame.props[1].temperature)
assert value(expr) == value(frame.params.entr_mol_form_sol_comp_ref)
frame.props[1].temperature.value = 400
assert value(expr) == pytest.approx(78.77, rel=1e-3)
assert_units_equivalent(expr, pyunits.J / pyunits.mol / pyunits.K)
def test_entr_mol_liq_comp(frame):
entr_mol_liq_comp.build_parameters(frame.params)
assert isinstance(frame.params.entr_mol_form_liq_comp_ref, Var)
assert value(frame.params.entr_mol_form_liq_comp_ref) == 69.95
expr = entr_mol_liq_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == value(frame.params.entr_mol_form_liq_comp_ref)
frame.props[1].temperature.value = 533.15
assert value(expr) == pytest.approx(122.05, rel=1e-3)
assert_units_equivalent(expr, pyunits.J / pyunits.mol / pyunits.K)
def test_units_roundoff_error(self):
# Issue 2393: this example resulted in roundoff error where the
# computed units for var_1 were
#(0.9999999999999986,
# <Unit('kilogram ** 1 / kelvin / meter ** 1.66533e-16 / second ** 3')>
#)
m = ConcreteModel()
m.var_1 = Var(initialize=400,
units=((units.J**0.4) * (units.kg**0.2) *
(units.W**0.6) / units.K / (units.m**2.2) /
(units.Pa**0.2) / (units.s**0.8)))
m.var_1.fix()
m.var_2 = Var(initialize=400, units=units.kg / units.s**3 / units.K)
assert_units_equivalent(m.var_1, m.var_2)
def test_enth_mol_ig_comp(frame):
enth_mol_ig_comp.build_parameters(frame.params)
assert isinstance(frame.params.enth_mol_form_vap_comp_ref, Var)
assert value(frame.params.enth_mol_form_vap_comp_ref) == -57797.0
expr = enth_mol_ig_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == pytest.approx(-240983.962, abs=1e-3)
frame.props[1].temperature.value = 400
assert value(expr) == pytest.approx(-237517.968, abs=1e-3)
assert_units_equivalent(expr, pyunits.J / pyunits.mol)
def test_relative_permitivity_constant(frame):
relative_permittivity_constant.build_parameters(frame.params)
assert isinstance(frame.params.relative_permittivity_liq_comp, Var)
assert value(frame.params.relative_permittivity_liq_comp) == 101
expr = relative_permittivity_constant.return_expression(
frame.props[1], frame.params, frame.props[1].temperature)
assert value(expr) == 101
frame.props[1].temperature.value = 600
assert value(expr) == 101
assert_units_equivalent(expr, pyunits.dimensionless)
def test_get_parameter_value(self):
Tc = CoolPropWrapper.get_parameter_value(
"Acetone", "temperature_crit")
assert Tc == (508.1, pyunits.K)
Pc = CoolPropWrapper.get_parameter_value(
"Acetone", "pressure_crit")
assert Pc == (4700000.0, pyunits.Pa)
rhoc = CoolPropWrapper.get_parameter_value(
"Acetone", "dens_mol_crit")
assert rhoc[0] == 4699.999999999999
assert_units_equivalent(rhoc[1], pyunits.mol/pyunits.m**3)
hc = CoolPropWrapper.get_parameter_value(
"Acetone", "enth_mol_crit")
assert hc[0] == 31614.73051047263
assert_units_equivalent(hc[1], pyunits.J/pyunits.mol)
sc = CoolPropWrapper.get_parameter_value(
"Acetone", "entr_mol_crit")
assert sc[0] == 72.97112978635582
assert_units_equivalent(sc[1], pyunits.J/pyunits.mol/pyunits.K)
omega = CoolPropWrapper.get_parameter_value("Acetone", "omega")
assert omega == (0.3071, pyunits.dimensionless)
mw = CoolPropWrapper.get_parameter_value("Acetone", "mw")
assert mw[0] == 0.05807914
assert_units_equivalent(mw[1], pyunits.kg/pyunits.mol)
def test_dens_mol_liq_comp(frame):
dens_mol_liq_comp.build_parameters(frame.params)
assert isinstance(frame.params.dens_mol_liq_comp_coeff_eqn_type, Param)
assert value(frame.params.dens_mol_liq_comp_coeff_eqn_type) == 1
expr = dens_mol_liq_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == pytest.approx(55.583e3, rel=1e-4)
frame.props[1].temperature.value = 333.15
assert value(expr) == pytest.approx(54.703e3, rel=1e-4)
assert_units_equivalent(expr, pyunits.mol / pyunits.m**3)
def test_dens_mol_sol_comp(frame):
Constant.dens_mol_sol_comp.build_parameters(frame.params)
assert isinstance(frame.params.dens_mol_sol_comp_coeff, Var)
assert value(frame.params.dens_mol_sol_comp_coeff) == pytest.approx(
100e3, rel=1e-4)
expr = Constant.dens_mol_sol_comp.return_expression(
frame.props[1], frame.params, frame.props[1].temperature)
assert value(expr) == pytest.approx(100e3, rel=1e-4)
frame.props[1].temperature.value = 400
assert value(expr) == pytest.approx(100e3, rel=1e-4)
assert_units_equivalent(expr, pyunits.mol / pyunits.m**3)
def test_units(self, btx):
assert_units_equivalent(btx.fs.unit.overall_heat_transfer_coefficient,
pyunits.W/pyunits.m**2/pyunits.K)
assert_units_equivalent(btx.fs.unit.area, pyunits.m**2)
assert_units_equivalent(btx.fs.unit.delta_temperature_in, pyunits.K)
assert_units_equivalent(btx.fs.unit.delta_temperature_out, pyunits.K)
assert_units_consistent(btx)
def test_unit_consistency(self, model):
assert_units_consistent(model.fs.unit)
assert_units_equivalent(model.fs.unit.rapid_mix_retention_time,
pyunits.s)
assert_units_equivalent(model.fs.unit.floc_retention_time, pyunits.min)
assert_units_equivalent(model.fs.unit.rapid_mix_basin_vol,
pyunits.m**3)
assert_units_equivalent(model.fs.unit.floc_basin_vol, pyunits.m**3)
def test_enth_mol_ig_comp_no_form(frame):
frame.config.include_enthalpy_of_formation = False
frame.params.config.include_enthalpy_of_formation = False
enth_mol_ig_comp.build_parameters(frame.params)
assert not hasattr(frame.params, "enth_mol_form_vap_comp_ref")
expr = enth_mol_ig_comp.return_expression(frame.props[1], frame.params,
frame.props[1].temperature)
assert value(expr) == pytest.approx(838.686, abs=1e-3)
frame.props[1].temperature.value = 400
assert value(expr) == pytest.approx(4304.680, abs=1e-3)
assert_units_equivalent(expr, pyunits.J / pyunits.mol)
