Ifpack2 Templated Preconditioning Package Version 1.0
Public Types | Public Member Functions | Public Attributes
Ifpack2::RILUK< MatrixType > Class Template Reference

ILU(k) factorization of a given Tpetra::RowMatrix. More...

#include <Ifpack2_RILUK_decl.hpp>

Inheritance diagram for Ifpack2::RILUK< MatrixType >:
Inheritance graph
[legend]

List of all members.

Public Types

typedef MatrixType::scalar_type scalar_type
 The type of the entries of the input MatrixType.
typedef
MatrixType::local_ordinal_type 
local_ordinal_type
 The type of local indices in the input MatrixType.
typedef
MatrixType::global_ordinal_type 
global_ordinal_type
 The type of global indices in the input MatrixType.
typedef MatrixType::node_type node_type
 The type of the Kokkos Node used by the input MatrixType.
typedef Teuchos::ScalarTraits
< scalar_type >::magnitudeType 
magnitude_type
 The type of the magnitude (absolute value) of a matrix entry.
typedef Tpetra::RowMatrix
< scalar_type,
local_ordinal_type,
global_ordinal_type, node_type
row_matrix_type
 Tpetra::RowMatrix specialization used by this class.
typedef Tpetra::CrsMatrix
< scalar_type,
local_ordinal_type,
global_ordinal_type, node_type
crs_matrix_type
 Tpetra::CrsMatrix specialization used by this class for representing L and U.

Public Member Functions

 RILUK (const Teuchos::RCP< const row_matrix_type > &A_in)
 Constructor that takes a Tpetra::RowMatrix.
 RILUK (const Teuchos::RCP< const crs_matrix_type > &A_in)
 Constructor that takes a Tpetra::CrsMatrix.
template<typename NewMatrixType >
Teuchos::RCP< RILUK
< NewMatrixType > > 
clone (const Teuchos::RCP< const NewMatrixType > &A_newnode) const
 Clone preconditioner to a new node type.
virtual ~RILUK ()
 Destructor (declared virtual for memory safety).
void TEUCHOS_DEPRECATED SetRelaxValue (const magnitude_type RelaxValue)
 Set RILU(k) relaxation parameter.
void TEUCHOS_DEPRECATED SetAbsoluteThreshold (const magnitude_type Athresh)
 Set absolute threshold value.
void TEUCHOS_DEPRECATED SetRelativeThreshold (const magnitude_type Rthresh)
 Set relative threshold value.
void TEUCHOS_DEPRECATED SetOverlapMode (const Tpetra::CombineMode OverlapMode)
 Set overlap mode type.
void setParameters (const Teuchos::ParameterList &params)
void initialize ()
 Initialize by computing the symbolic incomplete factorization.
void compute ()
 Compute the (numeric) incomplete factorization.
bool isInitialized () const
 Whether initialize() has been called on this object.
bool isComputed () const
 Whether compute() has been called on this object.
int getNumInitialize () const
 Number of successful initialize() calls for this object.
int getNumCompute () const
 Number of successful compute() calls for this object.
int getNumApply () const
 Number of successful apply() calls for this object.
double getInitializeTime () const
 Total time in seconds taken by all successful initialize() calls for this object.
double getComputeTime () const
 Total time in seconds taken by all successful compute() calls for this object.
double getApplyTime () const
 Total time in seconds taken by all successful apply() calls for this object.
magnitude_type TEUCHOS_DEPRECATED computeCondEst (Teuchos::ETransp mode) const
 Compute the condition number estimate and return its value.
virtual magnitude_type
TEUCHOS_DEPRECATED 
computeCondEst (CondestType CT=Ifpack2::Cheap, local_ordinal_type MaxIters=1550, magnitude_type Tol=1e-9, const Teuchos::Ptr< const row_matrix_type > &Matrix=Teuchos::null)
 Compute the condition number estimate and return its value.
magnitude_type getCondEst () const
 Return the computed condition number estimate, or -1 if not computed.
Teuchos::RCP< const
row_matrix_type
getMatrix () const
 Get the input matrix.
magnitude_type getRelaxValue () const
 Get RILU(k) relaxation parameter.
magnitude_type getAbsoluteThreshold () const
 Get absolute threshold value.
magnitude_type getRelativeThreshold () const
 Get relative threshold value.
int getLevelOfFill () const
 Get level of fill (the "k" in ILU(k)).
Tpetra::CombineMode getOverlapMode ()
 Get overlap mode type.
Tpetra::global_size_t getGlobalNumEntries () const
 Returns the number of nonzero entries in the global graph.
Teuchos::RCP
< Ifpack2::IlukGraph
< Tpetra::CrsGraph
< local_ordinal_type,
global_ordinal_type, node_type > > > 
getGraph () const
 Return the Ifpack2::IlukGraph associated with this factored matrix.
const crs_matrix_typegetL () const
 Return the L factor of the ILU factorization.
const Tpetra::Vector
< scalar_type,
local_ordinal_type,
global_ordinal_type, node_type > & 
getD () const
 Return the diagonal entries of the ILU factorization.
const crs_matrix_typegetU () const
 Return the U factor of the ILU factorization.
Teuchos::RCP< const
crs_matrix_type
getCrsMatrix () const
 Return the input matrix A as a Tpetra::CrsMatrix, if possible; else throws.
Implementation of Ifpack2::Details::CanChangeMatrix
virtual void setMatrix (const Teuchos::RCP< const row_matrix_type > &A)
 Change the matrix to be preconditioned.
Implementation of Teuchos::Describable interface
std::string description () const
 A one-line description of this object.
Implementation of Tpetra::Operator
Teuchos::RCP< const
Tpetra::Map
< local_ordinal_type,
global_ordinal_type, node_type > > 
getDomainMap () const
 Returns the Tpetra::Map object associated with the domain of this operator.
Teuchos::RCP< const
Tpetra::Map
< local_ordinal_type,
global_ordinal_type, node_type > > 
getRangeMap () const
 Returns the Tpetra::Map object associated with the range of this operator.
void apply (const Tpetra::MultiVector< scalar_type, local_ordinal_type, global_ordinal_type, node_type > &X, Tpetra::MultiVector< scalar_type, local_ordinal_type, global_ordinal_type, node_type > &Y, Teuchos::ETransp mode=Teuchos::NO_TRANS, scalar_type alpha=Teuchos::ScalarTraits< scalar_type >::one(), scalar_type beta=Teuchos::ScalarTraits< scalar_type >::zero()) const
 Apply the (inverse of the) incomplete factorization to X, resulting in Y.

Public Attributes

TEUCHOS_DEPRECATED typedef
MatrixType::scalar_type 
Scalar
 Preserved only for backwards compatibility. Please use "scalar_type".
TEUCHOS_DEPRECATED typedef
MatrixType::local_ordinal_type 
LocalOrdinal
 Preserved only for backwards compatibility. Please use "local_ordinal_type".
TEUCHOS_DEPRECATED typedef
MatrixType::global_ordinal_type 
GlobalOrdinal
 Preserved only for backwards compatibility. Please use "global_ordinal_type".
TEUCHOS_DEPRECATED typedef
MatrixType::node_type 
Node
 Preserved only for backwards compatibility. Please use "node_type".
TEUCHOS_DEPRECATED typedef
Teuchos::ScalarTraits
< scalar_type >::magnitudeType 
magnitudeType
 Preserved only for backwards compatibility. Please use "magnitude_type".

Detailed Description

template<class MatrixType>
class Ifpack2::RILUK< MatrixType >

ILU(k) factorization of a given Tpetra::RowMatrix.

Template Parameters:
MatrixTypeA specialization of Tpetra::RowMatrix.

This class implements a "relaxed" incomplete ILU (ILU) factorization with level k fill. It is based upon the ILU algorithms outlined in Yousef Saad's "Iterative Methods for Sparse Linear Systems", 2nd edition, Chapter 10.

Parameters

For a complete list of valid parameters, see the documentation of setParameters().

The computed factorization is a function of several parameters:

An important note about ordering

Note that the factorization is calculated based upon local ordering. This means that the ordering of the GIDs in the row map is ignored. Initial entries in \(L\), the strictly lower triangular part of A, and \(U\), the strictly upper triangular part of A, are given by

\(L(i,j) = A(i,j)\) if \(j < i\), for local IDs \(i\) and \(j\), even if GID \((j)\) \(>\) GID \((i)\),

and

\(U(i,j) = A(i,j)\) if \(i < j\), for local IDs \(i\) and \(j\), even if GID \((j)\) \(<\) GID \((i)\).

In particular, if the row map GIDs are not in ascending order on processor, then the incomplete factors will be different than those produced by ILU(k) using global IDs. If the row map GIDs are in ascending order, then the factors produced based on LID and GID ordering are the same.

Estimating preconditioner condition numbers

For ill-conditioned matrices, we often have difficulty computing usable incomplete factorizations. The most common source of problems is that the factorization may encounter a small or zero pivot. In that case, the factorization may fail. Even if the factorization succeeds, the factors may be so poorly conditioned that use of them in the iterative phase produces meaningless results. Before we can fix this problem, we must be able to detect it. To this end, we use a simple but effective condition number estimate for \((LU)^{-1}\).

The condition number of a matrix \(B\), called \(cond_p(B)\), is defined as \(cond_p(B) = \|B\|_p\|B^{-1}\|_p\) in some appropriate norm \(p\). \(cond_p(B)\) gives some indication of how many accurate floating point digits can be expected from operations involving the matrix and its inverse. A condition number approaching the accuracy of a given floating point number system, about 15 decimal digits in IEEE double precision, means that any results involving \(B\) or \(B^{-1}\) may be meaningless.

The \(\infty\)-norm of a vector \(y\) is defined as the maximum of the absolute values of the vector entries, and the \(\infty\)-norm of a matrix C is defined as \(\|C\|_\infty = \max_{\|y\|_\infty = 1} \|Cy\|_\infty\). A crude lower bound for the \(cond_\infty(C)\) is \(\|C^{-1}e\|_\infty\) where \(e = (1, 1, \ldots, 1)^T\). It is a lower bound because \(cond_\infty(C) = \|C\|_\infty\|C^{-1}\|_\infty \ge \|C^{-1}\|_\infty \ge |C^{-1}e\|_\infty\).

For our purposes, we want to estimate \(cond_\infty(LU)\), where \(L\) and \(U\) are our incomplete factors. Edmond in his Ph.D. thesis demonstrates that \(\|(LU)^{-1}e\|_\infty\) provides an effective estimate for \(cond_\infty(LU)\). Furthermore, since finding \(z\) such that \(LUz = y\) is a basic kernel for applying the preconditioner, computing this estimate of \(cond_\infty(LU)\) is performed by setting \(y = e\), calling the solve kernel to compute \(z\) and then computing \(\|z\|_\infty\).

A priori diagonal perturbations

If we detect using the above method that our factorization is too ill-conditioned, we can improve the conditioning by perturbing the matrix diagonal and restarting the factorization using this more diagonally dominant matrix. In order to apply perturbation, prior to starting the factorization, we compute a diagonal perturbation of our matrix \(A\) and perform the factorization on this perturbed matrix. The overhead cost of perturbing the diagonal is minimal since the first step in computing the incomplete factors is to copy the matrix \(A\) into the memory space for the incomplete factors. We simply compute the perturbed diagonal at this point.

The actual perturbation values we use are the diagonal values \((d_1, d_2, \ldots, d_n)\) with \(d_i = sgn(d_i)\alpha + d_i\rho\), \(i=1, 2, \ldots, n\), where \(n\) is the matrix dimension and \(sgn(d_i)\) returns the sign of the diagonal entry. This has the effect of forcing the diagonal values to have minimal magnitude of \(\alpha\) and to increase each by an amount proportional to \(\rho\), and still keep the sign of the original diagonal entry.

Phases of computation

Every Ifpack2 preconditioner has the following phases of computation:

  1. initialize()
  2. compute()
  3. apply()

RILUK constructs the symbolic incomplete factorization (that is, the structure of the incomplete factors) in the initialize() phase. It computes the numerical incomplete factorization (that is, it fills in the factors' entries with their correct values) in the compute() phase. The apply() phase applies the incomplete factorization to a given multivector using two triangular solves.

Measuring performance

Each RILUK object keeps track of both the time required for various operations, and the number of times those operations have been applied for that object. The operations tracked include:

The getNum* methods return the number of times that operation was called. The get*Time methods return the total number of seconds spent in all invocations of that operation. For example, getApplyTime() returns the number of seconds spent in all apply() calls. For an average time per apply() call, divide by getNumApply(), the total number of calls to apply().


Member Typedef Documentation

template<class MatrixType>
typedef MatrixType::scalar_type Ifpack2::RILUK< MatrixType >::scalar_type

The type of the entries of the input MatrixType.

template<class MatrixType>
typedef MatrixType::local_ordinal_type Ifpack2::RILUK< MatrixType >::local_ordinal_type

The type of local indices in the input MatrixType.

template<class MatrixType>
typedef MatrixType::global_ordinal_type Ifpack2::RILUK< MatrixType >::global_ordinal_type

The type of global indices in the input MatrixType.

template<class MatrixType>
typedef MatrixType::node_type Ifpack2::RILUK< MatrixType >::node_type

The type of the Kokkos Node used by the input MatrixType.

template<class MatrixType>
typedef Teuchos::ScalarTraits<scalar_type>::magnitudeType Ifpack2::RILUK< MatrixType >::magnitude_type
template<class MatrixType>
typedef Tpetra::RowMatrix<scalar_type, local_ordinal_type, global_ordinal_type, node_type> Ifpack2::RILUK< MatrixType >::row_matrix_type

Tpetra::RowMatrix specialization used by this class.

template<class MatrixType>
typedef Tpetra::CrsMatrix<scalar_type, local_ordinal_type, global_ordinal_type, node_type> Ifpack2::RILUK< MatrixType >::crs_matrix_type

Tpetra::CrsMatrix specialization used by this class for representing L and U.


Constructor & Destructor Documentation

template<class MatrixType >
Ifpack2::RILUK< MatrixType >::RILUK ( const Teuchos::RCP< const row_matrix_type > &  A_in)

Constructor that takes a Tpetra::RowMatrix.

Parameters:
A_in[in] The input matrix.
template<class MatrixType >
Ifpack2::RILUK< MatrixType >::RILUK ( const Teuchos::RCP< const crs_matrix_type > &  A_in)

Constructor that takes a Tpetra::CrsMatrix.

This constructor exists to avoid "ambiguous constructor" warnings. It does the same thing as the constructor that takes a Tpetra::RowMatrix.

Parameters:
A_in[in] The input matrix.
template<class MatrixType >
Ifpack2::RILUK< MatrixType >::~RILUK ( ) [virtual]

Destructor (declared virtual for memory safety).


Member Function Documentation

template<class MatrixType >
template<typename NewMatrixType >
Teuchos::RCP< RILUK< NewMatrixType > > Ifpack2::RILUK< MatrixType >::clone ( const Teuchos::RCP< const NewMatrixType > &  A_newnode) const

Clone preconditioner to a new node type.

This method makes a deep copy of the original preconditioner (and matrix), into objects with the Node type NewMatrixType::node_type.

template<class MatrixType>
void TEUCHOS_DEPRECATED Ifpack2::RILUK< MatrixType >::SetRelaxValue ( const magnitude_type  RelaxValue) [inline]

Set RILU(k) relaxation parameter.

This method is DEPRECATED. If you want to change the value of this parameter, you should instead call setParameters().

template<class MatrixType>
void TEUCHOS_DEPRECATED Ifpack2::RILUK< MatrixType >::SetAbsoluteThreshold ( const magnitude_type  Athresh) [inline]

Set absolute threshold value.

This method is DEPRECATED. If you want to change the value of this parameter, you should instead call setParameters().

template<class MatrixType>
void TEUCHOS_DEPRECATED Ifpack2::RILUK< MatrixType >::SetRelativeThreshold ( const magnitude_type  Rthresh) [inline]

Set relative threshold value.

This method is DEPRECATED. If you want to change the value of this parameter, you should instead call setParameters().

template<class MatrixType>
void TEUCHOS_DEPRECATED Ifpack2::RILUK< MatrixType >::SetOverlapMode ( const Tpetra::CombineMode  OverlapMode) [inline]

Set overlap mode type.

This method is DEPRECATED. If you want to change the value of this parameter, you should instead call setParameters().

template<class MatrixType >
void Ifpack2::RILUK< MatrixType >::setParameters ( const Teuchos::ParameterList params) [virtual]

Set parameters for the incomplete factorization.

This preconditioner supports the following parameters:

  • "fact: iluk level-of-fill" (int)
  • "fact: absolute threshold" (magnitude_type)
  • "fact: relative threshold" (magnitude_type)
  • "fact: relax value" (magnitude_type)

Implements Ifpack2::Preconditioner< MatrixType::scalar_type, MatrixType::local_ordinal_type, MatrixType::global_ordinal_type, MatrixType::node_type >.

template<class MatrixType >
void Ifpack2::RILUK< MatrixType >::initialize ( ) [virtual]
template<class MatrixType >
void Ifpack2::RILUK< MatrixType >::compute ( ) [virtual]

Compute the (numeric) incomplete factorization.

This function computes the RILU(k) factors L and U using the current:

  • Ifpack2_IlukGraph specifying the structure of L and U.
  • Value for the RILU(k) relaxation parameter.
  • Value for the a priori diagonal threshold values.

initialize() must be called first, before this method may be called.

Implements Ifpack2::Preconditioner< MatrixType::scalar_type, MatrixType::local_ordinal_type, MatrixType::global_ordinal_type, MatrixType::node_type >.

template<class MatrixType>
bool Ifpack2::RILUK< MatrixType >::isInitialized ( ) const [inline, virtual]
template<class MatrixType>
bool Ifpack2::RILUK< MatrixType >::isComputed ( ) const [inline, virtual]
template<class MatrixType>
int Ifpack2::RILUK< MatrixType >::getNumInitialize ( ) const [inline, virtual]
template<class MatrixType>
int Ifpack2::RILUK< MatrixType >::getNumCompute ( ) const [inline, virtual]
template<class MatrixType>
int Ifpack2::RILUK< MatrixType >::getNumApply ( ) const [inline, virtual]
template<class MatrixType>
double Ifpack2::RILUK< MatrixType >::getInitializeTime ( ) const [inline, virtual]
template<class MatrixType>
double Ifpack2::RILUK< MatrixType >::getComputeTime ( ) const [inline, virtual]
template<class MatrixType>
double Ifpack2::RILUK< MatrixType >::getApplyTime ( ) const [inline, virtual]
template<class MatrixType >
void Ifpack2::RILUK< MatrixType >::setMatrix ( const Teuchos::RCP< const row_matrix_type > &  A) [virtual]

Change the matrix to be preconditioned.

Parameters:
A[in] The new matrix.
Postcondition:
! isInitialized ()
! isComputed ()

Calling this method resets the preconditioner's state. After calling this method with a nonnull input, you must first call initialize() and compute() (in that order) before you may call apply().

You may call this method with a null input. If A is null, then you may not call initialize() or compute() until you first call this method again with a nonnull input. This method invalidates any previous factorization whether or not A is null, so calling setMatrix() with a null input is one way to clear the preconditioner's state (and free any memory that it may be using).

The new matrix A need not necessarily have the same Maps or even the same communicator as the original matrix.

template<class MatrixType >
std::string Ifpack2::RILUK< MatrixType >::description ( ) const

A one-line description of this object.

template<class MatrixType >
Teuchos::RCP< const Tpetra::Map< typename RILUK< MatrixType >::local_ordinal_type, typename RILUK< MatrixType >::global_ordinal_type, typename RILUK< MatrixType >::node_type > > Ifpack2::RILUK< MatrixType >::getDomainMap ( ) const [virtual]
template<class MatrixType >
Teuchos::RCP< const Tpetra::Map< typename RILUK< MatrixType >::local_ordinal_type, typename RILUK< MatrixType >::global_ordinal_type, typename RILUK< MatrixType >::node_type > > Ifpack2::RILUK< MatrixType >::getRangeMap ( ) const [virtual]
template<class MatrixType >
void Ifpack2::RILUK< MatrixType >::apply ( const Tpetra::MultiVector< scalar_type, local_ordinal_type, global_ordinal_type, node_type > &  X,
Tpetra::MultiVector< scalar_type, local_ordinal_type, global_ordinal_type, node_type > &  Y,
Teuchos::ETransp  mode = Teuchos::NO_TRANS,
scalar_type  alpha = Teuchos::ScalarTraits<scalar_type>::one (),
scalar_type  beta = Teuchos::ScalarTraits<scalar_type>::zero () 
) const [virtual]

Apply the (inverse of the) incomplete factorization to X, resulting in Y.

For an incomplete factorization \(A \approx LDU\), this method computes the following, depending on the value of mode:

  • If mode = Teuchos::NO_TRANS, it computes Y = beta*Y + alpha*(U \ (D \ (L \ X)))
  • If mode = Teuchos::TRANS, it computes Y = beta*Y + alpha*(L^T \ (D^T \ (U^T \ X)))
  • If mode = Teuchos::CONJ_TRANS, it computes Y = beta*Y + alpha*(L^* \ (D^* \ (U^* \ X))), where the asterisk indicates the conjugate transpose.

If alpha is zero, then the result of applying the operator to a vector is ignored. This matters because zero times NaN (not a number) is NaN, not zero. Analogously, if beta is zero, then any values in Y on input are ignored.

Parameters:
X[in] The input multivector.
Y[in/out] The output multivector.
mode[in] If Teuchos::TRANS resp. Teuchos::CONJ_TRANS, apply the transpose resp. conjugate transpose of the incomplete factorization. Otherwise, don't apply the tranpose.
alpha[in] Scaling factor for the result of applying the preconditioner.
beta[in] Scaling factor for the initial value of Y.

Implements Ifpack2::Preconditioner< MatrixType::scalar_type, MatrixType::local_ordinal_type, MatrixType::global_ordinal_type, MatrixType::node_type >.

template<class MatrixType >
Teuchos::ScalarTraits< typename MatrixType::scalar_type >::magnitudeType Ifpack2::RILUK< MatrixType >::computeCondEst ( Teuchos::ETransp  mode) const

Compute the condition number estimate and return its value.

Warning:
This method is DEPRECATED. It was inherited from Ifpack, and Ifpack never clearly stated what this method computes. Furthermore, Ifpack's method just estimates the condition number of the matrix A, and ignores the preconditioner -- which is probably not what users thought it did. If there is sufficient interest, we might reintroduce this method with a different meaning and a better algorithm.
template<class MatrixType>
virtual magnitude_type TEUCHOS_DEPRECATED Ifpack2::RILUK< MatrixType >::computeCondEst ( CondestType  CT = Ifpack2::Cheap,
local_ordinal_type  MaxIters = 1550,
magnitude_type  Tol = 1e-9,
const Teuchos::Ptr< const row_matrix_type > &  Matrix = Teuchos::null 
) [virtual]

Compute the condition number estimate and return its value.

Warning:
This method is DEPRECATED. It was inherited from Ifpack, and Ifpack never clearly stated what this method computes. Furthermore, Ifpack's method just estimates the condition number of the matrix A, and ignores the preconditioner -- which is probably not what users thought it did. If there is sufficient interest, we might reintroduce this method with a different meaning and a better algorithm.
template<class MatrixType>
magnitude_type Ifpack2::RILUK< MatrixType >::getCondEst ( ) const [inline, virtual]

Return the computed condition number estimate, or -1 if not computed.

Warning:
This method is DEPRECATED. See warning for computeCondEst().

Implements Ifpack2::Preconditioner< MatrixType::scalar_type, MatrixType::local_ordinal_type, MatrixType::global_ordinal_type, MatrixType::node_type >.

template<class MatrixType >
Teuchos::RCP< const typename RILUK< MatrixType >::row_matrix_type > Ifpack2::RILUK< MatrixType >::getMatrix ( ) const [virtual]
template<class MatrixType>
magnitude_type Ifpack2::RILUK< MatrixType >::getRelaxValue ( ) const [inline]

Get RILU(k) relaxation parameter.

template<class MatrixType>
magnitude_type Ifpack2::RILUK< MatrixType >::getAbsoluteThreshold ( ) const [inline]

Get absolute threshold value.

template<class MatrixType>
magnitude_type Ifpack2::RILUK< MatrixType >::getRelativeThreshold ( ) const [inline]

Get relative threshold value.

template<class MatrixType>
int Ifpack2::RILUK< MatrixType >::getLevelOfFill ( ) const [inline]

Get level of fill (the "k" in ILU(k)).

template<class MatrixType>
Tpetra::CombineMode Ifpack2::RILUK< MatrixType >::getOverlapMode ( ) [inline]

Get overlap mode type.

template<class MatrixType>
Tpetra::global_size_t Ifpack2::RILUK< MatrixType >::getGlobalNumEntries ( ) const [inline]

Returns the number of nonzero entries in the global graph.

template<class MatrixType>
Teuchos::RCP<Ifpack2::IlukGraph<Tpetra::CrsGraph<local_ordinal_type,global_ordinal_type,node_type> > > Ifpack2::RILUK< MatrixType >::getGraph ( ) const [inline]

Return the Ifpack2::IlukGraph associated with this factored matrix.

template<class MatrixType >
const RILUK< MatrixType >::crs_matrix_type & Ifpack2::RILUK< MatrixType >::getL ( ) const

Return the L factor of the ILU factorization.

template<class MatrixType >
const Tpetra::Vector< typename RILUK< MatrixType >::scalar_type, typename RILUK< MatrixType >::local_ordinal_type, typename RILUK< MatrixType >::global_ordinal_type, typename RILUK< MatrixType >::node_type > & Ifpack2::RILUK< MatrixType >::getD ( ) const

Return the diagonal entries of the ILU factorization.

template<class MatrixType >
const RILUK< MatrixType >::crs_matrix_type & Ifpack2::RILUK< MatrixType >::getU ( ) const

Return the U factor of the ILU factorization.

template<class MatrixType >
Teuchos::RCP< const typename RILUK< MatrixType >::crs_matrix_type > Ifpack2::RILUK< MatrixType >::getCrsMatrix ( ) const

Return the input matrix A as a Tpetra::CrsMatrix, if possible; else throws.


Member Data Documentation

template<class MatrixType>
TEUCHOS_DEPRECATED typedef MatrixType::scalar_type Ifpack2::RILUK< MatrixType >::Scalar

Preserved only for backwards compatibility. Please use "scalar_type".

template<class MatrixType>
TEUCHOS_DEPRECATED typedef MatrixType::local_ordinal_type Ifpack2::RILUK< MatrixType >::LocalOrdinal

Preserved only for backwards compatibility. Please use "local_ordinal_type".

template<class MatrixType>
TEUCHOS_DEPRECATED typedef MatrixType::global_ordinal_type Ifpack2::RILUK< MatrixType >::GlobalOrdinal

Preserved only for backwards compatibility. Please use "global_ordinal_type".

template<class MatrixType>
TEUCHOS_DEPRECATED typedef MatrixType::node_type Ifpack2::RILUK< MatrixType >::Node

Preserved only for backwards compatibility. Please use "node_type".

template<class MatrixType>
TEUCHOS_DEPRECATED typedef Teuchos::ScalarTraits<scalar_type>::magnitudeType Ifpack2::RILUK< MatrixType >::magnitudeType

Preserved only for backwards compatibility. Please use "magnitude_type".

Reimplemented from Ifpack2::Preconditioner< MatrixType::scalar_type, MatrixType::local_ordinal_type, MatrixType::global_ordinal_type, MatrixType::node_type >.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends