Add time to experiment termination conditions (pybamm-team#4073)

* add time termination lines

* fix bug

* add test

* add more test coverage

* update changelog

---------

Co-authored-by: Agriya Khetarpal <[email protected]>
Co-authored-by: Eric G. Kratz <[email protected]>

CHANGELOG.md

@@ -18,6 +18,7 @@
 - Add support for BPX version 0.4.0 which allows for blended electrodes and user-defined parameters in BPX([#3414](https://github.com/pybamm-team/PyBaMM/pull/3414))
 - Added `by_submodel` feature in `print_parameter_info` method to allow users to print parameters and types of submodels in a tabular and readable format ([#3628](https://github.com/pybamm-team/PyBaMM/pull/3628))
 - Added `WyciskOpenCircuitPotential` for differential capacity hysteresis state open-circuit potential submodel ([#3593](https://github.com/pybamm-team/PyBaMM/pull/3593))
+- Added `time` as an option for `Experiment.termination`. Now allows solving up to a user-specified time while also allowing different cycles and steps in an experiment to be handled normally. ([#4073](https://github.com/pybamm-team/PyBaMM/pull/4073))
 
 ## Bug Fixes
 

pybamm/callbacks.py

@@ -175,7 +175,19 @@ def on_step_start(self, logs):
         )
 
     def on_step_end(self, logs):
-        pass
+        time_stop = logs["stopping conditions"]["time"]
+        if time_stop is not None:
+            time_now = logs["experiment time"]
+            if time_now < time_stop[0]:
+                self.logger.notice(
+                    f"Time is now {time_now:.3f} s, "
+                    f"will stop at {time_stop[0]:.3f} s."
+                )
+            else:
+                self.logger.notice(
+                    f"Stopping experiment since time ({time_now:.3f} s) "
+                    f"has reached stopping time ({time_stop[0]:.3f} s)."
+                )
 
     def on_cycle_end(self, logs):
         cap_stop = logs["stopping conditions"]["capacity"]

pybamm/experiment/experiment.py

@@ -169,6 +169,15 @@ def read_termination(termination):
             elif term.endswith("V"):
                 end_discharge_V = term.split("V")[0]
                 termination_dict["voltage"] = (float(end_discharge_V), "V")
+            elif term.endswith("s"):
+                end_time_s = term.split("s")[0]
+                termination_dict["time"] = (float(end_time_s), "s")
+            elif term.endswith("min"):
+                end_time_s = term.split("min")[0]
+                termination_dict["time"] = (float(end_time_s) * 60, "s")
+            elif term.endswith("h"):
+                end_time_s = term.split("h")[0]
+                termination_dict["time"] = (float(end_time_s) * 3600, "s")
             else:
                 raise ValueError(
                     "Only capacity or voltage can be provided as a termination reason, "

pybamm/simulation.py

@@ -555,7 +555,8 @@ def solve(
             current_solution = starting_solution or pybamm.EmptySolution()
 
             voltage_stop = self.experiment.termination.get("voltage")
-            logs["stopping conditions"] = {"voltage": voltage_stop}
+            time_stop = self.experiment.termination.get("time")
+            logs["stopping conditions"] = {"voltage": voltage_stop, "time": time_stop}
 
             idx = 0
             num_cycles = len(self.experiment.cycle_lengths)
@@ -667,6 +668,11 @@ def solve(
                         )
                     else:
                         dt = step.duration
+
+                    # if dt + starttime is larger than time_stop, set dt to time_stop - starttime
+                    if time_stop is not None:
+                        dt = min(dt, time_stop[0] - start_time)
+
                     step_str = str(step)
                     model = self.steps_to_built_models[step.basic_repr()]
                     solver = self.steps_to_built_solvers[step.basic_repr()]
@@ -757,6 +763,7 @@ def solve(
 
                     current_solution = cycle_solution
 
+                    logs["experiment time"] = cycle_solution.t[-1]
                     callbacks.on_step_end(logs)
 
                     logs["termination"] = step_solution.termination
@@ -770,6 +777,11 @@ def solve(
                         feasible = False
                         break
 
+                    if time_stop is not None:
+                        max_time = cycle_solution.t[-1]
+                        if max_time >= time_stop[0]:
+                            break
+
                     # Increment index for next iteration
                     idx += 1
 

tests/unit/test_experiments/test_simulation_with_experiment.py

@@ -349,6 +349,60 @@ def test_run_experiment_termination_voltage(self):
         np.testing.assert_array_less(np.min(sol.cycles[1]["Voltage [V]"].data), 4)
         self.assertEqual(len(sol.cycles), 2)
 
+    def test_run_experiment_termination_time_min(self):
+        experiment = pybamm.Experiment(
+            [
+                ("Discharge at 0.5C for 10 minutes", "Rest for 10 minutes"),
+            ]
+            * 5,
+            termination="25 min",
+        )
+        model = pybamm.lithium_ion.SPM()
+        param = pybamm.ParameterValues("Chen2020")
+        sim = pybamm.Simulation(model, experiment=experiment, parameter_values=param)
+        # Test with calc_esoh=False here
+        sol = sim.solve(calc_esoh=False)
+        # Only two cycles should be completed, only 2nd cycle should go below 4V
+        np.testing.assert_array_less(np.max(sol.cycles[0]["Time [s]"].data), 1500)
+        np.testing.assert_array_equal(np.max(sol.cycles[1]["Time [s]"].data), 1500)
+        self.assertEqual(len(sol.cycles), 2)
+
+    def test_run_experiment_termination_time_s(self):
+        experiment = pybamm.Experiment(
+            [
+                ("Discharge at 0.5C for 10 minutes", "Rest for 10 minutes"),
+            ]
+            * 5,
+            termination="1500 s",
+        )
+        model = pybamm.lithium_ion.SPM()
+        param = pybamm.ParameterValues("Chen2020")
+        sim = pybamm.Simulation(model, experiment=experiment, parameter_values=param)
+        # Test with calc_esoh=False here
+        sol = sim.solve(calc_esoh=False)
+        # Only two cycles should be completed, only 2nd cycle should go below 4V
+        np.testing.assert_array_less(np.max(sol.cycles[0]["Time [s]"].data), 1500)
+        np.testing.assert_array_equal(np.max(sol.cycles[1]["Time [s]"].data), 1500)
+        self.assertEqual(len(sol.cycles), 2)
+
+    def test_run_experiment_termination_time_h(self):
+        experiment = pybamm.Experiment(
+            [
+                ("Discharge at 0.5C for 10 minutes", "Rest for 10 minutes"),
+            ]
+            * 5,
+            termination="0.5 h",
+        )
+        model = pybamm.lithium_ion.SPM()
+        param = pybamm.ParameterValues("Chen2020")
+        sim = pybamm.Simulation(model, experiment=experiment, parameter_values=param)
+        # Test with calc_esoh=False here
+        sol = sim.solve(calc_esoh=False)
+        # Only two cycles should be completed, only 2nd cycle should go below 4V
+        np.testing.assert_array_less(np.max(sol.cycles[0]["Time [s]"].data), 1800)
+        np.testing.assert_array_equal(np.max(sol.cycles[1]["Time [s]"].data), 1800)
+        self.assertEqual(len(sol.cycles), 2)
+
     def test_save_at_cycles(self):
         experiment = pybamm.Experiment(
             [