api: remove obsolete and clunky is_parameter

Author: mloubout

devito/finite_differences/differentiable.py

@@ -1131,20 +1131,8 @@ def _(expr, x0, **kwargs):
 
 @interp_for_fd.register(AbstractFunction)
 def _(expr, x0, **kwargs):
-    from devito.finite_differences.derivative import Derivative
-    x0_expr = {d: v for d, v in x0.items() if v is not expr.indices_ref[d]}
-    if expr.is_parameter:
-        # Parameter might not have been evaluated at x0 yet
-        # E.g., in expressions such as u[x]*f[x] evaluated at x+dx/2
-        # `f` will not be evaluated at it since gather_for_diff will pick `u` as
-        # higher priority function.
-        for d, v in x0.items():
-            if expr.indices[d] is d:
-                expr = expr._subs(d, v)
-        return expr
-    elif x0_expr:
-        dims = tuple((d, 0) for d in x0_expr)
-        fd_o = tuple([expr.interp_order]*len(dims))
-        return Derivative(expr, *dims, fd_order=fd_o, x0=x0_expr)
+    x0_expr = {d: v for d, v in x0.items() if v.has(d)}
+    if x0_expr:
+        return expr.subs({expr.indices[d]: v for d, v in x0_expr.items()})
     else:
         return expr

devito/types/dense.py

@@ -1019,7 +1019,7 @@ class Function(DiscreteFunction):
     is_autopaddable = True
 
     __rkwargs__ = (DiscreteFunction.__rkwargs__ +
-                   ('space_order', 'interp_order', 'dimensions', 'is_parameter'))
+                   ('space_order', 'interp_order', 'dimensions'))
 
     def _cache_meta(self):
         # Attach additional metadata to self's cache entry
@@ -1060,12 +1060,6 @@ def __init_finalize__(self, *args, **kwargs):
             # can clearly avoid that here though!
             self._fd = self.function._fd
 
-        # Flag whether it is a parameter or a variable.
-        # Used at operator evaluation to evaluate the Function at the
-        # variable location (i.e. if the variable is staggered in x the
-        # parameter has to be computed at x + hx/2)
-        self._is_parameter = kwargs.get('parameter', kwargs.get('is_parameter', False))
-
     def __fd_setup__(self):
         """
         Dynamically add derivative short-cuts.
@@ -1076,12 +1070,8 @@ def __fd_setup__(self):
     def _fd_priority(self):
         return 1 if self.staggered.on_node else 2
 
-    @property
-    def is_parameter(self):
-        return self._is_parameter
-
     def _eval_at(self, func):
-        if not self.is_parameter or self.staggered == func.staggered:
+        if self.staggered == func.staggered:
             return self
         mapper = {self.indices_ref[d]: func.indices_ref[d]
                   for d in self.dimensions

tests/test_derivatives.py

@@ -773,7 +773,7 @@ def test_param_stagg_inner(self):
         xp = x + x.spacing / 2
 
         f = TimeFunction(name="f", grid=grid, space_order=space_order, staggered=y)
-        p = Function(name="p", grid=grid, space_order=space_order, parameter=True)
+        p = Function(name="p", grid=grid, space_order=space_order)
         g = TimeFunction(name="g", grid=grid, space_order=space_order, staggered=(x, y))
 
         eqn = Eq(g, (p * f).dx)
@@ -798,8 +798,8 @@ def test_param_stagg_add(self):
                            time_order=1, staggered=NODE)
         txy = TimeFunction(name="txy", grid=grid, space_order=space_order,
                            time_order=1, staggered=(x, y))
-        c11 = Function(name="c11", grid=grid, space_order=space_order, parameter=True)
-        c66 = Function(name="c66", grid=grid, space_order=space_order, parameter=True)
+        c11 = Function(name="c11", grid=grid, space_order=space_order)
+        c66 = Function(name="c66", grid=grid, space_order=space_order)
 
         eq0 = Eq(vx, (c66 * txy).dy)
         eq1 = Eq(vx, (c11 * txx).dy)

tests/test_differentiable.py

@@ -109,23 +109,23 @@ def test_avg_mode(ndim, io):
 
     with pytest.raises(ValueError):
         # interp_order > space_order
-        Function(name="a", grid=grid, parameter=True, interp_order=8, space_order=4)
+        Function(name="a", grid=grid, interp_order=8, space_order=4)
     with pytest.raises(ValueError):
         # interp_order < 1
-        Function(name="a", grid=grid, parameter=True, interp_order=0, space_order=4)
+        Function(name="a", grid=grid, interp_order=0, space_order=4)
     with pytest.raises(TypeError):
         # interp_order not int
-        Function(name="a", grid=grid, parameter=True, interp_order=2.5, space_order=4)
+        Function(name="a", grid=grid, interp_order=2.5, space_order=4)
 
     a0 = Function(name="a0", grid=grid, **kw)
-    a = Function(name="a", grid=grid, parameter=True, **kw)
-    b = Function(name="b", grid=grid, parameter=True, avg_mode='harmonic', **kw)
+    a = Function(name="a", grid=grid, **kw)
+    b = Function(name="b", grid=grid, avg_mode='harmonic', **kw)
 
     a0_avg = a0._eval_at(v)
     a_avg = a._eval_at(v).evaluate.simplify()
     b_avg = b._eval_at(v).evaluate.simplify()
 
-    assert a0_avg == a0
+    assert a0_avg == a0.subs(v.indices_ref.getters)
 
     # Indices around the point at the center of a cell
     idx = list(range(-io//2 + 1, io//2 + 1))

tests/test_dse.py

@@ -1588,7 +1588,7 @@ def test_extraction_from_lifted_ispace(self, rotate):
         so = 8
         grid = Grid(shape=(6, 6, 6))
 
-        f = Function(name='f', grid=grid, space_order=so, parameter=True)
+        f = Function(name='f', grid=grid, space_order=so)
         v = TimeFunction(name="v", grid=grid, space_order=so)
         v1 = TimeFunction(name="v1", grid=grid, space_order=so)
         p = TimeFunction(name="p", grid=grid, space_order=so, staggered=NODE)

tests/test_staggered_utils.py

@@ -68,7 +68,7 @@ def test_is_param(ndim):
     var = Function(name="f", grid=grid, staggered=NODE)
     for d in dims:
         f = Function(name="f", grid=grid, staggered=d)
-        f2 = Function(name="f2", grid=grid, staggered=d, parameter=True)
+        f2 = Function(name="f2", grid=grid, staggered=d)
 
         # Not a parameter stay untouched (or FD would be destroyed by _eval_at)
         assert f._eval_at(var).evaluate == f
@@ -91,7 +91,7 @@ def test_gather_for_diff(expr, expected):
     y0 = y + y.spacing/2  # noqa
     a = Function(name="a", grid=grid, staggered=NODE)  # noqa
     b = Function(name="b", grid=grid, staggered=x)  # noqa
-    c = Function(name="c", grid=grid, staggered=y, parameter=True)  # noqa
+    c = Function(name="c", grid=grid, staggered=y)  # noqa
     d = Function(name="d", grid=grid)  # noqa
 
     assert eval(expr) == eval(expected)
@@ -143,7 +143,7 @@ def test_staggered_div():
     v[0].data[:] = 5.
     v[1].data[:] = 5.
 
-    A = Function(name="A", grid=grid, space_order=4, staggred=NODE, parameter=True)
+    A = Function(name="A", grid=grid, space_order=4, staggred=NODE)
     A._data_with_outhalo[:] = .5
 
     av = VectorTimeFunction(name="av", grid=grid, time_order=1, space_order=4)