def test_deprecated_nodal_face_mass_matrix(dims, order=3):
# FIXME DEPRECATED remove along with nodal_face_mass_matrix (>=2022)
vol_shape = mp.Simplex(dims)
vol_space = mp.space_for_shape(vol_shape, order)
vertices = mp.unit_vertices_for_shape(vol_shape)
volume_nodes = mp.edge_clustered_nodes_for_space(vol_space, vol_shape)
volume_basis = mp.basis_for_space(vol_space, vol_shape)
from modepy.matrices import nodal_face_mass_matrix
for face in mp.faces_for_shape(vol_shape):
face_space = mp.space_for_shape(face, order)
face_nodes = mp.edge_clustered_nodes_for_space(face_space, face)
face_vertices = vertices[:, face.volume_vertex_indices]
fmm = nodal_face_mass_matrix(
volume_basis.functions, volume_nodes,
face_nodes, order, face_vertices)
fmm2 = nodal_face_mass_matrix(
volume_basis.functions,
volume_nodes, face_nodes, order+1, face_vertices)
error = la.norm(fmm - fmm2, np.inf) / la.norm(fmm2, np.inf)
logger.info("fmm error: %.5e", error)
assert error < 5e-11, f"error {error:.5e} on face {face.face_index}"
fmm[np.abs(fmm) < 1e-13] = 0
nnz = np.sum(fmm > 0)
logger.info("fmm: nnz %d\n%s", nnz, fmm)
logger.info("mass matrix:\n%s", mp.mass_matrix(
mp.basis_for_space(face_space, face).functions,
mp.edge_clustered_nodes_for_space(face_space, face)))
def test_deprecated_modal_face_mass_matrix(dims, order=3):
# FIXME DEPRECATED remove along with modal_face_mass_matrix (>=2022)
shape = mp.Simplex(dims)
space = mp.space_for_shape(shape, order)
vertices = mp.unit_vertices_for_shape(shape)
basis = mp.basis_for_space(space, shape)
from modepy.matrices import modal_face_mass_matrix
for face in mp.faces_for_shape(shape):
face_vertices = vertices[:, face.volume_vertex_indices]
fmm = modal_face_mass_matrix(
basis.functions, order, face_vertices)
fmm2 = modal_face_mass_matrix(
basis.functions, order+1, face_vertices)
error = la.norm(fmm - fmm2, np.inf) / la.norm(fmm2, np.inf)
logger.info("fmm error: %.5e", error)
assert error < 1e-11, f"error {error:.5e} on face {face.face_index}"
fmm[np.abs(fmm) < 1e-13] = 0
nnz = np.sum(fmm > 0)
logger.info("fmm: nnz %d\n%s", nnz, fmm)
def tesselate_simplex(dim):
import modepy as mp
shape = mp.Simplex(dim)
space = mp.space_for_shape(shape, 2)
node_tuples = mp.node_tuples_for_space(space)
return node_tuples, mp.submesh_for_shape(shape, node_tuples)
def test_modal_coefficients_by_projection(actx_factory, quad_group_factory):
group_cls = SimplexElementGroup
modal_group_factory = ModalSimplexGroupFactory
actx = actx_factory()
order = 10
m_order = 5
# 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=group_cls)
# Make discretizations
nodal_disc = Discretization(actx, mesh, quad_group_factory(order))
modal_disc = Discretization(actx, mesh, modal_group_factory(m_order))
# Make connections one using quadrature projection
nodal_to_modal_conn_quad = NodalToModalDiscretizationConnection(
nodal_disc, modal_disc, allow_approximate_quad=True)
def f(x):
return 2 * actx.np.sin(5 * x)
x_nodal = thaw(nodal_disc.nodes()[0], actx)
nodal_f = f(x_nodal)
# Compute modal coefficients we expect to get
import modepy as mp
grp, = nodal_disc.groups
shape = mp.Simplex(grp.dim)
space = mp.space_for_shape(shape, order=m_order)
basis = mp.orthonormal_basis_for_space(space, shape)
quad = grp.quadrature_rule()
nodal_f_data = actx.to_numpy(nodal_f[0])
vdm = mp.vandermonde(basis.functions, quad.nodes)
w_diag = np.diag(quad.weights)
modal_data = []
for _, nodal_data in enumerate(nodal_f_data):
# Compute modal data in each element: V.T * W * nodal_data
elem_modal_f = np.dot(vdm.T, np.dot(w_diag, nodal_data))
modal_data.append(elem_modal_f)
modal_data = actx.from_numpy(np.asarray(modal_data))
modal_f_expected = DOFArray(actx, data=(modal_data, ))
# Map nodal coefficients using the quadrature-based projection
modal_f_computed = nodal_to_modal_conn_quad(nodal_f)
err = flat_norm(modal_f_expected - modal_f_computed)
assert err <= 1e-13
def estimate_resid(inner_n):
nodes = mp.warp_and_blend_nodes(dims, inner_n)
basis = mp.orthonormal_basis_for_space(
mp.PN(dims, inner_n), mp.Simplex(dims))
vdm = mp.vandermonde(basis.functions, nodes)
f = test_func(nodes[0])
coeffs = la.solve(vdm, f)
from modepy.modal_decay import estimate_relative_expansion_residual
return estimate_relative_expansion_residual(
coeffs.reshape(1, -1), dims, inner_n)
def get_simplex_element_flip_matrix(order, unit_nodes, permutation=None):
"""
Generate a resampling matrix that corresponds to a
permutation of the barycentric coordinates being applied.
The default permutation is to swap the
first two barycentric coordinates.
:param order: The order of the function space on the simplex,
(see second argument in
:fun:`modepy.simplex_best_available_basis`)
:param unit_nodes: A np array of unit nodes with shape
*(dim, nunit_nodes)*
:param permutation: Either *None*, or a tuple of shape
storing a permutation:
the *i*th barycentric coordinate gets mapped to
the *permutation[i]*th coordinate.
:return: A numpy array of shape *(nunit_nodes, nunit_nodes)*
which, when its transpose is right-applied
to the matrix of nodes (shaped *(dim, nunit_nodes)*),
corresponds to the permutation being applied
"""
from modepy.tools import barycentric_to_unit, unit_to_barycentric
bary_unit_nodes = unit_to_barycentric(unit_nodes)
flipped_bary_unit_nodes = bary_unit_nodes.copy()
if permutation is None:
flipped_bary_unit_nodes[0, :] = bary_unit_nodes[1, :]
flipped_bary_unit_nodes[1, :] = bary_unit_nodes[0, :]
else:
flipped_bary_unit_nodes[permutation, :] = bary_unit_nodes
flipped_unit_nodes = barycentric_to_unit(flipped_bary_unit_nodes)
dim = unit_nodes.shape[0]
shape = mp.Simplex(dim)
space = mp.PN(dim, order)
basis = mp.basis_for_space(space, shape)
flip_matrix = mp.resampling_matrix(basis.functions, flipped_unit_nodes,
unit_nodes)
flip_matrix[np.abs(flip_matrix) < 1e-15] = 0
# Flipping twice should be the identity
if permutation is None:
assert la.norm(
np.dot(flip_matrix, flip_matrix) -
np.eye(len(flip_matrix))) < 1e-13
return flip_matrix
def test_modal_coeffs_by_projection(dim):
shape = mp.Simplex(dim)
space = mp.space_for_shape(shape, order=5)
basis = mp.orthonormal_basis_for_space(space, shape)
quad = mp.XiaoGimbutasSimplexQuadrature(10, dim)
assert quad.exact_to >= 2 * space.order
modal_coeffs = np.random.randn(space.space_dim)
vdm = mp.vandermonde(basis.functions, quad.nodes)
evaluated = vdm @ modal_coeffs
modal_coeffs_2 = vdm.T @ (evaluated * quad.weights)
diff = modal_coeffs - modal_coeffs_2
assert la.norm(diff, 2) < 3e-13
def test_diff_matrix_permutation(dims):
order = 5
space = mp.PN(dims, order)
from pytools import \
generate_nonnegative_integer_tuples_summing_to_at_most as gnitstam
node_tuples = list(gnitstam(order, dims))
simplex_onb = mp.orthonormal_basis_for_space(space, mp.Simplex(dims))
nodes = np.array(mp.warp_and_blend_nodes(dims, order, node_tuples=node_tuples))
diff_matrices = mp.differentiation_matrices(
simplex_onb.functions, simplex_onb.gradients, nodes)
for iref_axis in range(dims):
perm = mp.diff_matrix_permutation(node_tuples, iref_axis)
assert la.norm(
diff_matrices[iref_axis]
- diff_matrices[0][perm][:, perm]) < 1e-10
def test_modal_decay(case_name, test_func, dims, n, expected_expn):
space = mp.PN(dims, n)
nodes = mp.warp_and_blend_nodes(dims, n)
basis = mp.orthonormal_basis_for_space(space, mp.Simplex(dims))
vdm = mp.vandermonde(basis.functions, nodes)
f = test_func(nodes[0])
coeffs = la.solve(vdm, f)
if 0:
from modepy.tools import plot_element_values
plot_element_values(n, nodes, f, resample_n=70,
show_nodes=True)
from modepy.modal_decay import fit_modal_decay
expn, _ = fit_modal_decay(coeffs.reshape(1, -1), dims, n)
expn = expn[0]
print(f"{case_name}: computed: {expn:g}, expected: {expected_expn:g}")
assert abs(expn-expected_expn) < 0.1
def get_local_face_mass_matrix(self, afgrp, volgrp, dtype):
nfaces = volgrp.mesh_el_group.nfaces
assert afgrp.nelements == nfaces * volgrp.nelements
matrix = np.empty((volgrp.nunit_dofs, nfaces, afgrp.nunit_dofs),
dtype=dtype)
import modepy as mp
shape = mp.Simplex(volgrp.dim)
unit_vertices = mp.unit_vertices_for_shape(shape).T
for face in mp.faces_for_shape(shape):
face_vertices = unit_vertices[np.array(
face.volume_vertex_indices)].T
matrix[:, face.face_index, :] = mp.nodal_face_mass_matrix(
volgrp.basis_obj().functions, volgrp.unit_nodes,
afgrp.unit_nodes, volgrp.order, face_vertices)
actx = self._setup_actx
return actx.freeze(actx.from_numpy(matrix))
assert abs(result - true_result) < ebound
@pytest.mark.parametrize(
("order", "ebound"),
[
(1, 2e-15),
(2, 5e-15),
(3, 1e-14),
# (4, 3e-14),
# (7, 3e-14),
# (9, 2e-13),
])
@pytest.mark.parametrize("shape", [
mp.Simplex(2),
mp.Simplex(3),
mp.Hypercube(2),
mp.Hypercube(3),
])
def test_orthogonality(shape, order, ebound):
"""Test orthogonality of ONBs using cubature."""
qspace = mp.space_for_shape(shape, 2 * order)
cub = mp.quadrature_for_space(qspace, shape)
basis = mp.orthonormal_basis_for_space(mp.space_for_shape(shape, order),
shape)
maxerr = 0
for i, f in enumerate(basis.functions):
for j, g in enumerate(basis.functions):
def make_group_from_vertices(vertices,
vertex_indices,
order,
group_cls=None,
unit_nodes=None):
# shape: (ambient_dim, nelements, nvertices)
ambient_dim = vertices.shape[0]
el_vertices = vertices[:, vertex_indices]
from meshmode.mesh import SimplexElementGroup, TensorProductElementGroup
if group_cls is None:
group_cls = SimplexElementGroup
if issubclass(group_cls, SimplexElementGroup):
if order < 1:
raise ValueError("can't represent simplices with mesh order < 1")
el_origins = el_vertices[:, :, 0][:, :, np.newaxis]
# ambient_dim, nelements, nspan_vectors
spanning_vectors = (el_vertices[:, :, 1:] - el_origins)
nspan_vectors = spanning_vectors.shape[-1]
dim = nspan_vectors
# dim, nunit_nodes
if unit_nodes is None:
shape = mp.Simplex(dim)
space = mp.space_for_shape(shape, order)
unit_nodes = mp.edge_clustered_nodes_for_space(space, shape)
unit_nodes_01 = 0.5 + 0.5 * unit_nodes
nodes = np.einsum("si,des->dei", unit_nodes_01,
spanning_vectors) + el_origins
elif issubclass(group_cls, TensorProductElementGroup):
nelements, nvertices = vertex_indices.shape
dim = nvertices.bit_length() - 1
if nvertices != 2**dim:
raise ValueError("invalid number of vertices for tensor-product "
"elements, must be power of two")
shape = mp.Hypercube(dim)
space = mp.space_for_shape(shape, order)
if unit_nodes is None:
unit_nodes = mp.edge_clustered_nodes_for_space(space, shape)
# shape: (dim, nnodes)
unit_nodes_01 = 0.5 + 0.5 * unit_nodes
_, nnodes = unit_nodes.shape
vertex_tuples = mp.node_tuples_for_space(type(space)(dim, 1))
assert len(vertex_tuples) == nvertices
vdm = np.empty((nvertices, nvertices))
for i, vertex_tuple in enumerate(vertex_tuples):
for j, func_tuple in enumerate(vertex_tuples):
vertex_ref = np.array(vertex_tuple, dtype=np.float64)
vdm[i, j] = np.prod(vertex_ref**func_tuple)
# shape: (ambient_dim, nelements, nvertices)
coeffs = np.empty((ambient_dim, nelements, nvertices))
for d in range(ambient_dim):
coeffs[d] = la.solve(vdm, el_vertices[d].T).T
vdm_nodes = np.zeros((nnodes, nvertices))
for j, func_tuple in enumerate(vertex_tuples):
vdm_nodes[:,
j] = np.prod(unit_nodes_01**np.array(func_tuple).reshape(
-1, 1),
axis=0)
nodes = np.einsum("ij,dej->dei", vdm_nodes, coeffs)
else:
raise ValueError(f"unsupported value for 'group_cls': {group_cls}")
# make contiguous
nodes = nodes.copy()
return group_cls(order, vertex_indices, nodes, unit_nodes=unit_nodes)
def get_mesh(self):
el_type_hist = {}
for el_type in self.element_types:
el_type_hist[el_type] = el_type_hist.get(el_type, 0) + 1
if not el_type_hist:
raise RuntimeError("empty mesh in gmsh input")
groups = self.groups = []
ambient_dim = self.points.shape[-1]
mesh_bulk_dim = max(el_type.dimensions for el_type in el_type_hist)
# {{{ build vertex numbering
# map set of face vertex indices to list of tags associated to face
face_vertex_indices_to_tags = {}
vertex_gmsh_index_to_mine = {}
for element, el_vertices in enumerate(self.element_vertices):
for gmsh_vertex_nr in el_vertices:
if gmsh_vertex_nr not in vertex_gmsh_index_to_mine:
vertex_gmsh_index_to_mine[gmsh_vertex_nr] = \
len(vertex_gmsh_index_to_mine)
if self.tags:
el_tag_indexes = [self.gmsh_tag_index_to_mine[t] for t in
self.element_markers[element]]
# record tags of boundary dimension
el_tags = [self.tags[i][0] for i in el_tag_indexes if
self.tags[i][1] == mesh_bulk_dim - 1]
el_grp_verts = {vertex_gmsh_index_to_mine[e] for e in el_vertices}
face_vertex_indices = frozenset(el_grp_verts)
if face_vertex_indices not in face_vertex_indices_to_tags:
face_vertex_indices_to_tags[face_vertex_indices] = []
face_vertex_indices_to_tags[face_vertex_indices] += el_tags
# }}}
# {{{ build vertex array
gmsh_vertex_indices, my_vertex_indices = \
list(zip(*vertex_gmsh_index_to_mine.items()))
vertices = np.empty(
(ambient_dim, len(vertex_gmsh_index_to_mine)), dtype=np.float64)
vertices[:, np.array(my_vertex_indices, np.intp)] = \
self.points[np.array(gmsh_vertex_indices, np.intp)].T
# }}}
from meshmode.mesh import (Mesh,
SimplexElementGroup, TensorProductElementGroup)
bulk_el_types = set()
for group_el_type, ngroup_elements in el_type_hist.items():
if group_el_type.dimensions != mesh_bulk_dim:
continue
bulk_el_types.add(group_el_type)
nodes = np.empty(
(ambient_dim, ngroup_elements, group_el_type.node_count()),
np.float64)
el_vertex_count = group_el_type.vertex_count()
vertex_indices = np.empty(
(ngroup_elements, el_vertex_count),
np.int32)
i = 0
for el_vertices, el_nodes, el_type in zip(
self.element_vertices, self.element_nodes, self.element_types):
if el_type is not group_el_type:
continue
nodes[:, i] = self.points[el_nodes].T
vertex_indices[i] = [
vertex_gmsh_index_to_mine[v_nr] for v_nr in el_vertices
]
i += 1
import modepy as mp
if isinstance(group_el_type, GmshSimplexElementBase):
shape = mp.Simplex(group_el_type.dimensions)
elif isinstance(group_el_type, GmshTensorProductElementBase):
shape = mp.Hypercube(group_el_type.dimensions)
else:
raise NotImplementedError(
f"gmsh element type: {type(group_el_type).__name__}")
space = mp.space_for_shape(shape, group_el_type.order)
unit_nodes = mp.equispaced_nodes_for_space(space, shape)
if isinstance(group_el_type, GmshSimplexElementBase):
group = SimplexElementGroup(
group_el_type.order,
vertex_indices,
nodes,
unit_nodes=unit_nodes
)
if group.dim == 2:
from meshmode.mesh.processing import flip_simplex_element_group
group = flip_simplex_element_group(vertices, group,
np.ones(ngroup_elements, bool))
elif isinstance(group_el_type, GmshTensorProductElementBase):
vertex_shuffle = type(group_el_type)(
order=1).get_lexicographic_gmsh_node_indices()
group = TensorProductElementGroup(
group_el_type.order,
vertex_indices[:, vertex_shuffle],
nodes,
unit_nodes=unit_nodes
)
else:
# NOTE: already checked above
raise AssertionError()
groups.append(group)
# FIXME: This is heuristic.
if len(bulk_el_types) == 1:
is_conforming = True
else:
is_conforming = mesh_bulk_dim < 3
# construct boundary tags for mesh
from meshmode.mesh import BTAG_ALL, BTAG_REALLY_ALL
boundary_tags = [BTAG_ALL, BTAG_REALLY_ALL]
if self.tags:
boundary_tags += [tag for tag, dim in self.tags if
dim == mesh_bulk_dim-1]
# compute facial adjacency for Mesh if there is tag information
facial_adjacency_groups = None
if is_conforming and self.tags:
from meshmode.mesh import _compute_facial_adjacency_from_vertices
facial_adjacency_groups = _compute_facial_adjacency_from_vertices(
groups, boundary_tags, np.int32, np.int8,
face_vertex_indices_to_tags)
return Mesh(
vertices, groups,
is_conforming=is_conforming,
facial_adjacency_groups=facial_adjacency_groups,
boundary_tags=boundary_tags,
**self.mesh_construction_kwargs)
def shape(self):
return mp.Simplex(self.dim)
