def test_inverse_modal_connections_quadgrid(actx_factory):
actx = actx_factory()
order = 5
def f(x):
return 1 + 2 * x + 3 * x**2
# Make a regular rectangle mesh
mesh = mgen.generate_regular_rect_mesh(
a=(0, 0),
b=(5, 3),
npoints_per_axis=(10, 6),
order=order,
group_cls=QuadratureSimplexGroupFactory.mesh_group_class)
dcoll = DiscretizationCollection(
actx,
mesh,
discr_tag_to_group_factory={
dof_desc.DISCR_TAG_BASE:
PolynomialWarpAndBlend2DRestrictingGroupFactory(order),
dof_desc.DISCR_TAG_QUAD:
QuadratureSimplexGroupFactory(2 * order)
})
# Use dof descriptors on the quadrature grid
dd_modal = dof_desc.DD_VOLUME_MODAL
dd_quad = dof_desc.DOFDesc(dof_desc.DTAG_VOLUME_ALL,
dof_desc.DISCR_TAG_QUAD)
x_quad = thaw(dcoll.discr_from_dd(dd_quad).nodes()[0], actx)
quad_f = f(x_quad)
# Map nodal coefficients of f to modal coefficients
forward_conn = dcoll.connection_from_dds(dd_quad, dd_modal)
modal_f = forward_conn(quad_f)
# Now map the modal coefficients back to nodal
backward_conn = dcoll.connection_from_dds(dd_modal, dd_quad)
quad_f_2 = backward_conn(modal_f)
# This error should be small since we composed a map with
# its inverse
err = flat_norm(quad_f - quad_f_2)
assert err <= 1e-11
def test_empty_boundary(actx_factory):
# https://github.com/inducer/grudge/issues/54
from meshmode.mesh import BTAG_NONE
actx = actx_factory()
dim = 2
mesh = mgen.generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
nelements_per_axis=(8, ) * dim,
order=4)
discr = DiscretizationCollection(actx, mesh, order=4)
normal = bind(discr, sym.normal(BTAG_NONE, dim, dim=dim - 1))(actx)
from meshmode.dof_array import DOFArray
for component in normal:
assert isinstance(component, DOFArray)
assert len(component) == len(discr.discr_from_dd(BTAG_NONE).groups)
def inverse_first_fundamental_form(actx: ArrayContext,
dcoll: DiscretizationCollection,
dd=None) -> np.ndarray:
r"""Computes the inverse of the first fundamental form:
.. math::
\begin{bmatrix}
E & F \\ F & G
\end{bmatrix}^{-1} =
\frac{1}{E G - F^2}
\begin{bmatrix}
G & -F \\ -F & E
\end{bmatrix}
where :math:`E, F, G` are coefficients of the first fundamental form.
:arg dd: a :class:`~grudge.dof_desc.DOFDesc`, or a value convertible to one.
Defaults to the base volume discretization.
:returns: a matrix containing coefficients of the inverse of the
first fundamental form.
"""
if dd is None:
dd = DD_VOLUME
dim = dcoll.discr_from_dd(dd).dim
if dcoll.ambient_dim == dim:
inv_mder = inverse_metric_derivative_mat(actx, dcoll, dd=dd)
inv_form1 = inv_mder.dot(inv_mder.T)
else:
form1 = first_fundamental_form(actx, dcoll, dd=dd)
if dim == 1:
inv_form1 = 1.0 / form1
elif dim == 2:
(E, F), (_, G) = form1 # noqa: N806
inv_form1 = 1.0 / (E * G - F * F) * np.stack(
[make_obj_array([G, -F]),
make_obj_array([-F, E])])
else:
raise ValueError(f"{dim}D surfaces not supported" % dim)
return inv_form1
def _signed_face_ones(actx: ArrayContext, dcoll: DiscretizationCollection,
dd) -> DOFArray:
assert dd.is_trace()
# NOTE: ignore quadrature_tags on dd, since we only care about
# the face_id here
all_faces_conn = dcoll.connection_from_dds(DD_VOLUME,
DOFDesc(dd.domain_tag))
signed_face_ones = dcoll.discr_from_dd(dd).zeros(
actx, dtype=dcoll.real_dtype) + 1
for igrp, grp in enumerate(all_faces_conn.groups):
for batch in grp.batches:
i = actx.thaw(batch.to_element_indices)
grp_field = signed_face_ones[igrp].reshape(-1)
grp_field[i] = \
(2.0 * (batch.to_element_face % 2) - 1.0) * grp_field[i]
return signed_face_ones
def test_inverse_modal_connections(actx_factory, nodal_group_factory):
actx = actx_factory()
order = 4
def f(x):
return 2 * actx.np.sin(20 * x) + 0.5 * actx.np.cos(10 * x)
# Make a regular rectangle mesh
mesh = mgen.generate_regular_rect_mesh(
a=(0, 0),
b=(5, 3),
npoints_per_axis=(10, 6),
order=order,
group_cls=nodal_group_factory.mesh_group_class)
dcoll = DiscretizationCollection(actx,
mesh,
discr_tag_to_group_factory={
dof_desc.DISCR_TAG_BASE:
nodal_group_factory(order)
})
dd_modal = dof_desc.DD_VOLUME_MODAL
dd_volume = dof_desc.DD_VOLUME
x_nodal = thaw(actx, dcoll.discr_from_dd(dd_volume).nodes()[0])
nodal_f = f(x_nodal)
# Map nodal coefficients of f to modal coefficients
forward_conn = dcoll.connection_from_dds(dd_volume, dd_modal)
modal_f = forward_conn(nodal_f)
# Now map the modal coefficients back to nodal
backward_conn = dcoll.connection_from_dds(dd_modal, dd_volume)
nodal_f_2 = backward_conn(modal_f)
# This error should be small since we composed a map with
# its inverse
err = actx.np.linalg.norm(nodal_f - nodal_f_2)
assert err <= 1e-13
def test_2d_gauss_theorem(actx_factory):
"""Verify Gauss's theorem explicitly on a mesh"""
pytest.importorskip("meshpy")
from meshpy.geometry import make_circle, GeometryBuilder
from meshpy.triangle import MeshInfo, build
geob = GeometryBuilder()
geob.add_geometry(*make_circle(1))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info = build(mesh_info)
from meshmode.mesh.io import from_meshpy
from meshmode.mesh import BTAG_ALL
mesh = from_meshpy(mesh_info, order=1)
actx = actx_factory()
dcoll = DiscretizationCollection(actx, mesh, order=2)
volm_disc = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
x_volm = thaw(volm_disc.nodes(), actx)
def f(x):
return flat_obj_array(
actx.np.sin(3 * x[0]) + actx.np.cos(3 * x[1]),
actx.np.sin(2 * x[0]) + actx.np.cos(x[1]))
f_volm = f(x_volm)
int_1 = op.integral(dcoll, "vol", op.local_div(dcoll, f_volm))
prj_f = op.project(dcoll, "vol", BTAG_ALL, f_volm)
normal = thaw(dcoll.normal(BTAG_ALL), actx)
int_2 = op.integral(dcoll, BTAG_ALL, prj_f.dot(normal))
assert abs(int_1 - int_2) < 1e-13
def test_tri_diff_mat(actx_factory, dim, order=4):
"""Check differentiation matrix along the coordinate axes on a disk
Uses sines as the function to differentiate.
"""
actx = actx_factory()
from pytools.convergence import EOCRecorder
axis_eoc_recs = [EOCRecorder() for axis in range(dim)]
def f(x, axis):
return actx.np.sin(3 * x[axis])
def df(x, axis):
return 3 * actx.np.cos(3 * x[axis])
for n in [4, 8, 16]:
mesh = mgen.generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
nelements_per_axis=(n, ) * dim,
order=4)
dcoll = DiscretizationCollection(actx, mesh, order=4)
volume_discr = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
x = thaw(volume_discr.nodes(), actx)
for axis in range(dim):
df_num = op.local_grad(dcoll, f(x, axis))[axis]
df_volm = df(x, axis)
linf_error = flat_norm(df_num - df_volm, ord=np.inf)
axis_eoc_recs[axis].add_data_point(1 / n,
actx.to_numpy(linf_error))
for axis, eoc_rec in enumerate(axis_eoc_recs):
logger.info("axis %d\n%s", axis, eoc_rec)
assert eoc_rec.order_estimate() > order - 0.25
def inverse_metric_derivative_mat(actx: ArrayContext,
dcoll: DiscretizationCollection,
dd=None) -> np.ndarray:
r"""Computes the inverse metric derivative matrix, which is
the inverse of the Jacobian (forward metric derivative) matrix.
:arg dd: a :class:`~grudge.dof_desc.DOFDesc`, or a value convertible to one.
Defaults to the base volume discretization.
:returns: a matrix containing the evaluated inverse metric derivatives.
"""
ambient_dim = dcoll.ambient_dim
if dd is None:
dd = DD_VOLUME
dim = dcoll.discr_from_dd(dd).dim
result = np.zeros((ambient_dim, dim), dtype=object)
for i in range(dim):
for j in range(ambient_dim):
result[i, j] = inverse_metric_derivative(actx, dcoll, i, j, dd=dd)
return result
def test_function_symbol_array(actx_factory, array_type):
"""Test if `FunctionSymbol` distributed properly over object arrays."""
actx = actx_factory()
dim = 2
mesh = mgen.generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
nelements_per_axis=(8, ) * dim,
order=4)
discr = DiscretizationCollection(actx, mesh, order=4)
volume_discr = discr.discr_from_dd(dof_desc.DD_VOLUME)
if array_type == "scalar":
sym_x = sym.var("x")
x = thaw(actx, actx.np.cos(volume_discr.nodes()[0]))
elif array_type == "vector":
sym_x = sym.make_sym_array("x", dim)
x = thaw(actx, volume_discr.nodes())
else:
raise ValueError("unknown array type")
norm = bind(discr, sym.norm(2, sym_x))(x=x)
assert isinstance(norm, float)
def area_element(actx: ArrayContext,
dcoll: DiscretizationCollection,
dd=None) -> DOFArray:
r"""Computes the scale factor used to transform integrals from reference
to global space.
:arg dd: a :class:`~grudge.dof_desc.DOFDesc`, or a value convertible to one.
Defaults to the base volume discretization.
:returns: a :class:`~meshmode.dof_array.DOFArray` containing the transformed
volumes for each element.
"""
if dd is None:
dd = DD_VOLUME
dim = dcoll.discr_from_dd(dd).dim
@memoize_in(dcoll, (area_element, dd, "area_elements_adim%s_gdim%s" %
(dcoll.ambient_dim, dim)))
def _area_elements():
return freeze(
actx.np.sqrt(pseudoscalar(actx, dcoll, dd=dd).norm_squared()),
actx)
return thaw(_area_elements(), actx)
def main(ctx_factory, dim=2, order=4, product_tag=None, visualize=False):
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
# {{{ parameters
# sphere radius
radius = 1.0
# sphere resolution
resolution = 64 if dim == 2 else 1
# cfl
dt_factor = 2.0
# final time
final_time = np.pi
# velocity field
sym_x = sym.nodes(dim)
c = make_obj_array([-sym_x[1], sym_x[0], 0.0])[:dim]
# flux
flux_type = "lf"
# }}}
# {{{ discretization
if dim == 2:
from meshmode.mesh.generation import make_curve_mesh, ellipse
mesh = make_curve_mesh(lambda t: radius * ellipse(1.0, t),
np.linspace(0.0, 1.0, resolution + 1), order)
elif dim == 3:
from meshmode.mesh.generation import generate_icosphere
mesh = generate_icosphere(radius,
order=4 * order,
uniform_refinement_rounds=resolution)
else:
raise ValueError("unsupported dimension")
discr_tag_to_group_factory = {}
if product_tag == "none":
product_tag = None
else:
product_tag = dof_desc.DISCR_TAG_QUAD
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory, \
QuadratureSimplexGroupFactory
discr_tag_to_group_factory[dof_desc.DISCR_TAG_BASE] = \
PolynomialWarpAndBlendGroupFactory(order)
if product_tag:
discr_tag_to_group_factory[product_tag] = \
QuadratureSimplexGroupFactory(order=4*order)
from grudge import DiscretizationCollection
discr = DiscretizationCollection(
actx, mesh, discr_tag_to_group_factory=discr_tag_to_group_factory)
volume_discr = discr.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume_discr.ndofs)
logger.info("nelements: %d", volume_discr.mesh.nelements)
# }}}
# {{{ symbolic operators
def f_initial_condition(x):
return x[0]
from grudge.models.advection import SurfaceAdvectionOperator
op = SurfaceAdvectionOperator(c, flux_type=flux_type, quad_tag=product_tag)
bound_op = bind(discr, op.sym_operator())
u0 = bind(discr, f_initial_condition(sym_x))(actx, t=0)
def rhs(t, u):
return bound_op(actx, t=t, u=u)
# check velocity is tangential
sym_normal = sym.surface_normal(dim, dim=dim - 1,
dd=dof_desc.DD_VOLUME).as_vector()
error = bind(discr, sym.norm(2, c.dot(sym_normal)))(actx)
logger.info("u_dot_n: %.5e", error)
# }}}
# {{{ time stepping
# compute time step
h_min = bind(discr, sym.h_max_from_volume(discr.ambient_dim,
dim=discr.dim))(actx)
dt = dt_factor * h_min / order**2
nsteps = int(final_time // dt) + 1
dt = final_time / nsteps + 1.0e-15
logger.info("dt: %.5e", dt)
logger.info("nsteps: %d", nsteps)
from grudge.shortcuts import set_up_rk4
dt_stepper = set_up_rk4("u", dt, u0, rhs)
plot = Plotter(actx, discr, order, visualize=visualize)
norm = bind(discr, sym.norm(2, sym.var("u")))
norm_u = norm(actx, u=u0)
step = 0
event = dt_stepper.StateComputed(0.0, 0, 0, u0)
plot(event, "fld-surface-%04d" % 0)
if visualize and dim == 3:
from grudge.shortcuts import make_visualizer
vis = make_visualizer(discr)
vis.write_vtk_file("fld-surface-velocity.vtu",
[("u", bind(discr, c)(actx)),
("n", bind(discr, sym_normal)(actx))],
overwrite=True)
df = dof_desc.DOFDesc(FACE_RESTR_INTERIOR)
face_discr = discr.connection_from_dds(dof_desc.DD_VOLUME, df).to_discr
face_normal = bind(
discr, sym.normal(df, face_discr.ambient_dim,
dim=face_discr.dim))(actx)
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, face_discr)
vis.write_vtk_file("fld-surface-face-normals.vtu",
[("n", face_normal)],
overwrite=True)
for event in dt_stepper.run(t_end=final_time, max_steps=nsteps + 1):
if not isinstance(event, dt_stepper.StateComputed):
continue
step += 1
if step % 10 == 0:
norm_u = norm(actx, u=event.state_component)
plot(event, "fld-surface-%04d" % step)
logger.info("[%04d] t = %.5f |u| = %.5e", step, event.t, norm_u)
plot(event, "fld-surface-%04d" % step)
def test_mass_surface_area(actx_factory, name):
actx = actx_factory()
# {{{ cases
if name == "2-1-ellipse":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=3.1, aspect_ratio=2.0)
surface_area = _ellipse_surface_area(builder.radius,
builder.aspect_ratio)
elif name == "spheroid":
from mesh_data import SpheroidMeshBuilder
builder = SpheroidMeshBuilder()
surface_area = _spheroid_surface_area(builder.radius,
builder.aspect_ratio)
elif name == "box2d":
from mesh_data import BoxMeshBuilder
builder = BoxMeshBuilder(ambient_dim=2)
surface_area = 1.0
elif name == "box3d":
from mesh_data import BoxMeshBuilder
builder = BoxMeshBuilder(ambient_dim=3)
surface_area = 1.0
else:
raise ValueError("unknown geometry name: %s" % name)
# }}}
# {{{ convergence
from pytools.convergence import EOCRecorder
eoc = EOCRecorder()
for resolution in builder.resolutions:
mesh = builder.get_mesh(resolution, builder.mesh_order)
dcoll = DiscretizationCollection(actx, mesh, order=builder.order)
volume_discr = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume_discr.ndofs)
logger.info("nelements: %d", volume_discr.mesh.nelements)
# {{{ compute surface area
dd = dof_desc.DD_VOLUME
ones_volm = volume_discr.zeros(actx) + 1
approx_surface_area = actx.to_numpy(op.integral(dcoll, dd, ones_volm))
logger.info("surface: got {:.5e} / expected {:.5e}".format(
approx_surface_area, surface_area))
area_error = abs(approx_surface_area -
surface_area) / abs(surface_area)
# }}}
# compute max element size
from grudge.dt_utils import h_max_from_volume
h_max = h_max_from_volume(dcoll)
eoc.add_data_point(h_max, area_error)
# }}}
logger.info("surface area error\n%s", str(eoc))
assert eoc.max_error() < 3e-13 or eoc.order_estimate() > builder.order
def test_surface_divergence_theorem(actx_factory, mesh_name, visualize=False):
r"""Check the surface divergence theorem.
.. math::
\int_Sigma \phi \nabla_i f_i =
\int_\Sigma \nabla_i \phi f_i +
\int_\Sigma \kappa \phi f_i n_i +
\int_{\partial \Sigma} \phi f_i m_i
where :math:`n_i` is the surface normal and :class:`m_i` is the
face normal (which should be orthogonal to both the surface normal
and the face tangent).
"""
actx = actx_factory()
# {{{ cases
if mesh_name == "2-1-ellipse":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=3.1, aspect_ratio=2.0)
elif mesh_name == "spheroid":
from mesh_data import SpheroidMeshBuilder
builder = SpheroidMeshBuilder()
elif mesh_name == "circle":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=1.0, aspect_ratio=1.0)
elif mesh_name == "starfish":
from mesh_data import StarfishMeshBuilder
builder = StarfishMeshBuilder()
elif mesh_name == "sphere":
from mesh_data import SphereMeshBuilder
builder = SphereMeshBuilder(radius=1.0, mesh_order=16)
else:
raise ValueError("unknown mesh name: %s" % mesh_name)
# }}}
# {{{ convergene
def f(x):
return flat_obj_array(
sym.sin(3 * x[1]) + sym.cos(3 * x[0]) + 1.0,
sym.sin(2 * x[0]) + sym.cos(x[1]),
3.0 * sym.cos(x[0] / 2) + sym.cos(x[1]),
)[:ambient_dim]
from pytools.convergence import EOCRecorder
eoc_global = EOCRecorder()
eoc_local = EOCRecorder()
theta = np.pi / 3.33
ambient_dim = builder.ambient_dim
if ambient_dim == 2:
mesh_rotation = np.array([
[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)],
])
else:
mesh_rotation = np.array([
[1.0, 0.0, 0.0],
[0.0, np.cos(theta), -np.sin(theta)],
[0.0, np.sin(theta), np.cos(theta)],
])
mesh_offset = np.array([0.33, -0.21, 0.0])[:ambient_dim]
for i, resolution in enumerate(builder.resolutions):
from meshmode.mesh.processing import affine_map
from meshmode.discretization.connection import FACE_RESTR_ALL
mesh = builder.get_mesh(resolution, builder.mesh_order)
mesh = affine_map(mesh, A=mesh_rotation, b=mesh_offset)
from meshmode.discretization.poly_element import \
QuadratureSimplexGroupFactory
discr = DiscretizationCollection(actx,
mesh,
order=builder.order,
discr_tag_to_group_factory={
"product":
QuadratureSimplexGroupFactory(
2 * builder.order)
})
volume = discr.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume.ndofs)
logger.info("nelements: %d", volume.mesh.nelements)
dd = dof_desc.DD_VOLUME
dq = dd.with_discr_tag("product")
df = dof_desc.as_dofdesc(FACE_RESTR_ALL)
ambient_dim = discr.ambient_dim
dim = discr.dim
# variables
sym_f = f(sym.nodes(ambient_dim, dd=dd))
sym_f_quad = f(sym.nodes(ambient_dim, dd=dq))
sym_kappa = sym.summed_curvature(ambient_dim, dim=dim, dd=dq)
sym_normal = sym.surface_normal(ambient_dim, dim=dim,
dd=dq).as_vector()
sym_face_normal = sym.normal(df, ambient_dim, dim=dim - 1)
sym_face_f = sym.project(dd, df)(sym_f)
# operators
sym_stiff = sum(
sym.StiffnessOperator(d)(f) for d, f in enumerate(sym_f))
sym_stiff_t = sum(
sym.StiffnessTOperator(d)(f) for d, f in enumerate(sym_f))
sym_k = sym.MassOperator(dq,
dd)(sym_kappa * sym_f_quad.dot(sym_normal))
sym_flux = sym.FaceMassOperator()(sym_face_f.dot(sym_face_normal))
# sum everything up
sym_op_global = sym.NodalSum(dd)(sym_stiff - (sym_stiff_t + sym_k))
sym_op_local = sym.ElementwiseSumOperator(dd)(sym_stiff -
(sym_stiff_t + sym_k +
sym_flux))
# evaluate
op_global = bind(discr, sym_op_global)(actx)
op_local = bind(discr, sym_op_local)(actx)
err_global = abs(op_global)
err_local = bind(discr, sym.norm(np.inf, sym.var("x")))(actx,
x=op_local)
logger.info("errors: global %.5e local %.5e", err_global, err_local)
# compute max element size
h_max = bind(
discr,
sym.h_max_from_volume(discr.ambient_dim, dim=discr.dim,
dd=dd))(actx)
eoc_global.add_data_point(h_max, err_global)
eoc_local.add_data_point(h_max, err_local)
if visualize:
from grudge.shortcuts import make_visualizer
vis = make_visualizer(discr, vis_order=builder.order)
filename = f"surface_divergence_theorem_{mesh_name}_{i:04d}.vtu"
vis.write_vtk_file(filename, [("r", actx.np.log10(op_local))],
overwrite=True)
# }}}
order = min(builder.order, builder.mesh_order) - 0.5
logger.info("\n%s", str(eoc_global))
logger.info("\n%s", str(eoc_local))
assert eoc_global.max_error() < 1.0e-12 \
or eoc_global.order_estimate() > order - 0.5
assert eoc_local.max_error() < 1.0e-12 \
or eoc_local.order_estimate() > order - 0.5
def test_face_normal_surface(actx_factory, mesh_name):
"""Check that face normals are orthogonal to the surface normal"""
actx = actx_factory()
# {{{ geometry
if mesh_name == "2-1-ellipse":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=3.1, aspect_ratio=2.0)
elif mesh_name == "spheroid":
from mesh_data import SpheroidMeshBuilder
builder = SpheroidMeshBuilder()
else:
raise ValueError("unknown mesh name: %s" % mesh_name)
mesh = builder.get_mesh(builder.resolutions[0], builder.mesh_order)
discr = DiscretizationCollection(actx, mesh, order=builder.order)
volume_discr = discr.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume_discr.ndofs)
logger.info("nelements: %d", volume_discr.mesh.nelements)
# }}}
# {{{ symbolic
from meshmode.discretization.connection import FACE_RESTR_INTERIOR
dv = dof_desc.DD_VOLUME
df = dof_desc.as_dofdesc(FACE_RESTR_INTERIOR)
ambient_dim = mesh.ambient_dim
dim = mesh.dim
sym_surf_normal = sym.project(dv,
df)(sym.surface_normal(ambient_dim,
dim=dim,
dd=dv).as_vector())
sym_surf_normal = sym_surf_normal / sym.sqrt(sum(sym_surf_normal**2))
sym_face_normal_i = sym.normal(df, ambient_dim, dim=dim - 1)
sym_face_normal_e = sym.OppositeInteriorFaceSwap(df)(sym_face_normal_i)
if mesh.ambient_dim == 3:
# NOTE: there's only one face tangent in 3d
sym_face_tangent = (
sym.pseudoscalar(ambient_dim, dim - 1, dd=df) /
sym.area_element(ambient_dim, dim - 1, dd=df)).as_vector()
# }}}
# {{{ checks
def _eval_error(x):
return bind(discr, sym.norm(np.inf, sym.var("x", dd=df), dd=df))(actx,
x=x)
rtol = 1.0e-14
surf_normal = bind(discr, sym_surf_normal)(actx)
face_normal_i = bind(discr, sym_face_normal_i)(actx)
face_normal_e = bind(discr, sym_face_normal_e)(actx)
# check interpolated surface normal is orthogonal to face normal
error = _eval_error(surf_normal.dot(face_normal_i))
logger.info("error[n_dot_i]: %.5e", error)
assert error < rtol
# check angle between two neighboring elements
error = _eval_error(face_normal_i.dot(face_normal_e) + 1.0)
logger.info("error[i_dot_e]: %.5e", error)
assert error > rtol
# check orthogonality with face tangent
if ambient_dim == 3:
face_tangent = bind(discr, sym_face_tangent)(actx)
error = _eval_error(face_tangent.dot(face_normal_i))
logger.info("error[t_dot_i]: %.5e", error)
assert error < 5 * rtol
def test_mass_surface_area(actx_factory, name):
actx = actx_factory()
# {{{ cases
if name == "2-1-ellipse":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=3.1, aspect_ratio=2.0)
surface_area = _ellipse_surface_area(builder.radius,
builder.aspect_ratio)
elif name == "spheroid":
from mesh_data import SpheroidMeshBuilder
builder = SpheroidMeshBuilder()
surface_area = _spheroid_surface_area(builder.radius,
builder.aspect_ratio)
elif name == "box2d":
from mesh_data import BoxMeshBuilder
builder = BoxMeshBuilder(ambient_dim=2)
surface_area = 1.0
elif name == "box3d":
from mesh_data import BoxMeshBuilder
builder = BoxMeshBuilder(ambient_dim=3)
surface_area = 1.0
else:
raise ValueError("unknown geometry name: %s" % name)
# }}}
# {{{ convergence
from pytools.convergence import EOCRecorder
eoc = EOCRecorder()
for resolution in builder.resolutions:
mesh = builder.get_mesh(resolution, builder.mesh_order)
discr = DiscretizationCollection(actx, mesh, order=builder.order)
volume_discr = discr.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume_discr.ndofs)
logger.info("nelements: %d", volume_discr.mesh.nelements)
# {{{ compute surface area
dd = dof_desc.DD_VOLUME
sym_op = sym.NodalSum(dd)(sym.MassOperator(dd, dd)(sym.Ones(dd)))
approx_surface_area = bind(discr, sym_op)(actx)
logger.info("surface: got {:.5e} / expected {:.5e}".format(
approx_surface_area, surface_area))
area_error = abs(approx_surface_area -
surface_area) / abs(surface_area)
# }}}
h_max = bind(
discr,
sym.h_max_from_volume(discr.ambient_dim, dim=discr.dim,
dd=dd))(actx)
eoc.add_data_point(h_max, area_error + 1.0e-16)
# }}}
logger.info("surface area error\n%s", str(eoc))
assert eoc.max_error() < 1.0e-14 \
or eoc.order_estimate() > builder.order
def forward_metric_nth_derivative(actx: ArrayContext,
dcoll: DiscretizationCollection,
xyz_axis,
ref_axes,
dd=None) -> DOFArray:
r"""Pointwise metric derivatives representing repeated derivatives of the
physical coordinate enumerated by *xyz_axis*: :math:`x_{\mathrm{xyz\_axis}}`
with respect to the coordiantes on the reference element :math:`\xi_i`:
.. math::
D^\alpha x_{\mathrm{xyz\_axis}} =
\frac{\partial^{|\alpha|} x_{\mathrm{xyz\_axis}} }{
\partial \xi_1^{\alpha_1}\cdots \partial \xi_m^{\alpha_m}}
where :math:`\alpha` is a multi-index described by *ref_axes*.
:arg xyz_axis: an integer denoting which physical coordinate to
differentiate.
:arg ref_axes: a :class:`tuple` of tuples indicating indices of
coordinate axes of the reference element to the number of derivatives
which will be taken. For example, the value ``((0, 2), (1, 1))``
indicates taking the second derivative with respect to the first
axis and the first derivative with respect to the second
axis. Each axis must occur only once and the tuple must be sorted
by the axis index.
:arg dd: a :class:`~grudge.dof_desc.DOFDesc`, or a value convertible to one.
Defaults to the base volume discretization.
:returns: a :class:`~meshmode.dof_array.DOFArray` containing the pointwise
metric derivative at each nodal coordinate.
"""
if dd is None:
dd = DD_VOLUME
inner_dd = dd.with_discr_tag(DISCR_TAG_BASE)
if isinstance(ref_axes, int):
ref_axes = ((ref_axes, 1), )
if not isinstance(ref_axes, tuple):
raise ValueError("ref_axes must be a tuple")
if tuple(sorted(ref_axes)) != ref_axes:
raise ValueError("ref_axes must be sorted")
if len(set(ref_axes)) != len(ref_axes):
raise ValueError("ref_axes must not contain an axis more than once")
from pytools import flatten
flat_ref_axes = flatten([rst_axis] * n for rst_axis, n in ref_axes)
from meshmode.discretization import num_reference_derivative
vec = num_reference_derivative(
dcoll.discr_from_dd(inner_dd), flat_ref_axes,
thaw(dcoll.discr_from_dd(inner_dd).nodes(), actx)[xyz_axis])
if dd.uses_quadrature():
vec = dcoll.connection_from_dds(inner_dd, dd)(vec)
return vec
def main(ctx_factory, dim=2, order=4, use_quad=False, visualize=False):
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(
queue,
allocator=cl_tools.MemoryPool(cl_tools.ImmediateAllocator(queue)),
force_device_scalars=True,
)
# {{{ parameters
# sphere radius
radius = 1.0
# sphere resolution
resolution = 64 if dim == 2 else 1
# final time
final_time = np.pi
# flux
flux_type = "lf"
# }}}
# {{{ discretization
if dim == 2:
from meshmode.mesh.generation import make_curve_mesh, ellipse
mesh = make_curve_mesh(
lambda t: radius * ellipse(1.0, t),
np.linspace(0.0, 1.0, resolution + 1),
order)
elif dim == 3:
from meshmode.mesh.generation import generate_icosphere
mesh = generate_icosphere(radius, order=4 * order,
uniform_refinement_rounds=resolution)
else:
raise ValueError("unsupported dimension")
discr_tag_to_group_factory = {}
if use_quad:
qtag = dof_desc.DISCR_TAG_QUAD
else:
qtag = None
from meshmode.discretization.poly_element import \
default_simplex_group_factory, \
QuadratureSimplexGroupFactory
discr_tag_to_group_factory[dof_desc.DISCR_TAG_BASE] = \
default_simplex_group_factory(base_dim=dim-1, order=order)
if use_quad:
discr_tag_to_group_factory[qtag] = \
QuadratureSimplexGroupFactory(order=4*order)
from grudge import DiscretizationCollection
dcoll = DiscretizationCollection(
actx, mesh,
discr_tag_to_group_factory=discr_tag_to_group_factory
)
volume_discr = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume_discr.ndofs)
logger.info("nelements: %d", volume_discr.mesh.nelements)
# }}}
# {{{ Surface advection operator
# velocity field
x = thaw(dcoll.nodes(), actx)
c = make_obj_array([-x[1], x[0], 0.0])[:dim]
def f_initial_condition(x):
return x[0]
from grudge.models.advection import SurfaceAdvectionOperator
adv_operator = SurfaceAdvectionOperator(
dcoll,
c,
flux_type=flux_type,
quad_tag=qtag
)
u0 = f_initial_condition(x)
def rhs(t, u):
return adv_operator.operator(t, u)
# check velocity is tangential
from grudge.geometry import normal
surf_normal = normal(actx, dcoll, dd=dof_desc.DD_VOLUME)
error = op.norm(dcoll, c.dot(surf_normal), 2)
logger.info("u_dot_n: %.5e", error)
# }}}
# {{{ time stepping
# FIXME: dt estimate is not necessarily valid for surfaces
dt = actx.to_numpy(
0.45 * adv_operator.estimate_rk4_timestep(actx, dcoll, fields=u0))
nsteps = int(final_time // dt) + 1
logger.info("dt: %.5e", dt)
logger.info("nsteps: %d", nsteps)
from grudge.shortcuts import set_up_rk4
dt_stepper = set_up_rk4("u", dt, u0, rhs)
plot = Plotter(actx, dcoll, order, visualize=visualize)
norm_u = actx.to_numpy(op.norm(dcoll, u0, 2))
step = 0
event = dt_stepper.StateComputed(0.0, 0, 0, u0)
plot(event, "fld-surface-%04d" % 0)
if visualize and dim == 3:
from grudge.shortcuts import make_visualizer
vis = make_visualizer(dcoll)
vis.write_vtk_file(
"fld-surface-velocity.vtu",
[
("u", c),
("n", surf_normal)
],
overwrite=True
)
df = dof_desc.DOFDesc(FACE_RESTR_INTERIOR)
face_discr = dcoll.discr_from_dd(df)
face_normal = thaw(dcoll.normal(dd=df), actx)
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, face_discr)
vis.write_vtk_file("fld-surface-face-normals.vtu", [
("n", face_normal)
], overwrite=True)
for event in dt_stepper.run(t_end=final_time, max_steps=nsteps + 1):
if not isinstance(event, dt_stepper.StateComputed):
continue
step += 1
if step % 10 == 0:
norm_u = actx.to_numpy(op.norm(dcoll, event.state_component, 2))
plot(event, "fld-surface-%04d" % step)
logger.info("[%04d] t = %.5f |u| = %.5e", step, event.t, norm_u)
# NOTE: These are here to ensure the solution is bounded for the
# time interval specified
assert norm_u < 3
def test_face_normal_surface(actx_factory, mesh_name):
"""Check that face normals are orthogonal to the surface normal"""
actx = actx_factory()
# {{{ geometry
if mesh_name == "2-1-ellipse":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=3.1, aspect_ratio=2.0)
elif mesh_name == "spheroid":
from mesh_data import SpheroidMeshBuilder
builder = SpheroidMeshBuilder()
else:
raise ValueError("unknown mesh name: %s" % mesh_name)
mesh = builder.get_mesh(builder.resolutions[0], builder.mesh_order)
dcoll = DiscretizationCollection(actx, mesh, order=builder.order)
volume_discr = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume_discr.ndofs)
logger.info("nelements: %d", volume_discr.mesh.nelements)
# }}}
# {{{ Compute surface and face normals
from meshmode.discretization.connection import FACE_RESTR_INTERIOR
from grudge.geometry import normal
dv = dof_desc.DD_VOLUME
df = dof_desc.as_dofdesc(FACE_RESTR_INTERIOR)
ambient_dim = mesh.ambient_dim
surf_normal = op.project(dcoll, dv, df, normal(actx, dcoll, dd=dv))
surf_normal = surf_normal / actx.np.sqrt(sum(surf_normal**2))
face_normal_i = thaw(dcoll.normal(df), actx)
face_normal_e = dcoll.opposite_face_connection()(face_normal_i)
if mesh.ambient_dim == 3:
from grudge.geometry import pseudoscalar, area_element
# NOTE: there's only one face tangent in 3d
face_tangent = (pseudoscalar(actx, dcoll, dd=df) /
area_element(actx, dcoll, dd=df)).as_vector(
dtype=object)
# }}}
# {{{ checks
def _eval_error(x):
return op.norm(dcoll, x, np.inf, dd=df)
rtol = 1.0e-14
# check interpolated surface normal is orthogonal to face normal
error = _eval_error(surf_normal.dot(face_normal_i))
logger.info("error[n_dot_i]: %.5e", error)
assert error < rtol
# check angle between two neighboring elements
error = _eval_error(face_normal_i.dot(face_normal_e) + 1.0)
logger.info("error[i_dot_e]: %.5e", error)
assert error > rtol
# check orthogonality with face tangent
if ambient_dim == 3:
error = _eval_error(face_tangent.dot(face_normal_i))
logger.info("error[t_dot_i]: %.5e", error)
assert error < 5 * rtol
def test_mass_mat_trig(actx_factory, ambient_dim, discr_tag):
"""Check the integral of some trig functions on an interval using the mass
matrix.
"""
actx = actx_factory()
nel_1d = 16
order = 4
a = -4.0 * np.pi
b = +9.0 * np.pi
true_integral = 13 * np.pi / 2 * (b - a)**(ambient_dim - 1)
from meshmode.discretization.poly_element import QuadratureSimplexGroupFactory
dd_quad = dof_desc.DOFDesc(dof_desc.DTAG_VOLUME_ALL, discr_tag)
if discr_tag is dof_desc.DISCR_TAG_BASE:
discr_tag_to_group_factory = {}
else:
discr_tag_to_group_factory = {
discr_tag: QuadratureSimplexGroupFactory(order=2 * order)
}
mesh = mgen.generate_regular_rect_mesh(a=(a, ) * ambient_dim,
b=(b, ) * ambient_dim,
nelements_per_axis=(nel_1d, ) *
ambient_dim,
order=1)
dcoll = DiscretizationCollection(
actx,
mesh,
order=order,
discr_tag_to_group_factory=discr_tag_to_group_factory)
def f(x):
return actx.np.sin(x[0])**2
volm_disc = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
x_volm = thaw(volm_disc.nodes(), actx)
f_volm = f(x_volm)
ones_volm = volm_disc.zeros(actx) + 1
quad_disc = dcoll.discr_from_dd(dd_quad)
x_quad = thaw(quad_disc.nodes(), actx)
f_quad = f(x_quad)
ones_quad = quad_disc.zeros(actx) + 1
mop_1 = op.mass(dcoll, dd_quad, f_quad)
num_integral_1 = op.nodal_sum(dcoll, dof_desc.DD_VOLUME, ones_volm * mop_1)
err_1 = abs(num_integral_1 - true_integral)
assert err_1 < 2e-9, err_1
mop_2 = op.mass(dcoll, dd_quad, ones_quad)
num_integral_2 = op.nodal_sum(dcoll, dof_desc.DD_VOLUME, f_volm * mop_2)
err_2 = abs(num_integral_2 - true_integral)
assert err_2 < 2e-9, err_2
if discr_tag is dof_desc.DISCR_TAG_BASE:
# NOTE: `integral` always makes a square mass matrix and
# `QuadratureSimplexGroupFactory` does not have a `mass_matrix` method.
num_integral_3 = op.nodal_sum(dcoll, dof_desc.DD_VOLUME,
f_quad * mop_2)
err_3 = abs(num_integral_3 - true_integral)
assert err_3 < 5e-10, err_3
def test_surface_divergence_theorem(actx_factory, mesh_name, visualize=False):
r"""Check the surface divergence theorem.
.. math::
\int_Sigma \phi \nabla_i f_i =
\int_\Sigma \nabla_i \phi f_i +
\int_\Sigma \kappa \phi f_i n_i +
\int_{\partial \Sigma} \phi f_i m_i
where :math:`n_i` is the surface normal and :class:`m_i` is the
face normal (which should be orthogonal to both the surface normal
and the face tangent).
"""
actx = actx_factory()
# {{{ cases
if mesh_name == "2-1-ellipse":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=3.1, aspect_ratio=2.0)
elif mesh_name == "spheroid":
from mesh_data import SpheroidMeshBuilder
builder = SpheroidMeshBuilder()
elif mesh_name == "circle":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=1.0, aspect_ratio=1.0)
elif mesh_name == "starfish":
from mesh_data import StarfishMeshBuilder
builder = StarfishMeshBuilder()
elif mesh_name == "sphere":
from mesh_data import SphereMeshBuilder
builder = SphereMeshBuilder(radius=1.0, mesh_order=16)
else:
raise ValueError("unknown mesh name: %s" % mesh_name)
# }}}
# {{{ convergence
def f(x):
return flat_obj_array(
actx.np.sin(3 * x[1]) + actx.np.cos(3 * x[0]) + 1.0,
actx.np.sin(2 * x[0]) + actx.np.cos(x[1]),
3.0 * actx.np.cos(x[0] / 2) + actx.np.cos(x[1]),
)[:ambient_dim]
from pytools.convergence import EOCRecorder
eoc_global = EOCRecorder()
eoc_local = EOCRecorder()
theta = np.pi / 3.33
ambient_dim = builder.ambient_dim
if ambient_dim == 2:
mesh_rotation = np.array([
[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)],
])
else:
mesh_rotation = np.array([
[1.0, 0.0, 0.0],
[0.0, np.cos(theta), -np.sin(theta)],
[0.0, np.sin(theta), np.cos(theta)],
])
mesh_offset = np.array([0.33, -0.21, 0.0])[:ambient_dim]
for i, resolution in enumerate(builder.resolutions):
from meshmode.mesh.processing import affine_map
from meshmode.discretization.connection import FACE_RESTR_ALL
mesh = builder.get_mesh(resolution, builder.mesh_order)
mesh = affine_map(mesh, A=mesh_rotation, b=mesh_offset)
from meshmode.discretization.poly_element import \
QuadratureSimplexGroupFactory
qtag = dof_desc.DISCR_TAG_QUAD
dcoll = DiscretizationCollection(actx,
mesh,
order=builder.order,
discr_tag_to_group_factory={
qtag:
QuadratureSimplexGroupFactory(
2 * builder.order)
})
volume = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume.ndofs)
logger.info("nelements: %d", volume.mesh.nelements)
dd = dof_desc.DD_VOLUME
dq = dd.with_discr_tag(qtag)
df = dof_desc.as_dofdesc(FACE_RESTR_ALL)
ambient_dim = dcoll.ambient_dim
# variables
f_num = f(thaw(dcoll.nodes(dd=dd), actx))
f_quad_num = f(thaw(dcoll.nodes(dd=dq), actx))
from grudge.geometry import normal, summed_curvature
kappa = summed_curvature(actx, dcoll, dd=dq)
normal = normal(actx, dcoll, dd=dq)
face_normal = thaw(dcoll.normal(df), actx)
face_f = op.project(dcoll, dd, df, f_num)
# operators
stiff = op.mass(
dcoll,
sum(
op.local_d_dx(dcoll, i, f_num_i)
for i, f_num_i in enumerate(f_num)))
stiff_t = sum(
op.weak_local_d_dx(dcoll, i, f_num_i)
for i, f_num_i in enumerate(f_num))
kterm = op.mass(dcoll, dq, kappa * f_quad_num.dot(normal))
flux = op.face_mass(dcoll, face_f.dot(face_normal))
# sum everything up
op_global = op.nodal_sum(dcoll, dd, stiff - (stiff_t + kterm))
op_local = op.elementwise_sum(dcoll, dd,
stiff - (stiff_t + kterm + flux))
err_global = abs(op_global)
err_local = op.norm(dcoll, op_local, np.inf)
logger.info("errors: global %.5e local %.5e", err_global, err_local)
# compute max element size
from grudge.dt_utils import h_max_from_volume
h_max = h_max_from_volume(dcoll)
eoc_global.add_data_point(h_max, actx.to_numpy(err_global))
eoc_local.add_data_point(h_max, err_local)
if visualize:
from grudge.shortcuts import make_visualizer
vis = make_visualizer(dcoll)
filename = f"surface_divergence_theorem_{mesh_name}_{i:04d}.vtu"
vis.write_vtk_file(filename, [("r", actx.np.log10(op_local))],
overwrite=True)
# }}}
order = min(builder.order, builder.mesh_order) - 0.5
logger.info("\n%s", str(eoc_global))
logger.info("\n%s", str(eoc_local))
assert eoc_global.max_error() < 1.0e-12 \
or eoc_global.order_estimate() > order - 0.5
assert eoc_local.max_error() < 1.0e-12 \
or eoc_local.order_estimate() > order - 0.5
