Base class for linear solvers.  
#include <dumux/linear/solver.hh>
|  | 
|  | LinearSolver (const std::string ¶mGroup="") | 
|  | Construct the solver. 
 | 
|  | 
| template<class Matrix, class Vector> | 
| bool | solve (const Matrix &A, Vector &x, const Vector &b) | 
|  | Solve the linear system Ax = b. 
 | 
|  | 
| template<class Vector> | 
| auto | norm (const Vector &x) const | 
|  | 
| std::string | name () const | 
|  | the name of the linear solver 
 | 
|  | 
| const std::string & | paramGroup () const | 
|  | the parameter group for getting parameter from the parameter tree 
 | 
|  | 
| int | verbosity () const | 
|  | the verbosity level 
 | 
|  | 
| void | setVerbosity (int v) | 
|  | set the verbosity level 
 | 
|  | 
| int | maxIter () const | 
|  | the maximum number of linear solver iterations 
 | 
|  | 
| void | setMaxIter (int i) | 
|  | set the maximum number of linear solver iterations 
 | 
|  | 
| Scalar | residReduction () const | 
|  | the linear solver residual reduction 
 | 
|  | 
| void | setResidualReduction (Scalar r) | 
|  | set the linear solver residual reduction 
 | 
|  | 
| Scalar | relaxation () const | 
|  | the linear solver relaxation factor 
 | 
|  | 
| void | setRelaxation (Scalar r) | 
|  | set the linear solver relaxation factor 
 | 
|  | 
| int | precondIter () const | 
|  | the number of preconditioner iterations 
 | 
|  | 
| void | setPrecondIter (int i) | 
|  | set the number of preconditioner iterations 
 | 
|  | 
| int | precondVerbosity () const | 
|  | the preconditioner verbosity 
 | 
|  | 
| void | setPrecondVerbosity (int verbosityLevel) | 
|  | set the preconditioner verbosity 
 | 
|  | 
◆ Scalar
export Scalar type (might be needed to set parameters from output) TODO: Do we need this? 
 
 
◆ LinearSolver()
  
  | 
        
          | Dumux::LinearSolver::LinearSolver | ( | const std::string & | paramGroup = "" | ) |  |  | inline | 
 
- Note
- Read parameters from the parameter tree
- LinearSolver.Verbosity the verbosity level of the linear solver
- LinearSolver.MaxIterations the maximum iterations of the solver
- LinearSolver.ResidualReduction the residual reduction threshold, i.e. stopping criterion
- LinearSolver.Preconditioner.Relaxation precondition relaxation
- LinearSolver.Preconditioner.Iterations the number of preconditioner iterations
- LinearSolver.Preconditioner.Verbosity the preconditioner verbosity level 
 
 
 
◆ maxIter()
  
  | 
        
          | int Dumux::LinearSolver::maxIter | ( |  | ) | const |  | inline | 
 
 
◆ name()
  
  | 
        
          | std::string Dumux::LinearSolver::name | ( |  | ) | const |  | inline | 
 
 
◆ norm()
template<class Vector> 
  
  | 
        
          | auto Dumux::LinearSolver::norm | ( | const Vector & | x | ) | const |  | inline | 
 
 
◆ paramGroup()
  
  | 
        
          | const std::string & Dumux::LinearSolver::paramGroup | ( |  | ) | const |  | inline | 
 
 
◆ precondIter()
  
  | 
        
          | int Dumux::LinearSolver::precondIter | ( |  | ) | const |  | inline | 
 
 
◆ precondVerbosity()
  
  | 
        
          | int Dumux::LinearSolver::precondVerbosity | ( |  | ) | const |  | inline | 
 
 
◆ relaxation()
  
  | 
        
          | Scalar Dumux::LinearSolver::relaxation | ( |  | ) | const |  | inline | 
 
 
◆ residReduction()
  
  | 
        
          | Scalar Dumux::LinearSolver::residReduction | ( |  | ) | const |  | inline | 
 
 
◆ setMaxIter()
  
  | 
        
          | void Dumux::LinearSolver::setMaxIter | ( | int | i | ) |  |  | inline | 
 
 
◆ setPrecondIter()
  
  | 
        
          | void Dumux::LinearSolver::setPrecondIter | ( | int | i | ) |  |  | inline | 
 
 
◆ setPrecondVerbosity()
  
  | 
        
          | void Dumux::LinearSolver::setPrecondVerbosity | ( | int | verbosityLevel | ) |  |  | inline | 
 
 
◆ setRelaxation()
  
  | 
        
          | void Dumux::LinearSolver::setRelaxation | ( | Scalar | r | ) |  |  | inline | 
 
 
◆ setResidualReduction()
  
  | 
        
          | void Dumux::LinearSolver::setResidualReduction | ( | Scalar | r | ) |  |  | inline | 
 
 
◆ setVerbosity()
  
  | 
        
          | void Dumux::LinearSolver::setVerbosity | ( | int | v | ) |  |  | inline | 
 
 
◆ solve()
template<class Matrix, class Vector> 
  
  | 
        
          | bool Dumux::LinearSolver::solve | ( | const Matrix & | A, |  
          |  |  | Vector & | x, |  
          |  |  | const Vector & | b ) |  | inline | 
 
- Note
- This has to be overloaded by the actual solver 
 
 
◆ verbosity()
  
  | 
        
          | int Dumux::LinearSolver::verbosity | ( |  | ) | const |  | inline | 
 
 
The documentation for this class was generated from the following file: