def solve_RO(base="TDS", level="simple"):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
property_models.build_prop(m, base="TDS")
build_RO(m, base=base, level=level)
# specify feed
property_models.specify_feed(m.fs.RO.feed_side.properties[0, 0],
base="TDS")
m.fs.RO.feed_side.properties[0, 0].pressure.fix(50e5)
# scaling
calculate_scaling_factors(m)
# initialize
m.fs.RO.initialize(optarg={"nlp_scaling_method": "user-scaling"})
m.fs.RO.display()
check_dof(m)
solve_block(m)
m.fs.RO.report()
return m
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 solve_flowsheet(**desal_kwargs):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
build(m, **desal_kwargs)
TransformationFactory("network.expand_arcs").apply_to(m)
# scale
calculate_scaling_factors(m.fs.tb_pretrt_to_desal)
scale(m, **desal_kwargs)
calculate_scaling_factors(m)
# initialize
m.fs.feed.initialize()
propagate_state(m.fs.s_pretrt_tb)
optarg = {'nlp_scaling_method': 'user-scaling'}
m.fs.tb_pretrt_to_desal.initialize(optarg=optarg)
initialize(m, **desal_kwargs)
check_dof(m)
solve_block(m, tee=False, fail_flag=True)
# report
report(m, **desal_kwargs)
return m
def solve_flowsheet(**desal_kwargs):
if desal_kwargs == {}:
desal_kwargs = flowsheet_two_stage.desal_kwargs
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
build(m, **desal_kwargs)
TransformationFactory("network.expand_arcs").apply_to(m)
# scale
scale(m, **desal_kwargs)
calculate_scaling_factors(m)
# initialize
initialize(m, **desal_kwargs)
check_dof(m)
solve_block(m, tee=False, fail_flag=True)
# report
print("==================================="
"\n Simulation ")
report(m, **desal_kwargs)
return m
def run_ideal_naocl_mixer_example(fixed_dosage=False):
model = ConcreteModel()
model.fs = FlowsheetBlock(default={"dynamic": False})
# Add properties to model
build_ideal_naocl_prop(model)
# Add mixer to the model
build_ideal_naocl_mixer_unit(model)
# Set some inlet values
set_ideal_naocl_mixer_inlets(model)
# Fix the inlets for a solve
fix_ideal_naocl_mixer_inlets(model)
# unfix the flow_mol for the naocl_stream and fix dosing rate (alt form)
if fixed_dosage == True:
model.fs.ideal_naocl_mixer_unit.naocl_stream.flow_mol[0].unfix()
model.fs.ideal_naocl_mixer_unit.dosing_rate.fix()
check_dof(model)
# initializer mixer
initialize_ideal_naocl_mixer(model.fs.ideal_naocl_mixer_unit)
solve_block(model, tee=True)
display_results_of_ideal_naocl_mixer(model.fs.ideal_naocl_mixer_unit)
return model
def solve_pretreatment_NF(**kwargs):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
property_models.build_prop(m, base=kwargs["NF_base"])
build_pretreatment_NF(m, **kwargs)
TransformationFactory("network.expand_arcs").apply_to(m)
scale_pretreatment_NF(m, **kwargs)
initialize_pretreatment_NF(m, **kwargs)
check_dof(m)
solve_block(m, tee=True, fail_flag=True)
display_pretreatment_NF(m, **kwargs)
def solve_SepRO(base="TDS"):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
property_models.build_prop(m, base=base)
build_SepRO(m, base=base)
property_models.specify_feed(m.fs.RO.mixed_state[0], base=base)
check_dof(m)
calculate_scaling_factors(m)
solve_block(m)
m.fs.RO.inlet.display()
m.fs.RO.permeate.display()
m.fs.RO.retentate.display()
return m
def solve_SepNF(base="ion"):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
property_models.build_prop(m, base=base)
build_SepNF(m, base=base)
property_models.specify_feed(m.fs.NF.mixed_state[0], base=base)
m.fs.NF.mixed_state[0].mass_frac_phase_comp # touching for tests
check_dof(m)
calculate_scaling_factors(m)
solve_block(m)
m.fs.NF.inlet.display()
m.fs.NF.permeate.display()
m.fs.NF.retentate.display()
return m
def solve_ZONF(base="ion"):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
property_models.build_prop(m, base=base)
build_ZONF(m, base=base)
property_models.specify_feed(m.fs.NF.feed_side.properties_in[0], base="ion")
check_dof(m)
calculate_scaling_factors(m)
solve_block(m)
m.fs.NF.inlet.display()
m.fs.NF.permeate.display()
m.fs.NF.retentate.display()
return m
def solve_desalination(**kwargs):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
property_models.build_prop(m, base="TDS")
build_desalination(m, **kwargs)
TransformationFactory("network.expand_arcs").apply_to(m)
scale_desalination(m, **kwargs)
initialize_desalination(m, **kwargs)
check_dof(m)
solve_block(m)
display_desalination(m, **kwargs)
return m
def solve_flowsheet_mvp_NF(**kwargs):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
build_flowsheet_mvp_NF(m, **kwargs)
TransformationFactory("network.expand_arcs").apply_to(m)
# scale
pretreatment_NF.scale_pretreatment_NF(m, **kwargs)
calculate_scaling_factors(m.fs.tb_pretrt_to_desal)
desalination.scale_desalination(m, **kwargs)
calculate_scaling_factors(m)
# initialize
optarg = {"nlp_scaling_method": "user-scaling"}
pretreatment_NF.initialize_pretreatment_NF(m, **kwargs)
m.fs.pretrt_saturation.properties.initialize(optarg=optarg)
propagate_state(m.fs.s_pretrt_tb)
m.fs.tb_pretrt_to_desal.initialize(optarg=optarg)
propagate_state(m.fs.s_tb_desal)
desalination.initialize_desalination(m, **kwargs)
m.fs.desal_saturation.properties.initialize()
m.fs.costing.initialize()
# check_build(m)
# check_scaling(m)
check_dof(m)
solve_block(m, tee=False, fail_flag=True)
pretreatment_NF.display_pretreatment_NF(m, **kwargs)
m.fs.tb_pretrt_to_desal.report()
desalination.display_desalination(m, **kwargs)
print(
"desalination solubility index:", value(m.fs.desal_saturation.saturation_index)
)
print(
"pretreatment solubility index:", value(m.fs.pretrt_saturation.saturation_index)
)
print("water recovery:", value(m.fs.system_recovery))
print("LCOW:", value(m.fs.costing.LCOW))
print("CP modulus:", value(m.fs.desal_saturation.cp_modulus))
return m
def solve():
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
build(m)
TransformationFactory("network.expand_arcs").apply_to(m)
scale(m)
initialize(m)
check_dof(m)
# solve
solve_block(m)
# display
display(m)
return m
def solve_flowsheet(has_bypass=True):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
build(m, has_bypass=has_bypass)
TransformationFactory("network.expand_arcs").apply_to(m)
# scale
scale(m, has_bypass=has_bypass)
calculate_scaling_factors(m)
# initialize
initialize(m, has_bypass=has_bypass)
check_dof(m)
solve_block(m, tee=True, fail_flag=True)
# report
report(m, has_bypass=has_bypass)
return m
def solve_flowsheet(**desal_kwargs):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
build(m, **desal_kwargs)
TransformationFactory("network.expand_arcs").apply_to(m)
# scale
scale(m, **desal_kwargs)
calculate_scaling_factors(m)
# initialize
m.fs.feed.initialize()
propagate_state(m.fs.s_pretrt_tb)
initialize(m, **desal_kwargs)
check_dof(m)
solve_block(m, tee=False, fail_flag=True)
# report
print('==================================='
'\n Simulation ')
report(m, **desal_kwargs)
return m
def solve_RO(base='TDS', level='simple'):
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
property_models.build_prop(m, base='TDS')
build_RO(m, base=base, level=level)
# specify feed
property_models.specify_feed(m.fs.RO.feed_side.properties_in[0],
base='TDS')
m.fs.RO.feed_side.properties_in[0].pressure.fix(50e5)
# scaling
calculate_scaling_factors(m)
# initialize
m.fs.RO.initialize(optarg={'nlp_scaling_method': 'user-scaling'})
check_dof(m)
solve_block(m)
m.fs.RO.report()
return m
def solve_specify_feed(base):
# build state block
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
build_prop(m, base=base)
if base == "TDS":
m.fs.stream = m.fs.prop_TDS.build_state_block([0], default={})
elif base == "ion":
m.fs.stream = m.fs.prop_ion.build_state_block([0], default={})
elif base == "salt":
m.fs.stream = m.fs.prop_salt.build_state_block([0], default={})
specify_feed(m.fs.stream[0], base=base)
m.fs.stream[
0].mass_frac_phase_comp # touch a variable to have a model with at least one constraint
# scale
calculate_scaling_factors(m.fs)
# solve
solve_block(m)
# display
m.fs.stream.display()
return m
def test_property_seawater_ions():
m = ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.properties = property_seawater_ions.PropParameterBlock()
m.fs.stream = m.fs.properties.build_state_block([0], default={})
# specify
feed_flow_mass = 1
feed_mass_frac = {
"Na": 11122e-6,
"Ca": 382e-6,
"Mg": 1394e-6,
"SO4": 2136e-6,
"Cl": 20300e-6,
}
m.fs.stream[0].flow_mass_phase_comp["Liq", "H2O"].fix(
feed_flow_mass * (1 - sum(x for x in feed_mass_frac.values())))
for s in feed_mass_frac:
m.fs.stream[0].flow_mass_phase_comp["Liq", s].fix(feed_flow_mass *
feed_mass_frac[s])
m.fs.stream[0].temperature.fix(273.15 + 25)
m.fs.stream[0].pressure.fix(101325)
m.fs.stream[0].mass_frac_phase_comp
m.fs.stream[0].flow_mol_phase_comp
# 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", "Na"))
m.fs.properties.set_default_scaling("flow_mass_phase_comp",
1e4,
index=("Liq", "Ca"))
m.fs.properties.set_default_scaling("flow_mass_phase_comp",
1e3,
index=("Liq", "Mg"))
m.fs.properties.set_default_scaling("flow_mass_phase_comp",
1e3,
index=("Liq", "SO4"))
m.fs.properties.set_default_scaling("flow_mass_phase_comp",
1e2,
index=("Liq", "Cl"))
iscale.calculate_scaling_factors(m.fs)
# checking state block
assert_units_consistent(m)
check_dof(m)
# initialize
m.fs.stream.initialize(optarg={"nlp_scaling_method": "user-scaling"})
# solve
solve_block(m)
# check values
assert value(m.fs.stream[0].mass_frac_phase_comp["Liq",
"H2O"]) == pytest.approx(
0.9647, rel=1e-3)
assert value(m.fs.stream[0].flow_mol_phase_comp["Liq",
"Na"]) == pytest.approx(
0.4838, rel=1e-3)
assert value(m.fs.stream[0].flow_mol_phase_comp["Liq",
"Ca"]) == pytest.approx(
9.531e-3, rel=1e-3)
def optimize(m, check_termination=True):
return solve_block(m, tee=False, fail_flag=check_termination)
def optimize(m):
solve_block(m, tee=False, fail_flag=True)
def simulate(m, check_termination=True):
return solve_block(m, tee=False, fail_flag=check_termination)
