From 26cba1dd4b7afc3209d605a121a35bb1fd5dd8ff Mon Sep 17 00:00:00 2001 From: Isuru Fernando Date: Sun, 3 May 2020 22:57:29 -0500 Subject: [PATCH] Get tests to pass --- sumpy/e2p.py | 10 +++++----- sumpy/expansion/local.py | 18 +++++++++++------- sumpy/expansion/multipole.py | 34 +++++++++++++++++++++++----------- sumpy/kernel.py | 11 +++++------ sumpy/symbolic.py | 4 ++-- sumpy/tools.py | 16 +++++++--------- test/test_kernels.py | 2 +- 7 files changed, 54 insertions(+), 41 deletions(-) diff --git a/sumpy/e2p.py b/sumpy/e2p.py index 2dad9828..fb5d323c 100644 --- a/sumpy/e2p.py +++ b/sumpy/e2p.py @@ -91,12 +91,12 @@ class E2PBase(KernelCacheWrapper): coeff_exprs = [sym.Symbol("coeff%d" % i) for i in range(len(self.expansion.get_coefficient_identifiers()))] - value = self.expansion.evaluate(coeff_exprs, bvec, rscale) - result_names = [ - sac.assign_unique("result_%d_p" % i, value) - for i, knl in enumerate(self.kernels) - ] + result_names = [] + for i, knl in enumerate(self.kernels): + value = self.expansion.evaluate(coeff_exprs, bvec, rscale, knl=knl) + name = sac.assign_unique("result_%d_p" % i, value) + result_names.append(name) sac.run_global_cse() diff --git a/sumpy/expansion/local.py b/sumpy/expansion/local.py index 369307db..5db686dc 100644 --- a/sumpy/expansion/local.py +++ b/sumpy/expansion/local.py @@ -102,7 +102,7 @@ class LineTaylorLocalExpansion(LocalExpansionBase): .subs("tau", 0) for i in self.get_coefficient_identifiers()] - def evaluate(self, coeffs, bvec, rscale): + def evaluate(self, coeffs, bvec, rscale, knl=None): # no point in heeding rscale here--just ignore it from pytools import factorial return sym.Add(*( @@ -132,22 +132,24 @@ class VolumeTaylorLocalExpansionBase(LocalExpansionBase): return result - def evaluate(self, coeffs, bvec, rscale): + def evaluate(self, coeffs, bvec, rscale, knl=None): evaluated_coeffs = ( self.expansion_terms_wrangler.get_full_kernel_derivatives_from_stored( coeffs, rscale)) - bvec = [b*rscale**-1 for b in bvec] + bvec_scaled = [b*rscale**-1 for b in bvec] from sumpy.tools import mi_power, mi_factorial result = sum( coeff - * mi_power(bvec, mi, evaluate=False) + * mi_power(bvec_scaled, mi, evaluate=False) / mi_factorial(mi) for coeff, mi in zip( evaluated_coeffs, self.get_full_coefficient_identifiers())) - return self.kernel.postprocess_at_target(result, bvec) + if knl is None: + knl = self.kernel + return knl.postprocess_at_target(result, bvec) def translate_from(self, src_expansion, src_coeff_exprs, src_rscale, dvec, tgt_rscale, use_fft=False): @@ -404,9 +406,11 @@ class _FourierBesselLocalExpansion(LocalExpansionBase): * sym.exp(sym.I * l * source_angle_rel_center), avec) for l in self.get_coefficient_identifiers()] - def evaluate(self, coeffs, bvec, rscale): + def evaluate(self, coeffs, bvec, rscale, knl=None): if not self.use_rscale: rscale = 1 + if knl is None: + knl = self.kernel from sumpy.symbolic import sym_real_norm_2 bessel_j = sym.Function("bessel_j") @@ -416,7 +420,7 @@ class _FourierBesselLocalExpansion(LocalExpansionBase): arg_scale = self.get_bessel_arg_scaling() return sum(coeffs[self.get_storage_index(l)] - * self.kernel.postprocess_at_target( + * knl.postprocess_at_target( bessel_j(l, arg_scale * bvec_len) / rscale ** abs(l) * sym.exp(sym.I * l * -target_angle_rel_center), bvec) diff --git a/sumpy/expansion/multipole.py b/sumpy/expansion/multipole.py index 0ebfe475..8186e460 100644 --- a/sumpy/expansion/multipole.py +++ b/sumpy/expansion/multipole.py @@ -30,7 +30,6 @@ from sumpy.expansion import ( ExpansionBase, VolumeTaylorExpansion, LaplaceConformingVolumeTaylorExpansion, HelmholtzConformingVolumeTaylorExpansion, BiharmonicConformingVolumeTaylorExpansion) -from pytools import cartesian_product import logging logger = logging.getLogger(__name__) @@ -65,16 +64,18 @@ class VolumeTaylorMultipoleExpansionBase(MultipoleExpansionBase): if not self.use_rscale: rscale = 1 + coeff_identifiers = self.get_full_coefficient_identifiers() if isinstance(kernel, DirectionalSourceDerivative): result = [0] * len(coeff_identifiers) for i, mi in enumerate(coeff_identifiers): - result[i] = self.kernel.postprocess_at_source(mi_power(avec, mi)) + result[i] = self.kernel.postprocess_at_source( + mi_power(avec, mi), avec) result[i] /= (mi_factorial(mi) * rscale ** sum(mi)) else: avec = [sym.UnevaluatedExpr(a * rscale**-1) for a in avec] result = [ mi_power(avec, mi) / mi_factorial(mi) - for mi in self.get_full_coefficient_identifiers()] + for mi in coeff_identifiers] return ( self.expansion_terms_wrangler.get_stored_mpole_coefficients_from_full( result, rscale)) @@ -95,21 +96,30 @@ class VolumeTaylorMultipoleExpansionBase(MultipoleExpansionBase): else: return (rscale**nderivatives_for_scaling * expr) - def evaluate(self, coeffs, bvec, rscale): + def evaluate(self, coeffs, bvec, rscale, knl=None): from sumpy.tools import MiDerivativeTakerWrapper + from pytools import single_valued if not self.use_rscale: rscale = 1 + if knl is None: + knl = self.kernel - taker = self.kernel.get_derivative_taker(bvec) + taker = knl.get_derivative_taker(bvec) + expr_dict = {(0,)*self.dim: 1} + expr_dict = knl.get_derivative_transformation_at_target(expr_dict) + pp_nderivatives = single_valued(sum(mi) for mi in expr_dict.keys()) result = [] for coeff, mi in zip(coeffs, self.get_coefficient_identifiers()): - mi_expr = self.kernel.postprocess_at_target( - MiDerivativeTakerWrapper(taker, mi), bvec) - expr = coeff * self.get_scaled_multipole(mi_expr, bvec, rscale, sum(mi)) + wrapper = MiDerivativeTakerWrapper(taker, mi) + mi_expr = knl.postprocess_at_target(wrapper, bvec) + expr = coeff * self.get_scaled_multipole(mi_expr, bvec, rscale, + sum(mi) + pp_nderivatives, sum(mi)) result.append(expr) - return sym.Add(*tuple(result)) + result = sym.Add(*tuple(result)) + #return knl.postprocess_at_target(result, bvec) + return result def translate_from(self, src_expansion, src_coeff_exprs, src_rscale, dvec, tgt_rscale): @@ -334,9 +344,11 @@ class _HankelBased2DMultipoleExpansion(MultipoleExpansionBase): avec) for l in self.get_coefficient_identifiers()] - def evaluate(self, coeffs, bvec, rscale): + def evaluate(self, coeffs, bvec, rscale, knl=None): if not self.use_rscale: rscale = 1 + if knl is None: + knl = self.kernel from sumpy.symbolic import sym_real_norm_2 hankel_1 = sym.Function("hankel_1") @@ -346,7 +358,7 @@ class _HankelBased2DMultipoleExpansion(MultipoleExpansionBase): arg_scale = self.get_bessel_arg_scaling() return sum(coeffs[self.get_storage_index(l)] - * self.kernel.postprocess_at_target( + * knl.postprocess_at_target( hankel_1(l, arg_scale * bvec_len) * rscale ** abs(l) * sym.exp(sym.I * l * target_angle_rel_center), bvec) diff --git a/sumpy/kernel.py b/sumpy/kernel.py index 7d436308..e020841d 100644 --- a/sumpy/kernel.py +++ b/sumpy/kernel.py @@ -279,7 +279,6 @@ class Kernel(object): expr = expr.diff(vec[i], mi[i]) return expr - def postprocess_at_source(self, expr, avec): """Transform a kernel evaluation or expansion expression in a place where the vector a (something - source) is known. ("something" may be @@ -499,7 +498,7 @@ class LaplaceKernel(ExpressionKernel): return "LapKnl%dD" % self.dim def get_derivative_taker(self, dvec): - from sumpy.tools import Laplace3DDerivativeTaker + from sumpy.tools import Laplace3DDerivativeTaker, MiDerivativeTaker if self.dim == 3: return Laplace3DDerivativeTaker(self.get_expression(dvec), dvec) else: @@ -971,9 +970,9 @@ class DirectionalTargetDerivative(DirectionalDerivative): # bvec = tgt - center result = defaultdict(lambda: 0) for mi, coeff in expr_dict.items(): - for axis in range(dim): + for axis in range(self.dim): new_mi = list(mi) - new_mi[self.axis] += 1 + new_mi[axis] += 1 result[tuple(new_mi)] += coeff * dir_vec[axis] return result @@ -1016,9 +1015,9 @@ class DirectionalSourceDerivative(DirectionalDerivative): # avec = center-src -> minus sign from chain rule result = defaultdict(lambda: 0) for mi, coeff in expr_dict.items(): - for axis in range(dim): + for axis in range(self.dim): new_mi = list(mi) - new_mi[self.axis] += 1 + new_mi[axis] += 1 result[tuple(new_mi)] += -coeff * dir_vec[axis] return result diff --git a/sumpy/symbolic.py b/sumpy/symbolic.py index 0fed239d..b63fca68 100644 --- a/sumpy/symbolic.py +++ b/sumpy/symbolic.py @@ -82,11 +82,11 @@ if USE_SYMENGINE: import symengine as sym from pymbolic.interop.symengine import ( PymbolicToSymEngineMapper as PymbolicToSympyMapper, - SymEngineToPymbolicMapper as SympyToPymbolicMapper) + SymEngineToPymbolicMapper as SympyToPymbolicMapper, make_cse) else: import sympy as sym from pymbolic.interop.sympy import ( - PymbolicToSympyMapper, SympyToPymbolicMapper) + PymbolicToSympyMapper, SympyToPymbolicMapper, make_cse) for _apifunc in SYMBOLIC_API: globals()[_apifunc] = getattr(sym, _apifunc) diff --git a/sumpy/tools.py b/sumpy/tools.py index 6bb4ff2e..34936601 100644 --- a/sumpy/tools.py +++ b/sumpy/tools.py @@ -155,7 +155,6 @@ class Laplace3DDerivativeTaker(MiDerivativeTaker): try: expr = self.cache_by_mi[mi] except KeyError: - order = sum(mi) if max(mi) == 1: return MiDerivativeTaker.diff(self, mi) d = -1 @@ -166,20 +165,19 @@ class Laplace3DDerivativeTaker(MiDerivativeTaker): assert d >= 0 expr = 0 for i in range(3): - mi_minus_one = tuple(mi) + mi_minus_one = list(mi) mi_minus_one[i] -= 1 - mi_minus_two = tuple(mi) + mi_minus_two = list(mi) mi_minus_two[i] -= 2 if i == d: - expr -= (2*mi[i]-1)*var_list[i]*self.diff(mi_minus_one) - expr -= (mi[i]-1)**2*self.diff(mi_minus_two) + expr -= (2*mi[i]-1)*self.var_list[i]*self.diff(tuple(mi_minus_one)) + expr -= (mi[i]-1)**2*self.diff(tuple(mi_minus_two)) else: - expr -= (2*mi[i])*var_list[i]*self.diff(mi_minus_one) - expr -= mi[i]*(mi[i]-1)*self.diff(mi_minus_two) + expr -= (2*mi[i])*self.var_list[i]*self.diff(tuple(mi_minus_one)) + expr -= mi[i]*(mi[i]-1)*self.diff(tuple(mi_minus_two)) expr /= self.r**2 - expr = sym.UnevaluatedExpr(expr) self.cache_by_mi[mi] = expr - return expr + return expr MiDerivativeTakerWrapper = namedtuple('MiDerivativeTakerWrapper', diff --git a/test/test_kernels.py b/test/test_kernels.py index 64c5b217..a1d5fec4 100644 --- a/test/test_kernels.py +++ b/test/test_kernels.py @@ -366,7 +366,7 @@ def _m2l_translate_simple(tgt_expansion, src_expansion, src_coeff_exprs, src_rsc # # To get the local expansion coefficients, we take derivatives of # the multipole expansion. - taker = src_expansion.get_kernel_derivative_taker(dvec) + taker = src_expansion.kernel.get_derivative_taker(dvec) from sumpy.tools import add_mi -- GitLab