def interior_faces_connection(self):
from meshmode.discretization.connection import (make_face_restriction,
FACE_RESTR_INTERIOR)
return make_face_restriction(self.volume_discr,
self.group_factory,
FACE_RESTR_INTERIOR,
per_face_groups=False)
def all_faces_connection(self):
from meshmode.discretization.connection import (make_face_restriction,
FACE_RESTR_ALL)
return make_face_restriction(self.volume_discr,
self.group_factory,
FACE_RESTR_ALL,
per_face_groups=False)
def _boundary_connection(self, boundary_tag):
from meshmode.discretization.connection import make_face_restriction
return make_face_restriction(
self._setup_actx,
self._volume_discr,
self.group_factory_for_quadrature_tag(sym.QTAG_NONE),
boundary_tag=boundary_tag)
def _all_faces_volume_connection(self):
return make_face_restriction(
self._setup_actx,
self._volume_discr,
self.group_factory_for_discretization_tag(DISCR_TAG_BASE),
FACE_RESTR_ALL,
# FIXME: This will need to change as soon as we support
# pyramids or other elements with non-identical face
# types.
per_face_groups=False)
def test_mesh_with_interior_unit_nodes(actx_factory, ambient_dim):
actx = actx_factory()
# NOTE: smaller orders or coarser meshes make the cases fail the
# node_vertex_consistency test; the default warp_and_blend_nodes have
# nodes at the vertices, so they pass for much smaller tolerances
order = 8
nelements = 32
n_minor = 2 * nelements
uniform_refinement_rounds = 4
import modepy as mp
if ambient_dim == 2:
unit_nodes = mp.LegendreGaussQuadrature(order,
force_dim_axis=True).nodes
mesh = mgen.make_curve_mesh(partial(mgen.ellipse, 2.0),
np.linspace(0.0, 1.0, nelements + 1),
order=order,
unit_nodes=unit_nodes)
elif ambient_dim == 3:
unit_nodes = mp.VioreanuRokhlinSimplexQuadrature(order, 2).nodes
mesh = mgen.generate_torus(4.0,
2.0,
n_major=2 * n_minor,
n_minor=n_minor,
order=order,
unit_nodes=unit_nodes)
mesh = mgen.generate_icosphere(
1.0,
uniform_refinement_rounds=uniform_refinement_rounds,
order=order,
unit_nodes=unit_nodes)
else:
raise ValueError(f"unsupported dimension: '{ambient_dim}'")
assert mesh.facial_adjacency_groups
assert mesh.nodal_adjacency
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import QuadratureSimplexGroupFactory
discr = Discretization(actx, mesh, QuadratureSimplexGroupFactory(order))
from meshmode.discretization.connection import make_face_restriction
conn = make_face_restriction(
actx,
discr,
group_factory=QuadratureSimplexGroupFactory(order),
boundary_tag=FACE_RESTR_ALL)
assert conn
def _all_faces_volume_connection(self):
from meshmode.discretization.connection import (make_face_restriction,
FACE_RESTR_ALL)
return make_face_restriction(
self._volume_discr,
self.group_factory_for_quadrature_tag(sym.QTAG_NONE),
FACE_RESTR_ALL,
# FIXME: This will need to change as soon as we support
# pyramids or other elements with non-identical face
# types.
per_face_groups=False)
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 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 __init__(self,
cl_ctx,
fspace_analog,
bdy_id=None,
with_refinement=False):
discr = fspace_analog.discretization()
factory = fspace_analog.factory()
bdy_connection = None
if bdy_id is not None:
bdy_connection = make_face_restriction(discr, factory, bdy_id)
discr = bdy_connection.to_discr
self._discr = discr
self._connection = bdy_connection
self._refine = with_refinement
def test_opposite_face_interpolation(ctx_getter, group_factory, mesh_name, dim,
mesh_pars):
logging.basicConfig(level=logging.INFO)
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, make_opposite_face_connection, check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 5
def f(x):
return 0.1 * cl.clmath.sin(30 * x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(FileSource("blob-2d.step"),
2,
order=order,
force_ambient_dim=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %s;" % h
])
print("END GEN")
elif mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(cl_ctx, mesh, group_factory(order))
print("h=%s -> %d elements" %
(h, sum(mgrp.nelements for mgrp in mesh.groups)))
bdry_connection = make_face_restriction(vol_discr,
group_factory(order),
FRESTR_INTERIOR_FACES)
bdry_discr = bdry_connection.to_discr
opp_face = make_opposite_face_connection(bdry_connection)
check_connection(opp_face)
bdry_x = bdry_discr.nodes()[0].with_queue(queue)
bdry_f = f(bdry_x)
bdry_f_2 = opp_face(queue, bdry_f)
err = la.norm((bdry_f - bdry_f_2).get(), np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1e-13)
def _test_mpi_boundary_swap(dim, order, num_groups):
from meshmode.distributed import MPIMeshDistributor, MPIBoundaryCommSetupHelper
from mpi4py import MPI
mpi_comm = MPI.COMM_WORLD
i_local_part = mpi_comm.Get_rank()
num_parts = mpi_comm.Get_size()
mesh_dist = MPIMeshDistributor(mpi_comm)
if mesh_dist.is_mananger_rank():
np.random.seed(42)
from meshmode.mesh.generation import generate_warped_rect_mesh
meshes = [generate_warped_rect_mesh(dim, order=order, nelements_side=4)
for _ in range(num_groups)]
if num_groups > 1:
from meshmode.mesh.processing import merge_disjoint_meshes
mesh = merge_disjoint_meshes(meshes)
else:
mesh = meshes[0]
part_per_element = np.random.randint(num_parts, size=mesh.nelements)
local_mesh = mesh_dist.send_mesh_parts(mesh, part_per_element, num_parts)
else:
local_mesh = mesh_dist.receive_mesh_part()
group_factory = PolynomialWarpAndBlendGroupFactory(order)
from arraycontext import PyOpenCLArrayContext
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
from meshmode.discretization import Discretization
vol_discr = Discretization(actx, local_mesh, group_factory)
from meshmode.distributed import get_connected_partitions
connected_parts = get_connected_partitions(local_mesh)
# Check that the connectivity makes sense before doing any communication
_test_connected_parts(mpi_comm, connected_parts)
from meshmode.discretization.connection import make_face_restriction
from meshmode.mesh import BTAG_PARTITION
local_bdry_conns = {}
for i_remote_part in connected_parts:
local_bdry_conns[i_remote_part] = make_face_restriction(
actx, vol_discr, group_factory, BTAG_PARTITION(i_remote_part))
remote_to_local_bdry_conns = {}
with MPIBoundaryCommSetupHelper(mpi_comm, actx, local_bdry_conns,
bdry_grp_factory=group_factory) as bdry_setup_helper:
from meshmode.discretization.connection import check_connection
while True:
conns = bdry_setup_helper.complete_some()
if not conns:
break
for i_remote_part, conn in conns.items():
check_connection(actx, conn)
remote_to_local_bdry_conns[i_remote_part] = conn
_test_data_transfer(mpi_comm,
actx,
local_bdry_conns,
remote_to_local_bdry_conns,
connected_parts)
logger.debug("Rank %d exiting", i_local_part)
def test_all_faces_interpolation(ctx_getter, mesh_name, dim, mesh_pars,
per_face_groups):
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, make_face_to_all_faces_embedding,
check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 4
def f(x):
return 0.1 * cl.clmath.sin(30 * x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(FileSource("blob-2d.step"),
2,
order=order,
force_ambient_dim=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %s;" % h
])
print("END GEN")
elif mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(cl_ctx, mesh,
PolynomialWarpAndBlendGroupFactory(order))
print("h=%s -> %d elements" %
(h, sum(mgrp.nelements for mgrp in mesh.groups)))
all_face_bdry_connection = make_face_restriction(
vol_discr,
PolynomialWarpAndBlendGroupFactory(order),
FRESTR_ALL_FACES,
per_face_groups=per_face_groups)
all_face_bdry_discr = all_face_bdry_connection.to_discr
for ito_grp, ceg in enumerate(all_face_bdry_connection.groups):
for ibatch, batch in enumerate(ceg.batches):
assert np.array_equal(batch.from_element_indices.get(queue),
np.arange(vol_discr.mesh.nelements))
if per_face_groups:
assert ito_grp == batch.to_element_face
else:
assert ibatch == batch.to_element_face
all_face_x = all_face_bdry_discr.nodes()[0].with_queue(queue)
all_face_f = f(all_face_x)
all_face_f_2 = all_face_bdry_discr.zeros(queue)
for boundary_tag in [
BTAG_ALL,
FRESTR_INTERIOR_FACES,
]:
bdry_connection = make_face_restriction(
vol_discr,
PolynomialWarpAndBlendGroupFactory(order),
boundary_tag,
per_face_groups=per_face_groups)
bdry_discr = bdry_connection.to_discr
bdry_x = bdry_discr.nodes()[0].with_queue(queue)
bdry_f = f(bdry_x)
all_face_embedding = make_face_to_all_faces_embedding(
bdry_connection, all_face_bdry_discr)
check_connection(all_face_embedding)
all_face_f_2 += all_face_embedding(queue, bdry_f)
err = la.norm((all_face_f - all_face_f_2).get(), np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1e-14)
def _boundary_connection(self, boundary_tag):
return make_face_restriction(
self._setup_actx,
self._volume_discr,
self.group_factory_for_discretization_tag(DISCR_TAG_BASE),
boundary_tag=boundary_tag)
def main():
import logging
logging.basicConfig(level=logging.INFO)
ctx = cl.create_some_context()
queue = cl.CommandQueue(ctx)
if 1:
ext = 0.5
mesh = generate_regular_rect_mesh(a=(-ext / 2, -ext / 2),
b=(ext / 2, ext / 2),
n=(int(ext / h), int(ext / h)))
else:
mesh = generate_gmsh(FileSource("circle.step"),
2,
order=mesh_order,
force_ambient_dim=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % h
])
logger.info("%d elements" % mesh.nelements)
# {{{ discretizations and connections
vol_discr = Discretization(
ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(vol_quad_order))
ovsmp_vol_discr = Discretization(
ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(vol_ovsmp_quad_order))
from meshmode.mesh import BTAG_ALL
from meshmode.discretization.connection import (make_face_restriction,
make_same_mesh_connection)
bdry_connection = make_face_restriction(
vol_discr, InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order),
BTAG_ALL)
bdry_discr = bdry_connection.to_discr
vol_to_ovsmp_vol = make_same_mesh_connection(ovsmp_vol_discr, vol_discr)
# }}}
# {{{ visualizers
vol_vis = make_visualizer(queue, vol_discr, 20)
bdry_vis = make_visualizer(queue, bdry_discr, 20)
# }}}
vol_x = vol_discr.nodes().with_queue(queue)
ovsmp_vol_x = ovsmp_vol_discr.nodes().with_queue(queue)
rhs = rhs_func(vol_x[0], vol_x[1])
poisson_true_sol = sol_func(vol_x[0], vol_x[1])
vol_vis.write_vtk_file("volume.vtu", [("f", rhs)])
bdry_normals = bind(bdry_discr, p.normal(
mesh.ambient_dim))(queue).as_vector(dtype=object)
bdry_vis.write_vtk_file("boundary.vtu", [("normals", bdry_normals)])
bdry_nodes = bdry_discr.nodes().with_queue(queue)
bdry_f = rhs_func(bdry_nodes[0], bdry_nodes[1])
bdry_f_2 = bdry_connection(queue, rhs)
bdry_vis.write_vtk_file("y.vtu", [("f", bdry_f_2)])
if 0:
vol_vis.show_scalar_in_mayavi(rhs, do_show=False)
bdry_vis.show_scalar_in_mayavi(bdry_f - bdry_f_2,
line_width=10,
do_show=False)
import mayavi.mlab as mlab
mlab.colorbar()
mlab.show()
# {{{ compute volume potential
from sumpy.qbx import LayerPotential
from sumpy.expansion.local import LineTaylorLocalExpansion
def get_kernel():
from sumpy.symbolic import pymbolic_real_norm_2
from pymbolic.primitives import make_sym_vector
from pymbolic import var
d = make_sym_vector("d", 3)
r = pymbolic_real_norm_2(d[:-1])
# r3d = pymbolic_real_norm_2(d)
#expr = var("log")(r3d)
log = var("log")
sqrt = var("sqrt")
a = d[-1]
expr = log(r)
expr = log(sqrt(r**2 + a**2))
expr = log(sqrt(r + a**2))
#expr = log(sqrt(r**2 + a**2))-a**2/2/(r**2+a**2)
#expr = 2*log(sqrt(r**2 + a**2))
scaling = 1 / (2 * var("pi"))
from sumpy.kernel import ExpressionKernel
return ExpressionKernel(dim=3,
expression=expr,
global_scaling_const=scaling,
is_complex_valued=False)
laplace_2d_in_3d_kernel = get_kernel()
layer_pot = LayerPotential(
ctx, [LineTaylorLocalExpansion(laplace_2d_in_3d_kernel, order=0)])
targets = cl.array.zeros(queue, (3, ) + vol_x.shape[1:], vol_x.dtype)
targets[:2] = vol_x
center_dist = 0.125 * np.min(
cl.clmath.sqrt(
bind(vol_discr, p.area_element(mesh.ambient_dim,
mesh.dim))(queue)).get())
centers = make_obj_array(
[ci.copy().reshape(vol_discr.nnodes) for ci in targets])
centers[2][:] = center_dist
print(center_dist)
sources = cl.array.zeros(queue, (3, ) + ovsmp_vol_x.shape[1:],
ovsmp_vol_x.dtype)
sources[:2] = ovsmp_vol_x
ovsmp_rhs = vol_to_ovsmp_vol(queue, rhs)
ovsmp_vol_weights = bind(
ovsmp_vol_discr,
p.area_element(mesh.ambient_dim, mesh.dim) * p.QWeight())(queue)
print("volume: %d source nodes, %d target nodes" %
(ovsmp_vol_discr.nnodes, vol_discr.nnodes))
evt, (vol_pot, ) = layer_pot(
queue,
targets=targets.reshape(3, vol_discr.nnodes),
centers=centers,
sources=sources.reshape(3, ovsmp_vol_discr.nnodes),
strengths=((ovsmp_vol_weights * ovsmp_rhs).reshape(
ovsmp_vol_discr.nnodes), ),
expansion_radii=np.zeros(vol_discr.nnodes),
)
vol_pot_bdry = bdry_connection(queue, vol_pot)
# }}}
# {{{ solve bvp
from sumpy.kernel import LaplaceKernel
from pytential.symbolic.pde.scalar import DirichletOperator
op = DirichletOperator(LaplaceKernel(2), -1, use_l2_weighting=True)
sym_sigma = sym.var("sigma")
op_sigma = op.operator(sym_sigma)
from pytential.qbx import QBXLayerPotentialSource
qbx = QBXLayerPotentialSource(
bdry_discr,
fine_order=bdry_ovsmp_quad_order,
qbx_order=qbx_order,
fmm_order=fmm_order,
)
bound_op = bind(qbx, op_sigma)
poisson_bc = poisson_bc_func(bdry_nodes[0], bdry_nodes[1])
bvp_bc = poisson_bc - vol_pot_bdry
bdry_f = rhs_func(bdry_nodes[0], bdry_nodes[1])
bvp_rhs = bind(bdry_discr, op.prepare_rhs(sym.var("bc")))(queue, bc=bvp_bc)
from pytential.solve import gmres
gmres_result = gmres(bound_op.scipy_op(queue, "sigma", dtype=np.float64),
bvp_rhs,
tol=1e-14,
progress=True,
hard_failure=False)
sigma = gmres_result.solution
print("gmres state:", gmres_result.state)
# }}}
bvp_sol = bind((qbx, vol_discr), op.representation(sym_sigma))(queue,
sigma=sigma)
poisson_sol = bvp_sol + vol_pot
poisson_err = poisson_sol - poisson_true_sol
rel_err = (norm(vol_discr, queue, poisson_err) /
norm(vol_discr, queue, poisson_true_sol))
bdry_vis.write_vtk_file("poisson-boundary.vtu", [
("vol_pot_bdry", vol_pot_bdry),
("sigma", sigma),
])
vol_vis.write_vtk_file("poisson-volume.vtu", [
("bvp_sol", bvp_sol),
("poisson_sol", poisson_sol),
("poisson_true_sol", poisson_true_sol),
("poisson_err", poisson_err),
("vol_pot", vol_pot),
("rhs", rhs),
])
print("h = %s" % h)
print("mesh_order = %s" % mesh_order)
print("vol_quad_order = %s" % vol_quad_order)
print("vol_ovsmp_quad_order = %s" % vol_ovsmp_quad_order)
print("bdry_quad_order = %s" % bdry_quad_order)
print("bdry_ovsmp_quad_order = %s" % bdry_ovsmp_quad_order)
print("qbx_order = %s" % qbx_order)
#print("vol_qbx_order = %s" % vol_qbx_order)
print("fmm_order = %s" % fmm_order)
print()
print("rel err: %g" % rel_err)
def test_boundary_interpolation(ctx_getter, group_factory, boundary_tag,
mesh_name, dim, mesh_pars, per_face_groups):
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (make_face_restriction,
check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 4
def f(x):
return 0.1 * cl.clmath.sin(30 * x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(FileSource("blob-2d.step"),
2,
order=order,
force_ambient_dim=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %s;" % h
])
print("END GEN")
elif mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(cl_ctx, mesh, group_factory(order))
print("h=%s -> %d elements" %
(h, sum(mgrp.nelements for mgrp in mesh.groups)))
x = vol_discr.nodes()[0].with_queue(queue)
vol_f = f(x)
bdry_connection = make_face_restriction(
vol_discr,
group_factory(order),
boundary_tag,
per_face_groups=per_face_groups)
check_connection(bdry_connection)
bdry_discr = bdry_connection.to_discr
bdry_x = bdry_discr.nodes()[0].with_queue(queue)
bdry_f = f(bdry_x)
bdry_f_2 = bdry_connection(queue, vol_f)
if mesh_name == "blob" and dim == 2:
mat = bdry_connection.full_resample_matrix(queue).get(queue)
bdry_f_2_by_mat = mat.dot(vol_f.get())
mat_error = la.norm(bdry_f_2.get(queue=queue) - bdry_f_2_by_mat)
assert mat_error < 1e-14, mat_error
err = la.norm((bdry_f - bdry_f_2).get(), np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1e-14)
def test_sanity_balls(ctx_getter, src_file, dim, mesh_order,
visualize=False):
pytest.importorskip("pytential")
logging.basicConfig(level=logging.INFO)
ctx = ctx_getter()
queue = cl.CommandQueue(ctx)
from pytools.convergence import EOCRecorder
vol_eoc_rec = EOCRecorder()
surf_eoc_rec = EOCRecorder()
# overkill
quad_order = mesh_order
from pytential import bind, sym
for h in [0.2, 0.14, 0.1]:
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource(src_file), dim, order=mesh_order,
other_options=["-string", "Mesh.CharacteristicLengthMax = %g;" % h],
force_ambient_dim=dim)
logger.info("%d elements" % mesh.nelements)
# {{{ discretizations and connections
from meshmode.discretization import Discretization
vol_discr = Discretization(ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(quad_order))
from meshmode.discretization.connection import make_face_restriction
bdry_connection = make_face_restriction(
vol_discr,
InterpolatoryQuadratureSimplexGroupFactory(quad_order),
BTAG_ALL)
bdry_discr = bdry_connection.to_discr
# }}}
# {{{ visualizers
from meshmode.discretization.visualization import make_visualizer
vol_vis = make_visualizer(queue, vol_discr, 20)
bdry_vis = make_visualizer(queue, bdry_discr, 20)
# }}}
from math import gamma
true_surf = 2*np.pi**(dim/2)/gamma(dim/2)
true_vol = true_surf/dim
vol_x = vol_discr.nodes().with_queue(queue)
vol_one = vol_x[0].copy()
vol_one.fill(1)
from pytential import norm, integral # noqa
comp_vol = integral(vol_discr, queue, vol_one)
rel_vol_err = abs(true_vol - comp_vol) / true_vol
vol_eoc_rec.add_data_point(h, rel_vol_err)
print("VOL", true_vol, comp_vol)
bdry_x = bdry_discr.nodes().with_queue(queue)
bdry_one_exact = bdry_x[0].copy()
bdry_one_exact.fill(1)
bdry_one = bdry_connection(queue, vol_one).with_queue(queue)
intp_err = norm(bdry_discr, queue, bdry_one-bdry_one_exact)
assert intp_err < 1e-14
comp_surf = integral(bdry_discr, queue, bdry_one)
rel_surf_err = abs(true_surf - comp_surf) / true_surf
surf_eoc_rec.add_data_point(h, rel_surf_err)
print("SURF", true_surf, comp_surf)
if visualize:
vol_vis.write_vtk_file("volume-h=%g.vtu" % h, [
("f", vol_one),
("area_el", bind(vol_discr, sym.area_element())(queue)),
])
bdry_vis.write_vtk_file("boundary-h=%g.vtu" % h, [("f", bdry_one)])
# {{{ check normals point outward
normal_outward_check = bind(bdry_discr,
sym.normal() | sym.Nodes(),
)(queue).as_scalar() > 0
assert normal_outward_check.get().all(), normal_outward_check.get()
# }}}
print("---------------------------------")
print("VOLUME")
print("---------------------------------")
print(vol_eoc_rec)
assert vol_eoc_rec.order_estimate() >= mesh_order
print("---------------------------------")
print("SURFACE")
print("---------------------------------")
print(surf_eoc_rec)
assert surf_eoc_rec.order_estimate() >= mesh_order
def _test_mpi_boundary_swap(dim, order, num_groups):
from meshmode.distributed import MPIMeshDistributor, MPIBoundaryCommSetupHelper
from mpi4py import MPI
mpi_comm = MPI.COMM_WORLD
i_local_part = mpi_comm.Get_rank()
num_parts = mpi_comm.Get_size()
mesh_dist = MPIMeshDistributor(mpi_comm)
if mesh_dist.is_mananger_rank():
np.random.seed(42)
from meshmode.mesh.generation import generate_warped_rect_mesh
meshes = [
generate_warped_rect_mesh(dim, order=order, n=4)
for _ in range(num_groups)
]
if num_groups > 1:
from meshmode.mesh.processing import merge_disjoint_meshes
mesh = merge_disjoint_meshes(meshes)
else:
mesh = meshes[0]
part_per_element = np.random.randint(num_parts, size=mesh.nelements)
local_mesh = mesh_dist.send_mesh_parts(mesh, part_per_element,
num_parts)
else:
local_mesh = mesh_dist.receive_mesh_part()
group_factory = PolynomialWarpAndBlendGroupFactory(order)
from meshmode.array_context import PyOpenCLArrayContext
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
from meshmode.discretization import Discretization
vol_discr = Discretization(actx, local_mesh, group_factory)
from meshmode.distributed import get_connected_partitions
connected_parts = get_connected_partitions(local_mesh)
assert i_local_part not in connected_parts
bdry_setup_helpers = {}
local_bdry_conns = {}
from meshmode.discretization.connection import make_face_restriction
from meshmode.mesh import BTAG_PARTITION
for i_remote_part in connected_parts:
local_bdry_conns[i_remote_part] = make_face_restriction(
actx, vol_discr, group_factory, BTAG_PARTITION(i_remote_part))
setup_helper = bdry_setup_helpers[i_remote_part] = \
MPIBoundaryCommSetupHelper(
mpi_comm, actx, local_bdry_conns[i_remote_part],
i_remote_part, bdry_grp_factory=group_factory)
setup_helper.post_sends()
remote_to_local_bdry_conns = {}
from meshmode.discretization.connection import check_connection
while bdry_setup_helpers:
for i_remote_part, setup_helper in bdry_setup_helpers.items():
if setup_helper.is_setup_ready():
assert bdry_setup_helpers.pop(i_remote_part) is setup_helper
conn = setup_helper.complete_setup()
check_connection(actx, conn)
remote_to_local_bdry_conns[i_remote_part] = conn
break
# FIXME: Not ideal, busy-waits
_test_data_transfer(mpi_comm, actx, local_bdry_conns,
remote_to_local_bdry_conns, connected_parts)
logger.debug("Rank %d exiting", i_local_part)
def test_partition_interpolation(ctx_factory, dim, mesh_pars,
num_parts, num_groups, part_method):
np.random.seed(42)
group_factory = PolynomialWarpAndBlendGroupFactory
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
order = 4
def f(x):
return 10.*actx.np.sin(50.*x)
for n in mesh_pars:
from meshmode.mesh.generation import generate_warped_rect_mesh
base_mesh = generate_warped_rect_mesh(dim, order=order, n=n)
if num_groups > 1:
from meshmode.mesh.processing import split_mesh_groups
# Group every Nth element
element_flags = np.arange(base_mesh.nelements,
dtype=base_mesh.element_id_dtype) % num_groups
mesh = split_mesh_groups(base_mesh, element_flags)
else:
mesh = base_mesh
if part_method == "random":
part_per_element = np.random.randint(num_parts, size=mesh.nelements)
else:
pytest.importorskip('pymetis')
from meshmode.distributed import get_partition_by_pymetis
part_per_element = get_partition_by_pymetis(mesh, num_parts,
connectivity=part_method)
from meshmode.mesh.processing import partition_mesh
part_meshes = [
partition_mesh(mesh, part_per_element, i)[0] for i in range(num_parts)]
connected_parts = set()
for i_local_part, part_mesh in enumerate(part_meshes):
from meshmode.distributed import get_connected_partitions
neighbors = get_connected_partitions(part_mesh)
for i_remote_part in neighbors:
connected_parts.add((i_local_part, i_remote_part))
from meshmode.discretization import Discretization
vol_discrs = [Discretization(actx, part_meshes[i], group_factory(order))
for i in range(num_parts)]
from meshmode.mesh import BTAG_PARTITION
from meshmode.discretization.connection import (make_face_restriction,
make_partition_connection,
check_connection)
for i_local_part, i_remote_part in connected_parts:
# Mark faces within local_mesh that are connected to remote_mesh
local_bdry_conn = make_face_restriction(actx, vol_discrs[i_local_part],
group_factory(order),
BTAG_PARTITION(i_remote_part))
# Mark faces within remote_mesh that are connected to local_mesh
remote_bdry_conn = make_face_restriction(actx, vol_discrs[i_remote_part],
group_factory(order),
BTAG_PARTITION(i_local_part))
bdry_nelements = sum(
grp.nelements for grp in local_bdry_conn.to_discr.groups)
remote_bdry_nelements = sum(
grp.nelements for grp in remote_bdry_conn.to_discr.groups)
assert bdry_nelements == remote_bdry_nelements, \
"partitions do not have the same number of connected elements"
# Gather just enough information for the connection
local_bdry = local_bdry_conn.to_discr
local_mesh = part_meshes[i_local_part]
local_adj_groups = [local_mesh.facial_adjacency_groups[i][None]
for i in range(len(local_mesh.groups))]
local_batches = [local_bdry_conn.groups[i].batches
for i in range(len(local_mesh.groups))]
local_from_elem_faces = [[batch.to_element_face
for batch in grp_batches]
for grp_batches in local_batches]
local_from_elem_indices = [[batch.to_element_indices.get(queue=queue)
for batch in grp_batches]
for grp_batches in local_batches]
remote_bdry = remote_bdry_conn.to_discr
remote_mesh = part_meshes[i_remote_part]
remote_adj_groups = [remote_mesh.facial_adjacency_groups[i][None]
for i in range(len(remote_mesh.groups))]
remote_batches = [remote_bdry_conn.groups[i].batches
for i in range(len(remote_mesh.groups))]
remote_from_elem_faces = [[batch.to_element_face
for batch in grp_batches]
for grp_batches in remote_batches]
remote_from_elem_indices = [[batch.to_element_indices.get(queue=queue)
for batch in grp_batches]
for grp_batches in remote_batches]
# Connect from remote_mesh to local_mesh
remote_to_local_conn = make_partition_connection(
actx, local_bdry_conn, i_local_part, remote_bdry,
remote_adj_groups, remote_from_elem_faces,
remote_from_elem_indices)
# Connect from local mesh to remote mesh
local_to_remote_conn = make_partition_connection(
actx, remote_bdry_conn, i_remote_part, local_bdry,
local_adj_groups, local_from_elem_faces,
local_from_elem_indices)
check_connection(actx, remote_to_local_conn)
check_connection(actx, local_to_remote_conn)
true_local_points = f(thaw(actx, local_bdry.nodes()[0]))
remote_points = local_to_remote_conn(true_local_points)
local_points = remote_to_local_conn(remote_points)
err = flat_norm(true_local_points - local_points, np.inf)
# Can't currently expect exact results due to limitations of
# interpolation 'snapping' in DirectDiscretizationConnection's
# _resample_point_pick_indices
assert err < 1e-11
def test_opposite_face_interpolation(ctx_getter, group_factory,
mesh_name, dim, mesh_pars):
logging.basicConfig(level=logging.INFO)
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, make_opposite_face_connection,
check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 5
def f(x):
return 0.1*cl.clmath.sin(30*x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(
FileSource("blob-2d.step"), 2, order=order,
force_ambient_dim=2,
other_options=[
"-string", "Mesh.CharacteristicLengthMax = %s;" % h]
)
print("END GEN")
elif mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par)
h = 1/mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(cl_ctx, mesh,
group_factory(order))
print("h=%s -> %d elements" % (
h, sum(mgrp.nelements for mgrp in mesh.groups)))
bdry_connection = make_face_restriction(
vol_discr, group_factory(order),
FRESTR_INTERIOR_FACES)
bdry_discr = bdry_connection.to_discr
opp_face = make_opposite_face_connection(bdry_connection)
check_connection(opp_face)
bdry_x = bdry_discr.nodes()[0].with_queue(queue)
bdry_f = f(bdry_x)
bdry_f_2 = opp_face(queue, bdry_f)
err = la.norm((bdry_f-bdry_f_2).get(), np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (
eoc_rec.order_estimate() >= order-0.5
or eoc_rec.max_error() < 1e-13)
def boundary_connection(self, boundary_tag):
from meshmode.discretization.connection import make_face_restriction
return make_face_restriction(self.volume_discr._setup_actx,
self.volume_discr,
self.group_factory,
boundary_tag=boundary_tag)
def test_opposite_face_interpolation(actx_factory, group_factory, mesh_name,
dim, mesh_pars):
if (group_factory is LegendreGaussLobattoTensorProductGroupFactory
and mesh_name in ["segment", "blob"]):
pytest.skip("tensor products not implemented on blobs")
logging.basicConfig(level=logging.INFO)
actx = actx_factory()
if group_factory is LegendreGaussLobattoTensorProductGroupFactory:
group_cls = TensorProductElementGroup
else:
group_cls = SimplexElementGroup
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, make_opposite_face_connection, check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 5
def f(x):
return 0.1 * actx.np.sin(30 * x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "segment":
assert dim == 1
mesh = mgen.generate_box_mesh([np.linspace(-0.5, 0.5, mesh_par)],
order=order,
group_cls=group_cls)
h = 1.0 / mesh_par
elif mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(
FileSource("blob-2d.step"),
2,
order=order,
force_ambient_dim=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %s;" % h
],
target_unit="MM",
)
print("END GEN")
elif mesh_name == "warp":
mesh = mgen.generate_warped_rect_mesh(dim,
order=order,
nelements_side=mesh_par,
group_cls=group_cls)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(actx, mesh, group_factory(order))
print("h=%s -> %d elements" %
(h, sum(mgrp.nelements for mgrp in mesh.groups)))
bdry_connection = make_face_restriction(actx, vol_discr,
group_factory(order),
FACE_RESTR_INTERIOR)
bdry_discr = bdry_connection.to_discr
opp_face = make_opposite_face_connection(actx, bdry_connection)
check_connection(actx, opp_face)
bdry_x = thaw(bdry_discr.nodes()[0], actx)
bdry_f = f(bdry_x)
bdry_f_2 = opp_face(bdry_f)
err = flat_norm(bdry_f - bdry_f_2, np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1.7e-13)
def test_all_faces_interpolation(actx_factory, group_factory, mesh_name, dim,
mesh_pars, per_face_groups):
if (group_factory is LegendreGaussLobattoTensorProductGroupFactory
and mesh_name == "blob"):
pytest.skip("tensor products not implemented on blobs")
actx = actx_factory()
if group_factory is LegendreGaussLobattoTensorProductGroupFactory:
group_cls = TensorProductElementGroup
else:
group_cls = SimplexElementGroup
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, make_face_to_all_faces_embedding,
check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 4
def f(x):
return 0.1 * actx.np.sin(30 * x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(
FileSource("blob-2d.step"),
2,
order=order,
force_ambient_dim=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %s;" % h
],
target_unit="MM",
)
print("END GEN")
elif mesh_name == "warp":
mesh = mgen.generate_warped_rect_mesh(dim,
order=4,
nelements_side=mesh_par,
group_cls=group_cls)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(actx, mesh, group_factory(order))
print("h=%s -> %d elements" %
(h, sum(mgrp.nelements for mgrp in mesh.groups)))
all_face_bdry_connection = make_face_restriction(
actx,
vol_discr,
group_factory(order),
FACE_RESTR_ALL,
per_face_groups=per_face_groups)
all_face_bdry_discr = all_face_bdry_connection.to_discr
for ito_grp, ceg in enumerate(all_face_bdry_connection.groups):
for ibatch, batch in enumerate(ceg.batches):
assert np.array_equal(
actx.to_numpy(actx.thaw(batch.from_element_indices)),
np.arange(vol_discr.mesh.nelements))
if per_face_groups:
assert ito_grp == batch.to_element_face
else:
assert ibatch == batch.to_element_face
all_face_x = thaw(all_face_bdry_discr.nodes()[0], actx)
all_face_f = f(all_face_x)
all_face_f_2 = all_face_bdry_discr.zeros(actx)
for boundary_tag in [
BTAG_ALL,
FACE_RESTR_INTERIOR,
]:
bdry_connection = make_face_restriction(
actx,
vol_discr,
group_factory(order),
boundary_tag,
per_face_groups=per_face_groups)
bdry_discr = bdry_connection.to_discr
bdry_x = thaw(bdry_discr.nodes()[0], actx)
bdry_f = f(bdry_x)
all_face_embedding = make_face_to_all_faces_embedding(
actx, bdry_connection, all_face_bdry_discr)
check_connection(actx, all_face_embedding)
all_face_f_2 = all_face_f_2 + all_face_embedding(bdry_f)
err = flat_norm(all_face_f - all_face_f_2, np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1e-14)
def test_boundary_interpolation(ctx_getter, group_factory, boundary_tag,
mesh_name, dim, mesh_pars, per_face_groups):
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 4
def f(x):
return 0.1*cl.clmath.sin(30*x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(
FileSource("blob-2d.step"), 2, order=order,
force_ambient_dim=2,
other_options=[
"-string", "Mesh.CharacteristicLengthMax = %s;" % h]
)
print("END GEN")
elif mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par)
h = 1/mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(cl_ctx, mesh,
group_factory(order))
print("h=%s -> %d elements" % (
h, sum(mgrp.nelements for mgrp in mesh.groups)))
x = vol_discr.nodes()[0].with_queue(queue)
vol_f = f(x)
bdry_connection = make_face_restriction(
vol_discr, group_factory(order),
boundary_tag, per_face_groups=per_face_groups)
check_connection(bdry_connection)
bdry_discr = bdry_connection.to_discr
bdry_x = bdry_discr.nodes()[0].with_queue(queue)
bdry_f = f(bdry_x)
bdry_f_2 = bdry_connection(queue, vol_f)
if mesh_name == "blob" and dim == 2:
mat = bdry_connection.full_resample_matrix(queue).get(queue)
bdry_f_2_by_mat = mat.dot(vol_f.get())
mat_error = la.norm(bdry_f_2.get(queue=queue) - bdry_f_2_by_mat)
assert mat_error < 1e-14, mat_error
err = la.norm((bdry_f-bdry_f_2).get(), np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (
eoc_rec.order_estimate() >= order-0.5
or eoc_rec.max_error() < 1e-14)
def test_sanity_single_element(ctx_getter, dim, order, visualize=False):
pytest.importorskip("pytential")
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from modepy.tools import unit_vertices
vertices = unit_vertices(dim).T.copy()
center = np.empty(dim, np.float64)
center.fill(-0.5)
import modepy as mp
from meshmode.mesh import SimplexElementGroup, Mesh, BTAG_ALL
mg = SimplexElementGroup(
order=order,
vertex_indices=np.arange(dim + 1, dtype=np.int32).reshape(1, -1),
nodes=mp.warp_and_blend_nodes(dim, order).reshape(dim, 1, -1),
dim=dim)
mesh = Mesh(vertices, [mg],
nodal_adjacency=None,
facial_adjacency_groups=None)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory
vol_discr = Discretization(cl_ctx, mesh,
PolynomialWarpAndBlendGroupFactory(order + 3))
# {{{ volume calculation check
vol_x = vol_discr.nodes().with_queue(queue)
vol_one = vol_x[0].copy()
vol_one.fill(1)
from pytential import norm, integral # noqa
from pytools import factorial
true_vol = 1 / factorial(dim) * 2**dim
comp_vol = integral(vol_discr, queue, vol_one)
rel_vol_err = abs(true_vol - comp_vol) / true_vol
assert rel_vol_err < 1e-12
# }}}
# {{{ boundary discretization
from meshmode.discretization.connection import make_face_restriction
bdry_connection = make_face_restriction(
vol_discr, PolynomialWarpAndBlendGroupFactory(order + 3), BTAG_ALL)
bdry_discr = bdry_connection.to_discr
# }}}
# {{{ visualizers
from meshmode.discretization.visualization import make_visualizer
#vol_vis = make_visualizer(queue, vol_discr, 4)
bdry_vis = make_visualizer(queue, bdry_discr, 4)
# }}}
from pytential import bind, sym
bdry_normals = bind(bdry_discr,
sym.normal(dim))(queue).as_vector(dtype=object)
if visualize:
bdry_vis.write_vtk_file("boundary.vtu",
[("bdry_normals", bdry_normals)])
from pytential import bind, sym
normal_outward_check = bind(
bdry_discr,
sym.normal(dim)
| (sym.nodes(dim) + 0.5 * sym.ones_vec(dim)),
)(queue).as_scalar() > 0
assert normal_outward_check.get().all(), normal_outward_check.get()
def test_all_faces_interpolation(ctx_getter, mesh_name, dim, mesh_pars,
per_face_groups):
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, make_face_to_all_faces_embedding,
check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 4
def f(x):
return 0.1*cl.clmath.sin(30*x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(
FileSource("blob-2d.step"), 2, order=order,
force_ambient_dim=2,
other_options=[
"-string", "Mesh.CharacteristicLengthMax = %s;" % h]
)
print("END GEN")
elif mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par)
h = 1/mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(cl_ctx, mesh,
PolynomialWarpAndBlendGroupFactory(order))
print("h=%s -> %d elements" % (
h, sum(mgrp.nelements for mgrp in mesh.groups)))
all_face_bdry_connection = make_face_restriction(
vol_discr, PolynomialWarpAndBlendGroupFactory(order),
FRESTR_ALL_FACES, per_face_groups=per_face_groups)
all_face_bdry_discr = all_face_bdry_connection.to_discr
for ito_grp, ceg in enumerate(all_face_bdry_connection.groups):
for ibatch, batch in enumerate(ceg.batches):
assert np.array_equal(
batch.from_element_indices.get(queue),
np.arange(vol_discr.mesh.nelements))
if per_face_groups:
assert ito_grp == batch.to_element_face
else:
assert ibatch == batch.to_element_face
all_face_x = all_face_bdry_discr.nodes()[0].with_queue(queue)
all_face_f = f(all_face_x)
all_face_f_2 = all_face_bdry_discr.zeros(queue)
for boundary_tag in [
BTAG_ALL,
FRESTR_INTERIOR_FACES,
]:
bdry_connection = make_face_restriction(
vol_discr, PolynomialWarpAndBlendGroupFactory(order),
boundary_tag, per_face_groups=per_face_groups)
bdry_discr = bdry_connection.to_discr
bdry_x = bdry_discr.nodes()[0].with_queue(queue)
bdry_f = f(bdry_x)
all_face_embedding = make_face_to_all_faces_embedding(
bdry_connection, all_face_bdry_discr)
check_connection(all_face_embedding)
all_face_f_2 += all_face_embedding(queue, bdry_f)
err = la.norm((all_face_f-all_face_f_2).get(), np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (
eoc_rec.order_estimate() >= order-0.5
or eoc_rec.max_error() < 1e-14)
def test_sanity_balls(ctx_getter, src_file, dim, mesh_order, visualize=False):
pytest.importorskip("pytential")
logging.basicConfig(level=logging.INFO)
ctx = ctx_getter()
queue = cl.CommandQueue(ctx)
from pytools.convergence import EOCRecorder
vol_eoc_rec = EOCRecorder()
surf_eoc_rec = EOCRecorder()
# overkill
quad_order = mesh_order
from pytential import bind, sym
for h in [0.2, 0.14, 0.1]:
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(FileSource(src_file),
dim,
order=mesh_order,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % h
],
force_ambient_dim=dim)
logger.info("%d elements" % mesh.nelements)
# {{{ discretizations and connections
from meshmode.discretization import Discretization
vol_discr = Discretization(
ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(quad_order))
from meshmode.discretization.connection import make_face_restriction
bdry_connection = make_face_restriction(
vol_discr, InterpolatoryQuadratureSimplexGroupFactory(quad_order),
BTAG_ALL)
bdry_discr = bdry_connection.to_discr
# }}}
# {{{ visualizers
from meshmode.discretization.visualization import make_visualizer
vol_vis = make_visualizer(queue, vol_discr, 20)
bdry_vis = make_visualizer(queue, bdry_discr, 20)
# }}}
from math import gamma
true_surf = 2 * np.pi**(dim / 2) / gamma(dim / 2)
true_vol = true_surf / dim
vol_x = vol_discr.nodes().with_queue(queue)
vol_one = vol_x[0].copy()
vol_one.fill(1)
from pytential import norm, integral # noqa
comp_vol = integral(vol_discr, queue, vol_one)
rel_vol_err = abs(true_vol - comp_vol) / true_vol
vol_eoc_rec.add_data_point(h, rel_vol_err)
print("VOL", true_vol, comp_vol)
bdry_x = bdry_discr.nodes().with_queue(queue)
bdry_one_exact = bdry_x[0].copy()
bdry_one_exact.fill(1)
bdry_one = bdry_connection(queue, vol_one).with_queue(queue)
intp_err = norm(bdry_discr, queue, bdry_one - bdry_one_exact)
assert intp_err < 1e-14
comp_surf = integral(bdry_discr, queue, bdry_one)
rel_surf_err = abs(true_surf - comp_surf) / true_surf
surf_eoc_rec.add_data_point(h, rel_surf_err)
print("SURF", true_surf, comp_surf)
if visualize:
vol_vis.write_vtk_file("volume-h=%g.vtu" % h, [
("f", vol_one),
("area_el", bind(vol_discr, sym.area_element())(queue)),
])
bdry_vis.write_vtk_file("boundary-h=%g.vtu" % h, [("f", bdry_one)])
# {{{ check normals point outward
normal_outward_check = bind(
bdry_discr,
sym.normal(mesh.ambient_dim) | sym.nodes(mesh.ambient_dim),
)(queue).as_scalar() > 0
assert normal_outward_check.get().all(), normal_outward_check.get()
# }}}
print("---------------------------------")
print("VOLUME")
print("---------------------------------")
print(vol_eoc_rec)
assert vol_eoc_rec.order_estimate() >= mesh_order
print("---------------------------------")
print("SURFACE")
print("---------------------------------")
print(surf_eoc_rec)
assert surf_eoc_rec.order_estimate() >= mesh_order
def main():
import logging
logging.basicConfig(level=logging.INFO)
ctx = cl.create_some_context()
queue = cl.CommandQueue(ctx)
if 1:
ext = 0.5
mesh = generate_regular_rect_mesh(
a=(-ext/2, -ext/2), b=(ext/2, ext/2), n=(int(ext/h), int(ext/h)))
else:
mesh = generate_gmsh(
FileSource("circle.step"), 2, order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = %g;" % h]
)
logger.info("%d elements" % mesh.nelements)
# {{{ discretizations and connections
vol_discr = Discretization(ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(vol_quad_order))
ovsmp_vol_discr = Discretization(ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(vol_ovsmp_quad_order))
from meshmode.mesh import BTAG_ALL
from meshmode.discretization.connection import (
make_face_restriction, make_same_mesh_connection)
bdry_connection = make_face_restriction(
vol_discr, InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order),
BTAG_ALL)
bdry_discr = bdry_connection.to_discr
vol_to_ovsmp_vol = make_same_mesh_connection(ovsmp_vol_discr, vol_discr)
# }}}
# {{{ visualizers
vol_vis = make_visualizer(queue, vol_discr, 20)
bdry_vis = make_visualizer(queue, bdry_discr, 20)
# }}}
vol_x = vol_discr.nodes().with_queue(queue)
ovsmp_vol_x = ovsmp_vol_discr.nodes().with_queue(queue)
rhs = rhs_func(vol_x[0], vol_x[1])
poisson_true_sol = sol_func(vol_x[0], vol_x[1])
vol_vis.write_vtk_file("volume.vtu", [("f", rhs)])
bdry_normals = bind(
bdry_discr, p.normal(mesh.ambient_dim))(queue).as_vector(dtype=object)
bdry_vis.write_vtk_file("boundary.vtu", [
("normals", bdry_normals)
])
bdry_nodes = bdry_discr.nodes().with_queue(queue)
bdry_f = rhs_func(bdry_nodes[0], bdry_nodes[1])
bdry_f_2 = bdry_connection(queue, rhs)
bdry_vis.write_vtk_file("y.vtu", [("f", bdry_f_2)])
if 0:
vol_vis.show_scalar_in_mayavi(rhs, do_show=False)
bdry_vis.show_scalar_in_mayavi(bdry_f - bdry_f_2, line_width=10,
do_show=False)
import mayavi.mlab as mlab
mlab.colorbar()
mlab.show()
# {{{ compute volume potential
from sumpy.qbx import LayerPotential
from sumpy.expansion.local import LineTaylorLocalExpansion
def get_kernel():
from sumpy.symbolic import pymbolic_real_norm_2
from pymbolic.primitives import make_sym_vector
from pymbolic import var
d = make_sym_vector("d", 3)
r = pymbolic_real_norm_2(d[:-1])
# r3d = pymbolic_real_norm_2(d)
#expr = var("log")(r3d)
log = var("log")
sqrt = var("sqrt")
a = d[-1]
expr = log(r)
expr = log(sqrt(r**2 + a**2))
expr = log(sqrt(r + a**2))
#expr = log(sqrt(r**2 + a**2))-a**2/2/(r**2+a**2)
#expr = 2*log(sqrt(r**2 + a**2))
scaling = 1/(2*var("pi"))
from sumpy.kernel import ExpressionKernel
return ExpressionKernel(
dim=3,
expression=expr,
global_scaling_const=scaling,
is_complex_valued=False)
laplace_2d_in_3d_kernel = get_kernel()
layer_pot = LayerPotential(ctx, [
LineTaylorLocalExpansion(laplace_2d_in_3d_kernel,
order=0)])
targets = cl.array.zeros(queue, (3,) + vol_x.shape[1:], vol_x.dtype)
targets[:2] = vol_x
center_dist = 0.125*np.min(
cl.clmath.sqrt(
bind(vol_discr,
p.area_element(mesh.ambient_dim, mesh.dim))
(queue)).get())
centers = make_obj_array([ci.copy().reshape(vol_discr.nnodes) for ci in targets])
centers[2][:] = center_dist
print(center_dist)
sources = cl.array.zeros(queue, (3,) + ovsmp_vol_x.shape[1:], ovsmp_vol_x.dtype)
sources[:2] = ovsmp_vol_x
ovsmp_rhs = vol_to_ovsmp_vol(queue, rhs)
ovsmp_vol_weights = bind(ovsmp_vol_discr,
p.area_element(mesh.ambient_dim, mesh.dim) * p.QWeight()
)(queue)
print("volume: %d source nodes, %d target nodes" % (
ovsmp_vol_discr.nnodes, vol_discr.nnodes))
evt, (vol_pot,) = layer_pot(
queue,
targets=targets.reshape(3, vol_discr.nnodes),
centers=centers,
sources=sources.reshape(3, ovsmp_vol_discr.nnodes),
strengths=(
(ovsmp_vol_weights*ovsmp_rhs).reshape(ovsmp_vol_discr.nnodes),),
expansion_radii=np.zeros(vol_discr.nnodes),
)
vol_pot_bdry = bdry_connection(queue, vol_pot)
# }}}
# {{{ solve bvp
from sumpy.kernel import LaplaceKernel
from pytential.symbolic.pde.scalar import DirichletOperator
op = DirichletOperator(LaplaceKernel(2), -1, use_l2_weighting=True)
sym_sigma = sym.var("sigma")
op_sigma = op.operator(sym_sigma)
from pytential.qbx import QBXLayerPotentialSource
qbx = QBXLayerPotentialSource(
bdry_discr, fine_order=bdry_ovsmp_quad_order, qbx_order=qbx_order,
fmm_order=fmm_order,
)
bound_op = bind(qbx, op_sigma)
poisson_bc = poisson_bc_func(bdry_nodes[0], bdry_nodes[1])
bvp_bc = poisson_bc - vol_pot_bdry
bdry_f = rhs_func(bdry_nodes[0], bdry_nodes[1])
bvp_rhs = bind(bdry_discr, op.prepare_rhs(sym.var("bc")))(queue, bc=bvp_bc)
from pytential.solve import gmres
gmres_result = gmres(
bound_op.scipy_op(queue, "sigma", dtype=np.float64),
bvp_rhs, tol=1e-14, progress=True,
hard_failure=False)
sigma = gmres_result.solution
print("gmres state:", gmres_result.state)
# }}}
bvp_sol = bind(
(qbx, vol_discr),
op.representation(sym_sigma))(queue, sigma=sigma)
poisson_sol = bvp_sol + vol_pot
poisson_err = poisson_sol-poisson_true_sol
rel_err = (
norm(vol_discr, queue, poisson_err)
/
norm(vol_discr, queue, poisson_true_sol))
bdry_vis.write_vtk_file("poisson-boundary.vtu", [
("vol_pot_bdry", vol_pot_bdry),
("sigma", sigma),
])
vol_vis.write_vtk_file("poisson-volume.vtu", [
("bvp_sol", bvp_sol),
("poisson_sol", poisson_sol),
("poisson_true_sol", poisson_true_sol),
("poisson_err", poisson_err),
("vol_pot", vol_pot),
("rhs", rhs),
])
print("h = %s" % h)
print("mesh_order = %s" % mesh_order)
print("vol_quad_order = %s" % vol_quad_order)
print("vol_ovsmp_quad_order = %s" % vol_ovsmp_quad_order)
print("bdry_quad_order = %s" % bdry_quad_order)
print("bdry_ovsmp_quad_order = %s" % bdry_ovsmp_quad_order)
print("qbx_order = %s" % qbx_order)
#print("vol_qbx_order = %s" % vol_qbx_order)
print("fmm_order = %s" % fmm_order)
print()
print("rel err: %g" % rel_err)
def test_sanity_single_element(actx_factory,
dim,
mesh_order,
group_cls,
visualize=False):
pytest.importorskip("pytential")
actx = actx_factory()
if group_cls is SimplexElementGroup:
group_factory = PolynomialWarpAndBlendGroupFactory(mesh_order + 3)
elif group_cls is TensorProductElementGroup:
group_factory = LegendreGaussLobattoTensorProductGroupFactory(
mesh_order + 3)
else:
raise TypeError
import modepy as mp
shape = group_cls._modepy_shape_cls(dim)
space = mp.space_for_shape(shape, mesh_order)
vertices = mp.unit_vertices_for_shape(shape)
nodes = mp.edge_clustered_nodes_for_space(space, shape).reshape(dim, 1, -1)
vertex_indices = np.arange(shape.nvertices, dtype=np.int32).reshape(1, -1)
center = np.empty(dim, np.float64)
center.fill(-0.5)
mg = group_cls(mesh_order, vertex_indices, nodes, dim=dim)
mesh = Mesh(vertices, [mg], is_conforming=True)
from meshmode.discretization import Discretization
vol_discr = Discretization(actx, mesh, group_factory)
# {{{ volume calculation check
if isinstance(mg, SimplexElementGroup):
from pytools import factorial
true_vol = 1 / factorial(dim) * 2**dim
elif isinstance(mg, TensorProductElementGroup):
true_vol = 2**dim
else:
raise TypeError
nodes = thaw(vol_discr.nodes(), actx)
vol_one = 1 + 0 * nodes[0]
from pytential import norm, integral # noqa
comp_vol = integral(vol_discr, vol_one)
rel_vol_err = abs(true_vol - comp_vol) / true_vol
assert rel_vol_err < 1e-12
# }}}
# {{{ boundary discretization
from meshmode.discretization.connection import make_face_restriction
bdry_connection = make_face_restriction(actx, vol_discr, group_factory,
BTAG_ALL)
bdry_discr = bdry_connection.to_discr
# }}}
from pytential import bind, sym
bdry_normals = bind(bdry_discr, sym.normal(dim).as_vector())(actx)
if visualize:
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(actx, bdry_discr, 4)
bdry_vis.write_vtk_file("sanity_single_element_boundary.vtu",
[("normals", bdry_normals)])
normal_outward_check = bind(
bdry_discr,
sym.normal(dim)
| (sym.nodes(dim) + 0.5 * sym.ones_vec(dim)),
)(actx).as_scalar()
normal_outward_check = flatten_to_numpy(actx, normal_outward_check > 0)
assert normal_outward_check.all(), normal_outward_check
def test_sanity_single_element(ctx_getter, dim, order, visualize=False):
pytest.importorskip("pytential")
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from modepy.tools import unit_vertices
vertices = unit_vertices(dim).T.copy()
center = np.empty(dim, np.float64)
center.fill(-0.5)
import modepy as mp
from meshmode.mesh import SimplexElementGroup, Mesh, BTAG_ALL
mg = SimplexElementGroup(
order=order,
vertex_indices=np.arange(dim+1, dtype=np.int32).reshape(1, -1),
nodes=mp.warp_and_blend_nodes(dim, order).reshape(dim, 1, -1),
dim=dim)
mesh = Mesh(vertices, [mg], nodal_adjacency=None, facial_adjacency_groups=None)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory
vol_discr = Discretization(cl_ctx, mesh,
PolynomialWarpAndBlendGroupFactory(order+3))
# {{{ volume calculation check
vol_x = vol_discr.nodes().with_queue(queue)
vol_one = vol_x[0].copy()
vol_one.fill(1)
from pytential import norm, integral # noqa
from pytools import factorial
true_vol = 1/factorial(dim) * 2**dim
comp_vol = integral(vol_discr, queue, vol_one)
rel_vol_err = abs(true_vol - comp_vol) / true_vol
assert rel_vol_err < 1e-12
# }}}
# {{{ boundary discretization
from meshmode.discretization.connection import make_face_restriction
bdry_connection = make_face_restriction(
vol_discr, PolynomialWarpAndBlendGroupFactory(order + 3),
BTAG_ALL)
bdry_discr = bdry_connection.to_discr
# }}}
# {{{ visualizers
from meshmode.discretization.visualization import make_visualizer
#vol_vis = make_visualizer(queue, vol_discr, 4)
bdry_vis = make_visualizer(queue, bdry_discr, 4)
# }}}
from pytential import bind, sym
bdry_normals = bind(bdry_discr, sym.normal())(queue).as_vector(dtype=object)
if visualize:
bdry_vis.write_vtk_file("boundary.vtu", [
("bdry_normals", bdry_normals)
])
from pytential import bind, sym
normal_outward_check = bind(bdry_discr,
sym.normal()
|
(sym.Nodes() + 0.5*sym.ones_vec(dim)),
)(queue).as_scalar() > 0
assert normal_outward_check.get().all(), normal_outward_check.get()
def test_partition_interpolation(ctx_factory, dim, mesh_pars, num_parts,
num_groups, scramble_partitions):
np.random.seed(42)
group_factory = PolynomialWarpAndBlendGroupFactory
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
order = 4
from pytools.convergence import EOCRecorder
eoc_rec = dict()
for i in range(num_parts):
for j in range(num_parts):
if i == j:
continue
eoc_rec[i, j] = EOCRecorder()
def f(x):
return 10. * cl.clmath.sin(50. * x)
for n in mesh_pars:
from meshmode.mesh.generation import generate_warped_rect_mesh
meshes = [
generate_warped_rect_mesh(dim, order=order, n=n)
for _ in range(num_groups)
]
if num_groups > 1:
from meshmode.mesh.processing import merge_disjoint_meshes
mesh = merge_disjoint_meshes(meshes)
else:
mesh = meshes[0]
if scramble_partitions:
part_per_element = np.random.randint(num_parts,
size=mesh.nelements)
else:
from pymetis import part_graph
_, p = part_graph(
num_parts,
xadj=mesh.nodal_adjacency.neighbors_starts.tolist(),
adjncy=mesh.nodal_adjacency.neighbors.tolist())
part_per_element = np.array(p)
from meshmode.mesh.processing import partition_mesh
part_meshes = [
partition_mesh(mesh, part_per_element, i)[0]
for i in range(num_parts)
]
from meshmode.discretization import Discretization
vol_discrs = [
Discretization(cl_ctx, part_meshes[i], group_factory(order))
for i in range(num_parts)
]
from meshmode.mesh import BTAG_PARTITION
from meshmode.discretization.connection import (
make_face_restriction, make_partition_connection, check_connection)
for i_local_part, i_remote_part in eoc_rec.keys():
if eoc_rec[i_local_part, i_remote_part] is None:
continue
# Mark faces within local_mesh that are connected to remote_mesh
local_bdry_conn = make_face_restriction(
vol_discrs[i_local_part], group_factory(order),
BTAG_PARTITION(i_remote_part))
# If these parts are not connected, don't bother checking the error
bdry_nodes = local_bdry_conn.to_discr.nodes()
if bdry_nodes.size == 0:
eoc_rec[i_local_part, i_remote_part] = None
continue
# Mark faces within remote_mesh that are connected to local_mesh
remote_bdry_conn = make_face_restriction(
vol_discrs[i_remote_part], group_factory(order),
BTAG_PARTITION(i_local_part))
assert bdry_nodes.size == remote_bdry_conn.to_discr.nodes().size, \
"partitions do not have the same number of connected nodes"
# Gather just enough information for the connection
local_bdry = local_bdry_conn.to_discr
local_mesh = part_meshes[i_local_part]
local_adj_groups = [
local_mesh.facial_adjacency_groups[i][None]
for i in range(len(local_mesh.groups))
]
local_batches = [
local_bdry_conn.groups[i].batches
for i in range(len(local_mesh.groups))
]
local_from_elem_faces = [[
batch.to_element_face for batch in grp_batches
] for grp_batches in local_batches]
local_from_elem_indices = [[
batch.to_element_indices.get(queue=queue)
for batch in grp_batches
] for grp_batches in local_batches]
remote_bdry = remote_bdry_conn.to_discr
remote_mesh = part_meshes[i_remote_part]
remote_adj_groups = [
remote_mesh.facial_adjacency_groups[i][None]
for i in range(len(remote_mesh.groups))
]
remote_batches = [
remote_bdry_conn.groups[i].batches
for i in range(len(remote_mesh.groups))
]
remote_from_elem_faces = [[
batch.to_element_face for batch in grp_batches
] for grp_batches in remote_batches]
remote_from_elem_indices = [[
batch.to_element_indices.get(queue=queue)
for batch in grp_batches
] for grp_batches in remote_batches]
# Connect from remote_mesh to local_mesh
remote_to_local_conn = make_partition_connection(
local_bdry_conn, i_local_part, remote_bdry, remote_adj_groups,
remote_from_elem_faces, remote_from_elem_indices)
# Connect from local mesh to remote mesh
local_to_remote_conn = make_partition_connection(
remote_bdry_conn, i_remote_part, local_bdry, local_adj_groups,
local_from_elem_faces, local_from_elem_indices)
check_connection(remote_to_local_conn)
check_connection(local_to_remote_conn)
true_local_points = f(local_bdry.nodes()[0].with_queue(queue))
remote_points = local_to_remote_conn(queue, true_local_points)
local_points = remote_to_local_conn(queue, remote_points)
err = la.norm((true_local_points - local_points).get(), np.inf)
eoc_rec[i_local_part, i_remote_part].add_data_point(1. / n, err)
for (i, j), e in eoc_rec.items():
if e is not None:
print("Error of connection from part %i to part %i." % (i, j))
print(e)
assert (e.order_estimate() >= order - 0.5 or e.max_error() < 1e-11)
def test_sanity_balls(actx_factory,
src_file,
dim,
mesh_order,
visualize=False):
pytest.importorskip("pytential")
logging.basicConfig(level=logging.INFO)
actx = actx_factory()
from pytools.convergence import EOCRecorder
vol_eoc_rec = EOCRecorder()
surf_eoc_rec = EOCRecorder()
# overkill
quad_order = mesh_order
from pytential import bind, sym
for h in [0.2, 0.1, 0.05]:
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(FileSource(src_file),
dim,
order=mesh_order,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % h
],
force_ambient_dim=dim,
target_unit="MM")
logger.info("%d elements", mesh.nelements)
# {{{ discretizations and connections
from meshmode.discretization import Discretization
vol_discr = Discretization(
actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(quad_order))
from meshmode.discretization.connection import make_face_restriction
bdry_connection = make_face_restriction(
actx, vol_discr,
InterpolatoryQuadratureSimplexGroupFactory(quad_order), BTAG_ALL)
bdry_discr = bdry_connection.to_discr
# }}}
from math import gamma
true_surf = 2 * np.pi**(dim / 2) / gamma(dim / 2)
true_vol = true_surf / dim
vol_x = thaw(vol_discr.nodes(), actx)
vol_one = vol_x[0] * 0 + 1
from pytential import norm, integral # noqa
comp_vol = integral(vol_discr, vol_one)
rel_vol_err = abs(true_vol - comp_vol) / true_vol
vol_eoc_rec.add_data_point(h, rel_vol_err)
print("VOL", true_vol, comp_vol)
bdry_x = thaw(bdry_discr.nodes(), actx)
bdry_one_exact = bdry_x[0] * 0 + 1
bdry_one = bdry_connection(vol_one)
intp_err = norm(bdry_discr, bdry_one - bdry_one_exact)
assert intp_err < 1e-14
comp_surf = integral(bdry_discr, bdry_one)
rel_surf_err = abs(true_surf - comp_surf) / true_surf
surf_eoc_rec.add_data_point(h, rel_surf_err)
print("SURF", true_surf, comp_surf)
if visualize:
from meshmode.discretization.visualization import make_visualizer
vol_vis = make_visualizer(actx, vol_discr, 7)
bdry_vis = make_visualizer(actx, bdry_discr, 7)
name = src_file.split("-")[0]
vol_vis.write_vtk_file(f"sanity_balls_volume_{name}_{h:g}.vtu", [
("f", vol_one),
("area_el",
bind(vol_discr,
sym.area_element(mesh.ambient_dim,
mesh.ambient_dim))(actx)),
])
bdry_vis.write_vtk_file(f"sanity_balls_boundary_{name}_{h:g}.vtu",
[("f", bdry_one)])
# {{{ check normals point outward
normal_outward_check = bind(
bdry_discr,
sym.normal(mesh.ambient_dim) | sym.nodes(mesh.ambient_dim),
)(actx).as_scalar()
normal_outward_check = flatten_to_numpy(actx, normal_outward_check > 0)
assert normal_outward_check.all(), normal_outward_check
# }}}
print("---------------------------------")
print("VOLUME")
print("---------------------------------")
print(vol_eoc_rec)
assert vol_eoc_rec.order_estimate() >= mesh_order
print("---------------------------------")
print("SURFACE")
print("---------------------------------")
print(surf_eoc_rec)
assert surf_eoc_rec.order_estimate() >= mesh_order
def nonlocal_integral_eq(
mesh,
scatterer_bdy_id,
outer_bdy_id,
wave_number,
options_prefix=None,
solver_parameters=None,
fspace=None,
vfspace=None,
true_sol_grad_expr=None,
actx=None,
dgfspace=None,
dgvfspace=None,
meshmode_src_connection=None,
qbx_kwargs=None,
):
r"""
see run_method for descriptions of unlisted args
args:
gamma and beta are used to precondition
with the following equation:
\Delta u - \kappa^2 \gamma u = 0
(\partial_n - i\kappa\beta) u |_\Sigma = 0
"""
# make sure we get outer bdy id as tuple in case it consists of multiple ids
if isinstance(outer_bdy_id, int):
outer_bdy_id = [outer_bdy_id]
outer_bdy_id = tuple(outer_bdy_id)
# away from the excluded region, but firedrake and meshmode point
# into
pyt_inner_normal_sign = -1
ambient_dim = mesh.geometric_dimension()
# {{{ Build src and tgt
# build connection meshmode near src boundary -> src boundary inside meshmode
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from meshmode.discretization.connection import make_face_restriction
factory = InterpolatoryQuadratureSimplexGroupFactory(
dgfspace.finat_element.degree)
src_bdy_connection = make_face_restriction(actx,
meshmode_src_connection.discr,
factory, scatterer_bdy_id)
# source is a qbx layer potential
from pytential.qbx import QBXLayerPotentialSource
disable_refinement = (fspace.mesh().geometric_dimension() == 3)
qbx = QBXLayerPotentialSource(src_bdy_connection.to_discr,
**qbx_kwargs,
_disable_refinement=disable_refinement)
# get target indices and point-set
target_indices, target = get_target_points_and_indices(
fspace, outer_bdy_id)
# }}}
# build the operations
from pytential import bind, sym
r"""
..math:
x \in \Sigma
grad_op(x) =
\nabla(
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
grad_op = pyt_inner_normal_sign * sym.grad(
ambient_dim,
sym.D(HelmholtzKernel(ambient_dim),
sym.var("u"),
k=sym.var("k"),
qbx_forced_limit=None))
r"""
..math:
x \in \Sigma
op(x) =
i \kappa \cdot
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
"""
op = pyt_inner_normal_sign * 1j * sym.var("k") * (sym.D(
HelmholtzKernel(ambient_dim),
sym.var("u"),
k=sym.var("k"),
qbx_forced_limit=None))
# bind the operations
pyt_grad_op = bind((qbx, target), grad_op)
pyt_op = bind((qbx, target), op)
# }}}
class MatrixFreeB(object):
def __init__(self, A, pyt_grad_op, pyt_op, actx, kappa):
"""
:arg kappa: The wave number
"""
self.actx = actx
self.k = kappa
self.pyt_op = pyt_op
self.pyt_grad_op = pyt_grad_op
self.A = A
self.meshmode_src_connection = meshmode_src_connection
# {{{ Create some functions needed for multing
self.x_fntn = Function(fspace)
# CG
self.potential_int = Function(fspace)
self.potential_int.dat.data[:] = 0.0
self.grad_potential_int = Function(vfspace)
self.grad_potential_int.dat.data[:] = 0.0
self.pyt_result = Function(fspace)
self.n = FacetNormal(mesh)
self.v = TestFunction(fspace)
# some meshmode ones
self.x_mm_fntn = self.meshmode_src_connection.discr.empty(
self.actx, dtype='c')
# }}}
def mult(self, mat, x, y):
# Copy function data into the fivredrake function
self.x_fntn.dat.data[:] = x[:]
# Transfer the function to meshmode
self.meshmode_src_connection.from_firedrake(project(
self.x_fntn, dgfspace),
out=self.x_mm_fntn)
# Restrict to boundary
x_mm_fntn_on_bdy = src_bdy_connection(self.x_mm_fntn)
# Apply the operation
potential_int_mm = self.pyt_op(self.actx,
u=x_mm_fntn_on_bdy,
k=self.k)
grad_potential_int_mm = self.pyt_grad_op(self.actx,
u=x_mm_fntn_on_bdy,
k=self.k)
# Store in firedrake
self.potential_int.dat.data[target_indices] = potential_int_mm.get(
)
for dim in range(grad_potential_int_mm.shape[0]):
self.grad_potential_int.dat.data[
target_indices, dim] = grad_potential_int_mm[dim].get()
# Integrate the potential
r"""
Compute the inner products using firedrake. Note this
will be subtracted later, hence appears off by a sign.
.. math::
\langle
n(x) \cdot \nabla(
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
), v
\rangle_\Sigma
- \langle
i \kappa \cdot
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y), v
\rangle_\Sigma
"""
self.pyt_result = assemble(
inner(inner(self.grad_potential_int, self.n), self.v) *
ds(outer_bdy_id) -
inner(self.potential_int, self.v) * ds(outer_bdy_id))
# y <- Ax - evaluated potential
self.A.mult(x, y)
with self.pyt_result.dat.vec_ro as ep:
y.axpy(-1, ep)
# {{{ Compute normal helmholtz operator
u = TrialFunction(fspace)
v = TestFunction(fspace)
r"""
.. math::
\langle
\nabla u, \nabla v
\rangle
- \kappa^2 \cdot \langle
u, v
\rangle
- i \kappa \langle
u, v
\rangle_\Sigma
"""
a = inner(grad(u), grad(v)) * dx \
- Constant(wave_number**2) * inner(u, v) * dx \
- Constant(1j * wave_number) * inner(u, v) * ds(outer_bdy_id)
# get the concrete matrix from a general bilinear form
A = assemble(a).M.handle
# }}}
# {{{ Setup Python matrix
B = PETSc.Mat().create()
# build matrix context
Bctx = MatrixFreeB(A, pyt_grad_op, pyt_op, actx, wave_number)
# set up B as same size as A
B.setSizes(*A.getSizes())
B.setType(B.Type.PYTHON)
B.setPythonContext(Bctx)
B.setUp()
# }}}
# {{{ Create rhs
# Remember f is \partial_n(true_sol)|_\Gamma
# so we just need to compute \int_\Gamma\partial_n(true_sol) H(x-y)
sigma = sym.make_sym_vector("sigma", ambient_dim)
r"""
..math:
x \in \Sigma
grad_op(x) =
\nabla(
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
grad_op = pyt_inner_normal_sign * \
sym.grad(ambient_dim, sym.S(HelmholtzKernel(ambient_dim),
sym.n_dot(sigma),
k=sym.var("k"), qbx_forced_limit=None))
r"""
..math:
x \in \Sigma
op(x) =
i \kappa \cdot
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
op = 1j * sym.var("k") * pyt_inner_normal_sign * \
sym.S(HelmholtzKernel(ambient_dim),
sym.n_dot(sigma),
k=sym.var("k"),
qbx_forced_limit=None)
rhs_grad_op = bind((qbx, target), grad_op)
rhs_op = bind((qbx, target), op)
# Transfer to meshmode
metadata = {'quadrature_degree': 2 * fspace.ufl_element().degree()}
dg_true_sol_grad = project(true_sol_grad_expr,
dgvfspace,
form_compiler_parameters=metadata)
true_sol_grad_mm = meshmode_src_connection.from_firedrake(dg_true_sol_grad,
actx=actx)
true_sol_grad_mm = src_bdy_connection(true_sol_grad_mm)
# Apply the operations
f_grad_convoluted_mm = rhs_grad_op(actx,
sigma=true_sol_grad_mm,
k=wave_number)
f_convoluted_mm = rhs_op(actx, sigma=true_sol_grad_mm, k=wave_number)
# Transfer function back to firedrake
f_grad_convoluted = Function(vfspace)
f_convoluted = Function(fspace)
f_grad_convoluted.dat.data[:] = 0.0
f_convoluted.dat.data[:] = 0.0
for dim in range(f_grad_convoluted_mm.shape[0]):
f_grad_convoluted.dat.data[target_indices,
dim] = f_grad_convoluted_mm[dim].get()
f_convoluted.dat.data[target_indices] = f_convoluted_mm.get()
r"""
\langle
f, v
\rangle_\Gamma
+ \langle
i \kappa \cdot \int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y), v
\rangle_\Sigma
- \langle
n(x) \cdot \nabla(
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
), v
\rangle_\Sigma
"""
rhs_form = inner(inner(true_sol_grad_expr, FacetNormal(mesh)),
v) * ds(scatterer_bdy_id, metadata=metadata) \
+ inner(f_convoluted, v) * ds(outer_bdy_id) \
- inner(inner(f_grad_convoluted, FacetNormal(mesh)),
v) * ds(outer_bdy_id)
rhs = assemble(rhs_form)
# {{{ set up a solver:
solution = Function(fspace, name="Computed Solution")
# {{{ Used for preconditioning
if 'gamma' in solver_parameters or 'beta' in solver_parameters:
gamma = complex(solver_parameters.pop('gamma', 1.0))
import cmath
beta = complex(solver_parameters.pop('beta', cmath.sqrt(gamma)))
p = inner(grad(u), grad(v)) * dx \
- Constant(wave_number**2 * gamma) * inner(u, v) * dx \
- Constant(1j * wave_number * beta) * inner(u, v) * ds(outer_bdy_id)
P = assemble(p).M.handle
else:
P = A
# }}}
# Set up options to contain solver parameters:
ksp = PETSc.KSP().create()
if solver_parameters['pc_type'] == 'pyamg':
del solver_parameters['pc_type'] # We are using the AMG preconditioner
pyamg_tol = solver_parameters.get('pyamg_tol', None)
if pyamg_tol is not None:
pyamg_tol = float(pyamg_tol)
pyamg_maxiter = solver_parameters.get('pyamg_maxiter', None)
if pyamg_maxiter is not None:
pyamg_maxiter = int(pyamg_maxiter)
ksp.setOperators(B)
ksp.setUp()
pc = ksp.pc
pc.setType(pc.Type.PYTHON)
pc.setPythonContext(
AMGTransmissionPreconditioner(wave_number,
fspace,
A,
tol=pyamg_tol,
maxiter=pyamg_maxiter,
use_plane_waves=True))
# Otherwise use regular preconditioner
else:
ksp.setOperators(B, P)
options_manager = OptionsManager(solver_parameters, options_prefix)
options_manager.set_from_options(ksp)
import petsc4py.PETSc
petsc4py.PETSc.Sys.popErrorHandler()
with rhs.dat.vec_ro as b:
with solution.dat.vec as x:
ksp.solve(b, x)
# }}}
return ksp, solution
def test_boundary_interpolation(actx_factory, group_factory, boundary_tag,
mesh_name, dim, mesh_pars, per_face_groups):
if (group_factory is LegendreGaussLobattoTensorProductGroupFactory
and mesh_name == "blob"):
pytest.skip("tensor products not implemented on blobs")
actx = actx_factory()
if group_factory is LegendreGaussLobattoTensorProductGroupFactory:
group_cls = TensorProductElementGroup
else:
group_cls = SimplexElementGroup
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (make_face_restriction,
check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 4
def f(x):
return 0.1 * actx.np.sin(30 * x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "blob":
assert dim == 2
h = float(mesh_par)
#from meshmode.mesh.io import generate_gmsh, FileSource
# print("BEGIN GEN")
# mesh = generate_gmsh(
# FileSource("blob-2d.step"), 2, order=order,
# force_ambient_dim=2,
# other_options=[
# "-string", "Mesh.CharacteristicLengthMax = %s;" % h]
# )
# print("END GEN")
from meshmode.mesh.io import read_gmsh
mesh = read_gmsh("blob2d-order%d-h%s.msh" % (order, mesh_par),
force_ambient_dim=2)
elif mesh_name == "warp":
mesh = mgen.generate_warped_rect_mesh(dim,
order=order,
nelements_side=mesh_par,
group_cls=group_cls)
h = 1 / mesh_par
elif mesh_name == "rect":
mesh = mgen.generate_regular_rect_mesh(
a=(0, ) * dim,
b=(1, ) * dim,
order=order,
nelements_per_axis=(mesh_par, ) * dim,
group_cls=group_cls)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(actx, mesh, group_factory(order))
print("h=%s -> %d elements" %
(h, sum(mgrp.nelements for mgrp in mesh.groups)))
x = thaw(vol_discr.nodes()[0], actx)
vol_f = f(x)
bdry_connection = make_face_restriction(
actx,
vol_discr,
group_factory(order),
boundary_tag,
per_face_groups=per_face_groups)
check_connection(actx, bdry_connection)
bdry_discr = bdry_connection.to_discr
bdry_x = thaw(bdry_discr.nodes()[0], actx)
bdry_f = f(bdry_x)
bdry_f_2 = bdry_connection(vol_f)
if mesh_name == "blob" and dim == 2 and mesh.nelements < 500:
from meshmode.discretization.connection.direct import \
make_direct_full_resample_matrix
mat = actx.to_numpy(
make_direct_full_resample_matrix(actx, bdry_connection))
bdry_f_2_by_mat = mat.dot(flatten_to_numpy(actx, vol_f))
mat_error = la.norm(
flatten_to_numpy(actx, bdry_f_2) - bdry_f_2_by_mat)
assert mat_error < 1e-14, mat_error
err = flat_norm(bdry_f - bdry_f_2, np.inf)
eoc_rec.add_data_point(h, err)
order_slack = 0.75 if mesh_name == "blob" else 0.5
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - order_slack
or eoc_rec.max_error() < 3.6e-13)
def test_partition_interpolation(actx_factory, dim, mesh_pars, num_parts,
num_groups, part_method):
np.random.seed(42)
group_factory = PolynomialWarpAndBlendGroupFactory
actx = actx_factory()
order = 4
def f(x):
return 10. * actx.np.sin(50. * x)
for n in mesh_pars:
from meshmode.mesh.generation import generate_warped_rect_mesh
base_mesh = generate_warped_rect_mesh(dim, order=order, n=n)
if num_groups > 1:
from meshmode.mesh.processing import split_mesh_groups
# Group every Nth element
element_flags = np.arange(
base_mesh.nelements,
dtype=base_mesh.element_id_dtype) % num_groups
mesh = split_mesh_groups(base_mesh, element_flags)
else:
mesh = base_mesh
if part_method == "random":
part_per_element = np.random.randint(num_parts,
size=mesh.nelements)
else:
pytest.importorskip("pymetis")
from meshmode.distributed import get_partition_by_pymetis
part_per_element = get_partition_by_pymetis(
mesh, num_parts, connectivity=part_method)
from meshmode.mesh.processing import partition_mesh
part_meshes = [
partition_mesh(mesh, part_per_element, i)[0]
for i in range(num_parts)
]
connected_parts = set()
for i_local_part, part_mesh in enumerate(part_meshes):
from meshmode.distributed import get_connected_partitions
neighbors = get_connected_partitions(part_mesh)
for i_remote_part in neighbors:
connected_parts.add((i_local_part, i_remote_part))
from meshmode.discretization import Discretization
vol_discrs = [
Discretization(actx, part_meshes[i], group_factory(order))
for i in range(num_parts)
]
from meshmode.mesh import BTAG_PARTITION
from meshmode.discretization.connection import (
make_face_restriction, make_partition_connection, check_connection)
for i_local_part, i_remote_part in connected_parts:
# Mark faces within local_mesh that are connected to remote_mesh
local_bdry_conn = make_face_restriction(
actx, vol_discrs[i_local_part], group_factory(order),
BTAG_PARTITION(i_remote_part))
# Mark faces within remote_mesh that are connected to local_mesh
remote_bdry_conn = make_face_restriction(
actx, vol_discrs[i_remote_part], group_factory(order),
BTAG_PARTITION(i_local_part))
bdry_nelements = sum(grp.nelements
for grp in local_bdry_conn.to_discr.groups)
remote_bdry_nelements = sum(
grp.nelements for grp in remote_bdry_conn.to_discr.groups)
assert bdry_nelements == remote_bdry_nelements, \
"partitions do not have the same number of connected elements"
local_bdry = local_bdry_conn.to_discr
remote_bdry = remote_bdry_conn.to_discr
from meshmode.distributed import make_remote_group_infos
remote_to_local_conn = make_partition_connection(
actx,
local_bdry_conn=local_bdry_conn,
i_local_part=i_local_part,
remote_bdry_discr=remote_bdry,
remote_group_infos=make_remote_group_infos(
actx, remote_bdry_conn))
# Connect from local mesh to remote mesh
local_to_remote_conn = make_partition_connection(
actx,
local_bdry_conn=remote_bdry_conn,
i_local_part=i_remote_part,
remote_bdry_discr=local_bdry,
remote_group_infos=make_remote_group_infos(
actx, local_bdry_conn))
check_connection(actx, remote_to_local_conn)
check_connection(actx, local_to_remote_conn)
true_local_points = f(thaw(actx, local_bdry.nodes()[0]))
remote_points = local_to_remote_conn(true_local_points)
local_points = remote_to_local_conn(remote_points)
err = actx.np.linalg.norm(true_local_points - local_points, np.inf)
# Can't currently expect exact results due to limitations of
# interpolation "snapping" in DirectDiscretizationConnection's
# _resample_point_pick_indices
assert err < 1e-11
def test_mesh_multiple_groups(actx_factory, ambient_dim, visualize=False):
actx = actx_factory()
order = 4
mesh = mgen.generate_regular_rect_mesh(a=(-0.5, ) * ambient_dim,
b=(0.5, ) * ambient_dim,
nelements_per_axis=(8, ) *
ambient_dim,
order=order)
assert len(mesh.groups) == 1
from meshmode.mesh.processing import split_mesh_groups
element_flags = np.any(
mesh.vertices[0, mesh.groups[0].vertex_indices] < 0.0,
axis=1).astype(np.int64)
mesh = split_mesh_groups(mesh, element_flags)
assert len(mesh.groups) == 2 # pylint: disable=no-member
assert mesh.facial_adjacency_groups
assert mesh.nodal_adjacency
if visualize and ambient_dim == 2:
from meshmode.mesh.visualization import draw_2d_mesh
draw_2d_mesh(mesh,
draw_vertex_numbers=False,
draw_element_numbers=True,
draw_face_numbers=False,
set_bounding_box=True)
import matplotlib.pyplot as plt
plt.savefig("test_mesh_multiple_groups_2d_elements.png", dpi=300)
from meshmode.discretization import Discretization
discr = Discretization(actx, mesh,
PolynomialWarpAndBlendGroupFactory(order))
if visualize:
group_id = discr.empty(actx, dtype=np.int32)
for igrp, vec in enumerate(group_id):
vec.fill(igrp)
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, discr, vis_order=order)
vis.write_vtk_file("mesh_multiple_groups.vtu",
[("group_id", group_id)],
overwrite=True)
# check face restrictions
from meshmode.discretization.connection import (
make_face_restriction, make_face_to_all_faces_embedding,
make_opposite_face_connection, check_connection)
for boundary_tag in [BTAG_ALL, FACE_RESTR_INTERIOR, FACE_RESTR_ALL]:
conn = make_face_restriction(
actx,
discr,
group_factory=PolynomialWarpAndBlendGroupFactory(order),
boundary_tag=boundary_tag,
per_face_groups=False)
check_connection(actx, conn)
bdry_f = conn.to_discr.zeros(actx) + 1
if boundary_tag == FACE_RESTR_INTERIOR:
opposite = make_opposite_face_connection(actx, conn)
check_connection(actx, opposite)
op_bdry_f = opposite(bdry_f)
error = flat_norm(bdry_f - op_bdry_f, np.inf)
assert error < 1.0e-11, error
if boundary_tag == FACE_RESTR_ALL:
embedding = make_face_to_all_faces_embedding(
actx, conn, conn.to_discr)
check_connection(actx, embedding)
em_bdry_f = embedding(bdry_f)
error = flat_norm(bdry_f - em_bdry_f)
assert error < 1.0e-11, error
# check some derivatives (nb: flatten is a generator)
import pytools
ref_axes = pytools.flatten([[i] for i in range(ambient_dim)])
from meshmode.discretization import num_reference_derivative
x = thaw(discr.nodes(), actx)
num_reference_derivative(discr, ref_axes, x[0])
