def model(self):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.liquid_properties = GenericParameterBlock(default=aqueous_mea)
m.fs.vapor_properties = GenericParameterBlock(default=wet_co2)
m.fs.unit = SolventCondenser(default={
"liquid_property_package": m.fs.liquid_properties,
"vapor_property_package": m.fs.vapor_properties})
m.fs.unit.inlet.flow_mol[0].fix(1.1117)
m.fs.unit.inlet.temperature[0].fix(339.33)
m.fs.unit.inlet.pressure[0].fix(184360)
m.fs.unit.inlet.mole_frac_comp[0, "CO2"].fix(0.8817)
m.fs.unit.inlet.mole_frac_comp[0, "H2O"].fix(0.1183)
m.fs.unit.reflux.flow_mol[0].fix(0.1083)
iscale.set_scaling_factor(
m.fs.unit.vapor_phase.properties_out[0].fug_phase_comp[
"Vap", "CO2"], 1e-5)
iscale.set_scaling_factor(
m.fs.unit.vapor_phase.properties_out[0].fug_phase_comp[
"Vap", "H2O"], 1e-3)
iscale.calculate_scaling_factors(m.fs.unit)
return m
def model():
m = ConcreteModel()
configuration = _get_prop(["H2", "N2", "NH3"], ["Vap"])
m.params = GenericParameterBlock(default=configuration)
m.props = m.params.state_block_class(
default={
"defined_state": True,
"parameters": m.params,
"has_phase_equilibrium": False
})
configuration["phases"]["Vap"]["equation_of_state"] = Ideal
m.params_IG = GenericParameterBlock(default=configuration)
m.props_IG = m.params.state_block_class(
default={
"defined_state": True,
"parameters": m.params_IG,
"has_phase_equilibrium": False
})
Ntot = 18 + 53 + 385
for prop in [m.props, m.props_IG]:
prop.flow_mol.fix(1)
prop.temperature.fix(573)
prop.pressure.fix(40e6)
prop.mole_frac_comp["N2"].fix(18 / Ntot)
prop.mole_frac_comp["H2"].fix(53 / Ntot)
prop.mole_frac_comp["NH3"].fix(385 / Ntot)
prop.initialize()
return m
def test_henry_invalid_phase_name():
m = ConcreteModel()
# Add a dummy var for use in constructing expressions
m.x = Var(["Vap", "Liq"], ["H2O"], initialize=1)
m.mole_frac_phase_comp = Var(["Vap", "Liq"], ["H2O"], initialize=1)
# Create a dummy parameter block
with pytest.raises(ConfigurationError,
match="params component H2O was marked as a Henry's "
"Law component in phase foo, but this is not a valid "
"phase name."):
m.params = GenericParameterBlock(default={
"components": {"H2O": {
"parameter_data": {"temperature_crit": 647.3},
"henry_component": {"foo": ConstantH},
"phase_equilibrium_form": {("Vap", "Liq"): fugacity}}},
"phases": {"Liq": {"equation_of_state": DummyEoS},
"Vap": {"equation_of_state": DummyEoS}},
"state_definition": FTPx,
"pressure_ref": 1e5,
"temperature_ref": 300,
"base_units": {"time": pyunits.s,
"length": pyunits.m,
"mass": pyunits.kg,
"amount": pyunits.mol,
"temperature": pyunits.K}})
def test_pem():
# Create the ConcreteModel and the FlowsheetBlock, and attach the flowsheet block to it.
m = ConcreteModel()
m.fs = FlowsheetBlock(
default={"dynamic":
False}) # dynamic or ss flowsheet needs to be specified here
# Add properties parameter block to the flowsheet with specifications
m.fs.properties = GenericParameterBlock(default=configuration)
m.fs.unit = PEM_Electrolyzer(default={"property_package": m.fs.properties})
assert hasattr(m.fs.unit, "efficiency_curve")
assert hasattr(m.fs.unit, "electricity_in")
assert hasattr(m.fs.unit, "outlet")
assert hasattr(m.fs.unit, "outlet_state")
assert isinstance(m.fs.unit.electricity, Var)
assert isinstance(m.fs.unit.electricity_to_mol, Var)
m.fs.unit.electricity_in.electricity.fix(1)
m.fs.unit.electricity_to_mol.fix(5)
initialization_tester(m)
solver = SolverFactory('ipopt')
results = solver.solve(m.fs)
assert results.solver.termination_condition == TerminationCondition.optimal
assert results.solver.status == SolverStatus.ok
assert m.fs.unit.electricity_in.electricity[0].value == 1
assert m.fs.unit.outlet.flow_mol[0].value == 5.0
assert m.fs.unit.outlet.temperature[0].value == 300
assert m.fs.unit.outlet.pressure[0].value == 101325
def frame(self):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = GenericParameterBlock(default=configuration)
return m
def test_parameters_no_assignment(self):
m = ConcreteModel()
m.params = GenericParameterBlock(default=configuration)
assert isinstance(m.params.Liq.ion_pair_set, Set)
assert len(m.params.Liq.ion_pair_set) == 4
for p in m.params.Liq.ion_pair_set:
assert p in [("Na+, Cl-"), ("Na+, OH-"), ("H+, Cl-"), ("H+, OH-")]
assert isinstance(m.params.Liq.component_pair_set, Set)
assert len(m.params.Liq.component_pair_set) == 32
assert isinstance(m.params.Liq.component_pair_set_symmetric, Set)
assert len(m.params.Liq.component_pair_set_symmetric) == 17
assert isinstance(m.params.Liq.alpha, Var)
assert len(m.params.Liq.alpha) == 17
for (i, j) in m.params.Liq.alpha:
if i != j:
assert (j, i) not in m.params.Liq.alpha
if (i, j) in [("C6H12", "C6H12"), ("H2O", "H2O"),
("H2O", "C6H12")]:
assert m.params.Liq.alpha[(i, j)].value == 0.3
assert m.params.Liq.alpha[(i, j)].fixed
else:
assert m.params.Liq.alpha[(i, j)].value == 0.2
assert m.params.Liq.alpha[(i, j)].fixed
assert isinstance(m.params.Liq.tau, Var)
assert len(m.params.Liq.tau) == 32
for (i, j) in m.params.Liq.tau:
assert m.params.Liq.tau[(i, j)].value == 0
assert m.params.Liq.tau[(i, j)].fixed
def test_log_fugacity():
m = ConcreteModel()
# Add a dummy var for use in constructing expressions
m.x = Var(["Vap", "Liq"], ["H2O"], initialize=1)
m.mole_frac_phase_comp = Var(["Vap", "Liq"], ["H2O"], initialize=1)
# Create a dummy parameter block
m.params = GenericParameterBlock(default={
"components": {"H2O": {"parameter_data": {"temperature_crit": 647.3},
"phase_equilibrium_form": {
("Vap", "Liq"): log_fugacity}}},
"phases": {"Liq": {"equation_of_state": DummyEoS},
"Vap": {"equation_of_state": DummyEoS}},
"state_definition": FTPx,
"pressure_ref": 1e5,
"temperature_ref": 300,
"base_units": {"time": pyunits.s,
"length": pyunits.m,
"mass": pyunits.kg,
"amount": pyunits.mol,
"temperature": pyunits.K}})
assert str(log_fugacity(m, "Vap", "Liq", "H2O")) == str(
42*m.x["Vap", "H2O"] == 42*m.x["Liq", "H2O"])
def simulate_enrtl_FpcTP(state_var_args):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = GenericParameterBlock(
default=entrl_config_FpcTP.configuration)
m.fs.state = m.fs.params.build_state_block(m.fs.time,
default={"defined_state": True})
for (v_name, ind), val in state_var_args.items():
var = getattr(m.fs.state[0], v_name)
var[ind].fix(val)
# scale model
calculate_scaling_factors(m)
for (ind, c) in m.fs.state[0].true_to_appr_species.items():
sf = get_scaling_factor(
m.fs.state[0].flow_mol_phase_comp_apparent[ind])
constraint_scaling_transform(c, sf)
for (ind, c) in m.fs.state[0].appr_mole_frac_constraint.items():
sf = get_scaling_factor(
m.fs.state[0].mole_frac_phase_comp_apparent[ind])
constraint_scaling_transform(c, sf)
check_scaling(m)
solve_block(m)
ksp = 3.2e-9 # Gibbs energy gives 3.9e-8, but this fits expectations better
saturation_index = value(m.fs.state[0].act_phase_comp["Liq", "Ca_2+"] *
m.fs.state[0].act_phase_comp["Liq", "SO4_2-"] *
m.fs.state[0].act_phase_comp["Liq", "H2O"]**2 /
ksp)
return saturation_index
def simulate_enrtl_FTPx(state_var_args):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = GenericParameterBlock(
default=entrl_config_FTPx.configuration)
m.fs.state = m.fs.params.build_state_block(m.fs.time,
default={"defined_state": True})
for (v_name, ind), val in state_var_args.items():
var = getattr(m.fs.state[0], v_name)
var[ind].fix(val)
m.fs.state[0].flow_mol_phase['Liq'].value = 1
# scale model
calculate_scaling_factors(m)
# Regular solve
solver = get_solver()
results = solver.solve(m)
ksp = 3.2e-9 # Gibbs energy gives 3.9e-8, but this fits expectations better
saturation_index = value(m.fs.state[0].act_phase_comp["Liq", "Ca_2+"] *
m.fs.state[0].act_phase_comp["Liq", "SO4_2-"] *
m.fs.state[0].act_phase_comp["Liq", "H2O"]**2 /
ksp)
return saturation_index
def frame():
m = ConcreteModel()
# Create a dummy parameter block
m.params = GenericParameterBlock(default={
"components": {"H2O": {"parameter_data": {"temperature_crit": 647.3},
"phase_equilibrium_form":
{("Vap", "Liq"): fugacity}}},
"phases": {"Liq": {"equation_of_state": DummyEoS},
"Vap": {"equation_of_state": DummyEoS}},
"state_definition": FTPx,
"pressure_ref": 1e5,
"temperature_ref": 300,
"base_units": {"time": pyunits.s,
"length": pyunits.m,
"mass": pyunits.kg,
"amount": pyunits.mol,
"temperature": pyunits.K}})
# Create a dummy state block
m.props = m.params.state_block_class([1], default={"parameters": m.params})
m.props[1].temperature_bubble = Var([("Liq", "Vap")], initialize=300)
m.props[1].temperature_dew = Var([("Liq", "Vap")], initialize=300)
m.props[1]._teq = Var([("Liq", "Vap")], initialize=300)
m.props[1].fug_phase_comp = Var(m.params.phase_list,
m.params.component_list,
initialize=10)
SmoothVLE.phase_equil(m.props[1], ("Liq", "Vap"))
return m
def test_non_VLE_pair():
m = ConcreteModel()
# Create a dummy parameter block
m.params = GenericParameterBlock(default={
"components": {"H2O": {"parameter_data": {"temperature_crit": 647.3},
"phase_equilibrium_form":
{("Sol", "Liq"): fugacity}}},
"phases": {"Sol": {"equation_of_state": DummyEoS},
"Liq": {"equation_of_state": DummyEoS}},
"state_definition": FTPx,
"pressure_ref": 1e5,
"temperature_ref": 300,
"base_units": {"time": pyunits.s,
"length": pyunits.m,
"mass": pyunits.kg,
"amount": pyunits.mol,
"temperature": pyunits.K}})
# Create a dummy state block
m.props = m.params.state_block_class([1], default={"parameters": m.params})
with pytest.raises(ConfigurationError,
match="params Generic Property Package phase pair "
"Liq-Sol was set to use Smooth VLE formulation, "
"however this is not a vapor-liquid pair."):
SmoothVLE.phase_equil(m.props[1], ("Liq", "Sol"))
def carbonic_acid_model(self):
model = ConcreteModel()
model.fs = FlowsheetBlock(default={"dynamic": False})
model.fs.thermo_params = GenericParameterBlock(default=carbonic_thermo_config)
model.fs.rxn_params = GenericReactionParameterBlock(
default={"property_package": model.fs.thermo_params, **reaction_config})
model.fs.unit = EquilibriumReactor(default={
"property_package": model.fs.thermo_params,
"reaction_package": model.fs.rxn_params,
"has_rate_reactions": False,
"has_equilibrium_reactions": False,
"has_heat_transfer": False,
"has_heat_of_reaction": False,
"has_pressure_change": False})
#NOTE: ENRTL model cannot initialize if the inlet values are 0
zero = 1e-20
acid = 0.00206/(55.2+0.00206)
model.fs.unit.inlet.mole_frac_comp[0, "H_+"].fix( zero )
model.fs.unit.inlet.mole_frac_comp[0, "OH_-"].fix( zero )
# Added as conjugate base form
model.fs.unit.inlet.mole_frac_comp[0, "CO3_2-"].fix( zero )
model.fs.unit.inlet.mole_frac_comp[0, "HCO3_-"].fix( acid )
model.fs.unit.inlet.mole_frac_comp[0, "H2CO3"].fix( zero )
model.fs.unit.inlet.mole_frac_comp[0, "Na_+"].fix( acid )
model.fs.unit.inlet.mole_frac_comp[0, "H2O"].fix( 1.-4*zero-acid- \
value(model.fs.unit.inlet.mole_frac_comp[0, "Na_+"]) )
model.fs.unit.inlet.pressure.fix(101325.0)
model.fs.unit.inlet.temperature.fix(298.)
model.fs.unit.inlet.flow_mol.fix(10)
return model
def m(self):
m = ConcreteModel()
# Add a dummy thermo package for validation
m.params = GenericParameterBlock(
default={
"components": {
"c1": {},
"c2": {}
},
"phases": {
"p1": {
"equation_of_state": DummyEoS
},
"p2": {
"equation_of_state": DummyEoS
}
},
"state_definition": modules[__name__],
"pressure_ref": 1e5,
"temperature_ref": 300,
"base_units": base_units
})
return m
def build_model():
m = ConcreteModel()
# Properties
comp_props = get_prop(components=["CO2", "H2O"], phases=["Vap", "Liq"])
# Parameters block
m.params = GenericParameterBlock(default=comp_props)
m.props = m.params.build_state_block(
default={
"defined_state": True,
"parameters": m.params,
"has_phase_equilibrium": True
})
m.props.flow_mol.fix(100)
m.props.pressure.fix(101325)
m.props.mole_frac_comp["CO2"].fix(0.94)
m.props.mole_frac_comp["H2O"].fix(0.06)
m.props.temperature_constraint = Constraint(
expr=m.props.temperature == m.props.temperature_dew["Vap", "Liq"])
assert degrees_of_freedom(m) == 0
m.props.initialize(state_vars_fixed=True)
results = get_solver(options={"bound_push": 1e-8}).solve(m)
assert check_optimal_termination(results)
return m
def equilibrium_reactions_config(self):
model = ConcreteModel()
model.fs = FlowsheetBlock(default={"dynamic": False})
model.fs.thermo_params = GenericParameterBlock(
default=thermo_only_config)
model.fs.rxn_params = GenericReactionParameterBlock(
default={
"property_package": model.fs.thermo_params,
**water_reaction_config
})
model.fs.unit = EquilibriumReactor(
default={
"property_package": model.fs.thermo_params,
"reaction_package": model.fs.rxn_params,
"has_rate_reactions": False,
"has_equilibrium_reactions": True,
"has_heat_transfer": False,
"has_heat_of_reaction": False,
"has_pressure_change": False
})
model.fs.unit.inlet.mole_frac_comp[0, "H_+"].fix(0.)
model.fs.unit.inlet.mole_frac_comp[0, "OH_-"].fix(0.)
model.fs.unit.inlet.mole_frac_comp[0, "H2O"].fix(1.)
model.fs.unit.inlet.pressure.fix(101325.0)
model.fs.unit.inlet.temperature.fix(298.)
model.fs.unit.inlet.flow_mol.fix(10)
return model
def model(self, thermo_config, variant: Variant, water_reaction_config):
if variant.is_equilibrium:
thermo_config = _get_without_inherent_reactions(thermo_config)
model = ConcreteModel()
model.fs = FlowsheetBlock(default={"dynamic": False})
model.fs.thermo_params = GenericParameterBlock(default=thermo_config)
print(water_reaction_config)
model.fs.rxn_params = GenericReactionParameterBlock(
default={
"property_package": model.fs.thermo_params,
**water_reaction_config
})
model.fs.unit = EquilibriumReactor(
default={
"property_package": model.fs.thermo_params,
"reaction_package": model.fs.rxn_params,
"has_rate_reactions": False,
"has_equilibrium_reactions": variant.is_equilibrium,
"has_heat_transfer": False,
"has_heat_of_reaction": False,
"has_pressure_change": False,
})
model.fs.unit.inlet.mole_frac_comp[0, "H_+"].fix(0.0)
model.fs.unit.inlet.mole_frac_comp[0, "OH_-"].fix(0.0)
model.fs.unit.inlet.mole_frac_comp[0, "H2O"].fix(1.0)
model.fs.unit.inlet.pressure.fix(101325.0)
model.fs.unit.inlet.temperature.fix(298.0)
model.fs.unit.inlet.flow_mol.fix(10)
return model
def water_model(self):
model = ConcreteModel()
model.fs = FlowsheetBlock(default={"dynamic": False})
model.fs.thermo_params = GenericParameterBlock(
default=water_thermo_config)
model.fs.rxn_params = GenericReactionParameterBlock(
default={
"property_package": model.fs.thermo_params,
**reaction_config
})
model.fs.unit = EquilibriumReactor(
default={
"property_package": model.fs.thermo_params,
"reaction_package": model.fs.rxn_params,
"has_rate_reactions": False,
"has_equilibrium_reactions": False,
"has_heat_transfer": False,
"has_heat_of_reaction": False,
"has_pressure_change": False,
})
# NOTE: ENRTL model cannot initialize if the inlet values are 0
zero = 1e-20
model.fs.unit.inlet.mole_frac_comp[0, "H_+"].fix(zero)
model.fs.unit.inlet.mole_frac_comp[0, "OH_-"].fix(zero)
model.fs.unit.inlet.mole_frac_comp[0, "H2O"].fix(1.0 - 2 * zero)
model.fs.unit.inlet.pressure.fix(101325.0)
model.fs.unit.inlet.temperature.fix(298.0)
model.fs.unit.inlet.flow_mol.fix(10)
return model
def model(self):
model = ConcreteModel()
model.params = GenericParameterBlock(default=configuration_vap)
model.props = model.params.build_state_block(
[1], default={"defined_state": True})
# Fix state
model.props[1].flow_mol.fix(1)
model.props[1].temperature.fix(295.00)
model.props[1].pressure.fix(1e5)
model.props[1].mole_frac_comp["hydrogen"].fix(0.077)
model.props[1].mole_frac_comp["methane"].fix(0.077)
model.props[1].mole_frac_comp["ethane"].fix(0.077)
model.props[1].mole_frac_comp["propane"].fix(0.077)
model.props[1].mole_frac_comp["nbutane"].fix(0.077)
model.props[1].mole_frac_comp["ibutane"].fix(0.077)
model.props[1].mole_frac_comp["ethylene"].fix(0.077)
model.props[1].mole_frac_comp["propene"].fix(0.077)
model.props[1].mole_frac_comp["butene"].fix(0.077)
model.props[1].mole_frac_comp["pentene"].fix(0.077)
model.props[1].mole_frac_comp["hexene"].fix(0.077)
model.props[1].mole_frac_comp["heptene"].fix(0.077)
model.props[1].mole_frac_comp["octene"].fix(0.076)
assert degrees_of_freedom(model.props[1]) == 0
return model
def build_model():
# Create the ConcreteModel and the FlowSheetBlock
m = ConcreteModel(name="H2TankModel")
m.fs = FlowsheetBlock(default={"dynamic": False})
# Load thermodynamic package
m.fs.h2ideal_props = GenericParameterBlock(default=h2_ideal_config)
# Add hydrogen tank
m.fs.h2_tank = SimpleHydrogenTank(
default={"property_package": m.fs.h2ideal_props})
# Fix the dof of the tank and initialize
m.fs.h2_tank.inlet.pressure.fix(101325)
m.fs.h2_tank.inlet.temperature.fix(300)
m.fs.h2_tank.inlet.flow_mol.fix(25)
m.fs.h2_tank.inlet.mole_frac_comp[0, "hydrogen"].fix(1)
m.fs.h2_tank.dt.fix(3600)
m.fs.h2_tank.tank_holdup_previous.fix(0)
m.fs.h2_tank.outlet_to_turbine.flow_mol.fix(10)
m.fs.h2_tank.outlet_to_pipeline.flow_mol.fix(10)
m.fs.h2_tank.outlet_to_turbine.mole_frac_comp[0, "hydrogen"].fix(1)
m.fs.h2_tank.outlet_to_pipeline.mole_frac_comp[0, "hydrogen"].fix(1)
assert degrees_of_freedom(m) == 0
m.fs.h2_tank.initialize()
res = solver.solve(m)
assert res.solver.termination_condition == TerminationCondition.optimal
return m
def btx_ftpz_generic(self):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.properties = GenericParameterBlock(default=configuration)
m.fs.unit = TrayColumn(
default={
"number_of_trays": 10,
"feed_tray_location": 5,
"condenser_type": CondenserType.totalCondenser,
"condenser_temperature_spec": TemperatureSpec.atBubblePoint,
"property_package": m.fs.properties,
"has_heat_transfer": False,
"has_pressure_change": False
})
# Inlet feed conditions
m.fs.unit.feed.flow_mol.fix(100)
m.fs.unit.feed.temperature.fix(368)
m.fs.unit.feed.pressure.fix(101325)
m.fs.unit.feed.mole_frac_comp[0, "benzene"].fix(0.5)
m.fs.unit.feed.mole_frac_comp[0, "toluene"].fix(0.5)
# unit level inputs
m.fs.unit.condenser.reflux_ratio.fix(1.4)
m.fs.unit.condenser.condenser_pressure.fix(101325)
m.fs.unit.reboiler.boilup_ratio.fix(1.3)
return m
def model(self):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
# Add a test thermo package for validation
m.fs.pparams = GenericParameterBlock(default=thermo_config)
m.fs.rparams = GenericReactionParameterBlock(default={
"property_package": m.fs.pparams,
**rxn_config
})
# Don't include energy balances, as the test doesn't have a proper
# enthalpy model. Fix outlet T instead.
m.fs.R101 = EquilibriumReactor(
default={
"property_package": m.fs.pparams,
"reaction_package": m.fs.rparams,
"has_equilibrium_reactions": True,
"has_rate_reactions": False,
"energy_balance_type": EnergyBalanceType.none
})
m.fs.R101.inlet.flow_mol_phase_comp[0, "Liq", "H2O"].fix(55.56)
m.fs.R101.inlet.flow_mol_phase_comp[0, "Liq", "Na+"].fix(1e-8)
m.fs.R101.inlet.flow_mol_phase_comp[0, "Liq", "Cl-"].fix(1e-8)
m.fs.R101.inlet.flow_mol_phase_comp[0, "Sol", "NaCl"].fix(1e-8)
m.fs.R101.inlet.temperature[0].fix(298.15)
m.fs.R101.inlet.pressure[0].fix(101325)
m.fs.R101.outlet.temperature[0].fix(298.15)
return m
def get_reference_entropy(comp):
m = ConcreteModel()
m.params = GenericParameterBlock(default=_get_prop([comp]))
m.props = m.params.state_block_class(
default={
"defined_state": True,
"parameters": m.params,
"has_phase_equilibrium": False
})
# Want to make sure intermediate quantities are constructed before we
# solve the block. Therefore introduce this variable and constraint
m.S_ref = Var(domain=Reals, initialize=1, units=pyunits.J / pyunits.mol)
def rule_S_ref(blk, j):
return m.S_ref == m.props.entr_mol
m.S_ref_eq = Constraint(m.params.component_list, rule=rule_S_ref)
m.props.mole_frac_comp[comp].fix(1)
m.props.temperature.fix(standard_temp)
m.props.pressure.fix(standard_pressure)
solver = SolverFactory('ipopt')
results = solver.solve(m)
assert check_optimal_termination(results)
assert (value(m.S_ref) == approx(value(m.props.entr_mol_phase_comp["Vap",
comp]),
rel=1E-12))
return value(m.S_ref)
def model(self):
model = ConcreteModel()
model.fs = FlowsheetBlock(default={"dynamic": False})
model.fs.param = GenericParameterBlock(default=configuration)
model.fs.unit = Flash(
default={
"property_package": model.fs.param,
"has_heat_transfer": False,
"has_pressure_change": False
})
# Fix state
model.fs.unit.inlet.flow_mol.fix(1)
model.fs.unit.inlet.temperature.fix(200.00)
model.fs.unit.inlet.pressure.fix(101325)
model.fs.unit.inlet.mole_frac_comp[0, "carbon_dioxide"].fix(1 / 2)
model.fs.unit.inlet.mole_frac_comp[0, "bmimPF6"].fix(1 / 2)
assert degrees_of_freedom(model.fs) == 0
# Apply scaling - model will not solver without this
model.fs.unit.control_volume.properties_in[
0].calculate_scaling_factors()
model.fs.unit.control_volume.properties_out[
0].calculate_scaling_factors()
return model
def test_build(self):
model = ConcreteModel()
model.param = GenericParameterBlock(default=configuration)
assert isinstance(model.param.phase_list, Set)
assert len(model.param.phase_list) == 2
for i in model.param.phase_list:
assert i in ["Liq", "Vap"]
assert model.param.Liq.is_liquid_phase()
assert model.param.Vap.is_vapor_phase()
assert isinstance(model.param.component_list, Set)
assert len(model.param.component_list) == 2
for i in model.param.component_list:
assert i in ['bmimPF6',
'carbon_dioxide']
assert isinstance(model.param.get_component(i), Component)
assert isinstance(model.param._phase_component_set, Set)
assert len(model.param._phase_component_set) == 3
for i in model.param._phase_component_set:
assert i in [("Liq", "bmimPF6"), ("Liq", "carbon_dioxide"),
("Vap", "carbon_dioxide")]
assert model.param.config.state_definition == FTPx
assertStructuredAlmostEqual(
model.param.config.state_bounds,
{ "flow_mol": (0, 100, 1000, pyunits.mol/pyunits.s),
"temperature": (10, 300, 500, pyunits.K),
"pressure": (5e-4, 1e5, 1e10, pyunits.Pa) },
item_callback=lambda x: value(x) * (
pyunits.get_units(x) or pyunits.dimensionless)._get_pint_unit()
)
assert model.param.config.phase_equilibrium_state == {
("Vap", "Liq"): SmoothVLE}
assert isinstance(model.param.phase_equilibrium_idx, Set)
assert len(model.param.phase_equilibrium_idx) == 1
for i in model.param.phase_equilibrium_idx:
assert i in ["PE1"]
assert model.param.phase_equilibrium_list == {
"PE1": {"carbon_dioxide": ("Vap", "Liq")}}
assert model.param.pressure_ref.value == 101325
assert model.param.temperature_ref.value == 298.15
assert model.param.bmimPF6.mw.value == 284.18E-3
assert model.param.bmimPF6.pressure_crit.value == 24e5
assert model.param.bmimPF6.temperature_crit.value == 860
assert model.param.carbon_dioxide.mw.value == 44.010E-3
assert model.param.carbon_dioxide.pressure_crit.value == 71.8e5
assert model.param.carbon_dioxide.temperature_crit.value == 304.1
assert_units_consistent(model)
def model(self):
model = ConcreteModel()
model.params = GenericParameterBlock(default=configuration)
model.props = model.params.build_state_block(
[1], default={"defined_state": True})
return model
def phe(self):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.hotside_properties = GenericParameterBlock(default=aqueous_mea)
m.fs.coldside_properties = GenericParameterBlock(default=aqueous_mea)
m.fs.unit = PHE(
default={
'passes': 4,
'channels_per_pass': 12,
'number_of_divider_plates': 2,
"hot_side": {
"property_package": m.fs.hotside_properties
},
"cold_side": {
"property_package": m.fs.coldside_properties
}
})
# hot fluid
m.fs.unit.hot_inlet.flow_mol[0].fix(60.54879)
m.fs.unit.hot_inlet.temperature[0].fix(392.23)
m.fs.unit.hot_inlet.pressure[0].fix(202650)
m.fs.unit.hot_inlet.mole_frac_comp[0, "CO2"].fix(0.0158)
m.fs.unit.hot_inlet.mole_frac_comp[0, "H2O"].fix(0.8747)
m.fs.unit.hot_inlet.mole_frac_comp[0, "MEA"].fix(0.1095)
# cold fluid
m.fs.unit.cold_inlet.flow_mol[0].fix(63.01910)
m.fs.unit.cold_inlet.temperature[0].fix(326.36)
m.fs.unit.cold_inlet.pressure[0].fix(202650)
m.fs.unit.cold_inlet.mole_frac_comp[0, "CO2"].fix(0.0414)
m.fs.unit.cold_inlet.mole_frac_comp[0, "H2O"].fix(0.8509)
m.fs.unit.cold_inlet.mole_frac_comp[0, "MEA"].fix(0.1077)
# Fix unit geometry - default values should be correct
m.fs.unit.plate_length.fix()
m.fs.unit.plate_width.fix()
m.fs.unit.plate_thickness.fix()
m.fs.unit.plate_pact_length.fix()
m.fs.unit.port_diameter.fix()
m.fs.unit.plate_therm_cond.fix()
m.fs.unit.area.fix()
return m
def is_thermo_reaction_pair_valid(thermo_config, reaction_config):
model = ConcreteModel()
model.fs = FlowsheetBlock(default={"dynamic": False})
model.fs.thermo_params = GenericParameterBlock(default=thermo_config)
model.fs.rxn_params = GenericReactionParameterBlock(
default={"property_package": model.fs.thermo_params, **reaction_config}
)
return True
def build_ideal_naocl_prop(model):
model.fs.ideal_naocl_thermo_params = GenericParameterBlock(
default=ideal_naocl_thermo_config)
model.fs.ideal_naocl_rxn_params = GenericReactionParameterBlock(
default={
"property_package": model.fs.ideal_naocl_thermo_params,
**ideal_naocl_reaction_config
})
def m(self):
# Clear cached components to ensure clean slate
CoolPropWrapper.flush_cached_components()
m = ConcreteModel()
m.fs = FlowsheetBlock(default={'dynamic': False})
configuration = {
# Specifying components
"components": {
'benzene': {"type": Component,
"dens_mol_liq_comp": CoolPropWrapper,
"enth_mol_liq_comp": CoolPropWrapper,
"enth_mol_ig_comp": CoolPropWrapper,
"entr_mol_liq_comp": CoolPropWrapper,
"entr_mol_ig_comp": CoolPropWrapper,
"pressure_sat_comp": CoolPropWrapper,
"parameter_data": {
"mw": CoolPropWrapper,
"dens_mol_crit": CoolPropWrapper,
"pressure_crit": CoolPropWrapper,
"temperature_crit": CoolPropWrapper,
"omega": CoolPropWrapper}}},
# Specifying phases
"phases": {'Liq': {"type": LiquidPhase,
"equation_of_state": Cubic,
"equation_of_state_options": {
"type": CubicType.PR}}},
# Set base units of measurement
"base_units": {"time": pyunits.s,
"length": pyunits.m,
"mass": pyunits.kg,
"amount": pyunits.mol,
"temperature": pyunits.K},
# Specifying state definition
"state_definition": FTPx,
"state_bounds": {"flow_mol": (0, 100, 1000, pyunits.mol/pyunits.s),
"temperature": (273.15, 300, 500, pyunits.K),
"pressure": (5e4, 1e5, 1e6, pyunits.Pa)},
"pressure_ref": (101325, pyunits.Pa),
"temperature_ref": (298.15, pyunits.K),
"parameter_data": {"PR_kappa": {("benzene", "benzene"): 0.000}}}
m.fs.props = GenericParameterBlock(default=configuration)
m.fs.state = m.fs.props.build_state_block(
[0], default={"defined_state": True})
m.fs.state[0].flow_mol.fix(1)
m.fs.state[0].pressure.fix(101325)
m.fs.state[0].temperature.fix(300)
m.fs.state[0].mole_frac_comp["benzene"].fix(1)
return m
def test_build(self):
model = ConcreteModel()
model.params = GenericParameterBlock(default=config_dict)
assert isinstance(model.params.phase_list, Set)
assert len(model.params.phase_list) == 2
for i in model.params.phase_list:
assert i in ["Liq", "Vap"]
assert model.params.Liq.is_liquid_phase()
assert model.params.Vap.is_vapor_phase()
assert isinstance(model.params.component_list, Set)
assert len(model.params.component_list) == 2
for i in model.params.component_list:
assert i in ['benzene', 'toluene']
assert isinstance(model.params.get_component(i), Component)
assert isinstance(model.params._phase_component_set, Set)
assert len(model.params._phase_component_set) == 4
for i in model.params._phase_component_set:
assert i in [("Liq", "benzene"), ("Liq", "toluene"),
("Vap", "benzene"), ("Vap", "toluene")]
assert model.params.config.state_definition == FcPh
assertStructuredAlmostEqual(
model.params.config.state_bounds,
{
"flow_mol_comp": (0, 100, 1000, pyunits.mol / pyunits.s),
"enth_mol": (1e4, 5e4, 2e5, pyunits.J / pyunits.mol),
"temperature": (273.15, 300, 450, pyunits.K),
"pressure": (5e4, 1e5, 1e6, pyunits.Pa)
},
item_callback=_as_quantity,
)
assert model.params.config.phase_equilibrium_state == {
("Vap", "Liq"): SmoothVLE
}
assert isinstance(model.params.phase_equilibrium_idx, Set)
assert len(model.params.phase_equilibrium_idx) == 2
for i in model.params.phase_equilibrium_idx:
assert i in ["PE1", "PE2"]
assert model.params.phase_equilibrium_list == {
"PE1": {
"benzene": ("Vap", "Liq")
},
"PE2": {
"toluene": ("Vap", "Liq")
}
}
assert model.params.pressure_ref.value == 1e5
assert model.params.temperature_ref.value == 300
assert_units_consistent(model)
