Eigen::PastixLU< _MatrixType, IsStrSym > Class Template Reference

Interface to the PaStix solver. More...

#include <src/eigen/Eigen/src/PaStiXSupport/PaStiXSupport.h>

Inheritance diagram for Eigen::PastixLU< _MatrixType, IsStrSym >:

Collaboration diagram for Eigen::PastixLU< _MatrixType, IsStrSym >:

Public Types
typedef _MatrixType	MatrixType
typedef PastixBase< PastixLU< MatrixType > >	Base
typedef Base::ColSpMatrix	ColSpMatrix
typedef MatrixType::StorageIndex	StorageIndex
enum
typedef internal::pastix_traits< PastixLU< _MatrixType > >::MatrixType	_MatrixType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef Matrix< Scalar, Dynamic, 1 >	Vector

Public Member Functions
	PastixLU ()
	PastixLU (const MatrixType &matrix)
void	compute (const MatrixType &matrix)
void	analyzePattern (const MatrixType &matrix)
void	factorize (const MatrixType &matrix)
bool	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &x) const
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const
Array< StorageIndex, IPARM_SIZE, 1 > &	iparm ()
int &	iparm (int idxparam)
Array< double, DPARM_SIZE, 1 > &	dparm ()
double &	dparm (int idxparam)
Index	cols () const
Index	rows () const
ComputationInfo	info () const
	Reports whether previous computation was successful.
template<typename Rhs >
const Solve< Derived, Rhs >	solve (const MatrixBase< Rhs > &b) const
template<typename Rhs >
const Solve< Derived, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const

Protected Member Functions
void	init ()
void	grabMatrix (const MatrixType &matrix, ColSpMatrix &out)
void	analyzePattern (ColSpMatrix &mat)
void	factorize (ColSpMatrix &mat)
void	clean ()
void	compute (ColSpMatrix &mat)
PastixLU< _MatrixType > &	derived ()
const PastixLU< _MatrixType > &	derived () const

Protected Attributes
ColSpMatrix	m_transposedStructure
bool	m_structureIsUptodate
Array< int, IPARM_SIZE, 1 >	m_iparm
Array< double, DPARM_SIZE, 1 >	m_dparm
int	m_initisOk
int	m_analysisIsOk
int	m_factorizationIsOk
ComputationInfo	m_info
pastix_data_t *	m_pastixdata
int	m_comm
Matrix< StorageIndex, Dynamic, 1 >	m_perm
Matrix< StorageIndex, Dynamic, 1 >	m_invp
int	m_size
bool	m_isInitialized

Detailed Description

template<typename _MatrixType, bool IsStrSym>
class Eigen::PastixLU< _MatrixType, IsStrSym >

Interface to the PaStix solver.

Sparse direct LU solver based on PaStiX library.

This class is used to solve the linear systems A.X = B via the PaStix library. The matrix can be either real or complex, symmetric or not.

See also

TutorialSparseDirectSolvers

This class is used to solve the linear systems A.X = B with a supernodal LU factorization in the PaStiX library. The matrix A should be squared and nonsingular PaStiX requires that the matrix A has a symmetric structural pattern. This interface can symmetrize the input matrix otherwise. The vectors or matrices X and B can be either dense or sparse.

Template Parameters

_MatrixType	the type of the sparse matrix A, it must be a SparseMatrix<>
IsStrSym	Indicates if the input matrix has a symmetric pattern, default is false NOTE : Note that if the analysis and factorization phase are called separately, the input matrix will be symmetrized at each call, hence it is advised to symmetrize the matrix in a end-user program and set IsStrSym to true

\implsparsesolverconcept

See also

TutorialSparseSolverConcept, class SparseLU

Member Typedef Documentation

_MatrixType

typedef internal::pastix_traits<PastixLU< _MatrixType > >::MatrixType Eigen::PastixBase< PastixLU< _MatrixType > >::_MatrixType

inherited

Base

template<typename _MatrixType , bool IsStrSym>

typedef PastixBase<PastixLU<MatrixType> > Eigen::PastixLU< _MatrixType, IsStrSym >::Base

ColSpMatrix

template<typename _MatrixType , bool IsStrSym>

typedef Base::ColSpMatrix Eigen::PastixLU< _MatrixType, IsStrSym >::ColSpMatrix

MatrixType

template<typename _MatrixType , bool IsStrSym>

typedef _MatrixType Eigen::PastixLU< _MatrixType, IsStrSym >::MatrixType

RealScalar

typedef MatrixType::RealScalar Eigen::PastixBase< PastixLU< _MatrixType > >::RealScalar

inherited

Scalar

typedef MatrixType::Scalar Eigen::PastixBase< PastixLU< _MatrixType > >::Scalar

inherited

StorageIndex

template<typename _MatrixType , bool IsStrSym>

