Drop sumpy.kernel.DirectionalTargetDerivative

Closes gh-228

Author: inducer

examples/curve-pot.py

@@ -37,10 +37,6 @@ def process_kernel(knl, what_operator):
     elif what_operator == "D":
         from sumpy.kernel import DirectionalSourceDerivative
         source_knl = DirectionalSourceDerivative(knl)
-    # DirectionalTargetDerivative (temporarily?) removed
-    # elif what_operator == "S'":
-    #     from sumpy.kernel import DirectionalTargetDerivative
-    #     knl = DirectionalTargetDerivative(knl)
     else:
         raise RuntimeError(f"unrecognized operator '{what_operator}'")
 

sumpy/expansion/multipole.py

@@ -101,10 +101,9 @@ def evaluate(self, kernel, coeffs, bvec, rscale, sac=None):
             rscale = 1
 
         base_taker = kernel.get_derivative_taker(bvec, rscale, sac)
-        # Following is a no-op, but AxisTargetDerivative.postprocess_at_target and
-        # DirectionalTargetDerivative.postprocess_at_target only handles
-        # DifferentiatedExprDerivativeTaker and sympy expressions, so we need to
-        # make the taker a DifferentitatedExprDerivativeTaker instance.
+        # Following is a no-op, but AxisTargetDerivative.postprocess_at_target
+        # only handles DifferentiatedExprDerivativeTaker and sympy expressions,
+        # so we need to make the taker a DifferentitatedExprDerivativeTaker instance.
         base_taker = DifferentiatedExprDerivativeTaker(base_taker,
                 {tuple([0]*self.dim): 1})
         taker = kernel.postprocess_at_target(base_taker, bvec)

sumpy/kernel.py

@@ -130,10 +130,6 @@
 .. autoclass:: DirectionalSourceDerivative
     :show-inheritance:
     :members: mapper_method,directional_kind
-.. autoclass:: DirectionalTargetDerivative
-    :show-inheritance:
-    :undoc-members:
-    :members: mapper_method,directional_kind,target_array_name
 
 Transforming kernels
 --------------------
@@ -1351,86 +1347,6 @@ def replace_inner_kernel(self, new_inner_kernel: Kernel) -> Kernel:
         return type(self)(new_inner_kernel, dir_vec_name=self.dir_vec_name)
 
 
-class DirectionalTargetDerivative(DirectionalDerivative):
-    mapper_method: ClassVar[str] = "map_directional_target_derivative"
-    directional_kind: ClassVar[Literal["src", "tgt"]] = "tgt"
-    target_array_name: ClassVar[str] = "targets"
-
-    @override
-    def get_code_transformer(self) -> Callable[[Expression], Expression]:
-        from sumpy.codegen import VectorComponentRewriter
-        vcr = VectorComponentRewriter(frozenset([self.dir_vec_name]))
-        via = _VectorIndexAdder(self.dir_vec_name, (prim.Variable("itgt"),))
-
-        inner_transform = self.inner_kernel.get_code_transformer()
-
-        def transform(expr: Expression) -> Expression:
-            return via(vcr(inner_transform(expr)))
-
-        return transform
-
-    @overload
-    def postprocess_at_target(
-            self, expr: sym.Expr, bvec: sp.Matrix,
-        ) -> sym.Expr: ...
-
-    @overload
-    def postprocess_at_target(
-            self, expr: ExprDerivativeTaker, bvec: sp.Matrix,
-        ) -> DifferentiatedExprDerivativeTaker: ...
-
-    @override
-    def postprocess_at_target(
-            self, expr: sym.Expr | ExprDerivativeTaker, bvec: sp.Matrix,
-        ) -> sym.Expr | DifferentiatedExprDerivativeTaker:
-        dir_vec = sym.make_sym_vector(self.dir_vec_name, self.dim)
-        target_vec = sym.make_sym_vector(self.target_array_name, self.dim)
-
-        inner_expr = self.inner_kernel.postprocess_at_target(expr, bvec)
-
-        # bvec = tgt - center
-        if not isinstance(inner_expr, DifferentiatedExprDerivativeTaker):
-            result = 0
-            for axis in range(self.dim):
-                # Since `bvec` and `tgt` are two different symbolic variables
-                # need to differentiate by both to get the correct answer
-                result += (
-                    (inner_expr.diff(bvec[axis]) + inner_expr.diff(target_vec[axis]))
-                    * dir_vec[axis])
-
-            assert isinstance(result, sym.Expr)
-            return result
-
-        new_transformation: DerivativeCoeffDict = defaultdict(lambda: 0)
-        for axis in range(self.dim):
-            axis_transformation = diff_derivative_coeff_dict(
-                    inner_expr.derivative_coeff_dict, axis, target_vec)
-            for mi, coeff in axis_transformation.items():
-                new_transformation[mi] += coeff * dir_vec[axis]
-
-        return DifferentiatedExprDerivativeTaker(
-            inner_expr.taker, dict(new_transformation))
-
-    @override
-    def get_args(self) -> Sequence[KernelArgument]:
-        return [
-            KernelArgument(
-                loopy_arg=lp.GlobalArg(
-                    self.dir_vec_name,
-                    None,
-                    shape=(self.dim, "ntargets"),
-                    offset=lp.auto
-                ),
-            ),
-            *self.inner_kernel.get_args()
-        ]
-
-    @override
-    def prepare_loopy_kernel(self, loopy_knl: lp.TranslationUnit) -> lp.TranslationUnit:
-        loopy_knl = self.inner_kernel.prepare_loopy_kernel(loopy_knl)
-        return lp.tag_array_axes(loopy_knl, self.dir_vec_name, "sep,C")
-
-
 class DirectionalSourceDerivative(DirectionalDerivative):
     mapper_method: ClassVar[str] = "map_directional_source_derivative"
     directional_kind: ClassVar[Literal["src", "tgt"]] = "src"

sumpy/qbx.py

@@ -516,7 +516,6 @@ def find_jump_term(kernel, arg_provider):
         AxisTargetDerivative,
         DerivativeBase,
         DirectionalSourceDerivative,
-        DirectionalTargetDerivative,
     )
 
     tgt_derivatives = []
@@ -526,9 +525,6 @@ def find_jump_term(kernel, arg_provider):
         if isinstance(kernel, AxisTargetDerivative):
             tgt_derivatives.append(kernel.axis)
             kernel = kernel.kernel
-        elif isinstance(kernel, DirectionalTargetDerivative):
-            tgt_derivatives.append(kernel.dir_vec_name)
-            kernel = kernel.kernel
         elif isinstance(kernel, AxisSourceDerivative):
             src_derivatives.append(kernel.axis)
             kernel = kernel.kernel

sumpy/tools.py

@@ -320,7 +320,7 @@ def __init__(self, ctx: cl.Context,
             device: Any | None = None) -> None:
         """
         :arg target_kernels: list of :class:`~sumpy.kernel.Kernel` instances,
-            with :class:`sumpy.kernel.DirectionalTargetDerivative` as
+            with :class:`sumpy.kernel.AxisTargetDerivative` as
             the outermost kernel wrappers, if present.
         :arg source_kernels: list of :class:`~sumpy.kernel.Kernel` instances
             with :class:`~sumpy.kernel.DirectionalSourceDerivative` as the