#546 fix unit tests except repr

pybamm/expression_tree/unary_operators.py

@@ -639,26 +639,26 @@ def surf(symbol, set_domain=False):
     :class:`pybamm.BoundaryValue`
         the surface value of ``symbol``
     """
+    original_symbol = symbol
     if isinstance(symbol, pybamm.SecondaryBroadcast):
-        orphan = symbol.orphans[0]
-        if orphan.domain in [
-            ["negative electrode"],
-            ["positive electrode"],
-        ] and isinstance(orphan, pybamm.PrimaryBroadcast):
-            child_surf = boundary_value(orphan.orphans[0], "right")
-            out = pybamm.FullBroadcast(
-                child_surf,
-                orphan.broadcast_domain,
-                secondary_domain=symbol.broadcast_domain,
-            )
-        else:
-            out = boundary_value(orphan, "right")
-            if set_domain:
-                if symbol.domain == ["negative particle"]:
-                    out.domain = ["negative electrode"]
-                elif symbol.domain == ["positive particle"]:
-                    out.domain = ["positive electrode"]
-            out = pybamm.SecondaryBroadcast(out, symbol.broadcast_domain)
+        symbol = symbol.orphans[0]
+        secondary_domain = original_symbol.broadcast_domain
+    else:
+        secondary_domain = None
+    if symbol.domain in [["negative electrode"], ["positive electrode"]] and isinstance(
+        symbol, pybamm.PrimaryBroadcast
+    ):
+        child_surf = boundary_value(symbol.orphans[0], "right")
+        out = pybamm.PrimaryBroadcast(child_surf, symbol.domain)
+    else:
+        out = boundary_value(symbol, "right")
+        if set_domain:
+            if original_symbol.domain == ["negative particle"]:
+                out.domain = ["negative electrode"]
+            elif original_symbol.domain == ["positive particle"]:
+                out.domain = ["positive electrode"]
+    if secondary_domain is not None:
+        out = pybamm.SecondaryBroadcast(out, secondary_domain)
     return out
 
 

pybamm/models/full_battery_models/lithium_ion/spm.py

@@ -108,29 +108,30 @@ def default_submesh_types(self):
             "positive electrode": pybamm.Uniform1DSubMesh,
             "negative particle": pybamm.Uniform1DSubMesh,
             "positive particle": pybamm.Uniform1DSubMesh,
-            "current collector": pybamm.Uniform1DSubMesh,
         }
-        dimensionality = self.options["bc_options"]["dimensionality"]
-        if dimensionality in [0, 1]:
-            return base_submeshes
-        elif dimensionality == 2:
+        if self.options["bc_options"]["dimensionality"] == 0:
+            base_submeshes["current collector"] = pybamm.SubMesh0D
+        elif self.options["bc_options"]["dimensionality"] == 1:
+            base_submeshes["current collector"] = pybamm.Uniform1DSubMesh
+        elif self.options["bc_options"]["dimensionality"] == 2:
             base_submeshes["current collector"] = pybamm.Scikit2DSubMesh
-            return base_submeshes
+        return base_submeshes
 
     @property
     def default_spatial_methods(self):
         base_spatial_methods = {
             "macroscale": pybamm.FiniteVolume,
             "negative particle": pybamm.FiniteVolume,
             "positive particle": pybamm.FiniteVolume,
-            "current collector": pybamm.FiniteVolume,
         }
-        dimensionality = self.options["bc_options"]["dimensionality"]
-        if dimensionality in [0, 1]:
-            return base_spatial_methods
-        elif dimensionality == 2:
+        if self.options["bc_options"]["dimensionality"] == 0:
+            # 0D submesh - use base spatial method
+            base_spatial_methods["current collector"] = pybamm.ZeroDimensionalMethod
+        if self.options["bc_options"]["dimensionality"] == 1:
+            base_spatial_methods["current collector"] = pybamm.FiniteVolume
+        elif self.options["bc_options"]["dimensionality"] == 2:
             base_spatial_methods["current collector"] = pybamm.ScikitFiniteElement
-            return base_spatial_methods
+        return base_spatial_methods
 
     @property
     def default_solver(self):

pybamm/models/simple_ode_model.py

@@ -36,9 +36,9 @@ def __init__(self):
         # Broadcast some of the variables
         self.variables = {
             "a": a,
-            "b broadcasted": pybamm.FullBroadcast(b, whole_cell),
+            "b broadcasted": pybamm.FullBroadcast(b, whole_cell, "current collector"),
             "c broadcasted": pybamm.FullBroadcast(
-                c, ["negative electrode", "separator"]
+                c, ["negative electrode", "separator"], "current collector"
             ),
         }
 

pybamm/models/submodels/thermal/base_thermal.py

@@ -79,7 +79,7 @@ def _get_standard_coupled_variables(self, variables):
         phi_s_p = variables["Positive electrode potential"]
 
         Q_ohm_s_n = -pybamm.inner(i_s_n, pybamm.grad(phi_s_n))
-        Q_ohm_s_s = pybamm.FullBroadcast(0, ["separator"])
+        Q_ohm_s_s = pybamm.FullBroadcast(0, ["separator"], "current collector")
         Q_ohm_s_p = -pybamm.inner(i_s_p, pybamm.grad(phi_s_p))
         Q_ohm_s = pybamm.Concatenation(Q_ohm_s_n, Q_ohm_s_s, Q_ohm_s_p)
 
@@ -90,13 +90,21 @@ def _get_standard_coupled_variables(self, variables):
         Q_rxn_n = j_n * eta_r_n
         Q_rxn_p = j_p * eta_r_p
         Q_rxn = pybamm.Concatenation(
-            *[Q_rxn_n, pybamm.FullBroadcast(0, ["separator"]), Q_rxn_p]
+            *[
+                Q_rxn_n,
+                pybamm.FullBroadcast(0, ["separator"], "current collector"),
+                Q_rxn_p,
+            ]
         )
 
         Q_rev_n = j_n * (param.Theta ** (-1) + T_n) * dUdT_n
         Q_rev_p = j_p * (param.Theta ** (-1) + T_p) * dUdT_p
         Q_rev = pybamm.Concatenation(
-            *[Q_rev_n, pybamm.FullBroadcast(0, ["separator"]), Q_rev_p]
+            *[
+                Q_rev_n,
+                pybamm.FullBroadcast(0, ["separator"], "current collector"),
+                Q_rev_p,
+            ]
         )
 
         Q = Q_ohm + Q_rxn + Q_rev

pybamm/models/submodels/thermal/full_thermal.py

@@ -56,9 +56,10 @@ def set_boundary_conditions(self, variables):
         T_n_left = pybamm.boundary_value(T, "left")
         T_p_right = pybamm.boundary_value(T, "right")
 
+        # TODO: check that changing lambda_k to lambda_n and lambda_p is ok here
         self.boundary_conditions = {
             T: {
-                "left": (-self.param.h * T_n_left / self.param.lambda_k, "Neumann"),
-                "right": (-self.param.h * T_p_right / self.param.lambda_k, "Neumann"),
+                "left": (-self.param.h * T_n_left / self.param.lambda_n, "Neumann"),
+                "right": (-self.param.h * T_p_right / self.param.lambda_p, "Neumann"),
             }
         }

pybamm/models/submodels/thermal/lumped_thermal.py

@@ -24,9 +24,9 @@ def __init__(self, param):
     def get_fundamental_variables(self):
 
         T_av = pybamm.standard_variables.T_av
-        T_n = pybamm.FullBroadcast(T_av, ["negative electrode"])
-        T_s = pybamm.FullBroadcast(T_av, ["separator"])
-        T_p = pybamm.FullBroadcast(T_av, ["positive electrode"])
+        T_n = pybamm.FullBroadcast(T_av, ["negative electrode"], "current collector")
+        T_s = pybamm.FullBroadcast(T_av, ["separator"], "current collector")
+        T_p = pybamm.FullBroadcast(T_av, ["positive electrode"], "current collector")
         T = pybamm.Concatenation(T_n, T_s, T_p)
 
         variables = self._get_standard_fundamental_variables(T)
@@ -39,7 +39,9 @@ def get_coupled_variables(self, variables):
     def _flux_law(self, T):
         """Fast x-direction heat diffusion (i.e. reached steady state)"""
         q = pybamm.FullBroadcast(
-            pybamm.Scalar(0), ["negative electrode", "separator", "positive electrode"]
+            pybamm.Scalar(0),
+            ["negative electrode", "separator", "positive electrode"],
+            "current collector",
         )
         return q
 

pybamm/processed_variable.py

@@ -93,9 +93,10 @@ def __init__(
             self.base_eval = base_variable.evaluate(t_sol[0], y_sol[:, 0])
 
         # handle 2D (in space) finite element variables differently
-        if "current collector" in self.domain:
-            if isinstance(self.mesh[self.domain[0]][0], pybamm.Scikit2DSubMesh):
-                self.initialise_3D_scikit_fem()
+        if "current collector" in self.domain and isinstance(
+            self.mesh[self.domain[0]][0], pybamm.Scikit2DSubMesh
+        ):
+            self.initialise_3D_scikit_fem()
         # check variable shape
         elif (
             isinstance(self.base_eval, numbers.Number)

tests/unit/test_expression_tree/test_symbol.py

@@ -208,19 +208,27 @@ def test_symbol_repr(self):
         hex_regex = r"\-?0x[0-9,a-f]+"
         self.assertRegex(
             a.__repr__(),
-            r"Symbol\(" + hex_regex + r", a, children\=\[\], domain\=\[\]\)",
+            r"Symbol\("
+            + hex_regex
+            + r", a, children\=\[\], domain\=\[\]\), secondary_domain\=\[\]\)",
         )
         self.assertRegex(
             b.__repr__(),
-            r"Symbol\(" + hex_regex + r", b, children\=\[\], domain\=\[\]\)",
+            r"Symbol\("
+            + hex_regex
+            + r", b, children\=\[\], domain\=\[\]\), secondary_domain\=\[\]\)",
         )
         self.assertRegex(
             c.__repr__(),
-            r"Symbol\(" + hex_regex + r", c, children\=\[\], domain\=\['test'\]\)",
+            r"Symbol\("
+            + hex_regex
+            + r", c, children\=\[\], domain\=\['test'\]\), secondary_domain\=\[\]\)",
         )
         self.assertRegex(
             d.__repr__(),
-            r"Symbol\(" + hex_regex + r", d, children\=\[\], domain\=\['test'\]\)",
+            r"Symbol\("
+            + hex_regex
+            + r", d, children\=\[\], domain\=\['test'\]\), secondary_domain\=\[\]\)",
         )
         self.assertRegex(
             (a + b).__repr__(),
@@ -230,29 +238,33 @@ def test_symbol_repr(self):
             (c * d).__repr__(),
             r"Multiplication\("
             + hex_regex
-            + r", \*, children\=\['c', 'd'\], domain=\['test'\]\)",
+            + r", \*, children\=\['c', 'd'\], domain=\['test'\]\)"
+            + r", secondary_domain\=\[\]\)",
         )
         self.assertRegex(
             pybamm.grad(a).__repr__(),
-            r"Gradient\(" + hex_regex + ", grad, children\=\['a'\], domain=\[\]\)",
+            r"Gradient\("
+            + hex_regex
+            + r", grad, children\=\['a'\], domain=\[\]\), secondary_domain\=\[\]\)",
         )
         self.assertRegex(
             pybamm.grad(c).__repr__(),
             r"Gradient\("
             + hex_regex
-            + ", grad, children\=\['c'\], domain=\['test'\]\)",
+            + r", grad, children\=\['c'\], domain=\['test'\]\)"
+            + r", secondary_domain\=\[\]\)",
         )
 
     def test_symbol_visualise(self):
 
         param = pybamm.standard_parameters_lithium_ion
 
-        one_n = pybamm.Broadcast(1, ["negative electrode"])
-        one_p = pybamm.Broadcast(1, ["positive electrode"])
+        one_n = pybamm.FullBroadcast(1, ["negative electrode"], "current collector")
+        one_p = pybamm.FullBroadcast(1, ["positive electrode"], "current collector")
 
-        zero_n = pybamm.Broadcast(0, ["negative electrode"])
-        zero_s = pybamm.Broadcast(0, ["separator"])
-        zero_p = pybamm.Broadcast(0, ["positive electrode"])
+        zero_n = pybamm.FullBroadcast(0, ["negative electrode"], "current collector")
+        zero_s = pybamm.FullBroadcast(0, ["separator"], "current collector")
+        zero_p = pybamm.FullBroadcast(0, ["positive electrode"], "current collector")
 
         deps_dt = pybamm.Concatenation(zero_n, zero_s, zero_p)
 
@@ -349,7 +361,7 @@ def test_shape_for_testing(self):
         )
 
         var = pybamm.Variable("var", domain=["random domain", "other domain"])
-        broadcast = pybamm.Broadcast(0, domain=["random domain", "other domain"])
+        broadcast = pybamm.Broadcast(0, ["random domain", "other domain"])
         self.assertEqual(var.shape_for_testing, broadcast.shape_for_testing)
         self.assertEqual(
             (var + broadcast).shape_for_testing, broadcast.shape_for_testing

tests/unit/test_models/test_full_battery_models/test_base_battery_model.py

@@ -9,7 +9,9 @@ class TestBaseBatteryModel(unittest.TestCase):
     def test_process_parameters_and_discretise(self):
         model = pybamm.ReactionDiffusionModel()
         c = pybamm.Parameter("Negative electrode width [m]") * pybamm.Variable(
-            "Negative electrolyte concentration", domain="negative electrode"
+            "Negative electrolyte concentration",
+            domain="negative electrode",
+            secondary_domain="current collector",
         )
         processed_c = model.process_parameters_and_discretise(c)
         self.assertIsInstance(processed_c, pybamm.Multiplication)

tests/unit/test_models/test_submodels/test_convection/test_full_convection.py

@@ -13,7 +13,9 @@ def test_public_functions(self):
 
         a = pybamm.Scalar(0)
         variables = {
-            "Current collector current density": a,
+            "Current collector current density": pybamm.PrimaryBroadcast(
+                a, "current collector"
+            ),
             "Interfacial current density": a,
         }
         submodel = pybamm.convection.Full(param)

tests/unit/test_models/test_submodels/test_electrolyte/test_stefan_maxwell/test_conductivity/test_composite_stefan_maxwell_conductivity.py

@@ -10,7 +10,7 @@
 class TestComposite(unittest.TestCase):
     def test_public_functions(self):
         param = pybamm.standard_parameters_lithium_ion
-        a = pybamm.Scalar(0)
+        a = pybamm.PrimaryBroadcast(0, "current collector")
         c_e = pybamm.standard_variables.c_e
 
         variables = {

tests/unit/test_models/test_submodels/test_electrolyte/test_stefan_maxwell/test_conductivity/test_full_stefan_maxwell_conductivity.py

@@ -14,11 +14,11 @@ def test_public_functions(self):
         variables = {
             "Porosity": a,
             "Electrolyte concentration": a,
-            "Negative electrode interfacial current density": pybamm.Broadcast(
-                a, "negative electrode"
+            "Negative electrode interfacial current density": pybamm.FullBroadcast(
+                a, "negative electrode", "current collector"
             ),
-            "Positive electrode interfacial current density": pybamm.Broadcast(
-                a, "positive electrode"
+            "Positive electrode interfacial current density": pybamm.FullBroadcast(
+                a, "positive electrode", "current collector"
             ),
             "Cell temperature": a,
         }

tests/unit/test_models/test_submodels/test_electrolyte/test_stefan_maxwell/test_conductivity/test_surface_form/test_full_surface_form_stefan_maxwell_conductivity.py

@@ -11,9 +11,13 @@ class TestFull(unittest.TestCase):
     def test_public_functions(self):
         param = pybamm.standard_parameters_lithium_ion
         a = pybamm.Scalar(0)
-        a_n = pybamm.Broadcast(pybamm.Scalar(0), ["negative electrode"])
-        a_s = pybamm.Broadcast(pybamm.Scalar(0), ["separator"])
-        a_p = pybamm.Broadcast(pybamm.Scalar(0), ["positive electrode"])
+        a_n = pybamm.FullBroadcast(
+            pybamm.Scalar(0), ["negative electrode"], "current collector"
+        )
+        a_s = pybamm.FullBroadcast(pybamm.Scalar(0), ["separator"], "current collector")
+        a_p = pybamm.FullBroadcast(
+            pybamm.Scalar(0), ["positive electrode"], "current collector"
+        )
         variables = {
             "Current collector current density": a,
             "Negative electrode porosity": a_n,

tests/unit/test_models/test_submodels/test_electrolyte/test_stefan_maxwell/test_diffusion/test_full_stefan_maxwell_diffusion.py

@@ -16,14 +16,16 @@ def test_public_functions(self):
             "Porosity change": a,
             "Volume-averaged velocity": a,
             "Electrolyte concentration": a,
-            "Negative electrode interfacial current density": pybamm.Broadcast(
-                a, "negative electrode"
+            "Negative electrode interfacial current density": pybamm.FullBroadcast(
+                a, "negative electrode", "current collector"
             ),
-            "Positive electrode interfacial current density": pybamm.Broadcast(
-                a, "positive electrode"
+            "Positive electrode interfacial current density": pybamm.FullBroadcast(
+                a, "positive electrode", "current collector"
             ),
-            "Cell temperature": pybamm.Broadcast(
-                a, ["negative electrode", "separator", "positive electrode"]
+            "Cell temperature": pybamm.FullBroadcast(
+                a,
+                ["negative electrode", "separator", "positive electrode"],
+                "current collector",
             ),
         }
         icd = " interfacial current density"

tests/unit/test_models/test_submodels/test_oxygen_diffusion/test_full_oxygen_diffusion.py

@@ -13,21 +13,21 @@ def test_public_functions(self):
         a = pybamm.Scalar(0)
         variables = {
             "Porosity": pybamm.Concatenation(
-                pybamm.Broadcast(a, "negative electrode"),
-                pybamm.Broadcast(a, "separator"),
-                pybamm.Broadcast(a, "positive electrode"),
+                pybamm.FullBroadcast(a, "negative electrode", "current collector"),
+                pybamm.FullBroadcast(a, "separator", "current collector"),
+                pybamm.FullBroadcast(a, "positive electrode", "current collector"),
             ),
             "Porosity change": pybamm.Concatenation(
-                pybamm.Broadcast(a, "negative electrode"),
-                pybamm.Broadcast(a, "separator"),
-                pybamm.Broadcast(a, "positive electrode"),
+                pybamm.FullBroadcast(a, "negative electrode", "current collector"),
+                pybamm.FullBroadcast(a, "separator", "current collector"),
+                pybamm.FullBroadcast(a, "positive electrode", "current collector"),
             ),
             "Volume-averaged velocity": a,
-            "Negative electrode interfacial current density": pybamm.Broadcast(
-                a, "negative electrode"
+            "Negative electrode interfacial current density": pybamm.FullBroadcast(
+                a, "negative electrode", "current collector"
             ),
-            "Positive electrode interfacial current density": pybamm.Broadcast(
-                a, "positive electrode"
+            "Positive electrode interfacial current density": pybamm.FullBroadcast(
+                a, "positive electrode", "current collector"
             ),
         }
         reactions = {