Feel++  0.92.0
Protected Attributes
Feel::Backend< T > Class Template Reference

base class for all linear algebra backends More...

#include <backend.hpp>

Inheritance diagram for Feel::Backend< T >:
Feel::BackendGmm< T >

List of all members.

Public Types

Typedefs
typedef T value_type
typedef type_traits< T >::real_type real_type
typedef Vector< value_type > vector_type
typedef boost::shared_ptr
< vector_type > 		vector_ptrtype
typedef MatrixSparse< value_type > sparse_matrix_type
typedef boost::shared_ptr
< sparse_matrix_type > 		sparse_matrix_ptrtype
typedef
sparse_matrix_type::graph_type 		graph_type
typedef
sparse_matrix_type::graph_ptrtype 		graph_ptrtype
typedef Backend< value_type > backend_type
typedef boost::shared_ptr
< backend_type > 		backend_ptrtype
typedef SolverNonLinear
< value_type > 		solvernonlinear_type
typedef boost::shared_ptr
< solvernonlinear_type > 		solvernonlinear_ptrtype
typedef boost::tuple< bool,
size_type, value_type > 		solve_return_type
typedef boost::tuple< bool,
size_type, value_type > 		nl_solve_return_type

Public Member Functions

Accessors
std::string kspType () const
std::string pcType () const
bool hasConstantNullSpace () const
std::string fieldsplitType () const
PreconditionerType pcEnumType () const
SolverType kspEnumType () const
FieldSplitType fieldSplitEnumType () const
std::string pcFactorMatSolverPackageType () const
MatSolverPackageType matSolverPackageEnumType () const
MatrixStructure precMatrixStructure () const
value_type rTolerance () const
value_type dTolerance () const
value_type aTolerance () const
size_type maxIterations () const
bool converged () const
size_type nIterations () const
bool transpose () const
WorldComm const & comm () const
Mutators
 BOOST_PARAMETER_MEMBER_FUNCTION ((void), setTolerances, tag,(required(rtolerance,(double)))(optional(maxit,(size_type), 1000)(atolerance,(double), 1e-50)(dtolerance,(double), 1e5)))
 BOOST_PARAMETER_MEMBER_FUNCTION ((void), setSolverType, tag,(required(ksp,(std::string)))(optional(pc,(std::string),"lu")(constant_null_space,(bool), false)(pcfactormatsolverpackage,(std::string),"petsc")))
void setPrecMatrixStructure (MatrixStructure mstruct)
solvernonlinear_ptrtype nlSolver ()
void setTranspose (bool transpose)
Methods
virtual real_type dot (vector_type const &x, vector_type const &y) const
real_type dot (vector_ptrtype const &x, vector_ptrtype const &y) const
virtual void prod (sparse_matrix_type const &A, vector_type const &x, vector_type &y) const =0
void prod (sparse_matrix_ptrtype const &A, vector_ptrtype const &x, vector_ptrtype &y) const
 BOOST_PARAMETER_MEMBER_FUNCTION ((solve_return_type), solve, tag,(required(matrix,(sparse_matrix_ptrtype))(in_out(solution),*)(rhs,(vector_ptrtype)))(optional(prec,(preconditioner_ptrtype), preconditioner(_matrix=matrix, _pc=LU_PRECOND, _backend=BACKEND_PETSC))(maxit,(size_type), M_maxit)(rtolerance,(double), M_rtolerance)(atolerance,(double), M_atolerance)(dtolerance,(double), M_dtolerance)(reuse_prec,(bool), M_reuse_prec)(transpose,(bool), false)(constant_null_space,(bool), false)(pc,(std::string), M_pc)(ksp,(std::string), M_ksp)(pcfactormatsolverpackage,(std::string), M_pcFactorMatSolverPackage)))
