SuperludistOO Class Reference

SuperludistOO: An object-oriented wrapper for Xiaoye Li's Superludist. More...

#include <SuperludistOO.h>

Collaboration diagram for SuperludistOO:

[legend]
List of all members.

Public Member Functions

Constructor methods
 SuperludistOO (const Epetra_LinearProblem &LinearProblem)
 SuperludistOO Constructor.
virtual ~SuperludistOO (void)
 SuperludistOO Destructor.
Post-construction setup methods.
void SetTrans (bool trans)
 Setting the transpose flag to true causes Solve() to compute A^t x = b.
Check/Attribute Access Methods.
bool GetTrans () const
 Return the transpose flag.
int CheckInput () const
 Prints a summary of solver parameters, performs simple sanity checks.
Post-solve access functions
double Condest () const
 Returns the condition number estimate for the current problem, if one exists, returns -1.0 if no estimate.
Solve method
int Solve (bool Factor)
 All computation is performed during the call to Solve().

Protected Attributes

const Epetra_LinearProblemProblem_
Epetra_LinearProblemRedistorredistor
Epetra_LinearProblemredistProblem
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_
int numprocs
int nprow
int npcol
gridinfo_t grid
superlu_options_t options
SuperMatrix A
ScalePermstruct_t ScalePermstruct
SuperLUStat_t stat
LUstruct_t LUstruct
double * berr
vector< int > Ap
vector< int > Ai
vector< double > Aval
bool A_and_LU_built
int numrows

Detailed Description

SuperludistOO: An object-oriented wrapper for Xiaoye Li's Superludist.

SuperludistOO will solve a linear systems of equations: $ AX=B $, using Epetra objects and the Superludist solver library, where $A$ is an Epetra_RowMatrix and $X$ and $B$ are Epetra_MultiVector objects.

SuperLUdist execution can be tuned through a variety of parameters. SuperludistOO.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.

SuperludistOO 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

SuperludistOO::SuperludistOO const Epetra_LinearProblem LinearProblem  ) 
 

SuperludistOO Constructor.

Creates a SuperludistOO 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 SuperludistOO 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.

SuperludistOO::~SuperludistOO void   )  [virtual]
 

SuperludistOO Destructor.

Completely deletes a SuperludistOO object.


Member Function Documentation

int SuperludistOO::CheckInput  )  const
 

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

Not supported in release 0.1;

double SuperludistOO::Condest  )  const
 

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

Not supported in release 0.1

int SuperludistOO::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.


The documentation for this class was generated from the following files:
Generated on Thu Sep 18 12:30:56 2008 for Amesos by doxygen 1.3.9.1