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