virtual solve_return_type solve (sparse_matrix_ptrtype const &A, sparse_matrix_ptrtype const &P, vector_ptrtype &x, vector_ptrtype const &b)=0
solve_return_type solve (sparse_matrix_ptrtype const &A, sparse_matrix_ptrtype const &P, vector_ptrtype &x, vector_ptrtype const &b, bool reuse_prec)
 BOOST_PARAMETER_MEMBER_FUNCTION ((nl_solve_return_type), nlSolve, tag,(required(in_out(solution),*))(optional(jacobian,(sparse_matrix_ptrtype), sparse_matrix_ptrtype())(residual,(vector_ptrtype), vector_ptrtype())(prec,(preconditioner_ptrtype), preconditioner(_pc=LU_PRECOND, _backend=BACKEND_PETSC))(maxit,(size_type), M_maxit)(rtolerance,(double), M_rtolerance)(atolerance,(double), M_atolerance)(dtolerance,(double), M_dtolerance)(reuse_prec,(bool), M_reuse_prec)(reuse_jac,(bool), M_reuse_jac)(transpose,(bool), false)(pc,(std::string), M_pc)(ksp,(std::string), M_ksp)(pcfactormatsolverpackage,(std::string), M_pcFactorMatSolverPackage)))
virtual nl_solve_return_type nlSolve (sparse_matrix_ptrtype &A, vector_ptrtype &x, vector_ptrtype &b, const double, const int)
virtual nl_solve_return_type nlSolve (sparse_matrix_ptrtype &A, vector_ptrtype &x, vector_ptrtype &b, const double, const int, bool reusePC, bool reuseJAC)
void attachPreconditioner (preconditioner_ptrtype preconditioner)

Protected Attributes

preconditioner_ptrtype M_preconditioner

Constructors, destructor

 Backend (WorldComm const &worldComm=WorldComm())
 Backend (po::variables_map const &vm, std::string const &prefix="", WorldComm const &worldComm=WorldComm())
 Backend (Backend const &)
virtual ~Backend ()
virtual sparse_matrix_ptrtype newMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l, const size_type nnz=30, const size_type noz=10, size_type prop=NON_HERMITIAN)=0
virtual sparse_matrix_ptrtype newMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l, graph_ptrtype const &graph, size_type matrix_properties=NON_HERMITIAN)=0
sparse_matrix_ptrtype newMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l, graph_ptrtype const &graph, std::vector< std::vector< int > > indexSplit, size_type matrix_properties=NON_HERMITIAN)
virtual sparse_matrix_ptrtype newMatrix (DataMap const &dm1, DataMap const &dm2, size_type prop=NON_HERMITIAN, bool init=true)=0
sparse_matrix_ptrtype newMatrix (DataMap const &domainmap, DataMap const &imagemap, graph_ptrtype const &graph, size_type matrix_properties=NON_HERMITIAN, bool init=true)
virtual sparse_matrix_ptrtype newZeroMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l)=0
virtual sparse_matrix_ptrtype newZeroMatrix (DataMap const &dm1, DataMap const &dm2)=0
 BOOST_PARAMETER_MEMBER_FUNCTION ((sparse_matrix_ptrtype), newMatrix, tag,(required(trial,*(boost::is_convertible< mpl::_, boost::shared_ptr< FunctionSpaceBase > >))(test,*(boost::is_convertible< mpl::_, boost::shared_ptr< FunctionSpaceBase > >)))(optional(pattern,(size_type), Pattern::COUPLED)(properties,(size_type), NON_HERMITIAN)(buildGraphWithTranspose,(bool), false)(pattern_block,*,(vf::Blocks< 1, 1, size_type >(size_type(Pattern::HAS_NO_BLOCK_PATTERN))))(diag_is_nonzero,*(boost::is_integral< mpl::_ >), true)(verbose,(int), 0)(collect_garbage,*(boost::is_integral< mpl::_ >), true)))
