def lpot_source_from_mesh(queue, mesh, lpot_kwargs=None): from meshmode.discretization import Discretization from meshmode.discretization.poly_element import ( InterpolatoryQuadratureSimplexGroupFactory) target_order = TARGET_ORDER pre_density_discr = Discretization( queue.context, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) refiner_extra_kwargs = { "_force_stage2_uniform_refinement_rounds": (FORCE_STAGE2_UNIFORM_REFINEMENT_ROUNDS), "_scaled_max_curvature_threshold": (SCALED_MAX_CURVATURE_THRESHOLD), } if lpot_kwargs is None: lpot_kwargs = DEFAULT_LPOT_KWARGS from pytential.qbx import QBXLayerPotentialSource lpot_source = QBXLayerPotentialSource( pre_density_discr, OVSMP_FACTOR * target_order, **lpot_kwargs, ) lpot_source, _ = lpot_source.with_refinement(**refiner_extra_kwargs) return lpot_source
def test_interpolation(actx_factory, name, source_discr_stage, target_granularity): actx = actx_factory() nelements = 32 target_order = 7 qbx_order = 4 where = sym.as_dofdesc("test_interpolation") from_dd = sym.DOFDescriptor( geometry=where.geometry, discr_stage=source_discr_stage, granularity=sym.GRANULARITY_NODE) to_dd = sym.DOFDescriptor( geometry=where.geometry, discr_stage=sym.QBX_SOURCE_QUAD_STAGE2, granularity=target_granularity) mesh = mgen.make_curve_mesh(mgen.starfish, np.linspace(0.0, 1.0, nelements + 1), target_order) discr = Discretization(actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) from pytential.qbx import QBXLayerPotentialSource qbx = QBXLayerPotentialSource(discr, fine_order=4 * target_order, qbx_order=qbx_order, fmm_order=False) from pytential import GeometryCollection places = GeometryCollection(qbx, auto_where=where) sigma_sym = sym.var("sigma") op_sym = sym.sin(sym.interp(from_dd, to_dd, sigma_sym)) bound_op = bind(places, op_sym, auto_where=where) def discr_and_nodes(stage): density_discr = places.get_discretization(where.geometry, stage) return density_discr, actx.to_numpy( flatten(density_discr.nodes(), actx) ).reshape(density_discr.ambient_dim, -1) _, target_nodes = discr_and_nodes(sym.QBX_SOURCE_QUAD_STAGE2) source_discr, source_nodes = discr_and_nodes(source_discr_stage) sigma_target = np.sin(la.norm(target_nodes, axis=0)) sigma_dev = unflatten( thaw(source_discr.nodes()[0], actx), actx.from_numpy(la.norm(source_nodes, axis=0)), actx) sigma_target_interp = actx.to_numpy( flatten(bound_op(actx, sigma=sigma_dev), actx) ) if name in ("default", "default_explicit", "stage2", "quad"): error = la.norm(sigma_target_interp - sigma_target) / la.norm(sigma_target) assert error < 1.0e-10 elif name in ("stage2_center",): assert len(sigma_target_interp) == 2 * len(sigma_target) else: raise ValueError(f"unknown test case name: {name}")
def get_lpot_source(actx: PyOpenCLArrayContext, dim): from meshmode.discretization import Discretization from meshmode.discretization.poly_element import ( InterpolatoryQuadratureSimplexGroupFactory) target_order = TARGET_ORDER if dim == 2: from meshmode.mesh.generation import starfish, make_curve_mesh mesh = make_curve_mesh(starfish, np.linspace(0, 1, 50), order=target_order) elif dim == 3: from meshmode.mesh.generation import generate_torus mesh = generate_torus(2, 1, order=target_order) else: raise ValueError("unsupported dimension: %d" % dim) pre_density_discr = Discretization( actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) lpot_kwargs = DEFAULT_LPOT_KWARGS.copy() lpot_kwargs.update( _expansion_stick_out_factor=TCF, fmm_order=FMM_ORDER, qbx_order=QBX_ORDER, fmm_backend="fmmlib", ) from pytential.qbx import QBXLayerPotentialSource lpot_source = QBXLayerPotentialSource( pre_density_discr, OVSMP_FACTOR*target_order, **lpot_kwargs) return lpot_source
def test_mesh_without_vertices(actx_factory): actx = actx_factory() # create a mesh mesh = mgen.generate_icosphere(r=1.0, order=4) # create one without the vertices grp, = mesh.groups groups = [ grp.copy(nodes=grp.nodes, vertex_indices=None) for grp in mesh.groups ] mesh = Mesh(None, groups, is_conforming=False) # try refining it from meshmode.mesh.refinement import refine_uniformly mesh = refine_uniformly(mesh, 1) # make sure the world doesn't end from meshmode.discretization import Discretization discr = Discretization(actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(4)) thaw(discr.nodes(), actx) from meshmode.discretization.visualization import make_visualizer make_visualizer(actx, discr, 4)
def starfish_lpot_source(queue, n_arms): from meshmode.discretization import Discretization from meshmode.discretization.poly_element import ( InterpolatoryQuadratureSimplexGroupFactory) from meshmode.mesh.generation import make_curve_mesh, NArmedStarfish mesh = make_curve_mesh(NArmedStarfish(n_arms, 0.8), np.linspace(0, 1, 1 + PANELS_PER_ARM * n_arms), TARGET_ORDER) pre_density_discr = Discretization( queue.context, mesh, InterpolatoryQuadratureSimplexGroupFactory(TARGET_ORDER)) lpot_kwargs = DEFAULT_LPOT_KWARGS.copy() lpot_kwargs.update(target_association_tolerance=0.025, _expansion_stick_out_factor=TCF, fmm_order=FMM_ORDER, qbx_order=QBX_ORDER, fmm_backend="fmmlib") from pytential.qbx import QBXLayerPotentialSource lpot_source = QBXLayerPotentialSource(pre_density_discr, OVSMP_FACTOR * TARGET_ORDER, **lpot_kwargs) lpot_source, _ = lpot_source.with_refinement() return lpot_source
def _build_qbx_discr(queue, ndim=2, nelements=30, target_order=7, qbx_order=4, curve_f=None): if curve_f is None: curve_f = NArmedStarfish(5, 0.25) if ndim == 2: mesh = make_curve_mesh(curve_f, np.linspace(0, 1, nelements + 1), target_order) elif ndim == 3: mesh = generate_torus(10.0, 2.0, order=target_order) else: raise ValueError("unsupported ambient dimension") from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory from pytential.qbx import QBXLayerPotentialSource density_discr = Discretization( queue.context, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) qbx, _ = QBXLayerPotentialSource(density_discr, fine_order=4 * target_order, qbx_order=qbx_order, fmm_order=False).with_refinement() return qbx
def test_tangential_onb(ctx_factory): cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) from meshmode.mesh.generation import generate_torus mesh = generate_torus(5, 2, order=3) discr = Discretization(cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(3)) tob = sym.tangential_onb(mesh.ambient_dim) nvecs = tob.shape[1] # make sure tangential_onb is mutually orthogonal and normalized orth_check = bind( discr, sym.make_obj_array([ np.dot(tob[:, i], tob[:, j]) - (1 if i == j else 0) for i in range(nvecs) for j in range(nvecs) ]))(queue) for i, orth_i in enumerate(orth_check): assert (cl.clmath.fabs(orth_i) < 1e-13).get().all() # make sure tangential_onb is orthogonal to normal orth_check = bind( discr, sym.make_obj_array([ np.dot(tob[:, i], sym.normal(mesh.ambient_dim).as_vector()) for i in range(nvecs) ]))(queue) for i, orth_i in enumerate(orth_check): assert (cl.clmath.fabs(orth_i) < 1e-13).get().all()
def test_geometry(ctx_factory): cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) nelements = 30 order = 5 mesh = make_curve_mesh(partial(ellipse, 1), np.linspace(0, 1, nelements+1), order) from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory discr = Discretization(actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(order)) import pytential.symbolic.primitives as prim area_sym = prim.integral(2, 1, 1) area = bind(discr, area_sym)(actx) err = abs(area-2*np.pi) print(err) assert err < 1e-3
def get_torus_with_ref_mean_curvature(actx, h): order = 4 r_minor = 1.0 r_major = 3.0 from meshmode.mesh.generation import generate_torus mesh = generate_torus(r_major, r_minor, n_major=h, n_minor=h, order=order) discr = Discretization(actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(order)) from meshmode.dof_array import thaw nodes = thaw(actx, discr.nodes()) # copied from meshmode.mesh.generation.generate_torus a = r_major b = r_minor u = actx.np.arctan2(nodes[1], nodes[0]) from pytools.obj_array import flat_obj_array rvec = flat_obj_array(actx.np.cos(u), actx.np.sin(u), 0*u) rvec = sum(nodes * rvec) - a cosv = actx.np.cos(actx.np.arctan2(nodes[2], rvec)) return discr, (a + 2.0 * b * cosv) / (2 * b * (a + b * cosv))
def test_tangential_onb(actx_factory): actx = actx_factory() from meshmode.mesh.generation import generate_torus mesh = generate_torus(5, 2, order=3) discr = Discretization( actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(3)) tob = sym.tangential_onb(mesh.ambient_dim) nvecs = tob.shape[1] # make sure tangential_onb is mutually orthogonal and normalized orth_check = bind(discr, sym.make_obj_array([ np.dot(tob[:, i], tob[:, j]) - (1 if i == j else 0) for i in range(nvecs) for j in range(nvecs)]) )(actx) for orth_i in orth_check: assert actx.to_numpy( actx.np.all(actx.np.abs(orth_i) < 1e-13) ) # make sure tangential_onb is orthogonal to normal orth_check = bind(discr, sym.make_obj_array([ np.dot(tob[:, i], sym.normal(mesh.ambient_dim).as_vector()) for i in range(nvecs)]) )(actx) for orth_i in orth_check: assert actx.to_numpy( actx.np.all(actx.np.abs(orth_i) < 1e-13) )
def create_discretization(queue, ndim, nelements=42, mesh_order=5, discr_order=5): ctx = queue.context # construct mesh if ndim == 2: from functools import partial from meshmode.mesh.generation import make_curve_mesh, ellipse mesh = make_curve_mesh(partial(ellipse, 2), np.linspace(0.0, 1.0, nelements + 1), order=mesh_order) elif ndim == 3: from meshmode.mesh.generation import generate_torus mesh = generate_torus(10.0, 5.0, order=mesh_order) else: raise ValueError("Unsupported dimension: {}".format(ndim)) # create discretization from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory discr = Discretization(ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(discr_order)) return discr
def test_off_surface_eval(actx_factory, use_fmm, visualize=False): logging.basicConfig(level=logging.INFO) actx = actx_factory() # prevent cache 'splosion from sympy.core.cache import clear_cache clear_cache() nelements = 30 target_order = 8 qbx_order = 3 if use_fmm: fmm_order = qbx_order else: fmm_order = False mesh = mgen.make_curve_mesh(partial(mgen.ellipse, 3), np.linspace(0, 1, nelements + 1), target_order) from pytential.qbx import QBXLayerPotentialSource from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory pre_density_discr = Discretization( actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) qbx = QBXLayerPotentialSource( pre_density_discr, 4 * target_order, qbx_order, fmm_order=fmm_order, ) from pytential.target import PointsTarget fplot = FieldPlotter(np.zeros(2), extent=0.54, npoints=30) targets = PointsTarget(actx.freeze(actx.from_numpy(fplot.points))) places = GeometryCollection((qbx, targets)) density_discr = places.get_discretization(places.auto_source.geometry) from sumpy.kernel import LaplaceKernel op = sym.D(LaplaceKernel(2), sym.var("sigma"), qbx_forced_limit=-2) sigma = density_discr.zeros(actx) + 1 fld_in_vol = bind(places, op)(actx, sigma=sigma) fld_in_vol_exact = -1 linf_err = actx.to_numpy( actx.np.linalg.norm(fld_in_vol - fld_in_vol_exact, ord=np.inf)) logger.info("l_inf error: %.12e", linf_err) if visualize: fplot.show_scalar_in_matplotlib(actx.to_numpy(fld_in_vol)) import matplotlib.pyplot as pt pt.colorbar() pt.show() assert linf_err < 1e-3
def test_unregularized_off_surface_fmm_vs_direct(ctx_factory): cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) nelements = 300 target_order = 8 fmm_order = 4 # {{{ geometry mesh = make_curve_mesh(WobblyCircle.random(8, seed=30), np.linspace(0, 1, nelements+1), target_order) from pytential.unregularized import UnregularizedLayerPotentialSource from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory density_discr = Discretization( actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) direct = UnregularizedLayerPotentialSource( density_discr, fmm_order=False, ) fmm = direct.copy( fmm_level_to_order=lambda kernel, kernel_args, tree, level: fmm_order) sigma = density_discr.zeros(actx) + 1 fplot = FieldPlotter(np.zeros(2), extent=5, npoints=100) from pytential.target import PointsTarget ptarget = PointsTarget(fplot.points) from pytential import GeometryCollection places = GeometryCollection({ "unregularized_direct": direct, "unregularized_fmm": fmm, "targets": ptarget}) # }}} # {{{ check from sumpy.kernel import LaplaceKernel op = sym.D(LaplaceKernel(2), sym.var("sigma"), qbx_forced_limit=None) direct_fld_in_vol = bind(places, op, auto_where=("unregularized_direct", "targets"))( actx, sigma=sigma) fmm_fld_in_vol = bind(places, op, auto_where=("unregularized_fmm", "targets"))(actx, sigma=sigma) err = actx.np.fabs(fmm_fld_in_vol - direct_fld_in_vol) linf_err = actx.to_numpy(err).max() print("l_inf error:", linf_err) assert linf_err < 5e-3
def test_off_surface_eval(ctx_factory, use_fmm, do_plot=False): logging.basicConfig(level=logging.INFO) cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) # prevent cache 'splosion from sympy.core.cache import clear_cache clear_cache() nelements = 30 target_order = 8 qbx_order = 3 if use_fmm: fmm_order = qbx_order else: fmm_order = False mesh = make_curve_mesh(partial(ellipse, 3), np.linspace(0, 1, nelements + 1), target_order) from pytential.qbx import QBXLayerPotentialSource from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory pre_density_discr = Discretization( cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) qbx, _ = QBXLayerPotentialSource( pre_density_discr, 4 * target_order, qbx_order, fmm_order=fmm_order, ).with_refinement() density_discr = qbx.density_discr from sumpy.kernel import LaplaceKernel op = sym.D(LaplaceKernel(2), sym.var("sigma"), qbx_forced_limit=-2) sigma = density_discr.zeros(queue) + 1 fplot = FieldPlotter(np.zeros(2), extent=0.54, npoints=30) from pytential.target import PointsTarget fld_in_vol = bind((qbx, PointsTarget(fplot.points)), op)(queue, sigma=sigma) err = cl.clmath.fabs(fld_in_vol - (-1)) linf_err = cl.array.max(err).get() print("l_inf error:", linf_err) if do_plot: fplot.show_scalar_in_matplotlib(fld_in_vol.get()) import matplotlib.pyplot as pt pt.colorbar() pt.show() assert linf_err < 1e-3
def main(): cl_ctx = cl.create_some_context() queue = cl.CommandQueue(cl_ctx) target_order = 10 from functools import partial nelements = 30 qbx_order = 4 from sumpy.kernel import LaplaceKernel from meshmode.mesh.generation import ( # noqa ellipse, cloverleaf, starfish, drop, n_gon, qbx_peanut, make_curve_mesh) mesh = make_curve_mesh(partial(ellipse, 1), np.linspace(0, 1, nelements+1), target_order) from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory density_discr = Discretization(cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) from pytential.qbx import QBXLayerPotentialSource qbx = QBXLayerPotentialSource(density_discr, 4*target_order, qbx_order, fmm_order=False) from pytools.obj_array import join_fields sig_sym = sym.var("sig") knl = LaplaceKernel(2) op = join_fields( sym.tangential_derivative(mesh.ambient_dim, sym.D(knl, sig_sym, qbx_forced_limit=+1)).as_scalar(), sym.tangential_derivative(mesh.ambient_dim, sym.D(knl, sig_sym, qbx_forced_limit=-1)).as_scalar(), ) nodes = density_discr.nodes().with_queue(queue) angle = cl.clmath.atan2(nodes[1], nodes[0]) n = 10 sig = cl.clmath.sin(n*angle) dt_sig = n*cl.clmath.cos(n*angle) res = bind(qbx, op)(queue, sig=sig) extval = res[0].get() intval = res[1].get() pv = 0.5*(extval + intval) dt_sig_h = dt_sig.get() import matplotlib.pyplot as pt pt.plot(extval, label="+num") pt.plot(pv + dt_sig_h*0.5, label="+ex") pt.legend(loc="best") pt.show()
def get_discretization(self, actx, resolution, mesh_order): mesh = self.get_mesh(resolution, mesh_order) from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory return Discretization( actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(self.target_order))
def test_parallel_vtk_file(actx_factory, dim): r""" Simple test just generates a sample parallel PVTU file and checks it against the expected result. The expected result is just a file in the tests directory. """ logging.basicConfig(level=logging.INFO) actx = actx_factory() nelements = 64 target_order = 4 if dim == 1: mesh = mgen.make_curve_mesh(mgen.NArmedStarfish(5, 0.25), np.linspace(0.0, 1.0, nelements + 1), target_order) elif dim == 2: mesh = mgen.generate_torus(5.0, 1.0, order=target_order) elif dim == 3: mesh = mgen.generate_warped_rect_mesh(dim, target_order, nelements_side=4) else: raise ValueError("unknown dimensionality") from meshmode.discretization import Discretization discr = Discretization( actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) from meshmode.discretization.visualization import make_visualizer vis = make_visualizer(actx, discr, target_order) class FakeComm: def Get_rank(self): # noqa: N802 return 0 def Get_size(self): # noqa: N802 return 2 file_name_pattern = f"visualizer_vtk_linear_{dim}_{{rank}}.vtu" pvtu_filename = file_name_pattern.format(rank=0).replace("vtu", "pvtu") vis.write_parallel_vtk_file( FakeComm(), file_name_pattern, [("scalar", discr.zeros(actx)), ("vector", make_obj_array([discr.zeros(actx) for i in range(dim)]))], overwrite=True) import os assert os.path.exists(pvtu_filename) import filecmp assert filecmp.cmp(f"ref-{pvtu_filename}", pvtu_filename)
def test_target_association_failure(ctx_factory): cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) # {{{ generate circle order = 5 nelements = 40 # Make the curve mesh. curve_f = partial(ellipse, 1) mesh = make_curve_mesh(curve_f, np.linspace(0, 1, nelements + 1), order) from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory factory = InterpolatoryQuadratureSimplexGroupFactory(order) discr = Discretization(actx, mesh, factory) lpot_source = QBXLayerPotentialSource( discr, qbx_order=order, # not used in target association fine_order=order) places = GeometryCollection(lpot_source) # }}} # {{{ generate targets and check close_circle = 0.999 * np.exp( 2j * np.pi * np.linspace(0, 1, 500, endpoint=False)) from pytential.target import PointsTarget close_circle_target = (PointsTarget( actx.from_numpy(np.array([close_circle.real, close_circle.imag])))) targets = ((close_circle_target, 0), ) from pytential.qbx.target_assoc import (TargetAssociationCodeContainer, associate_targets_to_qbx_centers, QBXTargetAssociationFailedException ) from pytential.qbx.utils import TreeCodeContainer code_container = TargetAssociationCodeContainer(actx, TreeCodeContainer(actx)) with pytest.raises(QBXTargetAssociationFailedException): associate_targets_to_qbx_centers(places, places.auto_source, code_container.get_wrangler(actx), targets, target_association_tolerance=1e-10)
def test_interpolation(ctx_factory, name, source_discr_stage, target_granularity): ctx = ctx_factory() queue = cl.CommandQueue(ctx) nelements = 32 target_order = 7 qbx_order = 4 mesh = make_curve_mesh(starfish, np.linspace(0.0, 1.0, nelements + 1), target_order) discr = Discretization( ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) from pytential.qbx import QBXLayerPotentialSource qbx, _ = QBXLayerPotentialSource(discr, fine_order=4 * target_order, qbx_order=qbx_order, fmm_order=False).with_refinement() where = 'test-interpolation' from_dd = sym.DOFDescriptor(geometry=where, discr_stage=source_discr_stage, granularity=sym.GRANULARITY_NODE) to_dd = sym.DOFDescriptor(geometry=where, discr_stage=sym.QBX_SOURCE_QUAD_STAGE2, granularity=target_granularity) sigma_sym = sym.var("sigma") op_sym = sym.sin(sym.interp(from_dd, to_dd, sigma_sym)) bound_op = bind(qbx, op_sym, auto_where=where) target_nodes = qbx.quad_stage2_density_discr.nodes().get(queue) if source_discr_stage == sym.QBX_SOURCE_STAGE2: source_nodes = qbx.stage2_density_discr.nodes().get(queue) elif source_discr_stage == sym.QBX_SOURCE_QUAD_STAGE2: source_nodes = target_nodes else: source_nodes = qbx.density_discr.nodes().get(queue) sigma_dev = cl.array.to_device(queue, la.norm(source_nodes, axis=0)) sigma_target = np.sin(la.norm(target_nodes, axis=0)) sigma_target_interp = bound_op(queue, sigma=sigma_dev).get(queue) if name in ('default', 'default-explicit', 'stage2', 'quad'): error = la.norm(sigma_target_interp - sigma_target) / la.norm(sigma_target) assert error < 1.0e-10 elif name in ('stage2-center', ): assert len(sigma_target_interp) == 2 * len(sigma_target) else: raise ValueError('unknown test case name: {}'.format(name))
def create_face_connection(queue, discr): from meshmode.discretization.connection import FACE_RESTR_ALL from meshmode.discretization.connection import make_face_restriction from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory discr_order = discr.groups[0].order connection = make_face_restriction(discr, InterpolatoryQuadratureSimplexGroupFactory(discr_order), FACE_RESTR_ALL, per_face_groups=True) return connection
def test_to_fd_consistency(ctx_factory, mm_mesh, fspace_degree): fspace_degree += mm_mesh.groups[0].order cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) factory = InterpolatoryQuadratureSimplexGroupFactory(fspace_degree) discr = Discretization(actx, mm_mesh, factory) fdrake_connection = build_connection_to_firedrake(discr) fdrake_fspace = fdrake_connection.firedrake_fspace() # Check consistency check_consistency(fdrake_fspace, discr)
def test_discr_nodes_caching(actx_factory): actx = actx_factory() nelements = 30 target_order = 5 mesh = mgen.make_curve_mesh( mgen.NArmedStarfish(5, 0.25), np.linspace(0.0, 1.0, nelements + 1), target_order) discr = Discretization(actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) discr.nodes(cached=False) assert discr._cached_nodes is None discr.nodes() assert discr._cached_nodes is not None
def create_refined_connection(queue, discr, threshold=0.3): from meshmode.mesh.refinement import RefinerWithoutAdjacency from meshmode.discretization.connection import make_refinement_connection from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory flags = np.random.rand(discr.mesh.nelements) < threshold refiner = RefinerWithoutAdjacency(discr.mesh) refiner.refine(flags) discr_order = discr.groups[0].order connection = make_refinement_connection(refiner, discr, InterpolatoryQuadratureSimplexGroupFactory(discr_order)) return connection
def test_vtk_overwrite(ctx_getter): pytest.importorskip("pyvisfile") def _try_write_vtk(writer, obj): import os from meshmode import FileExistsError filename = "test_vtk_overwrite.vtu" if os.path.exists(filename): os.remove(filename) writer(filename, []) with pytest.raises(FileExistsError): writer(filename, []) writer(filename, [], overwrite=True) if os.path.exists(filename): os.remove(filename) ctx = ctx_getter() queue = cl.CommandQueue(ctx) target_order = 7 from meshmode.mesh.generation import generate_torus mesh = generate_torus(10.0, 2.0, order=target_order) from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory discr = Discretization( queue.context, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) from meshmode.discretization.visualization import make_visualizer from meshmode.discretization.visualization import \ write_nodal_adjacency_vtk_file from meshmode.mesh.visualization import write_vertex_vtk_file vis = make_visualizer(queue, discr, 1) _try_write_vtk(vis.write_vtk_file, discr) _try_write_vtk( lambda x, y, **kwargs: write_vertex_vtk_file(discr.mesh, x, **kwargs), discr.mesh) _try_write_vtk( lambda x, y, **kwargs: write_nodal_adjacency_vtk_file( x, discr.mesh, **kwargs), discr.mesh)
def get_ellipse_with_ref_mean_curvature(cl_ctx, nelements, aspect=1): order = 4 mesh = make_curve_mesh(partial(ellipse, aspect), np.linspace(0, 1, nelements + 1), order) discr = Discretization(cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(order)) with cl.CommandQueue(cl_ctx) as queue: nodes = discr.nodes().get(queue=queue) a = 1 b = 1 / aspect t = np.arctan2(nodes[1] * aspect, nodes[0]) return discr, a * b / ((a * np.sin(t))**2 + (b * np.cos(t))**2)**(3 / 2)
def get_lpot_source(queue, mesh_getter, nelements, stickout_factor, well_sep_is_n_away, with_extents, max_leaf_refine_weight, k=0, fmm_backend="sumpy", from_sep_smaller_threshold=None): from meshmode.discretization import Discretization from meshmode.discretization.poly_element import ( InterpolatoryQuadratureSimplexGroupFactory) target_order = TARGET_ORDER mesh = mesh_getter(nelements, target_order) pre_density_discr = Discretization( queue.context, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order)) refiner_extra_kwargs = {} if k != 0: refiner_extra_kwargs["kernel_length_scale"] = 5 / k from pytential.qbx import QBXLayerPotentialSource lpot_source = QBXLayerPotentialSource( pre_density_discr, OVSMP_FACTOR * target_order, fmm_backend=fmm_backend, _well_sep_is_n_away=well_sep_is_n_away, _expansions_in_tree_have_extent=with_extents, _expansion_stick_out_factor=stickout_factor, _max_leaf_refine_weight=max_leaf_refine_weight, target_association_tolerance=1e-3, fmm_order=10, qbx_order=10, _from_sep_smaller_min_nsources_cumul=from_sep_smaller_threshold, _from_sep_smaller_crit="static_linf", _box_extent_norm="linf", ) lpot_source, _ = lpot_source.with_refinement(**refiner_extra_kwargs) return lpot_source
def with_refinement(self, target_order=None, kernel_length_scale=None, maxiter=None, visualize=False, refiner=None, _expansion_disturbance_tolerance=None, _force_stage2_uniform_refinement_rounds=None, _scaled_max_curvature_threshold=None): """ :arg refiner: If the mesh underlying :attr:`density_discr` is itself the result of refinement, then its :class:`meshmode.refinement.Refiner` instance may need to be reused for continued refinement. This argument provides the opportunity to pass in an existing refiner that should be used for continued refinement. :returns: a tuple ``(lpot_src, cnx)``, where ``lpot_src`` is a :class:`QBXLayerPotentialSource` and ``cnx`` is a :class:`meshmode.discretization.connection.DiscretizationConnection` from the originally given to the refined geometry. """ from pytential.qbx.refinement import refine_for_global_qbx from meshmode.discretization.poly_element import ( InterpolatoryQuadratureSimplexGroupFactory) if target_order is None: target_order = self.density_discr.groups[0].order with cl.CommandQueue(self.cl_context) as queue: lpot, connection = refine_for_global_qbx( self, self.refiner_code_container.get_wrangler(queue), InterpolatoryQuadratureSimplexGroupFactory(target_order), kernel_length_scale=kernel_length_scale, maxiter=maxiter, visualize=visualize, expansion_disturbance_tolerance= _expansion_disturbance_tolerance, force_stage2_uniform_refinement_rounds=( _force_stage2_uniform_refinement_rounds), scaled_max_curvature_threshold=( _scaled_max_curvature_threshold), refiner=refiner) return lpot, connection
def get_ellipse_with_ref_mean_curvature(actx, nelements, aspect=1): order = 4 mesh = make_curve_mesh(partial(ellipse, aspect), np.linspace(0, 1, nelements + 1), order) discr = Discretization(actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(order)) from meshmode.dof_array import thaw nodes = thaw(actx, discr.nodes()) a = 1 b = 1 / aspect t = actx.np.arctan2(nodes[1] * aspect, nodes[0]) return discr, a * b / ((a * actx.np.sin(t))**2 + (b * actx.np.cos(t))**2)**(3 / 2)
def create_discretization(queue, ndim, nelements=42, mesh_name=None, order=4): ctx = queue.context # construct mesh if ndim == 2: from functools import partial from meshmode.mesh.generation import make_curve_mesh, ellipse, starfish if mesh_name is None: mesh_name = "ellipse" t = np.linspace(0.0, 1.0, nelements + 1) if mesh_name == "ellipse": mesh = make_curve_mesh(partial(ellipse, 2), t, order=order) elif mesh_name == "starfish": mesh = make_curve_mesh(starfish, t, order=order) else: raise ValueError('unknown mesh name: {}'.format(mesh_name)) elif ndim == 3: from meshmode.mesh.generation import generate_torus from meshmode.mesh.generation import generate_warped_rect_mesh if mesh_name is None: mesh_name = "torus" if mesh_name == "torus": mesh = generate_torus(10.0, 5.0, order=order, n_minor=nelements, n_major=nelements) elif mesh_name == "warp": mesh = generate_warped_rect_mesh(ndim, order=order, n=nelements) else: raise ValueError("unknown mesh name: {}".format(mesh_name)) else: raise ValueError("unsupported dimension: {}".format(ndim)) # create discretization from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory discr = Discretization(ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(order)) return discr
def test_unregularized_with_ones_kernel(ctx_factory): cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) nelements = 10 order = 8 mesh = make_curve_mesh(partial(ellipse, 1), np.linspace(0, 1, nelements+1), order) from meshmode.discretization import Discretization from meshmode.discretization.poly_element import \ InterpolatoryQuadratureSimplexGroupFactory discr = Discretization(actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(order)) from pytential.unregularized import UnregularizedLayerPotentialSource lpot_source = UnregularizedLayerPotentialSource(discr) from pytential.target import PointsTarget targets = PointsTarget(np.zeros((2, 1), dtype=float)) places = GeometryCollection({ sym.DEFAULT_SOURCE: lpot_source, sym.DEFAULT_TARGET: lpot_source, "target_non_self": targets}) from sumpy.kernel import one_kernel_2d sigma_sym = sym.var("sigma") op = sym.IntG(one_kernel_2d, sigma_sym, qbx_forced_limit=None) sigma = discr.zeros(actx) + 1 result_self = bind(places, op, auto_where=places.auto_where)( actx, sigma=sigma) result_nonself = bind(places, op, auto_where=(places.auto_source, "target_non_self"))( actx, sigma=sigma) from meshmode.dof_array import flatten assert np.allclose(actx.to_numpy(flatten(result_self)), 2 * np.pi) assert np.allclose(actx.to_numpy(result_nonself), 2 * np.pi)