typedef MatrixType::StorageIndex Eigen::PastixLU< _MatrixType, IsStrSym >::StorageIndex

Vector

typedef Matrix<Scalar,Dynamic,1> Eigen::PastixBase< PastixLU< _MatrixType > >::Vector

inherited

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

         {
      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
    };

Constructor & Destructor Documentation

PastixLU() [1/2]

template<typename _MatrixType , bool IsStrSym>

Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU ( )

inline

               : Base()
    {
      init();
    }

References Eigen::PastixLU< _MatrixType, IsStrSym >::init().

Here is the call graph for this function:

PastixLU() [2/2]

template<typename _MatrixType , bool IsStrSym>

Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU ( const MatrixType &  matrix )

inlineexplicit

                                               :Base()
    {
      init();
      compute(matrix);
    }

References Eigen::PastixLU< _MatrixType, IsStrSym >::compute(), and Eigen::PastixLU< _MatrixType, IsStrSym >::init().

Here is the call graph for this function:

Member Function Documentation

_solve_impl() [1/2]

bool Eigen::PastixBase< Base >::_solve_impl ( const MatrixBase< Rhs > &  b, MatrixBase< Dest > &  x  ) const

inherited

{
  eigen_assert(m_isInitialized && "The matrix should be factorized first");
  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
                     THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
  int rhs = 1;
  
  x = b; /* on return, x is overwritten by the computed solution */
  
  for (int i = 0; i < b.cols(); i++){
    m_iparm[IPARM_START_TASK]          = API_TASK_SOLVE;
    m_iparm[IPARM_END_TASK]            = API_TASK_REFINE;
  
    internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, internal::convert_index<int>(x.rows()), 0, 0, 0,
                           m_perm.data(), m_invp.data(), &x(0, i), rhs, m_iparm.data(), m_dparm.data());
  }
  
  // Check the returned error
  m_info = m_iparm(IPARM_ERROR_NUMBER)==0 ? Success : NumericalIssue;
  
  return m_iparm(IPARM_ERROR_NUMBER)==0;
}

_solve_impl() [2/2]

void Eigen::SparseSolverBase< PastixLU< _MatrixType > >::_solve_impl ( const SparseMatrixBase< Rhs > &  b, SparseMatrixBase< Dest > &  dest  ) const

inlineinherited

    {
      internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
    }

analyzePattern() [1/2]

void Eigen::PastixBase< PastixLU< _MatrixType > >::analyzePattern ( ColSpMatrix &  mat )

protectedinherited

{                         
  eigen_assert(m_initisOk && "The initialization of PaSTiX failed");
  
  // clean previous calls
  if(m_size>0)
    clean();
  
  m_size = internal::convert_index<int>(mat.rows());
  m_perm.resize(m_size);
  m_invp.resize(m_size);
  
  m_iparm(IPARM_START_TASK) = API_TASK_ORDERING;
  m_iparm(IPARM_END_TASK) = API_TASK_ANALYSE;
  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
  
  // Check the returned error
  if(m_iparm(IPARM_ERROR_NUMBER))
  {
    m_info = NumericalIssue;
    m_analysisIsOk = false;
  }
  else
  { 
    m_info = Success;
    m_analysisIsOk = true;
  }
}

analyzePattern() [2/2]

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::analyzePattern ( const MatrixType &  matrix )

inline

Compute the LU symbolic factorization of matrix using its sparsity pattern. Several ordering methods can be used at this step. See the PaStiX user's manual. The result of this operation can be used with successive matrices having the same pattern as matrix

See also

factorize()

    {
      m_structureIsUptodate = false;
      ColSpMatrix temp;
      grabMatrix(matrix, temp);
      Base::analyzePattern(temp);
    }

References Eigen::PastixBase< Derived >::analyzePattern(), Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix(), and Eigen::PastixLU< _MatrixType, IsStrSym >::m_structureIsUptodate.

Here is the call graph for this function:

clean()

void Eigen::PastixBase< PastixLU< _MatrixType > >::clean ( )

inlineprotectedinherited

    {
      eigen_assert(m_initisOk && "The Pastix structure should be allocated first"); 
      m_iparm(IPARM_START_TASK) = API_TASK_CLEAN;
      m_iparm(IPARM_END_TASK) = API_TASK_CLEAN;
      internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
                             m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
    }

cols()

Index Eigen::PastixBase< PastixLU< _MatrixType > >::cols ( ) const

inlineinherited

{ return m_size; }

compute() [1/2]

void Eigen::PastixBase< PastixLU< _MatrixType > >::compute ( ColSpMatrix &  mat )

protectedinherited

{
  eigen_assert(mat.rows() == mat.cols() && "The input matrix should be squared");
  
  analyzePattern(mat);  
  factorize(mat);
  
  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
}

compute() [2/2]

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::compute ( const MatrixType &  matrix )

inline

Compute the LU supernodal factorization of matrix. iparm and dparm can be used to tune the PaStiX parameters. see the PaStiX user's manual

See also

analyzePattern() factorize()

    {
      m_structureIsUptodate = false;
      ColSpMatrix temp;
      grabMatrix(matrix, temp);
      Base::compute(temp);
    }

References Eigen::PastixBase< Derived >::compute(), Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix(), and Eigen::PastixLU< _MatrixType, IsStrSym >::m_structureIsUptodate.

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU().

Here is the call graph for this function:

Here is the caller graph for this function:

derived() [1/2]

PastixLU< _MatrixType > & Eigen::SparseSolverBase< PastixLU< _MatrixType > >::derived ( )

inlineprotectedinherited

{ return *static_cast<Derived*>(this); }

derived() [2/2]

const PastixLU< _MatrixType > & Eigen::SparseSolverBase< PastixLU< _MatrixType > >::derived ( ) const

inlineprotectedinherited

{ return *static_cast<const Derived*>(this); }

dparm() [1/2]

Array< double, DPARM_SIZE, 1 > & Eigen::PastixBase< PastixLU< _MatrixType > >::dparm ( )

inlineinherited

Returns a reference to the double vector DPARM of PaStiX parameters The statistics related to the different phases of factorization and solve are saved here as well

See also

analyzePattern() factorize()

    {
      return m_dparm; 
    }

dparm() [2/2]

double & Eigen::PastixBase< PastixLU< _MatrixType > >::dparm ( int  idxparam )

inlineinherited

Return a reference to a particular index parameter of the DPARM vector

See also

dparm()

    {
      return m_dparm(idxparam);
    }

factorize() [1/2]

void Eigen::PastixBase< PastixLU< _MatrixType > >::factorize ( ColSpMatrix &  mat )

protectedinherited

{
//   if(&m_cpyMat != &mat) m_cpyMat = mat;
  eigen_assert(m_analysisIsOk && "The analysis phase should be called before the factorization phase");
  m_iparm(IPARM_START_TASK) = API_TASK_NUMFACT;
  m_iparm(IPARM_END_TASK) = API_TASK_NUMFACT;
  m_size = internal::convert_index<int>(mat.rows());
  
  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
  
  // Check the returned error
  if(m_iparm(IPARM_ERROR_NUMBER))
  {
    m_info = NumericalIssue;
    m_factorizationIsOk = false;
    m_isInitialized = false;
  }
  else
  {
    m_info = Success;
    m_factorizationIsOk = true;
    m_isInitialized = true;
  }
}

factorize() [2/2]

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::factorize ( const MatrixType &  matrix )

inline

Compute the LU supernodal factorization of matrix WARNING The matrix matrix should have the same structural pattern as the same used in the analysis phase.

See also

analyzePattern()

    {
      ColSpMatrix temp;
      grabMatrix(matrix, temp);
      Base::factorize(temp);
    }

References Eigen::PastixBase< Derived >::factorize(), and Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix().

Here is the call graph for this function:

grabMatrix()

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix ( const MatrixType &  matrix, ColSpMatrix &  out  )

inlineprotected

    {
      if(IsStrSym)
        out = matrix;
      else
      {
        if(!m_structureIsUptodate)
        {
          // update the transposed structure
          m_transposedStructure = matrix.transpose();
          
          // Set the elements of the matrix to zero 
          for (Index j=0; j<m_transposedStructure.outerSize(); ++j) 
            for(typename ColSpMatrix::InnerIterator it(m_transposedStructure, j); it; ++it)
              it.valueRef() = 0.0;
 
          m_structureIsUptodate = true;
        }
        
        out = m_transposedStructure + matrix;
      }
      internal::c_to_fortran_numbering(out);
    }

References Eigen::internal::c_to_fortran_numbering(), Eigen::PastixLU< _MatrixType, IsStrSym >::m_structureIsUptodate, Eigen::PastixLU< _MatrixType, IsStrSym >::m_transposedStructure, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerSize(), and Eigen::SparseMatrixBase< Derived >::transpose().

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::analyzePattern(), Eigen::PastixLU< _MatrixType, IsStrSym >::compute(), and Eigen::PastixLU< _MatrixType, IsStrSym >::factorize().

Here is the call graph for this function:

Here is the caller graph for this function:

info()

ComputationInfo Eigen::PastixBase< PastixLU< _MatrixType > >::info ( ) const

inlineinherited

Reports whether previous computation was successful.

Returns

Success if computation was succesful, NumericalIssue if the PaStiX reports a problem InvalidInput if the input matrix is invalid

See also

iparm()

    {
      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
      return m_info;
    }

init()

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::init ( )

inlineprotected

    {
      m_structureIsUptodate = false;
      m_iparm(IPARM_SYM) = API_SYM_NO;
      m_iparm(IPARM_FACTORIZATION) = API_FACT_LU;
    }

