Merge pull request #2714 from devitocodes/JDBetteridge/derivative_hotfix

dsl: JDBetteridge/derivative hotfix

Author: mloubout

devito/finite_differences/derivative.py

@@ -5,15 +5,16 @@
 
 import sympy
 
-from .finite_difference import generic_derivative, cross_derivative
-from .differentiable import Differentiable, diffify, interp_for_fd, Add, Mul
-from .tools import direct, transpose
-from .rsfd import d45
-from devito.tools import (as_mapper, as_tuple, frozendict, is_integer,
-                          Pickable)
+from devito.tools import Pickable, as_mapper, as_tuple, frozendict, is_integer
+from devito.types.dimension import Dimension
 from devito.types.utils import DimensionTuple
 from devito.warnings import warn
 
+from .differentiable import Add, Differentiable, Mul, diffify, interp_for_fd
+from .finite_difference import cross_derivative, generic_derivative
+from .rsfd import d45
+from .tools import direct, transpose
+
 __all__ = ['Derivative']
 
 
@@ -101,14 +102,30 @@ def __new__(cls, expr, *dims, **kwargs):
         # Count the derivatives w.r.t. each variable
         dcounter = cls._count_derivatives(deriv_order, dims)
 
-        # It's possible that the expr is a `sympy.Number` at this point, which
+        # It is possible that the expr is a `sympy.Number` at this point, which
         # has derivative 0, unless we're taking a 0th derivative.
         if isinstance(expr, sympy.Number):
             if any(dcounter.values()):
                 return 0
             else:
                 return expr
 
+        # It is also possible that the expression itself is just a
+        # `devito.Dimension` type which is:
+        #   - derivative 1 if the Dimension coincides and the number of derivatives
+        #     is 1 ie: `Derivative(x, (x, 1)) == 1`.
+        #   - derivative 0 if the Dimension coincides and the total number of
+        #     derivatives is greater than 1 ie: `Derivative(x, (x, 2)) == 0` and
+        #     `Derivative(x, x, y) == 0`.
+        #   - An unevaluated expression otherwise.
+        if isinstance(expr, Dimension) and expr in dcounter:
+            if dcounter[expr] == 0:
+                pass
+            elif dcounter.pop(expr) == 1 and not dcounter:
+                return 1
+            else:
+                return 0
+
         # Validate the finite difference order `fd_order`
         fd_order = cls._validate_fd_order(kwargs.get('fd_order'), expr, dims, dcounter)
 
@@ -232,7 +249,11 @@ def _validate_fd_order(fd_order, expr, dims, dcounter):
         Required: `expr`, `dims`, and the derivative counter to validate.
         If not provided, the maximum supported order will be used.
         """
-        if fd_order is not None:
+        if isinstance(expr, Dimension):
+            # If the expression is just a dimension `expr.time_order` and
+            # `expr.space_order` are not defined
+            fd_order = (99,)*len(dcounter)
+        elif fd_order is not None:
             # If `fd_order` is specified, then validate
             fcounter = defaultdict(int)
             # First create a dictionary mapping variable wrt which to differentiate

tests/test_derivatives.py

@@ -1250,3 +1250,37 @@ def test_fallback_wrong_custom_size(self):
         exp1 = - .5 * (v._subs(x, x - x.spacing) - v._subs(x, x + x.spacing))/x.spacing
         assert simplify(eq0.rhs - exp0) == 0
         assert simplify(eq1.rhs - exp1) == 0
+
+
+class TestDimension:
+    """
+    Check the few cases where differentiating a dimension is allowed work correctly
+    and errors are raised otherwise.
+    """
+
+    @classmethod
+    def setup_class(cls):
+        cls.grid = Grid(shape=(11, 11), extent=(1, 1))
+        cls.x, cls.y = cls.grid.dimensions
+        u = TimeFunction(name='u', grid=cls.grid, space_order=1)
+        cls.t = u.time_dim
+
+    def test_constant(self):
+        assert Derivative(self.x, self.x) == 1
+
+    def test_null(self):
+        assert Derivative(self.x, (self.x, 2)) == 0
+        assert Derivative(self.x, self.x, self.y) == 0
+        assert Derivative(self.x, self.x, self.y) == 0
+        assert Derivative(self.x, self.x, self.y, self.t) == 0
+        assert Derivative(self.x, self.y, self.t, self.x) == 0
+        assert Derivative(self.x, self.y, self.t, (self.x, 2)) == 0
+
+    def test_unevaluated(self):
+        """
+        The following should all be instantiatible without raising an
+        exception, but should not simplify.
+        """
+        assert Derivative(self.x, self.t)
+        assert Derivative(self.x, self.y, self.t)
+        assert Derivative(self.x, (self.x, 0))