A simple ilu0 block diagonal preconditioner.  
#include <dumux/linear/seqsolverbackend.hh>
|  | 
| using | matrix_type = typename std::decay_t<M> | 
|  | The matrix type the preconditioner is for. 
 | 
|  | 
| using | domain_type = X | 
|  | The domain type of the preconditioner. 
 | 
|  | 
| using | range_type = Y | 
|  | The range type of the preconditioner. 
 | 
|  | 
| using | field_type = typename X::field_type | 
|  | The field type of the preconditioner. 
 | 
|  | 
|  | 
| template<class LOP, class Criterion, class SmootherArgs> | 
|  | BlockDiagAMGPreconditioner (const LOP &lop, const Criterion &c, const SmootherArgs &sa) | 
|  | Constructor. 
 | 
|  | 
| void | pre (X &v, Y &d) final | 
|  | Prepare the preconditioner. 
 | 
|  | 
| void | apply (X &v, const Y &d) final | 
|  | Apply one step of the preconditioner to the system A(v)=d. 
 | 
|  | 
| void | post (X &v) final | 
|  | Clean up. 
 | 
|  | 
| Dune::SolverCategory::Category | category () const final | 
|  | Category of the preconditioner (see SolverCategory::Category) 
 | 
|  | 
◆ domain_type
template<class M, class X, class Y, int blockLevel = 2> 
      
 
 
◆ field_type
template<class M, class X, class Y, int blockLevel = 2> 
      
 
 
◆ matrix_type
template<class M, class X, class Y, int blockLevel = 2> 
      
 
 
◆ range_type
template<class M, class X, class Y, int blockLevel = 2> 
      
 
 
◆ BlockDiagAMGPreconditioner()
template<class M, class X, class Y, int blockLevel = 2> 
template<class LOP, class Criterion, class SmootherArgs> 
 
Constructor gets all parameters to operate the prec. 
- Parameters
- 
  
    | lop | The linear operator |  | c | The criterion |  | sa | The smoother arguments |  
 
 
 
◆ apply()
template<class M, class X, class Y, int blockLevel = 2> 
 
On entry v=0 and d=b-A(x) (although this might not be computed in that way. On exit v contains the update, i.e one step computes \( v = M^{-1} d \) where \( M \) is the approximate inverse of the operator \( A \) characterizing the preconditioner. 
- Parameters
- 
  
    | v | The update to be computed |  | d | The current defect. |  
 
 
 
◆ category()
template<class M, class X, class Y, int blockLevel = 2> 
 
 
◆ post()
template<class M, class X, class Y, int blockLevel = 2> 
 
This method is called after the last apply call for the linear system to be solved. Memory may be deallocated safely here. v is the solution of the linear equation.
- Parameters
- 
  
    | v | The right hand side of the equation. |  
 
 
 
◆ pre()
template<class M, class X, class Y, int blockLevel = 2> 
 
A solver solves a linear operator equation A(v)=d by applying one or several steps of the preconditioner. The method pre() is called before the first apply operation. d and v are right hand side and solution vector of the linear system respectively. It may. e.g., scale the system, allocate memory or compute a (I)LU decomposition. Note: The ILU decomposition could also be computed in the constructor or with a separate method of the derived method if several linear systems with the same matrix are to be solved.
- Parameters
- 
  
    | v | The left hand side of the equation. |  | d | The right hand side of the equation. |  
 
 
 
The documentation for this class was generated from the following file: