make SEI single layer only

src/pybamm/input/parameters/lithium_ion/Chen2020.py

@@ -227,9 +227,7 @@ def get_parameter_values():
         "chemistry": "lithium_ion",
         # sei
         "Ratio of lithium moles to SEI moles": 2.0,
-        "Inner SEI reaction proportion": 0.5,
-        "Inner SEI partial molar volume [m3.mol-1]": 9.585e-05,
-        "Outer SEI partial molar volume [m3.mol-1]": 9.585e-05,
+        "SEI partial molar volume [m3.mol-1]": 9.585e-05,
         "SEI reaction exchange current density [A.m-2]": 1.5e-07,
         "SEI resistivity [Ohm.m]": 200000.0,
         "Outer SEI solvent diffusivity [m2.s-1]": 2.5000000000000002e-22,
@@ -239,8 +237,7 @@ def get_parameter_values():
         "Inner SEI electron conductivity [S.m-1]": 8.95e-14,
         "Inner SEI lithium interstitial diffusivity [m2.s-1]": 1e-20,
         "Lithium interstitial reference concentration [mol.m-3]": 15.0,
-        "Initial inner SEI thickness [m]": 2.5e-09,
-        "Initial outer SEI thickness [m]": 2.5e-09,
+        "Initial SEI thickness [m]": 5e-09,
         "EC initial concentration in electrolyte [mol.m-3]": 4541.0,
         "EC diffusivity [m2.s-1]": 2e-18,
         "SEI kinetic rate constant [m.s-1]": 1e-12,

src/pybamm/input/parameters/lithium_ion/Marquis2019.py

@@ -352,9 +352,7 @@ def get_parameter_values():
         "chemistry": "lithium_ion",
         # sei
         "Ratio of lithium moles to SEI moles": 2.0,
-        "Inner SEI reaction proportion": 0.5,
-        "Inner SEI partial molar volume [m3.mol-1]": 9.585e-05,
-        "Outer SEI partial molar volume [m3.mol-1]": 9.585e-05,
+        "SEI partial molar volume [m3.mol-1]": 9.585e-05,
         "SEI growth transfer coefficient": 0.5,
         "SEI reaction exchange current density [A.m-2]": 1.5e-07,
         "SEI resistivity [Ohm.m]": 200000.0,
@@ -365,8 +363,7 @@ def get_parameter_values():
         "Inner SEI electron conductivity [S.m-1]": 8.95e-14,
         "Inner SEI lithium interstitial diffusivity [m2.s-1]": 1e-20,
         "Lithium interstitial reference concentration [mol.m-3]": 15.0,
-        "Initial inner SEI thickness [m]": 2.5e-09,
-        "Initial outer SEI thickness [m]": 2.5e-09,
+        "Initial SEI thickness [m]": 5e-09,
         "EC initial concentration in electrolyte [mol.m-3]": 4541.0,
         "EC diffusivity [m2.s-1]": 2e-18,
         "SEI kinetic rate constant [m.s-1]": 1e-12,

src/pybamm/models/submodels/interface/sei/base_sei.py

@@ -55,43 +55,33 @@ def get_coupled_variables(self, variables):
 
         return variables
 
-    def _get_standard_thickness_variables(self, L_inner, L_outer):
+    def _get_standard_thickness_variables(self, L):
         """
         A private function to obtain the standard variables which
         can be derived from the local SEI thickness.
 
         Parameters
         ----------
-        L_inner : :class:`pybamm.Symbol`
-            The inner SEI thickness.
-        L_outer : :class:`pybamm.Symbol`
-            The outer SEI thickness.
+        L : :class:`pybamm.Symbol`
+            The SEI thickness.
 
         Returns
         -------
         variables : dict
             The variables which can be derived from the SEI thicknesses.
         """
         domain, Domain = self.domain_Domain
-        variables = {
-            f"{Domain} inner {self.reaction_name}thickness [m]": L_inner,
-            f"{Domain} outer {self.reaction_name}thickness [m]": L_outer,
-        }
+        variables = {f"{Domain} {self.reaction_name}thickness [m]": L}
 
         if self.reaction_loc != "interface":
-            L_inner_av = pybamm.x_average(L_inner)
-            L_outer_av = pybamm.x_average(L_outer)
+            L_av = pybamm.x_average(L)
             variables.update(
                 {
-                    f"X-averaged {domain} inner {self.reaction_name}"
-                    "thickness [m]": L_inner_av,
-                    f"X-averaged {domain} outer {self.reaction_name}"
-                    "thickness [m]": L_outer_av,
+                    f"X-averaged {domain} {self.reaction_name}thickness [m]": L_av,
                 }
             )
         # Get variables related to the total thickness
