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 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 test_3d_orientation(ctx_factory, what, mesh_gen_func, visualize=False):
pytest.importorskip("pytential")
logging.basicConfig(level=logging.INFO)
ctx = ctx_factory()
queue = cl.CommandQueue(ctx)
mesh = mesh_gen_func()
logger.info("%d elements" % mesh.nelements)
from meshmode.discretization import Discretization
discr = Discretization(ctx, mesh,
PolynomialWarpAndBlendGroupFactory(1))
from pytential import bind, sym
# {{{ check normals point outward
if what == "torus":
nodes = sym.nodes(mesh.ambient_dim).as_vector()
angle = sym.atan2(nodes[1], nodes[0])
center_nodes = sym.make_obj_array([
5*sym.cos(angle),
5*sym.sin(angle),
0*angle])
normal_outward_expr = (
sym.normal(mesh.ambient_dim) | (nodes-center_nodes))
else:
normal_outward_expr = (
sym.normal(mesh.ambient_dim) | sym.nodes(mesh.ambient_dim))
normal_outward_check = bind(discr, normal_outward_expr)(queue).as_scalar() > 0
assert normal_outward_check.get().all(), normal_outward_check.get()
# }}}
normals = bind(discr, sym.normal(mesh.ambient_dim).xproject(1))(queue)
if visualize:
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 1)
vis.write_vtk_file("normals.vtu", [
("normals", normals),
])