The grid operator represents an operator mapping which corresponds to the (possibly nonlinear) algebraic problem resulting from the discretization of a PDE. More...
Evaluating the grid operator and its jacobian matrix entails integrations over the computational domain during which the corresponding algebraic objects are assembled incrementally. The assembling is performed by two objects corresponding to the Dune::PDELab::AssemblerInterface and the Dune::PDELab::LocalAssemblerInterface . The former, the global assembler, provides the geometric objects, representing parts of the computational domain to be integrated. The latter, the local assembler, calls the local operator in an appropriate way to compute the local integrals and afterwards accumulates the results into the algebra objects.
The separation of these two tasks into different objects has significant advantages to a monolithic approach. It allows different implementations of the assembler interface to be used interchangeably in common implementations of time stepping schemes. The latter may link in between the global and the local assembler and thus apply the necessary modifications to the local integrations (like multiplying with the time step with or Runge-Kutta coefficients).
Furthermore, the separation provides a junction for caching objects. Such objects would provide the interface of the local assembler, while actually wrapping the true local assembler object.
Evaluating the grid operator (usually corresponds to computing the problem's residual vector)
Setup of the jacobian matrix sparsity pattern
Computing the jacobian matrix
As these three tasks require rather different local operations (e.g. setting up of the jacobian matrix sparsity pattern does not require any evaluations of the local function spaces), the local assembler does not directly interact with the global assembler. Instead, it provides engines which drive the global assembler for each of the different tasks. Therefore, every local assembler is required to provide the engines:
LocalPatternAssemblerEngine
LocalResidualAssemblerEngine
LocalJacobianAssemblerEngine
LocalResidualJacobianAssemblerEngine
The last of the engines above allows a combined assembling of the residual and the jacobian matrix.
Instationary problems and composite grid operators
When given a instationary PDE problem which (after spatial discretization) results in an algebraic problem
then the PDELab approach is to define a grid operator for each and and then combine these grid operators in a composite grid operator which provides the additional functionality needed by the chosen time stepping method (e.g. for a Runge-Kutta scheme, the grid operator must be able to be evaluated for each of the Runge-Kutta stages). The class Dune::PDELab::OneStepGridOperator is a fairly general implementation which allows the appli cation of many different one step methods including all methods of Runge-Kutta type.
In general, such composite grid operators will apply multiple assembler engines in a combined assembling during a single grid traversion. This will usually result in both engines performing operations, which they could efficiently share or distribute. To allow such optimizations, the composite grid operator may inform his subordinate grid operators of their co-operators and the order in which they will be called during assembling. This is done via the Dune::PDELab::GridOperatorInterface::setupGridOperators method.