-        L_sei = L_inner + L_outer
-        variables.update(self._get_standard_total_thickness_variables(L_sei))
+        variables.update(self._get_standard_total_thickness_variables(L))
 
         return variables
 
@@ -135,49 +125,33 @@ def _get_standard_concentration_variables(self, variables):
         # Set scales to one for the "no SEI" model so that they are not required
         # by parameter values in general
         if isinstance(self, pybamm.sei.NoSEI):
-            L_to_n_inner = 0
-            L_to_n_outer = 0
+            L_to_n = 0
             n_SEI_0 = 0
             n_crack_0 = 0
             z_sei = 1
         else:
             if self.reaction_loc == "interface":
                 # m * (mol/m3) = mol/m2 (n is an interfacial quantity)
-                L_to_n_inner = 1 / phase_param.V_bar_inner
-                L_to_n_outer = 1 / phase_param.V_bar_outer
-                L_to_n_inner_0 = L_to_n_inner
-                L_to_n_outer_0 = L_to_n_outer
+                L_to_n = 1 / phase_param.V_bar
+                L_to_n_0 = L_to_n
             else:
                 # m * (mol/m4) = mol/m3 (n is a bulk quantity)
                 a = variables[
                     f"{Domain} electrode {self.phase_name}"
                     "surface area to volume ratio [m-1]"
                 ]
-                L_to_n_inner = a / phase_param.V_bar_inner
-                L_to_n_outer = a / phase_param.V_bar_outer
-                L_to_n_inner_0 = phase_param.a_typ / phase_param.V_bar_inner
-                L_to_n_outer_0 = phase_param.a_typ / phase_param.V_bar_outer
+                L_to_n = a / phase_param.V_bar_sei
+                L_to_n_0 = phase_param.a_typ / phase_param.V_bar_sei
             z_sei = phase_param.z_sei
-            L_inner_0 = phase_param.L_inner_0
-            L_outer_0 = phase_param.L_outer_0
-            L_inner_crack_0 = phase_param.L_inner_crack_0
-            L_outer_crack_0 = phase_param.L_outer_crack_0
-            n_SEI_0 = L_inner_0 * L_to_n_inner_0 + L_outer_0 * L_to_n_outer_0
-            n_crack_0 = (
-                L_inner_crack_0 * L_to_n_inner_0 + L_outer_crack_0 * L_to_n_outer_0
-            )
+            L_0 = phase_param.L_sei_0
+            L_crack_0 = phase_param.L_sei_crack_0
+            n_SEI_0 = L_0 * L_to_n_0
+            n_crack_0 = L_crack_0 * L_to_n_0
 
         if self.reaction == "SEI":
-            L_inner = variables[f"{Domain} inner {reaction_name}thickness [m]"]
-            L_outer = variables[f"{Domain} outer {reaction_name}thickness [m]"]
-
-            n_inner = L_inner * L_to_n_inner  # inner SEI concentration
-            n_outer = L_outer * L_to_n_outer  # outer SEI concentration
+            L = variables[f"{Domain} {reaction_name}thickness [m]"]
 
-            n_inner_av = pybamm.x_average(n_inner)
-            n_outer_av = pybamm.x_average(n_outer)
-
-            n_SEI = n_inner + n_outer  # SEI concentration
+            n_SEI = L * L_to_n
             n_SEI_xav = pybamm.x_average(n_SEI)
             n_SEI_av = pybamm.yz_average(n_SEI_xav)
 
