From b4000d66b4aa9adc282e227d81301cbd192ec2bc Mon Sep 17 00:00:00 2001 From: Andreas Kloeckner Date: Mon, 8 Jan 2018 13:33:51 -0600 Subject: [PATCH] Apply autopep8 --- test/test_interpolate_volume_potential.py | 22 +++---- test/test_laplace.py | 1 + ...test_nearfield_interaction_completeness.py | 25 ++++---- test/test_table_manager.py | 13 ++--- test/test_table_manager_2.py | 2 +- volumential/expansion_wrangler_fpnd.py | 56 +++++++++--------- volumential/list1_gallery.py | 2 +- volumential/nearfield_potential_table.py | 12 ++-- volumential/singular_integral_2d.py | 2 +- volumential/table_manager.py | 8 +-- volumential/volume_fmm.py | 58 ++++++++++--------- 11 files changed, 101 insertions(+), 100 deletions(-) diff --git a/test/test_interpolate_volume_potential.py b/test/test_interpolate_volume_potential.py index c00f0ce..9835b8c 100644 --- a/test/test_interpolate_volume_potential.py +++ b/test/test_interpolate_volume_potential.py @@ -18,14 +18,14 @@ def func1(x, y): def make_adaptive_mesh(queue, - q_order=8, n_refinement_loops=100, refined_n_cells=1.8e2): + q_order=8, n_refinement_loops=100, refined_n_cells=1.8e2): mesh = mg.MeshGen2D(q_order, 3) iloop = 0 while mesh.n_active_cells() < refined_n_cells: iloop += 1 crtr = np.abs( - np.array([func1(c[0], c[1]) for c in mesh.get_cell_centers()]) - * mesh.get_cell_measures()) + np.array([func1(c[0], c[1]) for c in mesh.get_cell_centers()]) + * mesh.get_cell_measures()) mesh.update_mesh(crtr, 0.1, 0.2) if iloop > n_refinement_loops: print("Max number of refinement loops reached.") @@ -40,7 +40,7 @@ def make_adaptive_mesh(queue, from pytools.obj_array import make_obj_array q_points = make_obj_array( - [cl.array.to_device(queue, q_points[i]) for i in range(dim)]) + [cl.array.to_device(queue, q_points[i]) for i in range(dim)]) q_weights = cl.array.to_device(queue, q_weights) @@ -52,7 +52,8 @@ def test_on_adaptive_mesh(ctx_getter): ctx = ctx_getter() queue = cl.CommandQueue(ctx) - a = -1; b = 1 + a = -1 + b = 1 q_points, q_weights = make_adaptive_mesh(queue) fvals = func1(q_points[0].get(), q_points[1].get()) @@ -91,15 +92,16 @@ def test_on_adaptive_mesh(ctx_getter): # }}} End build tree and traversals h = 0.005 - out_x = np.arange(a, b+h, h) - out_y = np.arange(a, b+h, h) + out_x = np.arange(a, b + h, h) + out_y = np.arange(a, b + h, h) oxx, oyy = np.meshgrid(out_x, out_y) out_targets = make_obj_array( - [cl.array.to_device(queue, oxx.flatten()), - cl.array.to_device(queue, oyy.flatten())]) + [cl.array.to_device(queue, oxx.flatten()), + cl.array.to_device(queue, oyy.flatten())]) fvals_dev = cl.array.to_device(queue, fvals) - interp_fvals = interpolate_volume_potential(out_targets, trav, wrangler, fvals_dev) + interp_fvals = interpolate_volume_potential( + out_targets, trav, wrangler, fvals_dev) opot = interp_pot.get() assert(False) diff --git a/test/test_laplace.py b/test/test_laplace.py index 7f8b8d0..855822f 100644 --- a/test/test_laplace.py +++ b/test/test_laplace.py @@ -17,6 +17,7 @@ dim = 2 patch_order = 3 + def make_patch(center, size): return CalculusPatch(center=center, h=size, order=patch_order) diff --git a/test/test_nearfield_interaction_completeness.py b/test/test_nearfield_interaction_completeness.py index 331e9c5..485d014 100644 --- a/test/test_nearfield_interaction_completeness.py +++ b/test/test_nearfield_interaction_completeness.py @@ -50,9 +50,8 @@ def drive_test_completeness(q_order): # {{{ discretize the source field source_vals = cl.array.to_device(queue, - np.array( - [source_field(qp) for qp in q_points_org])) - + np.array( + [source_field(qp) for qp in q_points_org])) # }}} End discretize the source field @@ -90,7 +89,6 @@ def drive_test_completeness(q_order): # }}} End build tree and traversals - from volumential.table_manager import NearFieldInteractionTableManager tm = NearFieldInteractionTableManager("nft.hdf5") nft = tm.get_table(dim, "Constant", q_order) @@ -108,10 +106,10 @@ def drive_test_completeness(q_order): from volumential.expansion_wrangler_interface import ExpansionWranglerCodeContainer wcc = ExpansionWranglerCodeContainer(ctx, - partial(mpole_expn_class, knl), - partial(local_expn_class, knl), - out_kernels, - exclude_self=True) + partial(mpole_expn_class, knl), + partial(local_expn_class, knl), + out_kernels, + exclude_self=True) from volumential.expansion_wrangler_fpnd import FPNDExpansionWrangler wrangler = FPNDExpansionWrangler( @@ -125,13 +123,14 @@ def drive_test_completeness(q_order): # }}} End sumpy expansion for laplace kernel pot = wrangler.eval_direct(trav.target_boxes, - trav.neighbor_source_boxes_starts, - trav.neighbor_source_boxes_lists, - mode_coefs=source_vals) + trav.neighbor_source_boxes_starts, + trav.neighbor_source_boxes_lists, + mode_coefs=source_vals) pot = pot[0] for p in pot[0]: - assert(abs(p-4) < 1e-12) + assert(abs(p - 4) < 1e-12) + def test_completeness(): - for q in range(1,4): + for q in range(1, 4): drive_test_completeness(q) diff --git a/test/test_table_manager.py b/test/test_table_manager.py index 8599f12..bba592c 100644 --- a/test/test_table_manager.py +++ b/test/test_table_manager.py @@ -13,7 +13,7 @@ case_same_box = len(table.interaction_case_vecs) // 2 def test_case_id(): table1 = table_manager.get_table( - dim, "Laplace", q_order=1, force_recompute=False) + dim, "Laplace", q_order=1, force_recompute=False) assert (table1.interaction_case_vecs[case_same_box] == [0, 0]) @@ -33,8 +33,8 @@ def laplace_const_source_same_box(q_order): for target_point_index in range(n_q_points): pair_id = source_mode_index * n_q_points + target_point_index entry_id = case_same_box * n_pairs + pair_id - #print(source_mode_index, target_point_index, pair_id, entry_id, - #nft.data[entry_id]) + # print(source_mode_index, target_point_index, pair_id, entry_id, + # nft.data[entry_id]) pot[target_point_index] += 1.0 * nft.data[entry_id] return pot @@ -52,8 +52,8 @@ def laplace_cons_source_neighbor_box(q_order, case_id): for target_point_index in range(n_q_points): pair_id = source_mode_index * n_q_points + target_point_index entry_id = case_id * n_pairs + pair_id - #print(source_mode_index, target_point_index, pair_id, entry_id, - #nft.data[entry_id]) + # print(source_mode_index, target_point_index, pair_id, entry_id, + # nft.data[entry_id]) pot[target_point_index] += 1.0 * nft.data[entry_id] return pot @@ -64,7 +64,6 @@ def test_lcssb_1(): assert (len(u) == 1) - def interp_func(q_order, coef): nft = table_manager.get_table( dim, "Laplace", q_order=q_order, force_recompute=False) @@ -150,7 +149,7 @@ def drive_test_direct_quad_same_box(q_order): def test_direct_quad(): - for q in range(1,5): + for q in range(1, 5): drive_test_direct_quad_same_box(q) diff --git a/test/test_table_manager_2.py b/test/test_table_manager_2.py index 17ba941..63ca0e5 100644 --- a/test/test_table_manager_2.py +++ b/test/test_table_manager_2.py @@ -31,7 +31,7 @@ def get_target_point(case_id, target_id): dx = table.q_points[target_id][0] - 0.5 dy = table.q_points[target_id][1] - 0.5 target_point = np.array([center[0] + dx * scale, - center[1] + dy * scale]) + center[1] + dy * scale]) return target_point diff --git a/volumential/expansion_wrangler_fpnd.py b/volumential/expansion_wrangler_fpnd.py index 8d9a5e6..67154cb 100644 --- a/volumential/expansion_wrangler_fpnd.py +++ b/volumential/expansion_wrangler_fpnd.py @@ -142,7 +142,7 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): def multipole_expansions_view(self, mpole_exps, level): expn_start, expn_stop = \ - self.multipole_expansions_level_starts()[level:level+2] + self.multipole_expansions_level_starts()[level:level + 2] box_start, box_stop = self.tree.level_start_box_nrs[level:level + 2] return (box_start, mpole_exps[expn_start:expn_stop].reshape( @@ -150,7 +150,7 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): def local_expansions_view(self, local_exps, level): expn_start, expn_stop = \ - self.local_expansions_level_starts()[level:level+2] + self.local_expansions_level_starts()[level:level + 2] box_start, box_stop = self.tree.level_start_box_nrs[level:level + 2] return (box_start, local_exps[expn_start:expn_stop].reshape( @@ -184,14 +184,14 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): # use a FilteredTargetListsInTreeOrder object. def box_source_list_kwargs(self): - return dict( # NOQA + return dict( # NOQA box_source_starts=self.tree. box_source_starts, box_source_counts_nonchild=self.tree.box_source_counts_nonchild, \ sources=self.tree.sources) def box_target_list_kwargs(self): - return dict( # NOQA + return dict( # NOQA box_target_starts=self.tree. box_target_starts, box_target_counts_nonchild=self.tree.box_target_counts_nonchild, \ @@ -218,7 +218,7 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): level_start_ibox, mpoles_view = self.multipole_expansions_view( mpoles, lev) - evt, (mpoles_res, ) = p2m( # NOQA + evt, (mpoles_res, ) = p2m( # NOQA self.level_queues[lev], source_boxes=source_boxes[start:stop], centers=self.tree. @@ -267,11 +267,11 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): self.level_orders[target_level]) source_level_start_ibox, source_mpoles_view = \ - self.multipole_expansions_view(mpoles, source_level) + self.multipole_expansions_view(mpoles, source_level) target_level_start_ibox, target_mpoles_view = \ - self.multipole_expansions_view(mpoles, target_level) + self.multipole_expansions_view(mpoles, target_level) - evt, (mpoles_res, ) = m2m( # NOQA + evt, (mpoles_res, ) = m2m( # NOQA self.queue, src_expansions=source_mpoles_view, src_base_ibox=source_level_start_ibox, @@ -343,9 +343,9 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): def codegen_vec_component(dimension): return "(" + \ - "(box_centers[" + str(dimension) + ", target_box_id]" + \ - "- box_centers[" + str(dimension) + ", source_box_id]" + \ - ") / sbox_extent * 4.0 + encoding_shift" + \ + "(box_centers[" + str(dimension) + ", target_box_id]" + \ + "- box_centers[" + str(dimension) + ", source_box_id]" + \ + ") / sbox_extent * 4.0 + encoding_shift" + \ ")" def codegen_vec_id(dim): @@ -377,8 +377,8 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): else: raise NotImplementedError("Output kernel type " + - self.code.out_kernels[0].__repr__() + - " not supported") + self.code.out_kernels[0].__repr__() + + " not supported") lpknl = loopy.make_kernel( # NOQA [ @@ -478,8 +478,8 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): source_coefs=mode_coefs, table_data=table_data_dev, target_boxes=target_boxes) - # sorted_target_ids=self.tree.user_source_ids, - # user_source_ids=self.tree.user_source_ids) + # sorted_target_ids=self.tree.user_source_ids, + # user_source_ids=self.tree.user_source_ids) assert (pot[0] is pot_res) for pot_i in pot: @@ -507,13 +507,13 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): m2l = self.code.m2l(order, order) source_level_start_ibox, source_mpoles_view = \ - self.multipole_expansions_view(mpole_exps, lev) + self.multipole_expansions_view(mpole_exps, lev) target_level_start_ibox, target_local_exps_view = \ - self.local_expansions_view(local_exps, lev) + self.local_expansions_view(local_exps, lev) evt, ( local_exps_res, - ) = m2l( # NOQA + ) = m2l( # NOQA self.level_queues[lev], src_expansions=source_mpoles_view, \ src_base_ibox=source_level_start_ibox, @@ -551,9 +551,9 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): m2p = self.code.m2p(self.level_orders[isrc_level]) source_level_start_ibox, source_mpoles_view = \ - self.multipole_expansions_view(mpole_exps, isrc_level) + self.multipole_expansions_view(mpole_exps, isrc_level) - evt, pot_res = m2p( # NOQA + evt, pot_res = m2p( # NOQA self.queue, src_expansions=source_mpoles_view, \ src_base_ibox=source_level_start_ibox, @@ -587,16 +587,16 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): events = [] for lev in range(self.tree.nlevels): start, stop = \ - level_start_target_or_target_parent_box_nrs[lev:lev+2] + level_start_target_or_target_parent_box_nrs[lev:lev + 2] if start == stop: continue p2l = self.code.p2l(self.level_orders[lev]) target_level_start_ibox, target_local_exps_view = \ - self.local_expansions_view(local_exps, lev) + self.local_expansions_view(local_exps, lev) - evt, (result, ) = p2l( # NOQA + evt, (result, ) = p2l( # NOQA self.level_queues[lev], target_boxes=target_or_target_parent_boxes[start:stop], \ source_box_starts=starts[start:stop + 1], @@ -630,13 +630,13 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): self.level_orders[target_lev]) source_level_start_ibox, source_local_exps_view = \ - self.local_expansions_view(local_exps, source_lev) + self.local_expansions_view(local_exps, source_lev) target_level_start_ibox, target_local_exps_view = \ - self.local_expansions_view(local_exps, target_lev) + self.local_expansions_view(local_exps, target_lev) evt, ( local_exps_res, - ) = l2l( # NOQA + ) = l2l( # NOQA self.queue, src_expansions=source_local_exps_view, \ src_base_ibox=source_level_start_ibox, @@ -670,9 +670,9 @@ class FPNDExpansionWrangler(ExpansionWranglerInterface): l2p = self.code.l2p(self.level_orders[lev]) source_level_start_ibox, source_local_exps_view = \ - self.local_expansions_view(local_exps, lev) + self.local_expansions_view(local_exps, lev) - evt, pot_res = l2p( # NOQA + evt, pot_res = l2p( # NOQA self.level_queues[lev], src_expansions=source_local_exps_view, \ src_base_ibox=source_level_start_ibox, diff --git a/volumential/list1_gallery.py b/volumential/list1_gallery.py index 9c83a2a..4220af0 100644 --- a/volumential/list1_gallery.py +++ b/volumential/list1_gallery.py @@ -42,7 +42,7 @@ class TreeBox: 2 * dim_indicator - 1 - ) * child_radius + ) * child_radius self.children.append( TreeBox( diff --git a/volumential/nearfield_potential_table.py b/volumential/nearfield_potential_table.py index e5c0e93..5aa0490 100644 --- a/volumential/nearfield_potential_table.py +++ b/volumential/nearfield_potential_table.py @@ -138,7 +138,7 @@ class NearFieldInteractionTable(object): # digits to prevent floating point errors from polluting # the ordering. q_points_ordering = sorted(range(len(mapped_q_points)), - key=lambda i: list(np.floor(mapped_q_points[i]*10000))) + key=lambda i: list(np.floor(mapped_q_points[i] * 10000))) self.q_points = mapped_q_points[ q_points_ordering] @@ -353,10 +353,10 @@ class NearFieldInteractionTable(object): entry_info = self.decode_index( entry_id) - #source_mode = self.get_mode( + # source_mode = self.get_mode( # entry_info[ # "source_mode_index"]) - #target_point = self.find_target_point( + # target_point = self.find_target_point( # target_point_index= # entry_info[ # "target_point_index"], @@ -393,8 +393,7 @@ class NearFieldInteractionTable(object): entry_info[ "source_mode_index"]) target_point = self.find_target_point( - target_point_index= - entry_info[ + target_point_index=entry_info[ "target_point_index"], case_index=entry_info[ "case_index"]) @@ -420,8 +419,7 @@ class NearFieldInteractionTable(object): b=1, c=0, d=1, - singular_point= - target_point, + singular_point=target_point, maxiter=100) else: raise NotImplemented diff --git a/volumential/singular_integral_2d.py b/volumential/singular_integral_2d.py index 23a1fd5..7ecf50d 100644 --- a/volumential/singular_integral_2d.py +++ b/volumential/singular_integral_2d.py @@ -103,7 +103,7 @@ def qquad(func, if method == "Adaptive": # Using lambda for readability - outer_integrand = lambda y: quad( # NOQA + def outer_integrand(y): return quad( # NOQA lambda x: func(x, y, *args), a, b, (), toli, rtoli, maxiteri, vec_func, miniteri)[0] # NOQA # Is there a simple way to retrieve err info from the inner quad calls? diff --git a/volumential/table_manager.py b/volumential/table_manager.py index cf65b82..4aa2ae2 100644 --- a/volumential/table_manager.py +++ b/volumential/table_manager.py @@ -98,11 +98,11 @@ class NearFieldInteractionTableManager( except KeyError: logger.debug( - "Recomputing due to table data corruption." + "Recomputing due to table data corruption." ) table = self.compute_and_update_table( - dim, kernel_type, - q_order) + dim, kernel_type, + q_order) return table @@ -148,7 +148,7 @@ class NearFieldInteractionTableManager( "q_points"] table.data[...] = grp["data"] table.mode_normalizers[...] \ - = grp["mode_normalizers"] + = grp["mode_normalizers"] tmp_case_vecs = np.array( table.interaction_case_vecs) diff --git a/volumential/volume_fmm.py b/volumential/volume_fmm.py index 928a06a..f7dc182 100644 --- a/volumential/volume_fmm.py +++ b/volumential/volume_fmm.py @@ -7,6 +7,7 @@ from volumential.expansion_wrangler_interface import ExpansionWranglerInterface import numpy as np + def drive_volume_fmm(traversal, expansion_wrangler, src_weights, src_func): """ Top-level driver routine for volume potential calculation @@ -116,7 +117,8 @@ def drive_volume_fmm(traversal, expansion_wrangler, src_weights, src_func): # {{{ "Stage 6:" form locals for separated bigger source boxes ("list 4") - logger.debug("form locals for separated bigger source boxes ('list 4 far')") + logger.debug( + "form locals for separated bigger source boxes ('list 4 far')") local_exps = local_exps + wrangler.form_locals( traversal.level_start_target_or_target_parent_box_nrs, @@ -126,7 +128,7 @@ def drive_volume_fmm(traversal, expansion_wrangler, src_weights, src_func): # volume fmm does not work with list 4 currently assert (traversal.from_sep_close_bigger_starts is None) - #if traversal.from_sep_close_bigger_starts is not None: + # if traversal.from_sep_close_bigger_starts is not None: # logger.debug("evaluate separated close bigger interactions directly " # "('list 4 close')") @@ -179,13 +181,13 @@ def compute_barycentric_lagrange_params(q_order): from scipy.interpolate import BarycentricInterpolator as Interpolator interp = Interpolator(xi=q_points_1d, yi=None) interp_weights = interp.wi - interp_points = interp.xi + interp_points = interp.xi return (interp_points, interp_weights) def interpolate_volume_potential(target_points, traversal, wrangler, potential, - target_radii=None): + target_radii=None): """ Interpolate the volume potential. target_points and potential should be an cl array. @@ -209,7 +211,7 @@ def interpolate_volume_potential(target_points, traversal, wrangler, potential, # Set this number small enough so that all points found # are inside the box target_radii = cl.array.to_device(queue, - np.ones(n_points, dtype=dtype) * 1e-32) + np.ones(n_points, dtype=dtype) * 1e-32) lbl_lookup, evt = lookup_builder(queue, tree, target_points, target_radii) @@ -220,20 +222,20 @@ def interpolate_volume_potential(target_points, traversal, wrangler, potential, # map all boxes to a template [0,1]^2 so that the interpolation # weights and modes can be precomputed (blpoints, blweights) = compute_barycentric_lagrange_params(q_order) - blpoints = cl.array.to_device(queue, blpoints) + blpoints = cl.array.to_device(queue, blpoints) blweights = cl.array.to_device(queue, blweights) # {{{ loopy kernel for interpolation import loopy - lpknl = loopy.make_kernel( # NOQA + lpknl = loopy.make_kernel( # NOQA [ "{ [ tbox ] : 0 <= tbox < n_tgt_boxes }", "{ [ tpt, mid, mjd, mkd ] : tpt_begin <= tpt < tpt_end " "and 0 <= mid < n_box_modes and 0 <= mjd < Q_ORDER " "and 0 <= mkd < Q_ORDER }".replace( "Q_ORDER", str(q_order)) - ],""" + ], """ for tbox <> target_box_id = target_boxes[tbox] @@ -346,26 +348,26 @@ def interpolate_volume_potential(target_points, traversal, wrangler, potential, lpknl = loopy.set_options(lpknl, return_dict=True) evt, res_dict = lpknl( - queue, - p_out=pout, - multiplicity=multiplicity, - box_centers=tree.box_centers, - box_levels=tree.box_levels, - balls_near_box_starts=lbl_lookup.balls_near_box_starts, - balls_near_box_lists=lbl_lookup.balls_near_box_lists, - barycentric_lagrange_weights=blweights, - barycentric_lagrange_points=blpoints, - box_target_starts=tree.box_target_starts, - box_target_counts_cumul=tree.box_target_counts_cumul, - potential=potential, - user_mode_ids=tree.user_source_ids, - target_coords_x=target_points[0], - target_coords_y=target_points[1], - target_boxes=traversal.target_boxes, - dim=dim, - root_extent=tree.root_extent, - n_tgt_boxes=len(traversal.target_boxes) - ) + queue, + p_out=pout, + multiplicity=multiplicity, + box_centers=tree.box_centers, + box_levels=tree.box_levels, + balls_near_box_starts=lbl_lookup.balls_near_box_starts, + balls_near_box_lists=lbl_lookup.balls_near_box_lists, + barycentric_lagrange_weights=blweights, + barycentric_lagrange_points=blpoints, + box_target_starts=tree.box_target_starts, + box_target_counts_cumul=tree.box_target_counts_cumul, + potential=potential, + user_mode_ids=tree.user_source_ids, + target_coords_x=target_points[0], + target_coords_y=target_points[1], + target_boxes=traversal.target_boxes, + dim=dim, + root_extent=tree.root_extent, + n_tgt_boxes=len(traversal.target_boxes) + ) assert(pout is res_dict["p_out"]) assert(multiplicity is res_dict["multiplicity"]) -- GitLab