Implement Integrated electrolyte conductivity

pybamm/CITATIONS.txt

@@ -204,3 +204,13 @@ primaryClass={physics.app-ph},
   year={2005},
   publisher={IOP Publishing}
 }
+
+@article{brosaplanella2020TSPMe,
+title={Systematic derivation and validation of reduced thermal-electrochemical for Li-ion batteries using asymptotic methods}
+journal={Submitted for publication},
+author={Brosa Planella, Ferran and Sheikh, Muhammad and Widanage, Dhammika W},
+year={2020},
+eprint={},
+archivePrefix={arXiv},
+primaryClass={},
+}

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

@@ -27,7 +27,7 @@ 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
+    E_k_e = 0   # no activation energy provided
     arrhenius = exp(E_k_e / constants.R * (1 / 298.15 - 1 / T))
 
     return sigma_e * arrhenius

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

@@ -24,7 +24,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
+    E_D_e = 0   # no activation energy provided
     arrhenius = exp(E_D_e / constants.R * (1 / 298.15 - 1 / T))
 
     return D_c_e * arrhenius

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.
+
+    Parameters
+    ----------
+    param : parameter class
+        The parameters to use for this submodel
+    higher_order_terms : str
+        What kind of higher-order terms to use ('composite' or 'first-order')
+    domain : str, optional
+        The domain in which the model holds
+
+    **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 - pybamm.boundary_value(indef_integral_n, "left")
+        integral_s = (
+            indef_integral_s
+            - pybamm.boundary_value(indef_integral_s, "left")
+            + pybamm.boundary_value(integral_n, "right")
+        )
+        integral_p = (
+            indef_integral_p
+            - pybamm.boundary_value(indef_integral_p, "left")
+            + 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/unit/test_models/test_submodels/test_electrolyte_conductivity/test_integrated.py

@@ -0,0 +1,42 @@
+#
+# Test integrated Stefan Maxwell electrolyte conductivity submodel
+#
+
+import pybamm
+import tests
+import unittest
+
+
+class TestFull(unittest.TestCase):
+    def test_public_functions(self):
+        param = pybamm.LithiumIonParameters()
+        a = pybamm.PrimaryBroadcast(0, "current collector")
+        c_e_n = pybamm.standard_variables.c_e_n
+        c_e_s = pybamm.standard_variables.c_e_s
+        c_e_p = pybamm.standard_variables.c_e_p
+        variables = {
+            "X-averaged electrolyte concentration": a,
+            "Leading-order current collector current density": a,
+            "Negative electrolyte concentration": c_e_n,
+            "Separator electrolyte concentration": c_e_s,
+            "Positive electrolyte concentration": c_e_p,
+            "X-averaged negative electrode surface potential difference": a,
+            "X-averaged negative electrode potential": a,
+            "Negative electrolyte tortuosity": a,
+            "Separator tortuosity": a,
+            "Positive electrolyte tortuosity": a,
+            "X-averaged cell temperature": a,
+        }
+        submodel = pybamm.electrolyte_conductivity.Integrated(param)
+        std_tests = tests.StandardSubModelTests(submodel, variables)
+        std_tests.test_all()
+
+
+if __name__ == "__main__":
+    print("Add -v for more debug output")
+    import sys
+
+    if "-v" in sys.argv:
+        debug = True
+    pybamm.settings.debug_mode = True
+    unittest.main()