template<typename DomainSpace , typename ImageSpace >
sparse_matrix_ptrtype newMatrix (DomainSpace const &dm, ImageSpace const &im, sparse_matrix_ptrtype const &M, size_type prop=NON_HERMITIAN)
template<typename BlockType = sparse_matrix_ptrtype>
sparse_matrix_ptrtype newBlockMatrixImpl (vf::BlocksBase< BlockType > const &b, bool copy_values=true, bool diag_is_nonzero=true)
 BOOST_PARAMETER_MEMBER_FUNCTION ((sparse_matrix_ptrtype), newBlockMatrix, tag,(required(block,*))(optional(copy_values,*(boost::is_integral< mpl::_ >), true)(diag_is_nonzero,*(boost::is_integral< mpl::_ >), true)))
template<typename BlockType = vector_ptrtype>
vector_ptrtype newBlockVectorImpl (vf::BlocksBase< BlockType > const &b, bool copy_values=true)
 BOOST_PARAMETER_MEMBER_FUNCTION ((vector_ptrtype), newBlockVector, tag,(required(block,*))(optional(copy_values,*(boost::is_integral< mpl::_ >), true)))
 BOOST_PARAMETER_MEMBER_FUNCTION ((sparse_matrix_ptrtype), newZeroMatrix, tag,(required(test,*)(trial,*)))
virtual vector_ptrtype newVector (DataMap const &dm)=0
virtual vector_ptrtype newVector (const size_type n, const size_type n_local)=0
template<typename DomainSpace >
vector_ptrtype newVector (DomainSpace const &dm)
static backend_ptrtype build (BackendType=BACKEND_GMM, WorldComm const &worldComm=WorldComm())
static backend_ptrtype build (po::variables_map const &vm, std::string const &prefix="", WorldComm const &worldComm=WorldComm())

Detailed Description

template<typename T>
class Feel::Backend< T >

base class for all linear algebra backends

Author:
Christophe Prud'homme
See also:

Member Function Documentation

template<typename T>
value_type Feel::Backend< T >::aTolerance ( ) const [inline]
Returns:
the absolute tolerance
template<typename T>
void Feel::Backend< T >::attachPreconditioner ( preconditioner_ptrtype  preconditioner) [inline]

Attaches a Preconditioner object to be used by the solver

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (sparse_matrix_ptrtype)  ,
newMatrix  ,
tag  ,
(required(trial,*(boost::is_convertible< mpl::_, boost::shared_ptr< FunctionSpaceBase > >))(test,*(boost::is_convertible< mpl::_, boost::shared_ptr< FunctionSpaceBase > >)))(optional(pattern,(size_type), Pattern::COUPLED)(properties,(size_type), NON_HERMITIAN)(buildGraphWithTranspose,(bool), false)(pattern_block,*,(vf::Blocks< 1, 1, size_type >(size_type(Pattern::HAS_NO_BLOCK_PATTERN))))(diag_is_nonzero,*(boost::is_integral< mpl::_ >), true)(verbose,(int), 0)(collect_garbage,*(boost::is_integral< mpl::_ >), true))   
) [inline]

helper function

References Feel::Backend< T >::newMatrix().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (sparse_matrix_ptrtype)  ,
newBlockMatrix  ,
tag  ,
(required(block,*))(optional(copy_values,*(boost::is_integral< mpl::_ >), true)(diag_is_nonzero,*(boost::is_integral< mpl::_ >), true))   
) [inline]

instantiate a new block matrix sparse

References Feel::Backend< T >::newBlockMatrixImpl().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (vector_ptrtype)  ,
newBlockVector  ,
tag  ,
(required(block,*))(optional(copy_values,*(boost::is_integral< mpl::_ >), true))   
) [inline]

instantiate a new block matrix sparse

References Feel::Backend< T >::newBlockVectorImpl().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (sparse_matrix_ptrtype)  ,
newZeroMatrix  ,
tag  ,
(required(test,*)(trial,*))   
) [inline]

instantiate a new zero matrix

References Feel::Backend< T >::newZeroMatrix().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (void)  ,
setTolerances  ,
tag  ,
(required(rtolerance,(double)))(optional(maxit,(size_type), 1000)(atolerance,(double),1e-50)(dtolerance,(double),1e5))   
) [inline]

