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)
