Add MultiFittingProblem class and example

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Features
 
+- [#364](https://github.com/pybop-team/PyBOP/pull/364) - Adds the MultiFittingProblem class and the multi_fitting example script.
 - [#413](https://github.com/pybop-team/PyBOP/pull/413) - Adds `DesignCost` functionality to `WeightedCost` class with additional tests.
 - [#357](https://github.com/pybop-team/PyBOP/pull/357) - Adds `Transformation()` class with `LogTransformation()`, `IdentityTransformation()`, and `ScaledTransformation()`, `ComposedTransformation()` implementations with corresponding examples and tests.
 - [#427](https://github.com/pybop-team/PyBOP/issues/427) - Adds the nbstripout pre-commit hook to remove unnecessary metadata from notebooks.

examples/scripts/multi_fitting.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+import pybop
+
+# Parameter set and model definition
+parameter_set = pybop.ParameterSet.pybamm("Chen2020")
+model = pybop.lithium_ion.SPM(parameter_set=parameter_set)
+
+# Generate a dataset
+sigma = 0.001
+experiment = pybop.Experiment([("Discharge at 0.5C for 2 minutes (4 second period)")])
+values = model.predict(experiment=experiment)
+dataset_1 = pybop.Dataset(
+    {
+        "Time [s]": values["Time [s]"].data,
+        "Current function [A]": values["Current [A]"].data,
+        "Voltage [V]": values["Voltage [V]"].data
+        + np.random.normal(0, sigma, len(values["Voltage [V]"].data)),
+    }
+)
+
+# Generate a second dataset
+experiment = pybop.Experiment([("Discharge at 1C for 2 minutes (4 second period)")])
+values = model.predict(experiment=experiment)
+dataset_2 = pybop.Dataset(
+    {
+        "Time [s]": values["Time [s]"].data,
+        "Current function [A]": values["Current [A]"].data,
+        "Voltage [V]": values["Voltage [V]"].data
+        + np.random.normal(0, sigma, len(values["Voltage [V]"].data)),
+    }
+)
+
+# Fitting parameters
+parameters = pybop.Parameters(
+    pybop.Parameter(
+        "Negative electrode active material volume fraction",
+        prior=pybop.Gaussian(0.68, 0.05),
+        true_value=parameter_set["Negative electrode active material volume fraction"],
+    ),
+    pybop.Parameter(
+        "Positive electrode active material volume fraction",
+        prior=pybop.Gaussian(0.58, 0.05),
+        true_value=parameter_set["Positive electrode active material volume fraction"],
+    ),
+)
+
+
+# Generate a problem for each dataset and combine into one
+problem_1 = pybop.FittingProblem(model, parameters, dataset_1)
+problem_2 = pybop.FittingProblem(model, parameters, dataset_2)
+problem = pybop.MultiFittingProblem(problem_1, problem_2)
+
+# Generate the cost function and optimisation class
+cost = pybop.SumSquaredError(problem)
+optim = pybop.IRPropMin(
+    cost,
+    # sigma0=0.011,
+    verbose=True,
+    max_iterations=12,
+)
+
+# Run optimisation
+x, final_cost = optim.run()
+print("Estimated parameters:", x)
+
+# Plot the timeseries output
+pybop.quick_plot(problem_1, problem_inputs=x, title="Optimised Comparison")
+pybop.quick_plot(problem_2, problem_inputs=x, title="Optimised Comparison")
+
+# Plot convergence
+pybop.plot_convergence(optim)
+
+# Plot the parameter traces
+pybop.plot_parameters(optim)
+
+# Plot the cost landscape with optimisation path
+bounds = np.array([[0.5, 0.8], [0.4, 0.7]])
+pybop.plot2d(optim, bounds=bounds, steps=15)

pybop/__init__.py

@@ -86,7 +86,7 @@
 # Problem class
 #
 from .problems.base_problem import BaseProblem
-from .problems.fitting_problem import FittingProblem
+from .problems.fitting_problem import FittingProblem, MultiFittingProblem
 from .problems.design_problem import DesignProblem
 
 #

pybop/models/base_model.py

@@ -64,6 +64,7 @@ def __init__(self, name="Base Model", parameter_set=None):
         else:  # a pybop parameter set
             self._parameter_set = pybamm.ParameterValues(parameter_set.params)
 
+        self.pybamm_model = None
         self.parameters = Parameters()
         self.dataset = None
         self.signal = None
@@ -506,8 +507,10 @@ def predict(
         """
         inputs = self.parameters.verify(inputs)
 
-        if not self.pybamm_model._built:
-            self.pybamm_model.build_model()
+        if self.pybamm_model is None:
+            raise ValueError("This sim method currently only supports PyBaMM models")
+        elif not self._unprocessed_model._built:
+            self._unprocessed_model.build_model()
 
         parameter_set = parameter_set or self._unprocessed_parameter_set
         if inputs is not None:
@@ -518,22 +521,17 @@ def predict(
             parameter_set=parameter_set,
             allow_infeasible_solutions=self.allow_infeasible_solutions,
         ):
-            if self._unprocessed_model is not None:
-                if experiment is None:
-                    return pybamm.Simulation(
-                        self._unprocessed_model,
-                        parameter_values=parameter_set,
-                    ).solve(t_eval=t_eval, initial_soc=init_soc)
-                else:
-                    return pybamm.Simulation(
-                        self._unprocessed_model,
-                        experiment=experiment,
-                        parameter_values=parameter_set,
-                    ).solve(initial_soc=init_soc)
+            if experiment is None:
+                return pybamm.Simulation(
+                    self._unprocessed_model,
+                    parameter_values=parameter_set,
+                ).solve(t_eval=t_eval, initial_soc=init_soc)
             else:
-                raise ValueError(
-                    "This sim method currently only supports PyBaMM models"
-                )
+                return pybamm.Simulation(
+                    self._unprocessed_model,
+                    experiment=experiment,
+                    parameter_values=parameter_set,
+                ).solve(initial_soc=init_soc)
 
         else:
             return [np.inf]
@@ -598,6 +596,36 @@ def copy(self):
         """
         return copy.copy(self)
 
+    def new_copy(self):
+        """
+        Return a new copy of the model, explicitly copying all the mutable attributes
+        to avoid issues with shared objects.
+
+        Returns
+        -------
+        BaseModel
+            A new copy of the model.
+        """
+        new_model = copy.copy(self)
+
+        # Reset the key attributes
+        new_model.param_check_counter = 0
+        if self.pybamm_model is not None:
+            new_model.parameter_set = self._unprocessed_parameter_set
+            new_model.pybamm_model = self._unprocessed_model.new_copy()
+            new_model.geometry = self.pybamm_model.default_geometry
+            new_model.submesh_types = self.pybamm_model.default_submesh_types
+            new_model.var_pts = self.pybamm_model.default_var_pts
+            new_model.spatial_methods = self.pybamm_model.default_spatial_methods
+            new_model.solver = self.pybamm_model.default_solver
+            new_model._model_with_set_params = None
+            new_model._built_model = None
+            new_model._built_initial_soc = None
+            new_model._mesh = None
+            new_model._disc = None
+
+        return new_model
+
     def cell_mass(self, parameter_set: ParameterSet = None):
         """
         Calculate the cell mass in kilograms.

pybop/models/empirical/base_ecm.py

@@ -46,22 +46,23 @@ def __init__(
         model_options = dict(build=False)
         for key, value in model_kwargs.items():
             model_options[key] = value
-        self.pybamm_model = pybamm_model(**model_options)
-        self._unprocessed_model = self.pybamm_model
+        pybamm_model = pybamm_model(**model_options)
 
         # Correct OCP if set to default
         if (
             parameter_set is not None
             and "Open-circuit voltage [V]" in parameter_set.keys()
         ):
-            default_ocp = self.pybamm_model.default_parameter_values[
+            default_ocp = pybamm_model.default_parameter_values[
                 "Open-circuit voltage [V]"
             ]
             if parameter_set["Open-circuit voltage [V]"] == "default":
                 print("Setting open-circuit voltage to default function")
                 parameter_set["Open-circuit voltage [V]"] = default_ocp
 
         super().__init__(name=name, parameter_set=parameter_set)
+        self.pybamm_model = pybamm_model
+        self._unprocessed_model = self.pybamm_model
 
         # Set parameters, using either the provided ones or the default
         self.default_parameter_values = self.pybamm_model.default_parameter_values

pybop/models/empirical/ecm.py

@@ -1,7 +1,6 @@
 from pybamm import equivalent_circuit as pybamm_equivalent_circuit
 
 from pybop.models.empirical.base_ecm import ECircuitModel
-from pybop.parameters.parameter import Inputs
 
 
 class Thevenin(ECircuitModel):
@@ -44,22 +43,3 @@ def __init__(
         super().__init__(
             pybamm_model=pybamm_equivalent_circuit.Thevenin, name=name, **model_kwargs
         )
-
-    def _check_params(self, inputs: Inputs = None, allow_infeasible_solutions=True):
-        """
-        Check the compatibility of the model parameters.
-
-        Parameters
-        ----------
-        inputs : Inputs
-            The input parameters for the simulation.
-        allow_infeasible_solutions : bool, optional
-            If True, infeasible parameter values will be allowed in the optimisation (default: True).
-
-        Returns
-        -------
-        bool
-            A boolean which signifies whether the parameters are compatible.
-
-        """
-        return True

pybop/problems/base_problem.py

@@ -53,7 +53,8 @@ def __init__(
             )
 
         self.parameters = parameters
-        self._model = model
+        if model is not None:
+            self._model = model
         self.check_model = check_model
         if isinstance(signal, str):
             signal = [signal]