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()