set tolerances: relative tolerance rtol, divergence tolerance dtol and absolute tolerance atol

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (void)  ,
setSolverType  ,
tag  ,
(required(ksp,(std::string)))(optional(pc,(std::string),"lu")(constant_null_space,(bool), false)(pcfactormatsolverpackage,(std::string),"petsc"))   
) [inline]

set solver: krylov subspace method and preconditioners

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (solve_return_type)  ,
solve  ,
tag  ,
(required(matrix,(sparse_matrix_ptrtype))(in_out(solution),*)(rhs,(vector_ptrtype)))(optional(prec,(preconditioner_ptrtype), preconditioner(_matrix=matrix, _pc=LU_PRECOND, _backend=BACKEND_PETSC))(maxit,(size_type), M_maxit)(rtolerance,(double), M_rtolerance)(atolerance,(double), M_atolerance)(dtolerance,(double), M_dtolerance)(reuse_prec,(bool), M_reuse_prec)(transpose,(bool), false)(constant_null_space,(bool), false)(pc,(std::string), M_pc)(ksp,(std::string), M_ksp)(pcfactormatsolverpackage,(std::string), M_pcFactorMatSolverPackage))   
) [inline]

solve for $P A x = P b$ where $P$ is an approximation of the inverse of $A$. this interface uses the boost.parameter library to ease the function usage

Parameters:
Amatrix to inverse
rhsright hand side vector
solutionsolution of the system
Ppreconditioner
maxitmaximum number of iterations
tolerancetolerance on the residual
reuse_precif true use adaptive preconditioning strategy
transposeif true solve the transpose problem
Warning:
some parameter may not be meaningful for all backends

References Feel::Backend< T >::attachPreconditioner(), Feel::Backend< T >::newVector(), Feel::Backend< T >::setPrecMatrixStructure(), and Feel::Backend< T >::solve().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (nl_solve_return_type)  ,
nlSolve  ,
tag  ,
(required(in_out(solution),*))(optional(jacobian,(sparse_matrix_ptrtype), sparse_matrix_ptrtype())(residual,(vector_ptrtype), vector_ptrtype())(prec,(preconditioner_ptrtype), preconditioner(_pc=LU_PRECOND, _backend=BACKEND_PETSC))(maxit,(size_type), M_maxit)(rtolerance,(double), M_rtolerance)(atolerance,(double), M_atolerance)(dtolerance,(double), M_dtolerance)(reuse_prec,(bool), M_reuse_prec)(reuse_jac,(bool), M_reuse_jac)(transpose,(bool), false)(pc,(std::string), M_pc)(ksp,(std::string), M_ksp)(pcfactormatsolverpackage,(std::string), M_pcFactorMatSolverPackage))   
) [inline]

solve for $P F(x)=0 b$

References Feel::Backend< T >::newVector(), Feel::Backend< T >::nlSolve(), and Feel::Backend< T >::nlSolver().

template<typename T >
Backend< T >::backend_ptrtype Feel::Backend< T >::build ( BackendType  bt = BACKEND_GMM,
WorldComm const &  worldComm = WorldComm() 
) [static]

Builds a Backend, if Petsc is available, use Petsc by default, otherwise use GMM which is distributed with feel

Referenced by Feel::CRB< TruthModelType >::offline(), and Feel::POD< TruthModelType >::pod().

template<typename T >
Backend< T >::backend_ptrtype Feel::Backend< T >::build ( po::variables_map const &  vm,
std::string const &  prefix = "",
WorldComm const &  worldComm = WorldComm() 
) [static]

Builds a Backend

template<typename T>
WorldComm const& Feel::Backend< T >::comm ( ) const [inline]
Returns:
the communicator
template<typename T >
Backend< T >::real_type Feel::Backend< T >::dot ( vector_type const &  x,
vector_type const &  y 
) const [virtual]

