def test_from_fd_consistency(ctx_factory, fdrake_mesh, fspace_degree):
"""
Check basic consistency with a FiredrakeConnection built from firedrake
"""
# make discretization from firedrake
fdrake_fspace = FunctionSpace(fdrake_mesh, "DG", fspace_degree)
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
fdrake_connection = build_connection_from_firedrake(actx, fdrake_fspace)
discr = fdrake_connection.discr
# Check consistency
check_consistency(fdrake_fspace, discr)
def main():
# If can't import firedrake, do nothing
#
# filename MUST include "firedrake" (i.e. match *firedrake*.py) in order
# to be run during CI
try:
import firedrake # noqa : F401
except ImportError:
return 0
from meshmode.interop.firedrake import build_connection_from_firedrake
from firedrake import (UnitSquareMesh, FunctionSpace, SpatialCoordinate,
Function, cos)
# Create a firedrake mesh and interpolate cos(x+y) onto it
fd_mesh = UnitSquareMesh(10, 10)
fd_fspace = FunctionSpace(fd_mesh, "DG", 2)
spatial_coord = SpatialCoordinate(fd_mesh)
fd_fntn = Function(fd_fspace).interpolate(cos(sum(spatial_coord)))
# Make connections
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
fd_connection = build_connection_from_firedrake(actx, fd_fspace)
fd_bdy_connection = \
build_connection_from_firedrake(actx,
fd_fspace,
restrict_to_boundary="on_boundary")
# Plot the meshmode meshes that the connections connect to
import matplotlib.pyplot as plt
from meshmode.mesh.visualization import draw_2d_mesh
fig, (ax1, ax2) = plt.subplots(1, 2)
ax1.set_title("FiredrakeConnection")
plt.sca(ax1)
draw_2d_mesh(fd_connection.discr.mesh,
draw_vertex_numbers=False,
draw_element_numbers=False,
set_bounding_box=True)
ax2.set_title("FiredrakeConnection 'on_boundary'")
plt.sca(ax2)
draw_2d_mesh(fd_bdy_connection.discr.mesh,
draw_vertex_numbers=False,
draw_element_numbers=False,
set_bounding_box=True)
plt.show()
# Plot fd_fntn using unrestricted FiredrakeConnection
from meshmode.discretization.visualization import make_visualizer
discr = fd_connection.discr
vis = make_visualizer(actx, discr, discr.groups[0].order + 3)
field = fd_connection.from_firedrake(fd_fntn, actx=actx)
fig = plt.figure()
ax1 = fig.add_subplot(1, 2, 1, projection="3d")
ax1.set_title("cos(x+y) in\nFiredrakeConnection")
vis.show_scalar_in_matplotlib_3d(field, do_show=False)
# Now repeat using FiredrakeConnection restricted to "on_boundary"
bdy_discr = fd_bdy_connection.discr
bdy_vis = make_visualizer(actx, bdy_discr, bdy_discr.groups[0].order + 3)
bdy_field = fd_bdy_connection.from_firedrake(fd_fntn, actx=actx)
ax2 = fig.add_subplot(1, 2, 2, projection="3d")
plt.sca(ax2)
ax2.set_title("cos(x+y) in\nFiredrakeConnection 'on_boundary'")
bdy_vis.show_scalar_in_matplotlib_3d(bdy_field, do_show=False)
import matplotlib.cm as cm
fig.colorbar(cm.ScalarMappable())
plt.show()
def test_from_fd_idempotency(ctx_factory, fdrake_mesh, fspace_degree,
fspace_type, only_convert_bdy):
"""
Make sure fd->mm->fd and (fd->)->mm->fd->mm are identity
"""
# Make a function space and a function with unique values at each node
if fspace_type == "scalar":
fdrake_fspace = FunctionSpace(fdrake_mesh, "DG", fspace_degree)
# Just use the node nr
fdrake_unique = Function(fdrake_fspace)
fdrake_unique.dat.data[:] = np.arange(fdrake_unique.dat.data.shape[0])
elif fspace_type == "vector":
fdrake_fspace = VectorFunctionSpace(fdrake_mesh, "DG", fspace_degree)
# use the coordinates
xx = SpatialCoordinate(fdrake_fspace.mesh())
fdrake_unique = Function(fdrake_fspace).interpolate(xx)
elif fspace_type == "tensor":
fdrake_fspace = TensorFunctionSpace(fdrake_mesh, "DG", fspace_degree)
# use the coordinates, duplicated into the right tensor shape
xx = SpatialCoordinate(fdrake_fspace.mesh())
dim = fdrake_fspace.mesh().geometric_dimension()
unique_expr = as_tensor([xx for _ in range(dim)])
fdrake_unique = Function(fdrake_fspace).interpolate(unique_expr)
# Make connection
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
# If only converting boundary, first go ahead and do one round of
# fd->mm->fd. This will zero out any degrees of freedom absent in
# the meshmode mesh (because they are not associated to cells
# with >= 1 node on the boundary)
#
# Otherwise, just continue as normal
if only_convert_bdy:
fdrake_connection = \
build_connection_from_firedrake(actx,
fdrake_fspace,
restrict_to_boundary="on_boundary")
temp = fdrake_connection.from_firedrake(fdrake_unique, actx=actx)
fdrake_unique = fdrake_connection.from_meshmode(temp)
else:
fdrake_connection = build_connection_from_firedrake(
actx, fdrake_fspace)
# Test for idempotency fd->mm->fd
mm_field = fdrake_connection.from_firedrake(fdrake_unique, actx=actx)
fdrake_unique_copy = Function(fdrake_fspace)
fdrake_connection.from_meshmode(mm_field, out=fdrake_unique_copy)
np.testing.assert_allclose(fdrake_unique_copy.dat.data,
fdrake_unique.dat.data,
atol=CLOSE_ATOL)
# Test for idempotency (fd->)mm->fd->mm
mm_field_copy = fdrake_connection.from_firedrake(fdrake_unique_copy,
actx=actx)
if fspace_type == "scalar":
np.testing.assert_allclose(actx.to_numpy(mm_field_copy[0]),
actx.to_numpy(mm_field[0]),
atol=CLOSE_ATOL)
else:
for dof_arr_cp, dof_arr in zip(mm_field_copy.flatten(),
mm_field.flatten()):
np.testing.assert_allclose(actx.to_numpy(dof_arr_cp[0]),
actx.to_numpy(dof_arr[0]),
atol=CLOSE_ATOL)
def test_from_fd_transfer(ctx_factory, fspace_degree, fdrake_mesh_name,
fdrake_mesh_pars, dim, only_convert_bdy):
"""
Make sure creating a function which projects onto
one dimension then transports it is the same
(up to resampling error) as projecting to one
dimension on the transported mesh
"""
# build estimate-of-convergence recorder
from pytools.convergence import EOCRecorder
# (fd -> mm ? True : False, dimension projecting onto)
eoc_recorders = {(True, d): EOCRecorder() for d in range(dim)}
if not only_convert_bdy:
for d in range(dim):
eoc_recorders[(False, d)] = EOCRecorder()
# make a computing context
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
def get_fdrake_mesh_and_h_from_par(mesh_par):
if fdrake_mesh_name == "UnitInterval":
assert dim == 1
n = mesh_par
fdrake_mesh = UnitIntervalMesh(n)
h = 1 / n
elif fdrake_mesh_name == "UnitSquare":
assert dim == 2
n = mesh_par
fdrake_mesh = UnitSquareMesh(n, n)
h = 1 / n
elif fdrake_mesh_name == "UnitCube":
assert dim == 3
n = mesh_par
fdrake_mesh = UnitCubeMesh(n, n, n)
h = 1 / n
elif fdrake_mesh_name in ("blob2d-order1", "blob2d-order4"):
assert dim == 2
if fdrake_mesh_name == "blob2d-order1":
from firedrake import Mesh
fdrake_mesh = Mesh(f"{fdrake_mesh_name}-h{mesh_par}.msh",
dim=dim)
else:
from meshmode.mesh.io import read_gmsh
from meshmode.interop.firedrake import export_mesh_to_firedrake
mm_mesh = read_gmsh(f"{fdrake_mesh_name}-h{mesh_par}.msh",
force_ambient_dim=dim)
fdrake_mesh, _, _ = export_mesh_to_firedrake(mm_mesh)
h = float(mesh_par)
elif fdrake_mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
from meshmode.interop.firedrake import export_mesh_to_firedrake
mm_mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par)
fdrake_mesh, _, _ = export_mesh_to_firedrake(mm_mesh)
h = 1 / mesh_par
else:
raise ValueError("fdrake_mesh_name not recognized")
return (fdrake_mesh, h)
# Record error for each refinement of each mesh
for mesh_par in fdrake_mesh_pars:
fdrake_mesh, h = get_fdrake_mesh_and_h_from_par(mesh_par)
# make function space and build connection
fdrake_fspace = FunctionSpace(fdrake_mesh, "DG", fspace_degree)
if only_convert_bdy:
fdrake_connection = \
build_connection_from_firedrake(actx,
fdrake_fspace,
restrict_to_boundary="on_boundary")
else:
fdrake_connection = build_connection_from_firedrake(
actx, fdrake_fspace)
# get this for making functions in firedrake
spatial_coord = SpatialCoordinate(fdrake_mesh)
# get nodes in handier format for making meshmode functions
discr = fdrake_connection.discr
# nodes is np array (ambient_dim,) of DOFArray (ngroups,)
# of arrays (nelements, nunit_dofs), we want a single np array
# of shape (ambient_dim, nelements, nunit_dofs)
nodes = discr.nodes()
group_nodes = np.array(
[actx.to_numpy(dof_arr[0]) for dof_arr in nodes])
# Now, for each coordinate d, test transferring the function
# x -> sin(dth component of x)
for d in range(dim):
fdrake_f = Function(fdrake_fspace).interpolate(
sin(spatial_coord[d]))
# transport fdrake function and put in numpy
fd2mm_f = fdrake_connection.from_firedrake(fdrake_f, actx=actx)
fd2mm_f = actx.to_numpy(fd2mm_f[0])
meshmode_f = np.sin(group_nodes[d, :, :])
# record fd -> mm error
err = np.max(np.abs(fd2mm_f - meshmode_f))
eoc_recorders[(True, d)].add_data_point(h, err)
if not only_convert_bdy:
# now transport mm -> fd
meshmode_f_dofarr = discr.zeros(actx)
meshmode_f_dofarr[0][:] = meshmode_f
mm2fd_f = fdrake_connection.from_meshmode(meshmode_f_dofarr)
# record mm -> fd error
err = np.max(np.abs(fdrake_f.dat.data - mm2fd_f.dat.data))
eoc_recorders[(False, d)].add_data_point(h, err)
# assert that order is correct or error is "low enough"
for ((fd2mm, d), eoc_rec) in eoc_recorders.items():
print(
"\nfiredrake -> meshmode: %s\nvector *x* -> *sin(x[%s])*\n" %
(fd2mm, d), eoc_rec)
assert (eoc_rec.order_estimate() >= fspace_degree
or eoc_rec.max_error() < 2e-14)
def test_from_boundary_consistency(ctx_factory, fdrake_mesh, fspace_degree):
"""
Make basic checks that FiredrakeConnection restricted to cells
near the boundary is not doing
something obviously wrong,
i.e. that the firedrake boundary tags partition the converted meshmode mesh,
that the firedrake boundary tags correspond to the same physical
regions in the converted meshmode mesh as in the original firedrake mesh,
and that each boundary tag is associated to the same number of facets
in the converted meshmode mesh as in the original firedrake mesh.
"""
fdrake_fspace = FunctionSpace(fdrake_mesh, "DG", fspace_degree)
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
frombdy_conn = \
build_connection_from_firedrake(actx,
fdrake_fspace,
restrict_to_boundary="on_boundary")
# Ensure the meshmode mesh has one group and make sure both
# meshes agree on some basic properties
discr = frombdy_conn.discr
assert len(discr.mesh.groups) == 1
fdrake_mesh_fspace = fdrake_mesh.coordinates.function_space()
fdrake_mesh_order = fdrake_mesh_fspace.finat_element.degree
assert discr.mesh.groups[0].dim == fdrake_mesh.topological_dimension()
assert discr.mesh.groups[0].order == fdrake_mesh_order
# Get the unit vertex indices (in each cell)
fdrake_mesh = fdrake_fspace.mesh()
cfspace = fdrake_mesh.coordinates.function_space()
entity_dofs = cfspace.finat_element.entity_dofs()[0]
fdrake_unit_vert_indices = []
for _, local_node_nrs in sorted(entity_dofs.items()):
assert len(local_node_nrs) == 1
fdrake_unit_vert_indices.append(local_node_nrs[0])
fdrake_unit_vert_indices = np.array(fdrake_unit_vert_indices)
# only look at cells "near" bdy (with >= 1 vertex on)
from meshmode.interop.firedrake.connection import _get_cells_to_use
cells_near_bdy = _get_cells_to_use(fdrake_mesh, "on_boundary")
# get the firedrake vertices of cells near the boundary,
# in no particular order
fdrake_vert_indices = \
cfspace.cell_node_list[cells_near_bdy,
fdrake_unit_vert_indices[:, np.newaxis]]
fdrake_vert_indices = np.unique(fdrake_vert_indices)
fdrake_verts = fdrake_mesh.coordinates.dat.data[fdrake_vert_indices, ...]
if fdrake_mesh.geometric_dimension() == 1:
fdrake_verts = fdrake_verts[:, np.newaxis]
# Get meshmode vertices (shaped like (dim, nverts))
meshmode_verts = discr.mesh.vertices
# Ensure that the vertices of firedrake elements on
# the boundary are identical to the resultant meshes' vertices up to
# reordering
# Nb: I got help on this from stack overflow:
# https://stackoverflow.com/questions/38277143/sort-2d-numpy-array-lexicographically # noqa: E501
lex_sorted_mm_verts = meshmode_verts[:, np.lexsort(meshmode_verts)]
lex_sorted_fdrake_verts = fdrake_verts[np.lexsort(fdrake_verts.T)]
np.testing.assert_allclose(lex_sorted_mm_verts,
lex_sorted_fdrake_verts.T,
atol=CLOSE_ATOL)
# Ensure the discretization and the firedrake function space reference element
# agree on some basic properties
finat_elt = fdrake_fspace.finat_element
assert len(discr.groups) == 1
assert discr.groups[0].order == finat_elt.degree
assert discr.groups[0].nunit_dofs == finat_elt.space_dimension()
def run_method(trial,
method,
cl_ctx=None,
queue=None,
clear_memoized_objects=False,
true_sol_name="True Solution",
comp_sol_name="Computed Solution",
**kwargs):
"""
Returns (true solution, computed solution, snes_or_ksp)
:arg clear_memoized_objects: Destroy memoized objects if true.
:arg trial: A dict mapping each trial option to a valid value
:arg method: A valid method (see the keys of *method_options*)
:arg cl_ctx: the computing context
:arg queue: the computing queue for the context
kwargs should include the boundary id of the scatterer as 'scatterer_bdy_id'
and the boundary id of the outer boundary as 'outer_bdy_id'
kwargs should include the method options for :arg:`trial['method']`.
for the given method.
"""
if clear_memoized_objects:
global memoized_objects
memoized_objects = {}
if cl_ctx is None:
raise ValueError("Missing cl_ctx")
if queue is None:
raise ValueError("Missing queue")
# Get boundary ids
scatterer_bdy_id = kwargs['scatterer_bdy_id']
outer_bdy_id = kwargs['outer_bdy_id']
# Get degree and wave number
degree = trial['degree']
wave_number = trial['kappa']
# Get options prefix and solver parameters, if any
options_prefix = kwargs.get('options_prefix', None)
solver_parameters = dict(kwargs.get('solver_parameters', None))
# Get prepared trial args in kwargs
prepared_trial = prepare_trial(trial, true_sol_name, cl_ctx, queue)
mesh, fspace, vfspace, true_sol, true_sol_grad_expr = prepared_trial
# Create a place to memoize any objects if necessary
tuple_trial = trial_to_tuple(trial)
memo_key = tuple_trial[:2]
if memo_key not in memoized_objects:
memoized_objects[memo_key] = {}
comp_sol = None
# Handle any special kwargs and get computed solution
if method == 'pml':
# Get required objects
pml_max = kwargs['pml_max']
pml_min = kwargs['pml_min']
# Get optional argumetns
pml_type = kwargs.get('pml_type', None)
quad_const = kwargs.get('quad_const', None)
speed = kwargs.get('speed', None)
# Make tensor function space
if 'tfspace' not in memoized_objects[memo_key]:
memoized_objects[memo_key]['tfspace'] = \
TensorFunctionSpace(mesh, 'CG', degree)
tfspace = memoized_objects[memo_key]['tfspace']
snes, comp_sol = pml(
mesh,
scatterer_bdy_id,
outer_bdy_id,
wave_number,
options_prefix=options_prefix,
solver_parameters=solver_parameters,
fspace=fspace,
tfspace=tfspace,
true_sol_grad_expr=true_sol_grad_expr,
pml_type=pml_type,
quad_const=quad_const,
speed=speed,
pml_min=pml_min,
pml_max=pml_max,
)
snes_or_ksp = snes
elif method == 'nonlocal':
# Build DG spaces if not already built
if 'dgfspace' not in memoized_objects[memo_key]:
memoized_objects[memo_key]['dgfspace'] = \
FunctionSpace(mesh, 'DG', degree)
if 'dgvfspace' not in memoized_objects[memo_key]:
memoized_objects[memo_key]['dgvfspace'] = \
VectorFunctionSpace(mesh, 'DG', degree)
dgfspace = memoized_objects[memo_key]['dgfspace']
dgvfspace = memoized_objects[memo_key]['dgvfspace']
# Get opencl array context
from meshmode.array_context import PyOpenCLArrayContext
actx = PyOpenCLArrayContext(queue)
# Build connection fd -> meshmode if not already built
if 'meshmode_src_connection' not in memoized_objects[memo_key]:
from meshmode.interop.firedrake import build_connection_from_firedrake
memoized_objects[memo_key]['meshmode_src_connection'] = \
build_connection_from_firedrake(
actx,
dgfspace,
grp_factory=None,
restrict_to_boundary=scatterer_bdy_id)
meshmode_src_connection = memoized_objects[memo_key][
'meshmode_src_connection']
# Set defaults for qbx kwargs
qbx_order = kwargs.get('qbx_order', degree + 2)
fine_order = kwargs.get('fine_order', 4 * degree)
fmm_order = kwargs.get('FMM Order', None)
fmm_tol = kwargs.get('FMM Tol', None)
# make sure got either fmm_order xor fmm_tol
if fmm_order is None and fmm_tol is None:
raise ValueError("At least one of 'fmm_order', 'fmm_tol' must not "
"be *None*")
if fmm_order is not None and fmm_tol is not None:
raise ValueError("At most one of 'fmm_order', 'fmm_tol' must not "
"be *None*")
# if got fmm_tol, make a level-to-order
fmm_level_to_order = None
if fmm_tol is not None:
if not isinstance(fmm_tol, float):
raise TypeError("fmm_tol of type '%s' is not of type float" %
type(fmm_tol))
if fmm_tol <= 0.0:
raise ValueError(
"fmm_tol of '%s' is less than or equal to 0.0" % fmm_tol)
from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder
fmm_level_to_order = SimpleExpansionOrderFinder(fmm_tol)
# Otherwise, make sure we got a valid fmm_order
else:
if not isinstance(fmm_order, int):
if fmm_order != False:
raise TypeError(
"fmm_order of type '%s' is not of type int" %
type(fmm_order))
if fmm_order != False and fmm_order < 1:
raise ValueError("fmm_order of '%s' is less than 1" %
fmm_order)
qbx_kwargs = {
'qbx_order': qbx_order,
'fine_order': fine_order,
'fmm_order': fmm_order,
'fmm_level_to_order': fmm_level_to_order,
'fmm_backend': 'fmmlib',
}
# }}}
ksp, comp_sol = nonlocal_integral_eq(
mesh,
scatterer_bdy_id,
outer_bdy_id,
wave_number,
options_prefix=options_prefix,
solver_parameters=solver_parameters,
fspace=fspace,
vfspace=vfspace,
true_sol_grad_expr=true_sol_grad_expr,
actx=actx,
dgfspace=dgfspace,
dgvfspace=dgvfspace,
meshmode_src_connection=meshmode_src_connection,
qbx_kwargs=qbx_kwargs,
)
snes_or_ksp = ksp
elif method == 'transmission':
snes, comp_sol = transmission(
mesh,
scatterer_bdy_id,
outer_bdy_id,
wave_number,
options_prefix=options_prefix,
solver_parameters=solver_parameters,
fspace=fspace,
true_sol_grad_expr=true_sol_grad_expr,
)
snes_or_ksp = snes
else:
raise ValueError("Invalid method")
comp_sol.rename(name=comp_sol_name)
return true_sol, comp_sol, snes_or_ksp