Rodin::Assembly module

Global assembly of discrete operators.

Sequential evaluates local integrals and accumulates global matrices and vectors; Default selects the configured assembly strategy. BilinearFormAssemblyInput supplies spaces and integrators, and ConstraintMap expands degree-of-freedom constraints when assembling constrained or coupled problems.

Assembly Strategies

StrategyClassDescription
SequentialAssembly::SequentialSingle-threaded assembly. Iterates over mesh cells, evaluates local element matrices/vectors, and accumulates into the global system. Deterministic and reproducible.
OpenMPAssembly::OpenMPShared-memory parallel assembly using OpenMP. Each thread processes a subset of cells and accumulates contributions using thread-safe operations. Requires compilation with RODIN_USE_OPENMP=ON.
DefaultAssembly::DefaultCompile-time policy selector. Maps to OpenMP when OpenMP is available, otherwise falls back to Sequential. Users rarely need to specify this directly.

What Gets Assembled

  • Bilinear Form $ a(u,v) $ : Assembles into a sparse matrix $ A_{ij} = a(\phi_j, \psi_i) $ where $ \phi_j $ are trial basis functions and $ \psi_i $ are test basis functions.
  • Linear Form $ \ell(v) $ : Assembles into a vector $ b_i = \ell(\psi_i) $ .
  • Dirichlet BC: Assembles into an IndexMap mapping constrained DOFs to their prescribed values.
  • Problem: Orchestrates the full assembly pipeline — bilinear form, linear form(s), Dirichlet elimination — into a complete LinearSystem.

Assembly Pipeline

Assembly is normally triggered automatically when Problem::solve() is called. The pipeline is:

  1. Assemble the bilinear form into a sparse matrix $ A $
  2. Assemble the linear form into a vector $ b $
  3. Apply Dirichlet boundary conditions (row/column elimination)
  4. Package into a LinearSystem and pass to the solver

Users can also trigger assembly manually by calling BilinearForm::assemble() or LinearForm::assemble().

Multi-Field Assembly

For saddle-point problems (e.g. Stokes), the Assembly module supports block-structured systems via Tuple<BilinearForm...> and Tuple<LinearForm...>, which assemble into block matrices and vectors. This is used by multi-field Problem objects with multiple trial/test function pairs.

Representative formula

Trial basis functions $\phi_j$ and test basis functions $\psi_i$ give the assembled matrix and load vector:

\[ A_{ij}=a(\phi_j,\psi_i), \qquad b_i=\ell(\psi_i). \]

Classes

template<class Scalar>
class ConstraintMap
Read-only expansion map for value and identification constraints.
template<class LinearAlgebraType, class Operand>
class AssemblyBase
Base class template for assembly operations.
See specializations
SpecializationDescription
OperatorType, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class OperatorType,
  class Solution,
  class TrialFES,
  class TestFES>
class AssemblyBase<
  OperatorType,
  Variational::BilinearForm< Solution, TrialFES, TestFES, OperatorType >>;
Base class for bilinear form assembly operations.
OperatorType, Form
Full specialization
template <
  class OperatorType,
  class Form>
requires FormLanguage::IsNamedForm<Form>::Value
class AssemblyBase<
  OperatorType,
  Form>;
Base class for the assembly of a named bilinear form.
OperatorType, Tuple<…>
Full specialization
template <
  class OperatorType,
  class... Solution,
  class... TrialFES,
  class... TestFES,
  class... BlockType>
class AssemblyBase<
  OperatorType,
  Tuple< Variational::BilinearForm< Solution, TrialFES, TestFES, BlockType >... >>;
Base class for assembling tuples of bilinear forms.
VectorType, Variational::LinearForm<FES, VectorType>
Full specialization
template <
  class VectorType,
  class FES>
class AssemblyBase<
  VectorType,
  Variational::LinearForm< FES, VectorType >>;
Base class for linear form assembly operations.
VectorType, Tuple<…>
Full specialization
template <
  class VectorType,
  class... FES,
  class... BlockType>
class AssemblyBase<
  VectorType,
  Tuple< Variational::LinearForm< FES, BlockType >... >>;
