#580 coverage

CHANGELOG.md

@@ -2,19 +2,21 @@
 
 ## Features
 
-- Add method to evaluate parameters more easily (#669 )
-- Add `Interpolant` class to interpolate experimental data (e.g. OCP curves) (#661 )
-- Allow parameters to be set by material or by specifying a particular paper (#647 )
-- Set relative and absolute tolerances independently in solvers (#645 )
-- Add some non-uniform meshes in 1D and 2D (#617 )
+- Add method to evaluate parameters more easily ([#669](https://github.com/pybamm-team/PyBaMM/pull/669))
+- Add `Interpolant` class to interpolate experimental data (e.g. OCP curves) ([#661](https://github.com/pybamm-team/PyBaMM/pull/661))
+- Allow parameters to be set by material or by specifying a particular paper ([#647](https://github.com/pybamm-team/PyBaMM/pull/647))
+- Set relative and absolute tolerances independently in solvers ([#645](https://github.com/pybamm-team/PyBaMM/pull/645))
+- Add some non-uniform meshes in 1D and 2D ([#617](https://github.com/pybamm-team/PyBaMM/pull/617))
 
 ## Optimizations
 
-- Avoid re-checking size when making a copy of an `Index` object (#656 )
-- Avoid recalculating `_evaluation_array` when making a copy of a `StateVector` object (#653 )
+- Avoid re-checking size when making a copy of an `Index` object ([#656](https://github.com/pybamm-team/PyBaMM/pull/656))
+- Avoid recalculating `_evaluation_array` when making a copy of a `StateVector` object ([#653](https://github.com/pybamm-team/PyBaMM/pull/653))
 
 ## Bug fixes
 
+- Improve the way `ProcessedVariable` objects are created in higher dimensions ([#581](https://github.com/pybamm-team/PyBaMM/pull/581))
+
 # [v0.1.0](https://github.com/pybamm-team/PyBaMM/tree/v0.1.0) - 2019-10-08
 
 This is the first official version of PyBaMM.

pybamm/expression_tree/array.py

@@ -19,19 +19,30 @@ class Array(pybamm.Symbol):
         the name of the node
     domain : iterable of str, optional
         list of domains the parameter is valid over, defaults to empty list
+    auxiliary_domainds : dict, optional
+        dictionary of auxiliary domains, defaults to empty dict
+    entries_string : str
+        String representing the entries (slow to recalculate when copying)
 
     *Extends:* :class:`Symbol`
     """
 
-    def __init__(self, entries, name=None, domain=[], entries_string=None):
+    def __init__(
+        self,
+        entries,
+        name=None,
+        domain=None,
+        auxiliary_domains=None,
+        entries_string=None,
+    ):
         if entries.ndim == 1:
             entries = entries[:, np.newaxis]
         if name is None:
             name = "Array of shape {!s}".format(entries.shape)
         self._entries = entries
         # Use known entries string to avoid re-hashing, where possible
         self.entries_string = entries_string
-        super().__init__(name, domain=domain)
+        super().__init__(name, domain=domain, auxiliary_domains=auxiliary_domains)
 
     @property
     def entries(self):
@@ -73,7 +84,13 @@ def set_id(self):
 
     def new_copy(self):
         """ See :meth:`pybamm.Symbol.new_copy()`. """
-        return self.__class__(self.entries, self.name, self.domain, self.entries_string)
+        return self.__class__(
+            self.entries,
+            self.name,
+            self.domain,
+            self.auxiliary_domains,
+            self.entries_string,
+        )
 
     def _base_evaluate(self, t=None, y=None):
         """ See :meth:`pybamm.Symbol._base_evaluate()`. """

pybamm/expression_tree/matrix.py

@@ -11,19 +11,18 @@ class Matrix(pybamm.Array):
 
     **Extends:** :class:`Array`
 
-    Parameters
-    ----------
-
-    entries : numpy.array
-        the array associated with the node
-    name : str, optional
-        the name of the node
-
     """
 
-    def __init__(self, entries, name=None, domain=[], entries_string=None):
+    def __init__(
+        self,
+        entries,
+        name=None,
+        domain=None,
+        auxiliary_domains=None,
+        entries_string=None,
+    ):
         if name is None:
             name = "Matrix {!s}".format(entries.shape)
             if issparse(entries):
                 name = "Sparse " + name
-        super().__init__(entries, name, domain, entries_string)
+        super().__init__(entries, name, domain, auxiliary_domains, entries_string)

pybamm/expression_tree/vector.py

@@ -12,19 +12,16 @@ class Vector(pybamm.Array):
 
     **Extends:** :class:`Array`
 
-    Parameters
-    ----------
-
-    entries : numpy.array
-        the array associated with the node
-    name : str, optional
-        the name of the node
-    domain : iterable of str, optional
-        list of domains the parameter is valid over, defaults to empty list
-
     """
 
-    def __init__(self, entries, name=None, domain=[], entries_string=None):
+    def __init__(
+        self,
+        entries,
+        name=None,
+        domain=None,
+        auxiliary_domains=None,
+        entries_string=None,
+    ):
         # make sure that entries are a vector (can be a column vector)
         if entries.ndim == 1:
             entries = entries[:, np.newaxis]
@@ -39,7 +36,7 @@ def __init__(self, entries, name=None, domain=[], entries_string=None):
         if name is None:
             name = "Column vector of length {!s}".format(entries.shape[0])
 
-        super().__init__(entries, name, domain, entries_string)
+        super().__init__(entries, name, domain, auxiliary_domains, entries_string)
 
     def _jac(self, variable):
         """ See :meth:`pybamm.Symbol._jac()`. """

pybamm/processed_variable.py

@@ -408,21 +408,12 @@ def __call__(self, t=None, x=None, r=None, y=None, z=None):
     def call_2D(self, t, x, r, z):
         "Evaluate a 2D variable"
         spatial_var = eval_dimension_name(self.spatial_var_name, x, r, None, z)
-        if spatial_var is not None:
-            return self._interpolation_function(t, spatial_var)
-        else:
-            raise ValueError("input {} cannot be None".format(self.spatial_var_name))
+        return self._interpolation_function(t, spatial_var)
 
     def call_3D(self, t, x, r, y, z):
         "Evaluate a 3D variable"
         first_dim = eval_dimension_name(self.first_dimension, x, r, y, z)
         second_dim = eval_dimension_name(self.second_dimension, x, r, y, z)
-        if first_dim is None or second_dim is None:
-            raise ValueError(
-                "inputs {} and {} cannot be None".format(
-                    self.first_dimension, self.second_dimension
-                )
-            )
         if isinstance(first_dim, np.ndarray):
             if isinstance(second_dim, np.ndarray) and isinstance(t, np.ndarray):
                 first_dim = first_dim[:, np.newaxis, np.newaxis]
@@ -438,10 +429,15 @@ def call_3D(self, t, x, r, y, z):
 
 def eval_dimension_name(name, x, r, y, z):
     if name == "x":
-        return x
+        out = x
     elif name == "r":
-        return r
+        out = r
     elif name == "y":
-        return y
+        out = y
     elif name == "z":
-        return z
+        out = z
+
+    if out is None:
+        raise ValueError("inputs {} cannot be None".format(name))
+    else:
+        return out

tests/unit/test_processed_variable.py

@@ -126,6 +126,18 @@ def test_processed_variable_3D_x_z(self):
             np.reshape(y_sol, [len(x_sol), len(z_sol), len(t_sol)]),
         )
 
+        # On edges
+        x_s_edge = pybamm.Matrix(
+            np.repeat(disc.mesh["separator"][0].edges, len(z_sol)),
+            domain="separator",
+            auxiliary_domains={"secondary": "current collector"},
+        )
+        processed_x_s_edge = pybamm.ProcessedVariable(x_s_edge, t_sol, y_sol, disc.mesh)
+        np.testing.assert_array_equal(
+            x_s_edge.entries[:, 0],
+            processed_x_s_edge.entries[:, :, 0].reshape(-1, 1)[:, 0],
+        )
+
     def test_processed_variable_3D_scikit(self):
         var = pybamm.Variable("var", domain=["current collector"])
         y = pybamm.SpatialVariable("y", domain=["current collector"])