# Bilinear and Linear Forms – Matrices and Vectors

The stiffness matrix and the load vector are assembled from elementwise computations of the bilinear and linear forms. More...

## Classes | |

class | concepts::AfterIteration< F > |

Solver with after iterations. More... | |

class | concepts::BilinearForm< F, G > |

Abstract function class to evaluate a bilinear form. More... | |

class | concepts::Compose< F, H > |

Computes the product of two operators. More... | |

class | concepts::DDSolver< F, G > |

Domain Decomposition Solver. More... | |

class | concepts::LiCo< F > |

Linear combination of two operators. More... | |

class | concepts::LiCoI< F > |

Linear combination of an operator with the identity. More... | |

class | concepts::LinearForm< F, G > |

Abstract class for a linear form. More... | |

class | concepts::Matrix< F > |

Abstract class for an operator. More... | |

class | concepts::Multiple< F > |

Multiple of an operator. More... | |

class | concepts::Operator< F > |

Abstract class for an operator. More... | |

class | concepts::SchurCompl< F > |

Schur complement. More... | |

class | concepts::SubMatrixN< F > |

Abstract class for an operator, which is a sub matrix of another matrix. More... | |

class | concepts::TMatrixBase< F > |

An abstract class for a T matrix. More... | |

class | concepts::VecOperator< F > |

Abstract class for an operator acting on vectors only, not arbitrary functions. More... | |

class | concepts::Vector< F > |

A vector. More... | |

## Detailed Description

The stiffness matrix and the load vector are assembled from elementwise computations of the bilinear and linear forms.

## Assembling

The element matrices (or vectors, concepts::ElementMatrix) need to be assembled into the stiffness matrix in order to create the global linear system. This assembling needs a mapping from the local to the global degrees of freedom. This mapping is stored in a so-called T matrix (concepts::TMatrixBase) in each element.

The element matrices are computed by the application operator of the bilinear and linear forms (concepts::BilinearForm and concepts::LinearForm). The assembling is then handled by the constructor of the global linear system represented by a matrix (e.g. concepts::SparseMatrix derived from concepts::Matrix). It is also possible to have a matrix free representation of a stiffness matrix (derived from concepts::Operator).

Almost all assembling algorithms for matrices are implemented as static methods in concepts::Matrix.

## Bilinear Forms and Matrices

### Bilinear Forms

A bilinear form a(u,v) is evaluated for two functions of the basis of the space. This is done by evaluating a(u,v) for all shape functions on all elements to form the element matrices.

A bilinear form is computed in the application operator of a class derived from concepts::BilinearForm.

The application operator of such an bilinear form takes two elements and an element matrix (which is then filled) as arguments. The application operator computes the interactions of the shape functions of the two elements. In standard FEM, there are only interactions, if the two elements are identical.

### Matrices and Operators

To form the global matrix, the element matrices have to be assembled. This is done in the constructor of a matrix. The base class for all operators (and matrices are operators) is concepts::Operator.

It is possible to combine different operators using concepts::Compose or concepts::LiCo.

## Linear Forms and Vectors

### Linear Forms

A linear form l(v) is evaluated for each basis function of the space. This is done similarly to the bilinear form: the linear form is evaluated for all shape functions of each element. Then, the local contributions to the vector are assembled.

Linear forms are derived from concepts::LinearForm.

### Vectors

The local contributions to the global vector are assembled in the constructor of concepts::Vector, derived from concepts::Function.

## Solver

The application operator of a solver solves the linear system. concepts::GMRes and concepts::CG are our own implementations, concepts::PETSc includes a lot of (iterative) solvers. There are interfaces to the direct solvers concepts::SuperLU, concepts::Pardiso, concepts::Umfpack, see description of linear solvers.