Base class for assembling tuples of linear forms.
IndexMap<Scalar>, Variational::DirichletBC<…>
Full specialization
template <
  class Scalar,
  class Solution,
  class FES,
  class ValueDerived>
class AssemblyBase<
  IndexMap< Scalar >,
  Variational::DirichletBC< Variational::TrialFunction< Solution, FES >, Variational::FunctionBase< ValueDerived > >>;
Base class for value Dirichlet boundary condition assembly.
IndexMap<…>, Variational::DirichletBC<…>
Full specialization
template <
  class Scalar,
  class Sol1,
  class FES1,
  class Derived2,
  class FES2,
  Variational::ShapeFunctionSpaceType Sp>
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).
LinearSystem, Variational::Problem<LinearSystem, …>
Full specialization
template <
  class LinearSystem,
  class TrialFunction,
  class TestFunction>
class AssemblyBase<
  LinearSystem,
  Variational::Problem< LinearSystem, TrialFunction, TestFunction >>;
Base class for complete single-field problem assembly.
LinearSystem, Variational::Problem<LinearSystem, …>
Full specialization
template <
  class LinearSystem,
  class U1,
  class U2,
  class U3,
  class... Us>
class AssemblyBase<
  LinearSystem,
  Variational::Problem< LinearSystem, U1, U2, U3, Us... >>;
Base class for complete mixed problem assembly.
template<class LinearAlgebraType, class Operand>
class Sequential
Sequential (single-threaded) assembly implementation.
See specializations
SpecializationDescription
Math::SparseMatrix<Scalar>, Form
Full specialization
template <
  class Scalar,
  class Form>
requires FormLanguage::IsNamedForm<Form>::Value
class Sequential<
  Math::SparseMatrix< Scalar >,
  Form> final;
Assembly of a named bilinear form into a sparse matrix over a single thread.
Math::Vector<…>, Variational::LinearForm<FES, …>
Full specialization
template <
  class FES>
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.
Math::Matrix<…>, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
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.
Math::SparseMatrix<…>, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
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.
std::vector<…>, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
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.
std::vector<Math::SparseTriplet<Real>>, Tuple<…>
Full specialization
template <
  class... Solution,
  class... TrialFES,
  class... TestFES>
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.
Math::SparseMatrix<Real>, Tuple<…>
Full specialization
template <
  class... Solution,
  class... TrialFES,
  class... TestFES>
class Sequential<
  Math::SparseMatrix< Real >,
  Tuple< Variational::BilinearForm< Solution, TrialFES, TestFES, Math::SparseMatrix< Real > >... >> final;
Sequential block bilinear form assembly into a sparse matrix.
Math::Vector<Real>, Tuple<…>
Full specialization
template <
  class... FES>
class Sequential<
  Math::Vector< Real >,
  Tuple< Variational::LinearForm< FES, Math::Vector< Real > >... >> final;
Sequential block linear form assembly into a vector.
LinearSystem, Variational::Problem<LinearSystem, …>
Full specialization
template <
  class LinearSystem,
  class U1,
  class U2,
  class U3,
  class... Us>
class Sequential<
  LinearSystem,
  Variational::Problem< LinearSystem, U1, U2, U3, Us... >> final;
Sequential mixed problem assembly.
LinearSystem, Variational::Problem<LinearSystem, …>
Full specialization
template <
  class LinearSystem,
  class TrialFunction,
  class TestFunction>
class Sequential<
  LinearSystem,
  Variational::Problem< LinearSystem, TrialFunction, TestFunction >> final;
Sequential single-field problem assembly.
IndexMap<Scalar>, Variational::DirichletBC<…>
Full specialization
template <
  class Scalar,
  class Solution,
  class FES,
  class ValueDerived>
class Sequential<
  IndexMap< Scalar >,
  Variational::DirichletBC< Variational::TrialFunction< Solution, FES >, Variational::FunctionBase< ValueDerived > >> final;
Sequential value Dirichlet boundary condition assembly.
IndexMap<…>, Variational::DirichletBC<…>
Full specialization
template <
  class Scalar,
  class Sol1,
  class FES1,
  class Derived2,
  class FES2,
  Variational::ShapeFunctionSpaceType Sp>
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).
::Mat, Form
Full specialization
template <
  class Form>
requires FormLanguage::IsNamedForm<Form>::Value
class Sequential<
  ::Mat,
  Form> final;
Sequential PETSc assembly using a named form's local kernel.
::Vec, Variational::LinearForm<FES,::Vec>
Full specialization
template <
  class FES>
class Sequential<
  ::Vec,
  Variational::LinearForm< FES, ::Vec >> final;
Sequential assembly of a PETSc vector from a linear form.
::Mat, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
class Sequential<
  ::Mat,
  Variational::BilinearForm< Solution, TrialFES, TestFES, ::Mat >> final;
Sequential assembly of a PETSc matrix from a bilinear form.
Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<…>
Full specialization
template <
  class U,
  class V>
class Sequential<
  Rodin::PETSc::Math::LinearSystem,
  Rodin::Variational::Problem< Rodin::PETSc::Math::LinearSystem, U, V >> final;
Sequential assembly of a single-variable PETSc problem.
Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<…>
Full specialization
template <
  class U1,
  class U2,
  class U3,
  class... Us>
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.
template<class Mesh>
class SequentialIteration
Sequential mesh iteration strategy.
See specializations
SpecializationDescription
Geometry::Mesh<Context::Local>
Full specialization
template <>
class SequentialIteration<
  Geometry::Mesh< Context::Local >>;
Sequential mesh iteration for single-threaded assembly.
template<class TrialFES, class TestFES>
class BilinearFormAssemblyInput
Input data for bilinear form assembly.
template<class FES>
class LinearFormAssemblyInput
Input data for linear form assembly.
template<class ... Ts>
class BilinearFormTupleAssemblyInput
Input data for tuple of bilinear forms assembly.
template<class Scalar, class Solution, class FES, class Value>
class DirichletBCAssemblyInput
Input data for Dirichlet boundary condition assembly.
class DirichletBCShapeFunctionAssemblyInput
Input data for identification-style Dirichlet BC assembly (u = A(v)).
See declaration
template<class Scalar, class Sol1, class FES1, class Derived2, class FES2, Variational::ShapeFunctionSpaceType Sp>
class DirichletBCShapeFunctionAssemblyInput
template<class ... Ts>
class Default
Default assembly strategy selector.
See specializations
SpecializationDescription
Context::Local
Full specialization
template <>
class Default<
  Context::Local>;
Default assembly strategy for local context with OpenMP enabled.
Context::Local, Context::Local
Full specialization
template <>
class Default<
  Context::Local,
  Context::Local>;
Default assembly strategy for mixed local contexts with OpenMP enabled.
Context::MPI
Full specialization
template <>
class Default<
  Context::MPI>;
Selects MPI assembly when only the trial/test context is MPI.
Context::MPI, Context::MPI
Full specialization
template <>
class Default<
  Context::MPI,
  Context::MPI>;
Selects MPI assembly when both operand and assembly contexts are MPI.
template<class LinearAlgebraType, class Operand>
class OpenMP
OpenMP-based parallel assembly implementation.
See specializations
SpecializationDescription
Math::SparseMatrix<Scalar>, Form
Full specialization
template <
  class Scalar,
  class Form>
requires FormLanguage::IsNamedForm<Form>::Value
class OpenMP<
  Math::SparseMatrix< Scalar >,
  Form> final;
Assembly of a named bilinear form into a sparse matrix over OpenMP threads.
std::vector<…>, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
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.
Math::SparseMatrix<…>, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
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.
Math::Matrix<…>, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
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.
Math::Vector<…>, Variational::LinearForm<FES, …>
Full specialization
template <
  class FES>
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.
IndexMap<Scalar>, Variational::DirichletBC<…>
Full specialization
template <
  class Scalar,
  class Solution,
  class FES,
  class ValueDerived>
class OpenMP<
  IndexMap< Scalar >,
  Variational::DirichletBC< Variational::TrialFunction< Solution, FES >, Variational::FunctionBase< ValueDerived > >> final;
