General concepts » Polytopes

Introduction

In finite element analysis, a polytope is a geometric primitive that forms the building block of a mesh. A mesh is a collection of polytopes of various dimensions that together partition a domain .

In Rodin, polytopes are represented by the Polytope class and its associated Polytope::Type enumeration.

Polytope Dimensions

Polytopes exist in different dimensions, each with a specific role in the mesh:

The cells are the highest-dimensional polytopes in a mesh and correspond to the elements over which the finite element approximation is constructed. In a 2D mesh, the cells are faces (triangles or quadrilaterals); in 3D, the cells are volumes.

Available Polytope Types

The Polytope::Type enumeration defines the available element types:

Simplicial vs. tensor-product elements:**

• Simplicial elements (triangle, tetrahedron) are the simplest shapes in their dimension. They are flexible for meshing complex geometries because any domain can be triangulated.
• Tensor-product elements (quadrilateral, hexahedron) are formed as Cartesian products of lower-dimensional elements. They often provide higher accuracy per DOF on structured domains but are harder to fit to complex geometries.
• The wedge (triangular prism) is a hybrid: a tensor product of a triangle and a segment.

Reference Elements

All local computations in the finite element method (basis function evaluation, quadrature, gradient computation) are performed on a reference element** , then mapped to each physical cell via a geometric transformation . The reference element vertices for the standard types are:

The Jacobian of and its determinant are available at any quadrature point through the Point class:

// At a quadrature point p on element K:
auto J = p.getJacobian();              // d×d Jacobian matrix
auto detJ = p.getJacobianDeterminant();  // |J|

Using Polytopes for Mesh Generation

The polytope type determines the element shapes when generating uniform meshes via Mesh::UniformGrid():

#include <Rodin/Geometry.h>
using namespace Rodin::Geometry;

Mesh mesh;

// 2D meshes
mesh = mesh.UniformGrid(Polytope::Type::Triangle, {16, 16});
mesh = mesh.UniformGrid(Polytope::Type::Quadrilateral, {16, 16});

// 3D meshes
mesh = mesh.UniformGrid(Polytope::Type::Tetrahedron, {8, 8, 8});
mesh = mesh.UniformGrid(Polytope::Type::Hexahedron, {8, 8, 8});
mesh = mesh.UniformGrid(Polytope::Type::Wedge, {8, 8, 8});

Sub-Entities

Every polytope has sub-entities of lower dimension. For example, a triangle has 3 edges and 3 vertices; a tetrahedron has 4 faces, 6 edges, and 4 vertices. These relationships are captured by the Connectivity class.

To access sub-entity relationships, first compute the connectivity:

mesh.getConnectivity().compute(1, 2); // edges → cells
mesh.getConnectivity().compute(0, 2); // vertices → cells

Iterating Over Polytopes

You can iterate over polytopes of a given dimension using the mesh iterator interface:

// Iterate over cells (highest dimension)
for (auto it = mesh.getCell(); !it.end(); ++it)
{
  auto idx = it->getIndex();
  auto attr = it->getAttribute();
  // ... process cell ...
}

// Iterate over vertices
for (auto it = mesh.getVertex(); !it.end(); ++it)
{
  auto coords = it->getCoordinates();
  // ... process vertex ...
}

Choosing the Right Element Type

See Also

• Meshes — Working with meshes
• Connectivity — Relationships between polytopes
• Ciarlet's definition — The reference element
• Polytope class reference