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>.
    • class CellDeformation Lazily evaluated deformation state of a mesh cell.
    • struct CellGeomCache Per-cell geometry cache for the 2D triangular affine prototype.
    • class DeformationMap The deformation induced by a displacement, evaluated with memoisation.
    • class WNGIR Backend-independent WNGIR mesh-fitting solver.
      • struct AdmissibilityState Mesh-validity summary of a displacement.
      • struct NormalJump Kink of the discrete interface across facet boundaries.
      • struct RigidModeState Observation coercivity restricted to rigid displacements.
      • struct RobustScale Robust scale of the interface residual.
      • struct SurfaceState Interface-fit summary of a displacement.
    • struct WNGIRAdmissibilityReport Sampled geometric admissibility diagnostics.
    • class WNGIRLoss Fixed-scale Welsch loss and its consistent IRLS weight.
    • struct WNGIRParameters Runtime parameters controlling WNGIR assembly and iteration.
    • struct WNGIRReport Diagnostics produced by a WNGIR solve.
  • 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 Input data for complete problem 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 IsSpecialized Whether T is an optimized specialization rather than a generic handler.
    • struct IsSpecialized<T, std::void_t<decltype(T::Specialized)>> Specialization for types declaring a Specialized member.
    • 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 RangeOf Type trait to deduce the mathematical range type of an expression.
    • struct RangeOf<Boolean> Range type for Boolean values.
    • struct RangeOf<Complex> Range type for Complex values.
    • struct RangeOf<Eigen::Matrix<Scalar, Rows, 1, Options, MaxRows, MaxCols>> Range type for Eigen column vectors.
    • struct RangeOf<Eigen::Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>> Range type for Eigen matrices.
    • struct RangeOf<Integer> Range type for Integer values.
    • struct RangeOf<Math::SpatialMatrix<Scalar>> Range type deduced for Math::SpatialMatrix.
    • struct RangeOf<Math::SpatialVector<Scalar>> Range type deduced for Math::SpatialVector.
    • struct RangeOf<Real> Range type for Real values.
    • struct RangeOf<Variational::FunctionBase<Derived>> Range type for FunctionBase.
    • struct RangeOf<Variational::ShapeFunctionBase<Derived, FES, Space>> Range type for ShapeFunctionBase.
    • struct ResultOf Type trait to deduce the result type of an expression.
    • struct ResultOf<Variational::FunctionBase<Derived>> Specialization of ResultOf for FunctionBase.
    • struct ResultOf<Variational::ShapeFunctionBase<Derived, FES, Space>> Specialization of ResultOf for ShapeFunctionBase.
    • 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::Component<Variational::ShapeFunctionBase<OperandDerived, FES, Space>>> Type traits for Component over a shape function: exposes the finite element space, the shape function space, the operand type, the scalar type and the range type.
    • struct Traits<Variational::Conjugate<Variational::ShapeFunctionBase<NestedDerived, FES, Space>>> Type traits for Conjugate over a shape function: exposes the finite element space and the shape function space.
    • struct Traits<Variational::Derivative<Variational::GridFunction<Variational::H1<K, Scalar, Mesh>, Data>>> Type traits for Derivative over a grid function: exposes the finite element space, the operand type and the range type.
    • struct Traits<Variational::Derivative<Variational::GridFunction<Variational::P1<Range, Mesh>, Data>>> Type traits for Derivative over a grid function: exposes the finite element space, the operand type and the range type.
    • struct Traits<Variational::Derivative<Variational::ShapeFunction<NestedDerived, FES, Space>>> Type traits for Derivative over a shape function: exposes the shape function space, the finite element space, the scalar type and the operand type.
    • struct Traits<Variational::Derivative<Variational::ShapeFunction<NestedDerived, Variational::P1<Range, Mesh>, Space>>> Type traits for Derivative over a shape function: exposes the finite element space, the shape function space, the operand type and the range type.
    • struct Traits<Variational::Div<Variational::GridFunction<Variational::H1<K, Math::SpatialVector<Scalar>, Mesh>, Data>>> Type traits for Div over a grid function: exposes the finite element space, the scalar type and the operand type.
    • struct Traits<Variational::Div<Variational::GridFunction<Variational::P0g<Math::SpatialVector<Scalar>, Mesh>, Data>>> Type traits for Div over a grid function: exposes the finite element space, the scalar type and the operand type.
    • struct Traits<Variational::Div<Variational::GridFunction<Variational::P1<Math::SpatialVector<Scalar>, Mesh>, Data>>> Type traits for Div over a grid function: exposes the finite element space, the scalar type and the operand type.
    • struct Traits<Variational::Div<Variational::ShapeFunction<NestedDerived, Variational::H1<K, Math::SpatialVector<Scalar>, Mesh>, Space>>> Type traits for Div over a shape function: exposes the finite element space, the shape function space, the scalar type and the operand type.
    • struct Traits<Variational::Div<Variational::ShapeFunction<NestedDerived, Variational::P0g<Math::SpatialVector<Scalar>, Mesh>, Space>>> Type traits for Div over a shape function: exposes the finite element space, the shape function space, the scalar type and the operand type.
    • struct Traits<Variational::Div<Variational::ShapeFunction<NestedDerived, Variational::P1<Math::SpatialVector<Scalar>, Mesh>, Space>>> Type traits for Div over a shape function: exposes the finite element space, the shape function space, the scalar type and the operand type.
    • struct Traits<Variational::Division<Variational::ShapeFunctionBase<LHSDerived, FES, Space>, Variational::FunctionBase<RHSDerived>>> Type traits for Division over a shape function: exposes the finite element space, the shape function space, the left-hand side operand, the right-hand side operand and the range type.
    • struct Traits<Variational::Dot<Variational::FunctionBase<LHSDerived>, Variational::FunctionBase<RHSDerived>>> Type traits for Dot over a function expression: exposes the left-hand side operand, the right-hand side operand, the scalar type and the range type.
    • struct Traits<Variational::Dot<Variational::FunctionBase<LHSDerived>, Variational::ShapeFunctionBase<RHSDerived, FES, Space>>> Type traits for Dot over a function expression: exposes the finite element space, the shape function space, the left-hand side operand, the right-hand side operand, the scalar type and the range type.
    • struct Traits<Variational::Dot<Variational::ShapeFunctionBase<LHSDerived, TrialFES, Variational::TrialSpace>, Variational::ShapeFunctionBase<RHSDerived, TestFES, Variational::TestSpace>>> Type traits for Dot over a shape function: exposes the left-hand side operand, the right-hand side operand, the scalar type and the range type.
    • struct Traits<Variational::Flow<Variational::ShapeFunctionBase<Derived, FES, Variational::TestSpace>, VectorField, Step, BoundaryPolicy>> Type traits for Flow over a shape function: exposes the finite element space, the shape function space and the operand type.
    • struct Traits<Variational::FunctionBase<Derived>> Form-language traits for variational functions.
    • struct Traits<Variational::Grad<Variational::GridFunction<FES, Data>>> Type traits for Grad over a grid function: exposes the finite element space, the operand type and the range type.
    • struct Traits<Variational::Grad<Variational::GridFunction<Variational::P0<Range, Mesh>, Data>>> Type traits for Grad over a grid function: exposes the finite element space and the operand type.
    • struct Traits<Variational::Grad<Variational::ShapeFunction<NestedDerived, FES, Space>>> Type traits for Grad over a shape function: exposes the finite element space, the shape function space, the operand type and the range type.
    • struct Traits<Variational::Grad<Variational::ShapeFunction<NestedDerived, Variational::P0<Range, Mesh>, Space>>> Type traits for Grad over a shape function: exposes the finite element space, the shape function space and the operand type.
    • 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::H1<K, Math::SpatialVector<Scalar>, Mesh>> Type traits for H1: exposes the mesh type, the scalar type, the range type and the finite element type.
    • struct Traits<Variational::H1<K, Scalar, Mesh>> Type traits for H1: exposes the mesh type, the scalar type, the range type and the finite element type.
    • struct Traits<Variational::H1Element<K, Range>> Type traits for H1Element: exposes the scalar type and the range type of the element.
    • struct Traits<Variational::Jacobian<Variational::GridFunction<Variational::H1<K, Range, Mesh>, Data>>> Type traits for Jacobian over a grid function: exposes the finite element space and the operand type.
    • struct Traits<Variational::Jacobian<Variational::GridFunction<Variational::P0g<Range, Mesh>, Data>>> Type traits for Jacobian over a grid function: exposes the finite element space and the operand type.
    • struct Traits<Variational::Jacobian<Variational::GridFunction<Variational::P1<Range, Mesh>, Data>>> Type traits for Jacobian over a grid function: exposes the finite element space and the operand type.
    • struct Traits<Variational::Jacobian<Variational::ShapeFunction<NestedDerived, Variational::H1<K, Range, Mesh>, Space>>> Type traits for Jacobian over a shape function: exposes the finite element space, the shape function space and the operand type.
    • struct Traits<Variational::Jacobian<Variational::ShapeFunction<NestedDerived, Variational::P0g<Range, Mesh>, Space>>> Type traits for Jacobian over a shape function: exposes the finite element space, the shape function space and the operand type.
    • struct Traits<Variational::Jacobian<Variational::ShapeFunction<NestedDerived, Variational::P1<Range, Mesh>, Space>>> Type traits for Jacobian over a shape function: exposes the finite element space, the shape function space and the operand type.
    • struct Traits<Variational::LinearForm<FES, Vector>> Type traits for LinearForm: exposes the finite element space and the vector type.
    • struct Traits<Variational::LinearFormBase<Vector>> Type traits for LinearFormBase: exposes the vector type.
    • struct Traits<Variational::MatrixFunctionBase<Scalar, Derived>> Type traits for MatrixFunctionBase: exposes the scalar type and the derived type.
    • struct Traits<Variational::Mult<Variational::FunctionBase<LHSDerived>, Variational::ShapeFunctionBase<RHSDerived, FES, Space>>> Type traits for Mult over a function expression: exposes the finite element space, the shape function space, the scalar type, the left-hand side operand, the right-hand side operand and the range type.
    • struct Traits<Variational::Mult<Variational::ShapeFunctionBase<LHSDerived, FES, Space>, Variational::FunctionBase<RHSDerived>>> Type traits for Mult over a shape function: exposes the finite element space and the shape function space.
    • struct Traits<Variational::P0<Math::Vector<Number>, Mesh>> Type traits for P0: exposes the mesh type, the scalar type, the range type, the execution context and the finite element type.
    • struct Traits<Variational::P0<Number, Mesh>> Type traits for P0: exposes the mesh type, the scalar type, the range type, the execution context and the finite element type.
    • struct Traits<Variational::P0Element<Range>> Type traits for P0Element: exposes the scalar type and the range type of the element.
    • struct Traits<Variational::P0g<Math::SpatialVector<Number>, Mesh>> Type traits for P0g: exposes the mesh type, the scalar type, the range type, the execution context and the finite element type.
    • struct Traits<Variational::P0g<Number, Mesh>> Type traits for P0g: exposes the mesh type, the scalar type, the range type, the execution context and the finite element type.
    • struct Traits<Variational::P0gElement<Range>> Type traits for P0gElement: exposes the scalar type and the range type.
    • struct Traits<Variational::P1<Math::SpatialVector<Scalar>, Mesh>> Type traits for P1: exposes the mesh type, the scalar type, the range type and the finite element type.
    • struct Traits<Variational::P1<Scalar, Mesh>> Type traits for P1: exposes the mesh type, the scalar type, the range type and the finite element type.
    • struct Traits<Variational::P1Element<Range>> Type traits for P1Element: exposes the scalar type and the range type of the element.
    • struct Traits<Variational::Potential<LHS, Variational::FunctionBase<RHSDerived>>> Traits for Potential operator.
    • struct Traits<Variational::Potential<LHS, Variational::ShapeFunctionBase<Variational::ShapeFunction<RHSDerived, FES, Space>>>> Traits for Potential.
    • struct Traits<Variational::Problem<TrialFunction, TestFunction, LinearSystem>> Form-language traits for a two-field variational problem.
    • struct Traits<Variational::ProblemBase<LinearSystem>> Form-language traits for a problem base.
    • struct Traits<Variational::RealFunctionBase<Derived>> Traits for the CRTP base of real-valued functions.
    • struct Traits<Variational::ScalarFunctionBase<Scalar, Derived>> Type traits for ScalarFunctionBase: exposes the scalar type and the derived type.
    • struct Traits<Variational::ShapeFunction<Derived, FES, Space>> Type traits for ShapeFunction: exposes the derived type, the finite element space, the shape function space, the result type, the range type and the scalar type.
    • struct Traits<Variational::ShapeFunctionBase<Derived, FES, Space>> Type traits for ShapeFunctionBase: exposes the derived type, the finite element space, the shape function space, the result type, the range type and the scalar type.
    • struct Traits<Variational::Sum<Variational::FunctionBase<LHSDerived>, Variational::FunctionBase<RHSDerived>>> Type traits for Sum over a function expression: exposes the left-hand side operand and the right-hand side operand.
    • struct Traits<Variational::Sum<Variational::LinearFormIntegratorBase<LHSNumber>, Variational::LinearFormIntegratorBase<RHSNumber>>> Type traits for Sum over linear form integrators: exposes the left-hand side operand, the right-hand side operand and the scalar type.
    • struct Traits<Variational::Sum<Variational::ShapeFunctionBase<LHSDerived, FES, Space>, Variational::ShapeFunctionBase<RHSDerived, FES, Space>>> Type traits for Sum over a shape function: exposes the finite element space, the left-hand side operand, the right-hand side operand and the shape function space.
    • struct Traits<Variational::TestFunction<FES>> Type traits for TestFunction: exposes the finite element space and the shape function space.
    • struct Traits<Variational::Trace<Variational::ShapeFunctionBase<NestedDerived, FES, Space>>> Type traits for Trace over a shape function: exposes the finite element space and the shape function space.
    • struct Traits<Variational::TrialFunction<Solution, FES>> Type traits for TrialFunction: exposes the finite element space, the shape function space and the solution type.
    • struct Traits<Variational::UnaryMinus<Variational::ShapeFunctionBase<NestedDerived, FES, Space>>> Type traits for UnaryMinus over a shape function: exposes the finite element space and the shape function space.
    • 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.
    • class AABB Bounding-volume-hierarchy point locator over axis-aligned boxes.
      • struct ControlBasis Reference samples and the map taking sampled coordinates to control points of a geometry transformation.
  • 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.
    • class TensorProduct final Cartesian product of two quadrature formulae.
    • class WitherdenVincent final Fully symmetric positive interior quadrature.
    • class XiaoGimbutas final Near-minimal positive interior quadrature on simplices.
  • 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 FollowerPressureForce final Linear-form integrator: follower pressure residual . Add it with "+" to the Problem (it already carries the residual-convention sign of a pressure pushing along the outward normal).
    • class FollowerPressureTangent final Bilinear-form integrator: the EXACT load stiffness of the follower pressure, . Add it with "+" alongside the material tangent. NONSYMMETRIC.
    • 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 Internal virtual work residual integrator family.
    • class InternalVirtualWorkResidual<LawDerived, TestFunctionType, DisplacementType> final Momentum residual (pure displacement formulation).
    • class InternalVirtualWorkResidual<LawDerived, TestFunctionType, DisplacementType, PressureType> final Momentum residual of the mixed u-p formulation. Bound to the displacement test function .
    • class InternalVirtualWorkResidualP Incompressibility constraint residual of the mixed u-p formulation. Bound to the pressure test function .
    • class InternalVirtualWorkTangent Internal virtual work tangent integrator family.
    • class InternalVirtualWorkTangent<LawDerived, TrialFunctionType, TestFunctionType, DisplacementType> final Displacement tangent (pure displacement formulation).
    • class InternalVirtualWorkTangent<LawDerived, TrialFunctionType, TestFunctionType, DisplacementType, PressureType> final Displacement-displacement block of the mixed u-p formulation. Bound to the (u, v) pair.
    • class InternalVirtualWorkTangentPU Pressure-displacement coupling block (linearized incompressibility constraint). Bound to the (u, q) pair: columns are displacement DOFs, rows are pressure test DOFs.
    • class InternalVirtualWorkTangentUP Displacement-pressure coupling block . Bound to the (p, v) pair: columns are pressure DOFs, rows are displacement test DOFs.
    • 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.
    • class Yeoh final Compressible Yeoh hyperelastic law.
      • struct Cache Precomputed cache for the Yeoh 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 Induced dimension reduction iterative solver.
    • 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 Minimum residual iterative solver.
    • 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.
    • namespace F Contains built-in coordinate functions.
      • class X First coordinate projection function.
      • class Y Second coordinate projection function.
      • class Z Second coordinate projection function.
    • class Abs Represents the absolute value of a value.
    • class Abs<FunctionBase<NestedDerived>> Absolute value operation for functions.
    • class AND Represents the logical AND expression.
    • class AND<BooleanFunctionBase<LHSDerived>, BooleanFunctionBase<RHSDerived>> final Logical AND operator between two boolean functions.
    • class Average<FunctionBase<FunctionDerived>> final Average of a FunctionBase instance across an interface.
    • class Average<ShapeFunctionBase<NestedDerived, FES, Space>> final Average of a ShapeFunctionBase instance across an interface.
    • class BernsteinPyramid Bernstein basis on the reference pyramid.
    • class BilinearForm Represents a bilinear form on a trial and test space.
    • 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 BilinearFormIntegratorBase Abstract base class for bilinear form integrators.
    • class BooleanFunction
    • class BooleanFunction<Boolean> final Boolean-valued constant function.
    • class BooleanFunctionBase Base class for boolean-valued functions.
    • struct BoundaryHit Information passed to a boundary policy when a trajectory reaches the domain boundary.
    • class BoundaryIntegral Represents expressions of the integral operator on the boundary of a domain.
    • class BoundaryIntegral<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integration of the dot product of a trial and test operators.
    • class BoundaryIntegral<ShapeFunctionBase<NestedDerived, FES, TestSpace>> final Integration of a test operator.
    • class BoundaryNormal final Outward unit normal vector on domain boundaries.
    • class ComplexFunction
    • class ComplexFunction<Complex> final Represents a constant scalar function with type Complex.
    • class ComplexFunction<F> final Represents a scalar function given by an arbitrary scalar function.
    • class ComplexFunction<FReal, FImag> final Complex function built from real and imaginary callables.
    • class ComplexFunction<FunctionBase<NestedDerived>> final Complex function wrapper around a nested function.
    • class ComplexFunction<FunctionBase<RealNestedDerived>, FunctionBase<ImagNestedDerived>> final Complex function built from real and imaginary functions.
    • class ComplexFunction<Integer> final Complex-valued constant function built from an integer.
    • class ComplexFunction<Real> final Complex-valued constant function built from a real.
    • class ComplexFunctionBase Base class for complex-valued scalar functions.
    • class Component<FunctionBase<OperandDerived>, size_t> final Extracts a single component from a vector-valued function.
    • class Component<FunctionBase<OperandDerived>, size_t, size_t> final Extracts a single entry from a matrix-valued function.
    • class Component<GridFunction<FES, Data>> final Extracts a component from a vector-valued GridFunction.
    • class Component<ShapeFunctionBase<OperandDerived, FES, Space>> final Extracts a component from a vector-valued ShapeFunction.
    • class Composition
    • class Conjugate<FunctionBase<NestedDerived>> Complex conjugate of a function.
    • class Conjugate<ShapeFunctionBase<NestedDerived, FES, Space>> final Specialization for shape functions.
    • class Cos Represents the cosine function.
    • class Cos<FunctionBase<NestedDerived>> final Cosine function operator for real-valued scalar functions.
    • class Cosh<FunctionBase<NestedDerived>> final Hyperbolic cosine function operator for real-valued scalar functions.
    • class DefaultBoundaryPolicy Default boundary policy for flow maps.
    • class DenseProblem<LinearSystem, U, V> General class to assemble linear systems with Math::Matrix and Math::Vector types in a serial context.
    • class Derivative<GridFunction<H1<K, Scalar, Mesh>, Data>> final Derivative of an H1<K> GridFunction.
    • class Derivative<GridFunction<P1<Range, Mesh>, Data>> final Derivative of a P1 GridFunction.
    • class Derivative<ShapeFunction<NestedDerived, FES, SpaceType>> final Partial derivative of a shape function.
    • class DerivativeBase Base class for directional derivative operators.
    • class DerivativeBase<GridFunction<FES, Data>, Derived> CRTP base for the partial derivative of a grid function.
    • class DirichletBC
    • class DirichletBC<TrialFunction<Solution, FES>, FunctionBase<ValueDerived>> final Value-prescribing Dirichlet boundary condition, .
    • class DirichletBC<TrialFunction<Solution, FES1>, ShapeFunctionBase<Derived2, FES2, Sp>> final Identification Dirichlet boundary condition, or .
      • class Defect final Defect a Dirichlet constraint imposes on the trial function.
      • class DefectBase Type-erased base for the defect a Dirichlet constraint imposes.
    • class DirichletBCBase Abstract base class for a Dirichlet boundary condition.
    • class Div Represents the divergence of a vector valued function.
    • class Div<GridFunction<H1<K, Math::SpatialVector<Scalar>, Mesh>, Data>> final Divergence of an H1 vector GridFunction.
    • class Div<GridFunction<P0g<Math::SpatialVector<Scalar>, Mesh>, Data>> final Divergence of a P0g vector GridFunction (identically zero).
    • class Div<GridFunction<P1<Math::SpatialVector<Scalar>, Mesh>, Data>> final Divergence of a P1 vector GridFunction.
    • class Div<ShapeFunction<NestedDerived, H1<K, Math::SpatialVector<Number>, Mesh>, Space>> final Divergence of an H1 vector ShapeFunction.
      • struct Cache Per-cell tabulation cache.
        • struct Key Key identifying a cached tabulation.
    • class Div<ShapeFunction<NestedDerived, P0g<Math::SpatialVector<Scalar>, Mesh>, Space>> final Divergence of a P0g vector ShapeFunction (identically zero).
    • class Div<ShapeFunction<NestedDerived, P1<Math::SpatialVector<Scalar>, Mesh>, Space>> final Divergence of a P1 vector ShapeFunction.
      • struct Cache Per-cell tabulation cache.
        • struct CellKey Key identifying the cell a tabulation was computed for.
        • struct QpKey Key identifying the quadrature point a tabulation was computed for.
    • class DivBase Base class for divergence operator implementations.
    • class DivBase<GridFunction<FES, Data>, Derived> Divergence of a P1 GridFunction.
    • class Division Represents the division operation.
    • class Division<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> Division of a function by another function.
    • class Division<ShapeFunctionBase<LHSDerived, FES, Space>, FunctionBase<RHSDerived>> final Quotient of a shape function.
    • class Dot Represents the dot product between two objects.
    • class Dot<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Dot product between two functions.
    • class Dot<FunctionBase<LHSDerived>, ShapeFunctionBase<RHSDerived, FES, Space>> final Dot product between a function and a shape function.
    • class Dot<Potential<KernelType, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>> Dot product of a potential with a test shape function.
    • class Dot<ShapeFunctionBase<LHSDerived, FES, Space>, FunctionBase<RHSDerived>> final Dot product between a shape function and a function.
    • class Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>> final Dot product of trial and test shape functions for bilinear forms.
    • class DubinerTetrahedron Dubiner orthogonal modal basis on the reference tetrahedron.
    • class DubinerTriangle Dubiner orthogonal modal basis on the reference triangle.
    • class EQ
    • class EQ<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Logical EQ operator between two instances of FunctionBase.
    • class Exp<FunctionBase<NestedDerived>> Exponential function operation.
    • class FaceIntegral Represents expressions of the integral operator on the faces of a mesh.
    • class FaceIntegral<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integration of the dot product of a trial and test operators.
    • class FaceIntegral<ShapeFunctionBase<NestedDerived, FES, TestSpace>> final Integration of a test operator.
    • class FaceNormal Unit normal vector on codimension-one mesh entities.
    • 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 Represernts a finite element space.
    • class FiniteElementSpace<Geometry::Mesh<Context::MPI>, Derived> Represents a finite element space defined on a distributed mesh.
    • class FiniteElementSpaceBase Base class for finite element spaces.
      • struct LocalIndex Local degree of freedom indexing structure.
    • class FiniteElementSpacePullbackBase Base class for mappings taking functions defined on physical elements to reference elements.
    • class FiniteElementSpacePushforwardBase Base class for inverse mappings taking functions defined on reference elements to physical elements.
    • class Flow<FunctionBase<Derived>, VectorField, Step, BoundaryPolicy> Flow map operator for functions.
      • class Trace Result of a characteristic trace.
    • class Frobenius Represents the Frobenius norm.
    • class Frobenius<FunctionBase<NestedDerived>> Frobenius norm of a function.
    • class FunctionBase Base class for function objects which can be evaluated over a mesh.
    • class FunctionBaseCopy
    • class GEQ
    • class GEQ<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Pointwise greater-or-equal comparison of two function expressions.
    • class GLL Compile-time Gauss–Lobatto–Legendre (GLL) nodes on [-1, 1].
    • class GLL01 Gauss–Lobatto–Legendre nodes mapped from [-1, 1] to [0, 1].
    • class GlobalBilinearFormIntegratorBase Base class for bilinear form integrators coupling a trial and a test polytope across the mesh.
    • class Grad Represents the gradient of a scalar function .
    • class Grad<GridFunction<H1<K, Scalar, Mesh>, Data>> final Gradient of a GridFunction on H1<K> space.
    • class Grad<GridFunction<P0<Range, Mesh>, Data>> final Gradient of a P0 GridFunction.
    • class Grad<GridFunction<P0g<Scalar, Mesh>, Data>> final Gradient of a P0g grid function.
    • class Grad<GridFunction<P1<Scalar, Mesh>, Data>> final Gradient of a P1 grid function.
    • class Grad<ShapeFunction<NestedDerived, H1<K, Scalar, Mesh>, SpaceType>> final Gradient of a ShapeFunction on H1<K> space.
      • struct Cache Per-cell tabulation cache.
        • struct Key Key identifying a cached tabulation.
    • class Grad<ShapeFunction<NestedDerived, P0<Scalar, Mesh>, SpaceType>> final Gradient of a P0 ShapeFunction.
    • class Grad<ShapeFunction<NestedDerived, P0g<Scalar, Mesh>, SpaceType>> final Gradient of a P0g shape function.
    • class Grad<ShapeFunction<NestedDerived, P1<Scalar, Mesh>, SpaceType>> final Gradient of a ShapeFunction.
      • struct Cache Per-cell tabulation cache.
        • struct CellKey Key identifying the cell a tabulation was computed for.
        • struct QpKey Key identifying the quadrature point a tabulation was computed for.
    • class GradBase Base class for gradient operator implementations.
    • class GradBase<GridFunction<FES, Data>, Derived> Gradient operator for grid functions.
    • class GridFunction Represents a grid function belonging to some finite element space.
    • 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 grid function objects.
    • class GridFunctionBaseReference Base class for discrete finite element functions.
    • class GT
    • class GT<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Pointwise greater-than comparison of two function expressions.
    • class H1 Degree K H1-conforming Lagrange finite element space.
    • class H1<K, Math::SpatialVector<Scalar>, Geometry::Mesh<Context::Local>> final Vector-valued continuous piecewise polynomial (degree K) Lagrange finite element space.
      • class Pullback Pullback of a vector-valued H1 function to the reference element.
      • class Pushforward Pushforward of a vector-valued H1 function to the physical element.
    • 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::Local>> Degree K H1-conforming Lagrange finite element space.
      • class Cochain Local cochain map for H1 DOF injection from boundary to element.
      • class Pullback Pullback for the scalar/complex H1 space.
      • class Pushforward Inverse Pullback for the scalar/complex H1 space.
    • 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 H1Element Degree k H1-conforming Lagrange element.
      • class BasisFunction Represents a Lagrange basis function of degree K.
        • class DerivativeFunction Represents a partial derivative of a basis function.
        • class GradientFunction Represents the gradient of a basis function.
      • class LinearForm Evaluates linear form at a given function/vector field.
      • struct Tabulation Basis values and derivatives tabulated on the reference element.
    • class H1Element<K, Math::SpatialVector<Scalar>> final Continuous H1-conforming piecewise polynomial (degree k) vector Lagrange element.
      • class BasisFunction Basis function of the vector-valued H1 element.
        • class DerivativeFunction Represents a derivative function of a Pk vector element.
        • class JacobianFunction Jacobian of a vector-valued H1 basis function.
      • class LinearForm Degree-of-freedom functional of the vector-valued H1 element.
    • class IdentityMatrix Represents the identity matrix function .
    • class Im Extracts the imaginary part of a complex-valued function.
    • class Im<FunctionBase<NestedDerived>> Specialization for FunctionBase operands.
    • class IntegerFunction
    • class IntegerFunctionBase Base class for objects representing integer functions.
    • class Integral Represents mathematical expressions of the integral operator on a domain.
    • class Integral<Dot<Potential<Kernel, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integral of a potential tested against a shape function.
    • class Integral<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integration of the dot product of a trial and test operators.
    • class Integral<GridFunction<FES, Data>> final Integration of a GridFunction object.
    • class Integral<ShapeFunctionBase<NestedDerived, FES, TestSpace>> final Integration of a test operator.
    • class IntegrationPoint Evaluation point used by variational operators.
    • class Integrator Abstract base class for integrators in variational formulations.
    • class InterfaceIntegral Represents expressions of the integral operator on the interface of a domain.
    • class InterfaceIntegral<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integration of the dot product of a trial and test operators.
    • class InterfaceIntegral<ShapeFunctionBase<NestedDerived, FES, TestSpace>> final Integration of a test operator.
    • struct IsTestFunction Type trait to check if a type is a TestFunction.
    • struct IsTestFunction<PETSc::Variational::TestFunction<FES>> Marks PETSc test functions as valid test functions.
    • struct IsTestFunction<TestFunction<FES>> Specialization for TestFunction types.
    • struct IsTrialFunction Type trait to check if a type is a TrialFunction.
    • struct IsTrialFunction<PETSc::Variational::TrialFunction<Solution, FES>> Marks PETSc trial functions as valid trial functions.
    • struct IsTrialFunction<TrialFunction<Solution, FES>> Specialization for TrialFunction types.
    • class Jacobian Represents the Jacobian matrix of a type.
    • class Jacobian<GridFunction<H1<K, Math::SpatialVector<Scalar>, Mesh>, Data>> final Jacobian of an H1 vector GridFunction.
    • class Jacobian<GridFunction<P0g<Math::SpatialVector<Scalar>, Mesh>, Data>> final Jacobian of a P0g vector GridFunction (identically zero).
    • class Jacobian<GridFunction<P1<Math::SpatialVector<Scalar>, Mesh>, Data>> final Jacobian of a P1 vector GridFunction.
    • class Jacobian<ShapeFunction<NestedDerived, H1<K, Math::SpatialVector<Scalar>, Mesh>, Space>> final Jacobian of an H1 ShapeFunction object.
      • struct Cache Per-cell tabulation cache.
        • struct Key Key identifying a cached tabulation.
    • class Jacobian<ShapeFunction<ShapeFunctionDerived, P0g<Math::SpatialVector<Scalar>, Mesh>, Space>> final Jacobian of a P0g vector ShapeFunction (identically zero).
    • class Jacobian<ShapeFunction<ShapeFunctionDerived, P1<Range, Mesh>, Space>> final Jacobian of an P1 ShapeFunction object.
      • struct Cache Per-cell tabulation cache.
        • struct CellKey Key identifying the cell a tabulation was computed for.
        • struct QpKey Key identifying the quadrature point a tabulation was computed for.
    • class JacobianBase Base class for Jacobian matrix operator implementations.
    • class JacobianBase<GridFunction<FES, Data>, Derived> Jacobian of a P1 GridFunction.
    • class JacobiPolynomial Jacobi polynomial evaluator.
    • class Jump<FunctionBase<FunctionDerived>> final Jump of a FunctionBase instance across an interface.
    • class Jump<ShapeFunctionBase<NestedDerived, FES, Space>> final Jump of a ShapeFunctionBase instance across an interface.
    • class L2 Arbitrary order broken Sobolev space.
    • class LagrangeBasis1D Generic 1D Lagrange basis on arbitrary nodes.
    • class LagrangeBasisPoint Lagrange basis on the reference point (0D element).
    • class LagrangeBasisQuadrilateral Lagrange basis on the reference quadrilateral [0,1]².
    • class LagrangeBasisSegment Lagrange basis on the reference segment [0,1] using GLL nodes.
    • class LagrangeBasisTetrahedron Lagrange basis on the reference tetrahedron.
    • class LagrangeBasisTriangle Lagrange basis on the reference triangle.
    • class LagrangeBasisWedge Lagrange basis on the reference wedge (triangular prism).
    • class LegendrePolynomial Compile-time degree Legendre polynomial evaluator.
    • class LEQ
    • class LEQ<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Pointwise less-or-equal comparison of two function expressions.
    • 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 Represents a linear form on some finite element space.
    • class LinearForm<FES, ::Vec> final Linear form specialization that assembles into a PETSc vector.
    • class LinearForm<FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>> final Represents a linear form defined over some finite element space.
    • class LinearFormBase Base class for linear form objects.
    • class LinearFormIntegratorBase Base class for linear form integrators.
    • class LocalBilinearFormIntegratorBase Base class for bilinear form integrators whose trial and test functions live on the same polytope.
    • class LT
    • class LT<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Pointwise less-than comparison of two function expressions.
    • class MatrixFunction
    • class MatrixFunction<Math::Matrix<Scalar>> final Matrix-valued constant function.
    • class MatrixFunctionBase Base class for matrix-valued functions defined on a mesh.
    • class Max<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Represents the maximum operation between two functions.
    • class Max<FunctionBase<NestedDerived>, Real> Pointwise maximum of a function expression and a real.
    • class Max<Real, FunctionBase<NestedDerived>> Pointwise maximum of a function expression.
    • class Min<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Represents the minimum operation between two functions.
    • class Min<FunctionBase<NestedDerived>, Real> Pointwise minimum of a function expression.
    • class Min<Real, FunctionBase<NestedDerived>> Pointwise minimum of a function expression.
    • class Mult Represents the multiplication operation.
    • class Mult<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Multiplication of two FunctionBase instances.
    • class Mult<FunctionBase<LHSDerived>, ShapeFunctionBase<RHSDerived, FES, Space>> final Left Multiplication of a ShapeFunctionBase by a FunctionBase.
    • class Mult<LHS, LinearFormIntegratorBase<RHSNumber>> Product expression.
    • class Mult<LHS, LocalBilinearFormIntegratorBase<RHSNumber>> Product expression.
    • class Mult<ShapeFunctionBase<LHSDerived, FES, Space>, FunctionBase<RHSDerived>> final Right multiplication of a ShapeFunctionBase by a FunctionBase.
    • class NEQ
    • class NEQ<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Logical NEQ operator between two instances of FunctionBase.
    • class NonLinearFormIntegrator CRTP mixin for nonlinear form integrators.
    • class OR
    • class OR<BooleanFunctionBase<LHSDerived>, BooleanFunctionBase<RHSDerived>> final Logical OR operator between two instances of BooleanFunctionBase.
    • 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 P0<Real, Geometry::Mesh<Context::Local>> final Scalar-valued piecewise constant (P0) Lagrange finite element space.
      • class Pullback Pullback of a P0 function to the reference element.
      • class Pushforward Pushforward of a P0 function to the physical element.
    • class P0Element Degree 0 Lagrange element.
      • class BasisFunction Represents the constant basis function of a P0 scalar element.
        • class DerivativeFunction Represents a derivative of the P0 basis function (always zero).
      • class LinearForm Represents a linear form of a P0 scalar element.
    • class P0Element<Math::SpatialVector<Scalar>> final Piecewise constant (degree 0) vector Lagrange element.
      • class BasisFunction Represents a piecewise constant vector basis function.
        • class DerivativeFunction Represents a derivative of the vector P0 basis function (always zero).
      • class LinearForm Represents a linear form (evaluation functional) for vector P0 elements.
    • class P0g Forward declaration of global constant finite element spaces.
    • class P0g<Math::SpatialVector<Real>, Geometry::Mesh<Context::Local>> final Cellwise-constant vector-valued finite element space with a global basis.
      • class Pullback Pullback of a vector-valued P0g function to the reference element.
      • class Pushforward Pushforward of a vector-valued P0g function to the physical 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::Local>> final Cellwise-constant scalar finite element space with a global basis.
      • class Pullback Pullback of a P0g function to the reference element.
      • class Pushforward Pushforward of a P0g function to the physical element.
    • class P0g<Real, Geometry::Mesh<Context::MPI>> final Distributed scalar P0g finite element space for MPI meshes.
    • class P0gElement Forward declaration of global P0 finite elements.
      • class BasisFunction Basis function of the P0g element.
        • class DerivativeFunction Derivative of a P0g basis function, identically zero.
      • class LinearForm Degree-of-freedom functional of the P0g element.
    • class P0gElement<Math::SpatialVector<Scalar>> final Vector-valued cellwise-constant finite element.
      • class BasisFunction Basis function of the vector-valued P0g element.
        • class DerivativeFunction Derivative of a vector-valued P0g basis function, identically zero.
      • class LinearForm Degree-of-freedom functional of the vector-valued P0g element.
    • class P1 Degree 1 Lagrange finite element space.
    • class P1<Math::SpatialVector<Scalar>, Geometry::Mesh<Context::Local>> final Vector-valued continuous piecewise linear Lagrange finite element space.
      • class Pullback Pullback of a vector-valued P1 function to the reference element.
      • class Pushforward Pushforward of a vector-valued P1 function to the physical element.
    • 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 P1<Scalar, Geometry::Mesh<Context::Local>> Real valued Lagrange finite element space.
      • class Pullback Pullback for the scalar/complex P1 space.
      • class Pushforward Inverse Pullback for the scalar/complex P1 space.
    • class P1Element Degree 1 Lagrange element.
      • class BasisFunction Represents a piecewise linear basis function of a P1 scalar element.
        • class DerivativeFunction Represents a partial derivative of a P1 basis function.
        • class GradientFunction Represents the gradient of a P1 basis function.
      • class LinearForm Represents a linear form of a P1 scalar element.
    • class P1Element<Math::SpatialVector<Scalar>> final Continuous piecewise linear (degree 1) vector Lagrange element.
      • class BasisFunction Basis function of the vector-valued P1 element.
        • class DerivativeFunction Represents a derivative function of a P1 vector element.
        • class JacobianFunction Jacobian of a vector-valued P1 basis function.
      • class LinearForm Degree-of-freedom functional of the vector-valued P1 element.
    • class PeriodicBC<TrialFunction<Solution, FES>, IndexMap<IndexSet>> final Represents a Peridodic boundary condition on a ShapeFunction object.
    • class PeriodicBCBase Abstract base class for a periodic boundary condition.
    • class Potential<LHS, FunctionBase<RHSDerived>> final Potential of a function expression against a kernel.
    • class Potential<LHS, ShapeFunctionBase<ShapeFunction<RHSDerived, FES, SpaceType>, FES, SpaceType>> final
    • class Pow Represents the power function.
    • class Pow<FunctionBase<BaseDerived>, Number> final Represents the power function.
    • class Problem Represents a variational problem.
    • class Problem<LinearSystem, TrialFunction, TestFunction> Two-field variational problem.
    • class Problem<LinearSystem, U1, U2, U3, Us...> Variational problem in three or more unknown fields.
    • 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 ProblemBase Base class for variational problem objects.
    • class ProblemBody Accumulated bilinear forms, linear forms and boundary conditions of a Problem.
    • class ProblemBody<Operator, void, Scalar> Problem body containing operator terms only.
    • class ProblemBody<void, Vector, Scalar> Problem body containing vector terms only.
    • class ProblemBody<void, void, Scalar> Problem body containing only integrators and boundary conditions.
    • class ProblemBodyBase Base class representing the body of a variational problem.
    • class ProblemUsBase Base for mixed variational problems with three or more functions.
    • class ProblemUVBase General class to assemble linear systems with Operator and Vector generic types in a sequential context.
    • struct PyramidIndex Indexing of the tensor-product modes on the reference pyramid.
      • struct IJ Pair of tensor-product indices of a pyramid mode.
    • class PyramidModal Modal basis on the reference pyramid.
    • class QuadratureRule
    • class QuadratureRule<Dot<Potential<Kernel, ShapeFunctionBase<LHSDerived, P1<Range, Mesh>, TrialSpace>>, ShapeFunctionBase<RHSDerived, P1<Range, Mesh>, TestSpace>>> Specialization for in the case of P1 trial/test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Div<ShapeFunction<LHSDerived, H1<KTrial, TrialRange, Mesh>, TrialSpace>>, H1<KTrial, TrialRange, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, TestRange, Mesh>, TestSpace>, H1<KTest, TestRange, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Div<ShapeFunction<LHSDerived, P1<Math::SpatialVector<Real>, LHSMesh>, TrialSpace>>, P1<Math::SpatialVector<Real>, LHSMesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Real, RHSMesh>, TestSpace>, P1<Real, RHSMesh>, TestSpace>>> Specialization for in the case of P1 shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Dot<FunctionBase<CoeffDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Dot<FunctionBase<CoeffDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>> Integration of a rank-one form in the H1 Jacobian of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Dot<FunctionBase<CoeffDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Dot<FunctionBase<CoeffDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of a rank-one form in the P1 Jacobian of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the isotropic Dot product of two instances of the P1 Grad of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the isotropic Frobenius inner product two instances of the P1 Jacobian of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> Local bilinear-form quadrature for the dot product of a trial and a test shape function.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the anisotropic Dot product of two instances of the P1 Grad of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the anisotropic Frobenius inner product two instances of the P1 Jacobian of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the anisotropic Dot product of two instances of the P1 ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, FunctionBase<CoefficientDerived>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, FunctionBase<CoefficientDerived>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>, P1<RHSRange, RHSMesh>, TestSpace>>> Specialization for in the case of P1 shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, TrialRange, Mesh>, TrialSpace>, H1<KTrial, TrialRange, Mesh>, TrialSpace>, ShapeFunctionBase<Div<ShapeFunction<RHSDerived, H1<KTest, TestRange, Mesh>, TestSpace>>, H1<KTest, TestRange, Mesh>, TestSpace>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the isotropic Dot product of two instances of the P1 ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Real, LHSMesh>, TrialSpace>, P1<Real, LHSMesh>, TrialSpace>, ShapeFunctionBase<Div<ShapeFunction<RHSDerived, P1<Math::SpatialVector<Real>, RHSMesh>, TestSpace>>, P1<Math::SpatialVector<Real>, RHSMesh>, TestSpace>>> Specialization for in the case of P1 shape functions.
    • class QuadratureRule<FunctionBase<FunctionDerived>> final Quadrature rule for integrating general functions on mesh polytopes.
    • class QuadratureRule<GridFunction<FES, Data>> Integration of a scalar grid function over a mesh region.
    • class QuadratureRule<Mult<FunctionBase<CoefficientDerived>, Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>>> Specialization for with H1 trial and test shape functions.
    • class QuadratureRule<Mult<FunctionBase<CoefficientDerived>, Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>, P1<RHSRange, RHSMesh>, TestSpace>>>> Specialization for in the case of P1 shape functions.
    • class QuadratureRule<ShapeFunctionBase<Dot<FunctionBase<LHSDerived>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<K, Scalar, Mesh>, TestSpace>, H1<K, Scalar, Mesh>, TestSpace>>, H1<K, Scalar, Mesh>, TestSpace>> Specialization for with an H1 test shape function.
    • class QuadratureRule<ShapeFunctionBase<Dot<FunctionBase<LHSDerived>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>, P1<Range, Mesh>, TestSpace>>, P1<Range, Mesh>, TestSpace>> Integration of the Dot product of some coefficient function and a P1 ShapeFunction.
    • class QuadratureRule<ShapeFunctionBase<NestedDerived, FES, TestSpace>> Local linear-form quadrature for a test shape function expression.
    • class QuadratureRule<ShapeFunctionBase<ShapeFunction<NestedDerived, H1<K, Scalar, Mesh>, TestSpace>, H1<K, Scalar, Mesh>, TestSpace>> Specialization for with an H1 test shape function.
    • class QuadratureRule<ShapeFunctionBase<ShapeFunction<NestedDerived, P1<Range, Mesh>, TestSpace>, P1<Range, Mesh>, TestSpace>> Integration of a P1 ShapeFunction.
    • class Re Extracts the real part of a complex-valued function.
    • class Re<FunctionBase<NestedDerived>> Specialization for FunctionBase operands.
    • class RealFunction
    • 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 functions defined on a mesh.
    • class RelativeError Utility class for computing relative errors.
    • class ScalarFunctionBase Base class for scalar-valued functions with templated scalar type.
    • class ShapeFunction
    • class ShapeFunction<Derived, H1<K, Math::SpatialVector<Scalar>, Mesh>, Space> Shape function of a vector-valued H1 finite element space.
      • struct Cache Per-cell tabulation cache.
        • struct Key Key identifying a cached tabulation.
    • class ShapeFunction<Derived, H1<K, Scalar, Mesh>, Space> Shape function expression.
      • struct Cache Per-cell tabulation cache.
        • struct Key Key identifying a cached tabulation.
    • class ShapeFunction<Derived, P0<Range, Mesh>, Space> Shape function expression.
      • struct Cache Per-cell tabulation cache.
        • struct Key Key identifying a cached tabulation.
    • class ShapeFunction<Derived, P0g<Range, Mesh>, Space> Shape function expression.
      • struct VectorCache Cached per-cell values of a vector-valued P0g shape function.
    • class ShapeFunction<Derived, P1<Range, Mesh>, Space> Shape function expression.
      • struct Cache Per-cell tabulation cache.
        • struct StructureKey Key identifying the cached element structure.
        • struct ValueKey Key identifying the cached shape function values.
    • class ShapeFunctionBase Base class for shape function objects.
    • class Sin<FunctionBase<NestedDerived>> final Sine function operator for real-valued scalar functions.
    • class Sinh<FunctionBase<NestedDerived>> final Hyperbolic sine function operator for real-valued scalar functions.
    • class SparseProblem<LinearSystem, U, V> General class to assemble linear systems with Math::SparseMatrix and Math::Vector types in a serial context.
    • class Sqrt<FunctionBase<NestedDerived>> final Square root operation for functions.
    • class Sum Represents the sum operation.
    • class Sum<BilinearFormBase<Operator>, BilinearFormBase<Operator>> Sum expression.
    • class Sum<FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>, FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>> Sum of two lists of linear form integrators.
    • class Sum<FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>, LinearFormIntegratorBase<RHSNumber>> Sum of a list of linear form integrators and a single one.
    • class Sum<FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>, FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>> Sum of two lists of bilinear form integrators.
    • class Sum<FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>, LocalBilinearFormIntegratorBase<RHSNumber>> Sum of a list of bilinear form integrators and a single one.
    • class Sum<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Addition of two functions.
    • class Sum<LinearFormIntegratorBase<LHSNumber>, FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>> Sum of a linear form integrator and a list of them.
    • class Sum<LinearFormIntegratorBase<LHSNumber>, LinearFormIntegratorBase<RHSNumber>> Sum expression.
    • class Sum<LocalBilinearFormIntegratorBase<LHSNumber>, FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>> Sum of a bilinear form integrator and a list of them.
    • class Sum<LocalBilinearFormIntegratorBase<LHSNumber>, LocalBilinearFormIntegratorBase<RHSNumber>> Sum expression.
    • class Sum<ShapeFunctionBase<LHSDerived, FES, Space>, ShapeFunctionBase<RHSDerived, FES, Space>> final Addition of two shape functions.
    • class Tan Represents the tangent function.
    • class Tan<FunctionBase<NestedDerived>> Tangent function operator for real-valued scalar functions.
    • class TestFunction Represents a function which belongs to a test space.
    • class TestFunctionMismatchException Raised when an expression is combined with a foreign test function.
    • class TetrahedronBlend Optimized blending parameter α for tetrahedral warp-blend.
    • class Trace Represents the trace of a matrix function.
    • class Trace<FunctionBase<NestedDerived>> final Trace of a FunctionBase instance.
    • class Trace<ShapeFunctionBase<NestedDerived, FES, Space>> final Trace of a shape function.
    • class TraceOperator<FunctionBase> Trace (boundary restriction) operator for functions.
    • class Transpose Represents the transpose matrix of some matrix .
    • class Transpose<FunctionBase<NestedDerived>> final Transpose of a matrix-valued function.
    • class Transpose<ShapeFunctionBase<NestedDerived, FES, Space>> final Transpose of a matrix-valued ShapeFunction.
    • class TrialFunction Represents a function which belongs to a trial space.
    • class TrialFunctionMismatchException Raised when an expression is combined with a foreign trial function.
    • class TrialFunctionReference Reference wrapper for trial functions.
    • class TriangleBlend Optimized blending parameter α for triangular warp-blend.
    • class UnaryMinus Represent the negation of an operand.
    • class UnaryMinus<FormLanguage::List<LinearFormIntegratorBase<Number>>> Negation of a list of linear form integrators.
    • class UnaryMinus<FormLanguage::List<LocalBilinearFormIntegratorBase<Number>>> Negation of a list of bilinear form integrators.
    • class UnaryMinus<FunctionBase<NestedDerived>> final Negation of a function.
    • class UnaryMinus<LinearFormIntegratorBase<Number>> final Negation of a linear form integrator.
    • class UnaryMinus<LocalBilinearFormIntegratorBase<Number>> Negation of a bilinear form integrator.
    • class UnaryMinus<ShapeFunctionBase<NestedDerived, FES, Space>> final Negation of a shape function.
    • class UndeterminedTraceDomainException Raised when the trace of a function is taken without a determined domain.
    • class VandermondePyramid Vandermonde matrix of the modal basis on the reference pyramid.
    • class VandermondeTetrahedron Vandermonde matrix of the Dubiner basis on the reference tetrahedron.
    • class VandermondeTriangle Vandermonde matrix for nodal-to-modal transformation on triangles.
    • class VectorFunction
    • 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 WarpBlendTetrahedron Applies warp-blend algorithm to move tetrahedron nodes toward Fekete positions.
    • class WarpBlendTriangle Applies warp-blend algorithm to move triangle nodes toward Fekete positions.
    • class WarpFactor1D Computes the 1D warp factor for moving equispaced nodes to GLL positions.
    • class WarpShiftFace2D Computes 2D warp-blend shift for a triangular face.
    • class WarpShiftFace3D Computes 3D warp-blend shift for a tetrahedral face.
    • class Zero<Math::SpatialVector<Scalar>> final Vector zero function.
    • class Zero<Scalar> final Scalar zero function.
  • 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.