Shapes¶
modepy.shapes
provides a generic description of the supported shapes
(i.e. reference elements).
 class modepy.Face(volume_shape: Shape, face_index: int, volume_vertex_indices: tuple[int, ...], map_to_volume: Callable[[ndarray], ndarray])[source]¶
Mixin to be used with a concrete
Shape
subclass to represent geometry information about a face of a shape. face_index: int¶
The face index in
volume_shape
of this face.
 volume_vertex_indices: tuple[int, ...]¶
A tuple of indices into the vertices returned by
unit_vertices_for_shape()
for thevolume_shape
.
 modepy.unit_vertices_for_shape(shape: Shape) ndarray [source]¶
 modepy.unit_vertices_for_shape(shape: TensorProductShape)
 modepy.unit_vertices_for_shape(shape: Simplex)
 Returns:
an
ndarray
of shape (dim, nvertices).
 modepy.faces_for_shape(shape: Shape) tuple[Face, ...] [source]¶
 modepy.faces_for_shape(shape: Simplex)
 modepy.faces_for_shape(shape: Hypercube)
 Returns:
a tuple of
Face
s representing the faces of shape.
Tensor Product Shapes¶
Simplices¶
 class modepy.Simplex(dim: int)[source]¶
Bases:
Shape
An ndimensional simplex (lines, triangle, tetrahedron, etc.).
Coordinates on the triangle¶
Biunit coordinates \((r, s)\) (also called ‘unit’ coordinates):
^ s

C
\
 \
 O
 \
 \
AB> r
Vertices in biunit coordinates:
O = ( 0, 0)
A = (1, 1)
B = ( 1, 1)
C = (1, 1)
Equilateral coordinates \((x, y)\):
C
/ \
/ \
/ \
/ O \
/ \
AB
Vertices in equilateral coordinates:
O = ( 0, 0)
A = (1, 1/sqrt(3))
B = ( 1, 1/sqrt(3))
C = ( 0, 2/sqrt(3))
Coordinates on the tetrahedron¶
Biunit coordinates \((r, s, t)\) (also called ‘unit’ coordinates):
^ s

C
/\
/  \
/  \
/  \
/ O \
/ __AB> r
/_^ ___^^
,D^^^
t L
(squint, and it might start making sense…)
Vertices in biunit coordinates \((r, s, t)\):
O = ( 0, 0, 0)
A = (1, 1, 1)
B = ( 1, 1, 1)
C = (1, 1, 1)
D = (1, 1, 1)
Vertices in equilateral coordinates \((x, y, z)\):
O = ( 0, 0, 0)
A = (1, 1/sqrt(3), 1/sqrt(6))
B = ( 1, 1/sqrt(3), 1/sqrt(6))
C = ( 0, 2/sqrt(3), 1/sqrt(6))
D = ( 0, 0, 3/sqrt(6))
Hypercubes¶
 class modepy.Hypercube(dim: int)[source]¶
Bases:
TensorProductShape
An ndimensional hypercube (line, square, hexahedron, etc.).
Coordinates on the square¶
Biunit coordinates on \((r, s)\) (also called ‘unit’ coordinates):
^ s

CD
 
 
 O 
 
 
AB > r
Vertices in biunit coordinates:
O = ( 0, 0)
A = (1, 1)
B = ( 1, 1)
C = (1, 1)
D = ( 1, 1)
Coordinates on the cube¶
Biunit coordinates on \((r, s, t)\) (also called ‘unit’ coordinates):
t
^

EG
\ \
 \  \
 \  \
 F+H
  O  
A+C> s
\  \ 
\  \ 
\ \
BD
\
v r
Vertices in biunit coordinates:
O = ( 0, 0, 0)
A = (1, 1, 1)
B = ( 1, 1, 1)
C = (1, 1, 1)
D = ( 1, 1, 1)
E = (1, 1, 1)
F = ( 1, 1, 1)
G = (1, 1, 1)
H = ( 1, 1, 1)
The order of the vertices in the hypercubes follows binary counting
in tsr
(i.e. in reverse axis order).
For example, in 3D, A, B, C, D, ...
is 000, 001, 010, 011, ...
.
Submeshes¶
 modepy.submesh_for_shape(shape: Shape, node_tuples: Sequence[tuple[int, ...]]) Sequence[tuple[int, ...]] [source]¶
 modepy.submesh_for_shape(shape: Simplex, node_tuples)
 modepy.submesh_for_shape(shape: TensorProductShape, node_tuples)
Return a list of tuples of indices into the node list that generate a tessellation of the reference element.
 Parameters:
node_tuples –
A list of tuples (i, j, …) of integers indicating node positions inside the unit element. The returned list references indices in this list.
modepy.node_tuples_for_space()
may be used to generate node_tuples.
Added in version 2020.3.