def test_public_functions(self):
param = pybamm.LithiumIonParameters()
submodel = pybamm.thermal.Lumped(param)
std_tests = tests.StandardSubModelTests(submodel, coupled_variables)
std_tests.test_all()
submodel = pybamm.thermal.Lumped(param, cc_dimension=1)
std_tests = tests.StandardSubModelTests(submodel, coupled_variables)
std_tests.test_all()
submodel = pybamm.thermal.Lumped(param, cc_dimension=2)
std_tests = tests.StandardSubModelTests(submodel, coupled_variables)
std_tests.test_all()
submodel = pybamm.thermal.Lumped(param, cc_dimension=0, geometry="pouch")
std_tests = tests.StandardSubModelTests(submodel, coupled_variables)
std_tests.test_all()
submodel = pybamm.thermal.Lumped(param, cc_dimension=1, geometry="pouch")
std_tests = tests.StandardSubModelTests(submodel, coupled_variables)
std_tests.test_all()
submodel = pybamm.thermal.Lumped(param, cc_dimension=2, geometry="pouch")
std_tests = tests.StandardSubModelTests(submodel, coupled_variables)
std_tests.test_all()
def test_thermal_parameters(self):
values = pybamm.lithium_ion.BaseModel().default_parameter_values
param = pybamm.LithiumIonParameters()
c_rate = param.i_typ / 24
# Density
np.testing.assert_almost_equal(values.evaluate(param.rho_cn), 1.9019, 2)
np.testing.assert_almost_equal(values.evaluate(param.rho_n), 0.6403, 2)
np.testing.assert_almost_equal(values.evaluate(param.rho_s), 0.1535, 2)
np.testing.assert_almost_equal(values.evaluate(param.rho_p), 1.2605, 2)
np.testing.assert_almost_equal(values.evaluate(param.rho_cp), 1.3403, 2)
# Thermal conductivity
np.testing.assert_almost_equal(values.evaluate(param.lambda_cn), 6.7513, 2)
np.testing.assert_almost_equal(values.evaluate(param.lambda_n), 0.0296, 2)
np.testing.assert_almost_equal(values.evaluate(param.lambda_s), 0.0027, 2)
np.testing.assert_almost_equal(values.evaluate(param.lambda_p), 0.0354, 2)
np.testing.assert_almost_equal(values.evaluate(param.lambda_cp), 3.9901, 2)
# other thermal parameters
# note: in paper this is 0.0534 * c_rate which conflicts with this
# if we do C_th * c_rate we get 0.0534 so probably error in paper
# np.testing.assert_almost_equal(
# values.evaluate(param.C_th / c_rate), 0.0253, 2
# )
np.testing.assert_almost_equal(values.evaluate(param.Theta / c_rate), 0.008, 2)
# np.testing.assert_almost_equal(
# values.evaluate(param.B / c_rate), 36.216, 2
# )
np.testing.assert_equal(values.evaluate(param.T_init), 0)
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a = pybamm.Scalar(1)
full = pybamm.FullBroadcast(
a,
["negative electrode", "separator", "positive electrode"],
"current collector",
)
variables = {
"Porosity": a,
"Negative electrode porosity": a,
"Separator porosity": a,
"Positive electrode porosity": a,
"Electrolyte tortuosity": a,
"Porosity change": a,
"Volume-averaged velocity": a,
"Electrolyte concentration": a,
"Electrolyte current density": full,
"Sum of electrolyte reaction source terms": full,
"Cell temperature": full,
"Transverse volume-averaged acceleration": full,
}
submodel = pybamm.electrolyte_diffusion.Full(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions_first_order(self):
param = pybamm.LithiumIonParameters()
a = pybamm.PrimaryBroadcast(1, "current collector")
c_e_n = pybamm.standard_variables.c_e_n
c_e_s = pybamm.standard_variables.c_e_s
c_e_p = pybamm.standard_variables.c_e_p
variables = {
"Leading-order current collector current density": a,
"Negative electrolyte concentration": c_e_n,
"Separator electrolyte concentration": c_e_s,
"Positive electrolyte concentration": c_e_p,
"Leading-order x-averaged electrolyte concentration": a,
"X-averaged electrolyte concentration": a,
"X-averaged negative electrode potential": a,
"X-averaged negative electrode surface potential difference": a,
"Leading-order x-averaged negative electrode porosity": a,
"Leading-order x-averaged separator porosity": a,
"Leading-order x-averaged positive electrode porosity": a,
"Leading-order x-averaged negative electrolyte tortuosity": a,
"Leading-order x-averaged separator tortuosity": a,
"Leading-order x-averaged positive electrolyte tortuosity": a,
"X-averaged cell temperature": a,
}
submodel = pybamm.electrolyte_conductivity.Composite(
param, higher_order_terms="first-order")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a = pybamm.Scalar(0.5)
variables = {
"Negative electrode open circuit potential": a,
"Negative particle surface concentration": a,
"Negative electrode temperature": a,
"Negative electrolyte concentration": a,
"Current collector current density": a,
}
submodel = pybamm.interface.inverse_kinetics.InverseButlerVolmer(
param, "Negative", "lithium-ion main"
)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
variables = {
"Positive electrode open circuit potential": a,
"Positive particle surface concentration": a,
"Positive electrode temperature": a,
"Positive electrolyte concentration": a,
"Current collector current density": a,
}
submodel = pybamm.interface.inverse_kinetics.InverseButlerVolmer(
param, "Positive", "lithium-ion main"
)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a_n = pybamm.FullBroadcast(
pybamm.Scalar(1), "negative electrode", {"secondary": "current collector"}
)
a_p = pybamm.FullBroadcast(
pybamm.Scalar(1), "positive electrode", {"secondary": "current collector"}
)
variables = {
"Negative electrode interfacial current density": a_n,
"Negative electrode temperature": a_n,
"Negative electrode active material volume fraction": a_n,
"Negative electrode surface area to volume ratio": a_n,
"Negative particle radius": a_n,
}
submodel = pybamm.particle.FickianManyParticles(param, "Negative")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
variables = {
"Positive electrode interfacial current density": a_p,
"Positive electrode temperature": a_p,
"Positive electrode active material volume fraction": a_p,
"Positive electrode surface area to volume ratio": a_p,
"Positive particle radius": a_p,
}
submodel = pybamm.particle.FickianManyParticles(param, "Positive")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_prettify_print_name(self):
param = pybamm.LithiumIonParameters()
param1 = pybamm.standard_variables
# Test PRINT_NAME_OVERRIDES
self.assertEqual(param.timescale.print_name, r"\tau")
# Test superscripts
self.assertEqual(param.U_n_ref.print_name, r"U^{n\,ref}")
# Test subscripts
self.assertEqual(param.a_R_p.print_name, r"a_{R\,p}")
# Test dim and dimensional
self.assertEqual(param.j0_n_ref_dimensional.print_name,
r"\hat{j0}^{n\,ref}")
self.assertEqual(param.C_dl_n_dimensional.print_name,
r"\hat{C}_{dl\,n}")
# Test bar
self.assertEqual(param1.c_s_n_xav.print_name, r"\bar{c}_{s\,n}")
# Test greek letters
self.assertEqual(param1.delta_phi_n.print_name, r"\delta_\phi_n")
# Test new_copy()
param2 = pybamm.LeadAcidParameters()
x_n = pybamm.standard_spatial_vars.x_n
a_n = param2.a_n(x_n)
a_n.new_copy()
def test_public_functions(self):
# param = pybamm.LeadAcidParameters()
param = pybamm.LithiumIonParameters()
a = pybamm.PrimaryBroadcast(pybamm.Scalar(0), "current collector")
variables = {
"X-averaged negative electrode interfacial current density":
a,
"X-averaged negative electrode SEI interfacial current density":
a,
"X-averaged positive electrode interfacial current density":
a,
"X-averaged negative electrode lithium plating "
"interfacial current density":
a,
}
options = {
"SEI": "ec reaction limited",
"SEI film resistance": "distributed",
"SEI porosity change": "true",
"lithium plating": "irreversible",
"lithium plating porosity change": "true",
}
submodel = pybamm.porosity.ReactionDriven(param, options, True)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a = pybamm.Scalar(0)
variables = {"Porosity": a, "Electrolyte concentration": a}
submodel = pybamm.electrolyte_diffusion.ConstantConcentration(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_known_solution(self):
model = pybamm.lithium_ion.ElectrodeSOH()
param = pybamm.LithiumIonParameters()
parameter_values = pybamm.ParameterValues(
chemistry=pybamm.parameter_sets.Mohtat2020)
sim = pybamm.Simulation(model, parameter_values=parameter_values)
V_min = 3
V_max = 4.2
C_n = parameter_values.evaluate(param.C_n_init)
C_p = parameter_values.evaluate(param.C_p_init)
n_Li = parameter_values.evaluate(param.n_Li_particles_init)
# Solve the model and check outputs
sol = sim.solve(
[0],
inputs={
"V_min": V_min,
"V_max": V_max,
"C_n": C_n,
"C_p": C_p,
"n_Li": n_Li,
},
)
self.assertAlmostEqual(sol["Up(y_100) - Un(x_100)"].data[0],
V_max,
places=5)
self.assertAlmostEqual(sol["Up(y_0) - Un(x_0)"].data[0],
V_min,
places=5)
self.assertAlmostEqual(sol["n_Li_100"].data[0], n_Li, places=5)
self.assertAlmostEqual(sol["n_Li_0"].data[0], n_Li, places=5)
def test_creation(self):
param = pybamm.LithiumIonParameters()
model_n = pybamm.interface.ButlerVolmer(
param,
"Negative",
"lithium-ion main",
{
"SEI film resistance": "none",
"total interfacial current density as a state": "false",
},
)
j_n = model_n.get_coupled_variables(
self.variables)["Negative electrode interfacial current density"]
model_p = pybamm.interface.ButlerVolmer(
param,
"Positive",
"lithium-ion main",
{
"SEI film resistance": "none",
"total interfacial current density as a state": "false",
},
)
j_p = model_p.get_coupled_variables(
self.variables)["Positive electrode interfacial current density"]
# negative electrode Butler-Volmer is Multiplication
self.assertIsInstance(j_n, pybamm.Multiplication)
self.assertEqual(j_n.domain, ["negative electrode"])
# positive electrode Butler-Volmer is Multiplication
self.assertIsInstance(j_p, pybamm.Multiplication)
self.assertEqual(j_p.domain, ["positive electrode"])
def test_known_solutions(self):
model = pybamm.lithium_ion.ElectrodeSOH()
param = pybamm.LithiumIonParameters()
parameter_values = pybamm.ParameterValues(
chemistry=pybamm.parameter_sets.Mohtat2020)
sim = pybamm.Simulation(model, parameter_values=parameter_values)
V_min = parameter_values.evaluate(param.voltage_low_cut_dimensional)
V_max = parameter_values.evaluate(param.voltage_high_cut_dimensional)
C_n = parameter_values.evaluate(param.C_n_init)
C_p = parameter_values.evaluate(param.C_p_init)
n_Li = parameter_values.evaluate(param.n_Li_particles_init)
# Solve the model and check outputs
esoh_sol = sim.solve(
[0],
inputs={
"V_min": V_min,
"V_max": V_max,
"C_n": C_n,
"C_p": C_p,
"n_Li": n_Li,
},
)
x, y = pybamm.lithium_ion.get_initial_stoichiometries(
1, parameter_values)
self.assertAlmostEqual(x, esoh_sol["x_100"].data[0])
self.assertAlmostEqual(y, esoh_sol["y_100"].data[0])
x, y = pybamm.lithium_ion.get_initial_stoichiometries(
0, parameter_values)
self.assertAlmostEqual(x, esoh_sol["x_0"].data[0])
self.assertAlmostEqual(y, esoh_sol["y_0"].data[0])
def test_discretisation(self):
param = pybamm.LithiumIonParameters()
model_n = pybamm.interface.ButlerVolmer(
param,
"Negative",
"lithium-ion main",
{
"SEI film resistance": "none",
"total interfacial current density as a state": "false",
},
)
j_n = model_n.get_coupled_variables(
self.variables)["Negative electrode interfacial current density"]
model_p = pybamm.interface.ButlerVolmer(
param,
"Positive",
"lithium-ion main",
{
"SEI film resistance": "none",
"total interfacial current density as a state": "false",
},
)
j_p = model_p.get_coupled_variables(
self.variables)["Positive electrode interfacial current density"]
j = pybamm.concatenation(j_n,
pybamm.PrimaryBroadcast(0,
["separator"]), j_p)
# Process parameters and discretise
parameter_values = pybamm.lithium_ion.BaseModel(
).default_parameter_values
disc = get_discretisation_for_testing()
mesh = disc.mesh
disc.set_variable_slices([
self.c_e_n,
self.c_e_p,
self.delta_phi_s_n,
self.delta_phi_s_p,
self.c_s_n_surf,
self.c_s_p_surf,
])
j_n = disc.process_symbol(parameter_values.process_symbol(j_n))
j_p = disc.process_symbol(parameter_values.process_symbol(j_p))
j = disc.process_symbol(parameter_values.process_symbol(j))
# test butler-volmer in each electrode
submesh = np.concatenate([
mesh["negative electrode"].nodes, mesh["positive electrode"].nodes
])
y = np.concatenate([submesh**2, submesh**3, submesh**4])
self.assertEqual(
j_n.evaluate(None, y).shape, (mesh["negative electrode"].npts, 1))
self.assertEqual(
j_p.evaluate(None, y).shape, (mesh["positive electrode"].npts, 1))
# test concatenated butler-volmer
whole_cell = ["negative electrode", "separator", "positive electrode"]
whole_cell_mesh = disc.mesh.combine_submeshes(*whole_cell)
self.assertEqual(j.evaluate(None, y).shape, (whole_cell_mesh.npts, 1))
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a = pybamm.Scalar(0)
surf = "surface area per unit volume distribution in x"
variables = {
"Electrolyte tortuosity":
a,
"Electrolyte concentration":
pybamm.FullBroadcast(
a,
["negative electrode", "separator", "positive electrode"],
"current collector",
),
"Negative " + surf:
pybamm.FullBroadcast(a, "negative electrode", "current collector"),
"Positive " + surf:
pybamm.FullBroadcast(a, "positive electrode", "current collector"),
"Sum of interfacial current densities":
pybamm.FullBroadcast(
a,
["negative electrode", "separator", "positive electrode"],
"current collector",
),
"Cell temperature":
a,
}
submodel = pybamm.electrolyte_conductivity.Full(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_discretisation_lithium_ion(self):
param = pybamm.LithiumIonParameters()
model_n = pybamm.interface.BaseInterface(param, "Negative",
"lithium-ion main")
j0_n = model_n._get_exchange_current_density(self.variables)
model_p = pybamm.interface.BaseInterface(param, "Positive",
"lithium-ion main")
j0_p = model_p._get_exchange_current_density(self.variables)
# Process parameters and discretise
parameter_values = pybamm.lithium_ion.BaseModel(
).default_parameter_values
disc = get_discretisation_for_testing()
mesh = disc.mesh
disc.set_variable_slices(
[self.c_e, self.c_s_n_surf.orphans[0], self.c_s_p_surf.orphans[0]])
j0_n = disc.process_symbol(parameter_values.process_symbol(j0_n))
j0_p = disc.process_symbol(parameter_values.process_symbol(j0_p))
# Test
whole_cell = ["negative electrode", "separator", "positive electrode"]
submesh = mesh.combine_submeshes(*whole_cell)
y = np.concatenate([
submesh.nodes**2,
mesh["negative particle"].nodes,
mesh["positive particle"].nodes,
])
# should evaluate to vectors with the right shape
self.assertEqual(
j0_n.evaluate(y=y).shape, (mesh["negative electrode"].npts, 1))
self.assertEqual(
j0_p.evaluate(y=y).shape, (mesh["positive electrode"].npts, 1))
def test_public_functions(self):
a_n = pybamm.FullBroadcast(pybamm.Scalar(0), ["negative electrode"],
"current collector")
a_p = pybamm.FullBroadcast(pybamm.Scalar(0), ["positive electrode"],
"current collector")
a = pybamm.Scalar(0)
variables = {
"Negative particle crack length": a_n,
"Negative particle surface concentration": a_n,
"R-averaged negative particle concentration": a_n,
"Average negative particle concentration": a,
"X-averaged cell temperature": a,
"Negative electrode temperature": a_n,
"Positive particle crack length": a_p,
"Positive particle surface concentration": a_p,
"R-averaged positive particle concentration": a_p,
"Average positive particle concentration": a,
"Positive electrode temperature": a_p,
}
options = {
"particle": "Fickian diffusion",
"particle cracking": "both"
}
param = pybamm.LithiumIonParameters(options)
submodel = pybamm.particle_cracking.CrackPropagation(param, "Negative")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle_cracking.CrackPropagation(param, "Positive")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle_cracking.NoCracking(param, "Positive")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
submodel = pybamm.external_circuit.FunctionControl(
param, external_circuit_function
)
variables = {"Terminal voltage [V]": pybamm.Scalar(0)}
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_creation_lithium_ion(self):
param = pybamm.LithiumIonParameters()
model_n = pybamm.interface.BaseInterface(param, "Negative", "lithium-ion main")
j0_n = model_n._get_exchange_current_density(self.variables)
model_p = pybamm.interface.BaseInterface(param, "Positive", "lithium-ion main")
j0_p = model_p._get_exchange_current_density(self.variables)
self.assertEqual(j0_n.domain, ["negative electrode"])
self.assertEqual(j0_p.domain, ["positive electrode"])
def __init__(self, name="Electrode-specific SOH model"):
pybamm.citations.register("Mohtat2019")
super().__init__(name)
param = pybamm.LithiumIonParameters()
Un = param.U_n_dimensional
Up = param.U_p_dimensional
T_ref = param.T_ref
x_100 = pybamm.Variable("x_100", bounds=(0, 1))
C = pybamm.Variable("C", bounds=(0, np.inf))
V_max = pybamm.InputParameter("V_max")
V_min = pybamm.InputParameter("V_min")
C_n = pybamm.InputParameter("C_n")
C_p = pybamm.InputParameter("C_p")
n_Li = pybamm.InputParameter("n_Li")
y_100 = (n_Li * param.F / 3600 - x_100 * C_n) / C_p
x_0 = x_100 - C / C_n
y_0 = y_100 + C / C_p
self.algebraic = {
x_100: Up(y_100, T_ref) - Un(x_100, T_ref) - V_max,
C: Up(y_0, T_ref) - Un(x_0, T_ref) - V_min,
}
# initial guess must be chosen such that 0 < x_0, y_0, x_100, y_100 < 1
# First guess for x_100
x_100_init = 0.85
# Make sure x_0 = x_100 - C/C_n > 0
C_init = param.Q
C_init = pybamm.minimum(C_n * x_100_init - 0.1, C_init)
# Make sure y_100 > 0
# x_100_init = pybamm.minimum(n_Li * param.F / 3600 / C_n - 0.01, x_100_init)
self.initial_conditions = {x_100: x_100_init, C: C_init}
self.variables = {
"x_100": x_100,
"y_100": y_100,
"C": C,
"x_0": x_0,
"y_0": y_0,
"Un(x_100)": Un(x_100, T_ref),
"Un(x_0)": Un(x_0, T_ref),
"Up(y_100)": Up(y_100, T_ref),
"Up(y_0)": Up(y_0, T_ref),
"Up(y_100) - Un(x_100)": Up(y_100, T_ref) - Un(x_100, T_ref),
"Up(y_0) - Un(x_0)": Up(y_0, T_ref) - Un(x_0, T_ref),
"n_Li_100": 3600 / param.F * (y_100 * C_p + x_100 * C_n),
"n_Li_0": 3600 / param.F * (y_0 * C_p + x_0 * C_n),
"n_Li": n_Li,
"C_n": C_n,
"C_p": C_p,
"C_n * (x_100 - x_0)": C_n * (x_100 - x_0),
"C_p * (y_100 - y_0)": C_p * (y_0 - y_100),
}
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a = pybamm.PrimaryBroadcast(pybamm.Scalar(0), "current collector")
variables = {
"Current collector current density": a,
"X-averaged negative electrode interfacial current density": a,
"X-averaged negative electrode temperature": a,
"Negative electrode active material volume fraction": a,
"Negative electrode surface area to volume ratio": a,
}
submodel = pybamm.particle.PolynomialSingleParticle(
param, "Negative", "uniform profile"
)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle.PolynomialSingleParticle(
param, "Negative", "quadratic profile"
)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle.PolynomialSingleParticle(
param, "Negative", "quartic profile"
)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
variables = {
"Current collector current density": a,
"X-averaged positive electrode interfacial current density": a,
"X-averaged positive electrode temperature": a,
"Positive electrode active material volume fraction": a,
"Positive electrode surface area to volume ratio": a,
}
submodel = pybamm.particle.PolynomialSingleParticle(
param, "Positive", "uniform profile"
)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle.PolynomialSingleParticle(
param, "Positive", "quadratic profile"
)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle.PolynomialSingleParticle(
param, "Positive", "quartic profile"
)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a = pybamm.PrimaryBroadcast(1, "current collector")
a_n = pybamm.FullBroadcast(
pybamm.Scalar(1), ["negative electrode"], "current collector"
)
a_s = pybamm.FullBroadcast(pybamm.Scalar(1), ["separator"], "current collector")
a_p = pybamm.FullBroadcast(
pybamm.Scalar(1), ["positive electrode"], "current collector"
)
c_e_n = pybamm.standard_variables.c_e_n
c_e_s = pybamm.standard_variables.c_e_s
c_e_p = pybamm.standard_variables.c_e_p
variables = {
"Leading-order current collector current density": a,
"Negative electrolyte concentration": c_e_n,
"Separator electrolyte concentration": c_e_s,
"Positive electrolyte concentration": c_e_p,
"X-averaged electrolyte concentration": a,
"X-averaged negative electrode potential": a,
"X-averaged negative electrode surface potential difference": a,
"Leading-order x-averaged negative electrode porosity": a,
"Leading-order x-averaged separator porosity": a,
"Leading-order x-averaged positive electrode porosity": a,
"Leading-order x-averaged negative electrolyte tortuosity": a,
"Leading-order x-averaged separator tortuosity": a,
"Leading-order x-averaged positive electrolyte tortuosity": a,
"X-averaged cell temperature": a,
"Current collector current density": a,
"Negative electrode porosity": a_n,
"Sum of x-averaged negative electrode interfacial current densities": a,
"X-averaged negative electrode total interfacial current density": a,
"Current collector current density": a,
"Negative electrolyte potential": a_n,
"Negative electrolyte current density": a_n,
"Separator electrolyte potential": a_s,
"Separator electrolyte current density": a_s,
"Positive electrode porosity": a_p,
"Sum of x-averaged positive electrode interfacial current densities": a,
"X-averaged positive electrode total interfacial current density": a,
}
spf = pybamm.electrolyte_conductivity.surface_potential_form
submodel = spf.CompositeAlgebraic(param, "Negative")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = spf.CompositeDifferential(param, "Negative")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = spf.CompositeAlgebraic(param, "Positive")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = spf.CompositeDifferential(param, "Positive")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_print_parameters(self):
parameters = pybamm.LithiumIonParameters()
parameter_values = pybamm.lithium_ion.BaseModel(
).default_parameter_values
output_file = "lithium_ion_parameters.txt"
parameter_values.print_parameters(parameters, output_file)
# test print_parameters with dict and without C-rate
del parameter_values["Nominal cell capacity [A.h]"]
parameters = {"C_e": parameters.C_e, "sigma_n": parameters.sigma_n}
parameter_values.print_parameters(parameters)
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a = pybamm.Scalar(0)
variables = {
"Current collector current density": a,
"X-averaged negative electrode potential": a,
"X-averaged negative electrode surface potential difference": a,
}
submodel = pybamm.electrolyte_conductivity.LeadingOrder(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_symbol_visualise(self):
param = pybamm.LithiumIonParameters()
zero_n = pybamm.FullBroadcast(0, ["negative electrode"],
"current collector")
zero_s = pybamm.FullBroadcast(0, ["separator"], "current collector")
zero_p = pybamm.FullBroadcast(0, ["positive electrode"],
"current collector")
zero_nsp = pybamm.concatenation(zero_n, zero_s, zero_p)
v_box = pybamm.Scalar(0)
variables = {
"Porosity":
param.epsilon,
"Negative electrode porosity":
param.epsilon_n,
"Separator porosity":
param.epsilon_s,
"Positive electrode porosity":
param.epsilon_p,
"Electrolyte tortuosity":
param.epsilon**1.5,
"Porosity change":
zero_nsp,
"Electrolyte current density":
zero_nsp,
"Volume-averaged velocity":
v_box,
"Interfacial current density":
zero_nsp,
"Oxygen interfacial current density":
zero_nsp,
"Cell temperature":
pybamm.concatenation(zero_n, zero_s, zero_p),
"Transverse volume-averaged acceleration":
pybamm.concatenation(zero_n, zero_s, zero_p),
"Sum of electrolyte reaction source terms":
zero_nsp,
}
model = pybamm.electrolyte_diffusion.Full(param)
variables.update(model.get_fundamental_variables())
variables.update(model.get_coupled_variables(variables))
model.set_rhs(variables)
rhs = list(model.rhs.values())[0]
rhs.visualise("StefanMaxwell_test.png")
self.assertTrue(os.path.exists("StefanMaxwell_test.png"))
with self.assertRaises(ValueError):
rhs.visualise("StefanMaxwell_test")
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
submodel = pybamm.current_collector.Uniform(param)
variables = {
"Positive current collector potential": pybamm.PrimaryBroadcast(
0, "current collector"
),
"Total current density": 0,
}
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def get_initial_stoichiometries(initial_soc, parameter_values):
"""
Calculate initial stoichiometries to start off the simulation at a particular
state of charge, given voltage limits, open-circuit potentials, etc defined by
parameter_values
Parameters
----------
initial_soc : float
Target initial SOC. Must be between 0 and 1.
parameter_values : :class:`pybamm.ParameterValues`
The parameter values class that will be used for the simulation. Required for
calculating appropriate initial stoichiometries.
Returns
-------
x, y
The initial stoichiometries that give the desired initial state of charge
"""
if initial_soc < 0 or initial_soc > 1:
raise ValueError("Initial SOC should be between 0 and 1")
model = pybamm.lithium_ion.ElectrodeSOH()
param = pybamm.LithiumIonParameters()
sim = pybamm.Simulation(model, parameter_values=parameter_values)
V_min = parameter_values.evaluate(param.voltage_low_cut_dimensional)
V_max = parameter_values.evaluate(param.voltage_high_cut_dimensional)
C_n = parameter_values.evaluate(param.C_n_init)
C_p = parameter_values.evaluate(param.C_p_init)
n_Li = parameter_values.evaluate(param.n_Li_particles_init)
# Solve the model and check outputs
sol = sim.solve(
[0],
inputs={
"V_min": V_min,
"V_max": V_max,
"C_n": C_n,
"C_p": C_p,
"n_Li": n_Li,
},
)
x_0 = sol["x_0"].data[0]
y_0 = sol["y_0"].data[0]
C = sol["C"].data[0]
x = x_0 + initial_soc * C / C_n
y = y_0 - initial_soc * C / C_p
return x, y
def external_circuit_function(variables):
I = variables["Current [A]"]
V = variables["Terminal voltage [V]"]
liion_param = pybamm.LithiumIonParameters()
return (
V
+ I
- pybamm.FunctionParameter(
"Current plus voltage function",
{"Time [s]": pybamm.t * liion_param.timescale},
)
)
def test_set_parameters_lithium_ion(self):
param = pybamm.LithiumIonParameters()
model_n = pybamm.interface.BaseInterface(param, "Negative", "lithium-ion main")
j0_n = model_n._get_exchange_current_density(self.variables)
model_p = pybamm.interface.BaseInterface(param, "Positive", "lithium-ion main")
j0_p = model_p._get_exchange_current_density(self.variables)
# Process parameters
parameter_values = pybamm.lithium_ion.BaseModel().default_parameter_values
j0_n = parameter_values.process_symbol(j0_n)
j0_p = parameter_values.process_symbol(j0_p)
# Test
for x in j0_n.pre_order():
self.assertNotIsInstance(x, pybamm.Parameter)
for x in j0_p.pre_order():
self.assertNotIsInstance(x, pybamm.Parameter)
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a_n = pybamm.FullBroadcast(pybamm.Scalar(0), ["negative electrode"],
"current collector")
variables = {
"Negative electrode surface potential difference": a_n,
"Negative electrode temperature": a_n,
"Negative electrolyte concentration": a_n,
"Negative electrode lithium plating concentration": a_n,
"Negative electrode SEI film overpotential": a_n,
}
submodel = pybamm.lithium_plating.ReversiblePlating(param, "Negative")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LithiumIonParameters()
a_n = pybamm.FullBroadcast(pybamm.Scalar(0), "negative electrode",
{"secondary": "current collector"})
a_p = pybamm.FullBroadcast(pybamm.Scalar(0), "positive electrode",
{"secondary": "current collector"})
variables = {
"Negative electrode interfacial current density": a_n,
"Negative electrode temperature": a_n,
}
submodel = pybamm.particle.PolynomialManyParticles(
param, "Negative", "uniform profile")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle.PolynomialManyParticles(
param, "Negative", "quadratic profile")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle.PolynomialManyParticles(
param, "Negative", "quartic profile")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
variables = {
"Positive electrode interfacial current density": a_p,
"Positive electrode temperature": a_p,
}
submodel = pybamm.particle.PolynomialManyParticles(
param, "Positive", "uniform profile")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle.PolynomialManyParticles(
param, "Positive", "quadratic profile")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.particle.PolynomialManyParticles(
param, "Positive", "quartic profile")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
