def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.Scalar(0)
variables = {
"Porosity": pybamm.Concatenation(
pybamm.FullBroadcast(a, "negative electrode", "current collector"),
pybamm.FullBroadcast(a, "separator", "current collector"),
pybamm.FullBroadcast(a, "positive electrode", "current collector"),
),
"Electrolyte tortuosity": pybamm.Concatenation(
pybamm.FullBroadcast(a, "negative electrode", "current collector"),
pybamm.FullBroadcast(a, "separator", "current collector"),
pybamm.FullBroadcast(a, "positive electrode", "current collector"),
),
"Porosity change": pybamm.Concatenation(
pybamm.FullBroadcast(a, "negative electrode", "current collector"),
pybamm.FullBroadcast(a, "separator", "current collector"),
pybamm.FullBroadcast(a, "positive electrode", "current collector"),
),
"Volume-averaged velocity": a,
"Negative electrode interfacial current density": pybamm.FullBroadcast(
a, "negative electrode", "current collector"
),
"Positive electrode interfacial current density": pybamm.FullBroadcast(
a, "positive electrode", "current collector"
),
"Positive electrode oxygen interfacial current "
"density": pybamm.FullBroadcast(
a, "positive electrode", "current collector"
),
}
submodel = pybamm.oxygen_diffusion.Full(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_discretisation_main_reaction(self):
# With intercalation
param = pybamm.LeadAcidParameters()
model_n = pybamm.interface.BaseInterface(param, "Negative",
"lead-acid main")
j0_n = model_n._get_exchange_current_density(self.variables)
model_p = pybamm.interface.BaseInterface(param, "Positive",
"lead-acid main")
j0_p = model_p._get_exchange_current_density(self.variables)
# Process parameters and discretise
parameter_values = pybamm.lead_acid.BaseModel(
).default_parameter_values
disc = get_discretisation_for_testing()
mesh = disc.mesh
disc.set_variable_slices([self.c_e])
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 = submesh.nodes**2
# 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_update_initial_state_of_charge(self):
# Load parameters to be tested
parameters = pybamm.LeadAcidParameters()
parameter_values = pybamm.lead_acid.BaseModel(
).default_parameter_values
param_eval = parameter_values.print_parameters(parameters)
param_eval = {k: v[0] for k, v in param_eval.items()}
# Update initial state of charge
parameter_values.update({"Initial State of Charge": 0.2})
param_eval_update = parameter_values.print_parameters(parameters)
param_eval_update = {k: v[0] for k, v in param_eval_update.items()}
# Test that relevant parameters have changed as expected
self.assertLess(param_eval_update["q_init"], param_eval["q_init"])
self.assertLess(param_eval_update["c_e_init"], param_eval["c_e_init"])
self.assertLess(param_eval_update["epsilon_n_init"],
param_eval["epsilon_n_init"])
self.assertEqual(param_eval_update["epsilon_s_init"],
param_eval["epsilon_s_init"])
self.assertLess(param_eval_update["epsilon_p_init"],
param_eval["epsilon_p_init"])
self.assertGreater(param_eval_update["curlyU_n_init"],
param_eval["curlyU_n_init"])
self.assertGreater(param_eval_update["curlyU_p_init"],
param_eval["curlyU_p_init"])
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_functions_lead_acid(self):
# Load parameters to be tested
param = pybamm.LeadAcidParameters()
parameters = {
"D_e_1": param.D_e(pybamm.Scalar(1), pybamm.Scalar(0)),
"kappa_e_0": param.kappa_e(pybamm.Scalar(0), pybamm.Scalar(0)),
"chi_1": param.chi(pybamm.Scalar(1), pybamm.Scalar(0)),
"chi_0.5": param.chi(pybamm.Scalar(0.5), pybamm.Scalar(0)),
"U_n_1": param.U_n(pybamm.Scalar(1), pybamm.Scalar(0)),
"U_n_0.5": param.U_n(pybamm.Scalar(0.5), pybamm.Scalar(0)),
"U_p_1": param.U_p(pybamm.Scalar(1), pybamm.Scalar(0)),
"U_p_0.5": param.U_p(pybamm.Scalar(0.5), pybamm.Scalar(0)),
}
# Process
parameter_values = pybamm.ParameterValues(
chemistry=pybamm.parameter_sets.Sulzer2019)
param_eval = parameter_values.print_parameters(parameters)
param_eval = {k: v[0] for k, v in param_eval.items()}
# Known values for dimensionless functions
self.assertEqual(param_eval["D_e_1"], 1)
self.assertEqual(param_eval["kappa_e_0"], 0)
# Known monotonicity for dimensionless functions
self.assertGreater(param_eval["chi_1"], param_eval["chi_0.5"])
self.assertLess(param_eval["U_n_1"], param_eval["U_n_0.5"])
self.assertGreater(param_eval["U_p_1"], param_eval["U_p_0.5"])
def test_current_functions(self):
# create current functions
param = pybamm.LeadAcidParameters()
dimensional_current_density = param.dimensional_current_density_with_time
dimensionless_current_density = param.current_with_time
# process
parameter_values = pybamm.ParameterValues({
"Electrode height [m]":
0.1,
"Electrode width [m]":
0.1,
"Negative electrode thickness [m]":
1,
"Separator thickness [m]":
1,
"Positive electrode thickness [m]":
1,
"Typical electrolyte concentration [mol.m-3]":
1,
"Number of electrodes connected in parallel to make a cell":
8,
"Typical current [A]":
2,
"Current function [A]":
2,
})
dimensional_current_density_eval = parameter_values.process_symbol(
dimensional_current_density)
dimensionless_current_density_eval = parameter_values.process_symbol(
dimensionless_current_density)
self.assertAlmostEqual(dimensional_current_density_eval.evaluate(t=3),
2 / (8 * 0.1 * 0.1))
self.assertEqual(dimensionless_current_density_eval.evaluate(t=3), 1)
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.Scalar(0)
variables = {
"Current collector current density":
a,
"Negative electrolyte current density":
pybamm.PrimaryBroadcast(a, ["negative electrode"]),
"Positive electrolyte current density":
pybamm.PrimaryBroadcast(a, ["positive electrode"]),
"Negative electrode porosity":
a,
"Positive electrode porosity":
a,
"Separator electrolyte potential":
a,
"Positive electrode surface potential difference":
a,
}
submodel = pybamm.electrode.ohm.SurfaceForm(param, "Negative")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.electrode.ohm.SurfaceForm(param, "Positive")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.Scalar(0)
variables = {
"Porosity":
a,
"X-averaged negative electrode porosity":
a,
"X-averaged separator porosity":
a,
"X-averaged positive electrode porosity":
a,
"X-averaged negative electrode porosity change":
a,
"X-averaged separator porosity change":
a,
"X-averaged positive electrode porosity change":
a,
"Sum of x-averaged negative electrode interfacial current densities":
a,
"Sum of x-averaged positive electrode interfacial current densities":
a,
"Sum of x-averaged negative electrode electrolyte reaction source terms":
a,
"Sum of x-averaged positive electrode electrolyte reaction source terms":
a,
"X-averaged separator transverse volume-averaged acceleration":
a,
}
submodel = pybamm.electrolyte_diffusion.LeadingOrder(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_diff_delta_phi_e_lead_acid(self):
# With intercalation
param = pybamm.LeadAcidParameters()
model_n = pybamm.interface.ButlerVolmer(param, "Negative",
"lead-acid main")
model_p = pybamm.interface.ButlerVolmer(param, "Positive",
"lead-acid main")
parameter_values = pybamm.lead_acid.BaseModel(
).default_parameter_values
def j_n(delta_phi):
variables = {
**self.variables,
"Negative electrode surface potential difference":
delta_phi,
"Negative electrolyte concentration":
1,
}
return model_n.get_coupled_variables(variables)[
"Negative electrode interfacial current density"].orphans[0]
def j_p(delta_phi):
variables = {
**self.variables,
"Positive electrode surface potential difference":
delta_phi,
"Positive electrolyte concentration":
1,
}
return model_p.get_coupled_variables(variables)[
"Positive electrode interfacial current density"].orphans[0]
delta_phi = pybamm.InputParameter("delta_phi")
h = pybamm.Scalar(0.00001)
# Analytical
x = j_n(delta_phi)
x.diff(delta_phi)
j_n_diff = parameter_values.process_symbol(
j_n(delta_phi).diff(delta_phi))
j_p_diff = parameter_values.process_symbol(
j_p(delta_phi).diff(delta_phi))
# Numerical
j_n_FD = parameter_values.process_symbol(
(j_n(delta_phi + h) - j_n(delta_phi - h)) / (2 * h))
self.assertAlmostEqual(
j_n_diff.evaluate(inputs={"delta_phi": 0.5}),
j_n_FD.evaluate(inputs={"delta_phi": 0.5}),
places=5,
)
j_p_FD = parameter_values.process_symbol(
(j_p(delta_phi + h) - j_p(delta_phi - h)) / (2 * h))
self.assertAlmostEqual(
j_p_diff.evaluate(inputs={"delta_phi": 0.5}),
j_p_FD.evaluate(inputs={"delta_phi": 0.5}),
places=5,
)
def test_print_parameters(self):
parameters = pybamm.LeadAcidParameters()
parameter_values = pybamm.lead_acid.BaseModel().default_parameter_values
output_file = "lead_acid_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.LeadAcidParameters()
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,
}
submodel = pybamm.porosity.LeadingOrder(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_creation_main_reaction(self):
# With intercalation
param = pybamm.LeadAcidParameters()
model_n = pybamm.interface.BaseInterface(param, "Negative",
"lead-acid main")
j0_n = model_n._get_exchange_current_density(self.variables)
model_p = pybamm.interface.BaseInterface(param, "Positive",
"lead-acid 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 test_public_functions(self):
param = pybamm.LeadAcidParameters()
a_n = pybamm.PrimaryBroadcast(pybamm.Scalar(0), ["negative electrode"])
a_p = pybamm.PrimaryBroadcast(pybamm.Scalar(0), ["positive electrode"])
variables = {
"Negative electrode interfacial current density": a_n,
"Negative electrode sei interfacial current density": a_n,
"Positive electrode interfacial current density": a_p,
}
submodel = pybamm.porosity.Full(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.Scalar(0)
a_s = pybamm.PrimaryBroadcast(a, "separator")
variables = {
"Current collector current density": a,
"Separator pressure": a_s
}
submodel = pybamm.convection.through_cell.NoConvection(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.Scalar(0)
variables = {
"Current collector current density": a,
"X-averaged positive electrode open circuit potential": a,
"X-averaged positive electrode reaction overpotential": a,
"X-averaged positive electrolyte potential": a,
}
submodel = pybamm.electrode.ohm.LeadingOrder(param, "Negative")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.electrode.ohm.LeadingOrder(param, "Positive")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.Scalar(0)
variables = {
"X-averaged negative electrode porosity": a,
"X-averaged separator porosity": a,
"X-averaged positive electrode porosity": a,
"X-averaged negative electrode porosity change": a,
"X-averaged separator porosity change": a,
"X-averaged positive electrode porosity change": a,
"X-averaged negative electrode interfacial current density": a,
"X-averaged positive electrode interfacial current density": a,
"X-averaged negative electrode oxygen interfacial current density": a,
"X-averaged positive electrode oxygen interfacial current density": a,
}
submodel = pybamm.oxygen_diffusion.LeadingOrder(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.Scalar(0)
variables = {
"Current collector current density": a,
"Negative electrode porosity": a,
"Positive electrode porosity": a,
"Negative electrode interfacial current density": a,
"Positive electrode interfacial current density": a,
}
submodel = pybamm.electrode.ohm.Full(param, "Negative")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.electrode.ohm.Full(param, "Positive")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_function(self):
param = pybamm.LeadAcidParameters()
a_n = pybamm.PrimaryBroadcast(pybamm.Scalar(0), ["negative electrode"])
a_s = pybamm.PrimaryBroadcast(pybamm.Scalar(0), ["separator"])
a = pybamm.Scalar(0)
variables = {
"Current collector current density":
a,
"Negative electrode potential":
a_n,
"Negative electrolyte potential":
a_n,
"Negative electrolyte concentration":
a_n,
"Negative electrode temperature":
a_n,
"X-averaged positive electrode oxygen interfacial current density":
a,
"Separator tortuosity":
a_s,
"Separator oxygen concentration":
a_s,
"Leading-order negative electrode oxygen interfacial current density":
a,
}
submodel = pybamm.interface.DiffusionLimited(param, "Negative",
"lead-acid oxygen",
"leading")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.interface.DiffusionLimited(param, "Negative",
"lead-acid oxygen",
"composite")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
submodel = pybamm.interface.DiffusionLimited(param, "Negative",
"lead-acid oxygen",
"full")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_thermal_parameters(self):
values = pybamm.lead_acid.BaseModel().default_parameter_values
param = pybamm.LeadAcidParameters()
T = 1 # dummy temperature as the values are constant
# Density
self.assertAlmostEqual(values.evaluate(param.rho_cn(T)), 0.8810, places=2)
self.assertAlmostEqual(values.evaluate(param.rho_n(T)), 0.8810, places=2)
self.assertAlmostEqual(values.evaluate(param.rho_s(T)), 0.7053, places=2)
self.assertAlmostEqual(values.evaluate(param.rho_p(T)), 1.4393, places=2)
self.assertAlmostEqual(values.evaluate(param.rho_cp(T)), 1.4393, places=2)
self.assertAlmostEqual(values.evaluate(param.rho(T)), 1.7102, places=2)
# Thermal conductivity
self.assertAlmostEqual(values.evaluate(param.lambda_cn(T)), 1.6963, places=2)
self.assertAlmostEqual(values.evaluate(param.lambda_n(T)), 1.6963, places=2)
self.assertAlmostEqual(values.evaluate(param.lambda_s(T)), 0.0019, places=2)
self.assertAlmostEqual(values.evaluate(param.lambda_p(T)), 1.6963, places=2)
self.assertAlmostEqual(values.evaluate(param.lambda_cp(T)), 1.6963, places=2)
def test_set_parameters_main_reaction(self):
# With intercalation
param = pybamm.LeadAcidParameters()
model_n = pybamm.interface.BaseInterface(param, "Negative",
"lead-acid main")
j0_n = model_n._get_exchange_current_density(self.variables)
model_p = pybamm.interface.BaseInterface(param, "Positive",
"lead-acid main")
j0_p = model_p._get_exchange_current_density(self.variables)
# Process parameters
parameter_values = pybamm.lead_acid.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_diff_main_reaction(self):
# With intercalation
param = pybamm.LeadAcidParameters()
model_n = pybamm.interface.BaseInterface(param, "Negative",
"lead-acid main")
model_p = pybamm.interface.BaseInterface(param, "Positive",
"lead-acid main")
parameter_values = pybamm.lead_acid.BaseModel(
).default_parameter_values
def j0_n(c_e):
variables = {
**self.variables, "Negative electrolyte concentration": c_e
}
return model_n._get_exchange_current_density(variables)
def j0_p(c_e):
variables = {
**self.variables, "Positive electrolyte concentration": c_e
}
return model_p._get_exchange_current_density(variables)
c_e = pybamm.InputParameter("c_e")
h = pybamm.Scalar(0.00001)
# Analytical
j0_n_diff = parameter_values.process_symbol(j0_n(c_e).diff(c_e))
j0_p_diff = parameter_values.process_symbol(j0_p(c_e).diff(c_e))
# Numerical
j0_n_FD = parameter_values.process_symbol(
(j0_n(c_e + h) - j0_n(c_e - h)) / (2 * h))
self.assertAlmostEqual(
j0_n_diff.evaluate(inputs={"c_e": 0.5}),
j0_n_FD.evaluate(inputs={"c_e": 0.5}),
)
j0_p_FD = parameter_values.process_symbol(
(j0_p(c_e + h) - j0_p(c_e - h)) / (2 * h))
self.assertAlmostEqual(
j0_p_diff.evaluate(inputs={"c_e": 0.5}),
j0_p_FD.evaluate(inputs={"c_e": 0.5}),
)
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.PrimaryBroadcast(1, "current collector")
a_n = pybamm.PrimaryBroadcast(a, ["negative electrode"])
a_s = pybamm.PrimaryBroadcast(a, ["separator"])
a_p = pybamm.PrimaryBroadcast(a, ["positive electrode"])
variables = {
"Current collector current density": a,
"Negative electrode interfacial current density": a_n,
"X-averaged negative electrode interfacial current density": a,
"Positive electrode interfacial current density": a_p,
"X-averaged positive electrode interfacial current density": a,
"X-averaged separator pressure": a,
"X-averaged separator transverse volume-averaged acceleration": a,
"Separator pressure": a_s,
}
submodel = pybamm.convection.through_cell.Explicit(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_concatenated_parameters(self):
# create
param = pybamm.LeadAcidParameters()
s_param = param.s_plus_S
self.assertIsInstance(s_param, pybamm.Concatenation)
self.assertEqual(
s_param.domain,
["negative electrode", "separator", "positive electrode"])
# process parameters and discretise
parameter_values = pybamm.ParameterValues(
chemistry=pybamm.parameter_sets.Sulzer2019)
disc = get_discretisation_for_testing()
processed_s = disc.process_symbol(
parameter_values.process_symbol(s_param))
# test output
combined_submeshes = disc.mesh.combine_submeshes(
"negative electrode", "separator", "positive electrode")
self.assertEqual(processed_s.shape, (combined_submeshes.npts, 1))
def test_parameters_defaults_lead_acid(self):
# Load parameters to be tested
parameters = pybamm.LeadAcidParameters()
parameter_values = pybamm.lead_acid.BaseModel().default_parameter_values
param_eval = parameter_values.print_parameters(parameters)
param_eval = {k: v[0] for k, v in param_eval.items()}
# Diffusional C-rate should be smaller than C-rate
self.assertLess(param_eval["C_e"], param_eval["C_rate"])
# Dimensionless electrode conductivities should be large
self.assertGreater(param_eval["sigma_n"], 10)
self.assertGreater(param_eval["sigma_p"], 10)
# Dimensionless double-layer capacity should be small
self.assertLess(param_eval["C_dl_n"], 1e-3)
self.assertLess(param_eval["C_dl_p"], 1e-3)
# Volume change positive in negative electrode and negative in positive
# electrode
self.assertLess(param_eval["DeltaVsurf_n"], 0)
self.assertGreater(param_eval["DeltaVsurf_p"], 0)
def __init__(self,
options=None,
name="Unnamed lead-acid model",
build=False):
super().__init__(options, name)
self.param = pybamm.LeadAcidParameters()
# Default timescale is discharge timescale
self.timescale = self.param.tau_discharge
# Set default length scales
self.length_scales = {
"negative electrode": self.param.L_x,
"separator": self.param.L_x,
"positive electrode": self.param.L_x,
"current collector y": self.param.L_y,
"current collector z": self.param.L_z,
}
self.set_standard_output_variables()
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
submodel = pybamm.convection.through_cell.BaseThroughCellModel(param)
a = pybamm.PrimaryBroadcast(0, "current collector")
a_n = pybamm.PrimaryBroadcast(0, "negative electrode")
a_s = pybamm.PrimaryBroadcast(0, "separator")
a_p = pybamm.PrimaryBroadcast(0, "positive electrode")
variables = {
"X-averaged separator transverse volume-averaged acceleration": a,
"Current collector current density": a,
"Negative electrode volume-averaged velocity": a_n,
"Positive electrode volume-averaged velocity": a_p,
"Negative electrode volume-averaged acceleration": a_n,
"Positive electrode volume-averaged acceleration": a_p,
"Negative electrode pressure": a_n,
"Separator pressure": a_s,
"Positive electrode pressure": a_p,
}
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
a = pybamm.Scalar(0)
variables = {
"Current collector current density":
pybamm.PrimaryBroadcast(a, "current collector"),
"Interfacial current density":
a,
"Negative electrode interfacial current density":
a,
"Positive electrode interfacial current density":
a,
"X-averaged separator transverse volume-averaged acceleration":
a,
"X-averaged separator pressure":
a,
"Separator pressure":
pybamm.FullBroadcast(a, "separator", "current collector"),
}
submodel = pybamm.convection.through_cell.Full(param)
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
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 = {
"Current collector current density": a,
"Negative electrode potential": a_n,
"Negative electrolyte potential": a_n,
"Negative electrode open circuit potential": a_n,
"Negative electrolyte concentration": a_n,
"Negative particle surface concentration": a_n,
"Negative electrode temperature": a_n,
}
submodel = pybamm.interface.ButlerVolmer(param, "Negative",
"lead-acid main")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
variables = {
"Current collector current density":
a,
"Positive electrode potential":
a_p,
"Positive electrolyte potential":
a_p,
"Positive electrode open circuit potential":
a_p,
"Positive electrolyte concentration":
a_p,
"Positive particle surface concentration":
a_p,
"Negative electrode interfacial current density":
a_n,
"Negative electrode exchange current density":
a_n,
"Positive electrode temperature":
a_p,
"X-averaged negative electrode interfacial current density":
a,
"X-averaged positive electrode interfacial current density":
a,
"Sum of electrolyte reaction source terms":
0,
"Sum of negative electrode electrolyte reaction source terms":
0,
"Sum of positive electrode electrolyte reaction source terms":
0,
"Sum of x-averaged negative electrode "
"electrolyte reaction source terms":
0,
"Sum of x-averaged positive electrode "
"electrolyte reaction source terms":
0,
"Sum of interfacial current densities":
0,
"Sum of negative electrode interfacial current densities":
0,
"Sum of positive electrode interfacial current densities":
0,
"Sum of x-averaged negative electrode interfacial current densities":
0,
"Sum of x-averaged positive electrode interfacial current densities":
0,
}
submodel = pybamm.interface.ButlerVolmer(param, "Positive",
"lead-acid main")
std_tests = tests.StandardSubModelTests(submodel, variables)
std_tests.test_all()
def test_scipy_constants(self):
param = pybamm.LeadAcidParameters()
self.assertAlmostEqual(param.R.evaluate(), 8.314, places=3)
self.assertAlmostEqual(param.F.evaluate(), 96485, places=0)
def test_public_functions(self):
param = pybamm.LeadAcidParameters()
submodel = pybamm.oxygen_diffusion.NoOxygen(param)
std_tests = tests.StandardSubModelTests(submodel)
std_tests.test_all()
