My Project
|
Implements a generic linear solver abstraction. More...
#include <parallelbicgstabbackend.hh>
Public Member Functions | |
ParallelBiCGStabSolverBackend (const Simulator &simulator) | |
![]() | |
ParallelBaseBackend (const Simulator &simulator) | |
void | eraseMatrix () |
Causes the solve() method to discared the structure of the linear system of equations the next time it is called. | |
void | prepare (const SparseMatrixAdapter &M, const Vector &) |
Set up the internal data structures required for the linear solver. | |
void | setResidual (const Vector &b) |
Assign values to the internal data structure for the residual vector. | |
void | getResidual (Vector &b) const |
Retrieve the synchronized internal residual vector. | |
void | setMatrix (const SparseMatrixAdapter &M) |
Sets the values of the residual's Jacobian matrix. | |
bool | solve (Vector &x) |
Actually solve the linear system of equations. | |
size_t | iterations () const |
Return number of iterations used during last solve. | |
Static Public Member Functions | |
static void | registerParameters () |
![]() | |
static void | registerParameters () |
Register all run-time parameters for the linear solver. | |
Protected Member Functions | |
std::shared_ptr< RawLinearSolver > | prepareSolver_ (ParallelOperator &parOperator, ParallelScalarProduct &parScalarProduct, ParallelPreconditioner &parPreCond) |
std::pair< bool, int > | runSolver_ (std::shared_ptr< RawLinearSolver > solver) |
void | cleanupSolver_ () |
![]() | |
Implementation & | asImp_ () |
const Implementation & | asImp_ () const |
void | cleanup_ () |
std::shared_ptr< ParallelPreconditioner > | preparePreconditioner_ () |
void | cleanupPreconditioner_ () |
void | writeOverlapToVTK_ () |
Protected Attributes | |
friend | ParentType |
std::unique_ptr< ConvergenceCriterion< OverlappingVector > > | convCrit_ |
![]() | |
const Simulator & | simulator_ |
int | gridSequenceNumber_ |
size_t | lastIterations_ |
OverlappingMatrix * | overlappingMatrix_ |
OverlappingVector * | overlappingb_ |
OverlappingVector * | overlappingx_ |
PreconditionerWrapper | precWrapper_ |
Additional Inherited Members | |
![]() | |
enum | { dimWorld = GridView::dimensionworld } |
using | Implementation = GetPropType<TypeTag, Properties::LinearSolverBackend> |
using | Simulator = GetPropType<TypeTag, Properties::Simulator> |
using | Scalar = GetPropType<TypeTag, Properties::Scalar> |
using | LinearSolverScalar = GetPropType<TypeTag, Properties::LinearSolverScalar> |
using | SparseMatrixAdapter = GetPropType<TypeTag, Properties::SparseMatrixAdapter> |
using | Vector = GetPropType<TypeTag, Properties::GlobalEqVector> |
using | BorderListCreator = GetPropType<TypeTag, Properties::BorderListCreator> |
using | GridView = GetPropType<TypeTag, Properties::GridView> |
using | Overlap = GetPropType<TypeTag, Properties::Overlap> |
using | OverlappingVector = GetPropType<TypeTag, Properties::OverlappingVector> |
using | OverlappingMatrix = GetPropType<TypeTag, Properties::OverlappingMatrix> |
using | PreconditionerWrapper = GetPropType<TypeTag, Properties::PreconditionerWrapper> |
using | SequentialPreconditioner = typename PreconditionerWrapper::SequentialPreconditioner |
using | ParallelPreconditioner = Opm::Linear::OverlappingPreconditioner<SequentialPreconditioner, Overlap> |
using | ParallelScalarProduct = Opm::Linear::OverlappingScalarProduct<OverlappingVector, Overlap> |
using | ParallelOperator |
Implements a generic linear solver abstraction.
Chosing the preconditioner works by setting the "PreconditionerWrapper" property:
Where the choices possible for '$PRECONDITIONER'
are:
Jacobi:
A Jacobi preconditionerGaussSeidel:
A Gauss-Seidel preconditionerSSOR:
A symmetric successive overrelaxation (SSOR) preconditionerSOR:
A successive overrelaxation (SOR) preconditionerILUn:
An ILU(n) preconditionerILU0:
An ILU(0) preconditioner. The results of this preconditioner are the same as setting the PreconditionerOrder property to 0 and using the ILU(n) preconditioner. The reason for the existence of ILU0 is that it is computationally cheaper because it does not need to consider things which are only required for higher orders