OpenMP value Dirichlet boundary condition assembly.
LinearSystem, Variational::Problem<LinearSystem, …>
Full specialization
template <
  class LinearSystem,
  class TrialFunction,
  class TestFunction>
class OpenMP<
  LinearSystem,
  Variational::Problem< LinearSystem, TrialFunction, TestFunction >> final;
OpenMP single-field problem assembly.
LinearSystem, Variational::Problem<LinearSystem, …>
Full specialization
template <
  class LinearSystem,
  class U1,
  class U2,
  class U3,
  class... Us>
class OpenMP<
  LinearSystem,
  Variational::Problem< LinearSystem, U1, U2, U3, Us... >> final;
OpenMP mixed problem assembly.
IndexMap<…>, Variational::DirichletBC<…>
Full specialization
template <
  class Scalar,
  class Sol1,
  class FES1,
  class Derived2,
  class FES2,
  Variational::ShapeFunctionSpaceType Sp>
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).
::Mat, Form
Full specialization
template <
  class Form>
requires FormLanguage::IsNamedForm<Form>::Value
class OpenMP<
  ::Mat,
  Form> final;
OpenMP PETSc assembly using a named form's local kernel.
::Vec, Variational::LinearForm<FES,::Vec>
Full specialization
template <
  class FES>
class OpenMP<
  ::Vec,
  Variational::LinearForm< FES, ::Vec >> final;
OpenMP-parallel assembly of a PETSc vector from a linear form.
::Mat, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
class OpenMP<
  ::Mat,
  Variational::BilinearForm< Solution, TrialFES, TestFES, ::Mat >> final;
OpenMP-parallel assembly of a PETSc matrix from a bilinear form.
Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<…>
Full specialization
template <
  class U,
  class V>
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.
Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<…>
Full specialization
template <
  class U1,
  class U2,
  class U3,
  class... Us>
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.
template<class Mesh>
class OpenMPIteration
OpenMP-based parallel mesh iteration strategy.
See specializations
SpecializationDescription
Geometry::Mesh<Context::Local>
Full specialization
template <>
class OpenMPIteration<
  Geometry::Mesh< Context::Local >>;
OpenMP-based parallel mesh iteration for multi-threaded assembly.
template<class ... Ts>
class LinearFormTupleAssemblyInput
Input data for tuple of linear forms assembly.
template<class ... Ts>
class ProblemAssemblyInput
Input data for complete problem assembly.
See specializations
SpecializationDescription
ProblemBody, TrialFunction, TestFunction
Full specialization
template <
  class ProblemBody,
  class TrialFunction,
  class TestFunction>
class ProblemAssemblyInput<
  ProblemBody,
  TrialFunction,
  TestFunction>;
Input data for complete problem assembly.
ProblemBody, U1, U2, U3, Us...
Full specialization
template <
  class ProblemBody,
  class U1,
  class U2,
  class U3,
  class ... Us>
class ProblemAssemblyInput<
  ProblemBody,
  U1,
  U2,
  U3,
  Us...>;
Input data for mixed problem assembly with several trial/test functions.
template<class Scalar>
class ScatterMap
Cached map from polytope-local matrix entries into the value array of an assembled Math::SparseMatrix.
template<class FES>
class MPIBoundaryDOFs
Selects boundary DOF functionals using the existing mesh overlap.
class MPIIteration
Iteration helper over a region of an MPI mesh shard.
template<class LinearAlgebraType, class Operand>
class MPI
Primary template declaration of the MPI assembly executor.
See specializations
SpecializationDescription
IndexMap<Scalar>, Variational::DirichletBC<…>
Full specialization
template <
  class Scalar,
  class Solution,
  class FES,
  class ValueDerived>
class MPI<
  IndexMap< Scalar >,
  Variational::DirichletBC< Variational::TrialFunction< Solution, FES >, Variational::FunctionBase< ValueDerived > >> final;
MPI assembler for scalar-valued Dirichlet boundary data.
IndexMap<…>, Variational::DirichletBC<…>
Full specialization
template <
  class Scalar,
  class Sol1,
  class FES1,
  class Derived2,
  class FES2,
  Variational::ShapeFunctionSpaceType Sp>
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).
::Mat, Form
Full specialization
template <
  class Form>
requires FormLanguage::IsNamedForm<Form>::Value
class MPI<
  ::Mat,
  Form> final;
MPI PETSc assembly using a named form's local kernel.
::Vec, Variational::LinearForm<FES,::Vec>
Full specialization
template <
  class FES>
class MPI<
  ::Vec,
  Variational::LinearForm< FES, ::Vec >> final;
MPI-parallel assembly of a PETSc vector from a linear form.
::Mat, Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
class MPI<
  ::Mat,
  Variational::BilinearForm< Solution, TrialFES, TestFES, ::Mat >> final;
MPI-parallel assembly of a PETSc matrix from a bilinear form.
Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<…>
Full specialization
template <
  class U,
  class 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.
Rodin::PETSc::Math::LinearSystem, Rodin::Variational::Problem<…>
Full specialization
template <
  class U1,
  class U2,
  class U3,
  class... Us>
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.

Functions

BilinearFormAssemblyInput
Template argument deduction guide for BilinearFormAssemblyInput.
See declaration
template<class TrialFES, class TestFES>
BilinearFormAssemblyInput(const TrialFES& trialFES, const TestFES& testFES, FormLanguage::List<Variational::LocalBilinearFormIntegratorBase<decltype(std::declval<typename FormLanguage::Traits<TrialFES>::ScalarType>()*std::declval<typename FormLanguage::Traits<TestFES>::ScalarType>())>, & lbfis, FormLanguage::List<Variational::GlobalBilinearFormIntegratorBase<decltype(std::declval<typename FormLanguage::Traits<TrialFES>::ScalarType>()*std::declval<typename FormLanguage::Traits<TestFES>::ScalarType>())>, & gbfis) -> BilinearFormAssemblyInput< TrialFES, TestFES >
OpenMPIteration
Template argument deduction guide for OpenMPIteration.
See declaration
OpenMPIteration(const Geometry::Mesh<Context::Local>& mesh, const Geometry::Region& region) -> OpenMPIteration< Geometry::Mesh< Context::Local > >
SequentialIteration
Template argument deduction guide for SequentialIteration.
See declaration
SequentialIteration(const Geometry::Mesh<Context::Local>& mesh, const Geometry::Region& region) -> SequentialIteration< Geometry::Mesh< Context::Local > >

Function documentation

BilinearFormAssemblyInput

Defined in Rodin/Assembly/Input.h

See declaration
template<class TrialFES, class TestFES>
BilinearFormAssemblyInput(const TrialFES& trialFES, const TestFES& testFES, FormLanguage::List<Variational::LocalBilinearFormIntegratorBase<decltype(std::declval<typename FormLanguage::Traits<TrialFES>::ScalarType>()*std::declval<typename FormLanguage::Traits<TestFES>::ScalarType>())>, & lbfis, FormLanguage::List<Variational::GlobalBilinearFormIntegratorBase<decltype(std::declval<typename FormLanguage::Traits<TrialFES>::ScalarType>()*std::declval<typename FormLanguage::Traits<TestFES>::ScalarType>())>, & gbfis) -> BilinearFormAssemblyInput< TrialFES, TestFES >

Template argument deduction guide for BilinearFormAssemblyInput.

Parameters
trialFES Trial finite element space
testFES Test finite element space
lbfis List of local bilinear form integrators
gbfis List of global bilinear form integrators

OpenMPIteration

Defined in Rodin/Assembly/OpenMP.h

See declaration
OpenMPIteration(const Geometry::Mesh<Context::Local>& mesh, const Geometry::Region& region) -> OpenMPIteration< Geometry::Mesh< Context::Local > >

Template argument deduction guide for OpenMPIteration.

Parameters
mesh Mesh on which the object is defined.
region Geometric region defining the iteration domain

SequentialIteration

Defined in Rodin/Assembly/Sequential.h

See declaration
SequentialIteration(const Geometry::Mesh<Context::Local>& mesh, const Geometry::Region& region) -> SequentialIteration< Geometry::Mesh< Context::Local > >

Template argument deduction guide for SequentialIteration.

Parameters
mesh Mesh on which the object is defined.
region Mesh region selected for iteration.