def test_engine_caco3_cacl2_pitzer():
TK = 25.0 + 273.15
cNaHCO3 = 80e-3
cCaCl2 = 33.25e-3
args = (np.array([cNaHCO3, cCaCl2]), TK, pyequion.pCO2_ref)
feed_compounds = ["CaCO3", "CaCl2"]
initial_feed_mass_balance = ["Cl-"]
closing_equation_type = ClosingEquationType.OPEN
sys_eq = create_equilibrium(
feed_compounds,
closing_equation_type,
initial_feed_mass_balance=initial_feed_mass_balance,
)
x_guess = np.full(sys_eq.idx_control.idx["size"], -1e-2)
solution = solve_equilibrium(
sys_eq,
x_guess=x_guess,
args=args,
# jac=nahco3_residual_jacobian
setup_log_gamma_func=pyequion.setup_log_gamma_pitzer,
calc_log_gamma=pyequion.calc_log_gamma_pitzer,
)
pyequion.print_solution(solution)
print(solution.specie_names)
assert np.isclose(9.327, solution.pH,
1e-2) # 9.45 is D.H, check for Pitzer with phreeqc
def test_engine_baco3_solve_1mM_open():
EXPECTED = { # AQION
"sc": (198.5, 15), # FIXME: add parameters for BaCO3 conductivity
"I": (2.9652e-3, 4.0),
"pH": (8.48, 2.0),
"DIC": (1.97e-3, 5.0),
"SI": (0.85, 3.0),
}
TK = 25.0 + 273.15
cFeed = 1e-3
args = (np.array([cFeed]), TK, pyequion.pCO2_ref)
feed_compounds = ["BaCO3"]
# initial_feed_mass_balance = None
# element_mass_balance = ['Ba']
closing_equation_type = ClosingEquationType.OPEN
sys_eq = create_equilibrium(feed_compounds,
closing_equation_type=closing_equation_type)
# x_guess = np.full(nahco3_eq.idx.size, -1.0)
solution = solve_equilibrium(
sys_eq,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
assert compare_with_expected_perc_tuple(
solution.saturation_index["Witherite"], EXPECTED["SI"])
def test_engine_mix_solve_1_and_5_closed():
EXPECTED = {
"sc": (1272.0, -1),
"I": (15.885e-3, 1.0),
"pH": (7.92, 1.0),
}
TK = 25.0 + 273.15
cNaHCO3 = 1e-3
cCaCl2 = 5e-3
carbone_total = cNaHCO3 # 1.34e+01 * 1e-3
args = (
np.array([cNaHCO3, cCaCl2]),
TK,
carbone_total,
) # Instead of pCO2->DIC
feed_compounds = ["NaHCO3", "CaCl2"]
initial_feed_mass_balance = ["Cl-"]
# closing_equation_type = ClosingEquationType.CARBONE_TOTAL
sys_eq = create_equilibrium(
feed_compounds, initial_feed_mass_balance=initial_feed_mass_balance)
x_guess = np.full(sys_eq.idx_control.idx["size"], -1e-4)
solution = solve_equilibrium(
sys_eq,
x_guess=x_guess,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
def test_engine_activity_external_debye_huckel():
EXPECTED = {
"pH": (8.2, 1.0),
}
TK = 25.0 + 273.15
cNaHCO3 = 15e-3
cCaCl2 = 0.02e-3
carbone_total = cNaHCO3
c_feed = np.array([cNaHCO3, cCaCl2])
args = (c_feed, TK, carbone_total) # Instead of pCO2->DIC
feed_compounds = ["NaHCO3", "CaCl2"]
initial_feed_mass_balance = ["Cl-"]
element_mass_balance = ["Na", "Ca"]
closing_equation_type = ClosingEquationType.CARBON_TOTAL
sys_eq = create_equilibrium(
feed_compounds,
closing_equation_type,
element_mass_balance,
initial_feed_mass_balance,
)
# setup_log_gamma(sys_eq, TK, c_feed)
x_guess = np.full(sys_eq.idx_control.idx["size"], -1e-4)
solution = solve_equilibrium(sys_eq,
x_guess=x_guess,
args=args
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert np.isclose(EXPECTED["pH"][0], solution.pH, 1e-2)
def test_engine_baco3_solve_1mM_closed():
EXPECTED = { # AQION
"sc": (241.8, 15), # FIXME: add parameters for BaCO3 conductivity
"I": (3.092e-3, 4.0),
"pH": (10.48, 2.0),
"DIC": (1e-3, -1),
"SI": (2.0, 3.0),
}
TK = 25.0 + 273.15
cFeed = 1e-3
DIC = EXPECTED["DIC"][0]
args = (np.array([cFeed]), TK, DIC)
feed_compounds = ["BaCO3"]
# initial_feed_mass_balance = None
# element_mass_balance = ['Ba']
# closing_equation_type = ClosingEquationType.CARBONE_TOTAL
sys_eq = create_equilibrium(feed_compounds)
# x_guess = np.full(nahco3_eq.idx.size, -1.0)
solution = solve_equilibrium(
sys_eq,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
assert compare_with_expected_perc_tuple(
solution.saturation_index["Witherite"], EXPECTED["SI"])
def test_engine_baco3_cacl2_solve_5_2_mM_closed():
EXPECTED = { # AQION
"sc": (1099.5, 15), # FIXME: add parameters for BaCO3 conductivity
"I": (15.457e-3, 15.0),
"pH": (10.71, 2.0),
"DIC": (5e-3, -1),
"SI-CaCO3-Calcite": (2.30, 10.0),
"SI-BaCO3": (2.99, 10.0),
# Include Vaterite, Aragonite, Amorph, Ikaite (6H2O)
}
sys_eq = pyequion.create_equilibrium(feed_compounds=["CaCl2", "BaCO3"],
initial_feed_mass_balance=["Cl-"])
TK = 25.0 + 273.15
cCaCl2 = 2e-3
cBaCO3 = 5e-3
DIC = 5e-3
args = (np.array([cCaCl2, cBaCO3]), TK, DIC)
solution = pyequion.solve_equilibrium(sys_eq, args=args)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
assert compare_with_expected_perc_tuple(
solution.saturation_index["Calcite"], EXPECTED["SI-CaCO3-Calcite"])
assert compare_with_expected_perc_tuple(
solution.saturation_index["Witherite"], EXPECTED["SI-BaCO3"])
solution = pyequion.solve_equilibrium(sys_eq,
args=args,
allow_precipitation=True)
pyequion.print_solution(solution)
def test_engine_zemaits_na2so4_caso4():
# flake8: noqa
"Was not able to get good aggrement"
EXPECTED = { # AQION
"sc": (1099.5, 15), # FIXME: add parameters for BaCO3 conductivity
"I": (15.457e-3, 15.0),
"pH": (10.71, 2.0),
"DIC": (5e-3, -1),
"SI-CaCO3-Calcite": (2.30, 10.0),
"SI-BaCO3": (2.99, 10.0),
# Include Vaterite, Aragonite, Amorph, Ikaite (6H2O)
}
sys_eq = pyequion.create_equilibrium(feed_compounds=["Na2SO4", "CaSO4"])
TK = 25.0 + 273.15
cNa2SO4 = 94.8e-3
cCaSO4 = 21.8e-3
args = (np.array([cNa2SO4, cCaSO4]), TK, np.nan)
# solution = pyequion.solve_equilibrium(sys_eq, args=args)
# pyequion.print_solution(solution)
# assert_solution_result(solution, EXPECTED)
# assert compare_with_expected_perc_tuple(solution.saturation_index['Calcite'], EXPECTED['SI-CaCO3-Calcite'])
# assert compare_with_expected_perc_tuple(solution.saturation_index['Witherite'], EXPECTED['SI-BaCO3'])
solution = pyequion.solve_equilibrium(sys_eq,
args=args,
allow_precipitation=True)
pyequion.print_solution(solution)
def test_from_ions_is_equal_to_from_compounds():
comps = {"Na+": 10, "HCO3-": 10, "Ca++": 5.0, "Cl-": 10.0}
solution_ions = pyequion.solve_solution(comps)
pyequion.print_solution(solution_ions)
comps = {"NaHCO3": 10, "CaCl2": 5.0}
solution_comps = pyequion.solve_solution(comps)
pyequion.print_solution(solution_comps)
assert np.isclose(solution_ions.pH, solution_comps.pH)
def test_engine_mix_solve_1_and_5_closed_precipitation():
EXPECTED = {
"sc": (6977.5, -1),
"I": (99.779e-3, 1.0),
"pH": (8.85, 1.0),
"SI": {
"Calcite": (0.00, 1.0),
"Aragonite": (-0.14, 1.0),
"Vaterite": (-0.57, 1.0),
},
"sat-conc": {
"Calcite": (80.0e-3, 1.0),
"Aragonite": (0.0, -1.0),
"Vaterite": (0.0, -1.0),
},
}
TK = 25.0 + 273.15
cCaCO3 = 80e-3
cCaCl2 = 33.25e-3
carbone_total = cCaCO3 # 1.34e+01 * 1e-3
args = (
np.array([cCaCO3, cCaCl2]),
TK,
carbone_total,
) # Instead of pCO2->DIC
feed_compounds = ["CaCO3", "CaCl2"]
initial_feed_mass_balance = ["Cl-"]
allow_precipitation = True
closing_equation_type = ClosingEquationType.CARBON_TOTAL
sys_eq = create_equilibrium(
feed_compounds,
closing_equation_type,
initial_feed_mass_balance=initial_feed_mass_balance,
)
# This was with an old API, the create_equilibrium is created without solid reaction and
# only in the solution function the code is adjust to treat the precipitation
# x_guess = np.full(sys_eq.idx_control.idx['size'], -1e-1)
solution = solve_equilibrium(
sys_eq,
args=args,
# jac=nahco3_residual_jacobian
allow_precipitation=allow_precipitation,
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
for tag in EXPECTED["SI"]:
assert compare_with_expected_perc_tuple(solution.saturation_index[tag],
EXPECTED["SI"][tag])
assert compare_with_expected_perc_tuple(
solution.preciptation_conc[tag], EXPECTED["sat-conc"][tag])
def test_engine_mix_closed_add_IS():
EXPECTED = {
"sc": (1314.9, 15),
"I": (15.083e-3, 1.0),
"pH": (8.2, 1.0),
"DIC": (1.5e01 * 1e-3, -1),
"SI": {
"Calcite": (-0.53, 5.0),
"Aragonite": (-0.67, 5.0),
"Halite": (-7.91, 5.0),
},
}
TK = 25.0 + 273.15
cNaHCO3 = 15e-3
cCaCl2 = 0.02e-3
carbone_total = cNaHCO3
args = (
np.array([cNaHCO3, cCaCl2]),
TK,
carbone_total,
) # Instead of pCO2->DIC
feed_compounds = ["NaHCO3", "CaCl2"]
initial_feed_mass_balance = ["Cl-"]
sys_eq = create_equilibrium(
feed_compounds, initial_feed_mass_balance=initial_feed_mass_balance)
x_guess = np.full(sys_eq.idx_control.idx["size"], -1e-4)
solution = solve_equilibrium(
sys_eq,
x_guess=x_guess,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
assert compare_with_expected_perc_tuple(
solution.saturation_index["Halite"], EXPECTED["SI"]["Halite"])
assert compare_with_expected_perc_tuple(
solution.saturation_index["Calcite"], EXPECTED["SI"]["Calcite"])
assert compare_with_expected_perc_tuple(
solution.saturation_index["Aragonite"], EXPECTED["SI"]["Aragonite"])
def test_engine_mix_closed_add_IS_dic_modified():
EXPECTED = {
"sc": (1339.4, 15),
"I": (16.102e-3, 1.0),
"pH": (9.24, 1.0),
"DIC": (1.34e01 * 1e-3, -1),
"SI": (0.20, 200.0), # FIXME: High error!
}
TK = 25.0 + 273.15
cNaHCO3 = 15e-3
cCaCl2 = 0.02e-3
carbone_total = EXPECTED["DIC"][0] # 1.34e+01 * 1e-3
args = (
np.array([cNaHCO3, cCaCl2]),
TK,
carbone_total,
) # Instead of pCO2->DIC
feed_compounds = ["NaHCO3", "CaCl2"]
initial_feed_mass_balance = ["Cl-"]
closing_equation_type = ClosingEquationType.CARBON_TOTAL
sys_eq = create_equilibrium(
feed_compounds,
closing_equation_type,
initial_feed_mass_balance=initial_feed_mass_balance,
)
x_guess = np.full(sys_eq.idx_control.idx["size"], -1e-4)
solution = solve_equilibrium(
sys_eq,
x_guess=x_guess,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
assert compare_with_expected_perc_tuple(
solution.saturation_index["Calcite"], EXPECTED["SI"])
def test_pH_as_a_closing_equation():
comps = {"NaHCO3": 10, "CaCl2": 5.0}
sol1 = pyequion.solve_solution(comps)
pyequion.print_solution(sol1)
x_guess = sol1.x
pH = 8.5
solution_comps = pyequion.solve_solution(comps,
close_type=ClosingEquationType.PH,
pH_fixed=pH,
element_mass_balance=['Na'])
pyequion.print_solution(solution_comps)
assert (np.isclose(solution_comps.pH, pH))
pH = 7.9386654148526965
solution_comps2 = pyequion.solve_solution(
comps,
close_type=ClosingEquationType.PH,
pH_fixed=pH,
x_guess=x_guess,
element_mass_balance=['Na'],
)
pyequion.print_solution(solution_comps2)
assert (np.isclose(solution_comps2.pH, pH))
assert (np.isclose(solution_comps2.DIC, comps['NaHCO3'] * 1e-3))
return
def test_engine_nap_hco3m_Capp_clm_closed():
EXPECTED = {
"sc": (1339.4, -200),
"I": (16.102e-3, 1.0),
"pH": (9.24, 1.0),
"DIC": (1.34e01 * 1e-3, -1),
}
TK = 25.0 + 273.15
cNap = 15e-3
cHCO3m = 15e-3
cCapp = 0.02e-3
cClm = 0.02e-3
carbone_total = EXPECTED["DIC"][0]
# args = (np.array([cNap, cHCO3m, cBaqpp]), TK, carbone_total)
feed_compounds = ["Na+", "HCO3-", "Ca++", "Cl-"]
# initial_feed_mass_balance = ['Cl-']
fixed_elements = ["Cl-"]
allow_precipitation = False
# element_mass_balance = ['Na', 'Ca']
closing_equation_type = ClosingEquationType.CARBON_TOTAL
sys_eq = create_equilibrium(
feed_compounds,
# closing_equation_type, element_mass_balance,
closing_equation_type,
allow_precipitation=allow_precipitation,
fixed_elements=fixed_elements,
)
args = (np.array([cNap, cHCO3m, cCapp, cClm]), TK, carbone_total)
# x_guess = np.full(nahco3_eq.idx.size, -1.0)
solution = solve_equilibrium(
sys_eq,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
def test_engine_greg_andr_caso4():
sys_eq = pyequion.create_equilibrium(feed_compounds=["CaSO4"])
TK = 25.0 + 273.15
# cNa2SO4 = 94.8e-3
cCaSO4 = 15.6e-3
args = (np.array([cCaSO4]), TK, np.nan)
solution = pyequion.solve_equilibrium(sys_eq, args=args)
pyequion.print_solution(solution)
# assert_solution_result(solution, EXPECTED)
# assert compare_with_expected_perc_tuple(solution.saturation_index['Calcite'], EXPECTED['SI-CaCO3-Calcite'])
# assert compare_with_expected_perc_tuple(solution.saturation_index['Witherite'], EXPECTED['SI-BaCO3'])
solution = pyequion.solve_equilibrium(sys_eq,
args=args,
allow_precipitation=True)
pyequion.print_solution(solution)
def test_engine_cacl2_solve_open_0p01():
EXPECTED = {
"sc": (1336.4, -200),
"I": (16.073e-3, 200), # ONLY PH KOWN
"pH": (5.61, 1.0),
"DIC": (1.34e01 * 1e-3, -1),
}
TK = 25.0 + 273.15
c_feed = 5 * 1e-3 # Forcing to be an array
args = (np.array([c_feed]), TK, pyequion.pCO2_ref)
"""
Big Issue: How to automate the known-mass-balance
- A specie is removed (CaCl2)
- A specie is still a variable (Ca)
- A specie is placed as known (Cl)
"""
feed_compounds = ["CaCl2"]
initial_feed_mass_balance = ["Cl-"]
closing_equation_type = ClosingEquationType.OPEN
sys_eq = create_equilibrium(
feed_compounds,
closing_equation_type,
initial_feed_mass_balance=initial_feed_mass_balance,
)
# x_guess = np.full(nahco3_eq.idx.size, -1.0)
idx = sys_eq.idx_control.idx
x_guess = np.full(idx["size"], -1e-3)
x_guess[idx["Ca++"]] = np.log10(c_feed)
solution = solve_equilibrium(
sys_eq,
x_guess=x_guess,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
def test_phreeqpython_baco3_cacl2_closed_5_2():
fname = inspect.stack()[0][3]
comp_dict = {"BaCO3": 5.0, "CaCl2": 2.0}
solution_ref1 = REF_SOLUTIONS[fname][0]
solution = solve_solution(
comp_dict,
initial_feed_mass_balance=["Cl-"],
close_type=ClosingEquationType.CARBON_TOTAL,
carbon_total=5.0,
)
assert_solution(solution, solution_ref1, tol={"pH": 1e-2})
assert_solid(solution, solution_ref1)
pyequion.print_solution(solution)
solution_ref2 = REF_SOLUTIONS[fname][1]
solution = solve_solution(
comp_dict,
close_type=ClosingEquationType.OPEN,
initial_feed_mass_balance=["Cl-"],
)
assert_solution(solution, solution_ref2, tol={"pH": 1e-2})
assert_solid(solution, solution_ref2, tol={"si": 1e-1})
def test_engine_mix_solve_closed():
EXPECTED = {
"sc": (1339.4, 20.0),
"I": (16.102e-3, 1.0),
"pH": (9.24, 1.0),
"DIC": (1.34e01 * 1e-3, -1),
}
TK = 25.0 + 273.15
cNaHCO3 = 15e-3
cCaCl2 = 0.02e-3
carbone_total = EXPECTED["DIC"][0] # 1.34e+01 * 1e-3
args = (
np.array([cNaHCO3, cCaCl2]),
TK,
carbone_total,
) # Instead of pCO2->DIC
feed_compounds = ["NaHCO3", "CaCl2"]
initial_feed_mass_balance = ["Cl-"]
closing_equation_type = ClosingEquationType.CARBON_TOTAL
sys_eq = create_equilibrium(
feed_compounds,
closing_equation_type,
initial_feed_mass_balance=initial_feed_mass_balance,
)
x_guess = np.full(sys_eq.idx_control.idx["size"], -1e-4)
solution = solve_equilibrium(
sys_eq,
x_guess=x_guess,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
# input('')
assert_solution_result(solution, EXPECTED)
def test_two_irreversible_cacl2_bacl2():
EXPECTED = {
"sc": (3417.7, -1),
"I": (43.02e-3, 3.0),
"pH": (7.91, 1.0),
}
feed_compounds = ["NaHCO3", "CaCl2", "BaCl2"]
initial_feed_mass_balance = ["Cl-"]
# closing_eq = ClosingEquationType.CARBON_TOTAL
sys_eq = create_equilibrium(
feed_compounds, initial_feed_mass_balance=initial_feed_mass_balance)
TK = 25.0 + 273.15
cNaHCO3 = 15e-3
cCaCl2 = 5e-3
cBaCl2 = 5e-3
carbone_total = cNaHCO3
args = (np.array([cNaHCO3, cCaCl2, cBaCl2]), TK, carbone_total)
solution = solve_equilibrium(sys_eq, args=args)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
def test_engine_baco3_cacl2_nahco3_solve_1mM_each_closed():
EXPECTED = { # AQION
"sc": (484.5, 15), # FIXME: add parameters for BaCO3 conductivity
"I": (6.213e-3, 15.0),
"pH": (9.89, 2.0),
"DIC": (2e-3, -1),
"SI-Calcite": (1.73, 5.0),
"SI-BaCO3": (1.91, 5.0),
}
TK = 25.0 + 273.15
DIC = EXPECTED["DIC"][0]
cCaCl2 = 1e-3
cBaCO3 = 1e-3
cNaHCO3 = 1e-3
args = (np.array([cCaCl2, cBaCO3, cNaHCO3]), TK, DIC)
feed_compounds = ["CaCl2", "BaCO3", "NaHCO3"]
initial_feed_mass_balance = ["Cl-"]
# element_mass_balance = ['Ca', 'Ba', 'Na']
sys_eq = create_equilibrium(
feed_compounds,
initial_feed_mass_balance=initial_feed_mass_balance,
)
# x_guess = np.full(nahco3_eq.idx.size, -1.0)
solution = solve_equilibrium(
sys_eq,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
assert compare_with_expected_perc_tuple(
solution.saturation_index["Calcite"], EXPECTED["SI-Calcite"])
assert compare_with_expected_perc_tuple(
solution.saturation_index["Witherite"], EXPECTED["SI-BaCO3"])
def test_creating_solution_result_from_x():
feed_compounds = ["Na+", "HCO3-", "Ca++", "Cl-"]
fixed_elements = ["Cl-"]
sys_eq = pyequion.create_equilibrium(
feed_compounds,
fixed_elements=fixed_elements,
)
comps = {"Na+": 10, "HCO3-": 10, "Ca++": 5.0, "Cl-": 10.0}
solution_exp = pyequion.solve_solution(comps, sys_eq)
pyequion.print_solution(solution_exp)
x = solution_exp.x
sys_eq2 = pyequion.create_equilibrium(
feed_compounds,
fixed_elements=fixed_elements,
)
solution_new = pyequion.get_solution_from_x(sys_eq2, x, comps)
assert np.isclose(solution_exp.pH, solution_new.pH)
def test_engine_nap_hco3m_bacl2_open():
EXPECTED = {
"sc": (1525.3, 25), # FIXME
"I": (20.776e-3, 3.0),
"pH": (9.22, 1.0),
"DIC": (13.2 * 1e-3, 5),
"IS(s)": (2.39, -1), # TODO nao incluido ainda
}
TK = 25.0 + 273.15
cNap = 15e-3
cHCO3m = 15e-3
cBaqpp = 2e-3
# carbone_total = 15e-3
# args = (np.array([cNap, cHCO3m, cBaqpp]), TK, carbone_total)
args = (np.array([cNap, cHCO3m, cBaqpp]), TK, pyequion.pCO2_ref)
feed_compounds = ["Na+", "HCO3-", "BaCl2"]
initial_feed_mass_balance = ["Cl-"]
# element_mass_balance = ['Na', 'Ba']
closing_equation_type = ClosingEquationType.OPEN
sys_eq = create_equilibrium(
feed_compounds,
closing_equation_type,
# element_mass_balance,
initial_feed_mass_balance=initial_feed_mass_balance,
)
# x_guess = np.full(nahco3_eq.idx.size, -1.0)
solution = solve_equilibrium(
sys_eq,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
def test_engine_nap_hco3m_Capp_clm_check_hco3_conc_closed():
EXPECTED = {
"sc": (1272.0, -1),
"I": (15.885e-3, 1.0),
"pH": (7.92, 1.0),
}
TK = 25.0 + 273.15
cNap = 1e-3
cHCO3m = 1e-3
cCapp = 5e-3
cClm = 10e-3 # CAREFUL HERE-> !! STOIC CL*2
carbone_total = cHCO3m
# args = (np.array([cNap, cHCO3m, cBaqpp]), TK, carbone_total)
feed_compounds = ["Na+", "HCO3-", "Ca++", "Cl-"]
# initial_feed_mass_balance = ['Cl-']
fixed_elements = ["Cl-"]
allow_precipitation = False
# element_mass_balance = ['Na', 'Ca']
sys_eq = create_equilibrium(
feed_compounds,
# element_mass_balance,
allow_precipitation=allow_precipitation,
fixed_elements=fixed_elements,
)
args = (np.array([cNap, cHCO3m, cCapp, cClm]), TK, carbone_total)
# x_guess = np.full(nahco3_eq.idx.size, -1.0)
solution = solve_equilibrium(
sys_eq,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
def test_engine_nap_hco3m_capp_clm_open():
EXPECTED = {
"sc": (1525.3, 25), # FIXME
"I": (20.3e-3, 3.0),
"pH": (8.06, 1.0),
"DIC": (15.0 * 1e-3, 5),
"IS(s)": (2.39, -1), # TODO nao incluido ainda
}
TK = 25.0 + 273.15
cNap = 15e-3
cHCO3m = 15e-3
cBapp = 2e-3
cClpp = 2 * 2e-3
carbone_total = 15e-3
# args = (np.array([cNap, cHCO3m, cBaqpp]), TK, carbone_total)
args = (np.array([cNap, cHCO3m, cBapp, cClpp]), TK, carbone_total)
feed_compounds = ["Na+", "HCO3-", "Ca++", "Cl-"]
fixed_elements = ["Cl-"]
closing_equation_type = ClosingEquationType.CARBON_TOTAL
sys_eq = create_equilibrium(
feed_compounds,
closing_equation_type,
# element_mass_balance,
fixed_elements=fixed_elements,
)
# x_guess = np.full(nahco3_eq.idx.size, -1.0)
solution = solve_equilibrium(
sys_eq,
args=args,
# jac=nahco3_residual_jacobian
)
pyequion.print_solution(solution)
assert_solution_result(solution, EXPECTED)
print("2o JIT Elapsed = {}".format(time.time() - t01))
# Running with LOOP
print("JIT with LOOP")
Tspan = np.linspace(24.0, 28.0, 101)
t01 = time.time()
sol_span = [
pyequion.solve_solution({
"NaHCO3": 50,
"CaCl2": 10
}, esys) for T in Tspan
]
pH = np.array([s.pH for s in sol_span])
print("2o JIT Elapsed = {}".format(time.time() - t01))
# Create a different system after compilation is on
sys_eq = pyequion.create_equilibrium(feed_compounds=["CaSO4", "NaCl"])
t01 = time.time()
sol3 = pyequion.solve_solution({
"CaSO4": 100,
"NaCl": 100
},
sys_eq,
activity_model_type="bromley")
print("JITTED Changed System -> Elapsed = {}".format(time.time() - t01))
pyequion.print_solution(sol3)
print("End")
Obs:
Results here are model calculated value, as in B-dot formulation.
Results should be used with causion and no warranty is provided.
Users are wellcome to create issues and contribute with the software for enhanced validations.
"""
# %% Imports
import pyequion
# %% NaHCO3 Equilibrium
sol = pyequion.solve_solution({"NaHCO3": 15.0})
pyequion.print_solution(sol, conc_and_activity=True)
print("NaHCO3 at 15mM has a calculated pH of {}".format(sol.pH))
print("The reactions are (better visualized in jupyter)")
pyequion.ipython_display_reactions(sol)
# %% NaHCO3 + CaCl2 Equilibrium
sol = pyequion.solve_solution({"NaHCO3": 15.0, "CaCl2": 50.0})
pyequion.print_solution(sol, conc_and_activity=True)
print("NaHCO3=15mM and CaCl2=50mM has a calculated pH of {}".format(sol.pH))
print(
