#1429 fixed some more tests

examples/scripts/SPMe.py

@@ -8,7 +8,7 @@
 pybamm.set_logging_level("INFO")
 
 # load model
-model = pybamm.lithium_ion.SPMe()
+model = pybamm.lithium_ion.SPM({"particle": "uniform profile"})
 model.convert_to_format = "python"
 
 # create geometry

pybamm/expression_tree/unary_operators.py

@@ -1146,9 +1146,18 @@ def x_average(symbol):
         new_symbol = symbol.new_copy()
         new_symbol.parent = None
         return new_symbol
-    # If symbol is a Broadcast, its average value is its child
-    elif isinstance(symbol, pybamm.Broadcast):
+    # If symbol is a primary broadcast, or a full broadcast without auxiliary domains,
+    # its average value is its child
+    if isinstance(symbol, pybamm.PrimaryBroadcast) or (
+        isinstance(symbol, pybamm.FullBroadcast) and symbol.auxiliary_domains == {}
+    ):
         return symbol.orphans[0]
+    # If symbol is a full broadcast, its average value is a primary broadcast of its
+    # child in its secondary dimension
+    if isinstance(symbol, pybamm.FullBroadcast):
+        return pybamm.PrimaryBroadcast(
+            symbol.orphans[0], symbol.auxiliary_domains["secondary"]
+        )
     # If symbol is a concatenation of Broadcasts, its average value is its child
     elif (
         isinstance(symbol, pybamm.Concatenation)

pybamm/models/submodels/oxygen_diffusion/base_oxygen_diffusion.py

@@ -20,28 +20,21 @@ class BaseModel(pybamm.BaseSubModel):
     def __init__(self, param):
         super().__init__(param)
 
-    def _get_standard_concentration_variables(self, c_ox):
+    def _get_standard_concentration_variables(self, c_ox_n, c_ox_s, c_ox_p):
         """
         A private function to obtain the standard variables which
         can be derived from the concentration of oxygen.
 
-        Parameters
-        ----------
-        c_ox : :class:`pybamm.Symbol`
-            The concentration of oxygen.
-        c_ox_av : :class:`pybamm.Symbol`
-            The cell-averaged concentration of oxygen.
-
         Returns
         -------
         variables : dict
             The variables which can be derived from the concentration in the
             oxygen.
         """
 
-        c_ox_av = pybamm.x_average(c_ox)
         c_ox_typ = self.param.c_ox_typ
-        c_ox_n, c_ox_s, c_ox_p = c_ox.orphans
+        c_ox = pybamm.concatenation(c_ox_n, c_ox_s, c_ox_p)
+        c_ox_av = pybamm.x_average(c_ox)
 
         variables = {
             "Oxygen concentration": c_ox,

pybamm/models/submodels/oxygen_diffusion/first_order_oxygen_diffusion.py

@@ -70,7 +70,9 @@ def get_coupled_variables(self, variables):
         c_ox = pybamm.concatenation(
             param.C_e * c_ox_n_1, param.C_e * c_ox_s_1, param.C_e * c_ox_p_1
         )
-        variables.update(self._get_standard_concentration_variables(c_ox))
+        variables.update(
+            self._get_standard_concentration_variables(c_ox_n, c_ox_s, c_ox_p)
+        )
 
         N_ox = pybamm.concatenation(
             param.C_e * N_ox_n_1, param.C_e * N_ox_s_1, param.C_e * N_ox_p_1

pybamm/models/submodels/oxygen_diffusion/full_oxygen_diffusion.py

@@ -61,7 +61,9 @@ def get_fundamental_variables(self):
         variables = {"Separator and positive electrode oxygen concentration": c_ox_s_p}
 
         c_ox = pybamm.concatenation(c_ox_n, c_ox_s, c_ox_p)
-        variables.update(self._get_standard_concentration_variables(c_ox))
+        variables.update(
+            self._get_standard_concentration_variables(c_ox_n, c_ox_s, c_ox_p)
+        )
 
         return variables
 

pybamm/models/submodels/oxygen_diffusion/leading_oxygen_diffusion.py

@@ -32,7 +32,7 @@ def get_fundamental_variables(self):
         c_ox_p = pybamm.PrimaryBroadcast(c_ox_av, "positive electrode")
         c_ox = pybamm.concatenation(c_ox_n, c_ox_s, c_ox_p)
 
-        return self._get_standard_concentration_variables(c_ox)
+        return self._get_standard_concentration_variables(c_ox_n, c_ox_s, c_ox_p)
 
     def get_coupled_variables(self, variables):
 

pybamm/models/submodels/oxygen_diffusion/no_oxygen.py

@@ -25,9 +25,8 @@ def get_fundamental_variables(self):
         c_ox_n = pybamm.FullBroadcast(0, ["negative electrode"], "current collector")
         c_ox_s = pybamm.FullBroadcast(0, ["separator"], "current collector")
         c_ox_p = pybamm.FullBroadcast(0, ["positive electrode"], "current collector")
-        c_ox = pybamm.concatenation(c_ox_n, c_ox_s, c_ox_p)
 
-        variables = self._get_standard_concentration_variables(c_ox)
+        variables = self._get_standard_concentration_variables(c_ox_n, c_ox_s, c_ox_p)
 
         N_e = pybamm.FullBroadcastToEdges(
             0,

pybamm/models/submodels/thermal/base_thermal.py

@@ -88,8 +88,8 @@ def _get_standard_coupled_variables(self, variables):
 
         param = self.param
 
-        T = variables["Cell temperature"]
-        T_n, _, T_p = T.orphans
+        T_n = variables["Negative electrode temperature"]
+        T_p = variables["Positive electrode temperature"]
 
         a_n = variables["Negative electrode surface area to volume ratio"]
         a_p = variables["Positive electrode surface area to volume ratio"]
@@ -105,6 +105,9 @@ def _get_standard_coupled_variables(self, variables):
 
         i_e = variables["Electrolyte current density"]
         phi_e = variables["Electrolyte potential"]
+        phi_e_n = variables["Negative electrolyte potential"]
+        phi_e_s = variables["Separator electrolyte potential"]
+        phi_e_p = variables["Positive electrolyte potential"]
 
         i_s_n = variables["Negative electrode current density"]
         i_s_p = variables["Positive electrode current density"]
@@ -124,7 +127,6 @@ def _get_standard_coupled_variables(self, variables):
         if isinstance(i_e, pybamm.Concatenation):
             # compute by domain if possible
             i_e_n, i_e_s, i_e_p = i_e.orphans
-            phi_e_n, phi_e_s, phi_e_p = phi_e.orphans
             Q_ohm_e_n = -pybamm.inner(i_e_n, pybamm.grad(phi_e_n))
             Q_ohm_e_s = -pybamm.inner(i_e_s, pybamm.grad(phi_e_s))
             Q_ohm_e_p = -pybamm.inner(i_e_p, pybamm.grad(phi_e_p))

pybamm/models/submodels/thermal/x_full.py

@@ -53,7 +53,9 @@ def get_coupled_variables(self, variables):
 
     def set_rhs(self, variables):
         T = variables["Cell temperature"]
-        T_n, T_s, T_p = T.orphans
+        T_n = variables["Negative electrode temperature"]
+        T_s = variables["Separator temperature"]
+        T_p = variables["Positive electrode temperature"]
 
         Q = variables["Total heating"]
 

pybamm/models/submodels/tortuosity/base_tortuosity.py

@@ -21,8 +21,10 @@ def __init__(self, param, phase):
         super().__init__(param)
         self.phase = phase
 
-    def _get_standard_tortuosity_variables(self, tor, set_leading_order=False):
-        tor_n, tor_s, tor_p = tor.orphans
+    def _get_standard_tortuosity_variables(
+        self, tor_n, tor_s, tor_p, set_leading_order=False
+    ):
+        tor = pybamm.concatenation(tor_n, tor_s, tor_p)
 
         variables = {
             self.phase + " tortuosity": tor,

pybamm/models/submodels/tortuosity/bruggeman_tortuosity.py

@@ -20,20 +20,26 @@ def get_coupled_variables(self, variables):
         param = self.param
 
         if self.phase == "Electrolyte":
-            eps_n, eps_s, eps_p = variables["Porosity"].orphans
-            tor = pybamm.concatenation(
-                eps_n ** param.b_e_n, eps_s ** param.b_e_s, eps_p ** param.b_e_p
-            )
+            eps_n = variables["Negative electrode porosity"]
+            eps_s = variables["Separator porosity"]
+            eps_p = variables["Positive electrode porosity"]
+
+            tor_n = eps_n ** param.b_e_n
+            tor_s = eps_s ** param.b_e_s
+            tor_p = eps_p ** param.b_e_p
         elif self.phase == "Electrode":
             eps_n = variables["Negative electrode active material volume fraction"]
             eps_s = pybamm.FullBroadcast(0, "separator", "current collector")
             eps_p = variables["Positive electrode active material volume fraction"]
-            tor = pybamm.concatenation(
-                eps_n ** param.b_s_n, eps_s ** param.b_s_s, eps_p ** param.b_s_p
-            )
+
+            tor_n = eps_n ** param.b_s_n
+            tor_s = eps_s ** param.b_s_s
+            tor_p = eps_p ** param.b_s_p
 
         variables.update(
-            self._get_standard_tortuosity_variables(tor, self.set_leading_order)
+            self._get_standard_tortuosity_variables(
+                tor_n, tor_s, tor_p, self.set_leading_order
+            )
         )
 
         return variables