From 2627e49fb0c028ef105fcab22bc4e3ff660e07c4 Mon Sep 17 00:00:00 2001 From: Mukta Hardikar Date: Fri, 27 Sep 2024 12:43:57 -0600 Subject: [PATCH 1/4] added alkalinity balance eq. Needs to be verified --- .../reflo/unit_models/chemical_softening.py | 36 ++++++++++++++++++- 1 file changed, 35 insertions(+), 1 deletion(-) diff --git a/src/watertap_contrib/reflo/unit_models/chemical_softening.py b/src/watertap_contrib/reflo/unit_models/chemical_softening.py index ee60ed2a..5cc29011 100644 --- a/src/watertap_contrib/reflo/unit_models/chemical_softening.py +++ b/src/watertap_contrib/reflo/unit_models/chemical_softening.py @@ -175,7 +175,7 @@ def build(self): non_hardness_comps = [ j for j in self.config.property_package.solute_set - if j not in ["Ca_2+", "Mg_2+"] + if j not in ["Ca_2+", "Mg_2+", "Alkalinity_2-"] ] # MW of components @@ -1027,6 +1027,40 @@ def eq_mass_balance_mg(b): (b.MgCl2_dosing * b.properties_out[0].flow_vol_phase["Liq"]), to_units=pyunits.kg / pyunits.s, ) + + # TODO: Check if soda ash needs to be included + # single stage lime (example in book MWH water treatment): source water alkalinity - Ca hardness + residual Ca hardness + # excess lime (example in book MWH water treatment): source water alkalinity - Ca hardness - excess lime dose + residual Ca hardness + # single stage lime soda (only hydroxide alkalinity): source water alkalinity + soda ash - total hardness + residual hardness + # excess lime soda (only hydroxide alkalinity): source water alkalinity + soda ash - total hardness + residual hardness + + @self.Constraint(doc="Alkalinity mass balance") + def eq_effluent_alk(b): + return b.properties_out[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" + ] - pyunits.convert( b.total_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ) + pyunits.convert( + b.noncarbonate_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, + ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Mg_2+"] + * b.Mg_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s) + + # ) - pyunits.convert(b.excess_CaO*b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + + @self.Constraint(doc="Alkalinity mass balance") + def eq_mass_balance_alk(b): + return b.properties_waste[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] == b.properties_in[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] - b.properties_out[ + 0 + ].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] + if ["TSS"] in comps: From 1470b10313925bde31d45bdd99e7565508f640bc Mon Sep 17 00:00:00 2001 From: Mukta Hardikar Date: Fri, 27 Sep 2024 12:58:08 -0600 Subject: [PATCH 2/4] outlet alkalinity eq for each procedure --- .../reflo/unit_models/chemical_softening.py | 55 ++++++++++++++----- 1 file changed, 42 insertions(+), 13 deletions(-) diff --git a/src/watertap_contrib/reflo/unit_models/chemical_softening.py b/src/watertap_contrib/reflo/unit_models/chemical_softening.py index 5cc29011..9e7b5ed0 100644 --- a/src/watertap_contrib/reflo/unit_models/chemical_softening.py +++ b/src/watertap_contrib/reflo/unit_models/chemical_softening.py @@ -1034,20 +1034,49 @@ def eq_mass_balance_mg(b): # single stage lime soda (only hydroxide alkalinity): source water alkalinity + soda ash - total hardness + residual hardness # excess lime soda (only hydroxide alkalinity): source water alkalinity + soda ash - total hardness + residual hardness - @self.Constraint(doc="Alkalinity mass balance") - def eq_effluent_alk(b): - return b.properties_out[0].flow_mass_phase_comp[ - "Liq", "Alkalinity_2-" - ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" - ] - pyunits.convert( b.total_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) + pyunits.convert( - b.noncarbonate_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] - * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, - ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Mg_2+"] - * b.Mg_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s) + + if self.config.softening_procedure_type is SofteningProcedureType.single_stage_lime: + @self.Constraint(doc="Alkalinity mass balance") + def eq_effluent_alk(b): + return b.properties_out[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" + ] - pyunits.convert( b.Ca_CaCO3* b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, + ) + + + elif self.config.softening_procedure_type is SofteningProcedureType.excess_lime: + @self.Constraint(doc="Alkalinity mass balance") + def eq_effluent_alk(b): + return b.properties_out[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" + ] - pyunits.convert( b.Ca_CaCO3* b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ) - pyunits.convert(b.excess_CaO*b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + )+ pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, + ) + + elif ( + self.config.softening_procedure_type + is SofteningProcedureType.excess_lime_soda or SofteningProcedureType.single_stage_lime_soda + ): + + @self.Constraint(doc="Alkalinity mass balance") + def eq_effluent_alk(b): + return b.properties_out[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" + ] - pyunits.convert( b.total_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ) + pyunits.convert( + b.noncarbonate_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, + ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Mg_2+"] + * b.Mg_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s) - # ) - pyunits.convert(b.excess_CaO*b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s @self.Constraint(doc="Alkalinity mass balance") def eq_mass_balance_alk(b): From c413c5cd2a6c6df5ff6c308af288915f15db9895 Mon Sep 17 00:00:00 2001 From: Mukta Hardikar Date: Fri, 27 Sep 2024 15:23:36 -0600 Subject: [PATCH 3/4] single_stage_lime_soda updated --- .../reflo/unit_models/chemical_softening.py | 27 ++++++++++++++----- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/src/watertap_contrib/reflo/unit_models/chemical_softening.py b/src/watertap_contrib/reflo/unit_models/chemical_softening.py index 9e7b5ed0..2f8565d2 100644 --- a/src/watertap_contrib/reflo/unit_models/chemical_softening.py +++ b/src/watertap_contrib/reflo/unit_models/chemical_softening.py @@ -1028,9 +1028,9 @@ def eq_mass_balance_mg(b): to_units=pyunits.kg / pyunits.s, ) - # TODO: Check if soda ash needs to be included - # single stage lime (example in book MWH water treatment): source water alkalinity - Ca hardness + residual Ca hardness - # excess lime (example in book MWH water treatment): source water alkalinity - Ca hardness - excess lime dose + residual Ca hardness + # TODO: + # single stage lime (example in book Crittenden): source water alkalinity - Ca hardness + residual Ca hardness + # excess lime (example in book Crittenden): source water alkalinity - Ca hardness - excess lime dose + residual Ca hardness # single stage lime soda (only hydroxide alkalinity): source water alkalinity + soda ash - total hardness + residual hardness # excess lime soda (only hydroxide alkalinity): source water alkalinity + soda ash - total hardness + residual hardness @@ -1041,7 +1041,7 @@ def eq_effluent_alk(b): return b.properties_out[0].flow_mass_phase_comp[ "Liq", "Alkalinity_2-" ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" - ] - pyunits.convert( b.Ca_CaCO3* b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ] - pyunits.convert( b.Ca_CaCO3*b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, ) @@ -1055,13 +1055,26 @@ def eq_effluent_alk(b): ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" ] - pyunits.convert( b.Ca_CaCO3* b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s ) - pyunits.convert(b.excess_CaO*b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - )+ pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, ) - + + elif self.config.softening_procedure_type is SofteningProcedureType.single_stage_lime_soda: + @self.Constraint(doc="Alkalinity mass balance") + def eq_effluent_alk(b): + return b.properties_out[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" + ] - pyunits.convert( b.Ca_CaCO3 * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ) + pyunits.convert( + b.noncarbonate_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s + ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, + ) + elif ( self.config.softening_procedure_type - is SofteningProcedureType.excess_lime_soda or SofteningProcedureType.single_stage_lime_soda + is SofteningProcedureType.excess_lime_soda ): @self.Constraint(doc="Alkalinity mass balance") From 07c1119ddb09d7fbd04e1427a3c2e2c7ed3afbe4 Mon Sep 17 00:00:00 2001 From: Mukta Hardikar Date: Fri, 27 Sep 2024 15:57:54 -0600 Subject: [PATCH 4/4] alkalinity eq verfied with NMSU documentation --- .../reflo/unit_models/chemical_softening.py | 131 +++++++++++------- .../tests/test_chemical_softening.py | 18 +-- 2 files changed, 88 insertions(+), 61 deletions(-) diff --git a/src/watertap_contrib/reflo/unit_models/chemical_softening.py b/src/watertap_contrib/reflo/unit_models/chemical_softening.py index 2f8565d2..c8891f92 100644 --- a/src/watertap_contrib/reflo/unit_models/chemical_softening.py +++ b/src/watertap_contrib/reflo/unit_models/chemical_softening.py @@ -1027,82 +1027,109 @@ def eq_mass_balance_mg(b): (b.MgCl2_dosing * b.properties_out[0].flow_vol_phase["Liq"]), to_units=pyunits.kg / pyunits.s, ) - - # TODO: + + # TODO: # single stage lime (example in book Crittenden): source water alkalinity - Ca hardness + residual Ca hardness # excess lime (example in book Crittenden): source water alkalinity - Ca hardness - excess lime dose + residual Ca hardness # single stage lime soda (only hydroxide alkalinity): source water alkalinity + soda ash - total hardness + residual hardness # excess lime soda (only hydroxide alkalinity): source water alkalinity + soda ash - total hardness + residual hardness + if ( + self.config.softening_procedure_type + is SofteningProcedureType.single_stage_lime + ): - if self.config.softening_procedure_type is SofteningProcedureType.single_stage_lime: @self.Constraint(doc="Alkalinity mass balance") def eq_effluent_alk(b): return b.properties_out[0].flow_mass_phase_comp[ "Liq", "Alkalinity_2-" - ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" - ] - pyunits.convert( b.Ca_CaCO3*b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] - * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, - ) - + ] == b.properties_in[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] - pyunits.convert( + b.Ca_CaCO3 * b.properties_in[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) + pyunits.convert( + b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv + * b.properties_out[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) elif self.config.softening_procedure_type is SofteningProcedureType.excess_lime: + @self.Constraint(doc="Alkalinity mass balance") def eq_effluent_alk(b): return b.properties_out[0].flow_mass_phase_comp[ "Liq", "Alkalinity_2-" - ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" - ] - pyunits.convert( b.Ca_CaCO3* b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) - pyunits.convert(b.excess_CaO*b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] - * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, - ) - - elif self.config.softening_procedure_type is SofteningProcedureType.single_stage_lime_soda: + ] == b.properties_in[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] - pyunits.convert( + b.total_hardness * b.properties_in[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) - pyunits.convert( + b.excess_CaO * b.properties_in[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) + pyunits.convert( + b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv + * b.properties_out[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) + pyunits.convert( + b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv + * b.properties_out[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) + pyunits.convert( + b.properties_out[0].conc_mass_phase_comp["Liq", "Mg_2+"] + * b.Mg_CaCO3_conv + * b.properties_out[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) + + elif ( + self.config.softening_procedure_type + is SofteningProcedureType.single_stage_lime_soda + ): + @self.Constraint(doc="Alkalinity mass balance") def eq_effluent_alk(b): return b.properties_out[0].flow_mass_phase_comp[ "Liq", "Alkalinity_2-" - ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" - ] - pyunits.convert( b.Ca_CaCO3 * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) + pyunits.convert( - b.noncarbonate_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] - * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, - ) - + ] == pyunits.convert( + b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv + * b.properties_out[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) + elif ( - self.config.softening_procedure_type - is SofteningProcedureType.excess_lime_soda - ): - - @self.Constraint(doc="Alkalinity mass balance") - def eq_effluent_alk(b): - return b.properties_out[0].flow_mass_phase_comp[ - "Liq", "Alkalinity_2-" - ] == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-" - ] - pyunits.convert( b.total_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) + pyunits.convert( - b.noncarbonate_hardness * b.properties_in[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s - ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] - * b.Ca_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s, - ) + pyunits.convert( b.properties_out[0].conc_mass_phase_comp["Liq", "Mg_2+"] - * b.Mg_CaCO3_conv* b.properties_out[0].flow_vol_phase["Liq"], to_units=pyunits.kg / pyunits.s) - + self.config.softening_procedure_type + is SofteningProcedureType.excess_lime_soda + ): + + @self.Constraint(doc="Alkalinity mass balance") + def eq_effluent_alk(b): + return b.properties_out[0].flow_mass_phase_comp[ + "Liq", "Alkalinity_2-" + ] == pyunits.convert( + b.properties_out[0].conc_mass_phase_comp["Liq", "Ca_2+"] + * b.Ca_CaCO3_conv + * b.properties_out[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) + pyunits.convert( + b.properties_out[0].conc_mass_phase_comp["Liq", "Mg_2+"] + * b.Mg_CaCO3_conv + * b.properties_out[0].flow_vol_phase["Liq"], + to_units=pyunits.kg / pyunits.s, + ) @self.Constraint(doc="Alkalinity mass balance") def eq_mass_balance_alk(b): - return b.properties_waste[0].flow_mass_phase_comp[ - "Liq", "Alkalinity_2-" - ] == b.properties_in[0].flow_mass_phase_comp[ - "Liq", "Alkalinity_2-" - ] - b.properties_out[ - 0 - ].flow_mass_phase_comp[ - "Liq", "Alkalinity_2-" - ] - + return ( + b.properties_waste[0].flow_mass_phase_comp["Liq", "Alkalinity_2-"] + == b.properties_in[0].flow_mass_phase_comp["Liq", "Alkalinity_2-"] + - b.properties_out[0].flow_mass_phase_comp["Liq", "Alkalinity_2-"] + ) if ["TSS"] in comps: diff --git a/src/watertap_contrib/reflo/unit_models/tests/test_chemical_softening.py b/src/watertap_contrib/reflo/unit_models/tests/test_chemical_softening.py index f7be92b0..1cb13889 100644 --- a/src/watertap_contrib/reflo/unit_models/tests/test_chemical_softening.py +++ b/src/watertap_contrib/reflo/unit_models/tests/test_chemical_softening.py @@ -165,7 +165,7 @@ def test_build(self, chem_soft_frame): assert isinstance(port, Port) assert len(port.vars) == 3 - assert number_variables(m) == 96 + assert number_variables(m) == 95 assert number_total_constraints(m) == 62 assert number_unused_variables(m) == 17 @@ -206,7 +206,7 @@ def test_solution(self, chem_soft_frame): soft_results = { "ca_eff_target": 0.008, "mg_eff_target": 0.002427, - "removal_efficiency": {"SiO2": 0.7, "Alkalinity_2-": 0.7}, + # "removal_efficiency": {"SiO2": 0.7, "Alkalinity_2-": 0.7}, "volume_mixer": 1.0535825, "volume_floc": 65.8489, "volume_sed": 342.4143, @@ -412,7 +412,7 @@ def test_build(self, chem_soft_frame): assert isinstance(port, Port) assert len(port.vars) == 3 - assert number_variables(m) == 86 + assert number_variables(m) == 85 assert number_total_constraints(m) == 51 assert number_unused_variables(m) == 18 @@ -454,7 +454,7 @@ def test_solution(self, chem_soft_frame): soft_results = { "ca_eff_target": 0.008, "mg_eff_target": 0.002427, - "removal_efficiency": {"Alkalinity_2-": 0.7}, + # "removal_efficiency": {"Alkalinity_2-": 0.7}, "volume_mixer": 13.89, "volume_floc": 868.29, "volume_sed": 4515.12, @@ -665,7 +665,7 @@ def test_build(self, chem_soft_frame): assert isinstance(port, Port) assert len(port.vars) == 3 - assert number_variables(m) == 86 + assert number_variables(m) == 85 assert number_total_constraints(m) == 52 assert number_unused_variables(m) == 18 @@ -707,7 +707,7 @@ def test_solution(self, chem_soft_frame): soft_results = { "ca_eff_target": 0.012, "mg_eff_target": 0.000728, - "removal_efficiency": {"Alkalinity_2-": 0.7}, + # "removal_efficiency": {"Alkalinity_2-": 0.7}, "volume_mixer": 13.89, "volume_floc": 868.29, "volume_sed": 4515.12, @@ -920,7 +920,7 @@ def test_build(self, chem_soft_frame): assert isinstance(port, Port) assert len(port.vars) == 3 - assert number_variables(m) == 86 + assert number_variables(m) == 85 assert number_total_constraints(m) == 52 assert number_unused_variables(m) == 18 @@ -962,7 +962,7 @@ def test_solution(self, chem_soft_frame): soft_results = { "ca_eff_target": 0.012, "mg_eff_target": 0.000728, - "removal_efficiency": {"Alkalinity_2-": 0.7}, + # "removal_efficiency": {"Alkalinity_2-": 0.7}, "volume_mixer": 13.89, "volume_floc": 868.29, "volume_sed": 4515.12, @@ -1177,7 +1177,7 @@ def test_build(self, chem_soft_frame): assert isinstance(port, Port) assert len(port.vars) == 3 - assert number_variables(m) == 96 + assert number_variables(m) == 95 assert number_total_constraints(m) == 62 assert number_unused_variables(m) == 17