From cf4f3820d07389d63fb9ce79b06d4c45b7ac0034 Mon Sep 17 00:00:00 2001
From: Isuru Fernando <idf2@illinois.edu>
Date: Thu, 14 Jan 2021 23:08:46 -0600
Subject: [PATCH] Add a test for simpler, but slower version of l2l and m2m

---
 sumpy/expansion/local.py     |  4 +--
 sumpy/expansion/multipole.py |  4 +--
 test/test_kernels.py         | 55 ++++++++++++++++++++++++++++++++++++
 3 files changed, 59 insertions(+), 4 deletions(-)

diff --git a/sumpy/expansion/local.py b/sumpy/expansion/local.py
index ba95f2bb..5d5550d5 100644
--- a/sumpy/expansion/local.py
+++ b/sumpy/expansion/local.py
@@ -141,7 +141,7 @@ class VolumeTaylorLocalExpansionBase(LocalExpansionBase):
                     evaluated_coeffs, self.get_full_coefficient_identifiers()))
 
     def translate_from(self, src_expansion, src_coeff_exprs, src_rscale,
-            dvec, tgt_rscale, sac=None):
+            dvec, tgt_rscale, sac=None, _fast_version=True):
         logger.info("building translation operator: %s(%d) -> %s(%d): start"
                 % (type(src_expansion).__name__,
                     src_expansion.order,
@@ -329,7 +329,7 @@ class VolumeTaylorLocalExpansionBase(LocalExpansionBase):
                         * rscale_ratio ** sum(mi)
 
         # {{{ simpler, functionally equivalent code
-        if 0:
+        if not _fast_version:
             # Rscale/operand magnitude is fairly sensitive to the order of
             # operations--which is something we don't have fantastic control
             # over at the symbolic level. Scaling dvec, then differentiating,
diff --git a/sumpy/expansion/multipole.py b/sumpy/expansion/multipole.py
index fbc6c51b..5723bd2a 100644
--- a/sumpy/expansion/multipole.py
+++ b/sumpy/expansion/multipole.py
@@ -143,7 +143,7 @@ class VolumeTaylorMultipoleExpansionBase(MultipoleExpansionBase):
         return MiDerivativeTaker(self.kernel.get_expression(bvec), bvec)
 
     def translate_from(self, src_expansion, src_coeff_exprs, src_rscale,
-            dvec, tgt_rscale, sac=None):
+            dvec, tgt_rscale, sac=None, _fast_version=True):
         if not isinstance(src_expansion, type(self)):
             raise RuntimeError("do not know how to translate %s to "
                     "Taylor multipole expansion"
@@ -330,7 +330,7 @@ class VolumeTaylorMultipoleExpansionBase(MultipoleExpansionBase):
                 result[i] += cur_dim_output_coeffs[i]
 
         # {{{ simpler, functionally equivalent code
-        if 0:
+        if not _fast_version:
             src_mi_to_index = dict((mi, i) for i, mi in enumerate(
                 src_expansion.get_coefficient_identifiers()))
             result = [0] * len(self.get_full_coefficient_identifiers())
diff --git a/test/test_kernels.py b/test/test_kernels.py
index f8d5122d..076fb22b 100644
--- a/test/test_kernels.py
+++ b/test/test_kernels.py
@@ -626,6 +626,61 @@ def test_translations(ctx_factory, knl, local_expn_class, mpole_expn_class):
         verifier()
 
 
+@pytest.mark.parametrize("order", [4])
+@pytest.mark.parametrize(("base_knl", "local_expn_class", "mpole_expn_class"), [
+    (LaplaceKernel(2), VolumeTaylorLocalExpansion, VolumeTaylorMultipoleExpansion),
+    ])
+@pytest.mark.parametrize("with_source_derivative", [
+    False,
+    True
+    ])
+def test_m2m_and_l2l_exprs_simpler(base_knl, local_expn_class, mpole_expn_class,
+        order, with_source_derivative):
+
+    from sympy.core.cache import clear_cache
+    clear_cache()
+
+    np.random.seed(17)
+
+    extra_kwargs = {}
+    if isinstance(base_knl, HelmholtzKernel):
+        if base_knl.allow_evanescent:
+            extra_kwargs["k"] = 0.2 * (0.707 + 0.707j)
+        else:
+            extra_kwargs["k"] = 0.2
+    if isinstance(base_knl, StokesletKernel):
+        extra_kwargs["mu"] = 0.2
+
+    if with_source_derivative:
+        knl = DirectionalSourceDerivative(base_knl, "dir_vec")
+    else:
+        knl = base_knl
+
+    mpole_expn = mpole_expn_class(knl, order=order)
+    local_expn = local_expn_class(knl, order=order)
+
+    from sumpy.symbolic import make_sym_vector, Symbol
+    dvec = make_sym_vector("d", knl.dim)
+    src_coeff_exprs = [Symbol("src_coeff%d" % i) for i in range(len(mpole_expn))]
+
+    src_rscale = 3
+    tgt_rscale = 2
+
+    faster_m2m = mpole_expn.translate_from(mpole_expn, src_coeff_exprs, src_rscale,
+            dvec, tgt_rscale)
+    slower_m2m = mpole_expn.translate_from(mpole_expn, src_coeff_exprs, src_rscale,
+            dvec, tgt_rscale, _fast_version=False)
+    for expr1, expr2 in zip(faster_m2m, slower_m2m):
+        assert float((expr1 - expr2).expand()) == 0.0
+
+    faster_l2l = local_expn.translate_from(local_expn, src_coeff_exprs, src_rscale,
+            dvec, tgt_rscale)
+    slower_l2l = local_expn.translate_from(local_expn, src_coeff_exprs, src_rscale,
+            dvec, tgt_rscale, _fast_version=False)
+    for expr1, expr2 in zip(faster_l2l, slower_l2l):
+        assert float((expr1 - expr2).expand()) == 0.0
+
+
 # You can test individual routines by typing
 # $ python test_kernels.py 'test_p2p(cl.create_some_context)'
 
-- 
GitLab