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)