Rodin namespace

The Rodin library for finite element methods and shape optimization.

Rodin is a lightweight and modular C++20 finite element framework providing tools for solving partial differential equations and performing shape and topology optimization. Key modules include:

Geometry — Meshes, polytopes, and connectivity
Variational — Finite element spaces, trial/test functions, and variational problem formulation
IO — Input/output in MFEM, MEDIT, HDF5, and XDMF formats
Solver — Linear and iterative solvers (CG, GMRES, SparseLU)
Assembly — Assembly of stiffness matrices and load vectors

Namespaces

namespace Adaptation: Mesh adaptation and deformation operations.
namespace FormLanguage: Typed expressions for constructing variational forms.
namespace Advection: Transport and advection of fields.
namespace Alert: Contextual exceptions and diagnostic reporting.
namespace Assembly: Global assembly of discrete operators.
namespace Context: Execution contexts for local and distributed computation.
namespace Distance: Distance-field computations.
namespace Eikonal: Eikonal equations and distance propagation.
namespace Geometry: Meshes, geometric transformations, and mapped evaluation.
namespace Heart: Cardiac models and their coupled state evolution.
namespace Hilbert: Hilbert-space formulations and regularization.
namespace IO: Reading and writing meshes, fields, and associated data.
namespace Location: Spatial indexing and geometric search.
namespace Math: Spatial arithmetic, matrix operations, and sparse linear algebra.
namespace MMG: Mesh adaptation through the MMG integration.
namespace MPI: Distributed meshes, finite element spaces, and search operations.
namespace Variational: Finite element spaces, fields, and variational problems.
namespace PETSc: PETSc integration module for Rodin.
namespace Solver: Solution of linear and nonlinear discrete systems.
namespace QF: Module for defining quadrature formulae over reference polytopes.
namespace Scotch: Graph partitioning through the Scotch integration.
namespace Solid: Constitutive laws, kinematics, and solid-mechanics integration.
namespace Test: Helpers for constructing numerical tests.
namespace Utility: Type utilities and generic programming helpers.
namespace Tests: Tests of the Rodin library

Classes

struct IndexArrayCompare

Functor for lexicographically ordering index arrays.

struct IndexArrayEquality

Functor for comparing two index arrays for equality.

template<class From, class To> class Cast

Template class for type casting operations.

class Copyable

Abstract base class for objects that can be copied.

struct IndexSetEquality

Functor for comparing two IndexSet objects for equality.

struct IndexSetHash

Functor for computing a hash value for an IndexSet.

template<class L, class R> class Pair

Forward declaration of the Pair template class.

template<class ... Ts> class Tuple

Forward declaration of the Tuple template class.

See specializations

Specialization	Description
Full specialization template <> class Tuple< >;	Specialization of Tuple for an empty parameter pack.
`T, Ts...` Full specialization template < class T, class ... Ts> class Tuple< T, Ts...>;	A tuple class that extends std::tuple with additional functionality.

struct DefaultSentinelT

Sentinel type for default-constructed iterators.

class Identifiable

Abstract base class for objects that can be copied.

class Moveable

Abstract base class for objects that can be moved.

Typedefs

template<class ScalarType> using Array = Eigen::ArrayX<ScalarType>: Alias for a dynamically sized array.
using IndexArray = Array<Index>: Alias for an index array.
using Integer = int: Standard type for representing integer values.
using Boolean = bool: Standard type for representing boolean values.
using Float = float: Standard type for representing (32 bit) floating-point values.
using Double = double: Standard type for representing double precision (64 bit) floating-point values.
using Index = std::size_t: Standard type for representing indices.
using Real = Double: Standard type for representing scalar values.
using Complex = std::complex<Real>: Standard type for representing complex values.
template<class T> using List = boost::container::list<T>: Standard type for representing lists.
template<class T> using Deque = boost::container::deque<T>: Standard type for representing deques.

Functions

template<class L, class R> Pair(L lhs, R rhs) -> Pair< L, R >: Deduction guide for the Pair class.
Tuple() -> Tuple<>: Deduction guide for the empty tuple.
template<class... Params> Tuple(Params... params) -> Tuple< Params... >: Deduction guide for a tuple from its constructor arguments.
template<Index First, Index Last> static auto IndexTuple() -> auto constexpr: Generates a tuple of indices.
auto operator""_UZ(unsigned long long x) -> std::size_t constexpr: User-defined literal for size_t values.