def test_build(self, iapws):
assert len(iapws.fs.unit.inlet.vars) == 3
assert hasattr(iapws.fs.unit.inlet, "flow_mol")
assert hasattr(iapws.fs.unit.inlet, "enth_mol")
assert hasattr(iapws.fs.unit.inlet, "pressure")
assert hasattr(iapws.fs.unit, "outlet")
assert len(iapws.fs.unit.outlet.vars) == 3
assert hasattr(iapws.fs.unit.outlet, "flow_mol")
assert hasattr(iapws.fs.unit.outlet, "enth_mol")
assert hasattr(iapws.fs.unit.outlet, "pressure")
assert hasattr(iapws.fs.unit, "heat_duty")
assert number_variables(iapws) == 8
assert number_total_constraints(iapws) == 3
assert number_unused_variables(iapws) == 0
def test_build(self, sapon):
assert hasattr(sapon.fs.unit, "flow_vol")
assert hasattr(sapon.fs.unit, "conc_mol_comp")
assert hasattr(sapon.fs.unit, "temperature")
assert hasattr(sapon.fs.unit, "pressure")
assert hasattr(sapon.fs.unit, "outlet")
assert len(sapon.fs.unit.outlet.vars) == 4
assert hasattr(sapon.fs.unit.outlet, "flow_vol")
assert hasattr(sapon.fs.unit.outlet, "conc_mol_comp")
assert hasattr(sapon.fs.unit.outlet, "temperature")
assert hasattr(sapon.fs.unit.outlet, "pressure")
assert number_variables(sapon) == 8
assert number_total_constraints(sapon) == 0
assert number_unused_variables(sapon) == 8
def test_build(self, iron_oc):
assert hasattr(iron_oc.fs.unit, "gas_inlet")
assert len(iron_oc.fs.unit.gas_inlet.vars) == 4
assert isinstance(iron_oc.fs.unit.gas_inlet.flow_mol, Var)
assert isinstance(iron_oc.fs.unit.gas_inlet.mole_frac_comp, Var)
assert isinstance(iron_oc.fs.unit.gas_inlet.temperature, Var)
assert isinstance(iron_oc.fs.unit.gas_inlet.pressure, Var)
assert hasattr(iron_oc.fs.unit, "solid_inlet")
assert len(iron_oc.fs.unit.solid_inlet.vars) == 3
assert isinstance(iron_oc.fs.unit.solid_inlet.flow_mass, Var)
assert isinstance(iron_oc.fs.unit.solid_inlet.mass_frac_comp, Var)
assert isinstance(iron_oc.fs.unit.solid_inlet.temperature, Var)
assert hasattr(iron_oc.fs.unit, "gas_outlet")
assert len(iron_oc.fs.unit.gas_outlet.vars) == 4
assert isinstance(iron_oc.fs.unit.gas_outlet.flow_mol, Var)
assert isinstance(iron_oc.fs.unit.gas_outlet.mole_frac_comp, Var)
assert isinstance(iron_oc.fs.unit.gas_outlet.temperature, Var)
assert isinstance(iron_oc.fs.unit.gas_outlet.pressure, Var)
assert hasattr(iron_oc.fs.unit, "solid_outlet")
assert len(iron_oc.fs.unit.solid_outlet.vars) == 3
assert isinstance(iron_oc.fs.unit.solid_outlet.flow_mass, Var)
assert isinstance(iron_oc.fs.unit.solid_outlet.mass_frac_comp, Var)
assert isinstance(iron_oc.fs.unit.solid_outlet.temperature, Var)
assert isinstance(iron_oc.fs.unit.bed_area_eqn, Constraint)
assert isinstance(iron_oc.fs.unit.gas_phase_area, Constraint)
assert isinstance(iron_oc.fs.unit.solid_phase_area, Constraint)
assert isinstance(iron_oc.fs.unit.gas_phase_length, Constraint)
assert isinstance(iron_oc.fs.unit.solid_phase_length, Constraint)
assert isinstance(iron_oc.fs.unit.gas_super_vel, Constraint)
assert isinstance(iron_oc.fs.unit.solid_super_vel, Constraint)
assert isinstance(iron_oc.fs.unit.gas_phase_config_pressure_drop,
Constraint)
assert isinstance(iron_oc.fs.unit.gas_solid_htc_eqn, Constraint)
assert isinstance(iron_oc.fs.unit.gas_phase_heat_transfer, Constraint)
assert isinstance(iron_oc.fs.unit.solid_phase_config_rxn_ext,
Constraint)
assert isinstance(iron_oc.fs.unit.gas_comp_hetero_rxn, Constraint)
assert number_variables(iron_oc) == 799
assert number_total_constraints(iron_oc) == 765
assert number_unused_variables(iron_oc) == 12
def test_build(self, iron_oc):
assert isinstance(iron_oc.fs.unit.volume_bed_constraint, Constraint)
assert isinstance(iron_oc.fs.unit.volume_solid_constraint, Constraint)
assert isinstance(iron_oc.fs.unit.solids_material_holdup_constraints,
Constraint)
assert isinstance(iron_oc.fs.unit
.solids_material_accumulation_constraints,
Constraint)
assert isinstance(iron_oc.fs.unit.mass_solids_constraint, Constraint)
assert isinstance(iron_oc.fs.unit.sum_component_constraint, Constraint)
assert isinstance(iron_oc.fs.unit.solids_energy_holdup_constraints,
Constraint)
assert isinstance(iron_oc.fs.unit
.solids_energy_accumulation_constraints, Constraint)
assert number_variables(iron_oc) == 3650
assert number_total_constraints(iron_oc) == 2925
assert number_unused_variables(iron_oc) == 206
def test_build(self, btx):
assert hasattr(btx.fs.unit, "flow_mol")
assert hasattr(btx.fs.unit, "mole_frac_comp")
assert hasattr(btx.fs.unit, "temperature")
assert hasattr(btx.fs.unit, "pressure")
assert hasattr(btx.fs.unit, "outlet")
assert len(btx.fs.unit.outlet.vars) == 4
assert hasattr(btx.fs.unit.outlet, "flow_mol")
assert hasattr(btx.fs.unit.outlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.outlet, "temperature")
assert hasattr(btx.fs.unit.outlet, "pressure")
assert hasattr(btx.fs.unit, "isothermal")
assert number_variables(btx) == 34
assert number_total_constraints(btx) == 29
assert number_unused_variables(btx) == 0
def test_build(self, btx):
assert hasattr(btx.fs.unit, "hot_inlet")
assert len(btx.fs.unit.hot_inlet.vars) == 4
assert hasattr(btx.fs.unit.hot_inlet, "flow_mol")
assert hasattr(btx.fs.unit.hot_inlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.hot_inlet, "temperature")
assert hasattr(btx.fs.unit.hot_inlet, "pressure")
assert hasattr(btx.fs.unit, "cold_inlet")
assert len(btx.fs.unit.cold_inlet.vars) == 4
assert hasattr(btx.fs.unit.cold_inlet, "flow_mol")
assert hasattr(btx.fs.unit.cold_inlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.cold_inlet, "temperature")
assert hasattr(btx.fs.unit.cold_inlet, "pressure")
assert hasattr(btx.fs.unit, "hot_outlet")
assert len(btx.fs.unit.hot_outlet.vars) == 4
assert hasattr(btx.fs.unit.hot_outlet, "flow_mol")
assert hasattr(btx.fs.unit.hot_outlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.hot_outlet, "temperature")
assert hasattr(btx.fs.unit.hot_outlet, "pressure")
assert hasattr(btx.fs.unit, "cold_outlet")
assert len(btx.fs.unit.cold_outlet.vars) == 4
assert hasattr(btx.fs.unit.cold_outlet, "flow_mol")
assert hasattr(btx.fs.unit.cold_outlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.cold_outlet, "temperature")
assert hasattr(btx.fs.unit.cold_outlet, "pressure")
assert isinstance(btx.fs.unit.overall_heat_transfer_coefficient, Var)
assert isinstance(btx.fs.unit.area, Var)
assert not hasattr(btx.fs.unit, "crossflow_factor")
assert isinstance(btx.fs.unit.heat_duty, Var)
assert isinstance(btx.fs.unit.delta_temperature_in, Var)
assert isinstance(btx.fs.unit.delta_temperature_out, Var)
assert isinstance(btx.fs.unit.unit_heat_balance, Constraint)
assert isinstance(btx.fs.unit.delta_temperature, (Var, Expression))
assert isinstance(btx.fs.unit.heat_transfer_equation, Constraint)
assert number_variables(btx) == 50
assert number_total_constraints(btx) == 38
assert number_unused_variables(btx) == 0
def test_build(self, methane):
assert hasattr(methane.fs.unit, "inlet")
assert len(methane.fs.unit.inlet.vars) == 3
assert hasattr(methane.fs.unit.inlet, "flow_mol_comp")
assert hasattr(methane.fs.unit.inlet, "temperature")
assert hasattr(methane.fs.unit.inlet, "pressure")
assert hasattr(methane.fs.unit, "outlet")
assert len(methane.fs.unit.outlet.vars) == 3
assert hasattr(methane.fs.unit.outlet, "flow_mol_comp")
assert hasattr(methane.fs.unit.outlet, "temperature")
assert hasattr(methane.fs.unit.outlet, "pressure")
assert hasattr(methane.fs.unit, "gibbs_minimization")
assert hasattr(methane.fs.unit, "heat_duty")
assert hasattr(methane.fs.unit, "deltaP")
assert number_variables(methane) == 78
assert number_total_constraints(methane) == 66
assert number_unused_variables(methane) == 0
def test_build(self, btx):
assert hasattr(btx.fs.unit, "properties")
assert hasattr(btx.fs.unit, "inlet")
assert len(btx.fs.unit.inlet.vars) == 4
assert hasattr(btx.fs.unit.inlet, "flow_mol")
assert hasattr(btx.fs.unit.inlet, "mole_frac")
assert hasattr(btx.fs.unit.inlet, "temperature")
assert hasattr(btx.fs.unit.inlet, "pressure")
assert hasattr(btx.fs.unit, "outlet")
assert len(btx.fs.unit.outlet.vars) == 4
assert hasattr(btx.fs.unit.outlet, "flow_mol")
assert hasattr(btx.fs.unit.outlet, "mole_frac")
assert hasattr(btx.fs.unit.outlet, "temperature")
assert hasattr(btx.fs.unit.outlet, "pressure")
assert number_variables(btx) == 8
assert number_total_constraints(btx) == 3
assert number_unused_variables(btx) == 2
def test_build(self, trans):
assert hasattr(trans.fs.unit, "properties_in")
assert hasattr(trans.fs.unit, "properties_out")
assert hasattr(trans.fs.unit, "inlet")
assert len(trans.fs.unit.inlet.vars) == 4
assert hasattr(trans.fs.unit.inlet, "flow_vol")
assert hasattr(trans.fs.unit.inlet, "conc_mol_comp")
assert hasattr(trans.fs.unit.inlet, "temperature")
assert hasattr(trans.fs.unit.inlet, "pressure")
assert hasattr(trans.fs.unit, "outlet")
assert len(trans.fs.unit.outlet.vars) == 4
assert hasattr(trans.fs.unit.outlet, "flow_mol")
assert hasattr(trans.fs.unit.outlet, "mole_frac_comp")
assert hasattr(trans.fs.unit.outlet, "temperature")
assert hasattr(trans.fs.unit.outlet, "pressure")
assert number_variables(trans) == 25
assert number_total_constraints(trans) == 12
assert number_unused_variables(trans) == 8
def test_build(self, btx):
assert hasattr(btx.fs.unit, "inlet")
assert len(btx.fs.unit.inlet.vars) == 4
assert hasattr(btx.fs.unit.inlet, "flow_mol")
assert hasattr(btx.fs.unit.inlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.inlet, "temperature")
assert hasattr(btx.fs.unit.inlet, "pressure")
assert hasattr(btx.fs.unit, "outlet")
assert len(btx.fs.unit.outlet.vars) == 4
assert hasattr(btx.fs.unit.outlet, "flow_mol")
assert hasattr(btx.fs.unit.outlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.outlet, "temperature")
assert hasattr(btx.fs.unit.outlet, "pressure")
assert hasattr(btx.fs.unit, "heat_duty")
assert hasattr(btx.fs.unit, "deltaP")
assert number_variables(btx) == 24
assert number_total_constraints(btx) == 17
assert number_unused_variables(btx) == 0
def test_build(self, iron_oc):
assert hasattr(iron_oc.fs.unit, "gas_inlet")
assert len(iron_oc.fs.unit.gas_inlet.vars) == 4
assert isinstance(iron_oc.fs.unit.gas_inlet.flow_mol, Var)
assert isinstance(iron_oc.fs.unit.gas_inlet.mole_frac_comp, Var)
assert isinstance(iron_oc.fs.unit.gas_inlet.temperature, Var)
assert isinstance(iron_oc.fs.unit.gas_inlet.pressure, Var)
assert hasattr(iron_oc.fs.unit, "solid_inlet")
assert len(iron_oc.fs.unit.solid_inlet.vars) == 4
assert isinstance(iron_oc.fs.unit.solid_inlet.flow_mass, Var)
assert isinstance(iron_oc.fs.unit.solid_inlet.particle_porosity, Var)
assert isinstance(iron_oc.fs.unit.solid_inlet.mass_frac_comp, Var)
assert isinstance(iron_oc.fs.unit.solid_inlet.temperature, Var)
assert hasattr(iron_oc.fs.unit, "gas_outlet")
assert len(iron_oc.fs.unit.gas_outlet.vars) == 4
assert isinstance(iron_oc.fs.unit.gas_outlet.flow_mol, Var)
assert isinstance(iron_oc.fs.unit.gas_outlet.mole_frac_comp, Var)
assert isinstance(iron_oc.fs.unit.gas_outlet.temperature, Var)
assert isinstance(iron_oc.fs.unit.gas_outlet.pressure, Var)
assert hasattr(iron_oc.fs.unit, "solid_outlet")
assert len(iron_oc.fs.unit.solid_outlet.vars) == 4
assert isinstance(iron_oc.fs.unit.solid_outlet.flow_mass, Var)
assert isinstance(iron_oc.fs.unit.solid_outlet.particle_porosity, Var)
assert isinstance(iron_oc.fs.unit.solid_outlet.mass_frac_comp, Var)
assert isinstance(iron_oc.fs.unit.solid_outlet.temperature, Var)
assert isinstance(iron_oc.fs.unit.gas_energy_balance_out, Constraint)
assert isinstance(iron_oc.fs.unit.solid_energy_balance_out, Constraint)
assert isinstance(iron_oc.fs.unit.isothermal_gas_emulsion, Constraint)
assert isinstance(iron_oc.fs.unit.isothermal_solid_emulsion,
Constraint)
assert isinstance(iron_oc.fs.unit.isothermal_bubble, Constraint)
assert number_variables(iron_oc) == 1144
assert number_total_constraints(iron_oc) == 1039
assert number_unused_variables(iron_oc) == 80
print(unused_variables_set(iron_oc))
def test_build(self, sapon):
assert hasattr(sapon.fs.unit, "inlet")
assert len(sapon.fs.unit.inlet.vars) == 4
assert hasattr(sapon.fs.unit.inlet, "flow_vol")
assert hasattr(sapon.fs.unit.inlet, "conc_mol_comp")
assert hasattr(sapon.fs.unit.inlet, "temperature")
assert hasattr(sapon.fs.unit.inlet, "pressure")
assert hasattr(sapon.fs.unit, "outlet")
assert len(sapon.fs.unit.outlet.vars) == 4
assert hasattr(sapon.fs.unit.outlet, "flow_vol")
assert hasattr(sapon.fs.unit.outlet, "conc_mol_comp")
assert hasattr(sapon.fs.unit.outlet, "temperature")
assert hasattr(sapon.fs.unit.outlet, "pressure")
assert hasattr(sapon.fs.unit, "rate_reaction_constraint")
assert hasattr(sapon.fs.unit, "heat_duty")
assert hasattr(sapon.fs.unit, "deltaP")
assert number_variables(sapon) == 26
assert number_total_constraints(sapon) == 16
assert number_unused_variables(sapon) == 0
def test_build(self, btg):
assert hasattr(btg.fs.unit, "inlet")
assert len(btg.fs.unit.inlet.vars) == 4
assert hasattr(btg.fs.unit.inlet, "flow_mol")
assert hasattr(btg.fs.unit.inlet, "mole_frac_comp")
assert hasattr(btg.fs.unit.inlet, "temperature")
assert hasattr(btg.fs.unit.inlet, "pressure")
assert hasattr(btg.fs.unit, "outlet")
assert len(btg.fs.unit.outlet.vars) == 4
assert hasattr(btg.fs.unit.outlet, "flow_mol")
assert hasattr(btg.fs.unit.outlet, "mole_frac_comp")
assert hasattr(btg.fs.unit.outlet, "temperature")
assert hasattr(btg.fs.unit.outlet, "pressure")
assert hasattr(btg.fs.unit, "heat_duty")
assert hasattr(btg.fs.unit, "deltaP")
assert number_variables(btg) == 74
assert number_total_constraints(btg) == 37
# Unused vars are density parameters
assert number_unused_variables(btg) == 10
def test_build(self, sapon):
assert len(sapon.fs.unit.inlet_1.vars) == 4
assert hasattr(sapon.fs.unit.inlet_1, "flow_vol")
assert hasattr(sapon.fs.unit.inlet_1, "conc_mol_comp")
assert hasattr(sapon.fs.unit.inlet_1, "temperature")
assert hasattr(sapon.fs.unit.inlet_1, "pressure")
assert len(sapon.fs.unit.outlet_1.vars) == 4
assert hasattr(sapon.fs.unit.outlet_1, "flow_vol")
assert hasattr(sapon.fs.unit.outlet_1, "conc_mol_comp")
assert hasattr(sapon.fs.unit.outlet_1, "temperature")
assert hasattr(sapon.fs.unit.outlet_1, "pressure")
assert len(sapon.fs.unit.inlet_2.vars) == 4
assert hasattr(sapon.fs.unit.inlet_2, "flow_vol")
assert hasattr(sapon.fs.unit.inlet_2, "conc_mol_comp")
assert hasattr(sapon.fs.unit.inlet_2, "temperature")
assert hasattr(sapon.fs.unit.inlet_2, "pressure")
assert len(sapon.fs.unit.outlet_2.vars) == 4
assert hasattr(sapon.fs.unit.outlet_2, "flow_vol")
assert hasattr(sapon.fs.unit.outlet_2, "conc_mol_comp")
assert hasattr(sapon.fs.unit.outlet_2, "temperature")
assert hasattr(sapon.fs.unit.outlet_2, "pressure")
assert isinstance(sapon.fs.unit.overall_heat_transfer_coefficient, Var)
assert isinstance(sapon.fs.unit.area, Var)
assert isinstance(sapon.fs.unit.crossflow_factor, Var)
assert isinstance(sapon.fs.unit.heat_duty, Var)
assert isinstance(sapon.fs.unit.delta_temperature_in, Var)
assert isinstance(sapon.fs.unit.delta_temperature_out, Var)
assert isinstance(sapon.fs.unit.unit_heat_balance, Constraint)
assert isinstance(sapon.fs.unit.delta_temperature, (Expression, Var))
assert isinstance(sapon.fs.unit.heat_transfer_equation, Constraint)
assert number_variables(sapon) == 39
assert number_total_constraints(sapon) == 20
assert number_unused_variables(sapon) == 0
def test_build(self, btx):
assert hasattr(btx.fs.unit, "inlet")
assert len(btx.fs.unit.inlet.vars) == 4
assert hasattr(btx.fs.unit.inlet, "flow_mol")
assert hasattr(btx.fs.unit.inlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.inlet, "temperature")
assert hasattr(btx.fs.unit.inlet, "pressure")
assert hasattr(btx.fs.unit, "outlet")
assert len(btx.fs.unit.outlet.vars) == 4
assert hasattr(btx.fs.unit.outlet, "flow_mol")
assert hasattr(btx.fs.unit.outlet, "mole_frac_comp")
assert hasattr(btx.fs.unit.outlet, "temperature")
assert hasattr(btx.fs.unit.outlet, "pressure")
assert hasattr(btx.fs.unit, "work_mechanical")
assert hasattr(btx.fs.unit, "deltaP")
assert isinstance(btx.fs.unit.ratioP, Var)
assert isinstance(btx.fs.unit.ratioP_calculation, Constraint)
assert number_variables(btx) == 25
assert number_total_constraints(btx) == 19
assert number_unused_variables(btx) == 0
def test_build(self, iapws):
assert len(iapws.fs.unit.inlet_1.vars) == 3
assert hasattr(iapws.fs.unit.inlet_1, "flow_mol")
assert hasattr(iapws.fs.unit.inlet_1, "enth_mol")
assert hasattr(iapws.fs.unit.inlet_1, "pressure")
assert hasattr(iapws.fs.unit, "outlet_1")
assert len(iapws.fs.unit.outlet_1.vars) == 3
assert hasattr(iapws.fs.unit.outlet_1, "flow_mol")
assert hasattr(iapws.fs.unit.outlet_1, "enth_mol")
assert hasattr(iapws.fs.unit.outlet_1, "pressure")
assert len(iapws.fs.unit.inlet_2.vars) == 3
assert hasattr(iapws.fs.unit.inlet_2, "flow_mol")
assert hasattr(iapws.fs.unit.inlet_2, "enth_mol")
assert hasattr(iapws.fs.unit.inlet_2, "pressure")
assert hasattr(iapws.fs.unit, "outlet_2")
assert len(iapws.fs.unit.outlet_2.vars) == 3
assert hasattr(iapws.fs.unit.outlet_2, "flow_mol")
assert hasattr(iapws.fs.unit.outlet_2, "enth_mol")
assert hasattr(iapws.fs.unit.outlet_2, "pressure")
assert isinstance(iapws.fs.unit.overall_heat_transfer_coefficient, Var)
assert isinstance(iapws.fs.unit.area, Var)
assert not hasattr(iapws.fs.unit, "crossflow_factor")
assert isinstance(iapws.fs.unit.heat_duty, Var)
assert isinstance(iapws.fs.unit.delta_temperature_in, Var)
assert isinstance(iapws.fs.unit.delta_temperature_out, Var)
assert isinstance(iapws.fs.unit.unit_heat_balance, Constraint)
assert isinstance(iapws.fs.unit.delta_temperature, (Expression, Var))
assert isinstance(iapws.fs.unit.heat_transfer_equation, Constraint)
assert number_variables(iapws) == 18
assert number_total_constraints(iapws) == 10
assert number_unused_variables(iapws) == 0
def test_stats_equilibrium(self, equilibrium_reactions_config):
model = equilibrium_reactions_config
assert (number_variables(model) == 233)
assert (number_total_constraints(model) == 72)
def test_build(self, RO_frame):
m = RO_frame
# test ports
port_lst = ['inlet', 'retentate', 'permeate']
for port_str in port_lst:
port = getattr(m.fs.unit, port_str)
assert len(port.vars) == 3 # number of state variables for NaCl property package
assert isinstance(port, Port)
# test pyomo objects on unit
unit_objs_type_dict = {'dens_solvent': Param,
'A_comp': Var,
'B_comp': Var,
'flux_mass_phase_comp': Var,
'area': Var,
'recovery_vol_phase': Var,
'recovery_mass_phase_comp': Var,
'rejection_phase_comp': Var,
'deltaP': Var,
'cp_modulus': Var,
'mass_transfer_phase_comp': Var,
'flux_mass_phase_comp_avg': Expression,
'over_pressure_ratio': Expression,
'eq_mass_transfer_term': Constraint,
'eq_permeate_production': Constraint,
'eq_flux_mass': Constraint,
'eq_connect_mass_transfer': Constraint,
'eq_connect_enthalpy_transfer': Constraint,
'eq_permeate_isothermal': Constraint,
'eq_recovery_vol_phase': Constraint,
'eq_recovery_mass_phase_comp': Constraint,
'eq_rejection_phase_comp': Constraint,
'eq_mass_frac_permeate': Constraint,
'eq_permeate_outlet_isothermal': Constraint,
'eq_permeate_outlet_isobaric': Constraint,
'eq_flow_vol_permeate': Constraint,
'nfe': Param,
}
for (obj_str, obj_type) in unit_objs_type_dict.items():
obj = getattr(m.fs.unit, obj_str)
assert isinstance(obj, obj_type)
# check that all added unit objects are tested
for obj in m.fs.unit.component_objects(
[Param, Var, Expression, Constraint], descend_into=False):
obj_str = obj.local_name
if obj_str[0] == '_':
continue # do not test hidden references
assert obj_str in unit_objs_type_dict
# test feed-side control volume and associated stateblocks
assert isinstance(m.fs.unit.feed_side, ControlVolume0DBlock)
cv_stateblock_lst = ['properties_in', 'properties_out',
'properties_interface',]
for sb_str in cv_stateblock_lst:
sb = getattr(m.fs.unit.feed_side, sb_str)
assert isinstance(sb, props.NaClStateBlock)
# test objects added to control volume
cv_objs_type_dict = {'eq_concentration_polarization': Constraint,
'eq_equal_temp_interface': Constraint,
'eq_equal_pressure_interface': Constraint,
'eq_equal_flow_vol_interface': Constraint}
for (obj_str, obj_type) in cv_objs_type_dict.items():
obj = getattr(m.fs.unit.feed_side, obj_str)
assert isinstance(obj, obj_type)
# test statistics
assert number_variables(m) == 125
assert number_total_constraints(m) == 96
assert number_unused_variables(m) == 7 # vars from property package parameters
def test_stats(self, chlorination_obj):
model = chlorination_obj
assert (number_variables(model) == 278)
assert (number_total_constraints(model) == 99)
assert (number_unused_variables(model) == 43)
def test_CP_calculation_with_kf_fixed(self):
""" Testing 0D-RO with ConcentrationPolarizationType.calculated option enabled.
This option makes use of an alternative constraint for the feed-side, membrane-interface concentration.
Additionally, two more variables are created when this option is enabled: Kf - feed-channel
mass transfer coefficients at the channel inlet and outlet.
"""
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.properties = props.NaClParameterBlock()
m.fs.unit = ReverseOsmosis0D(default={
"property_package": m.fs.properties,
"has_pressure_change": True,
"concentration_polarization_type": ConcentrationPolarizationType.calculated,
"mass_transfer_coefficient": MassTransferCoefficient.fixed})
# fully specify system
feed_flow_mass = 1
feed_mass_frac_NaCl = 0.035
feed_pressure = 50e5
feed_temperature = 273.15 + 25
membrane_pressure_drop = 3e5
membrane_area = 50
A = 4.2e-12
B = 3.5e-8
pressure_atmospheric = 101325
kf = 2e-5
feed_mass_frac_H2O = 1 - feed_mass_frac_NaCl
m.fs.unit.inlet.flow_mass_phase_comp[0, 'Liq', 'NaCl'].fix(
feed_flow_mass * feed_mass_frac_NaCl)
m.fs.unit.inlet.flow_mass_phase_comp[0, 'Liq', 'H2O'].fix(
feed_flow_mass * feed_mass_frac_H2O)
m.fs.unit.inlet.pressure[0].fix(feed_pressure)
m.fs.unit.inlet.temperature[0].fix(feed_temperature)
m.fs.unit.deltaP.fix(-membrane_pressure_drop)
m.fs.unit.area.fix(membrane_area)
m.fs.unit.A_comp.fix(A)
m.fs.unit.B_comp.fix(B)
m.fs.unit.permeate.pressure[0].fix(pressure_atmospheric)
m.fs.unit.Kf[0, 0., 'NaCl'].fix(kf)
m.fs.unit.Kf[0, 1., 'NaCl'].fix(kf)
# test statistics
assert number_variables(m) == 125
assert number_total_constraints(m) == 96
assert number_unused_variables(m) == 7 # vars from property package parameters
# test degrees of freedom
assert degrees_of_freedom(m) == 0
# test scaling
m.fs.properties.set_default_scaling('flow_mass_phase_comp', 1, index=('Liq', 'H2O'))
m.fs.properties.set_default_scaling('flow_mass_phase_comp', 1e2, index=('Liq', 'NaCl'))
calculate_scaling_factors(m)
# check that all variables have scaling factors.
# TODO: Setting the "include_fixed" arg as True reveals
# unscaled vars that weren't being accounted for previously. However, calling the whole block (i.e.,
# m) shows that several NaCl property parameters are unscaled. For now, we are just interested in ensuring
# unit variables are scaled (hence, calling m.fs.unit) but might need to revisit scaling and associated
# testing for property models.
unscaled_var_list = list(unscaled_variables_generator(m.fs.unit, include_fixed=True))
assert len(unscaled_var_list) == 0
# # test initialization
initialization_tester(m, fail_on_warning=True)
# test variable scaling
badly_scaled_var_lst = list(badly_scaled_var_generator(m))
assert badly_scaled_var_lst == []
# test solve
results = solver.solve(m)
# Check for optimal solution
assert_optimal_termination(results)
# test solution
assert (pytest.approx(3.815e-3, rel=1e-3) ==
value(m.fs.unit.flux_mass_phase_comp_avg[0, 'Liq', 'H2O']))
assert (pytest.approx(1.668e-6, rel=1e-3) ==
value(m.fs.unit.flux_mass_phase_comp_avg[0, 'Liq', 'NaCl']))
assert (pytest.approx(0.1908, rel=1e-3) ==
value(m.fs.unit.mixed_permeate[0].flow_mass_phase_comp['Liq', 'H2O']))
assert (pytest.approx(8.337e-5, rel=1e-3) ==
value(m.fs.unit.mixed_permeate[0].flow_mass_phase_comp['Liq', 'NaCl']))
assert (pytest.approx(46.07, rel=1e-3) ==
value(m.fs.unit.feed_side.properties_interface[0, 0.].conc_mass_phase_comp['Liq', 'NaCl']))
assert (pytest.approx(44.34, rel=1e-3) ==
value(m.fs.unit.feed_side.properties_out[0].conc_mass_phase_comp['Liq', 'NaCl']))
assert (pytest.approx(50.20, rel=1e-3) ==
value(m.fs.unit.feed_side.properties_interface[0, 1.].conc_mass_phase_comp['Liq', 'NaCl']))
def test_Pdrop_fixed_per_unit_length(self):
""" Testing 0D-RO with PressureChangeType.fixed_per_unit_length option.
"""
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.properties = props.NaClParameterBlock()
m.fs.unit = ReverseOsmosis0D(default={
"property_package": m.fs.properties,
"has_pressure_change": True,
"concentration_polarization_type": ConcentrationPolarizationType.calculated,
"mass_transfer_coefficient": MassTransferCoefficient.calculated,
"pressure_change_type": PressureChangeType.fixed_per_unit_length})
# fully specify system
feed_flow_mass = 1
feed_mass_frac_NaCl = 0.035
feed_mass_frac_H2O = 1 - feed_mass_frac_NaCl
feed_pressure = 50e5
feed_temperature = 273.15 + 25
membrane_area = 50
length = 20
A = 4.2e-12
B = 3.5e-8
pressure_atmospheric = 101325
membrane_pressure_drop = 3e5
m.fs.unit.inlet.flow_mass_phase_comp[0, 'Liq', 'NaCl'].fix(
feed_flow_mass * feed_mass_frac_NaCl)
m.fs.unit.inlet.flow_mass_phase_comp[0, 'Liq', 'H2O'].fix(
feed_flow_mass * feed_mass_frac_H2O)
m.fs.unit.inlet.pressure[0].fix(feed_pressure)
m.fs.unit.inlet.temperature[0].fix(feed_temperature)
m.fs.unit.area.fix(membrane_area)
m.fs.unit.A_comp.fix(A)
m.fs.unit.B_comp.fix(B)
m.fs.unit.permeate.pressure[0].fix(pressure_atmospheric)
m.fs.unit.channel_height.fix(0.002)
m.fs.unit.spacer_porosity.fix(0.75)
m.fs.unit.length.fix(length)
m.fs.unit.dP_dx.fix(-membrane_pressure_drop / length)
# test statistics
assert number_variables(m) == 142
assert number_total_constraints(m) == 112
assert number_unused_variables(m) == 0
# test degrees of freedom
assert degrees_of_freedom(m) == 0
# test scaling
m.fs.properties.set_default_scaling('flow_mass_phase_comp', 1, index=('Liq', 'H2O'))
m.fs.properties.set_default_scaling('flow_mass_phase_comp', 1e2, index=('Liq', 'NaCl'))
calculate_scaling_factors(m)
# check that all variables have scaling factors.
# TODO: see aforementioned TODO on revisiting scaling and associated testing for property models.
unscaled_var_list = list(unscaled_variables_generator(m.fs.unit, include_fixed=True))
assert len(unscaled_var_list) == 0
# test initialization
initialization_tester(m, fail_on_warning=True)
# test variable scaling
badly_scaled_var_lst = list(badly_scaled_var_generator(m))
assert badly_scaled_var_lst == []
# test solve
results = solver.solve(m, tee=True)
# Check for optimal solution
assert_optimal_termination(results)
# test solution
assert (pytest.approx(-3.000e5, rel=1e-3) == value(m.fs.unit.deltaP[0]))
assert (pytest.approx(4.562e-3, rel=1e-3) ==
value(m.fs.unit.flux_mass_phase_comp_avg[0, 'Liq', 'H2O']))
assert (pytest.approx(1.593e-6, rel=1e-3) ==
value(m.fs.unit.flux_mass_phase_comp_avg[0, 'Liq', 'NaCl']))
assert (pytest.approx(0.2281, rel=1e-3) ==
value(m.fs.unit.mixed_permeate[0].flow_mass_phase_comp['Liq', 'H2O']))
assert (pytest.approx(7.963e-5, rel=1e-3) ==
value(m.fs.unit.mixed_permeate[0].flow_mass_phase_comp['Liq', 'NaCl']))
assert (pytest.approx(41.96, rel=1e-3) ==
value(m.fs.unit.feed_side.properties_interface[0,0.].conc_mass_phase_comp['Liq', 'NaCl']))
assert (pytest.approx(46.57, rel=1e-3) ==
value(m.fs.unit.feed_side.properties_out[0].conc_mass_phase_comp['Liq', 'NaCl']))
assert (pytest.approx(49.94, rel=1e-3) ==
value(m.fs.unit.feed_side.properties_interface[0, 1.].conc_mass_phase_comp['Liq', 'NaCl']))
def test_stats_inherent(self, inherent_reactions_config):
model = inherent_reactions_config
assert (number_variables(model) == 281)
assert (number_total_constraints(model) == 72)
def test_build(self, btx_ftpz, btx_fctp):
# General build
assert hasattr(btx_ftpz.fs.unit, "material_mixing_equations")
assert hasattr(btx_ftpz.fs.unit, "enthalpy_mixing_equations")
assert hasattr(btx_ftpz.fs.unit, "pressure_drop_equation")
assert btx_ftpz.fs.unit.config.has_heat_transfer
assert hasattr(btx_ftpz.fs.unit, "heat_duty")
assert btx_ftpz.fs.unit.config.has_pressure_change
assert hasattr(btx_ftpz.fs.unit, "deltaP")
# State blocks
assert hasattr(btx_ftpz.fs.unit, "properties_in_liq")
assert hasattr(btx_ftpz.fs.unit, "properties_in_vap")
assert hasattr(btx_ftpz.fs.unit, "properties_out")
# Ports
assert hasattr(btx_ftpz.fs.unit, "liq_in")
assert hasattr(btx_ftpz.fs.unit.liq_in, "flow_mol")
assert hasattr(btx_ftpz.fs.unit.liq_in, "mole_frac_comp")
assert hasattr(btx_ftpz.fs.unit.liq_in, "temperature")
assert hasattr(btx_ftpz.fs.unit.liq_in, "pressure")
assert hasattr(btx_ftpz.fs.unit, "vap_in")
assert hasattr(btx_ftpz.fs.unit.vap_in, "flow_mol")
assert hasattr(btx_ftpz.fs.unit.vap_in, "mole_frac_comp")
assert hasattr(btx_ftpz.fs.unit.vap_in, "temperature")
assert hasattr(btx_ftpz.fs.unit.vap_in, "pressure")
assert hasattr(btx_ftpz.fs.unit, "liq_out")
assert hasattr(btx_ftpz.fs.unit.liq_out, "flow_mol")
assert hasattr(btx_ftpz.fs.unit.liq_out, "mole_frac_comp")
assert hasattr(btx_ftpz.fs.unit.liq_out, "temperature")
assert hasattr(btx_ftpz.fs.unit.liq_out, "pressure")
assert hasattr(btx_ftpz.fs.unit, "vap_out")
assert hasattr(btx_ftpz.fs.unit.vap_out, "flow_mol")
assert hasattr(btx_ftpz.fs.unit.vap_out, "mole_frac_comp")
assert hasattr(btx_ftpz.fs.unit.vap_out, "temperature")
assert hasattr(btx_ftpz.fs.unit.vap_out, "pressure")
assert not hasattr(btx_ftpz.fs.unit, "feed")
assert not hasattr(btx_ftpz.fs.unit, "liq_side_draw")
assert not hasattr(btx_ftpz.fs.unit, "liq_side_sf")
assert not hasattr(btx_ftpz.fs.unit, "vap_side_draw")
assert not hasattr(btx_ftpz.fs.unit, "vap_side_sf")
assert number_variables(btx_ftpz.fs.unit) == 71
assert number_total_constraints(btx_ftpz.fs.unit) == 59
assert number_unused_variables(btx_ftpz) == 0
# General build
assert hasattr(btx_fctp.fs.unit, "material_mixing_equations")
assert hasattr(btx_fctp.fs.unit, "enthalpy_mixing_equations")
assert hasattr(btx_fctp.fs.unit, "pressure_drop_equation")
assert btx_fctp.fs.unit.config.has_heat_transfer
assert hasattr(btx_fctp.fs.unit, "heat_duty")
assert btx_fctp.fs.unit.config.has_pressure_change
assert hasattr(btx_fctp.fs.unit, "deltaP")
# State blocks
assert hasattr(btx_fctp.fs.unit, "properties_in_liq")
assert hasattr(btx_fctp.fs.unit, "properties_in_vap")
assert hasattr(btx_fctp.fs.unit, "properties_out")
# Ports
assert hasattr(btx_fctp.fs.unit, "liq_in")
assert hasattr(btx_fctp.fs.unit.liq_in, "flow_mol_comp")
assert hasattr(btx_fctp.fs.unit.liq_in, "temperature")
assert hasattr(btx_fctp.fs.unit.liq_in, "pressure")
assert hasattr(btx_fctp.fs.unit, "vap_in")
assert hasattr(btx_fctp.fs.unit.vap_in, "flow_mol_comp")
assert hasattr(btx_fctp.fs.unit.vap_in, "temperature")
assert hasattr(btx_fctp.fs.unit.vap_in, "pressure")
assert hasattr(btx_fctp.fs.unit, "liq_out")
assert hasattr(btx_fctp.fs.unit.liq_out, "flow_mol_comp")
assert hasattr(btx_fctp.fs.unit.liq_out, "temperature")
assert hasattr(btx_fctp.fs.unit.liq_out, "pressure")
assert hasattr(btx_fctp.fs.unit, "vap_out")
assert hasattr(btx_fctp.fs.unit.vap_out, "flow_mol_comp")
assert hasattr(btx_fctp.fs.unit.vap_out, "temperature")
assert hasattr(btx_fctp.fs.unit.vap_out, "pressure")
assert not hasattr(btx_fctp.fs.unit, "feed")
assert not hasattr(btx_fctp.fs.unit, "liq_side_draw")
assert not hasattr(btx_fctp.fs.unit, "liq_side_sf")
assert not hasattr(btx_fctp.fs.unit, "vap_side_draw")
assert not hasattr(btx_fctp.fs.unit, "vap_side_sf")
assert number_variables(btx_fctp.fs.unit) == 74
assert number_total_constraints(btx_fctp.fs.unit) == 64
assert number_unused_variables(btx_fctp) == 0
def test_build(self, NF_frame):
m = NF_frame
# test ports and variables
port_lst = ["inlet", "retentate", "permeate"]
port_vars_lst = ["flow_mass_phase_comp", "pressure", "temperature"]
for port_str in port_lst:
assert hasattr(m.fs.unit, port_str)
port = getattr(m.fs.unit, port_str)
assert len(port.vars) == 3
assert isinstance(port, Port)
for var_str in port_vars_lst:
assert hasattr(port, var_str)
var = getattr(port, var_str)
assert isinstance(var, Var)
# test unit objects (including parameters, variables, and constraints)
unit_objs_lst = [
"A_comp",
"B_comp",
"sigma",
"dens_solvent",
"flux_mass_phase_comp_in",
"flux_mass_phase_comp_out",
"avg_conc_mass_phase_comp_in",
"avg_conc_mass_phase_comp_out",
"area",
"deltaP",
"mass_transfer_phase_comp",
"flux_mass_phase_comp_avg",
"eq_mass_transfer_term",
"eq_permeate_production",
"eq_flux_in",
"eq_flux_out",
"eq_avg_conc_in",
"eq_avg_conc_out",
"eq_connect_mass_transfer",
"eq_connect_enthalpy_transfer",
"eq_permeate_isothermal",
]
for obj_str in unit_objs_lst:
assert hasattr(m.fs.unit, obj_str)
# test state block objects
cv_name = "feed_side"
cv_stateblock_lst = ["properties_in", "properties_out"]
stateblock_objs_lst = [
"flow_mass_phase_comp",
"pressure",
"temperature",
"pressure_osm",
"osm_coeff",
"mass_frac_phase_comp",
"conc_mass_phase_comp",
"dens_mass_phase",
"enth_mass_phase",
"eq_pressure_osm",
"eq_osm_coeff",
"eq_mass_frac_phase_comp",
"eq_conc_mass_phase_comp",
"eq_dens_mass_phase",
"eq_enth_mass_phase",
]
# control volume
assert hasattr(m.fs.unit, cv_name)
cv_blk = getattr(m.fs.unit, cv_name)
for blk_str in cv_stateblock_lst:
assert hasattr(cv_blk, blk_str)
blk = getattr(cv_blk, blk_str)
for obj_str in stateblock_objs_lst:
assert hasattr(blk[0], obj_str)
# permeate
assert hasattr(m.fs.unit, "properties_permeate")
blk = getattr(m.fs.unit, "properties_permeate")
for var_str in stateblock_objs_lst:
assert hasattr(blk[0], var_str)
# test statistics
assert number_variables(m) == 73
assert number_total_constraints(m) == 45
assert number_unused_variables(
m) == 7 # vars from property package parameters
def test_statistics(self, frame):
m = frame
assert number_variables(m) == 38
assert number_total_constraints(m) == 16
assert number_unused_variables(m) == 1 # pressure is unused
def test_build(self, Crystallizer_frame):
m = Crystallizer_frame
# test ports and variables
port_lst = ["inlet", "outlet", "solids", "vapor"]
port_vars_lst = ["flow_mass_phase_comp", "pressure", "temperature"]
for port_str in port_lst:
assert hasattr(m.fs.unit, port_str)
port = getattr(m.fs.unit, port_str)
assert len(port.vars) == 3
assert isinstance(port, Port)
for var_str in port_vars_lst:
assert hasattr(port, var_str)
var = getattr(port, var_str)
assert isinstance(var, Var)
# test unit objects (including parameters, variables, and constraints)
# First, parameters
unit_objs_params_lst = [
"approach_temperature_heat_exchanger",
"dimensionless_crystal_length",
]
for obj_str in unit_objs_params_lst:
assert hasattr(m.fs.unit, obj_str)
# Next, variables
unit_objs_vars_lst = [
"crystal_growth_rate",
"crystal_median_length",
"crystallization_yield",
"dens_mass_magma",
"dens_mass_slurry",
"diameter_crystallizer",
"height_crystallizer",
"height_slurry",
"magma_circulation_flow_vol",
"pressure_operating",
"product_volumetric_solids_fraction",
"relative_supersaturation",
"souders_brown_constant",
"t_res",
"temperature_operating",
"volume_suspension",
"work_mechanical",
]
for obj_str in unit_objs_vars_lst:
assert hasattr(m.fs.unit, obj_str)
# Next, expressions
unit_objs_expr_lst = [
"eq_max_allowable_velocity",
"eq_minimum_height_diameter_ratio",
"eq_vapor_space_height",
]
for obj_str in unit_objs_expr_lst:
assert hasattr(m.fs.unit, obj_str)
# Finally, constraints
unit_objs_cons_lst = [
"eq_T_con1",
"eq_T_con2",
"eq_T_con3",
"eq_crystallizer_height_constraint",
"eq_dens_magma",
"eq_dens_mass_slurry",
"eq_enthalpy_balance",
"eq_mass_balance_constraints",
"eq_minimum_hex_circulation_rate_constraint",
"eq_operating_pressure_constraint",
"eq_p_con1",
"eq_p_con2",
"eq_p_con3",
"eq_relative_supersaturation",
"eq_removal_balance",
"eq_residence_time",
"eq_slurry_height_constraint",
"eq_solubility_massfrac_equality_constraint",
"eq_suspension_volume",
"eq_vapor_head_diameter_constraint",
"eq_vol_fraction_solids",
]
for obj_str in unit_objs_cons_lst:
assert hasattr(m.fs.unit, obj_str)
# Test stateblocks
# List olf attributes on all stateblocks
stateblock_objs_lst = [
"flow_mass_phase_comp",
"pressure",
"temperature",
"solubility_mass_phase_comp",
"solubility_mass_frac_phase_comp",
"mass_frac_phase_comp",
"dens_mass_solvent",
"dens_mass_solute",
"dens_mass_phase",
"cp_phase",
"cp_solvent",
"flow_vol_phase",
"flow_vol",
"enth_flow",
"enth_mass_solvent",
"dh_crystallization",
"eq_solubility_mass_phase_comp",
"eq_solubility_mass_frac_phase_comp",
"eq_mass_frac_phase_comp",
"eq_dens_mass_solvent",
"eq_dens_mass_solute",
"eq_dens_mass_phase",
"eq_cp_solute",
"eq_cp_phase",
"eq_flow_vol_phase",
"eq_enth_mass_solvent",
]
# List of attributes for liquid stateblocks only
stateblock_objs_liq_lst = ["pressure_sat", "eq_pressure_sat"]
# Inlet block
assert hasattr(m.fs.unit, "properties_in")
blk = getattr(m.fs.unit, "properties_in")
for var_str in stateblock_objs_lst:
assert hasattr(blk[0], var_str)
for var_str in stateblock_objs_liq_lst:
assert hasattr(blk[0], var_str)
# Liquid outlet block
assert hasattr(m.fs.unit, "properties_out")
blk = getattr(m.fs.unit, "properties_out")
for var_str in stateblock_objs_lst:
assert hasattr(blk[0], var_str)
for var_str in stateblock_objs_liq_lst:
assert hasattr(blk[0], var_str)
# Vapor outlet block
assert hasattr(m.fs.unit, "properties_vapor")
blk = getattr(m.fs.unit, "properties_vapor")
for var_str in stateblock_objs_lst:
assert hasattr(blk[0], var_str)
# Liquid outlet block
assert hasattr(m.fs.unit, "properties_solids")
blk = getattr(m.fs.unit, "properties_solids")
for var_str in stateblock_objs_lst:
assert hasattr(blk[0], var_str)
# test statistics
assert number_variables(m) == 238
assert number_total_constraints(m) == 124
assert number_unused_variables(m) == 4
def test_stats_stoich(self, water_stoich):
m = water_stoich
assert number_variables(m) == 123
assert number_total_constraints(m) == 54
assert number_unused_variables(m) == 59
def test_build():
m = ConcreteModel()
m.fs = FlowsheetBlock(default={'dynamic': False})
m.fs.properties = props.SeawaterParameterBlock()
m.fs.unit = PressureExchanger(
default={'property_package': m.fs.properties})
# test ports and state variables
port_lst = [
'low_pressure_inlet', 'low_pressure_outlet', 'high_pressure_inlet',
'high_pressure_outlet'
]
port_vars_lst = ['flow_mass_phase_comp', 'pressure', 'temperature']
for port_str in port_lst:
assert hasattr(m.fs.unit, port_str)
port = getattr(m.fs.unit, port_str)
assert len(port.vars) == 3
assert isinstance(port, Port)
for var_str in port_vars_lst:
assert hasattr(port, var_str)
var = getattr(port, var_str)
assert isinstance(var, Var)
# test unit variables
assert hasattr(m.fs.unit, 'efficiency_pressure_exchanger')
assert isinstance(m.fs.unit.efficiency_pressure_exchanger, Var)
# test unit constraints
unit_cons_lst = [
'eq_pressure_transfer', 'eq_equal_flow_vol', 'eq_equal_low_pressure'
]
for c in unit_cons_lst:
assert hasattr(m.fs.unit, c)
con = getattr(m.fs.unit, c)
assert isinstance(con, Constraint)
# test control volumes, only terms directly used by pressure exchanger
cv_list = ['low_pressure_side', 'high_pressure_side']
cv_var_lst = ['deltaP']
cv_con_lst = ['eq_isothermal_temperature']
cv_exp_lst = ['work']
for cv_str in cv_list:
assert hasattr(m.fs.unit, cv_str)
cv = getattr(m.fs.unit, cv_str)
for cv_var_str in cv_var_lst:
cv_var = getattr(cv, cv_var_str)
assert isinstance(cv_var, Var)
for cv_con_str in cv_con_lst:
cv_con = getattr(cv, cv_con_str)
assert isinstance(cv_con, Constraint)
for cv_exp_str in cv_exp_lst:
cv_exp = getattr(cv, cv_exp_str)
assert isinstance(cv_exp, Expression)
# test state blocks, only terms directly used by pressure exchanger
cv_stateblock_lst = ['properties_in', 'properties_out']
stateblock_var_lst = ['pressure', 'temperature']
stateblock_exp_lst = ['flow_vol']
for cv_str in cv_list:
cv = getattr(m.fs.unit, cv_str)
for cv_sb_str in cv_stateblock_lst:
assert hasattr(cv, cv_sb_str)
cv_sb = getattr(cv, cv_sb_str)
for sb_var_str in stateblock_var_lst:
assert hasattr(cv_sb[0], sb_var_str)
sb_var = getattr(cv_sb[0], sb_var_str)
assert isinstance(sb_var, Var)
for sb_exp_str in stateblock_exp_lst:
assert hasattr(cv_sb[0], sb_exp_str)
sb_exp = getattr(cv_sb[0], sb_exp_str)
assert isinstance(sb_exp, Expression)
# test statistics
assert number_variables(m.fs.unit) == 39
assert number_total_constraints(m.fs.unit) == 31
assert number_unused_variables(m.fs.unit) == 0
def test_build(self, btx_ftpz, btx_fctp):
assert hasattr(btx_ftpz.fs.unit, "reflux_ratio")
assert not hasattr(btx_ftpz.fs.unit, "eq_total_cond_spec")
assert hasattr(btx_ftpz.fs.unit, "inlet")
assert hasattr(btx_ftpz.fs.unit.inlet, "flow_mol")
assert hasattr(btx_ftpz.fs.unit.inlet, "mole_frac_comp")
assert hasattr(btx_ftpz.fs.unit.inlet, "temperature")
assert hasattr(btx_ftpz.fs.unit.inlet, "pressure")
assert hasattr(btx_ftpz.fs.unit, "reflux")
assert hasattr(btx_ftpz.fs.unit.reflux, "flow_mol")
assert hasattr(btx_ftpz.fs.unit.reflux, "mole_frac_comp")
assert hasattr(btx_ftpz.fs.unit.reflux, "temperature")
assert hasattr(btx_ftpz.fs.unit.reflux, "pressure")
assert hasattr(btx_ftpz.fs.unit, "distillate")
assert hasattr(btx_ftpz.fs.unit.distillate, "flow_mol")
assert hasattr(btx_ftpz.fs.unit.distillate, "mole_frac_comp")
assert hasattr(btx_ftpz.fs.unit.distillate, "temperature")
assert hasattr(btx_ftpz.fs.unit.distillate, "pressure")
assert hasattr(btx_ftpz.fs.unit, "vapor_outlet")
assert hasattr(btx_ftpz.fs.unit.vapor_outlet, "flow_mol")
assert hasattr(btx_ftpz.fs.unit.vapor_outlet, "mole_frac_comp")
assert hasattr(btx_ftpz.fs.unit.vapor_outlet, "temperature")
assert hasattr(btx_ftpz.fs.unit.vapor_outlet, "pressure")
assert number_variables(btx_ftpz.fs.unit) == 48
assert number_total_constraints(btx_ftpz.fs.unit) == 40
assert number_unused_variables(btx_ftpz) == 1
assert hasattr(btx_fctp.fs.unit, "reflux_ratio")
assert not hasattr(btx_fctp.fs.unit, "eq_total_cond_spec")
assert hasattr(btx_fctp.fs.unit, "inlet")
assert hasattr(btx_fctp.fs.unit.inlet, "flow_mol_comp")
assert hasattr(btx_fctp.fs.unit.inlet, "temperature")
assert hasattr(btx_fctp.fs.unit.inlet, "pressure")
assert hasattr(btx_fctp.fs.unit, "reflux")
assert hasattr(btx_fctp.fs.unit.reflux, "flow_mol_comp")
assert hasattr(btx_fctp.fs.unit.reflux, "temperature")
assert hasattr(btx_fctp.fs.unit.reflux, "pressure")
assert hasattr(btx_fctp.fs.unit, "distillate")
assert hasattr(btx_fctp.fs.unit.distillate, "flow_mol_comp")
assert hasattr(btx_fctp.fs.unit.distillate, "temperature")
assert hasattr(btx_fctp.fs.unit.distillate, "pressure")
assert hasattr(btx_fctp.fs.unit, "vapor_outlet")
assert hasattr(btx_fctp.fs.unit.vapor_outlet, "flow_mol_comp")
assert hasattr(btx_fctp.fs.unit.vapor_outlet, "temperature")
assert hasattr(btx_fctp.fs.unit.vapor_outlet, "pressure")
assert number_variables(btx_fctp.fs.unit) == 50
assert number_total_constraints(btx_fctp.fs.unit) == 43
assert number_unused_variables(btx_fctp) == 1
def test_Pdrop_calculation(self):
"""Testing 0D-RO with PressureChangeType.calculated option."""
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.properties = props.NaClParameterBlock()
m.fs.unit = ReverseOsmosis0D(
default={
"property_package": m.fs.properties,
"has_pressure_change": True,
"concentration_polarization_type":
ConcentrationPolarizationType.calculated,
"mass_transfer_coefficient":
MassTransferCoefficient.calculated,
"pressure_change_type": PressureChangeType.calculated,
})
# fully specify system
feed_flow_mass = 1 / 3.6
feed_mass_frac_NaCl = 0.035
feed_mass_frac_H2O = 1 - feed_mass_frac_NaCl
feed_pressure = 70e5
feed_temperature = 273.15 + 25
membrane_area = 19
A = 4.2e-12
B = 3.5e-8
pressure_atmospheric = 101325
m.fs.unit.inlet.flow_mass_phase_comp[0, "Liq", "NaCl"].fix(
feed_flow_mass * feed_mass_frac_NaCl)
m.fs.unit.inlet.flow_mass_phase_comp[0, "Liq", "H2O"].fix(
feed_flow_mass * feed_mass_frac_H2O)
m.fs.unit.inlet.pressure[0].fix(feed_pressure)
m.fs.unit.inlet.temperature[0].fix(feed_temperature)
m.fs.unit.area.fix(membrane_area)
m.fs.unit.A_comp.fix(A)
m.fs.unit.B_comp.fix(B)
m.fs.unit.permeate.pressure[0].fix(pressure_atmospheric)
m.fs.unit.channel_height.fix(0.001)
m.fs.unit.spacer_porosity.fix(0.97)
m.fs.unit.length.fix(16)
# test statistics
assert number_variables(m) == 147
assert number_total_constraints(m) == 118
assert number_unused_variables(
m) == 0 # vars from property package parameters
# test degrees of freedom
assert degrees_of_freedom(m) == 0
# test scaling
m.fs.properties.set_default_scaling("flow_mass_phase_comp",
1,
index=("Liq", "H2O"))
m.fs.properties.set_default_scaling("flow_mass_phase_comp",
1e2,
index=("Liq", "NaCl"))
calculate_scaling_factors(m)
# check that all variables have scaling factors.
# TODO: see aforementioned TODO on revisiting scaling and associated testing for property models.
unscaled_var_list = list(
unscaled_variables_generator(m.fs.unit, include_fixed=True))
assert len(unscaled_var_list) == 0
# test initialization
initialization_tester(m, fail_on_warning=True)
# test variable scaling
badly_scaled_var_lst = list(badly_scaled_var_generator(m))
assert badly_scaled_var_lst == []
# test solve
results = solver.solve(m, tee=True)
# Check for optimal solution
assert_optimal_termination(results)
# test solution
assert pytest.approx(-1.661e5, rel=1e-3) == value(m.fs.unit.deltaP[0])
assert pytest.approx(-1.038e4, rel=1e-3) == value(m.fs.unit.deltaP[0] /
m.fs.unit.length)
assert pytest.approx(395.8, rel=1e-3) == value(m.fs.unit.N_Re[0, 0.0])
assert pytest.approx(0.2361,
rel=1e-3) == value(m.fs.unit.velocity[0, 0.0])
assert pytest.approx(191.1, rel=1e-3) == value(m.fs.unit.N_Re[0, 1.0])
assert pytest.approx(0.1187,
rel=1e-3) == value(m.fs.unit.velocity[0, 1.0])
assert pytest.approx(7.089e-3, rel=1e-3) == value(
m.fs.unit.flux_mass_phase_comp_avg[0, "Liq", "H2O"])
assert pytest.approx(2.188e-6, rel=1e-3) == value(
m.fs.unit.flux_mass_phase_comp_avg[0, "Liq", "NaCl"])
assert pytest.approx(0.1347, rel=1e-3) == value(
m.fs.unit.mixed_permeate[0].flow_mass_phase_comp["Liq", "H2O"])
assert pytest.approx(4.157e-5, rel=1e-3) == value(
m.fs.unit.mixed_permeate[0].flow_mass_phase_comp["Liq", "NaCl"])
assert pytest.approx(50.08, rel=1e-3) == value(
m.fs.unit.feed_side.properties_interface[
0, 0.0].conc_mass_phase_comp["Liq", "NaCl"])
assert pytest.approx(70.80, rel=1e-3) == value(
m.fs.unit.feed_side.properties_out[0].conc_mass_phase_comp["Liq",
"NaCl"])
assert pytest.approx(76.32, rel=1e-3) == value(
m.fs.unit.feed_side.properties_interface[
0, 1.0].conc_mass_phase_comp["Liq", "NaCl"])
