Classes

• namespace Rodin The Rodin library for finite element methods and shape optimization.
  • namespace Adaptation Mesh adaptation and deformation operations.
    • namespace SWIFT Robust interface fitting with a fitting–distribution metric.
      • class Adapt Mesh-fitting workflow selected by mesh context.
      • class Adapt<Mesh, Context::Local> final Owns the local P1 fitting setup and displaces the supplied mesh.
      • struct AdmissibilityReport Sampled geometric admissibility diagnostics.
      • class CurrentInverse Frozen inverse deformation gradient, expressed as a form-language coefficient.
      • class Distribution final Sparse core of the frozen centered current-strain bilinear form.
      • class FittingForce final Negative first-variation coefficient of the robust interface energy.
      • class FittingTensor final Matrix coefficient of the SWIFT surface fitting metric. Hessian of half the squared residual, with omitted and fixed gradient-scale normalization.
      • class HingeForce final Hinge contribution to the next primal Newton iterate.
      • class HingeMetric final Hessian of the affine quadratic quality hinges.
      • class HingeProblem final Native variational tangent problem for the affine quadratic hinges.
      • class HingeState Pointwise slacks and Newton coefficients of the affine quadratic hinges.
      • class LinearSolver final Linear solve of the local SWIFT metric or hinge tangent.
      • class Loss Fixed-scale Welsch loss with consistent influence and curvature.
      • struct Parameters Runtime parameters controlling SWIFT assembly and iteration.
        • struct Convergence Accuracy requirements and independent work budgets.
          • struct Iterations Independent limits for fitting, Newton, linear solves and searches.
          • struct Tolerance Geometric success, stationarity and best-effort exit tolerances.
        • struct Globalization Directional scaling and actual trial acceptance.
        • struct Linear Linear backend selection and thread policy.
        • struct Model Coefficients, reference scale and admissible geometry of the model.
          • struct Distribution Global strain-variation weights, each assembled with h.
          • struct Hinge Independent constraint strengths relative to predicted decrease.
        • struct Quadrature Integration and independent geometry-validation orders.
        • struct Sampling Shared reference witnesses for hinges and actual-quality checks.
      • class Problem Strain-distributed Welsch Implicit-interface Fitting Technique (SWIFT).
      • class QualityCovering final Cached closed-form reference coverings with equal positive base weights.
      • class QualitySamples Common witnesses for affine hinges and actual quality checks.
      • struct Report Diagnostics produced by a SWIFT solve.
      • class ResidualState Pointwise robust residual state at a deformed interface point.
      • class WitnessLattice final Cached generating lattice for reference coverings and offline comparisons.
    • class CellDeformation Lazily evaluated deformation state of a mesh cell.
    • class DeformationMap The deformation induced by a displacement.
  • namespace Advection Transport and advection of fields.
    • 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 Contextual exceptions and diagnostic reporting.
    • 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 Internal::CanBeOutput Type trait to check if a type can be output to a stream.
    • 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 Global assembly of discrete operators.
    • 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, Form> Base class for the assembly of a named bilinear form.
    • 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 with OpenMP enabled.
    • class Default<Context::Local, Context::Local> Default assembly strategy for mixed local contexts with OpenMP enabled.
    • 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, Form> final MPI PETSc assembly using a named form's local kernel.
    • 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 MPIBoundaryDOFs Selects boundary DOF functionals using the existing mesh overlap.
    • class MPIIteration Iteration helper over a region of an MPI mesh shard.
    • class OpenMP OpenMP-based parallel assembly implementation.
    • 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<Scalar>, Form> final Assembly of a named bilinear form into a sparse matrix over OpenMP threads.
    • 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<Math::SparseTriplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>, Variational::BilinearForm<Solution, TrialFES, TestFES, std::vector<Math::SparseTriplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>>> final OpenMP-based parallel assembly for bilinear forms.
    • class OpenMP<::Mat, Form> final OpenMP PETSc assembly using a named form's local kernel.
    • 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 OpenMPIteration OpenMP-based parallel mesh iteration strategy.
    • 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 ScatterMap Cached map from polytope-local matrix entries into the value array of an assembled Math::SparseMatrix.
    • 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<Scalar>, Form> final Assembly of a named bilinear form into a sparse matrix over a single thread.
    • 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<Math::SparseTriplet<Real>>, Tuple<Variational::BilinearForm<Solution, TrialFES, TestFES, std::vector<Math::SparseTriplet<Real>>>...>> final Sequential block bilinear form assembly into Eigen triplets.
    • class Sequential<std::vector<Math::SparseTriplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>, Variational::BilinearForm<Solution, TrialFES, TestFES, std::vector<Math::SparseTriplet<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, Form> final Sequential PETSc assembly using a named form's local kernel.
    • 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 Execution contexts for local and distributed computation.
    • 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 Distance-field computations.
    • 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 Eikonal equations and distance propagation.
    • 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 FormLanguage Typed expressions for constructing variational forms.
    • 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 FunctionDerived Derived type D of the Variational::FunctionBase<D> that T inherits from.
    • struct IsEigenObject Type trait to check if a type is an Eigen object.
    • struct IsInterfaceShapeFunction Detects shape expressions whose basis spans two incident cells.
    • struct IsInterfaceShapeFunction<Variational::Average<Variational::ShapeFunctionBase<Derived, FES, Space>>> Propagates two-cell support through a shape expression.
    • struct IsInterfaceShapeFunction<Variational::Component<Operand, Indices...>> Propagates support through component selection.
    • struct IsInterfaceShapeFunction<Variational::Conjugate<Operand>> Propagates the operand's support through a unary expression.
    • struct IsInterfaceShapeFunction<Variational::Derivative<Operand>> Propagates the operand's support through a unary expression.
    • struct IsInterfaceShapeFunction<Variational::Div<Operand>> Propagates the operand's support through a unary expression.
    • struct IsInterfaceShapeFunction<Variational::Division<LHS, RHS>> Detects two-cell support in either binary operand.
    • struct IsInterfaceShapeFunction<Variational::Dot<LHS, RHS>> Detects two-cell support in either binary operand.
    • struct IsInterfaceShapeFunction<Variational::Grad<Operand>> Propagates the operand's support through a unary expression.
    • struct IsInterfaceShapeFunction<Variational::Jacobian<Operand>> Propagates the operand's support through a unary expression.
    • struct IsInterfaceShapeFunction<Variational::Jump<Variational::ShapeFunctionBase<Derived, FES, Space>>> Propagates two-cell support through a shape expression.
    • struct IsInterfaceShapeFunction<Variational::Mult<LHS, RHS>> Detects two-cell support in either binary operand.
    • struct IsInterfaceShapeFunction<Variational::ShapeFunctionBase<Derived, FES, Space>> Propagates two-cell support through a shape expression.
    • struct IsInterfaceShapeFunction<Variational::Sum<LHS, RHS>> Detects two-cell support in either binary operand.
    • struct IsInterfaceShapeFunction<Variational::Trace<Operand>> Propagates the operand's support through a unary expression.
    • struct IsInterfaceShapeFunction<Variational::Transpose<Operand>> Propagates the operand's support through a unary expression.
    • struct IsInterfaceShapeFunction<Variational::UnaryMinus<Operand>> Propagates the operand's support through a unary expression.
    • struct IsMatrixRange Type trait: whether T has matrix range (a spatial matrix or a multi-column Eigen object).
    • struct IsNamedForm Type trait: whether T is a named bilinear form.
    • struct IsNamedForm<Variational::DiffusionForm<Solution, TrialFES, TestFES, Operator, CoefficientDerived>> Marks Variational::DiffusionForm as a named form.
    • struct IsNamedForm<Variational::HelmholtzForm<Solution, TrialFES, TestFES, Operator, DiffusionDerived, MassDerived>> Marks Variational::HelmholtzForm as a named form.
    • struct IsNamedForm<Variational::LinearElasticityForm<Solution, FES, Operator, LambdaDerived, MuDerived>> Marks Variational::LinearElasticityForm as a named form.
    • struct IsNamedForm<Variational::MassForm<Solution, TrialFES, TestFES, Operator, CoefficientDerived>> Marks Variational::MassForm as a named form.
    • 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 IsTensorRange Type trait: whether T has vector range (a spatial vector or a single-column Eigen object).
    • struct IsTensorRange<Math::SpatialTensor<Scalar, Rank>> Matrix-range finite element or expression specialization.
    • struct IsVectorRange Matrix-range finite element or expression specialization.
    • 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 NamedFormOperatorType Selects named-form operators from the trial solution type.
    • struct NamedFormOperatorType<Solution, Scalar> Selects PETSc operators for PETSc trial coefficient storage.
    • 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::SpatialTensor<Scalar, Rank>> Range type for FunctionBase.
    • struct RangeOf<Math::SpatialVector<Scalar>> Range type deduced for Math::SpatialVector.
    • struct RangeOf<Real> Range type for Real values.
    • struct RangeOf<Variational::FunctionBase<Derived>> Type traits for the matrix or tensor expression specialization.
    • 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<Adaptation::SWIFT::LinearSolver<LinearSystem>> Native solver traits for the SWIFT linear adapter.
    • struct Traits<Boolean> Traits specialization for Boolean type.
    • struct Traits<Complex> Traits specialization for Complex type.
    • struct Traits<Eigen::Matrix<Number, Rows, 1, Options, MaxRows, 1>> Scalar type of an Eigen column vector, including bounded vectors.
    • struct Traits<Eigen::Matrix<Number, Rows, Cols, Options, MaxRows, MaxCols>> Scalar type of a native Eigen dense matrix, including fixed and bounded types.
    • struct Traits<Geometry::Mesh<Context>> Traits specialization for Mesh types.
    • struct Traits<Integer> Traits specialization for Integer type.
    • struct Traits<Math::FixedSizeMatrix<Number, Rows, Cols>> Scalar type of a fixed-size Rodin dense matrix.
    • 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::SpatialTensor<Scalar, Rank>> Type traits for the matrix or tensor expression specialization.
    • 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<FES, Data>>> Type traits for the matrix or tensor expression specialization.
    • 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<Derived, FES, Space>>> Type traits for the matrix or tensor expression specialization.
    • 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::DiffusionForm<Solution, TrialFES, TestFES, Operator, CoefficientDerived>> Traits of a Variational::DiffusionForm.
    • struct Traits<Variational::Div<Variational::GridFunction<FES, Data>>> Type traits for the matrix or tensor expression specialization.
    • 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<Derived, FES, Space>>> Type traits for the matrix or tensor expression specialization.
    • 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::H1<K, Math::SpatialMatrix<Scalar>, Mesh>, Data>>> Rank-three physical gradient range for the matrix H1 solution.
    • struct Traits<Variational::Grad<Variational::GridFunction<Variational::P0<Math::SpatialMatrix<Scalar>, Mesh>, Data>>> Rank-three physical gradient range for the matrix P0 solution.
    • 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::GridFunction<Variational::P0g<Math::SpatialMatrix<Scalar>, Mesh>, Data>>> Rank-three physical gradient range for the matrix P0g solution.
    • struct Traits<Variational::Grad<Variational::GridFunction<Variational::P1<Math::SpatialMatrix<Scalar>, Mesh>, Data>>> Rank-three physical gradient range for the matrix P1 solution.
    • struct Traits<Variational::Grad<Variational::ShapeFunction<Derived, Variational::H1<K, Math::SpatialMatrix<Scalar>, Mesh>, Space>>> Rank-three physical gradient range for matrix H1 shape functions.
    • struct Traits<Variational::Grad<Variational::ShapeFunction<Derived, Variational::P0<Math::SpatialMatrix<Scalar>, Mesh>, Space>>> Rank-three physical gradient range for matrix P0 shape functions.
    • struct Traits<Variational::Grad<Variational::ShapeFunction<Derived, Variational::P0g<Math::SpatialMatrix<Scalar>, Mesh>, Space>>> Rank-three physical gradient range for matrix P0g shape functions.
    • struct Traits<Variational::Grad<Variational::ShapeFunction<Derived, Variational::P1<Math::SpatialMatrix<Scalar>, Mesh>, Space>>> Rank-three physical gradient range for matrix P1 shape functions.
    • 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::SpatialMatrix<Scalar>, Mesh>> Type traits for the matrix or tensor expression specialization.
    • 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::HelmholtzForm<Solution, TrialFES, TestFES, Operator, DiffusionDerived, MassDerived>> Traits of a Variational::HelmholtzForm.
    • struct Traits<Variational::Jacobian<Variational::GridFunction<FES, Data>>> Type traits for the matrix or tensor expression specialization.
    • 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<Derived, FES, Space>>> Type traits for the matrix or tensor expression specialization.
    • 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::LinearElasticityForm<Solution, FES, Operator, LambdaDerived, MuDerived>> Traits of a Variational::LinearElasticityForm.
    • 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::MassForm<Solution, TrialFES, TestFES, Operator, CoefficientDerived>> Traits of a Variational::MassForm.
    • 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::SpatialMatrix<Scalar>, Mesh>> Type traits for the matrix or tensor expression specialization.
    • struct Traits<Variational::P0<Math::SpatialVector<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::SpatialMatrix<Scalar>, Mesh>> Type traits for the matrix or tensor expression specialization.
    • 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::SpatialMatrix<Scalar>, Mesh>> Type traits for the matrix or tensor expression specialization.
    • 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 Meshes, geometric transformations, and mapped evaluation.
    • namespace Euclidean Module for dealing with Euclidean geometries.
      • class Base Base class for Euclidean geometric objects using CRTP.
      • class Box Closed axis-aligned box .
      • struct HasConnectMethod Type trait to detect if a type has a connect method.
      • struct HasConnectMethod<T, OtherGeometry, std::void_t<decltype(std::declval<T>().connect(std::declval<const OtherGeometry&>()))>> Specialization when connect method exists.
      • struct HasDistanceMethod Type trait to detect if a type has a distance method.
      • struct HasDistanceMethod<T, OtherGeometry, std::void_t<decltype(std::declval<T>().distance(std::declval<const OtherGeometry&>()))>> Specialization when distance method exists.
      • struct HasIntersectMethod Type trait to detect if a type has an intersect method.
      • struct HasIntersectMethod<T, OtherGeometry, std::void_t<decltype(std::declval<T>().intersect(std::declval<const OtherGeometry&>()))>> Specialization when intersect method exists.
      • class Hyperplane Affine hyperplane .
      • class Line Affine line in a compile-time Euclidean dimension. with nonzero direction . Projection uses the Euclidean inner product. Closest points use direct formulas through dimension three and a fixed-size QR solve in higher dimensions. Unit direction columns use a rank threshold of twice scalar machine epsilon (relative to the largest QR pivot in higher dimensions). Numerically parallel directions have rank below two and admit no unique line intersection. Intersections return only unique points; coincident lines return no point.
      • class LineSegment Segment between distinct endpoints. The closed segment corresponds to ; parameter evaluation also accepts extrapolation. Storage has exactly Dimension components. Intersection returns a point only when unique, including a shared endpoint of collinear segments; positive-length overlaps return no unique point.
      • class Point Point with compile-time fixed coordinate storage. Arithmetic applies componentwise; subtracting two points yields a spatial displacement. The template dimension is a nonnegative compile-time coordinate count.
      • class Sphere Sphere in a compile-time ambient dimension. In one dimension the sphere comprises two endpoints; in two it is a circle.
    • class AttributeIndex Attribute indexing for mesh polytopes.
    • class BalancedCompactPartitioner Partitioner that creates balanced, spatially compact partitions.
    • class BoundedIndexGenerator final Index generator for a bounded range of indices.
    • class Bounds A conservative convex enclosure described by support bounds.
    • 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 Mesh-aware binary Potts classifier selected by mesh type.
    • class MinSTCut<Mesh<Context::Local>> final Serial mesh-aware Potts classifier using local connectivity.
      • struct Parameters Fidelity and geometric perimeter weighting.
      • struct Result Cell classification and the separating mesh facets.
    • 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.
    • 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 Builder for constructing SubMesh objects.
    • 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 Cardiac models and their coupled state evolution.
    • struct CCMLC2014::Physics::Rheology::CarreauYasuda Carreau-Yasuda non-Newtonian branch-flow law.
    • class CCMLC2014::Physics::CavityFluxEvaluator Evaluates cavity inflow/outflow fluxes through the valve branches.
    • struct CCMLC2014PassiveLaw Default passive stress law for the CCMLC2014 reduced model.
    • struct CCMLC2014::Physics::Rheology::Cross Cross non-Newtonian branch-flow law.
    • class CCMLC2014::Numerics::DynamicSystem Assembles the coupled full-state residual and exact tangent.
    • struct CCMLC2014::Model::EvalDataT Intermediate data cached during residual/Jacobian evaluation.
    • struct CCMLC2014::Model::HistoryT Storage of recent states needed by second-order finite differences.
    • class HolzapfelReducedLaw Passive-energy evaluator based on reduced invariants.
      • struct Parameters Parameters of the reduced passive-energy law.
    • struct CCMLC2014::Model::InputT Model parameters and external forcings for one CCMLC2014 simulation.
    • struct CCMLC2014::Model::LocalActiveDataT Internal data for the local active-dynamics solve at one global step.
    • class CCMLC2014::Physics::MidpointKinematics Evaluates midpoint kinematics for the 0D reduced cavity model.
    • struct CCMLC2014::Physics::Rheology::Newtonian Linear Newtonian branch-flow law.
    • struct PassiveEnergyDerivatives Bundle of gradient and Hessian for passive-energy derivatives.
    • class CCMLC2014::Physics::PassiveStressEvaluator Evaluates the passive stress contribution from the constitutive law.
    • struct CCMLC2014::Physics::Rheology::PowerLaw Power-law non-Newtonian branch-flow law.
    • struct CCMLC2014::Physics::Rheology::Quemada Quemada non-Newtonian branch-flow law.
    • 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.
    • struct CCMLC2014::Model::ReportT Newton report for one global dynamic step.
    • struct CCMLC2014::Physics::SolverConfig Numerical tolerances and iteration limits for branch-flow solves.
    • struct CCMLC2014::Model::StateT CCMLC2014 dynamic state variables at a given time.
    • class CCMLC2014::Solver::StepperT Time-stepper for the coupled 0D CCMLC2014 ventricular model.
      • class Problem final Variational problem adapter for Newton iteration.
    • class CCMLC2014::Physics::ViscousStressEvaluator Evaluates the viscous stress contribution.
    • class CCMLC2014::Physics::WindkesselOutflowEvaluator Evaluates the Windkessel outflow and its pressure derivatives.
  • namespace Hilbert Hilbert-space formulations and regularization.
    • class H1a Hilbertian extension-regularization procedure with a regularization length-scale parameter.
  • namespace IO Reading and writing meshes, fields, and associated data.
    • 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 TransformationData HDF5 representation of a concrete parametric geometry chart.
      • struct XDMFTopologyLayout Layout metadata for XDMF topology dataset emission.
    • namespace Internal Internal helpers for PETSc HDF5 serialization primitives.
    • struct MFEM::FaceOrderEntry Face index and vertex ordering used when emitting MFEM face DOFs.
    • struct MFEM::GridFunctionHeader Header information for MFEM grid function files.
    • 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, FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>> Reads matrix entries stored as independent MEDIT scalar vertex fields. Higher-order spaces interpolate the vertex field, as required by SolAtVertices.
    • 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, FES, Math::Vector<Scalar>> Loads each MFEM component through the scalar family's node mapping.
    • 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, ::Vec> final PETSc storage adapter for supported MFEM finite element collections.
    • 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 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.
    • struct MFEM::MeshHeader Header information for MFEM mesh files.
    • 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.
    • struct MFEM::MeshVersion Version information for MFEM mesh format.
    • struct MFEM::ParseEmptyLine Parser for empty lines.
    • struct MFEM::ParseEmptyLineOrComment Parser for empty lines or comment lines.
    • class MEDIT::ParseEntity Parser for mesh entities (elements) in MEDIT format.
      • struct Data Parsed entity data.
    • struct MFEM::ParseGeometry Parser for geometry (element) information in MFEM format.
      • struct Data Parsed geometry data.
    • struct MFEM::ParseKeyword Parser for MFEM keywords.
    • class MFEM::ParseMeshHeader Parser for MFEM mesh file headers.
    • struct MFEM::ParseUnsignedInteger Parser for unsigned integers in MFEM format.
    • class MFEM::ParseVertex Parser for vertex coordinates in MFEM format.
    • class Printer Base template for printing objects to streams.
    • class MFEM::TetrahedronNodes MFEM-style nodal set on the reference tetrahedron (0,0,0)-(1,0,0)-(0,1,0)-(0,0,1).
    • class MFEM::TriangleNodes MFEM-style nodal set on the reference triangle (0,0)-(1,0)-(0,1).
    • class MFEM::VandermondeTetrahedron Vandermonde matrix on the tetrahedron using MFEM's nodal set.
    • class MFEM::VandermondeTriangle Vandermonde matrix on the triangle using MFEM's nodal set.
    • class MFEM::WedgeChange Change of nodes from Rodin wedge nodes to MFEM wedge nodes.
    • class MFEM::WedgeNodes MFEM-style nodal set on the reference wedge / prism.
    • class XDMF XDMF domain writer for static or transient visualization output.
      • struct SnapshotRecord::AttributeRecord Attribute metadata recorded for one snapshot.
      • 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 Keyword XML element names used in the XDMF 3 document format.
      • struct SnapshotRecord::MeshAttributeRecord Mesh-attached attribute metadata recorded for one snapshot.
      • struct SnapshotRecord::PieceMeta Per-rank mesh metadata cached during write().
  • namespace Location Spatial indexing and geometric search.
    • class AABB Bounding-volume-hierarchy point locator over axis-aligned boxes.
    • class AABB<MeshType> final Noncollective point location in owned entities of an MPI mesh.
  • namespace Math Spatial arithmetic, matrix operations, and sparse linear algebra.
    • class Deg Represents an angle in degrees.
    • class FixedSizeMatrix Compile-time fixed-size dense matrix.
    • class FixedSizeVector Compile-time fixed-size dense vector.
    • 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 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 Matrix Dynamic-size dense matrix.
    • class RootFinding::NewtonRaphson Newton-Raphson method for finding roots of scalar equations.
    • class Rad Represents an angle in radians.
    • struct RungeKutta::RK2 Classical second-order Runge-Kutta method with midpoint rule.
    • struct RungeKutta::RK4 Classical fourth-order Runge-Kutta method (RK4).
    • class SpatialMatrix Spatial matrix with bounded maximum dimensions.
    • class SpatialTensor A rank-R spatial tensor with stack storage and runtime extents.
    • class SpatialVector Spatial vector with bounded maximum size.
    • class Unit Base class for units using CRTP.
    • class Vector Dynamic-size dense vector.
  • namespace MMG Mesh adaptation through the MMG integration.
    • 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 Mesh from the MEDIT format.
    • class MeshPrinter Printer for 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 meshes, finite element spaces, and search operations.
  • namespace PETSc PETSc integration module for Rodin.
    • namespace Assembly PETSc-specific assembly strategies.
      • class ConstraintMap final Affine constraint map with collective dependency closure.
      • 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 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 QF Module for defining quadrature formulae over reference polytopes.
    • 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 QuadratureFormula final Persistent immutable reference quadrature points and weights.
      • struct Lookup::Entry One constructor key and its borrowed published formula.
    • class QuadratureFormulaBase Read-only access to reference quadrature points and weights.
      • struct Samples Read-only sample arrays borrowed from a concrete formula.
    • 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 Graph partitioning through the Scotch integration.
    • class Exception Exception type for errors reported by Scotch wrappers.
    • class Partitioner Mesh partitioner implemented with the SCOTCH library.
  • namespace Solid Constitutive laws, kinematics, and solid-mechanics integration.
    • namespace Tags Standard tag types for auxiliary constitutive data.
      • struct Activation Tag for the activation parameter.
      • struct ActiveBeta Current independent beta field.
      • struct ActiveExtension Tag for the active fiber extension .
      • struct ActiveGamma Current independent gamma field.
      • 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.
    • 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 Residual Residual and tangent for the three independent active fields.
      • 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.
    • struct Internal::FaceKinematics
    • 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 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.
    • class NeoHookean final Compressible Neo-Hookean hyperelastic law.
    • class Output CRTP base class for outputs.
    • class SaintVenantKirchhoff final Saint-Venant-Kirchhoff hyperelastic law.
    • class Yeoh final Compressible Yeoh hyperelastic law.
  • namespace Solver Solution of linear and nonlinear discrete systems.
    • 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.
    • struct Info Outcome of the most recent operation of a factorization-based solver.
    • 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 Helpers for constructing numerical tests.
    • class Utility::ExpectedResultTable Table-driven testing utility for validating computational models.
      • class ExpectedResult Container for a single expected result and its parameters.
    • 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.
    • class Random::PointOnTriangle Random point generator on the reference triangle.
    • class Random::RandomFloat Uniform random floating-point generator for tests.
    • class Random::RandomInteger Uniform random integer generator for tests.
    • struct Random::detail::UniformIntDistType Maps integral types to a distribution-compatible type.
  • namespace Tests Tests of the Rodin library
    • namespace Benchmarks Performance benchmarks.
    • namespace Manufactured Manufactured solution test cases
    • namespace Unit Unitary tests.
  • namespace Utility Type utilities and generic programming helpers.
    • struct Internal::AllImpl Internal implementation for checking if all types satisfy a predicate.
    • struct Internal::AllImpl<Predicate, T1> Base case for a single type.
    • struct Internal::AllImpl<Predicate, T1, T2, Ts...> Recursive case for multiple types.
    • struct Internal::AtImpl Internal implementation for accessing parameter pack elements by index.
    • struct Internal::AtImpl<0, First, Rest...> Base case specialization for index 0.
    • struct Internal::AtImpl<N, First, Rest...> Recursive case for index N > 0.
    • 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 Finite element spaces, fields, and variational problems.
    • 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.
    • struct AllPETScTrialOrTest Primary template for AllPETScTrialOrTest.
    • class AND Represents the logical AND expression.
    • class AND<BooleanFunctionBase<LHSDerived>, BooleanFunctionBase<RHSDerived>> final Logical AND operator between two boolean functions.
    • class Average
    • 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 Primary template for Component.
    • class Component<FunctionBase<Derived>, size_t, size_t, size_t> final One entry of a rank-three tensor-valued function.
    • 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<Derived, FES, Space>, size_t, size_t, size_t> final One entry of a tensor-valued trial or test basis.
    • class Component<ShapeFunctionBase<OperandDerived, FES, Space>> final Extracts a component from a vector-valued ShapeFunction.
    • class Component<ShapeFunctionBase<OperandDerived, FES, Space>, size_t, size_t> final Matrix-range finite element or expression specialization.
    • class Composition
    • class Conjugate
    • 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
    • class Cosh<FunctionBase<NestedDerived>> final Hyperbolic cosine function operator for real-valued scalar functions.
    • class DefaultBoundaryPolicy Default boundary policy for flow maps.
    • class DenseProblem
    • class DenseProblem<LinearSystem, U, V> General class to assemble linear systems with Math::Matrix and Math::Vector types in a serial context.
    • class Derivative
    • class Derivative<GridFunction<FES, Data>> final Matrix-field derivative, .
    • 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<Derived, FES, Space>> final Matrix-basis derivative, .
    • 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 DiffusionForm final Discrete diffusion form .
      • class Kernel Local kernel of the diffusion form.
    • 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<FES, Data>> final Matrix-field div, .
    • 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<Derived, FES, Space>> final Matrix-basis div, .
    • class Div<ShapeFunction<NestedDerived, H1<K, Math::SpatialVector<Number>, Mesh>, Space>> final Divergence of an H1 vector ShapeFunction.
      • struct Cache Physical derivatives prepared by the current integration-point bind.
    • 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 QuadraturePointKey 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 DOFMapping Local numbering of the union of two finite-element DOF sets.
    • class DOFMapping<true> Union numbering and side-local indices for distinct supports.
    • 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.
      • struct Gradients Selects the three derivative columns of caller-owned modal rows.
      • struct Values Selects the value column of caller-owned modal rows.
    • 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
    • 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 Primary template for Flow.
    • 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 Cache Function value retained for the current quadrature binding.
    • 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, Math::SpatialMatrix<Scalar>, Mesh>, Data>> final Physical gradient of a matrix H1 solution, with derivative axis last. Uses this family's scalar basis and component ordering.
    • class Grad<GridFunction<H1<K, Scalar, Mesh>, Data>> final Gradient of a GridFunction on H1<K> space.
    • class Grad<GridFunction<P0<Math::SpatialMatrix<Scalar>, Mesh>, Data>> final Physical gradient of a matrix P0 solution, with derivative axis last. Uses this family's scalar basis and component ordering.
    • class Grad<GridFunction<P0<Range, Mesh>, Data>> final Gradient of a P0 GridFunction.
    • class Grad<GridFunction<P0g<Math::SpatialMatrix<Scalar>, Mesh>, Data>> final Physical gradient of a matrix P0g solution, with derivative axis last. Uses this family's scalar basis and component ordering.
    • class Grad<GridFunction<P0g<Scalar, Mesh>, Data>> final Gradient of a P0g grid function.
    • class Grad<GridFunction<P1<Math::SpatialMatrix<Scalar>, Mesh>, Data>> final Physical gradient of a matrix P1 solution, with derivative axis last. Uses this family's scalar basis and component ordering.
    • class Grad<GridFunction<P1<Scalar, Mesh>, Data>> final Gradient of a P1 grid function.
    • class Grad<ShapeFunction<Derived, H1<K, Math::SpatialMatrix<Scalar>, Mesh>, Space>> final Physical gradients of matrix H1 trial or test bases.
    • class Grad<ShapeFunction<Derived, P0<Math::SpatialMatrix<Scalar>, Mesh>, Space>> final Physical gradients of matrix P0 trial or test bases.
    • class Grad<ShapeFunction<Derived, P0g<Math::SpatialMatrix<Scalar>, Mesh>, Space>> final Physical gradients of matrix P0g trial or test bases.
    • class Grad<ShapeFunction<Derived, P1<Math::SpatialMatrix<Scalar>, Mesh>, Space>> final Physical gradients of matrix P1 trial or test bases.
    • class Grad<ShapeFunction<NestedDerived, H1<K, Scalar, Mesh>, SpaceType>> final Gradient of a ShapeFunction on H1<K> space.
      • struct Cache Physical gradients prepared by the current integration-point bind.
    • 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 QuadraturePointKey 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::SpatialMatrix<Scalar>, Geometry::Mesh<Context::Local>> final Matrix-valued finite element space with component-wise scalar basis replication.
    • class H1<K, Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::MPI>> final Matrix-range finite element or expression specialization.
    • 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 Evaluation Owned modal derivatives for nodal gradient evaluation at one point.
      • class LinearForm Evaluates linear form at a given function/vector field.
    • class H1Element<K, Math::SpatialMatrix<Scalar>> final Matrix-valued reference element built from scalar nodal functionals.
      • class BasisFunction Matrix basis with one nonzero entry.
      • class LinearForm Matrix-range finite element or expression specialization.
    • 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.
    • struct H1MassOperands Certifies the plain-leaf operands of an H1 weighted mass expression.
    • struct H1MassOperands<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<ShapeFunction<Derived, H1<K, Range, Mesh>, TrialSpace>, H1<K, Range, Mesh>, TrialSpace>>> Retains the existing left-coefficient mass applicability.
    • struct H1MassOperands<Mult<ShapeFunctionBase<ShapeFunction<Derived, H1<K, Range, Mesh>, TrialSpace>, H1<K, Range, Mesh>, TrialSpace>, FunctionBase<CoefficientDerived>>> Certifies scalar right scaling of aggregate H1 carriers.
    • class HelmholtzForm Discrete Helmholtz-type form .
      • class Kernel Local kernel of the Helmholtz form.
    • 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.
    • class InterfaceShapeFunctionBase Evaluation base for a two-sided shape trace.
    • class InterfaceShapeFunctionBase<Derived, ShapeFunctionBase<NestedDerived, FES, Space>> Two-sided evaluation of a cell-local shape expression.
    • class Interpolation Finite-element interpolation selected by the space's context.
    • class Interpolation<FES> final Selects and evaluates distributed interpolation functionals.
    • struct IsPETScTestFunction Primary template for IsPETScTestFunction.
    • struct IsPETScTrialFunction Primary template for IsPETScTrialFunction.
    • 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<FES, Data>> final Matrix-field jacobian, .
    • 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<Derived, FES, Space>> final Matrix-basis jacobian, .
    • class Jacobian<ShapeFunction<NestedDerived, H1<K, Math::SpatialVector<Scalar>, Mesh>, Space>> final Jacobian of an H1 ShapeFunction object.
      • struct Cache Physical derivatives prepared by the current integration-point bind.
    • 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 a P1 ShapeFunction object.
      • struct Cache Per-cell tabulation cache.
        • struct CellKey Key identifying the cell a tabulation was computed for.
        • struct QuadraturePointKey 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
    • 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 LagrangeFiniteElementBase Common reference-space properties of Lagrange element families.
    • 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 LinearElasticityForm Discrete isotropic linear elasticity form.
      • class Kernel Local kernel of the linear elasticity form.
    • class LinearElasticityIntegral Helper class to construct linear elasticity integrators.
    • class LinearElasticityIntegrator Bilinear form integrator for linear elasticity.
    • class LinearElasticityIntegrator<Solution, P1<Range, Mesh>, LambdaDerived, MuDerived> 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 MassForm Discrete mass form .
      • class Kernel Local kernel of the mass form.
    • class MatrixFunction Callable matrix coefficient with explicit row and column extents.
    • class MatrixFunction<Math::Matrix<Scalar>> final Matrix-valued constant function.
    • class MatrixFunction<Math::SpatialMatrix<Scalar>> final Matrix-range finite element or expression specialization.
    • class MatrixFunctionBase Base class for matrix-valued functions defined on a mesh.
    • class Max
    • 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
    • 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 NamedFormStorage Owns the operator of a named bilinear form.
    • class NamedFormStorage<::Mat> Owns a named form's PETSc matrix, copying values and transferring moves.
    • 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<Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::Local>> final Matrix-valued finite element space with component-wise scalar basis replication.
    • class P0<Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::MPI>> final Matrix-range finite element or expression specialization.
    • class P0<Math::SpatialVector<Scalar>, Geometry::Mesh<Context::Local>> final Cellwise constant vector space with independent component DOFs.
      • class Pullback Pulls a physical vector field back to a cell reference domain.
      • class Pushforward Pushes a reference vector field forward to a physical cell.
    • 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<Scalar, 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::SpatialMatrix<Scalar>> final Matrix-valued reference element built from scalar nodal functionals.
      • class BasisFunction Matrix basis with one nonzero entry.
      • class LinearForm Matrix-range finite element or expression specialization.
    • 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::SpatialMatrix<Scalar>, Geometry::Mesh<Context::Local>> final Matrix-range finite element or expression specialization.
    • class P0g<Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::MPI>> final Matrix-range finite element or expression specialization.
    • class P0g<Math::SpatialVector<Scalar>, 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<Scalar>, Geometry::Mesh<Context::MPI>> final Distributed vector P0g finite element space for MPI meshes.
    • class P0g<Scalar, 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<Scalar, 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::SpatialMatrix<Scalar>> final Matrix-valued reference element built from scalar nodal functionals.
      • class BasisFunction Matrix basis with one nonzero entry.
      • class LinearForm Matrix-range finite element or expression specialization.
    • 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::SpatialMatrix<Scalar>, Geometry::Mesh<Context::Local>> final Matrix-valued finite element space with component-wise scalar basis replication.
    • class P1<Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::MPI>> final Matrix-range finite element or expression specialization.
    • 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::SpatialMatrix<Scalar>> final Matrix-valued reference element built from scalar nodal functionals.
      • class BasisFunction Matrix basis with one nonzero entry.
      • class LinearForm Matrix-range finite element or expression specialization.
    • 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
    • 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
    • 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 with three or more trial/test functions.
    • 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.
      • struct Gradients Selects the three derivative columns of caller-owned modal rows.
      • struct Values Selects the value column of caller-owned modal rows.
    • 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, 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<LeftOperand, RightOperand>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>> Weighted mass quadrature for plain H1 trial and test leaves.
    • 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 ReferenceTabulation Owned scalar basis values and reference derivatives.
      • struct Gradients Writable reference gradients, indexed by basis then coordinate.
      • struct Values Writable values of all scalar basis functions at one reference point.
    • class ReferenceTabulationCache Bounded reference-table reuse for an element and scalar type.
    • 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::SpatialMatrix<Scalar>, Mesh>, Space> Matrix-valued shape-function specialization with cached scalar basis tabulation.
    • 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<Math::SpatialMatrix<Scalar>, Mesh>, Space> Matrix-valued shape-function specialization with cached scalar basis 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<Math::SpatialMatrix<Scalar>, Mesh>, Space> Matrix-valued shape-function specialization with cached scalar basis 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<Math::SpatialMatrix<Scalar>, Mesh>, Space> Matrix-valued shape-function specialization with cached scalar basis tabulation.
    • 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
    • class Sin<FunctionBase<NestedDerived>> final Sine function operator for real-valued scalar functions.
    • class Sinh
    • class Sinh<FunctionBase<NestedDerived>> final Hyperbolic sine function operator for real-valued scalar functions.
    • class SparseProblem
    • class SparseProblem<LinearSystem, U, V> General class to assemble linear systems with Math::SparseMatrix and Math::Vector types in a serial context.
    • class Sqrt
    • 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 TensorFunction final Tensor coefficient with value semantics.
    • 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
    • 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<GlobalBilinearFormIntegratorBase<Number>>> Negation of a list of bilinear form integrators.
    • 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<GlobalBilinearFormIntegratorBase<Number>> Negation of a bilinear form integrator.
    • 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
    • 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.