clean up

Returns:
$ r = x^T * y $

References Feel::Vector< T >::localSize().

Referenced by Feel::Backend< T >::dot().

template<typename T>
real_type Feel::Backend< T >::dot ( vector_ptrtype const &  x,
vector_ptrtype const &  y 
) const [inline]
Returns:
$ r = x^T * y $

References Feel::Backend< T >::dot().

template<typename T>
value_type Feel::Backend< T >::dTolerance ( ) const [inline]
Returns:
the divergence tolerance
template<typename T >
FieldSplitType Feel::Backend< T >::fieldSplitEnumType ( ) const
Returns:
enum fieldsplit type from options
template<typename T>
std::string Feel::Backend< T >::fieldsplitType ( ) const [inline]
Returns:
the type of fieldsplitType
template<typename T>
bool Feel::Backend< T >::hasConstantNullSpace ( ) const [inline]

return true if the null space is the constant values, false otherwise

template<typename T >
SolverType Feel::Backend< T >::kspEnumType ( ) const
Returns:
enum solver type from options
template<typename T>
std::string Feel::Backend< T >::kspType ( ) const [inline]
Returns:
the type of linear solver
template<typename T >
MatSolverPackageType Feel::Backend< T >::matSolverPackageEnumType ( ) const
Returns:
enum MatSolverPackage type from options
template<typename T>
size_type Feel::Backend< T >::maxIterations ( ) const [inline]
Returns:
the maximum number of iterations
template<typename T>
template<typename BlockType = sparse_matrix_ptrtype>
sparse_matrix_ptrtype Feel::Backend< T >::newBlockMatrixImpl ( vf::BlocksBase< BlockType > const &  b,
bool  copy_values = true,
bool  diag_is_nonzero = true 
) [inline]

instantiate a new block matrix sparse

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T>
template<typename BlockType = vector_ptrtype>
vector_ptrtype Feel::Backend< T >::newBlockVectorImpl ( vf::BlocksBase< BlockType > const &  b,
bool  copy_values = true 
) [inline]

instantiate a new block matrix sparse

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T>
virtual sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l,
const size_type  nnz = 30,
const size_type  noz = 10,
size_type  prop = NON_HERMITIAN 
) [pure virtual]

instantiate a new sparse vector

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION(), and Feel::Backend< T >::newMatrix().

template<typename T>
virtual sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l,
graph_ptrtype const &  graph,
size_type  matrix_properties = NON_HERMITIAN 
) [pure virtual]

instantiate a new sparse vector

Implemented in Feel::BackendGmm< T >.

template<typename T>
sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l,
graph_ptrtype const &  graph,
std::vector< std::vector< int > >  indexSplit,
size_type  matrix_properties = NON_HERMITIAN 
) [inline]

instantiate a new sparse vector

References Feel::Backend< T >::newMatrix().

template<typename T>
virtual sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( DataMap const &  dm1,
DataMap const &  dm2,
size_type  prop = NON_HERMITIAN,
bool  init = true 
) [pure virtual]

instantiate a new sparse vector

Implemented in Feel::BackendGmm< T >.

template<typename T>
sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( DataMap const &  domainmap,
DataMap const &  imagemap,
graph_ptrtype const &  graph,
size_type  matrix_properties = NON_HERMITIAN,
bool  init = true 
) [inline]

instantiate a new sparse vector

References Feel::DataMap::nDof(), Feel::Backend< T >::newMatrix(), and Feel::DataMap::nLocalDofWithoutGhost().

template<typename T>
virtual vector_ptrtype Feel::Backend< T >::newVector ( DataMap const &  dm) [pure virtual]

instantiate a new vector

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION(), and Feel::Backend< T >::newVector().

template<typename T>
virtual vector_ptrtype Feel::Backend< T >::newVector ( const size_type  n,
const size_type  n_local 
) [pure virtual]

instantiate a new vector

Implemented in Feel::BackendGmm< T >.

