#546 fix unit tests except QuickPlot

pybamm/expression_tree/broadcasts.py

@@ -51,7 +51,10 @@ def __init__(
         self.broadcast_type = broadcast_type
         self.broadcast_domain = broadcast_domain
         if auxiliary_domains is None:
-            auxiliary_domains = {"secondary": child.domain}
+            if child.domain != []:
+                auxiliary_domains = {"secondary": child.domain}
+            else:
+                auxiliary_domains = {}
         super().__init__(name, child, domain, auxiliary_domains)
 
     def check_and_set_domain_and_broadcast_type(
@@ -86,12 +89,16 @@ def check_and_set_domain_and_broadcast_type(
     def _unary_simplify(self, child):
         """ See :meth:`pybamm.UnaryOperator.simplify()`. """
 
-        return Broadcast(child, self.broadcast_domain, self.broadcast_type)
+        return Broadcast(
+            child, self.broadcast_domain, self.auxiliary_domains, self.broadcast_type
+        )
 
     def _unary_new_copy(self, child):
         """ See :meth:`pybamm.UnaryOperator.simplify()`. """
 
-        return Broadcast(child, self.broadcast_domain, self.broadcast_type)
+        return Broadcast(
+            child, self.broadcast_domain, self.auxiliary_domains, self.broadcast_type
+        )
 
     def evaluate_for_shape(self):
         """

pybamm/expression_tree/concatenations.py

@@ -28,6 +28,7 @@ def __init__(self, *children, name=None, check_domain=True, concat_fun=None):
             auxiliary_domains = self.get_children_auxiliary_domains(children)
         else:
             domain = []
+            auxiliary_domains = {}
         self.concatenation_function = concat_fun
         super().__init__(
             name, children, domain=domain, auxiliary_domains=auxiliary_domains

pybamm/models/submodels/particle/fickian/fickian_many_particles.py

@@ -37,13 +37,12 @@ def get_fundamental_variables(self):
     def get_coupled_variables(self, variables):
 
         c_s = variables[self.domain + " particle concentration"]
-        T_k_av = pybamm.PrimaryBroadcast(
+        T_k = pybamm.PrimaryBroadcast(
             variables[self.domain + " electrode temperature"],
             [self.domain.lower() + " particle"],
         )
 
-        # TODO: fix average so can do X-average N_s
-        N_s = self._flux_law(c_s, T_k_av)
+        N_s = self._flux_law(c_s, T_k)
 
         variables.update(self._get_standard_flux_variables(N_s, N_s))
         return variables

tests/unit/test_expression_tree/test_broadcasts.py

@@ -14,21 +14,13 @@ def test_broadcast(self):
         self.assertEqual(broad_a.children[0].name, a.name)
         self.assertEqual(broad_a.domain, ["negative electrode"])
 
-        b = pybamm.Symbol("b", domain=["negative electrode"])
-        with self.assertRaises(pybamm.DomainError):
-            pybamm.Broadcast(b, ["separator"])
-
     def test_broadcast_number(self):
         broad_a = pybamm.Broadcast(1, ["negative electrode"])
         self.assertEqual(broad_a.name, "broadcast")
         self.assertIsInstance(broad_a.children[0], pybamm.Symbol)
         self.assertEqual(broad_a.children[0].evaluate(), np.array([1]))
         self.assertEqual(broad_a.domain, ["negative electrode"])
 
-        b = pybamm.Symbol("b", domain=["negative electrode"])
-        with self.assertRaises(pybamm.DomainError):
-            pybamm.Broadcast(b, ["separator"])
-
     def test_broadcast_type(self):
         a = pybamm.Symbol("a", domain="current collector")
         with self.assertRaisesRegex(ValueError, "Variables on the current collector"):

tests/unit/test_expression_tree/test_copy.py

@@ -1,13 +1,13 @@
 #
-# Test for the Symbol class
+# Test for making copies
 #
 import numpy as np
 import pybamm
 import unittest
 from tests import get_mesh_for_testing
 
 
-class TestSimplify(unittest.TestCase):
+class TestCopy(unittest.TestCase):
     def test_symbol_new_copy(self):
         a = pybamm.Scalar(0)
         b = pybamm.Scalar(1)
@@ -32,7 +32,7 @@ def test_symbol_new_copy(self):
             pybamm.BoundaryValue(v_n, "right"),
             pybamm.BoundaryGradient(v_n, "right"),
             pybamm.PrimaryBroadcast(a, "domain"),
-            pybamm.FullBroadcast(a, "domain", "other domain"),
+            pybamm.FullBroadcast(a, "domain", {"secondary": "other domain"}),
             pybamm.Concatenation(v_n, v_s),
             pybamm.NumpyConcatenation(a, b, v_s),
             pybamm.DomainConcatenation([v_n, v_s], mesh),

tests/unit/test_expression_tree/test_simplify.py

@@ -1,5 +1,5 @@
 #
-# Test for the Symbol class
+# Test for the Simplify class
 #
 import math
 import numpy as np

tests/unit/test_expression_tree/test_symbol.py

@@ -44,6 +44,21 @@ def test_symbol_domains(self):
         with self.assertRaises(TypeError):
             a = pybamm.Symbol("a", domain=1)
 
+    def test_symbol_auxiliary_domains(self):
+        a = pybamm.Symbol(
+            "a",
+            domain="test",
+            auxiliary_domains={"secondary": "sec", "tertiary": "tert"},
+        )
+        self.assertEqual(a.domain, ["test"])
+        self.assertEqual(
+            a.auxiliary_domains, {"secondary": ["sec"], "tertiary": ["tert"]}
+        )
+        a = pybamm.Symbol("a", domain=["t", "e", "s"])
+        self.assertEqual(a.domain, ["t", "e", "s"])
+        with self.assertRaises(TypeError):
+            a = pybamm.Symbol("a", domain=1)
+
     def test_symbol_methods(self):
         a = pybamm.Symbol("a")
         b = pybamm.Symbol("b")
@@ -204,55 +219,56 @@ def test_symbol_repr(self):
         a = pybamm.Symbol("a")
         b = pybamm.Symbol("b")
         c = pybamm.Symbol("c", domain=["test"])
-        d = pybamm.Symbol("d", domain=["test"])
+        d = pybamm.Symbol("d", domain=["test"], auxiliary_domains={"sec": "other test"})
         hex_regex = r"\-?0x[0-9,a-f]+"
         self.assertRegex(
             a.__repr__(),
             r"Symbol\("
             + hex_regex
-            + r", a, children\=\[\], domain\=\[\]\), auxiliary_domain\=\[\]\)",
+            + r", a, children\=\[\], domain\=\[\], auxiliary_domains\=\{\}\)",
         )
         self.assertRegex(
             b.__repr__(),
             r"Symbol\("
             + hex_regex
-            + r", b, children\=\[\], domain\=\[\]\), auxiliary_domain\=\[\]\)",
+            + r", b, children\=\[\], domain\=\[\], auxiliary_domains\=\{\}\)",
         )
         self.assertRegex(
             c.__repr__(),
             r"Symbol\("
             + hex_regex
-            + r", c, children\=\[\], domain\=\['test'\]\), auxiliary_domain\=\[\]\)",
+            + r", c, children\=\[\], domain\=\['test'\], auxiliary_domains\=\{\}\)",
         )
         self.assertRegex(
             d.__repr__(),
             r"Symbol\("
             + hex_regex
-            + r", d, children\=\[\], domain\=\['test'\]\), auxiliary_domain\=\[\]\)",
+            + r", d, children\=\[\], domain\=\['test'\]"
+            + r", auxiliary_domains\=\{'sec': \"\['other test'\]\"\}\)",
         )
         self.assertRegex(
             (a + b).__repr__(),
-            r"Addition\(" + hex_regex + r", \+, children\=\['a', 'b'\], domain=\[\]\)",
+            r"Addition\(" + hex_regex + r", \+, children\=\['a', 'b'\], domain=\[\]",
         )
         self.assertRegex(
             (c * d).__repr__(),
             r"Multiplication\("
             + hex_regex
-            + r", \*, children\=\['c', 'd'\], domain=\['test'\]\)"
-            + r", auxiliary_domain\=\[\]\)",
+            + r", \*, children\=\['c', 'd'\], domain=\['test'\]"
+            + r", auxiliary_domains\=\{'sec': \"\['other test'\]\"\}\)",
         )
         self.assertRegex(
             pybamm.grad(a).__repr__(),
             r"Gradient\("
             + hex_regex
-            + r", grad, children\=\['a'\], domain=\[\]\), auxiliary_domain\=\[\]\)",
+            + r", grad, children\=\['a'\], domain=\[\], auxiliary_domains\=\{\}\)",
         )
         self.assertRegex(
             pybamm.grad(c).__repr__(),
             r"Gradient\("
             + hex_regex
-            + r", grad, children\=\['c'\], domain=\['test'\]\)"
-            + r", auxiliary_domain\=\[\]\)",
+            + r", grad, children\=\['c'\], domain=\['test'\]"
+            + r", auxiliary_domains\=\{\}\)",
         )
 
     def test_symbol_visualise(self):

tests/unit/test_expression_tree/test_unary_operators.py

@@ -57,7 +57,33 @@ def test_integral(self):
         self.assertEqual(inta.name, "integral dx ['negative electrode']")
         self.assertEqual(inta.children[0].name, a.name)
         self.assertEqual(inta.integration_variable[0], x)
-        self.assertEqual(inta.domain, ["current collector"])
+        self.assertEqual(inta.domain, [])
+        self.assertEqual(inta.auxiliary_domains, {})
+        # space integral with secondary domain
+        a_sec = pybamm.Symbol(
+            "a",
+            domain=["negative electrode"],
+            auxiliary_domains={"secondary": "current collector"},
+        )
+        x = pybamm.SpatialVariable("x", ["negative electrode"])
+        inta_sec = pybamm.Integral(a_sec, x)
+        self.assertEqual(inta_sec.domain, ["current collector"])
+        self.assertEqual(inta_sec.auxiliary_domains, {})
+        # space integral with secondary domain
+        a_tert = pybamm.Symbol(
+            "a",
+            domain=["negative electrode"],
+            auxiliary_domains={
+                "secondary": "current collector",
+                "tertiary": "some extra domain",
+            },
+        )
+        x = pybamm.SpatialVariable("x", ["negative electrode"])
+        inta_tert = pybamm.Integral(a_tert, x)
+        self.assertEqual(inta_tert.domain, ["current collector"])
+        self.assertEqual(
+            inta_tert.auxiliary_domains, {"secondary": ["some extra domain"]}
+        )
 
         # space integral over two variables
         b = pybamm.Symbol("b", domain=["current collector"])
@@ -76,6 +102,11 @@ def test_integral(self):
         self.assertEqual(inta.children[0].name, a.name)
         self.assertEqual(inta.integration_variable[0], x)
         self.assertEqual(inta.domain, ["negative electrode"])
+        inta_sec = pybamm.IndefiniteIntegral(a_sec, x)
+        self.assertEqual(inta_sec.domain, ["negative electrode"])
+        self.assertEqual(
+            inta_sec.auxiliary_domains, {"secondary": ["current collector"]}
+        )
 
         # expected errors
         a = pybamm.Symbol("a", domain=["negative electrode"])
@@ -175,7 +206,26 @@ def test_boundary_value(self):
         boundary_a = pybamm.boundary_value(a, "right")
         self.assertIsInstance(boundary_a, pybamm.BoundaryValue)
         self.assertEqual(boundary_a.side, "right")
-        self.assertEqual(boundary_a.domain, ["current collector"])
+        self.assertEqual(boundary_a.domain, [])
+        self.assertEqual(boundary_a.auxiliary_domains, {})
+        # test with secondary domain
+        a_sec = pybamm.Symbol(
+            "a",
+            domain=["separator"],
+            auxiliary_domains={"secondary": "current collector"},
+        )
+        boundary_a_sec = pybamm.boundary_value(a_sec, "right")
+        self.assertEqual(boundary_a_sec.domain, ["current collector"])
+        self.assertEqual(boundary_a_sec.auxiliary_domains, {})
+        # test with secondary domain and tertiary domain
+        a_tert = pybamm.Symbol(
+            "a",
+            domain=["separator"],
+            auxiliary_domains={"secondary": "current collector", "tertiary": "bla"},
+        )
+        boundary_a_tert = pybamm.boundary_value(a_tert, "right")
+        self.assertEqual(boundary_a_tert.domain, ["current collector"])
+        self.assertEqual(boundary_a_tert.auxiliary_domains, {"secondary": ["bla"]})
 
     def test_average(self):
         a = pybamm.Scalar(1)
@@ -185,13 +235,12 @@ def test_average(self):
         average_broad_a = pybamm.x_average(pybamm.Broadcast(a, ["negative electrode"]))
         self.assertEqual(average_broad_a.evaluate(), np.array([1]))
 
-        average_conc_broad = pybamm.x_average(
-            pybamm.Concatenation(
-                pybamm.Broadcast(1, ["negative electrode"]),
-                pybamm.Broadcast(2, ["separator"]),
-                pybamm.Broadcast(3, ["positive electrode"]),
-            )
+        conc_broad = pybamm.Concatenation(
+            pybamm.Broadcast(1, ["negative electrode"]),
+            pybamm.Broadcast(2, ["separator"]),
+            pybamm.Broadcast(3, ["positive electrode"]),
         )
+        average_conc_broad = pybamm.x_average(conc_broad)
         self.assertIsInstance(average_conc_broad, pybamm.Division)
 
         for domain in [
@@ -207,7 +256,7 @@ def test_average(self):
             self.assertIsInstance(av_a.children[0], pybamm.Integral)
             self.assertEqual(av_a.children[0].integration_variable[0].domain, x.domain)
             # electrode domains go to current collector when averaged
-            self.assertEqual(av_a.domain, ["current collector"])
+            self.assertEqual(av_a.domain, [])
 
         a = pybamm.Symbol("a", domain="bad domain")
         with self.assertRaises(pybamm.DomainError):

tests/unit/test_models/test_submodels/test_particle/test_fickian/test_fickian_many_particles.py

@@ -11,13 +11,16 @@ class TestManyParticles(unittest.TestCase):
     def test_public_functions(self):
         param = pybamm.standard_parameters_lithium_ion
 
-        a = pybamm.Scalar(0)
-        a_n = pybamm.Broadcast(0, ["negative electrode"])
-        a_p = pybamm.Broadcast(0, ["positive electrode"])
+        a_n = pybamm.FullBroadcast(
+            pybamm.Scalar(0), "negative electrode", {"secondary": "current collector"}
+        )
+        a_p = pybamm.FullBroadcast(
+            pybamm.Scalar(0), "positive electrode", {"secondary": "current collector"}
+        )
 
         variables = {
             "Negative electrode interfacial current density": a_n,
-            "Average negative electrode temperature": a,
+            "Negative electrode temperature": a_n,
         }
 
         submodel = pybamm.particle.fickian.ManyParticles(param, "Negative")
@@ -26,7 +29,7 @@ def test_public_functions(self):
 
         variables = {
             "Positive electrode interfacial current density": a_p,
-            "Average positive electrode temperature": a,
+            "Positive electrode temperature": a_p,
         }
         submodel = pybamm.particle.fickian.ManyParticles(param, "Positive")
         std_tests = tests.StandardSubModelTests(submodel, variables)

tests/unit/test_models/test_submodels/test_particle/test_fickian/test_fickian_single_particle.py

@@ -11,7 +11,7 @@ class TestSingleParticle(unittest.TestCase):
     def test_public_functions(self):
         param = pybamm.standard_parameters_lithium_ion
 
-        a = pybamm.Scalar(0)
+        a = pybamm.PrimaryBroadcast(pybamm.Scalar(0), "current collector")
         variables = {
             "Average negative electrode interfacial current density": a,
             "Average negative electrode temperature": a,

tests/unit/test_spatial_methods/test_finite_volume.py

@@ -171,7 +171,7 @@ def test_extrapolate_2d_models(self):
         extrap_right = pybamm.BoundaryValue(var, "right")
         disc.set_variable_slices([var])
         extrap_right_disc = disc.process_symbol(extrap_right)
-        self.assertEqual(extrap_right_disc.domain, ["current collector"])
+        self.assertEqual(extrap_right_disc.domain, [])
 
     def test_discretise_diffusivity_times_spatial_operator(self):
         # Set up