Superludist2_OO Class Reference

Superludist2_OO: An object-oriented wrapper for Superludist. More...

#include <Superludist2_OO.h>

Collaboration diagram for Superludist2_OO:

Public Member Functions
	Superludist2_OO (const Epetra_LinearProblem &LinearProblem)
	Superludist2_OO Constructor. More...
virtual	~Superludist2_OO (void)
	Superludist2_OO Destructor. More...
void	SetTrans (bool trans)
	Setting the transpose flag to true causes Solve() to compute A^t x = b. More...
bool	GetTrans () const
	Return the transpose flag.
int	CheckInput () const
	Prints a summary of solver parameters, performs simple sanity checks. More...
double	Condest () const
	Returns the condition number estimate for the current problem, if one exists, returns -1.0 if no estimate. More...
int	Solve (bool Factor)
	All computation is performed during the call to Solve() More...

Protected Attributes
const Epetra_LinearProblem *	Problem_
Epetra_LinearProblemRedistor *	redistor
Epetra_LinearProblem *	redistProblem
int	M
int	N
int	nz
int *	ptr
int *	ind
double *	val
double *	rhs
double *	lhs
int	Nrhs
int	ldrhs
int	ldlhs
bool	Transpose_
bool	Factored_
bool	FirstCallToSolve_
SOLVEstruct_t	SOLVEstruct
int	numprocs
int	nprow
int	npcol
gridinfo_t	grid
superlu_options_t	options
SuperMatrix	A
ScalePermstruct_t	ScalePermstruct
SuperLUStat_t	stat
LUstruct_t	LUstruct
vector< int >	Ap
vector< int >	Ai
vector< double >	Aval
bool	A_and_LU_built
int	numrows

Detailed Description

Superludist2_OO: An object-oriented wrapper for Superludist.

Superludist2_OO will solve a linear systems of equations: , using Epetra objects and the Superludist solver library, where is an Epetra_RowMatrix and and are Epetra_MultiVector objects.

SuperLUdist execution can be tuned through a variety of parameters. Superludist2_OO.h allows control of these parameters through the following named parameters, ignoring parameters with names that it does not recognize. Where possible, the parameters are common to all direct solvers (although some may ignore them). However, some parameters, in particular tuning parameters, are unique to each solver.

Superludist2_OO consists of five steps. The first three listed below are referred to as the pre-factorization transformations. 1) Equilibration - to reduce the condition number of the problem 2) Row Permutation - to make the diagonal values larger 3) Col permutation - to help maintain sparsity 4) Factorization - Compute the L and U factors 5) Solve - Perform the forward and back solves

In other solvers, the steps are: symbolic factorization (Step 3 above), numeric factorization (Step 4 above) and Solve (Step 5 above). Step 2, row permutation can be considered static pivoting and equilibration is akin to left and right scaling.

NO MECHANISM EXISTS TODAY TO SET OPTIONS OR PARAMETERS.

The following parameters are generic, i.e. potentially applicable to all direct solvers. The ints are passed as options. The doubles are passed as parameters.

"EquilibrationType" - int - enum DsolEquilibrationOption{ DSOL_DO_NOT_EQUILIBRATE, DSOL_ROW_EQUILIBRATION, DSOL_COL_EQUILIBRATION, DSOL_ROW_COL_EQUILIBRATION }

"EquilibrationReuse" - int - enum DsolEquilibrationReuseOption{ DSOL_EQUILIBRATE_NEW_MATRICES, DSOL_USE_STORED_EQUILIBRATION } If DSOL_USE_STORED_EQUILIBRATION is set, new equilibration arrays are only computed if none have been stored. There are two ways that equilibration constants can be stored. 1) Each time that the matrices are equilibrated, the equilibrations are stored. 2) The user can store equilibration constants by calling SetLeftEquilibration() and SetRightEquilibration().

"ColumnPermutationType" - int - enum DsolColumnPermutationTypeOption{ DSOL_NO_COLUMN_PERMUTATION, DSOL_MMD_AT_times_A, DSOL_MMD_AT_plus_A, DSOL_COLAMD }

"ColumnPermutationReuse" - int - enum DsolColumnPermutationReuseOption{ DSOL_COL_PERM_NEW_MATRICES, DSOL_USE_STORED_COL_PERM } If DSOL_USE_STORED_COL_PERM is set, a new column permutation is only computed if none has been stored. There are two ways that a column permutation can be stored. 1) Each time that a column permutation is computed it is stored. 2) The user can store a column permutation by calling SetColumnPermutation().

"RowPermutationType" - int - enum DsolRowPermutationTypeOption{ DSOL_NO_ROW_PERMUTATION, DSOL_DUFF_KOSTER }