template<typename T>
template<typename DomainSpace >
vector_ptrtype Feel::Backend< T >::newVector ( DomainSpace const &  dm) [inline]

helper function

References Feel::Backend< T >::newVector().

template<typename T>
virtual sparse_matrix_ptrtype Feel::Backend< T >::newZeroMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l 
) [pure virtual]

instantiate a new sparse vector

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T >
Backend< T >::nl_solve_return_type Feel::Backend< T >::nlSolve ( sparse_matrix_ptrtype &  A,
vector_ptrtype &  x,
vector_ptrtype &  b,
const double  tol,
const int  its 
) [virtual]

solve for the nonlinear problem $F( u ) = 0$

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T >
Backend< T >::nl_solve_return_type Feel::Backend< T >::nlSolve ( sparse_matrix_ptrtype &  A,
vector_ptrtype &  x,
vector_ptrtype &  b,
const double  tol,
const int  its,
bool  reusePC,
bool  reuseJAC 
) [virtual]

solve for the nonlinear problem $F( u ) = 0$ with an adaptive strategy to reuse the preconditioner

template<typename T>
solvernonlinear_ptrtype Feel::Backend< T >::nlSolver ( ) [inline]
Returns:
the non linear solver

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T >
PreconditionerType Feel::Backend< T >::pcEnumType ( ) const
Returns:
enum pc type from options
template<typename T>
std::string Feel::Backend< T >::pcFactorMatSolverPackageType ( ) const [inline]
Returns:
the type of pcFactorMatSolverPackageType
template<typename T>
std::string Feel::Backend< T >::pcType ( ) const [inline]
Returns:
the type of preconditioner
template<typename T>
MatrixStructure Feel::Backend< T >::precMatrixStructure ( ) const [inline]
Returns:
the type of preconditioner associated to the matrix
template<typename T>
virtual void Feel::Backend< T >::prod ( sparse_matrix_type const &  A,
vector_type const &  x,
vector_type &  y 
) const [pure virtual]
Returns:
$ y = A * x $

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::prod().

template<typename T>
void Feel::Backend< T >::prod ( sparse_matrix_ptrtype const &  A,
vector_ptrtype const &  x,
vector_ptrtype &  y 
) const [inline]
Returns:
$ y = A * x $

References Feel::Backend< T >::prod().

template<typename T>
value_type Feel::Backend< T >::rTolerance ( ) const [inline]
Returns:
the relative tolerance
template<typename T>
void Feel::Backend< T >::setPrecMatrixStructure ( MatrixStructure  mstruct) [inline]

set the type of preconditioner associated to the matrix

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T>
virtual solve_return_type Feel::Backend< T >::solve ( sparse_matrix_ptrtype const &  A,
sparse_matrix_ptrtype const &  P,
vector_ptrtype &  x,
vector_ptrtype const &  b 
) [pure virtual]

solve for $P A x = P b$ where $P$ is an approximation of the inverse of $A$.

Parameters:
Amatrix to inverse
rhsright hand side vector
solutionsolution of the system
Ppreconditioner
maxitmaximum number of iterations
tolerancetolerance on the residual
transposeif true solve the transpose problem
Warning:
some parameter may not be meaningful for all backends

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T >
Backend< T >::solve_return_type Feel::Backend< T >::solve ( sparse_matrix_ptrtype const &  A,
sparse_matrix_ptrtype const &  P,
vector_ptrtype &  x,
vector_ptrtype const &  b,
bool  reuse_prec 
)

solve for $P A x = P b$ where $P$ is an approximation of the inverse of $A$ using an adaptive preconditioning strategy.

Parameters:
Amatrix to inverse
rhsright hand side vector
solutionsolution of the system
Ppreconditioner
maxitmaximum number of iterations
tolerancetolerance on the residual
transposeif true solve the transpose problem
Warning:
some parameter may not be meaningful for all backends
Generated on Fri May 18 2012 04:39:02 for Feel++ by   doxygen 1.7.6.1