Classes

• namespace Rodin The Rodin library for finite element methods and shape optimization.
  • namespace Adaptation Namespace Rodin::Tests::Benchmarks.
    • class AnalyticMatrixFunction final Matrix-valued FunctionBase adapter built from a single callable of signature (const Geometry::Point&) -> Math::SpatialMatrix<Real>.
    • class AnalyticVectorFunction final Vector-valued FunctionBase adapter built from a single callable of signature (const Geometry::Point&) -> Math::SpatialVector<Real>.
    • struct CellGeomCache Per-cell geometry cache for the 2D triangular affine prototype.
    • class WNGIR Backend-independent WNGIR mesh-fitting solver.
  • namespace Advection Namespace Rodin::Advection.
    • class Lagrangian Lagrangian variational advection for scalar fields.
    • class Lagrangian<Variational::TrialFunction<Variational::GridFunction<FES, Data>, FES>, Variational::TestFunction<FES>, Initial, VectorField, Step> Lagrangian advection specialization for trial/test function formulation.
    • class StopInsideBoundaryPolicy Boundary policy for characteristic tracing: stop-at-boundary with inward offset.
    • class TaylorBoundaryShiftPolicy First-order boundary-hit handler for semi-Lagrangian tracing with an inward shift.
  • namespace Alert Namespace Rodin::Alert.
    • namespace Identifier Namespace containing factory functions for code identifiers.
    • struct BlueT Tag type for blue terminal color.
    • struct BoldT Empty tag type for bold text formatting.
    • struct BrightGrayT Tag type for bright gray terminal color.
    • struct BrightWhiteT Tag type for bright white terminal color.
    • class ClassException Exception class that automatically includes the class name.
    • class Color Type-safe wrapper for custom RGB colors.
    • struct CyanT Tag type for cyan terminal color.
    • class Exception Exception class with formatted output capabilities.
    • class ExceptionPrefix Prefix class for exception messages.
    • struct GrayT Tag type for gray terminal color.
    • struct GreenT Tag type for green terminal color.
    • class IdentifierT Templated text class for code identifiers with bold formatting.
    • class Info Informational message class with formatted output.
    • class InfoPrefix Prefix class for informational messages.
    • struct MagentaT Tag type for magenta terminal color.
    • class MemberFunctionException Exception type for errors occurring in member functions.
    • class MemberFunctionWarning Warning type for issues occurring in member functions.
    • class Message Forward declaration of the Message template class.
    • class MessagePrefix Base class for message prefixes with colored text.
    • class NamespacedException Exception class that automatically includes the namespace name.
    • struct NewLineT Empty tag type for inserting newline characters.
    • struct NoColorT Tag type representing no color (transparent/default).
    • class Notation Specialized text class for mathematical and technical notation.
    • class PrefixedMessage Convenience message for custom Alert prefixes.
    • struct RaiseT Empty tag type for raising an Alert message.
    • struct RedT Tag type for red terminal color.
    • struct ResetT Empty tag type for resetting terminal formatting.
    • struct RGB RGB color template with compile-time color values.
    • struct StylizeT Empty tag type for enabling terminal color output.
    • class Success Success message class with formatted output.
    • class SuccessPrefix Prefix class for success messages.
    • class Text Templated text class with foreground and background color support.
    • class Warning Warning message class with formatted output.
    • class WarningPrefix Prefix class for warning messages.
    • struct WhiteT Tag type for white terminal color.
    • struct YellowT Tag type for yellow terminal color.
  • namespace Assembly Namespace Rodin::Assembly.
    • class AssemblyBase Base class template for assembly operations.
    • class AssemblyBase<IndexMap<Scalar>, Variational::DirichletBC<Variational::TrialFunction<Solution, FES>, Variational::FunctionBase<ValueDerived>>> Base class for value Dirichlet boundary condition assembly.
    • class AssemblyBase<IndexMap<std::pair<IndexArray, Math::Vector<Scalar>>>, Variational::DirichletBC<Variational::TrialFunction<Sol1, FES1>, Variational::ShapeFunctionBase<Derived2, FES2, Sp>>> AssemblyBase specialization for the identification Dirichlet BC u = A(v).
    • class AssemblyBase<LinearSystem, Variational::Problem<LinearSystem, TrialFunction, TestFunction>> Base class for complete single-field problem assembly.
    • class AssemblyBase<LinearSystem, Variational::Problem<LinearSystem, U1, U2, U3, Us...>> Base class for complete mixed problem assembly.
    • class AssemblyBase<OperatorType, Tuple<Variational::BilinearForm<Solution, TrialFES, TestFES, BlockType>...>> Base class for assembling tuples of bilinear forms.
    • class AssemblyBase<OperatorType, Variational::BilinearForm<Solution, TrialFES, TestFES, OperatorType>> Base class for bilinear form assembly operations.
    • class AssemblyBase<VectorType, Tuple<Variational::LinearForm<FES, BlockType>...>> Base class for assembling tuples of linear forms.
    • class AssemblyBase<VectorType, Variational::LinearForm<FES, VectorType>> Base class for linear form assembly operations.
    • class BilinearFormAssemblyInput Input data for bilinear form assembly.
    • class BilinearFormTupleAssemblyInput Input data for tuple of bilinear forms assembly.
    • class ConstraintMap Read-only expansion map for value and identification constraints.
      • struct Entry One master DOF contribution in an expansion row.
    • class Default Default assembly strategy selector.
    • class Default<Context::Local> Default assembly strategy for local context without OpenMP.
    • class Default<Context::Local, Context::Local> Default assembly strategy for mixed local contexts without OpenMP.
    • class Default<Context::MPI> Selects MPI assembly when only the trial/test context is MPI.
    • class Default<Context::MPI, Context::MPI> Selects MPI assembly when both operand and assembly contexts are MPI.
    • class DirichletBCAssemblyInput Input data for Dirichlet boundary condition assembly.
    • class DirichletBCShapeFunctionAssemblyInput Input data for identification-style Dirichlet BC assembly (u = A(v)).
    • class LinearFormAssemblyInput Input data for linear form assembly.
    • class LinearFormTupleAssemblyInput Input data for tuple of linear forms assembly.
    • class MPI Primary template declaration of the MPI assembly executor.
    • class MPI<IndexMap<Scalar>, Variational::DirichletBC<Variational::TrialFunction<Solution, FES>, Variational::FunctionBase<ValueDerived>>> final MPI assembler for scalar-valued Dirichlet boundary data.
    • class MPI<IndexMap<std::pair<IndexArray, Math::Vector<Scalar>>>, Variational::DirichletBC<Variational::TrialFunction<Sol1, FES1>, Variational::ShapeFunctionBase<Derived2, FES2, Sp>>> final MPI assembler for the identification Dirichlet BC u = A(v).
    • class MPI<Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<Rodin::PETSc::Math::LinearSystem, U, V>> final MPI-parallel assembly of a single-variable PETSc problem.
    • class MPI<Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<Rodin::PETSc::Math::LinearSystem, U1, U2, U3, Us...>> final MPI-parallel assembly of a multi-variable PETSc problem.
    • class MPI<::Mat, Variational::BilinearForm<Solution, TrialFES, TestFES, ::Mat>> final MPI-parallel assembly of a PETSc matrix from a bilinear form.
    • class MPI<::Vec, Variational::LinearForm<FES, ::Vec>> final MPI-parallel assembly of a PETSc vector from a linear form.
    • class MPIIteration Iteration helper over a region of an MPI mesh shard.
    • class OpenMP<::Mat, Variational::BilinearForm<Solution, TrialFES, TestFES, ::Mat>> final OpenMP-parallel assembly of a PETSc matrix from a bilinear form.
    • class OpenMP<::Vec, Variational::LinearForm<FES, ::Vec>> final OpenMP-parallel assembly of a PETSc vector from a linear form.
    • class OpenMP<IndexMap<Scalar>, Variational::DirichletBC<Variational::TrialFunction<Solution, FES>, Variational::FunctionBase<ValueDerived>>> final OpenMP value Dirichlet boundary condition assembly.
    • class OpenMP<IndexMap<std::pair<IndexArray, Math::Vector<Scalar>>>, Variational::DirichletBC<Variational::TrialFunction<Sol1, FES1>, Variational::ShapeFunctionBase<Derived2, FES2, Sp>>> final OpenMP assembler for the identification Dirichlet BC u = A(v).
    • class OpenMP<LinearSystem, Variational::Problem<LinearSystem, TrialFunction, TestFunction>> final OpenMP single-field problem assembly.
    • class OpenMP<LinearSystem, Variational::Problem<LinearSystem, U1, U2, U3, Us...>> final OpenMP mixed problem assembly.
    • class OpenMP<Math::Matrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>, Variational::BilinearForm<Solution, TrialFES, TestFES, Math::Matrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>> final OpenMP bilinear form assembly into a dense matrix.
    • class OpenMP<Math::SparseMatrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>, Variational::BilinearForm<Solution, TrialFES, TestFES, Math::SparseMatrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>> final OpenMP assembly of the Math::SparseMatrix associated to a BilinearFormBase object.
    • class OpenMP<Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>, Variational::LinearForm<FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>>> OpenMP assembly of the Math::Vector associated to a LinearForm object.
    • class OpenMP<Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<Rodin::PETSc::Math::LinearSystem, U, V>> final OpenMP-parallel assembly of a single-variable PETSc problem.
    • class OpenMP<Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<Rodin::PETSc::Math::LinearSystem, U1, U2, U3, Us...>> final OpenMP-parallel assembly of a multi-variable PETSc problem.
    • class OpenMP<std::vector<Eigen::Triplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>, Variational::BilinearForm<Solution, TrialFES, TestFES, std::vector<Eigen::Triplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>>> final OpenMP-based parallel assembly for bilinear forms.
    • class OpenMPIteration<Geometry::Mesh<Context::Local>> OpenMP-based parallel mesh iteration for multi-threaded assembly.
    • class ProblemAssemblyInput<ProblemBody, TrialFunction, TestFunction> Input data for complete problem assembly.
    • class ProblemAssemblyInput<ProblemBody, U1, U2, U3, Us...> Input data for mixed problem assembly with several trial/test functions.
    • class Sequential Sequential (single-threaded) assembly implementation.
    • class Sequential<IndexMap<Scalar>, Variational::DirichletBC<Variational::TrialFunction<Solution, FES>, Variational::FunctionBase<ValueDerived>>> final Sequential value Dirichlet boundary condition assembly.
    • class Sequential<IndexMap<std::pair<IndexArray, Math::Vector<Scalar>>>, Variational::DirichletBC<Variational::TrialFunction<Sol1, FES1>, Variational::ShapeFunctionBase<Derived2, FES2, Sp>>> final Sequential assembler for the identification Dirichlet BC u = A(v).
    • class Sequential<LinearSystem, Variational::Problem<LinearSystem, TrialFunction, TestFunction>> final Sequential single-field problem assembly.
    • class Sequential<LinearSystem, Variational::Problem<LinearSystem, U1, U2, U3, Us...>> final Sequential mixed problem assembly.
    • class Sequential<Math::Matrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>, Variational::BilinearForm<Solution, TrialFES, TestFES, Math::Matrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>> final Sequential assembly of the Math::SparseMatrix associated to a BilinearFormBase object.
    • class Sequential<Math::SparseMatrix<Real>, Tuple<Variational::BilinearForm<Solution, TrialFES, TestFES, Math::SparseMatrix<Real>>...>> final Sequential block bilinear form assembly into a sparse matrix.
    • class Sequential<Math::SparseMatrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>, Variational::BilinearForm<Solution, TrialFES, TestFES, Math::SparseMatrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>> final Sequential assembly of the Math::SparseMatrix associated to a BilinearFormBase object.
    • class Sequential<Math::Vector<Real>, Tuple<Variational::LinearForm<FES, Math::Vector<Real>>...>> final Sequential block linear form assembly into a vector.
    • class Sequential<Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>, Variational::LinearForm<FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>>> final Sequential assembly implementation for linear forms.
    • class Sequential<Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<Rodin::PETSc::Math::LinearSystem, U, V>> final Sequential assembly of a single-variable PETSc problem.
    • class Sequential<Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<Rodin::PETSc::Math::LinearSystem, U1, U2, U3, Us...>> final Sequential assembly of a multi-variable PETSc problem.
    • class Sequential<std::vector<Eigen::Triplet<Real>>, Tuple<Variational::BilinearForm<Solution, TrialFES, TestFES, std::vector<Eigen::Triplet<Real>>>...>> final Sequential block bilinear form assembly into Eigen triplets.
    • class Sequential<std::vector<Eigen::Triplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>, Variational::BilinearForm<Solution, TrialFES, TestFES, std::vector<Eigen::Triplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>>> final Sequential bilinear form assembly into Eigen triplets.
    • class Sequential<::Mat, Variational::BilinearForm<Solution, TrialFES, TestFES, ::Mat>> final Sequential assembly of a PETSc matrix from a bilinear form.
    • class Sequential<::Vec, Variational::LinearForm<FES, ::Vec>> final Sequential assembly of a PETSc vector from a linear form.
    • class SequentialIteration Sequential mesh iteration strategy.
    • class SequentialIteration<Geometry::Mesh<Context::Local>> Sequential mesh iteration for single-threaded assembly.
  • namespace Context Namespace Rodin::Context.
    • class Base Abstract base class for all execution contexts.
    • class Local Represents a single machine context.
    • class MPI MPI context for parallel computing with Message Passing Interface.
  • namespace Distance Namespace Rodin::Distance.
    • class Base Base class for distance function computation models using CRTP.
    • class Eikonal Distance function computation using the Eikonal equation.
    • class Poisson Poisson approximation to the distance function.
    • class Rvachev Rvachev normalization for a level set function.
    • class SignedPoisson Poisson approximation to the signed distance function.
    • class SpaldingTucker Spalding-Tucker normalization for a level set function.
  • namespace Eikonal Namespace Rodin::Eikonal.
    • class FMM Fast marching method for solving the Eikonal equation.
    • class FMM<Variational::GridFunction<Variational::P1<Real, Geometry::Mesh<Context::Local>>, Data>, SpeedFunction> FMM specialization for P1 finite elements on local meshes.
  • namespace Elasticity Namespace Rodin::Elasticity.
  • namespace FormLanguage Namespace Rodin::FormLanguage.
    • class Base Base class for all objects in Rodin's FormLanguage system.
    • struct ColsAtCompileTime Compile-time column count of a type; -1 when unavailable.
    • struct ColsAtCompileTime<T, std::void_t<decltype(std::decay_t<T>::ColsAtCompileTime)>> Compile-time column count for Eigen-like types exposing ColsAtCompileTime.
    • struct Debug Template for debugging form language types.
    • struct Division Type trait for deducing the result type of division.
    • struct Dot Type trait for deducing the result type of dot product.
    • struct IsEigenObject Type trait to check if a type is an Eigen object.
    • struct IsMatrixRange Type trait: whether T has matrix range (a spatial matrix or a multi-column Eigen object).
    • struct IsPlainObject Type trait to identify Eigen plain object types.
    • struct IsPlainObject<Eigen::PlainObjectBase<Derived>> Specialization for Eigen::PlainObjectBase types.
    • struct IsSpatialMatrix Type trait: whether T is a Math::SpatialMatrix.
    • struct IsSpatialMatrix<Math::SpatialMatrix<Scalar>> Type trait specialization for Math::SpatialMatrix.
    • struct IsSpatialVector Type trait: whether T is a Math::SpatialVector.
    • struct IsSpatialVector<Math::SpatialVector<Scalar>> Type trait specialization for Math::SpatialVector.
    • struct IsVectorRange Type trait: whether T has vector range (a spatial vector or a single-column Eigen object).
    • class List Container for polymorphic form language objects.
      • class ConstIterator Forward iterator for const List.
      • class Iterator Forward iterator for non-const List.
    • struct Minus Type trait for deducing the result type of subtraction.
    • struct Mult Type trait for deducing the result type of multiplication.
    • struct RangeKindOf Deduces the RangeKind of a type T.
    • struct Sum Type trait for deducing the result type of addition.
    • struct Traits Type traits for form language objects.
    • struct Traits<Boolean> Traits specialization for Boolean type.
    • struct Traits<Complex> Traits specialization for Complex type.
    • struct Traits<Geometry::Mesh<Context>> Traits specialization for Mesh types.
    • struct Traits<Integer> Traits specialization for Integer type.
    • struct Traits<Math::FixedSizeVector<Number, S>> Type traits for a Math::FixedSizeVector: exposes the scalar type and the compile-time size.
    • struct Traits<Math::LinearSystem<Operator, Vector>> Type traits for a Math::LinearSystem: exposes the operator, vector, and scalar types.
    • struct Traits<Math::Matrix<Number>> Type traits for a dense Math::Matrix: exposes the scalar type.
    • struct Traits<Math::SparseMatrix<Number>> Type traits for a Math::SparseMatrix: exposes the scalar type.
    • struct Traits<Math::SpatialMatrix<Number>> Type traits for a Math::SpatialMatrix: exposes the scalar type.
    • struct Traits<Math::SpatialVector<Number>> Type traits for a Math::SpatialVector: exposes the scalar type.
    • struct Traits<Math::Vector<Number>> Type traits for a dynamic Math::Vector: exposes the scalar type.
    • struct Traits<PETSc::Variational::GridFunction<FES>> Form-language traits specialization for PETSc grid functions.
    • struct Traits<PETSc::Variational::TestFunction<FES>> Form-language traits specialization for PETSc test functions.
    • struct Traits<PETSc::Variational::TrialFunction<Solution, FES>> Form-language traits specialization for PETSc trial functions.
    • struct Traits<Real> Traits specialization for Real type.
    • struct Traits<Rodin::Geometry::PointCloud> Type traits for a Geometry::PointCloud: exposes the scalar type.
    • struct Traits<Solver::BiCGSTAB<LinearSystem>> Form-language traits for BiCGSTAB solvers.
    • struct Traits<Solver::CG<LinearSystem>> Form-language traits for CG solvers.
    • struct Traits<Solver::DGMRES<LinearSystem>> Form-language traits for DGMRES solvers.
    • struct Traits<Solver::GMRES<LinearSystem>> Form-language traits for GMRES solvers.
    • struct Traits<Solver::HouseholderQR<LinearSystem>> Form-language traits for HouseholderQR solvers.
    • struct Traits<Solver::IDRS<LinearSystem>> Form-language traits for IDRS solvers.
    • struct Traits<Solver::IDRSTABL<LinearSystem>> Form-language traits for IDRSTABL solvers.
    • struct Traits<Solver::KSP> Traits specialization for Solver::KSP (Rodin wrapper for PETSc KSP).
    • struct Traits<Solver::LDLT<LinearSystem>> Form-language traits for LDLT solvers.
    • struct Traits<Solver::LeastSquaresCG<LinearSystem>> Form-language traits for LeastSquaresCG solvers.
    • struct Traits<Solver::LinearSolverBase<LinearSystem>> Form-language traits for linear solver bases.
    • struct Traits<Solver::MINRES<LinearSystem>> Form-language traits for MINRES solvers.
    • struct Traits<Solver::PartialPivLU<LinearSystem>> Form-language traits for PartialPivLU solvers.
    • struct Traits<Solver::SimplicialLDLT<LinearSystem>> Form-language traits for SimplicialLDLT solvers.
    • struct Traits<Solver::SimplicialLLT<LinearSystem>> Form-language traits for SimplicialLLT solvers.
    • struct Traits<Solver::SparseLU<LinearSystem>> Form-language traits for SparseLU solvers.
    • struct Traits<Solver::SparseQR<LinearSystem>> Form-language traits for SparseQR solvers.
    • struct Traits<Variational::BilinearForm<Solution, TrialFES, TestFES, Operator>> Traits for bilinear forms.
    • struct Traits<Variational::BilinearFormBase<Operator>> Traits for bilinear form bases.
    • struct Traits<Variational::FunctionBase<Derived>> Form-language traits for variational functions.
    • struct Traits<Variational::GridFunction<FES, Data>> Traits for GridFunction: exposes the space and data types.
    • struct Traits<Variational::GridFunctionBase<Derived, FES, Data>> Traits for GridFunctionBase: exposes the space and data types.
    • struct Traits<Variational::RealFunctionBase<Derived>> Traits for the CRTP base of real-valued functions.
    • struct Traits<Variational::VectorFunctionBase<Scalar, Derived>> Traits for vector-valued function bases.
    • struct Traits<::Mat> Traits specialization for PETSc matrices.
    • struct Traits<::Vec> Traits specialization for PETSc vectors.
    • struct UnaryMinus Type trait for deducing the result type of unary negation.
  • namespace Geometry Namespace Rodin::Geometry.
    • namespace Euclidean Namespace Rodin::Geometry::Euclidean.
      • class Base Base class for Euclidean geometric objects using CRTP.
      • class Circle Circle in 2D Euclidean space.
      • struct has_connect_method Type trait to detect if a type has a connect method.
      • struct has_connect_method<T, OtherGeometry, std::void_t<decltype(std::declval<T>().connect(std::declval<const OtherGeometry&>()))>> Specialization when connect method exists.
      • struct has_distance_method Type trait to detect if a type has a distance method.
      • struct has_distance_method<T, OtherGeometry, std::void_t<decltype(std::declval<T>().distance(std::declval<const OtherGeometry&>()))>> Specialization when distance method exists.
      • struct has_intersect_method Type trait to detect if a type has an intersect method.
      • struct has_intersect_method<T, OtherGeometry, std::void_t<decltype(std::declval<T>().intersect(std::declval<const OtherGeometry&>()))>> Specialization when intersect method exists.
      • class Line2D Infinite line in 2D Euclidean space.
      • class LineSegment2D Line segment in 2D Euclidean space.
      • class Point2D Point in 2D Euclidean space.
      • class Rectangle Axis-aligned rectangle in 2D Euclidean space.
    • class AttributeIndex Attribute indexing for mesh polytopes.
      • struct Slot Storage for attributes of polytopes in a single dimension.
    • class BalancedCompactPartitioner Partitioner that creates balanced, spatially compact partitions.
    • class BoundedIndexGenerator final Index generator for a bounded range of indices.
    • class CCL Mesh data structures, geometric operations, and computational geometry utilities.
    • class Cell Represents a cell (highest-dimensional element) in a mesh.
    • class CellIterator Iterator over mesh cells (highest-dimensional polytopes).
    • class Connectivity Template for connectivity information.
    • class Connectivity<Context::Local> final Mesh connectivity for sequential (local) meshes.
      • struct PolytopeIndex Bidirectional index mapping for polytope identification.
      • struct SubPolytope Represents a sub-polytope (lower-dimensional face).
    • class ConnectivityBase Abstract base class for mesh connectivity.
    • class ContainerIndexGenerator Index generator that wraps a container's iterators.
    • class EmptyIndexGenerator final Index generator that represents an empty sequence.
    • class Face Represents a face (codimension-1 element) in a mesh.
    • class FaceIterator Iterator over mesh faces (codimension-1 polytopes).
    • class GeometryIndexed Template container indexed by polytope geometry types.
    • class GreedyPartitioner Partitioner using a greedy algorithm.
    • class IdentityTransformation final Polytope identity transformation.
    • class IndexGeneratorBase Abstract base class for index generators.
    • class IteratorIndexGenerator Index generator that wraps an iterator pair.
    • class Mesh Represents a polyhedral complex.
    • class Mesh<Context::Local> Represents the subdivision of some domain into faces of (possibly) different geometries.
      • class Builder Class used to build Mesh<Context::Local> instances.
    • class Mesh<Context::MPI> Distributed mesh specialization for MPI contexts.
      • class Builder Builder used to construct a distributed mesh from a shard.
      • struct ReconcileOptions Options controlling iterative reconciliation rounds.
    • class MeshBase Abstract base class for all mesh implementations.
    • class MinSTCut Serial binary Potts classifier solved by an s-t min cut.
      • struct Edge A weighted graph edge between two cells.
      • struct Options Optional classification policies layered on top of the bare Potts graph cut.
      • struct Result Result of a classification: per-cell labels and cut data.
    • class ParametricTransformation Template for finite-element parametric transformations.
    • class Partitioner Abstract base class for mesh partitioning strategies.
    • class Point final Concrete implementation of a spatial point on a mesh.
    • class PointBase Base class for spatial points on a discrete mesh.
    • class PointCloud Point cloud with a point-centric API and Eigen "matrix" views.
    • class Polytope Base class for all geometric elements in finite element meshes.
      • class Key Vertex index array identifying a polytope in the mesh.
        • struct SymmetricEquality Compares two keys for equality ignoring vertex ordering.
        • struct SymmetricHash Hash functor that produces the same hash for any permutation of the vertex indices.
      • struct Project Projection operations for polytope sub-entities.
      • struct Traits Geometric traits for polytope types.
        • struct HalfSpace Half-space representation of reference element.
    • class PolytopeIterator Iterator over general polytopes of specified dimension.
    • class PolytopeIteratorBase Base class template for polytope iterators.
    • class PolytopeQuadrature Cached quadrature attached to one specific polytope.
    • class PolytopeQuadratureIndex Thread-safe cache of polytope quadratures.
    • class PolytopeTransformation Abstract base class for polytope geometric transformations.
    • class PolytopeTransformationIndex Thread-safe index for managing polytope transformations.
      • struct Dimension Storage for transformations of polytopes in a single dimension.
      • struct Slot Storage slot for a single transformation.
    • class SetIndexGenerator Index generator backed by a set of indices.
    • class Shard Local view of one partition of a distributed mesh.
      • class Builder Incremental builder for Shard.
      • struct PolytopeMap Bidirectional correspondence between local shard and distributed indices.
    • class Sharder Interface for mesh sharding algorithms.
    • class Sharder<Context::MPI> Utility for distributing a global mesh across MPI ranks by splitting into per-rank shards, scattering them from a root, and gathering the local mesh on each rank.
    • class SharderBase Base implementation for decomposing a partitioned mesh into shards.
    • class SubMesh Represents a subset of a Mesh.
    • class SubMesh<Context::Local> final SubMesh representing a subregion of a parent mesh.
      • class Builder Builder for constructing SubMesh instances.
    • class SubMesh<Context::MPI> final SubMesh representing a distributed subregion of a parent MPI mesh.
      • class Builder Builder for constructing distributed SubMesh instances.
    • class SubMeshBase Abstract base class for SubMesh implementations.
      • struct PolytopeMap Polytope index mapping structure.
    • class SubMeshBuilder Distributed MPI SubMesh specialization.
    • class VectorIndexGenerator Index generator backed by a vector of indices.
    • class Vertex Represents a vertex (0-dimensional element) in a mesh.
    • class VertexIterator Iterator over mesh vertices (0-dimensional polytopes).
  • namespace Heart Namespace Rodin::Heart.
    • struct CCMLC2014PassiveLaw Default passive stress law for the CCMLC2014 reduced model.
    • class HolzapfelReducedLaw Passive-energy evaluator based on reduced invariants.
      • struct Parameters Parameters of the reduced passive-energy law.
    • struct PassiveEnergyDerivatives Bundle of gradient and Hessian for passive-energy derivatives.
    • struct ReducedInvariantGradient First derivatives of passive-energy density with respect to reduced invariants.
    • struct ReducedInvariantHessian Second derivatives of passive-energy density with respect to reduced invariants.
    • struct ReducedInvariants Reduced invariants used by the passive-energy law.
  • namespace Hilbert Namespace Rodin::Hilbert.
    • class H1a Hilbertian extension-regularization procedure with a regularization length-scale parameter.
  • namespace IO Namespace Rodin::IO.
    • namespace HDF5 HDF5 utility namespace providing type aliases, path constants, RAII handle wrappers, and low-level dataset read/write helpers.
      • namespace Path HDF5 dataset path constants for the mesh and grid function storage layouts.
      • class Handle RAII wrapper for HDF5 identifier handles.
      • struct XDMFTopologyLayout Layout metadata for XDMF topology dataset emission.
    • namespace Internal Internal helpers for PETSc HDF5 serialization primitives.
    • class GridFunctionLoader Loader template for grid functions with specific file format.
    • class GridFunctionLoader<FileFormat::HDF5, FES, ::Vec> HDF5 loader for PETSc-backed grid functions.
    • class GridFunctionLoader<FileFormat::HDF5, FES, Math::Vector<Scalar>> HDF5 grid function loader for local grid functions backed by Math::Vector<Scalar>.
    • class GridFunctionLoader<FileFormat::MEDIT, Variational::H1<K, Range, Geometry::Mesh<Context::Local>>, Math::Vector<typename FormLanguage::Traits<Range>::ScalarType>> MEDIT grid-function loader for local H1 finite element spaces.
    • class GridFunctionLoader<FileFormat::MEDIT, Variational::P1<Range, Geometry::Mesh<Context::Local>>, Math::Vector<typename FormLanguage::Traits<Range>::ScalarType>> MEDIT grid-function loader for local P1 finite element spaces.
    • class GridFunctionLoader<FileFormat::MFEM, Variational::H1<K, Range, Geometry::Mesh<Context::Local>>, Math::Vector<typename FormLanguage::Traits<Range>::ScalarType>> Specialization for loading H1 grid functions from MFEM format.
    • class GridFunctionLoader<FileFormat::MFEM, Variational::P0<Range, Geometry::Mesh<Context::Local>>, Math::Vector<typename FormLanguage::Traits<Range>::ScalarType>> Loader for P0 (piecewise constant) grid functions in MFEM format.
    • class GridFunctionLoader<FileFormat::MFEM, Variational::P1<Range, Geometry::Mesh<Context::Local>>, Math::Vector<typename FormLanguage::Traits<Range>::ScalarType>> Specialization for loading P1 grid functions from MFEM format.
    • class GridFunctionLoaderBase Base class for concrete grid function loaders.
    • class GridFunctionPrinter Printer template for grid functions with specific file format.
    • class GridFunctionPrinter<FileFormat::HDF5, FES, ::Vec> final HDF5 printer for PETSc-backed grid functions.
    • class GridFunctionPrinter<FileFormat::HDF5, FES, Math::Vector<Scalar>> final HDF5 grid function printer for local grid functions backed by Math::Vector<Scalar>.
    • class GridFunctionPrinter<FileFormat::MEDIT, FES, ::Vec> final MEDIT printer for PETSc-backed grid functions.
    • class GridFunctionPrinter<FileFormat::MEDIT, FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>> MEDIT grid-function printer for vector-backed grid functions.
    • class GridFunctionPrinter<FileFormat::MFEM, FES, Math::Vector<Scalar>> final Final specialization for printing grid functions with vector data in MFEM format.
    • class GridFunctionPrinter<FileFormat::MFEM, Variational::H1<K, Range, Geometry::Mesh<Context::Local>>, Math::Vector<Scalar>> final Specialization for printing H1 grid functions with vector data in MFEM format.
    • class GridFunctionPrinter<FileFormat::MFEM, Variational::H1<K, Range, Geometry::Mesh<Ctx>>, ::Vec> final MFEM printer for PETSc-backed H1 (order ) grid functions.
    • class GridFunctionPrinter<FileFormat::MFEM, Variational::P0<Range, Geometry::Mesh<Ctx>>, ::Vec> final MFEM printer for PETSc-backed P0 grid functions.
    • class GridFunctionPrinter<FileFormat::MFEM, Variational::P1<Range, Geometry::Mesh<Ctx>>, ::Vec> final MFEM printer for PETSc-backed P1 grid functions.
    • class GridFunctionPrinterBase Base class for concrete grid function printers.
    • class GridFunctionPrinterBase<FileFormat::MEDIT, FES, Data> Base class for MEDIT grid-function printers.
    • class GridFunctionPrinterBase<FileFormat::MFEM, Variational::H1<K, Range, Geometry::Mesh<Context>>, Data> Base class for printing H1 (continuous Lagrange) grid functions in MFEM format.
    • class GridFunctionPrinterBase<FileFormat::MFEM, Variational::P0<Range, Geometry::Mesh<Context>>, Data> Base class for printing P0 (piecewise constant) grid functions in MFEM format.
    • class GridFunctionPrinterBase<FileFormat::MFEM, Variational::P1<Range, Geometry::Mesh<Context>>, Data> Base class for printing P1 (continuous Lagrange) grid functions in MFEM format.
    • class Loader Base template for loading objects from files or streams.
    • class MeshLoader Loader template for meshes with specific file format and context.
    • class MeshLoader<FileFormat::HDF5, Context::Local> HDF5 mesh loader specialization for local (sequential) meshes.
    • class MeshLoader<FileFormat::HDF5, Context::MPI> Loads a distributed MPI mesh from an HDF5 file.
    • class MeshLoader<IO::FileFormat::MEDIT, Context::Local> Specialization for loading Sequential meshes in the MEDIT file format.
    • class MeshLoader<IO::FileFormat::MFEM, Context::Local> Specialization for loading sequential meshes in MFEM format.
    • class MeshLoaderBase Base class for loading meshes from files or streams.
    • class MeshPrinter Printer template for meshes with specific file format and context.
    • class MeshPrinter<FileFormat::HDF5, Context::Local> HDF5 mesh printer specialization for local (sequential) meshes.
    • class MeshPrinter<FileFormat::HDF5, Context::MPI> Prints a distributed MPI mesh to an HDF5 file.
    • class MeshPrinter<FileFormat::MEDIT, Context::Local> MEDIT mesh printer for local meshes.
    • class MeshPrinter<FileFormat::MFEM, Context::Local> Specialization for printing sequential meshes in MFEM format.
    • class MeshPrinterBase Base class for printing meshes to streams or files.
    • class Printer Base template for printing objects to streams.
    • class XDMF XDMF domain writer for static or transient visualization output.
      • struct AttributeRecord Internal record for one registered attribute.
      • struct FilePatterns File naming patterns used by the writer.
      • class Grid Handle to one named grid inside the XDMF domain.
      • struct GridOptions Per-grid export options.
      • struct GridRecord Internal record for one named grid.
      • struct Keyword XML element names used in the XDMF 3 document format.
      • struct SnapshotRecord Internal record for one temporal snapshot.
        • struct AttributeRecord Attribute metadata recorded for one snapshot.
        • struct MeshAttributeRecord Mesh-attached attribute metadata recorded for one snapshot.
        • struct PieceMeta Per-rank mesh metadata cached during write().
  • namespace Location Namespace Rodin::Location.
  • namespace Math Namespace Rodin::Math.
    • class Deg Represents an angle in degrees.
    • class LinearSystem Represents a linear system of equations.
    • class LinearSystem<Math::Matrix<MatrixScalar>, Math::Vector<VectorScalar>> Linear system specialization for dense matrices.
    • class LinearSystem<Math::SparseMatrix<MatrixScalar>, Math::Vector<VectorScalar>> Linear system specialization for sparse matrices.
    • class LinearSystem<::Mat, ::Vec> Specialization of Rodin::Math::LinearSystem for PETSc objects (Mat and Vec).
      • class FieldSplits Container for named PETSc index sets used with field-split preconditioners (e.g. PCFIELDSPLIT).
        • struct Split A single named index set for field-split preconditioning.
    • class LinearSystemBase Base class for linear systems of the form .
    • class Rad Represents an angle in radians.
    • class SpatialMatrix Spatial matrix with bounded maximum dimensions.
    • class SpatialVector Spatial vector with bounded maximum size.
    • class Unit Base class for units using CRTP.
  • namespace MMG Namespace Rodin::Traits.
    • class Adapt Performs anisotropic/isotropic remeshing from a nodal size map.
    • class LevelSetDiscretizer Discretizes implicit geometry defined by a nodal level-set field.
    • class Mesh Local mesh enriched with MMG boundary tags and constraints.
      • class Builder Class used to build MMG::Mesh instances.
    • class MeshLoader Loads an Rodin::MMG::Mesh from the MEDIT format.
    • class MeshPrinter Printer for Rodin::MMG::Mesh in MEDIT/MMG-compatible syntax.
    • class MMG5 Base class for MMG-backed operations in Rodin.
    • class MMG5Exception Exception type for MMG wrapper failures.
    • struct NoSplitT Tag type indicating that a material reference must not be split.
    • class Optimizer Improves mesh quality while preserving characteristic local sizes.
    • struct Split Interior/exterior labels produced when splitting one material.
  • namespace MPI Distributed-memory parallel extensions using MPI.
  • namespace PETSc PETSc integration module for Rodin.
    • namespace Assembly PETSc-specific assembly strategies.
      • class MatrixSetup Sets up a PETSc matrix for assembly while reusing compatible existing structure.
        • struct Options Requested PETSc matrix layout and setup policy.
      • class VectorSetup Sets up a PETSc vector for assembly while reusing compatible existing structure.
        • struct Options Requested PETSc vector layout and setup policy.
    • namespace Math PETSc-backed linear algebra adapters.
    • namespace Solver PETSc-backed linear and nonlinear solver adapters.
    • namespace Variational PETSc-backed variational form adapters.
      • class GridFunction Convenience wrapper that inherits all functionality from Rodin::Variational::GridFunction<FES, ::Vec>.
      • class TestFunction PETSc-aware test function wrapper.
      • class TrialFunction PETSc-aware trial function wrapper.
    • class Object RAII base class for wrappers around PETSc opaque handles.
  • namespace Plot Namespace Rodin::Plot.
    • namespace Artist Namespace Rodin::Plot::Artist.
      • namespace Axes Namespace Rodin::Plot::Artist::Axes.
      • namespace Axis Namespace Rodin::Plot::Artist::Axis.
      • namespace Lines Namespace Rodin::Plot::Artist::Lines.
    • namespace Backend Namespace Rodin::Plot::Backend.
      • namespace Bases Namespace Rodin::Plot::Backend::Bases.
      • namespace Event Namespace Rodin::Plot::Backend::Event.
      • namespace Renderer Namespace Rodin::Plot::Backend::Event.
        • namespace Drawables Namespace Rodin::Plot::Backend::Renderer::Drawables.
    • namespace GUI Namespace Rodin::Plot::GUI.
  • namespace QF Namespace Rodin::QF.
    • class Centroid final Single-point centroid quadrature formula.
    • class GaussLegendre final Gauss-Legendre quadrature formula on reference polytopes.
    • class GaussLobatto final Gauss-Lobatto quadrature formula on reference polytopes.
    • class GrundmannMoller Grundmann-Möller simplex quadrature formula.
    • class PolytopeQuadratureFormula Generic quadrature formula dispatcher for all polytope types.
    • class QuadratureFormulaBase Abstract base class for quadrature formulas.
  • namespace Scotch PT-Scotch mesh partitioning integration.
    • class Exception Exception type for errors reported by Scotch wrappers.
    • class Partitioner Mesh partitioner implemented with the SCOTCH library.
  • namespace Serialization Namespace support for serialization of Rodin types.
  • namespace Solid Hyperelastic solid mechanics module for large-deformation problems.
    • namespace Tags Standard tag types for auxiliary constitutive data.
      • struct Activation Tag for the activation parameter.
      • struct ActiveExtension Tag for the active fiber extension .
      • struct CellIndex Tag for the index of the current cell (polytope) being assembled.
      • struct ElectricalActivation Tag for the scalar electrical/chemical activation input.
      • struct FiberDirection Tag for the fiber direction vector.
      • struct PreviousActiveBeta Tag for previous active variable .
      • struct PreviousActiveExtension Tag for the previous active fiber extension .
      • struct PreviousActiveGamma Tag for previous active variable .
      • struct PreviousFiberStrain Tag for the previous fiber strain .
      • struct QuadraturePointIndex Tag for the index of the current quadrature point within the cell.
      • struct SheetDirection Tag for the sheet direction vector.
      • struct SheetNormalDirection Tag for the sheet-normal direction vector.
      • struct TimeStep Tag for the active-law time step.
    • class ActiveContraction final Adds active fiber stress to a passive law.
      • struct Cache Cached passive and active quantities at a quadrature point.
    • class ActiveFiberLaw Local active fiber contraction law.
      • struct Parameters Parameters controlling the local active-fiber law.
        • struct Initial Initial active extension, stiffness, and stress data.
      • struct Response Local response and tangent data for a fiber update.
      • struct State Internal active-fiber state.
    • class CauchyStress Computes the Cauchy stress from a constitutive law.
    • class ConstitutivePoint Central data bundle for constitutive evaluation at a quadrature point.
    • class FiberInvariants Fiber invariants for anisotropic hyperelasticity.
    • class FiberKinematics Preferred-direction kinematics at a constitutive point.
    • class FirstPiolaKirchhoffStress Computes the first Piola-Kirchhoff stress from a constitutive law.
    • class GreenLagrangeStrain Computes the Green-Lagrange strain tensor from a kinematic state.
    • class HolzapfelOgden final Compressible Holzapfel-Ogden law with one preferred direction.
      • struct Cache Cached invariant values and fiber direction.
      • struct Parameters Material parameters for the Holzapfel-Ogden law.
    • class Hooke Isotropic Hooke's law for linear elasticity.
    • class HyperElasticLaw CRTP base class for hyperelastic constitutive laws.
    • class Input CRTP base class for inputs.
    • class InternalVirtualWork Façade for the internal virtual work nonlinear form.
    • class InternalVirtualWorkResidual Linear form integrator for the internal virtual work residual in hyperelastic problems.
    • class InternalVirtualWorkTangent Local bilinear form integrator for the internal virtual work tangent in hyperelastic problems.
    • class IsotropicInvariants Isotropic invariants of the right Cauchy-Green tensor.
    • class KinematicState Kinematic state for finite-strain continuum mechanics.
    • class MooneyRivlin final Compressible Mooney-Rivlin hyperelastic law.
      • struct Cache Precomputed cache for the Mooney-Rivlin law.
    • class NeoHookean final Compressible Neo-Hookean hyperelastic law.
      • struct Cache Precomputed cache for the Neo-Hookean law.
    • class Output CRTP base class for outputs.
    • class SaintVenantKirchhoff final Saint-Venant-Kirchhoff hyperelastic law.
      • struct Cache Precomputed cache for the Saint-Venant-Kirchhoff law.
  • namespace Solver Namespace Rodin::Solver.
    • class BiCGSTAB Bi-conjugate gradient stabilized iterative solver.
    • class BiCGSTAB<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Bi-conjugate gradient stabilized solver for non-symmetric sparse systems.
    • class CG Conjugate gradient solver for symmetric positive definite systems.
    • class CG<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final Conjugate gradient solver for symmetric positive definite dense systems.
    • class CG<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Conjugate gradient solver for symmetric positive definite sparse systems.
    • class CG<PETSc::Math::LinearSystem> final Conjugate gradient solver for PETSc linear systems.
    • class DGMRES Deflated generalized minimal residual iterative solver.
    • class DGMRES<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final DGMRES solver for dense systems.
    • class DGMRES<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final DGMRES solver for sparse systems.
    • class EigenSolver Wrapper class for any Eigen sparse solver.
    • class GMRES Generalized minimal residual iterative solver.
    • class GMRES<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final GMRES solver for dense systems.
    • class GMRES<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final GMRES solver for sparse systems.
    • class GMRES<PETSc::Math::LinearSystem> final Generalized minimal residual (GMRES) solver for PETSc linear systems.
    • class HouseholderQR Householder QR decomposition for dense matrices.
    • class HouseholderQR<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final A direct sparse HouseholderQR Cholesky factorizations without square root for use with Math::SparseMatrix and Math::Vector.
    • class IDRS<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final IDRS(s) solver for dense systems.
    • class IDRS<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final IDRS(s) solver for sparse systems.
    • class IDRSTABL IDR(s)STABL iterative solver.
    • class IDRSTABL<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final IDRstab(l) solver for dense systems.
    • class IDRSTABL<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final IDRstab(l) solver for sparse systems.
    • class KSP PETSc KSP (Krylov subspace) linear solver wrapper.
    • class LDLT Robust LDLT Cholesky decomposition for dense matrices.
    • class LDLT<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final Robust LDLT Cholesky factorization with pivoting for dense matrices.
    • class LeastSquaresCG Least-squares conjugate gradient solver.
    • class LeastSquaresCG<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final Least-squares conjugate gradient solver for dense systems.
    • class LeastSquaresCG<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Least-squares conjugate gradient solver for sparse systems.
    • class LinearSolverBase Abstract base class for linear system solvers.
    • class MINRES<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final MINRES solver for symmetric dense systems.
    • class MINRES<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final MINRES solver for symmetric sparse systems.
    • class NewtonSolver final Newton solver for state-dependent tangential problems.
      • struct Report Summary of the most recent call to solve().
      • struct StepResult Outcome of a single Newton step.
    • class NewtonSolverBase Abstract base class for Newton-type nonlinear solvers.
    • class PartialPivLU Dense LU factorization with partial pivoting for general matrices.
    • class PartialPivLU<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final Dense LU factorization solver with partial pivoting for general matrices.
    • class SimplicialLDLT Direct sparse LDLT Cholesky factorization solver.
    • class SimplicialLDLT<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Simplicial LDLT Cholesky factorization without square root.
    • class SimplicialLLT Direct sparse LLT Cholesky factorization solver.
    • class SimplicialLLT<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Simplicial LLT Cholesky factorization for sparse SPD matrices.
    • class SNES PETSc SNES (Scalable Nonlinear Equations Solvers) wrapper.
    • class SparseLU Sparse supernodal LU factorization for general matrices.
    • class SparseLU<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Sparse supernodal LU factorization solver for general sparse matrices.
    • class SparseQR Sparse QR factorization with column pivoting.
    • class SparseQR<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Sparse QR factorization with numerical column pivoting.
  • namespace Test Module containing various utilities and classes for writing tests.
    • class FDProbe Finite-difference probe for a nonlinear assembled problem.
    • class FDProbe<Math::LinearSystem<Operator, Vector>> Finite-difference probe for an assembled linear system.
    • struct FDProbeReport Report produced by a finite-difference tangent probe.
  • namespace Tests Tests of the Rodin library
    • namespace Benchmarks Namespace Rodin::Tests::Manufactured.
    • namespace Manufactured Namespace Rodin::Tests::Unit.
      • namespace Conductivity Manufactured solutions for the conductivity problem using P1 spaces.
      • namespace Darcy Manufactured solution for the Darcy problem using P1 spaces.
      • namespace DirichletBCIdentification Manufactured solutions for the identification Dirichlet BC DirichletBC(u, A(v)), where A(v) is a linear shape-function expression.
      • namespace DivPoisson Manufactured solutions for the divergence Poisson problem using P1 vector spaces.
      • namespace Helmholtz3D
      • namespace LinearElasticity Manufactured solutions for the linear elasticity problem.
      • namespace LinearElasticity3D
      • namespace Poisson Manufactured solutions for the Poisson problem.
      • namespace Poisson3D Manufactured solutions for the 3D Poisson problem on supported 3D meshes.
      • namespace ReactionDiffusion3D
      • namespace Stokes Manufactured solutions for the Stokes problem using H1 of order 2.
    • namespace Unit Namespace Rodin::Tests.
      • class Assembly_OpenMP_Problem Single-variable Problem: Default assembler (OpenMP when available) produces same operator as Sequential for all 2D geometries.
      • class FlowTest Unit tests for Flow class basic functionality.
      • class FMMTest Basic unit tests for Fast Marching Method (FMM)
      • class LagrangianTest Unit tests for Lagrangian class basic functionality.
  • namespace Threads Namespace Rodin::Threads.
  • namespace Traits Namespace Rodin::Utility.
  • namespace Utility Namespace Rodin::Test.
    • struct BottomTemplate Metafunction to extract the innermost (bottom) type from nested templates.
    • struct BottomTemplate<T<S>> Specialization for single-parameter template instantiations.
    • class Cast Template for defining type conversion operations.
    • struct DependentValue Creates a type-dependent compile-time constant value.
    • struct Extract Template metafunction for extracting types from tuple structures.
    • struct Extract<Tuple<T, Ts...>> Specialization of Extract for Tuple types.
    • struct HasTypeMember Type trait to detect if a type has a nested Type member.
    • struct HasTypeMember<T, std::void_t<typename T::Type>> Specialization for types that have a nested Type member.
    • struct HasValueMember Type trait to detect if a type has a nested Value member type.
    • struct HasValueMember<T, std::void_t<typename T::Value>> Specialization for types that have a nested Value member type.
    • class IntegerSequence Represents a compile-time sequence of integers.
    • struct IsOneOf Type trait to check if a type is one of a specified list of types.
    • struct IsOneOf<F, S, T...> Specialization for non-empty type lists.
    • struct IsSpecialization Type trait to check if a type is a specialization of a given template.
    • struct IsSpecialization<Ref<Args...>, Ref> Specialization for types that are specializations of the reference template.
    • struct Make Factory template for perfect forwarding construction.
    • class OptionalReference A wrapper providing optional reference semantics.
    • struct Overloaded Helper type for creating overloaded function objects from lambdas.
    • class ParameterPack Template metaprogramming utilities for parameter packs.
    • struct Product Metafunction to compute the Cartesian product of two Tuple type-lists.
    • struct Product<Tuple<Gs...>, Tuple<>> Specialization for empty second Tuple.
    • struct Product<Tuple<H>, Tuple<Gs...>> Specialization for Tuple with exactly one element.
    • struct Product<Tuple<H1, H2, Hs...>, Tuple<Gs...>> Specialization for Tuple with at least two elements (H1, H2, Hs…).
    • struct Product<Tuple<>, Tuple<Gs...>> Specialization for empty first Tuple.
    • struct Repeat Metafunction to create a Tuple with N repetitions of type T.
    • struct Repeat<0, T> Specialization for N = 0.
    • struct Repeat<1, T> Specialization for N = 1.
    • struct UnwrapRefDecay Combines decay and reference unwrapping.
    • struct UnwrapReference Metafunction to unwrap std::reference_wrapper types.
    • struct UnwrapReference<std::reference_wrapper<U>> Specialization for std::reference_wrapper.
    • class Wrap Metafunction to wrap all types in a Tuple with an external template.
    • class Wrap<Tuple<Ts...>> Specialization for Tuple types.
    • struct Zip Metafunction to combine two Tuples element-wise using a binary template.
    • struct Zip<Tuple<Ts...>, Tuple<Gs...>> Specialization for two Tuples.
  • namespace Variational Namespace Rodin::Variational.
    • class BilinearForm<Solution, TrialFES, TestFES, ::Mat> final Bilinear form specialization that assembles into a PETSc matrix.
    • class BilinearForm<Solution, TrialFES, TestFES, Math::Matrix<Scalar>> final Specialization of BilinearForm for a dense matrix operator.
    • class BilinearForm<Solution, TrialFES, TestFES, Math::SparseMatrix<Scalar>> final Speciallization of BilinearForm for a matrix type.
    • class BilinearFormBase Base class for bilinear form representations.
    • class FeketeTetrahedron Cached Fekete-type nodes on the reference tetrahedron for degree K.
    • class FeketeTriangle Cached Fekete-type nodes on the reference triangle for degree K.
    • class FiniteElementBase Base class for finite elements.
    • class FiniteElementSpace<Geometry::Mesh<Context::MPI>, Derived> Represents a finite element space defined on a distributed mesh.
    • class FunctionBase Base class for functions defined on finite element meshes.
    • class GridFunction<FES, ::Vec> Grid function specialization storing DOF coefficients in a PETSc vector (Vec).
      • struct ArrayRead State tracking for read-only array access to the PETSc vector.
      • struct ArrayWrite State tracking for mutable (write) array access to the PETSc vector.
      • struct GhostBimap Bidirectional mapping between global ghost DOF indices and local ghost offsets within the PETSc ghosted vector.
    • class GridFunction<FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>> final Grid function storing its degrees of freedom in a dense Math::Vector over the space's scalar type (the standard local backend).
    • class GridFunctionBase Base class for discrete finite element functions.
    • class H1<K, Math::SpatialVector<Scalar>, Geometry::Mesh<Context::MPI>> Distributed vector-valued H1 finite element space for MPI meshes.
      • struct IndexBimap Bidirectional map between local and global DOF indices.
      • class Pullback Pullback of a callable (or FunctionBase) to the reference polytope.
      • class Pushforward Pushforward of a function from the reference polytope.
    • class H1<K, Scalar, Geometry::Mesh<Context::MPI>> Distributed H1 finite element space for MPI meshes (scalar range).
      • struct IndexBimap Bidirectional map between local and global DOF indices.
      • class Pullback Pullback of a callable (or FunctionBase) to the reference polytope.
      • class Pushforward Pushforward of a function from the reference polytope.
    • class Integrator Abstract base class for integrators in variational formulations.
    • struct IsTestFunction<PETSc::Variational::TestFunction<FES>> Marks PETSc test functions as valid test functions.
    • struct IsTrialFunction<PETSc::Variational::TrialFunction<Solution, FES>> Marks PETSc trial functions as valid trial functions.
    • class JacobiPolynomial Jacobi polynomial evaluator.
    • class LegendrePolynomial Compile-time degree Legendre polynomial evaluator.
    • class LinearElasticityIntegral Helper class to construct linear elasticity integrators.
    • class LinearElasticityIntegrator Bilinear form integrator for linear elasticity.
    • class LinearElasticityIntegrator<Solution, P1<Range, Mesh>, MuDerived, LambdaDerived> final P1 linear elasticity bilinear form integrator.
    • class LinearForm<FES, ::Vec> final Linear form specialization that assembles into a PETSc vector.
    • class NonLinearFormIntegrator CRTP mixin for nonlinear form integrators.
    • class P0 Degree 0 Lagrange finite element space.
    • class P0<Range, Geometry::Mesh<Context::MPI>> Distributed P0 finite element space for MPI meshes.
      • struct IndexBimap Bidirectional map between local and global DOF indices.
      • class Pullback Pullback of a function to the reference polytope.
      • class Pushforward Pushforward of a function from the reference polytope.
    • class P0Element Degree 0 Lagrange element.
    • class P0g<Math::SpatialVector<Real>, Geometry::Mesh<Context::MPI>> final Distributed vector P0g finite element space for MPI meshes.
    • class P0g<Real, Geometry::Mesh<Context::MPI>> final Distributed scalar P0g finite element space for MPI meshes.
    • class P1 Degree 1 Lagrange finite element space.
    • class P1<Range, Geometry::Mesh<Context::MPI>> Distributed P1 finite element space for MPI meshes.
      • class CallablePullback Pullback of a pointwise callable to the reference polytope.
      • struct IndexBimap Bidirectional map between local and global dof indices.
      • class Pullback Pullback of a function to the reference polytope.
      • class Pushforward Pushforward of a function from the reference polytope.
    • class P1Element Degree 1 Lagrange element.
    • class Problem<PETSc::Math::LinearSystem, U, V> PETSc variational problem for a single trial / test function pair.
    • class Problem<PETSc::Math::LinearSystem, U1, U2, U3, Us...> PETSc variational problem for multiple coupled trial / test functions.
    • class RealFunction<F> final Represents a scalar function given by an arbitrary scalar function.
    • class RealFunction<FunctionBase<NestedDerived>> final Real-valued function that wraps another real function expression.
    • class RealFunction<Integer> final Represents a constant scalar function initialized from an Integer.
    • class RealFunction<Real> final Represents a constant scalar function with type Real.
    • class RealFunctionBase Base class for real-valued scalar functions.
    • class RelativeError Utility class for computing relative errors.
    • class VectorFunction<F> final Vector function backed by a callable.
    • class VectorFunction<Math::Vector<Scalar>> final Vector function backed by an existing dense vector.
    • class VectorFunction<V, Values...> final Represents a vector function which may be constructed from values which can be converted to objects of type RealFunction.
    • class VectorFunctionBase Base class for vector-valued functions defined on a mesh.
  • class Cast Template class for type casting operations.
  • class Copyable Abstract base class for objects that can be copied.
  • struct DefaultSentinelT Sentinel type for default-constructed iterators.
  • class Identifiable Abstract base class for objects that can be copied.
  • struct IndexArrayCompare Functor for lexicographically ordering index arrays.
  • struct IndexArrayEquality Functor for comparing two index arrays for equality.
  • struct IndexSetEquality Functor for comparing two IndexSet objects for equality.
  • struct IndexSetHash Functor for computing a hash value for an IndexSet.
  • class Moveable Abstract base class for objects that can be moved.
  • class Pair Forward declaration of the Pair template class.
  • class Tuple Forward declaration of the Tuple template class.
  • class Tuple<T, Ts...> A tuple class that extends std::tuple with additional functionality.
  • class Tuple<> Specialization of Tuple for an empty parameter pack.