add more options in BatchStudy

Author: priyanshuone6

docs/source/models/base_models/base_battery_model.rst

@@ -4,5 +4,5 @@ Base Battery Model
 .. autoclass:: pybamm.BaseBatteryModel
     :members:
 
-.. autoclass:: pybamm.models.full_battery_models.base_battery_model.Options
+.. autoclass:: pybamm.Options
     :members:

pybamm/__init__.py

@@ -120,7 +120,7 @@ def version(formatted=False):
 from .models.event import EventType
 
 # Battery models
-from .models.full_battery_models.base_battery_model import BaseBatteryModel
+from .models.full_battery_models.base_battery_model import BaseBatteryModel, Options
 from .models.full_battery_models import lead_acid
 from .models.full_battery_models import lithium_ion
 

pybamm/batch_study.py

@@ -13,11 +13,30 @@ class BatchStudy:
     ----------
     models : dict
         A dictionary of models to be simulated
-    solvers : dict (optional)
-        A dictionary of solvers to use to solve the model. Default is None
     experiments : dict (optional)
         A dictionary of experimental conditions under which to solve the model.
         Default is None
+    geometries : dict (optional)
+        A dictionary of geometries upon which to solve the model
+    parameter_values : dict (optional)
+        A dictionary of parameters and their corresponding numerical values.
+        Default is None
+    submesh_types : dict (optional)
+        A dictionary of the types of submesh to use on each subdomain.
+        Default is None
+    var_pts : dict (optional)
+        A dictionary of the number of points used by each spatial variable.
+        Default is None
+    spatial_methods : dict (optional)
+        A dictionary of the types of spatial method to use on each domain.
+        Default is None
+    solvers : dict (optional)
+        A dictionary of solvers to use to solve the model. Default is None
+    output_variables : dict (optional)
+        A dictionary of variables to plot automatically. Default is None
+    C_rates : dict (optional)
+        A dictionary of C-rates at which you would like to run a constant current
+        (dis)charge. Default is None
     repeats : int (optional)
         The number of times `solve` should be called. Default is 1
     permutations : bool (optional)
@@ -27,64 +46,131 @@ class BatchStudy:
         Default is False
     """
 
+    INPUT_LIST = [
+        "experiments",
+        "geometries",
+        "parameter_values",
+        "submesh_types",
+        "var_pts",
+        "spatial_methods",
+        "solvers",
+        "output_variables",
+        "C_rates",
+    ]
+
     def __init__(
-        self, models, solvers=None, experiments=None, repeats=1, permutations=False
+        self,
+        models,
+        experiments=None,
+        geometries=None,
+        parameter_values=None,
+        submesh_types=None,
+        var_pts=None,
+        spatial_methods=None,
+        solvers=None,
+        output_variables=None,
+        C_rates=None,
+        repeats=1,
+        permutations=False,
     ):
         self.models = models
-        self.solvers = solvers
         self.experiments = experiments
+        self.geometries = geometries
+        self.parameter_values = parameter_values
+        self.submesh_types = submesh_types
+        self.var_pts = var_pts
+        self.spatial_methods = spatial_methods
+        self.solvers = solvers
+        self.output_variables = output_variables
+        self.C_rates = C_rates
         self.repeats = repeats
         self.permutations = permutations
 
         if not self.permutations:
-            if self.solvers and (len(self.models) != len(self.solvers)):
-                raise ValueError(
-                    f"Either provide no solvers or an equal number of solvers as the"
-                    f" models ({len(self.models)} models given) if permutations=False"
-                )
-            elif self.experiments and (len(self.models) != len(self.experiments)):
-                raise ValueError(
-                    f"Either provide no experiments or an equal number of experiments"
-                    f" as the models ({len(self.models)} models given)"
-                    f" if permutations=False"
-                )
+            for name in self.INPUT_LIST:
+                if getattr(self, name) and (
+                    len(self.models) != len(getattr(self, name))
+                ):
+                    raise ValueError(
+                        f"Either provide no {name} or an equal number of {name}"
+                        f" as the models ({len(self.models)} models given)"
+                        f" if permutations=False"
+                    )
 
-    def solve(self, t_eval=None):
+    def solve(
+        self,
+        t_eval=None,
+        solver=None,
+        check_model=True,
+        save_at_cycles=None,
+        starting_solution=None,
+        **kwargs,
+    ):
+        """
+        For more information on the parameters used in the solve,
+        See :meth:`pybamm.Simulation.solve`
+        """
         self.sims = []
         iter_func = product if self.permutations else zip
 
-        # Instantiate values for solvers based on the value of self.permutations
-        if self.solvers:
-            solver_values = self.solvers.values()
-        elif self.permutations:
-            solver_values = [None]
-        else:
-            solver_values = [None] * len(self.models)
+        # Instantiate items in INPUT_LIST based on the value of self.permutations
+        inp_values = []
+        for name in self.INPUT_LIST:
+            if getattr(self, name):
+                inp_value = getattr(self, name).values()
+            elif self.permutations:
+                inp_value = [None]
+            else:
+                inp_value = [None] * len(self.models)
+            inp_values.append(inp_value)
 
-        # Instantiate values for experminents based on the value of self.permutations
-        if self.experiments:
-            experiment_values = self.experiments.values()
-        elif self.permutations:
-            experiment_values = [None]
-        else:
-            experiment_values = [None] * len(self.models)
-
-        for model, solver, experiment in iter_func(
-            self.models.values(), solver_values, experiment_values
-        ):
-            sim = pybamm.Simulation(model, solver=solver, experiment=experiment)
-            # repeat to get average solve time and integration time
+        for (
+            model,
+            experiment,
+            geometry,
+            parameter_value,
+            submesh_type,
+            var_pt,
+            spatial_method,
+            solver,
+            output_variable,
+            C_rate,
+        ) in iter_func(self.models.values(), *inp_values):
+            sim = pybamm.Simulation(
+                model,
+                experiment=experiment,
+                geometry=geometry,
+                parameter_values=parameter_value,
+                submesh_types=submesh_type,
+                var_pts=var_pt,
+                spatial_methods=spatial_method,
+                solver=solver,
+                output_variables=output_variable,
+                C_rate=C_rate,
+            )
+            # Repeat to get average solve time and integration time
             solve_time = 0
             integration_time = 0
             for _ in range(self.repeats):
-                sol = sim.solve(t_eval)
+                sol = sim.solve(
+                    t_eval,
+                    solver,
+                    check_model,
+                    save_at_cycles,
+                    starting_solution,
+                    **kwargs,
+                )
                 solve_time += sol.solve_time
                 integration_time += sol.integration_time
             sim.solution.solve_time = solve_time / self.repeats
             sim.solution.integration_time = integration_time / self.repeats
             self.sims.append(sim)
 
     def plot(self, output_variables=None, **kwargs):
+        """
+        For more information on the parameters used in the plot,
+        See :meth:`pybamm.Simulation.plot`
+        """
         self.quick_plot = pybamm.dynamic_plot(
             self.sims, output_variables=output_variables, **kwargs
         )

pybamm/models/full_battery_models/base_battery_model.py

@@ -310,13 +310,19 @@ def __init__(self, extra_options):
         super().__init__(options.items())
 
     def print_options(self):
+        """
+        Print the possible options with the ones currently selected
+        """
         for key, value in self.items():
             if key in self.possible_options.keys():
                 print(f"{key!r}: {value!r} (possible: {self.possible_options[key]!r})")
             else:
                 print(f"{key!r}: {value!r}")
 
     def print_detailed_options(self):
+        """
+        Print the docstring for Options
+        """
         print(self.__doc__)