I2304 multiple models to solver

CHANGELOG.md

@@ -17,6 +17,7 @@
 - Renamed entry point for parameter sets to `pybamm_parameter_sets` ([#2475](https://github.com/pybamm-team/PyBaMM/pull/2475))
 - Removed code for generating `ModelingToolkit` problems ([#2432](https://github.com/pybamm-team/PyBaMM/pull/2432))
 - Removed `FirstOrder` and `Composite` lead-acid models, and some submodels specific to those models ([#2431](https://github.com/pybamm-team/PyBaMM/pull/2431))
+- Trying to use a solver to solve multiple models results in a RuntimeError exception ([#2481](https://github.com/pybamm-team/PyBaMM/pull/2481))
 
 # [v22.10.post1](https://github.com/pybamm-team/PyBaMM/tree/v22.10.post1) - 2022-10-31
 

pybamm/simulation.py

@@ -106,14 +106,15 @@ def __init__(
         self.submesh_types = submesh_types or self.model.default_submesh_types
         self.var_pts = var_pts or self.model.default_var_pts
         self.spatial_methods = spatial_methods or self.model.default_spatial_methods
-        self.solver = solver or self.model.default_solver
+        self._solver = solver or self.model.default_solver
         self.output_variables = output_variables
 
         # Initialize empty built states
         self._model_with_set_params = None
         self._built_model = None
         self._built_initial_soc = None
         self.op_conds_to_built_models = None
+        self.op_conds_to_built_solvers = None
         self._mesh = None
         self._disc = None
         self._solution = None
@@ -383,6 +384,7 @@ def set_initial_soc(self, initial_soc):
             self._model_with_set_params = None
             self._built_model = None
             self.op_conds_to_built_models = None
+            self.op_conds_to_built_solvers = None
 
         c_n_init = self.parameter_values[
             "Initial concentration in negative electrode [mol.m-3]"
@@ -439,11 +441,13 @@ def build(self, check_model=True, initial_soc=None):
             self._built_model = self._disc.process_model(
                 self._model_with_set_params, inplace=False, check_model=check_model
             )
+            # rebuilt model so clear solver setup
+            self._solver.models_set_up = {}
 
     def build_for_experiment(self, check_model=True, initial_soc=None):
         """
         Similar to :meth:`Simulation.build`, but for the case of simulating an
-        experiment, where there may be several models to build
+        experiment, where there may be several models and solvers to build.
         """
         if initial_soc is not None:
             self.set_initial_soc(initial_soc)
@@ -461,12 +465,15 @@ def build_for_experiment(self, check_model=True, initial_soc=None):
             self._disc = pybamm.Discretisation(self._mesh, self._spatial_methods)
             # Process all the different models
             self.op_conds_to_built_models = {}
+            self.op_conds_to_built_solvers = {}
             for op_cond, model_with_set_params in self.op_string_to_model.items():
                 # It's ok to modify the model with set parameters in place as it's
                 # not returned anywhere
                 built_model = self._disc.process_model(
                     model_with_set_params, inplace=True, check_model=check_model
                 )
+                solver = self.solver.copy()
+                self.op_conds_to_built_solvers[op_cond] = solver
                 self.op_conds_to_built_models[op_cond] = built_model
 
     def solve(
@@ -707,6 +714,7 @@ def solve(
                     dt = op_conds["time"]
                     op_conds_str = op_conds["string"]
                     model = self.op_conds_to_built_models[op_conds_str]
+                    solver = self.op_conds_to_built_solvers[op_conds_str]
 
                     logs["step number"] = (step_num, cycle_length)
                     logs["step operating conditions"] = op_conds_str

pybamm/solvers/base_solver.py

@@ -666,7 +666,8 @@ def solve(
         ----------
         model : :class:`pybamm.BaseModel`
             The model whose solution to calculate. Must have attributes rhs and
-            initial_conditions
+            initial_conditions. All calls to solve must pass in the same model or
+            an error is raised
         t_eval : numeric type
             The times (in seconds) at which to compute the solution
         external_variables : dict
@@ -698,6 +699,8 @@ def solve(
         :class:`pybamm.ModelError`
             If an empty model is passed (`model.rhs = {}` and `model.algebraic={}` and
             `model.variables = {}`)
+        :class:`RuntimeError`
+            If multiple calls to `solve` pass in different models
 
         """
         pybamm.logger.info("Start solving {} with {}".format(model.name, self.name))
@@ -781,6 +784,13 @@ def solve(
         # Set up (if not done already)
         timer = pybamm.Timer()
         if model not in self.models_set_up:
+            if len(self.models_set_up) > 0:
+                existing_model = next(iter(self.models_set_up))
+                raise RuntimeError(
+                    "This solver has already been initialised for model "
+                    f'"{existing_model.name}". Please create a separate '
+                    "solver for this model"
+                )
             # It is assumed that when len(inputs_list) > 1, model set
             # up (initial condition, time-scale and length-scale) does
             # not depend on input parameters. Thefore only `ext_and_inputs[0]`
@@ -1138,29 +1148,36 @@ def step(
         # Set up external variables and inputs
         ext_and_inputs = self._set_up_ext_and_inputs(model, external_variables, inputs)
 
-        if (
-            isinstance(old_solution, pybamm.EmptySolution)
-            and old_solution.termination is None
-        ):
-            # Run set up on first step
-            pybamm.logger.verbose(
-                "Start stepping {} with {}".format(model.name, self.name)
-            )
+        t = old_solution.t[-1]
 
+        first_step_this_model = False
+        if model not in self.models_set_up:
+            first_step_this_model = True
+            if len(self.models_set_up) > 0:
+                existing_model = next(iter(self.models_set_up))
+                raise RuntimeError(
+                    "This solver has already been initialised for model "
+                    f'"{existing_model.name}". Please create a separate '
+                    "solver for this model"
+                )
             self.set_up(model, ext_and_inputs)
             self.models_set_up.update(
                 {model: {"initial conditions": model.concatenated_initial_conditions}}
             )
-        elif model not in self.models_set_up:
-            # Run set up if the model has changed
 
-            self.set_up(model, ext_and_inputs)
-            self.models_set_up.update(
-                {model: {"initial conditions": model.concatenated_initial_conditions}}
+        if (
+            isinstance(old_solution, pybamm.EmptySolution)
+            and old_solution.termination is None
+        ):
+            pybamm.logger.verbose(
+                "Start stepping {} with {}".format(model.name, self.name)
             )
-        t = old_solution.t[-1]
 
-        if not isinstance(old_solution, pybamm.EmptySolution):
+        if isinstance(old_solution, pybamm.EmptySolution):
+            if not first_step_this_model:
+                # reset y0 to original initial conditions
+                self.set_up(model, ext_and_inputs, ics_only=True)
+        else:
             if old_solution.all_models[-1] == model:
                 # initialize with old solution
                 model.y0 = old_solution.all_ys[-1][:, -1]
@@ -1171,6 +1188,7 @@ def step(
                 model.y0 = concatenated_initial_conditions.evaluate(
                     0, inputs=ext_and_inputs
                 )
+
         set_up_time = timer.time()
 
         # (Re-)calculate consistent initial conditions

tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py

@@ -49,7 +49,7 @@ def get_max_error(current):
             solution_loqs = solver.solve(
                 leading_order_model, t_eval, inputs={"Current function [A]": current}
             )
-            solution_full = solver.solve(
+            solution_full = solver.copy().solve(
                 full_model, t_eval, inputs={"Current function [A]": current}
             )
 

tests/integration/test_solvers/test_idaklu.py

@@ -83,7 +83,6 @@ def test_set_tol_by_variable(self):
 
     def test_changing_grid(self):
         model = pybamm.lithium_ion.SPM()
-        solver = pybamm.IDAKLUSolver()
 
         # load parameter values and geometry
         geometry = model.default_geometry
@@ -103,6 +102,7 @@ def test_changing_grid(self):
             mesh = pybamm.Mesh(geometry, model.default_submesh_types, var_pts)
             disc = pybamm.Discretisation(mesh, model.default_spatial_methods)
             model_disc = disc.process_model(model, inplace=False)
+            solver = pybamm.IDAKLUSolver()
 
             # solve
             solver.solve(model_disc, t_eval)

tests/unit/test_experiments/test_simulation_with_experiment.py

@@ -171,6 +171,39 @@ def test_run_experiment_cccv_ode(self):
         )
         self.assertEqual(solutions[1].termination, "final time")
 
+    @unittest.skipIf(not pybamm.have_idaklu(), "idaklu solver is not installed")
+    def test_run_experiment_cccv_solvers(self):
+        experiment_2step = pybamm.Experiment(
+            [
+                (
+                    "Discharge at C/20 for 1 hour",
+                    "Charge at 1 A until 4.1 V",
+                    "Hold at 4.1 V until C/2",
+                    "Discharge at 2 W for 1 hour",
+                ),
+            ]
+            * 2,
+        )
+
+        solutions = []
+        for solver in [pybamm.CasadiSolver(), pybamm.IDAKLUSolver()]:
+            model = pybamm.lithium_ion.SPM()
+            sim = pybamm.Simulation(model, experiment=experiment_2step, solver=solver)
+            solution = sim.solve()
+            solutions.append(solution)
+
+        np.testing.assert_array_almost_equal(
+            solutions[0]["Terminal voltage [V]"].data,
+            solutions[1]["Terminal voltage [V]"].data,
+            decimal=1,
+        )
+        np.testing.assert_array_almost_equal(
+            solutions[0]["Current [A]"].data,
+            solutions[1]["Current [A]"].data,
+            decimal=0,
+        )
+        self.assertEqual(solutions[1].termination, "final time")
+
     def test_run_experiment_drive_cycle(self):
         drive_cycle = np.array([np.arange(10), np.arange(10)]).T
         experiment = pybamm.Experiment(

tests/unit/test_plotting/test_quick_plot.py

@@ -475,14 +475,15 @@ def test_model_with_inputs(self):
         timescale = parameter_values.evaluate(pybamm.LithiumIonParameters().timescale)
         model = pybamm.lithium_ion.SPMe({"timescale": timescale})
         parameter_values.update({"Electrode height [m]": "[input]"})
-        solver = pybamm.CasadiSolver(mode="safe")
+        solver1 = pybamm.CasadiSolver(mode="safe")
         sim1 = pybamm.Simulation(
-            model, parameter_values=parameter_values, solver=solver
+            model, parameter_values=parameter_values, solver=solver1
         )
         inputs1 = {"Electrode height [m]": 1.00}
         sol1 = sim1.solve(t_eval=np.linspace(0, 1000, 101), inputs=inputs1)
+        solver2 = pybamm.CasadiSolver(mode="safe")
         sim2 = pybamm.Simulation(
-            model, parameter_values=parameter_values, solver=solver
+            model, parameter_values=parameter_values, solver=solver2
         )
         inputs2 = {"Electrode height [m]": 2.00}
         sol2 = sim2.solve(t_eval=np.linspace(0, 1000, 101), inputs=inputs2)

tests/unit/test_solvers/test_base_solver.py

@@ -333,6 +333,21 @@ def test_extrapolation_warnings(self):
         with self.assertWarns(pybamm.SolverWarning):
             solver.solve(model, t_eval=[0, 1])
 
+    def test_multiple_models_error(self):
+        model = pybamm.BaseModel()
+        v = pybamm.Variable("v")
+        model.rhs = {v: -1}
+        model.initial_conditions = {v: 1}
+        model2 = pybamm.BaseModel()
+        v2 = pybamm.Variable("v")
+        model2.rhs = {v2: -1}
+        model2.initial_conditions = {v2: 1}
+
+        solver = pybamm.ScipySolver()
+        solver.solve(model, t_eval=[0, 1])
+        with self.assertRaisesRegex(RuntimeError, "already been initialised"):
+            solver.solve(model2, t_eval=[0, 1])
+
     @unittest.skipIf(not pybamm.have_idaklu(), "idaklu solver is not installed")
     def test_sensitivities(self):
         def exact_diff_a(y, a, b):

tests/unit/test_solvers/test_casadi_solver.py

@@ -150,6 +150,9 @@ def test_model_solver_failure(self):
             solution = solver.solve(model_disc, t_eval)
         self.assertLess(solution.t[-1], 20)
         # Solve with failure at t=0
+        solver = pybamm.CasadiSolver(
+            dt_max=1e-3, return_solution_if_failed_early=True, max_step_decrease_count=2
+        )
         model.initial_conditions = {var: 0, var2: 1}
         model_disc = disc.process_model(model, inplace=False)
         t_eval = np.linspace(0, 20, 100)

tests/unit/test_solvers/test_scipy_solver.py

@@ -221,12 +221,9 @@ def test_step_different_model(self):
         np.testing.assert_array_equal(step_sol1.t, [0, dt])
         np.testing.assert_array_almost_equal(step_sol1.y[0], np.exp(0.1 * step_sol1.t))
 
-        # Step again, the model has changed
-        step_sol2 = solver.step(step_sol1, model2, dt)
-        np.testing.assert_array_equal(step_sol2.t, [0, dt, 2 * dt])
-        np.testing.assert_array_almost_equal(
-            step_sol2.all_ys[0][0], np.exp(0.1 * step_sol1.t)
-        )
+        # Step again, the model has changed so this raises an error
+        with self.assertRaisesRegex(RuntimeError, "already been initialised"):
+            solver.step(step_sol1, model2, dt)
 
     def test_model_solver_with_inputs(self):
         # Create model
@@ -496,6 +493,7 @@ def test_model_solver_manually_update_initial_conditions(self):
         model.concatenated_initial_conditions = pybamm.NumpyConcatenation(
             pybamm.Vector([[2]])
         )
+        solver = pybamm.ScipySolver(rtol=1e-8, atol=1e-8)
         solution = solver.solve(model, t_eval)
         np.testing.assert_array_almost_equal(
             solution.y[0], 2 * np.exp(-solution.t), decimal=5