Feel++  0.91.4
Public Types | Public Member Functions | Static Public Member Functions | List of all members
Feel::BackendGmm< T > Class Template Reference

#include <backendgmm.hpp>

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

Public Types

typedef super::value_type value_type
 
typedef BackendGmmDefaults defaults_type
 
typedef super::sparse_matrix_type sparse_matrix_type
 
typedef
super::sparse_matrix_ptrtype 
sparse_matrix_ptrtype
 
typedef MatrixGmm< value_type,
gmm::row_major > 
gmm_sparse_matrix_type
 
typedef boost::shared_ptr
< gmm_sparse_matrix_type
gmm_sparse_matrix_ptrtype
 
typedef
sparse_matrix_type::graph_type 
graph_type
 
typedef
sparse_matrix_type::graph_ptrtype 
graph_ptrtype
 
typedef super::vector_type vector_type
 
typedef super::vector_ptrtype vector_ptrtype
 
typedef VectorUblas< value_type > gmm_vector_type
 
typedef boost::shared_ptr
< vector_type
gmm_vector_ptrtype
 
typedef super::solve_return_type solve_return_type
 
typedef super::nl_solve_return_type nl_solve_return_type
 
- Public Types inherited from Feel::Backend< T >
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

 BackendGmm (po::variables_map const &vm, std::string const &prefix="")
 
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 matrix_properties=NON_HERMITIAN)
 
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)
 
sparse_matrix_ptrtype newMatrix (DataMap const &d1, DataMap const &d2, size_type matrix_properties=NON_HERMITIAN, bool init=true)
 
sparse_matrix_ptrtype newZeroMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l)
 
sparse_matrix_ptrtype newZeroMatrix (DataMap const &d1, DataMap const &d2)
 
vector_ptrtype newVector (DataMap const &d)
 
vector_ptrtype newVector (const size_type n, const size_type n_local)
 
void set_noisy (int noisy)
 
void set_maxiter (int maxiter)
 
void set_fillin (int fillin)
 
void set_threshold (double threshold)
 
void set_tol (double tol)
 
void set_symmetric (bool isSymmetric)
 
void set_direct (bool isDirect)
 
void set_solver_type (std::string const &solver)
 
void set_preconditioner_type (std::string const &prec)
 
void set_restart (int restart)
 
void prod (sparse_matrix_type const &A, vector_type const &x, vector_type &b) const
 
solve_return_type solve (sparse_matrix_type const &A, vector_type &x, const vector_type &b)
 
solve_return_type solve (sparse_matrix_ptrtype const &A, vector_ptrtype &x, const vector_ptrtype &b)
 
solve_return_type solve (sparse_matrix_ptrtype const &A, sparse_matrix_ptrtype const &P, vector_ptrtype &x, const vector_ptrtype &b)
 
value_type dot (const gmm_vector_type &f, const gmm_vector_type &x) const
 
bool converged ()
 
size_type get_iteration ()
 
boost::shared_ptr
< MatrixTriplet< T > > 
toTriplet (sparse_matrix_type const &m)
 
- Public Member Functions inherited from Feel::Backend< T >
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
 
 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)
 
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
 
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)))
 
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)
 
 Backend ()
 
 Backend (po::variables_map const &vm, std::string const &prefix="")
 
 Backend (Backend const &)
 
virtual ~Backend ()
 
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)
 
 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,*)))
 
template<typename DomainSpace >
vector_ptrtype newVector (DomainSpace const &dm)
 

Static Public Member Functions

template<typename DomainSpace , typename DualImageSpace >
static sparse_matrix_ptrtype newMatrix (boost::shared_ptr< DomainSpace > const &space1, boost::shared_ptr< DualImageSpace > const &space2, size_type matrix_properties=NON_HERMITIAN)
 
template<typename SpaceT >
static vector_ptrtype newVector (boost::shared_ptr< SpaceT > const &space)
 
template<typename SpaceT >
static vector_ptrtype newVector (SpaceT const &space)
 
- Static Public Member Functions inherited from Feel::Backend< T >
static backend_ptrtype build (BackendType=BACKEND_GMM)
 
static backend_ptrtype build (po::variables_map const &vm, std::string const &prefix="")
 

Additional Inherited Members

- Protected Attributes inherited from Feel::Backend< T >
preconditioner_ptrtype M_preconditioner
 

Detailed Description

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

this class provides an interface to the GMM linear algebra library

Member Function Documentation

template<typename T>
sparse_matrix_ptrtype Feel::BackendGmm< 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 
)
inlinevirtual

instantiate a new sparse vector

Implements Feel::Backend< T >.

template<typename T>
sparse_matrix_ptrtype Feel::BackendGmm< 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 
)
inlinevirtual

instantiate a new sparse vector

Implements Feel::Backend< T >.

template<typename T>
sparse_matrix_ptrtype Feel::BackendGmm< T >::newMatrix ( DataMap const &  dm1,
DataMap const &  dm2,
size_type  prop = NON_HERMITIAN,
bool  init = true 
)
inlinevirtual

instantiate a new sparse vector

Implements Feel::Backend< T >.

References Feel::DataMap::nGlobalElements().

template<typename T>
vector_ptrtype Feel::BackendGmm< T >::newVector ( DataMap const &  dm)
inlinevirtual

instantiate a new vector

Implements Feel::Backend< T >.

References Feel::DataMap::nGlobalElements().

template<typename T>
vector_ptrtype Feel::BackendGmm< T >::newVector ( const size_type  n,
const size_type  n_local 
)
inlinevirtual

instantiate a new vector

Implements Feel::Backend< T >.

template<typename T>
sparse_matrix_ptrtype Feel::BackendGmm< T >::newZeroMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l 
)
inlinevirtual

instantiate a new sparse vector

Implements Feel::Backend< T >.

template<typename T>
void Feel::BackendGmm< T >::prod ( sparse_matrix_type const &  A,
vector_type const &  x,
vector_type y 
) const
inlinevirtual
template<typename T>
solve_return_type Feel::BackendGmm< T >::solve ( sparse_matrix_ptrtype const &  A,
sparse_matrix_ptrtype const &  P,
vector_ptrtype &  x,
const vector_ptrtype &  b 
)
inlinevirtual

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

Implements Feel::Backend< T >.