"RowPermutationReuse" - int - enum DsolRowPermutationReuseOption{ DSOL_ROW_PERM_NEW_MATRICES, DSOL_USE_STORED_ROW_PERM } If DSOL_USE_STORED_ROW_PERM is set, a new row permutation is only computed if none has been stored. There are two ways that a row permutation can be stored. 1) Each time that a row permutation is computed it is stored. 2) The user can store a row permutation by calling SetRowPermutation().

"FactorType" - int - enum DsolFactorTypeOption{ DSOL_DO_FACTOR, DSOL_DO_NOT_FACTOR } "FactorType" is not fully supported in release 0.1

"FactorTypeReuse" - int - enum DsolFactorTypeOption{ DSOL_REUSE_FACTOR, DSOL_DO_NOT_REUSE_FACTOR } "FactorTypeReuse" is not fully supported in release 0.1

"BLAS block size" - int - BLAS block size

Constructor & Destructor Documentation

Superludist2_OO::Superludist2_OO

(

const Epetra_LinearProblem &

LinearProblem

)

Superludist2_OO Constructor.

Creates a Superludist2_OO instance, using an Epetra_LinearProblem, passing in an already-defined Epetra_LinearProblem object. The Epetra_LinearProblem class is the preferred method for passing in the linear problem to Superludist2_OO because this class provides scaling capabilities and self-consistency checks that are not available when using other constructors.

Note: The operator in LinearProblem must be an Epetra_RowMatrix.

Superludist2_OO::~Superludist2_OO ( void  )

virtual

Superludist2_OO Destructor.

Completely deletes a Superludist2_OO object.

Member Function Documentation

int Superludist2_OO::CheckInput

(

)

const

Prints a summary of solver parameters, performs simple sanity checks.

Not supported in release 0.1;

double Superludist2_OO::Condest

(

)

const

Returns the condition number estimate for the current problem, if one exists, returns -1.0 if no estimate.

Member functions to set and clear the compact representations of the pre-factorizations are not included in the interface yet, in part because I am not sure what the interface to them should be. Here is a description of these functions, whose interface we will define later.

The next two member functions have no impact on the factorization unless "EquilibrationReuse" is set to DSOL_USE_STORED_EQUILIBRATION SetLeftEquilibrationVector - Sets the left equilibration vector for use on the next matrix factorization as specified by "EquilibrationReuse" ClearLeftEquilibrationVector - Forces the next matrix factorization to compute an equilibration as specified by "EquilibrationType" GetLeftEquilibrationVector -

The following member functions are analogous to the ones for Left Equilibration. SetRightEquilibrationVector - ClearRightEquilibrationVector - GetRightEquilibrationVector -

The next two member functions have no impact on the factorization unless "RowPermutationReuse" is set to DSOL_USE_STORED_ROW_PERM SetRowPermutationVector - Sets the left row permutation vector for use on the next matrix factorization as specified by "Row PermutationReuse" ClearRowPermutationVector - Forces the next matrix factorization to compute a row permutation as specified by "RowPermutationType" GetRowPermutationVector -

The following member functions are analogous to the ones for Row Permutation. SetColumnPermutationVector - ClearColumnPermutationVector - GetColumnPermutationVector -

Not supported in release 0.1

void Superludist2_OO::SetTrans ( bool  trans )

inline

Setting the transpose flag to true causes Solve() to compute A^t x = b.

Transpose not supported in release 0.1;

int Superludist2_OO::Solve

(

bool

Factor

)

All computation is performed during the call to Solve()

Factor controls whether or not the matrix should be factored prior to the solve. Default is true.

References Add, Epetra_Comm::Barrier(), Epetra_Comm::Broadcast(), Epetra_Operator::Comm(), Epetra_MpiComm::Comm(), Copy, Epetra_CrsMatrix::ExtractMyRowView(), Epetra_CrsMatrix::GCID(), Epetra_LinearProblem::GetLHS(), Epetra_LinearProblem::GetOperator(), Epetra_LinearProblem::GetRHS(), GetTrans(), Insert, Epetra_BlockMap::LinearMap(), Epetra_BlockMap::MaxMyGID(), Epetra_BlockMap::MinMyGID(), Epetra_BlockMap::MyGlobalElements(), Epetra_Comm::MyPID(), Epetra_CrsMatrix::NumGlobalCols(), Epetra_BlockMap::NumGlobalElements(), Epetra_CrsMatrix::NumGlobalRows(), Epetra_CrsMatrix::NumMyCols(), Epetra_BlockMap::NumMyElements(), Epetra_CrsMatrix::NumMyEntries(), Epetra_CrsMatrix::NumMyNonzeros(), Epetra_CrsMatrix::NumMyRows(), Epetra_Comm::NumProc(), and Epetra_CrsMatrix::RowMap().

---

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

• Superludist2_OO.h
• Superludist2_OO.cpp