Implement Integrated electrolyte conductivity

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 -   Added parameter set for an A123 LFP cell ([#1209](https://github.com/pybamm-team/PyBaMM/pull/1209))
 -   Added variables related to equivalent circuit models ([#1204](https://github.com/pybamm-team/PyBaMM/pull/1204))
+-   Added the `Integrated` electrolyte conductivity submodel ([#1188](https://github.com/pybamm-team/PyBaMM/pull/1188))
 -   Added an example script to check conservation of lithium ([#1186](https://github.com/pybamm-team/PyBaMM/pull/1186))
 -   Added `erf` and `erfc` functions ([#1184](https://github.com/pybamm-team/PyBaMM/pull/1184))
 

docs/source/models/submodels/electrolyte_conductivity/index.rst

@@ -7,5 +7,6 @@ Electrolyte Conductivity
     base_electrolyte_conductivity
     leading_order_conductivity
     composite_conductivity
+    integrated_conductivity
     full_conductivity
     surface_form/index

docs/source/models/submodels/electrolyte_conductivity/integrated_conductivity.rst

@@ -0,0 +1,5 @@
+Integrated Model
+================
+
+.. autoclass:: pybamm.electrolyte_conductivity.Integrated
+    :members:

pybamm/CITATIONS.txt

@@ -208,6 +208,16 @@ primaryClass={physics.app-ph},
   publisher={IOP Publishing}
 }
 
+@article{brosaplanella2020TSPMe,
+title={Systematic derivation and validation of a reduced thermal-electrochemical model for lithium-ion batteries using asymptotic methods}
+journal={Submitted for publication},
+author={Brosa Planella, Ferran and Sheikh, Muhammad and Widanage, Dhammika W},
+year={2020},
+eprint={2011.01611},
+archivePrefix={arXiv},
+primaryClass={physics.chem-ph},
+}
+
 @article{lain2019design,
   title={Design Strategies for High Power vs. High Energy Lithium Ion Cells},
   author={Lain, Michael J and Brandon, James and Kendrick, Emma},

pybamm/input/parameters/lithium-ion/electrolytes/lipf6_Nyman2008/electrolyte_conductivity_Nyman2008.py

@@ -1,6 +1,3 @@
-from pybamm import exp, constants
-
-
 def electrolyte_conductivity_Nyman2008(c_e, T):
     """
     Conductivity of LiPF6 in EC:EMC (3:7) as a function of ion concentration. The data
@@ -27,7 +24,6 @@ def electrolyte_conductivity_Nyman2008(c_e, T):
         0.1297 * (c_e / 1000) ** 3 - 2.51 * (c_e / 1000) ** 1.5 + 3.329 * (c_e / 1000)
     )
 
-    E_k_e = 34700
-    arrhenius = exp(E_k_e / constants.R * (1 / 298.15 - 1 / T))
+    # Nyman et al. (2008) does not provide temperature dependence
 
-    return sigma_e * arrhenius
+    return sigma_e

pybamm/input/parameters/lithium-ion/electrolytes/lipf6_Nyman2008/electrolyte_diffusivity_Nyman2008.py

@@ -1,6 +1,3 @@
-from pybamm import exp, constants
-
-
 def electrolyte_diffusivity_Nyman2008(c_e, T):
     """
     Diffusivity of LiPF6 in EC:EMC (3:7) as a function of ion concentration. The data
@@ -24,7 +21,7 @@ def electrolyte_diffusivity_Nyman2008(c_e, T):
     """
 
     D_c_e = 8.794e-11 * (c_e / 1000) ** 2 - 3.972e-10 * (c_e / 1000) + 4.862e-10
-    E_D_e = 37040
-    arrhenius = exp(E_D_e / constants.R * (1 / 298.15 - 1 / T))
 
-    return D_c_e * arrhenius
+    # Nyman et al. (2008) does not provide temperature dependence
+
+    return D_c_e

pybamm/models/full_battery_models/base_battery_model.py

@@ -198,6 +198,7 @@ def options(self, extra_options):
             "current collector": "uniform",
             "particle": "Fickian diffusion",
             "particle shape": "spherical",
+            "electrolyte conductivity": "default",
             "thermal": "isothermal",
             "cell geometry": None,
             "external submodels": [],
@@ -375,6 +376,19 @@ def options(self, extra_options):
                 "placed at the top of the cell."
             )
 
+        if options["electrolyte conductivity"] not in [
+            "default",
+            "full",
+            "leading order",
+            "composite",
+            "integrated",
+        ]:
+            raise pybamm.OptionError(
+                "electrolyte conductivity model '{}' not recognised".format(
+                    options["electrolyte conductivity"]
+                )
+            )
+
         self._options = options
 
     def set_standard_output_variables(self):

pybamm/models/full_battery_models/lithium_ion/dfn.py

@@ -121,6 +121,13 @@ def set_electrolyte_submodel(self):
             self.param
         )
 
+        if self.options["electrolyte conductivity"] not in ["default", "full"]:
+            raise pybamm.OptionError(
+                "electrolyte conductivity '{}' not suitable for DFN".format(
+                    self.options["electrolyte conductivity"]
+                )
+            )
+
         if self.options["surface form"] is False:
             self.submodels[
                 "electrolyte conductivity"

pybamm/models/full_battery_models/lithium_ion/spm.py

@@ -136,6 +136,13 @@ def set_electrolyte_submodel(self):
 
         surf_form = pybamm.electrolyte_conductivity.surface_potential_form
 
+        if self.options["electrolyte conductivity"] not in ["default", "leading order"]:
+            raise pybamm.OptionError(
+                "electrolyte conductivity '{}' not suitable for SPM".format(
+                    self.options["electrolyte conductivity"]
+                )
+            )
+
         if self.options["surface form"] is False:
             self.submodels[
                 "leading-order electrolyte conductivity"
@@ -152,6 +159,7 @@ def set_electrolyte_submodel(self):
                 self.submodels[
                     "leading-order " + domain.lower() + " electrolyte conductivity"
                 ] = surf_form.LeadingOrderAlgebraic(self.param, domain)
+
         self.submodels[
             "electrolyte diffusion"
         ] = pybamm.electrolyte_diffusion.ConstantConcentration(self.param)

pybamm/models/full_battery_models/lithium_ion/spme.py

@@ -136,9 +136,39 @@ def set_positive_electrode_submodel(self):
 
     def set_electrolyte_submodel(self):
 
-        self.submodels[
-            "electrolyte conductivity"
-        ] = pybamm.electrolyte_conductivity.Composite(self.param)
+        if self.options["electrolyte conductivity"] not in [
+            "default",
+            "composite",
+            "integrated",
+        ]:
+            raise pybamm.OptionError(
+                "electrolyte conductivity '{}' not suitable for SPMe".format(
+                    self.options["electrolyte conductivity"]
+                )
+            )
+
+        if self.options["surface form"] is False:
+            if self.options["electrolyte conductivity"] in ["default", "composite"]:
+                self.submodels[
+                    "electrolyte conductivity"
+                ] = pybamm.electrolyte_conductivity.Composite(self.param)
+            elif self.options["electrolyte conductivity"] == "integrated":
+                self.submodels[
+                    "electrolyte conductivity"
+                ] = pybamm.electrolyte_conductivity.Integrated(self.param)
+        elif self.options["surface form"] == "differential":
+            raise NotImplementedError(
+                "surface form '{}' has not been implemented for SPMe yet".format(
+                    self.options["surface form"]
+                )
+            )
+        elif self.options["surface form"] == "algebraic":
+            raise NotImplementedError(
+                "surface form '{}' has not been implemented for SPMe yet".format(
+                    self.options["surface form"]
+                )
+            )
+
         self.submodels["electrolyte diffusion"] = pybamm.electrolyte_diffusion.Full(
             self.param
         )

pybamm/models/submodels/electrolyte_conductivity/__init__.py

@@ -2,5 +2,6 @@
 from .leading_order_conductivity import LeadingOrder
 from .composite_conductivity import Composite
 from .full_conductivity import Full
+from .integrated_conductivity import Integrated
 
 from . import surface_potential_form

pybamm/models/submodels/electrolyte_conductivity/integrated_conductivity.py

@@ -0,0 +1,173 @@
+#
+# Composite electrolyte potential employing integrated Stefan-Maxwell
+#
+import pybamm
+from .base_electrolyte_conductivity import BaseElectrolyteConductivity
+
+
+class Integrated(BaseElectrolyteConductivity):
+    """
+    Integrated model for conservation of charge in the electrolyte derived from
+    integrating the Stefan-Maxwell constitutive equations, from [1]_.
+
+    Parameters
+    ----------
+    param : parameter class
+        The parameters to use for this submodel
+    domain : str, optional
+        The domain in which the model holds
+    reactions : dict, optional
+        Dictionary of reaction terms
+
+    References
+    ----------
+    .. [1] F. Brosa Planella, M. Sheikh, and W. D. Widanage, “Systematic derivation and
+           validation of reduced thermal-electrochemical models for lithium-ion
+           batteries using asymptotic methods.” arXiv preprint, 2020.
+
+    **Extends:** :class:`pybamm.electrolyte_conductivity.BaseElectrolyteConductivity`
+
+    """
+
+    def __init__(self, param, domain=None):
+        pybamm.citations.register("brosaplanella2020TSPMe")
+        super().__init__(param, domain)
+
+    def _higher_order_macinnes_function(self, x):
+        return pybamm.log(x)
+
+    def get_coupled_variables(self, variables):
+        c_e_av = variables["X-averaged electrolyte concentration"]
+
+        i_boundary_cc_0 = variables["Leading-order current collector current density"]
+        c_e_n = variables["Negative electrolyte concentration"]
+        c_e_s = variables["Separator electrolyte concentration"]
+        c_e_p = variables["Positive electrolyte concentration"]
+        c_e_n0 = pybamm.boundary_value(c_e_n, "left")
+
+        delta_phi_n_av = variables[
+            "X-averaged negative electrode surface potential difference"
+        ]
+        phi_s_n_av = variables["X-averaged negative electrode potential"]
+
+        tor_n = variables["Negative electrolyte tortuosity"]
+        tor_s = variables["Separator tortuosity"]
+        tor_p = variables["Positive electrolyte tortuosity"]
+
+        T_av = variables["X-averaged cell temperature"]
+        T_av_n = pybamm.PrimaryBroadcast(T_av, "negative electrode")
+        T_av_s = pybamm.PrimaryBroadcast(T_av, "separator")
+        T_av_p = pybamm.PrimaryBroadcast(T_av, "positive electrode")
+
+        param = self.param
+        l_n = param.l_n
+        l_p = param.l_p
+        x_n = pybamm.standard_spatial_vars.x_n
+        x_s = pybamm.standard_spatial_vars.x_s
+        x_p = pybamm.standard_spatial_vars.x_p
+        x_n_edge = pybamm.standard_spatial_vars.x_n_edge
+        x_p_edge = pybamm.standard_spatial_vars.x_p_edge
+
+        chi_av = param.chi(c_e_av)
+        chi_av_n = pybamm.PrimaryBroadcast(chi_av, "negative electrode")
+        chi_av_s = pybamm.PrimaryBroadcast(chi_av, "separator")
+        chi_av_p = pybamm.PrimaryBroadcast(chi_av, "positive electrode")
+
+        # electrolyte current
+        i_e_n = i_boundary_cc_0 * x_n / l_n
+        i_e_s = pybamm.PrimaryBroadcast(i_boundary_cc_0, "separator")
+        i_e_p = i_boundary_cc_0 * (1 - x_p) / l_p
+        i_e = pybamm.Concatenation(i_e_n, i_e_s, i_e_p)
+
+        i_e_n_edge = i_boundary_cc_0 * x_n_edge / l_n
+        i_e_s_edge = pybamm.PrimaryBroadcastToEdges(i_boundary_cc_0, "separator")
+        i_e_p_edge = i_boundary_cc_0 * (1 - x_p_edge) / l_p
+
+        # electrolyte potential
+        indef_integral_n = (
+            pybamm.IndefiniteIntegral(
+                i_e_n_edge / (param.kappa_e(c_e_n, T_av_n) * tor_n), x_n
+            )
+            * param.C_e
+            / param.gamma_e
+        )
+        indef_integral_s = (
+            pybamm.IndefiniteIntegral(
+                i_e_s_edge / (param.kappa_e(c_e_s, T_av_s) * tor_s), x_s
+            )
+            * param.C_e
+            / param.gamma_e
+        )
+        indef_integral_p = (
+            pybamm.IndefiniteIntegral(
+                i_e_p_edge / (param.kappa_e(c_e_p, T_av_p) * tor_p), x_p
+            )
+            * param.C_e
+            / param.gamma_e
+        )
+
+        integral_n = indef_integral_n
+        integral_s = indef_integral_s + pybamm.boundary_value(integral_n, "right")
+        integral_p = indef_integral_p + pybamm.boundary_value(integral_s, "right")
+
+        phi_e_const = (
+            -delta_phi_n_av
+            + phi_s_n_av
+            - (
+                chi_av
+                * (1 + param.Theta * T_av)
+                * pybamm.x_average(self._higher_order_macinnes_function(c_e_n / c_e_n0))
+            )
+            + pybamm.x_average(integral_n)
+        )
+
+        phi_e_n = (
+            phi_e_const
+            + (
+                chi_av_n
+                * (1 + param.Theta * T_av_n)
+                * self._higher_order_macinnes_function(c_e_n / c_e_n0)
+            )
+            - integral_n
+        )
+
+        phi_e_s = (
+            phi_e_const
+            + (
+                chi_av_s
+                * (1 + param.Theta * T_av_s)
+                * self._higher_order_macinnes_function(c_e_s / c_e_n0)
+            )
+            - integral_s
+        )
+
+        phi_e_p = (
+            phi_e_const
+            + (
+                chi_av_p
+                * (1 + param.Theta * T_av_p)
+                * self._higher_order_macinnes_function(c_e_p / c_e_n0)
+            )
+            - integral_p
+        )
+
+        # concentration overpotential
+        eta_c_av = (
+            chi_av
+            * (1 + param.Theta * T_av)
+            * (
+                pybamm.x_average(self._higher_order_macinnes_function(c_e_p / c_e_av))
+                - pybamm.x_average(self._higher_order_macinnes_function(c_e_n / c_e_av))
+            )
+        )
+
+        # average electrolyte ohmic losses
+        delta_phi_e_av = -(pybamm.x_average(integral_p) - pybamm.x_average(integral_n))
+
+        variables.update(
+            self._get_standard_potential_variables(phi_e_n, phi_e_s, phi_e_p)
+        )
+        variables.update(self._get_standard_current_variables(i_e))
+        variables.update(self._get_split_overpotential(eta_c_av, delta_phi_e_av))
+
+        return variables

tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_compare_outputs.py

@@ -15,7 +15,7 @@ def test_compare_outputs_surface_form(self):
         ]
         model_combos = [
             ([pybamm.lithium_ion.SPM(opt) for opt in options]),
-            ([pybamm.lithium_ion.SPMe(opt) for opt in options]),
+            # ([pybamm.lithium_ion.SPMe(opt) for opt in options]), # not implemented
             ([pybamm.lithium_ion.DFN(opt) for opt in options]),
         ]
 

tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_spme.py

@@ -112,14 +112,20 @@ def test_particle_quartic(self):
         modeltest = tests.StandardModelTest(model)
         modeltest.test_all()
 
-    def test_surface_form_differential(self):
-        options = {"surface form": "differential"}
-        model = pybamm.lithium_ion.SPMe(options)
-        modeltest = tests.StandardModelTest(model)
-        modeltest.test_all()
-
-    def test_surface_form_algebraic(self):
-        options = {"surface form": "algebraic"}
+    # def test_surface_form_differential(self):
+    #     options = {"surface form": "differential"}
+    #     model = pybamm.lithium_ion.SPMe(options)
+    #     modeltest = tests.StandardModelTest(model)
+    #     modeltest.test_all()
+
+    # def test_surface_form_algebraic(self):
+    #     options = {"surface form": "algebraic"}
+    #     model = pybamm.lithium_ion.SPMe(options)
+    #     modeltest = tests.StandardModelTest(model)
+    #     modeltest.test_all()
+
+    def test_integrated_conductivity(self):
+        options = {"electrolyte conductivity": "integrated"}
         model = pybamm.lithium_ion.SPMe(options)
         modeltest = tests.StandardModelTest(model)
         modeltest.test_all()