• namespace Eigen Eigen interoperability declarations for Rodin mathematical types.
  • namespace internal Eigen traits and evaluators for Rodin matrices and vectors.
    • struct eval<Rodin::Math::FixedSizeMatrix<Scalar, Rows, Cols>, Dense> Retains an already evaluated fixed-size matrix without copying it.
    • struct eval<Rodin::Math::Matrix<Scalar>, Dense> Retains an already evaluated dynamic matrix without copying it.
    • struct evaluator<Rodin::Math::FixedSizeMatrix<Scalar, Rows, Cols>> Evaluates fixed-size Rodin matrices through their Eigen storage.
    • struct evaluator<Rodin::Math::FixedSizeVector<Scalar, Size>> Evaluates fixed-size Rodin vectors through their Eigen storage.
    • struct evaluator<Rodin::Math::Matrix<Scalar>> Evaluates dynamic Rodin matrices through their Eigen storage.
    • struct evaluator<Rodin::Math::Vector<Scalar>> Evaluates dynamic Rodin vectors through their Eigen storage.
    • struct traits<Rodin::Math::FixedSizeMatrix<Scalar, Rows, Cols>> Retains Eigen map and reference support for fixed-size Rodin matrices.
    • struct traits<Rodin::Math::FixedSizeVector<Scalar, Size>> Retains Eigen map and reference support for fixed-size Rodin vectors.
    • struct traits<Rodin::Math::Matrix<Scalar>> Retains Eigen map and reference support for dynamic Rodin matrices.
    • struct traits<Rodin::Math::Vector<Scalar>> Retains Eigen map and reference support for dynamic Rodin vectors.
• namespace std Standard-library customizations for Rodin types.
  • struct tuple_element<0, Rodin::Math::LinearSystem<Matrix, Vector>> Structured-binding element 0 of a LinearSystem: the operator .
  • struct tuple_element<1, Rodin::Math::LinearSystem<Matrix, Vector>> Structured-binding element 1 of a LinearSystem: the solution .
  • struct tuple_element<2, Rodin::Math::LinearSystem<Matrix, Vector>> Structured-binding element 2 of a LinearSystem: the right-hand side .