def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={
"solute_list": [
"nonvolatile_toc",
"tds",
"chloride",
"electrical_conductivity",
"sodium",
"tss",
"foo",
]
})
m.fs.unit = WalnutShellFilterZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(1000)
m.fs.unit.inlet.flow_mass_comp[0, "nonvolatile_toc"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "tds"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "chloride"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "electrical_conductivity"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "sodium"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "foo"].fix(1)
return m
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={
"solute_list": [
"viruses_enteric",
"tss",
"toc",
"cryptosporidium",
"total_coliforms_fecal_ecoli",
]
})
m.fs.unit = UVAOPZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(10000)
m.fs.unit.inlet.flow_mass_comp[0, "viruses_enteric"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "toc"].fix(2)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(3)
m.fs.unit.inlet.flow_mass_comp[0, "cryptosporidium"].fix(5)
m.fs.unit.inlet.flow_mass_comp[0, "total_coliforms_fecal_ecoli"].fix(3)
return m
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={"solute_list": ["toc", "nitrate", "sulfate", "bar", "crux"]}
)
m.fs.unit = WellFieldZO(
default={
"property_package": m.fs.params,
"database": m.db,
"process_subtype": "emwd",
}
)
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(120)
m.fs.unit.inlet.flow_mass_comp[0, "toc"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "nitrate"].fix(2)
m.fs.unit.inlet.flow_mass_comp[0, "sulfate"].fix(0.3)
m.fs.unit.inlet.flow_mass_comp[0, "bar"].fix(40)
m.fs.unit.inlet.flow_mass_comp[0, "crux"].fix(0.0005)
return m
def test_costing():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"solute_list": ["tss"]})
m.fs.unit = FilterPressZO(
default={"property_package": m.fs.params, "database": m.db}
)
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(23)
m.fs.costing = ZeroOrderCosting()
m.fs.unit.load_parameters_from_database()
m.fs.unit.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing}
)
assert isinstance(m.fs.costing.filter_press, Block)
assert isinstance(m.fs.costing.filter_press.capital_a_parameter, Var)
assert isinstance(m.fs.costing.filter_press.capital_b_parameter, Var)
assert isinstance(m.fs.unit.costing.capital_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit) == 0
assert m.fs.unit.electricity[0] in m.fs.costing._registered_flows["electricity"]
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={
"solute_list": [
"tds",
"magnesium",
"calcium",
"nitrate",
"sulfate",
"tss",
]
})
m.fs.unit = EvaporationPondZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(10)
m.fs.unit.inlet.flow_mass_comp[0, "tds"].fix(123)
m.fs.unit.inlet.flow_mass_comp[0, "magnesium"].fix(456)
m.fs.unit.inlet.flow_mass_comp[0, "calcium"].fix(789)
m.fs.unit.inlet.flow_mass_comp[0, "nitrate"].fix(10)
m.fs.unit.inlet.flow_mass_comp[0, "sulfate"].fix(11)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(12)
return m
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={
"solute_list": [
"nitrogen",
"phosphates",
"bioconcentrated_phosphorous",
"nitrous_oxide",
]
}
)
m.fs.unit = CANDOPZO(
default={"property_package": m.fs.params, "database": m.db}
)
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(120)
m.fs.unit.inlet.flow_mass_comp[0, "nitrogen"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "phosphates"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "bioconcentrated_phosphorous"].fix(0)
m.fs.unit.inlet.flow_mass_comp[0, "nitrous_oxide"].fix(0)
return m
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={
"solute_list": [
"cod",
"nonbiodegradable_cod",
"ammonium_as_nitrogen",
"phosphate_as_phosphorous",
]
})
m.fs.unit = AnaerobicMBRMECZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(0.043642594)
m.fs.unit.inlet.flow_mass_comp[0, "cod"].fix(1.00625e-4)
m.fs.unit.inlet.flow_mass_comp[0, "nonbiodegradable_cod"].fix(1e-20)
m.fs.unit.inlet.flow_mass_comp[0,
"ammonium_as_nitrogen"].fix(4.59375e-06)
m.fs.unit.inlet.flow_mass_comp[0, "phosphate_as_phosphorous"].fix(
2.1875e-06)
return m
def test_custom_path():
# Pick a path we know will exist, even if it isn't a data folder
db = Database(dbpath=os.path.join(
os.path.dirname(os.path.abspath(__file__)), "..", "..", "core"))
assert db._dbpath == os.path.join(
os.path.dirname(os.path.abspath(__file__)), "..", "..", "core")
def test_costing():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"solute_list": ["nitrogen"]})
m.fs.costing = ZeroOrderCosting()
m.fs.unit = PhotothermalMembraneZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(120)
m.fs.unit.inlet.flow_mass_comp[0, "nitrogen"].fix(1)
m.fs.unit.load_parameters_from_database(use_default_removal=True)
assert degrees_of_freedom(m.fs.unit) == 0
m.fs.unit.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing})
assert isinstance(m.fs.costing.photothermal_membrane, Block)
assert isinstance(m.fs.costing.photothermal_membrane.membrane_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit) == 0
initialization_tester(m)
assert pytest.approx(4.719596,
rel=1e-5) == value(m.fs.unit.costing.capital_cost)
def test_invalid_path():
with pytest.raises(
OSError,
match="Could not find requested path foo. Please "
"check that this path exists.",
):
Database(dbpath="foo")
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={
"solute_list": [
"bod",
"tss",
"ammonium_as_nitrogen",
"nitrate",
"nitrogen",
]
})
m.fs.unit = DMBRZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(10)
m.fs.unit.inlet.flow_mass_comp[0, "bod"].fix(5)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(5)
m.fs.unit.inlet.flow_mass_comp[0, "ammonium_as_nitrogen"].fix(2)
m.fs.unit.inlet.flow_mass_comp[0, "nitrate"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "nitrogen"].fix(1)
return m
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={
"solute_list":
["eeq", "nonvolatile_toc", "toc", "nitrate", "tss", "foo"]
})
m.fs.unit = TriMediaFiltrationZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(10)
m.fs.unit.inlet.flow_mass_comp[0, "eeq"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "nonvolatile_toc"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "toc"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "nitrate"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "foo"].fix(1)
return m
def test_costing():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"solute_list": ["sulfur", "toc", "tss"]})
m.fs.costing = ZeroOrderCosting()
m.fs.unit1 = PumpElectricityZO(
default={"property_package": m.fs.params, "database": m.db}
)
m.fs.unit1.inlet.flow_mass_comp[0, "H2O"].fix(1e-5)
m.fs.unit1.inlet.flow_mass_comp[0, "sulfur"].fix(10)
m.fs.unit1.inlet.flow_mass_comp[0, "toc"].fix(20)
m.fs.unit1.inlet.flow_mass_comp[0, "tss"].fix(30)
m.fs.unit1.load_parameters_from_database()
assert degrees_of_freedom(m.fs.unit1) == 0
m.fs.unit1.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing}
)
assert isinstance(m.fs.costing.pump_electricity, Block)
assert isinstance(m.fs.costing.pump_electricity.pump_cost, Var)
assert isinstance(m.fs.unit1.costing.capital_cost, Var)
assert isinstance(m.fs.unit1.costing.capital_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit1) == 0
assert m.fs.unit1.electricity[0] in m.fs.costing._registered_flows["electricity"]
def test_costing():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={"solute_list": ["tss", "sulfate", "foo", "bar"]})
m.fs.costing = ZeroOrderCosting()
m.fs.unit = InjectionWellDisposalZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(123)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(4)
m.fs.unit.inlet.flow_mass_comp[0, "sulfate"].fix(0.005)
m.fs.unit.inlet.flow_mass_comp[0, "foo"].fix(0.67)
m.fs.unit.inlet.flow_mass_comp[0, "bar"].fix(8.9)
m.fs.unit.load_parameters_from_database()
assert degrees_of_freedom(m.fs.unit) == 0
initialization_tester(m)
results = solver.solve(m)
assert_optimal_termination(results)
assert isinstance(m.fs.costing.injection_well_disposal, Block)
assert isinstance(m.fs.costing.injection_well_disposal.capital_a_parameter,
Var)
assert isinstance(m.fs.costing.injection_well_disposal.capital_b_parameter,
Var)
assert isinstance(m.fs.unit.costing.capital_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost_constraint, Constraint)
def test_initialize():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"database": m.db})
m.fs.unit = FeedZO(default={"property_package": m.fs.params})
m.fs.unit.load_feed_data_from_database()
initialization_tester(m)
res = {
"H2O": 4263.816948529999,
"boron": 0.020166519999999997,
"bromide": 0.3038727899999999,
"calcium": 1.8773196799999994,
"chloride": 87.82519459999996,
"magnesium": 5.857457399999998,
"potassium": 1.8117784899999994,
"sodium": 48.945060699999985,
"strontium": 0.005958289999999999,
"sulfate": 12.283243999999996,
"tds": 160.41549999999995,
"tss": 0.13749899999999993,
}
for (t, j), v in m.fs.unit.outlet.flow_mass_comp.items():
assert value(v) == pytest.approx(res[j], rel=1e-5)
def test_costing():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={"solute_list": ["nitrogen", "phosphorus", "struvite", "foo"]})
source_file = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"..",
"..",
"..",
"examples",
"flowsheets",
"case_studies",
"wastewater_resource_recovery",
"electrochemical_nutrient_removal",
"case_1617.yaml",
)
m.fs.costing = ZeroOrderCosting(
default={"case_study_definition": source_file})
m.fs.unit = ElectroNPZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(1000)
m.fs.unit.inlet.flow_mass_comp[0, "nitrogen"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "phosphorus"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "struvite"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "foo"].fix(1)
m.fs.unit.load_parameters_from_database(use_default_removal=True)
assert degrees_of_freedom(m.fs.unit) == 0
m.fs.unit.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing})
assert isinstance(m.fs.costing.electrochemical_nutrient_removal, Block)
assert isinstance(m.fs.costing.electrochemical_nutrient_removal.HRT, Var)
assert isinstance(
m.fs.costing.electrochemical_nutrient_removal.sizing_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit) == 0
initialization_tester(m)
results = solver.solve(m)
assert_optimal_termination(results)
assert m.fs.unit.electricity[0] in m.fs.costing._registered_flows[
"electricity"]
assert (m.fs.unit.MgCl2_flowrate[0]
in m.fs.costing._registered_flows["magnesium_chloride"])
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"database": m.db})
m.fs.unit = FeedZO(default={"property_package": m.fs.params})
return m
def test_costing(subtype):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={"solute_list": ["sulfur", "toc", "tss"]})
m.fs.costing = ZeroOrderCosting()
m.fs.unit1 = FixedBedZO(
default={
"property_package": m.fs.params,
"database": m.db,
"process_subtype": subtype,
})
m.fs.unit1.inlet.flow_mass_comp[0, "H2O"].fix(10000)
m.fs.unit1.inlet.flow_mass_comp[0, "sulfur"].fix(1)
m.fs.unit1.inlet.flow_mass_comp[0, "toc"].fix(2)
m.fs.unit1.inlet.flow_mass_comp[0, "tss"].fix(3)
m.fs.unit1.load_parameters_from_database(use_default_removal=True)
assert degrees_of_freedom(m.fs.unit1) == 0
m.fs.unit1.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing})
assert isinstance(m.fs.costing.fixed_bed, Block)
assert isinstance(m.fs.costing.fixed_bed.capital_a_parameter, Var)
assert isinstance(m.fs.costing.fixed_bed.capital_b_parameter, Var)
assert isinstance(m.fs.costing.fixed_bed.reference_state, Var)
assert isinstance(m.fs.unit1.costing.capital_cost, Var)
assert isinstance(m.fs.unit1.costing.capital_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit1) == 0
assert m.fs.unit1.electricity[0] in m.fs.costing._registered_flows[
"electricity"]
assert (m.fs.unit1.acetic_acid_demand[0]
in m.fs.costing._registered_flows["acetic_acid"])
assert (m.fs.unit1.phosphoric_acid_demand[0]
in m.fs.costing._registered_flows["phosphoric_acid"])
assert (m.fs.unit1.ferric_chloride_demand[0]
in m.fs.costing._registered_flows["ferric_chloride"])
assert (m.fs.unit1.activated_carbon_demand[0]
in m.fs.costing._registered_flows["activated_carbon"])
assert m.fs.unit1.sand_demand[0] in m.fs.costing._registered_flows["sand"]
assert (m.fs.unit1.anthracite_demand[0]
in m.fs.costing._registered_flows["anthracite"])
assert (m.fs.unit1.cationic_polymer_demand[0]
in m.fs.costing._registered_flows["cationic_polymer"])
def test_default_path():
db = Database()
assert os.path.normpath(db._dbpath) == os.path.normpath(
os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"..",
"..",
"data",
"techno_economic",
))
def test_costing():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={"solute_list": ["iron", "manganese", "foo"]})
m.fs.costing = ZeroOrderCosting()
m.fs.unit1 = IronManganeseRemovalZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit1.inlet.flow_mass_comp[0, "H2O"].fix(10000)
m.fs.unit1.inlet.flow_mass_comp[0, "iron"].fix(250)
m.fs.unit1.inlet.flow_mass_comp[0, "manganese"].fix(250)
m.fs.unit1.inlet.flow_mass_comp[0, "foo"].fix(1)
m.fs.unit1.load_parameters_from_database(use_default_removal=True)
assert degrees_of_freedom(m.fs.unit1) == 0
m.fs.unit1.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing})
assert isinstance(m.fs.costing.iron_and_manganese_removal, Block)
assert isinstance(
m.fs.costing.iron_and_manganese_removal.capital_blower_a_parameter,
Var)
assert isinstance(
m.fs.costing.iron_and_manganese_removal.capital_backwash_a_parameter,
Var)
assert isinstance(
m.fs.costing.iron_and_manganese_removal.capital_backwash_b_parameter,
Var)
assert isinstance(
m.fs.costing.iron_and_manganese_removal.capital_filter_a_parameter,
Var)
assert isinstance(
m.fs.costing.iron_and_manganese_removal.capital_filter_b_parameter,
Var)
assert isinstance(m.fs.costing.iron_and_manganese_removal.flow_exponent,
Var)
assert isinstance(m.fs.unit1.costing.capital_cost, Var)
assert isinstance(m.fs.unit1.costing.capital_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit1) == 0
assert m.fs.unit1.electricity[0] in m.fs.costing._registered_flows[
"electricity"]
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={"solute_list": ["sulfur", "toc", "tss"]})
m.fs.costing = ZeroOrderCosting()
return m
def test_costing(subtype):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={"solute_list": ["sulfur", "toc", "tds"]})
m.fs.costing = ZeroOrderCosting()
m.fs.unit1 = IonExchangeZO(default={
"property_package": m.fs.params,
"database": m.db,
"process_subtype": subtype})
m.fs.unit1.inlet.flow_mass_comp[0, "H2O"].fix(10000)
m.fs.unit1.inlet.flow_mass_comp[0, "sulfur"].fix(1)
m.fs.unit1.inlet.flow_mass_comp[0, "toc"].fix(2)
m.fs.unit1.inlet.flow_mass_comp[0, "tds"].fix(3)
m.fs.unit1.load_parameters_from_database(use_default_removal=True)
assert degrees_of_freedom(m.fs.unit1) == 0
m.fs.unit1.costing = UnitModelCostingBlock(default={
"flowsheet_costing_block": m.fs.costing})
assert isinstance(m.fs.costing.ion_exchange, Block)
assert isinstance(m.fs.costing.ion_exchange.capital_a_parameter,
Var)
assert isinstance(m.fs.costing.ion_exchange.capital_b_parameter,
Var)
assert isinstance(m.fs.costing.ion_exchange.capital_c_parameter,
Var)
assert isinstance(m.fs.costing.ion_exchange.capital_d_parameter,
Var)
assert isinstance(m.fs.unit1.costing.capital_cost, Var)
assert isinstance(m.fs.unit1.costing.capital_cost_constraint,
Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit1) == 0
assert m.fs.unit1.electricity[0] in \
m.fs.costing._registered_flows["electricity"]
assert m.fs.unit1.NaCl_flowrate[0] in \
m.fs.costing._registered_flows["sodium_chloride"]
assert m.fs.unit1.resin_demand[0] in \
m.fs.costing._registered_flows["ion_exchange_resin"]
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"solute_list": ["foo"]})
m.fs.unit = SWOnshoreIntakeZO(default={"property_package": m.fs.params,
"database": m.db})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(10000)
m.fs.unit.inlet.flow_mass_comp[0, "foo"].fix(1)
return m
def test_toc_in_solute_list(self):
model = ConcreteModel()
model.db = Database()
model.fs = FlowsheetBlock(default={"dynamic": False})
model.fs.params = WaterParameterBlock(
default={"solute_list": ["cryptosporidium", "viruses_enteric"]})
with pytest.raises(
ConfigurationError,
match="TOC must be in solute list for Ozonation or Ozone/AOP"):
model.fs.unit = OzoneAOPZO(default={
"property_package": model.fs.params,
"database": model.db
})
def test_costing_non_default_subtype():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"solute_list": ["tds", "dye"]})
m.fs.costing = ZeroOrderCosting()
m.fs.unit = NanofiltrationZO(
default={
"property_package": m.fs.params,
"database": m.db,
"process_subtype": "rHGO_dye_rejection",
}
)
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(10000)
m.fs.unit.inlet.flow_mass_comp[0, "tds"].fix(1)
m.fs.unit.inlet.flow_mass_comp[0, "dye"].fix(2)
m.fs.unit.load_parameters_from_database(use_default_removal=True)
assert degrees_of_freedom(m.fs.unit) == 0
m.fs.unit.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing}
)
assert isinstance(m.fs.unit.costing.capital_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost_constraint, Constraint)
assert isinstance(m.fs.costing.nanofiltration, Block)
assert isinstance(m.fs.unit.costing.variable_operating_cost, Var)
assert isinstance(m.fs.unit.costing.variable_operating_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit) == 0
initialization_tester(m)
results = solver.solve(m)
# Check for optimal solution
assert check_optimal_termination(results)
assert pytest.approx(39162.813807, rel=1e-5) == value(m.fs.unit.area)
assert pytest.approx(0.58744, rel=1e-5) == value(m.fs.unit.costing.capital_cost)
assert pytest.approx(0.088116, rel=1e-5) == value(
m.fs.unit.costing.variable_operating_cost
)
def test_costing(subtype):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"solute_list": ["sulfur", "toc", "tss"]})
m.fs.costing = ZeroOrderCosting()
m.fs.unit = LandfillZO(
default={
"property_package": m.fs.params,
"database": m.db,
"process_subtype": subtype,
}
)
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(1e-5)
m.fs.unit.inlet.flow_mass_comp[0, "sulfur"].fix(1000)
m.fs.unit.inlet.flow_mass_comp[0, "toc"].fix(2000)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(3000)
m.fs.unit.load_parameters_from_database()
m.fs.unit.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing}
)
assert isinstance(m.fs.costing.landfill, Block)
assert isinstance(m.fs.costing.landfill.capital_a_parameter, Var)
assert isinstance(m.fs.costing.landfill.capital_b_parameter, Var)
assert isinstance(m.fs.unit.costing.capital_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit) == 0
initialization_tester(m)
_ = solver.solve(m)
assert isinstance(m.fs.unit.costing.capital_cost_constraint, Constraint)
if subtype == "default":
assert pytest.approx(43.5627, rel=1e-5) == value(m.fs.unit.costing.capital_cost)
if subtype == "landfill_zld":
assert pytest.approx(20.09155, rel=1e-5) == value(
m.fs.unit.costing.capital_cost
)
assert m.fs.unit.electricity[0] in m.fs.costing._registered_flows["electricity"]
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.water_props = WaterParameterBlock(default={"solute_list": ["cod"]})
m.fs.unit = GasSpargedMembraneZO(
default={"property_package": m.fs.water_props, "database": m.db}
)
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(1000)
m.fs.unit.inlet.flow_mass_comp[0, "cod"].fix(1)
return m
def model(self):
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(default={"solute_list": ["tss"]})
m.fs.unit = MicroscreenFiltrationZO(
default={"property_package": m.fs.params, "database": m.db}
)
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(10)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(1)
return m
def test_COD_not_in_solute_list():
model = ConcreteModel()
model.db = Database()
model.fs = FlowsheetBlock(default={"dynamic": False})
model.fs.params = WaterParameterBlock(default={"solute_list": ["foo"]})
with pytest.raises(
ValueError,
match="cod must be included in the solute list since"
" this unit model converts cod to nonbiodegradable_cod.",
):
model.fs.unit = CofermentationZO(default={
"property_package": model.fs.params,
"database": model.db
})
def test_costing():
m = ConcreteModel()
m.db = Database()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.params = WaterParameterBlock(
default={
"solute_list":
["tds", "magnesium", "calcium", "nitrate", "sulfate", "tss"]
})
m.fs.costing = ZeroOrderCosting()
m.fs.unit = EvaporationPondZO(default={
"property_package": m.fs.params,
"database": m.db
})
m.fs.unit.inlet.flow_mass_comp[0, "H2O"].fix(10)
m.fs.unit.inlet.flow_mass_comp[0, "tds"].fix(123)
m.fs.unit.inlet.flow_mass_comp[0, "magnesium"].fix(456)
m.fs.unit.inlet.flow_mass_comp[0, "calcium"].fix(789)
m.fs.unit.inlet.flow_mass_comp[0, "nitrate"].fix(10)
m.fs.unit.inlet.flow_mass_comp[0, "sulfate"].fix(11)
m.fs.unit.inlet.flow_mass_comp[0, "tss"].fix(12)
m.fs.unit.load_parameters_from_database(use_default_removal=True)
m.fs.unit.costing = UnitModelCostingBlock(
default={"flowsheet_costing_block": m.fs.costing})
assert isinstance(m.fs.costing.evaporation_pond, Block)
assert isinstance(m.fs.costing.evaporation_pond.cost_per_acre_a_parameter,
Var)
assert isinstance(m.fs.costing.evaporation_pond.cost_per_acre_b_parameter,
Var)
assert isinstance(m.fs.costing.evaporation_pond.cost_per_acre_c_parameter,
Var)
assert isinstance(m.fs.costing.evaporation_pond.cost_per_acre_d_parameter,
Var)
assert isinstance(m.fs.costing.evaporation_pond.cost_per_acre_e_parameter,
Var)
assert isinstance(m.fs.costing.evaporation_pond.liner_thickness, Var)
assert isinstance(m.fs.costing.evaporation_pond.land_cost, Var)
assert isinstance(m.fs.costing.evaporation_pond.land_clearing_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost, Var)
assert isinstance(m.fs.unit.costing.capital_cost_constraint, Constraint)
assert_units_consistent(m.fs)
assert degrees_of_freedom(m.fs.unit) == 0