@@ -199,12 +173,6 @@ def _get_standard_concentration_variables(self, variables):
 
             variables.update(
                 {
-                    f"{Domain} inner {reaction_name}concentration [mol.m-3]": n_inner,
-                    f"X-averaged {domain} inner {reaction_name}"
-                    "concentration [mol.m-3]": n_inner_av,
-                    f"{Domain} outer {reaction_name}concentration [mol.m-3]": n_outer,
-                    f"X-averaged {domain} outer {reaction_name}"
-                    "concentration [mol.m-3]": n_outer_av,
                     f"{Domain} {reaction_name}concentration [mol.m-3]": n_SEI,
                     f"X-averaged {domain} {reaction_name}"
                     "concentration [mol.m-3]": n_SEI_xav,
@@ -216,17 +184,10 @@ def _get_standard_concentration_variables(self, variables):
             )
         # Concentration variables are handled slightly differently for SEI on cracks
         elif self.reaction == "SEI on cracks":
-            L_inner_cr = variables[f"{Domain} inner {reaction_name}thickness [m]"]
-            L_outer_cr = variables[f"{Domain} outer {reaction_name}thickness [m]"]
+            L_cr = variables[f"{Domain} {reaction_name}thickness [m]"]
             roughness = variables[f"{Domain} electrode roughness ratio"]
 
-            n_inner_cr = L_inner_cr * L_to_n_inner * (roughness - 1)
-            n_outer_cr = L_outer_cr * L_to_n_outer * (roughness - 1)
-
-            n_inner_cr_av = pybamm.x_average(n_inner_cr)
-            n_outer_cr_av = pybamm.x_average(n_outer_cr)
-
-            n_SEI_cr = n_inner_cr + n_outer_cr  # SEI on cracks concentration
+            n_SEI_cr = L_cr * L_to_n * (roughness - 1)  # SEI on cracks concentration
             n_SEI_cr_xav = pybamm.x_average(n_SEI_cr)
             n_SEI_cr_av = pybamm.yz_average(n_SEI_cr_xav)
 
@@ -248,14 +209,6 @@ def _get_standard_concentration_variables(self, variables):
 
             variables.update(
                 {
-                    f"{Domain} inner {reaction_name}"
-                    "concentration [mol.m-3]": n_inner_cr,
-                    f"X-averaged {domain} inner {reaction_name}"
-                    "concentration [mol.m-3]": n_inner_cr_av,
-                    f"{Domain} outer {reaction_name}"
-                    "concentration [mol.m-3]": n_outer_cr,
-                    f"X-averaged {domain} outer {reaction_name}"
-                    "concentration [mol.m-3]": n_outer_cr_av,
                     f"{Domain} {reaction_name}" "concentration [mol.m-3]": n_SEI_cr,
                     f"X-averaged {domain} {reaction_name}"
                     "concentration [mol.m-3]": n_SEI_cr_xav,
@@ -268,37 +221,24 @@ def _get_standard_concentration_variables(self, variables):
 
         return variables
 
-    def _get_standard_reaction_variables(self, j_inner, j_outer):
+    def _get_standard_reaction_variables(self, j_sei):
         """
         A private function to obtain the standard variables which
         can be derived from the SEI interfacial reaction current
 
         Parameters
         ----------
-        j_inner : :class:`pybamm.Symbol`
-            The inner SEI interfacial reaction current.
-        j_outer : :class:`pybamm.Symbol`
-            The outer SEI interfacial reaction current.
+        j_sei : :class:`pybamm.Symbol`
+            The SEI interfacial reaction current.
 
         Returns
         -------
         variables : dict
             The variables which can be derived from the SEI currents.
         """
         domain, Domain = self.domain_Domain
-        j_inner_av = pybamm.x_average(j_inner)
-        j_outer_av = pybamm.x_average(j_outer)
-        j_sei = j_inner + j_outer
 
         variables = {
-            f"{Domain} electrode inner {self.reaction_name}"
-            "interfacial current density [A.m-2]": j_inner,
-            f"X-averaged {domain} electrode inner {self.reaction_name}"
-            "interfacial current density [A.m-2]": j_inner_av,
-            f"{Domain} electrode outer {self.reaction_name}"
-            "interfacial current density [A.m-2]": j_outer,
-            f"X-averaged {domain} electrode outer {self.reaction_name}"
-            "interfacial current density [A.m-2]": j_outer_av,
             f"{Domain} electrode {self.reaction_name}"
             "interfacial current density [A.m-2]": j_sei,
         }

src/pybamm/models/submodels/interface/sei/constant_sei.py

@@ -33,9 +33,8 @@ def __init__(self, param, domain, options, phase="primary"):
     def get_fundamental_variables(self):
         domain = self.domain.lower()
         # Constant thicknesses
-        L_inner = self.phase_param.L_inner_0
-        L_outer = self.phase_param.L_outer_0
-        variables = self._get_standard_thickness_variables(L_inner, L_outer)
+        L_sei = self.phase_param.L_sei_0
+        variables = self._get_standard_thickness_variables(L_sei)
 
         # Reactions
         if self.reaction_loc == "interface":
@@ -44,7 +43,7 @@ def get_fundamental_variables(self):
             zero = pybamm.FullBroadcast(
                 pybamm.Scalar(0), f"{domain} electrode", "current collector"
             )
-        variables.update(self._get_standard_reaction_variables(zero, zero))
+        variables.update(self._get_standard_reaction_variables(zero))
 
         return variables
 

src/pybamm/models/submodels/interface/sei/no_sei.py

@@ -36,8 +36,8 @@ def get_fundamental_variables(self):
             zero = pybamm.FullBroadcast(
                 pybamm.Scalar(0), f"{domain} electrode", "current collector"
             )
-        variables = self._get_standard_thickness_variables(zero, zero)
-        variables.update(self._get_standard_reaction_variables(zero, zero))
+        variables = self._get_standard_thickness_variables(zero)
+        variables.update(self._get_standard_reaction_variables(zero))
         return variables
 
     def get_coupled_variables(self, variables):