Feel++  0.91.4
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
mpi::communicator 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),*(mpl::or_< boost::is_convertible< mpl::_, vector_type & >, boost::is_convertible< mpl::_, vector_ptrtype > >))(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),*(mpl::or_< boost::is_convertible< mpl::_, vector_type & >, boost::is_convertible< mpl::_, vector_ptrtype > >)))(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 ()
 Backend (po::variables_map const &vm, std::string const &prefix="")
 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
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)))
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<int NR, int NC, typename BlockType = sparse_matrix_ptrtype>
sparse_matrix_ptrtype newBlockMatrixImpl (vf::Blocks< NR, NC, 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<int NR, typename BlockType = vector_ptrtype>
vector_ptrtype newBlockVectorImpl (vf::Blocks< NR, 1, 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)
static backend_ptrtype build (po::variables_map const &vm, std::string const &prefix="")

Additional Inherited Members


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))   
)
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),*(mpl::or_< boost::is_convertible< mpl::_, vector_type & >,boost::is_convertible< mpl::_, vector_ptrtype > >))(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),*(mpl::or_< boost::is_convertible< mpl::_, vector_type & >,boost::is_convertible< mpl::_, vector_ptrtype > >)))(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
template<typename T >
Backend< T >::backend_ptrtype Feel::Backend< T >::build ( BackendType  bt = BACKEND_GMM)
static

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

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

Builds a Backend

template<typename T>
mpi::communicator 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<int NR, int NC, typename BlockType = sparse_matrix_ptrtype>
sparse_matrix_ptrtype Feel::Backend< T >::newBlockMatrixImpl ( vf::Blocks< NR, NC, 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<int NR, typename BlockType = vector_ptrtype>
vector_ptrtype Feel::Backend< T >::newBlockVectorImpl ( vf::Blocks< NR, 1, 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>
virtual vector_ptrtype Feel::Backend< T >::newVector ( DataMap const &  dm)
pure virtual
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