Update C-Rate current for changing nominal capacity (#5286)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: BradyPlanden

src/pybamm/simulation.py

@@ -128,6 +128,7 @@ def __init__(
         self._model_with_set_params = None
         self._built_model = None
         self._built_initial_soc = None
+        self._built_nominal_capacity = None
         self.steps_to_built_models = None
         self.steps_to_built_solvers = None
         self._mesh = None
@@ -163,6 +164,42 @@ def set_up_and_parameterise_experiment(self, solve_kwargs=None):
         warnings.warn(msg, DeprecationWarning, stacklevel=2)
         self._set_up_and_parameterise_experiment(solve_kwargs=solve_kwargs)
 
+    def _update_experiment_models_for_capacity(self, solve_kwargs=None):
+        """
+        Check if the nominal capacity has changed and update the experiment models
+        if needed. This re-processes the models without rebuilding the mesh and
+        discretisation.
+        """
+        current_capacity = self._parameter_values.get(
+            "Nominal cell capacity [A.h]", None
+        )
+
+        if self._built_nominal_capacity == current_capacity:
+            return
+
+        # Capacity has changed, need to re-process the models
+        pybamm.logger.info(
+            f"Nominal capacity changed from {self._built_nominal_capacity} to "
+            f"{current_capacity}. Re-processing experiment models."
+        )
+
+        # Re-parameterise the experiment with the new capacity
+        self._set_up_and_parameterise_experiment(solve_kwargs)
+
+        # Re-discretise the models
+        self.steps_to_built_models = {}
+        self.steps_to_built_solvers = {}
+        for (
+            step,
+            model_with_set_params,
+        ) in self.experiment_unique_steps_to_model.items():
+            built_model = self._disc.process_model(model_with_set_params, inplace=True)
+            solver = self._solver.copy()
+            self.steps_to_built_solvers[step] = solver
+            self.steps_to_built_models[step] = built_model
+
+        self._built_nominal_capacity = current_capacity
+
     def _set_up_and_parameterise_experiment(self, solve_kwargs=None):
         """
         Create and parameterise the models for each step in the experiment.
@@ -266,6 +303,7 @@ def set_initial_state(self, initial_soc, direction=None, inputs=None):
             # reset
             self._model_with_set_params = None
             self._built_model = None
+            self._built_nominal_capacity = None
             self.steps_to_built_models = None
             self.steps_to_built_solvers = None
 
@@ -338,6 +376,8 @@ def build_for_experiment(
             self.set_initial_state(initial_soc, direction=direction, inputs=inputs)
 
         if self.steps_to_built_models:
+            # Check if we need to update the models due to capacity change
+            self._update_experiment_models_for_capacity(solve_kwargs)
             return
         else:
             self._set_up_and_parameterise_experiment(solve_kwargs)
@@ -366,6 +406,10 @@ def build_for_experiment(
                 self.steps_to_built_solvers[step] = solver
                 self.steps_to_built_models[step] = built_model
 
+            self._built_nominal_capacity = self._parameter_values.get(
+                "Nominal cell capacity [A.h]", None
+            )
+
     def solve(
         self,
         t_eval=None,

tests/unit/test_experiments/test_simulation_with_experiment.py

@@ -1,3 +1,4 @@
+import logging
 import os
 from datetime import datetime
 
@@ -1022,3 +1023,125 @@ def neg_stoich_cutoff(variables):
 
         neg_stoich = sol["Negative electrode stoichiometry"].data
         assert neg_stoich[-1] == pytest.approx(0.5, abs=0.0001)
+
+    def test_simulation_changing_capacity_crate_steps(self):
+        """Test that C-rate steps are correctly updated when capacity changes"""
+        model = pybamm.lithium_ion.SPM()
+        experiment = pybamm.Experiment(
+            [
+                (
+                    "Discharge at C/5 for 20 minutes",
+                    "Discharge at C/2 for 20 minutes",
+                    "Discharge at 1C for 20 minutes",
+                )
+            ]
+        )
+        param = pybamm.ParameterValues("Chen2020")
+        sim = pybamm.Simulation(model, experiment=experiment, parameter_values=param)
+
+        # First solve
+        sol1 = sim.solve(calc_esoh=False)
+        original_capacity = param["Nominal cell capacity [A.h]"]
+
+        # Check that C-rates correspond to expected currents
+        I_C5_1 = np.abs(sol1.cycles[0].steps[0]["Current [A]"].data).mean()
+        I_C2_1 = np.abs(sol1.cycles[0].steps[1]["Current [A]"].data).mean()
+        I_1C_1 = np.abs(sol1.cycles[0].steps[2]["Current [A]"].data).mean()
+
+        np.testing.assert_allclose(I_C5_1, original_capacity / 5, rtol=1e-2)
+        np.testing.assert_allclose(I_C2_1, original_capacity / 2, rtol=1e-2)
+        np.testing.assert_allclose(I_1C_1, original_capacity, rtol=1e-2)
+
+        # Update capacity
+        new_capacity = 0.9 * original_capacity
+        sim._parameter_values.update({"Nominal cell capacity [A.h]": new_capacity})
+
+        # Second solve with updated capacity
+        sol2 = sim.solve(calc_esoh=False)
+
+        # Check that C-rates now correspond to updated currents
+        I_C5_2 = np.abs(sol2.cycles[0].steps[0]["Current [A]"].data).mean()
+        I_C2_2 = np.abs(sol2.cycles[0].steps[1]["Current [A]"].data).mean()
+        I_1C_2 = np.abs(sol2.cycles[0].steps[2]["Current [A]"].data).mean()
+
+        np.testing.assert_allclose(I_C5_2, new_capacity / 5, rtol=1e-2)
+        np.testing.assert_allclose(I_C2_2, new_capacity / 2, rtol=1e-2)
+        np.testing.assert_allclose(I_1C_2, new_capacity, rtol=1e-2)
+
+        # Verify all currents scaled proportionally
+        np.testing.assert_allclose(I_C5_2 / I_C5_1, 0.9, rtol=1e-2)
+        np.testing.assert_allclose(I_C2_2 / I_C2_1, 0.9, rtol=1e-2)
+        np.testing.assert_allclose(I_1C_2 / I_1C_1, 0.9, rtol=1e-2)
+
+    def test_simulation_multiple_cycles_with_capacity_change(self):
+        """Test capacity changes across multiple experiment cycles"""
+        model = pybamm.lithium_ion.SPM()
+        experiment = pybamm.Experiment(
+            [("Discharge at 1C for 5 minutes", "Charge at 1C for 5 minutes")] * 2
+        )
+        param = pybamm.ParameterValues("Chen2020")
+        sim = pybamm.Simulation(model, experiment=experiment, parameter_values=param)
+
+        # First solve
+        sol1 = sim.solve(calc_esoh=False)
+        original_capacity = param["Nominal cell capacity [A.h]"]
+
+        # Get discharge currents for both cycles
+        I_discharge_cycle1 = np.abs(sol1.cycles[0].steps[0]["Current [A]"].data).mean()
+        I_discharge_cycle2 = np.abs(sol1.cycles[1].steps[0]["Current [A]"].data).mean()
+
+        # Both cycles should use the same capacity initially
+        np.testing.assert_allclose(I_discharge_cycle1, original_capacity, rtol=1e-2)
+        np.testing.assert_allclose(I_discharge_cycle2, original_capacity, rtol=1e-2)
+
+        # Update capacity between cycles
+        new_capacity = 0.85 * original_capacity
+        sim._parameter_values.update({"Nominal cell capacity [A.h]": new_capacity})
+
+        # Solve again
+        sol2 = sim.solve(calc_esoh=False)
+
+        # All cycles in the new solution should use updated capacity
+        I_discharge_cycle1_new = np.abs(
+            sol2.cycles[0].steps[0]["Current [A]"].data
+        ).mean()
+        I_discharge_cycle2_new = np.abs(
+            sol2.cycles[1].steps[0]["Current [A]"].data
+        ).mean()
+
+        np.testing.assert_allclose(I_discharge_cycle1_new, new_capacity, rtol=1e-2)
+        np.testing.assert_allclose(I_discharge_cycle2_new, new_capacity, rtol=1e-2)
+
+    def test_simulation_logging_with_capacity_change(self, caplog):
+        """Test that capacity changes are logged appropriately"""
+        model = pybamm.lithium_ion.SPM()
+        experiment = pybamm.Experiment([("Discharge at 1C for 10 minutes",)])
+        param = pybamm.ParameterValues("Chen2020")
+        sim = pybamm.Simulation(model, experiment=experiment, parameter_values=param)
+
+        # First solve
+        sim.solve(calc_esoh=False)
+        original_capacity = param["Nominal cell capacity [A.h]"]
+
+        # Update capacity
+        new_capacity = 0.75 * original_capacity
+        sim._parameter_values.update({"Nominal cell capacity [A.h]": new_capacity})
+
+        # Set logging level to capture INFO messages
+        original_log_level = pybamm.logger.level
+        pybamm.set_logging_level("INFO")
+
+        try:
+            # Second solve should log capacity change
+            with caplog.at_level(logging.INFO, logger="pybamm.logger"):
+                sim.solve(calc_esoh=False)
+
+            # Check that a log message about capacity change was recorded
+            log_messages = [record.message for record in caplog.records]
+            capacity_change_logged = any(
+                "Nominal capacity changed" in msg for msg in log_messages
+            )
+            assert capacity_change_logged
+        finally:
+            # Restore original logging level
+            pybamm.logger.setLevel(original_log_level)