References Eigen::PastixLU< _MatrixType, IsStrSym >::m_iparm, and Eigen::PastixLU< _MatrixType, IsStrSym >::m_structureIsUptodate.

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU(), and Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU().

Here is the caller graph for this function:

iparm() [1/2]

Array< StorageIndex, IPARM_SIZE, 1 > & Eigen::PastixBase< PastixLU< _MatrixType > >::iparm ( )

inlineinherited

Returns a reference to the integer vector IPARM of PaStiX parameters to modify the default parameters. The statistics related to the different phases of factorization and solve are saved here as well

See also

analyzePattern() factorize()

    {
      return m_iparm; 
    }

iparm() [2/2]

int & Eigen::PastixBase< PastixLU< _MatrixType > >::iparm ( int  idxparam )

inlineinherited

Return a reference to a particular index parameter of the IPARM vector

See also

iparm()

    {
      return m_iparm(idxparam);
    }

rows()

Index Eigen::PastixBase< PastixLU< _MatrixType > >::rows ( ) const

inlineinherited

{ return m_size; }

solve() [1/2]

template<typename Derived >

template<typename Rhs >

const Solve< Derived, Rhs > Eigen::SparseSolverBase< Derived >::solve ( const MatrixBase< Rhs > &  b ) const

inlineinherited

Returns

an expression of the solution x of using the current decomposition of A.

See also

compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

References Eigen::SparseSolverBase< Derived >::derived(), eigen_assert, and Eigen::SparseSolverBase< Derived >::m_isInitialized.

Referenced by igl::embree::bone_heat(), igl::Frame_field_deformer::compute_optimal_positions(), igl::eigs(), igl::copyleft::comiso::FrameInterpolator::interpolateSymmetric(), igl::slim::solve_weighted_arap(), and igl::copyleft::comiso::NRosyField::solveNoRoundings().

Here is the call graph for this function:

Here is the caller graph for this function:

solve() [2/2]

template<typename Derived >

template<typename Rhs >

const Solve< Derived, Rhs > Eigen::SparseSolverBase< Derived >::solve ( const SparseMatrixBase< Rhs > &  b ) const

inlineinherited

Returns

an expression of the solution x of using the current decomposition of A.

See also

compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

Member Data Documentation

m_analysisIsOk

int Eigen::PastixBase< PastixLU< _MatrixType > >::m_analysisIsOk

protectedinherited

m_comm

int Eigen::PastixBase< PastixLU< _MatrixType > >::m_comm

mutableprotectedinherited

m_dparm

template<typename _MatrixType , bool IsStrSym>

Array<double,DPARM_SIZE,1> Eigen::PastixBase< Derived >::m_dparm

mutableprotected

m_factorizationIsOk

int Eigen::PastixBase< PastixLU< _MatrixType > >::m_factorizationIsOk

protectedinherited

m_info

ComputationInfo Eigen::PastixBase< PastixLU< _MatrixType > >::m_info

mutableprotectedinherited

m_initisOk

int Eigen::PastixBase< PastixLU< _MatrixType > >::m_initisOk

protectedinherited

m_invp

Matrix<StorageIndex,Dynamic,1> Eigen::PastixBase< PastixLU< _MatrixType > >::m_invp

mutableprotectedinherited

m_iparm

template<typename _MatrixType , bool IsStrSym>

Array<int,IPARM_SIZE,1> Eigen::PastixBase< Derived >::m_iparm

mutableprotected

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::init().

m_isInitialized

bool Eigen::SparseSolverBase< PastixLU< _MatrixType > >::m_isInitialized

mutableprotectedinherited

m_pastixdata

pastix_data_t* Eigen::PastixBase< PastixLU< _MatrixType > >::m_pastixdata

mutableprotectedinherited

m_perm

Matrix<StorageIndex,Dynamic,1> Eigen::PastixBase< PastixLU< _MatrixType > >::m_perm

mutableprotectedinherited

m_size

int Eigen::PastixBase< PastixLU< _MatrixType > >::m_size

mutableprotectedinherited

m_structureIsUptodate

template<typename _MatrixType , bool IsStrSym>

bool Eigen::PastixLU< _MatrixType, IsStrSym >::m_structureIsUptodate

protected

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::analyzePattern(), Eigen::PastixLU< _MatrixType, IsStrSym >::compute(), Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix(), and Eigen::PastixLU< _MatrixType, IsStrSym >::init().

m_transposedStructure

template<typename _MatrixType , bool IsStrSym>

ColSpMatrix Eigen::PastixLU< _MatrixType, IsStrSym >::m_transposedStructure

protected

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix().

---

The documentation for this class was generated from the following file:

• src/eigen/Eigen/src/PaStiXSupport/PaStiXSupport.h