#492 added voltage getters to parameter values

Author: Scottmar93

pybamm/discretisations/discretisation.py

@@ -431,7 +431,11 @@ def process_dict(self, var_eqn_dict):
 
             new_var_eqn_dict[eqn_key] = self.process_symbol(eqn)
 
-            new_var_eqn_dict[eqn_key].test_shape()
+            try: 
+                new_var_eqn_dict[eqn_key].test_shape()
+            except: 
+                new_var_eqn_dict[eqn_key].test_shape()
+                
 
         return new_var_eqn_dict
 

pybamm/models/full_battery_models/base_battery_model.py

@@ -34,9 +34,13 @@ def default_parameter_values(self):
             ),
             {
                 "Typical current [A]": 1,
+                "Typical voltage [V]": 3.5,
                 "Current function": pybamm.GetConstantCurrent(
                     pybamm.standard_parameters_lithium_ion.I_typ
                 ),
+                "Voltage function": pybamm.GetConstantVoltage(
+                    pybamm.standard_parameters_lithium_ion.V_typ
+                ),
                 "Electrolyte diffusivity": os.path.join(
                     input_path, "electrolyte_diffusivity_Capiglia1999.py"
                 ),

pybamm/models/full_battery_models/lithium_ion/dfn.py

@@ -19,9 +19,9 @@ def __init__(self, options=None, name="Doyle-Fuller-Newman model"):
         self.set_current_collector_submodel()
         self.set_porosity_submodel()
         self.set_convection_submodel()
+        self.set_solid_submodel()
         self.set_interfacial_submodel()
         self.set_particle_submodel()
-        self.set_solid_submodel()
         self.set_electrolyte_submodel()
         self.set_thermal_submodel()
 

pybamm/models/submodels/current_collector/homogeneous_current_collector.py

@@ -18,15 +18,34 @@ class Uniform(BaseModel):
     **Extends:** :class:`pybamm.current_collector.BaseModel`
     """
 
-    def __init__(self, param):
+    def __init__(self, param, options=None):
         super().__init__(param)
+        if options:
+            self.options = options
+        else:
+            self.options = {"problem type": "potentiostatic"}
 
     def get_fundamental_variables(self):
+        if self.options["problem type"] == "potentiostatic":
+            variables = self._get_potentiostatic_fundamental_variables()
+        elif self.options["problem type"] == "galvanostatic":
+            variables = self._get_galvanostatic_fundamental_variables()
+        else:
+            raise pybamm.OptionError
 
-        i_cc = pybamm.Scalar(0)
+        return variables
 
+    def _get_galvanostatic_fundamental_variables(self):
+        i_cc = pybamm.Scalar(0)
         i_boundary_cc = self.param.current_with_time
-
         variables = self._get_standard_current_variables(i_cc, i_boundary_cc)
+        return variables
+
+    def _get_potentiostatic_fundamental_variables(self):
 
+        phi_s_cn = pybamm.Scalar(0)
+        phi_s_cp = self.param.voltage_with_time
+
+        variables = self._get_standard_potential_variables(phi_s_cn, phi_s_cp)
         return variables
+

pybamm/models/submodels/electrode/ohm/full_ohm.py

@@ -58,6 +58,17 @@ def get_coupled_variables(self, variables):
         if self.domain == "Positive":
             variables.update(self._get_standard_whole_cell_current_variables(variables))
 
+        if (
+            self.domain == "Positive"
+            and self.options["problem type"] == "potentiostatic"
+        ):
+            variables.update(self._get_current_collector_current_density(i_s))
+
+        return variables
+
+    def _get_current_collector_current_density(self, i_s):
+        i_boundary_cc = pybamm.BoundaryValue(i_s, "right")
+        variables = {"Current collector current density": i_boundary_cc}
         return variables
 
     def set_algebraic(self, variables):
@@ -107,15 +118,15 @@ def _set_galvanostatic_boundary_conditions(self, variables):
     def _set_potentiostatic_boundary_conditions(self, variables):
 
         phi_s = variables[self.domain + " electrode potential"]
-        v = variables["Applied voltage"]
+        v_cc = variables["Local current collector potential difference"]
 
         if self.domain == "Negative":
             lbc = (pybamm.Scalar(0), "Dirichlet")
             rbc = (pybamm.Scalar(0), "Neumann")
 
         elif self.domain == "Positive":
             lbc = (pybamm.Scalar(0), "Neumann")
-            rbc = (v, "Dirichlet")
+            rbc = (v_cc, "Dirichlet")
 
         self.boundary_conditions[phi_s] = {"left": lbc, "right": rbc}
 

pybamm/parameters/parameter_values.py

@@ -239,17 +239,19 @@ def _process_symbol(self, symbol):
             new_children = [self.process_symbol(child) for child in symbol.children]
             function_name = self[symbol.name]
 
-            # if current setter, process any parameters that are symbols and
+            # if current/voltage setter, process any parameters that are symbols and
             # store the evaluated symbol in the parameters_eval dict
-            if isinstance(function_name, pybamm.GetCurrent):
+            if isinstance(function_name, (pybamm.GetCurrent, pybamm.GetVoltage)):
                 for param, sym in function_name.parameters.items():
                     if isinstance(sym, pybamm.Symbol):
                         new_sym = self.process_symbol(sym)
                         function_name.parameters[param] = new_sym
                         function_name.parameters_eval[param] = new_sym.evaluate()
                 # If loading data, need to update interpolant with
                 # evaluated parameters
-                if isinstance(function_name, pybamm.GetCurrentData):
+                if isinstance(
+                    function_name, (pybamm.GetCurrentData, pybamm.GetVoltageData)
+                ):
                     function_name.interpolate()
 
             if callable(function_name):