bool Test(const Teuchos::RefCountPtr<Epetra_RowMatrix>& Matrix, Teuchos::ParameterList& List)
{
int NumVectors = 1;
bool UseTranspose = false;
Epetra_MultiVector LHS(Matrix->OperatorDomainMap(),NumVectors);
Epetra_MultiVector RHS(Matrix->OperatorRangeMap(),NumVectors);
Epetra_MultiVector LHSexact(Matrix->OperatorDomainMap(),NumVectors);
LHS.PutScalar(0.0);
LHSexact.Random();
Matrix->Multiply(UseTranspose,LHSexact,RHS);
Epetra_LinearProblem Problem(&*Matrix,&LHS,&RHS);
Teuchos::RefCountPtr<T> Prec;
Prec = Teuchos::rcp( new T(&*Matrix) );
assert(Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->SetParameters(List));
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
// create the AztecOO solver
AztecOO AztecOOSolver(Problem);
// specify solver
AztecOOSolver.SetAztecOption(AZ_solver,AZ_gmres);
AztecOOSolver.SetAztecOption(AZ_output,32);
AztecOOSolver.SetPrecOperator(&*Prec);
// solver. The solver should converge in one iteration,
// or maximum two (numerical errors)
AztecOOSolver.Iterate(1550,1e-8);
cout << *Prec;
vector<double> Norm(NumVectors);
LHS.Update(1.0,LHSexact,-1.0);
LHS.Norm2(&Norm[0]);
for (int i = 0 ; i < NumVectors ; ++i) {
cout << "Norm[" << i << "] = " << Norm[i] << endl;
if (Norm[i] > 1e-3)
return(false);
}
return(true);
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
Teuchos::ParameterList GaleriList;
// The problem is defined on a 2D grid, global size is nx * nx.
int nx = 30;
GaleriList.set("n", nx * nx);
GaleriList.set("nx", nx);
GaleriList.set("ny", nx);
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap64("Linear", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_RowMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
// =============================================================== //
// B E G I N N I N G O F I F P A C K C O N S T R U C T I O N //
// =============================================================== //
Teuchos::ParameterList List;
// allocates an IFPACK factory. No data is associated
// to this object (only method Create()).
Ifpack Factory;
// create the preconditioner. For valid PrecType values,
// please check the documentation
string PrecType = "ILU"; // incomplete LU
int OverlapLevel = 1; // must be >= 0. If Comm.NumProc() == 1,
// it is ignored.
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec = Teuchos::rcp( Factory.Create(PrecType, &*A, OverlapLevel) );
assert(Prec != Teuchos::null);
// specify parameters for ILU
List.set("fact: drop tolerance", 1e-9);
List.set("fact: level-of-fill", 1);
// the combine mode is on the following:
// "Add", "Zero", "Insert", "InsertAdd", "Average", "AbsMax"
// Their meaning is as defined in file Epetra_CombineMode.h
List.set("schwarz: combine mode", "Add");
// sets the parameters
IFPACK_CHK_ERR(Prec->SetParameters(List));
// initialize the preconditioner. At this point the matrix must
// have been FillComplete()'d, but actual values are ignored.
IFPACK_CHK_ERR(Prec->Initialize());
// Builds the preconditioners, by looking for the values of
// the matrix.
IFPACK_CHK_ERR(Prec->Compute());
// =================================================== //
// E N D O F I F P A C K C O N S T R U C T I O N //
// =================================================== //
// At this point, we need some additional objects
// to define and solve the linear system.
// defines LHS and RHS
Epetra_Vector LHS(A->OperatorDomainMap());
Epetra_Vector RHS(A->OperatorDomainMap());
// solution is constant
LHS.PutScalar(1.0);
// now build corresponding RHS
A->Apply(LHS,RHS);
// now randomize the solution
RHS.Random();
// need an Epetra_LinearProblem to define AztecOO solver
Epetra_LinearProblem Problem(&*A,&LHS,&RHS);
// now we can allocate the AztecOO solver
AztecOO Solver(Problem);
// specify solver
Solver.SetAztecOption(AZ_solver,AZ_gmres);
Solver.SetAztecOption(AZ_output,32);
// HERE WE SET THE IFPACK PRECONDITIONER
Solver.SetPrecOperator(&*Prec);
// .. and here we solve
Solver.Iterate(1550,1e-8);
cout << *Prec;
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
// =======================================================================
// GOAL: test that the names in the factory do not change. This test
// will not solve any linear system.
//
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
Teuchos::ParameterList GaleriList;
const int n = 9;
GaleriList.set("n", n);
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap("Linear", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Minij", &*Map, GaleriList) );
Ifpack Factory;
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec;
Prec = Teuchos::rcp( Factory.Create("point relaxation", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("point relaxation stand-alone", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("block relaxation", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("block relaxation stand-alone", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("IC", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("ICT", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("ILU", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("ILUT", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("IC stand-alone", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("ICT stand-alone", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("ILU stand-alone", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("ILUT stand-alone", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
#ifdef HAVE_IFPACK_AMESOS
Prec = Teuchos::rcp( Factory.Create("Amesos", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("Amesos stand-alone", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
#endif
Prec = Teuchos::rcp( Factory.Create("Chebyshev", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("Polynomial", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
Prec = Teuchos::rcp( Factory.Create("Krylov", &*A) );
assert (Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
cout << *Prec;
if (Comm.MyPID() == 0)
cout << "Test `PrecondititonerFactory.exe' passed!" << endl;
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
// initialize MPI and Epetra communicator
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
Teuchos::ParameterList GaleriList;
// The problem is defined on a 2D grid, global size is nx * nx.
int nx = 30;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_RowMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
// =============================================================== //
// B E G I N N I N G O F I F P A C K C O N S T R U C T I O N //
// =============================================================== //
Teuchos::ParameterList List;
// allocates an IFPACK factory. No data is associated
// to this object (only method Create()).
Ifpack Factory;
// create the preconditioner. For valid PrecType values,
// please check the documentation
std::string PrecType = "Amesos";
int OverlapLevel = 2; // must be >= 0. If Comm.NumProc() == 1,
// it is ignored.
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec = Teuchos::rcp( Factory.Create(PrecType, &*A, OverlapLevel) );
assert(Prec != Teuchos::null);
// specify the Amesos solver to be used.
// If the selected solver is not available,
// IFPACK will try to use Amesos' KLU (which is usually always
// compiled). Amesos' serial solvers are:
// "Amesos_Klu", "Amesos_Umfpack", "Amesos_Superlu"
List.set("amesos: solver type", "Amesos_Klu");
// sets the parameters
IFPACK_CHK_ERR(Prec->SetParameters(List));
// initialize the preconditioner. At this point the matrix must
// have been FillComplete()'d, but actual values are ignored.
// At this call, Amesos will perform the symbolic factorization.
IFPACK_CHK_ERR(Prec->Initialize());
// Builds the preconditioners, by looking for the values of
// the matrix. At this call, Amesos will perform the
// numeric factorization.
IFPACK_CHK_ERR(Prec->Compute());
// =================================================== //
// E N D O F I F P A C K C O N S T R U C T I O N //
// =================================================== //
// At this point, we need some additional objects
// to define and solve the linear system.
// defines LHS and RHS
Epetra_Vector LHS(A->OperatorDomainMap());
Epetra_Vector RHS(A->OperatorDomainMap());
// solution is constant
LHS.PutScalar(1.0);
// now build corresponding RHS
A->Apply(LHS,RHS);
// now randomize the solution
RHS.Random();
// need an Epetra_LinearProblem to define AztecOO solver
Epetra_LinearProblem Problem(&*A,&LHS,&RHS);
// now we can allocate the AztecOO solver
AztecOO Solver(Problem);
// specify solver
Solver.SetAztecOption(AZ_solver,AZ_gmres);
Solver.SetAztecOption(AZ_output,32);
// HERE WE SET THE IFPACK PRECONDITIONER
Solver.SetPrecOperator(&*Prec);
// .. and here we solve
// NOTE: with one process, the solver must converge in
// one iteration.
Solver.Iterate(1550,1e-8);
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm (MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int MyPID = Comm.MyPID();
bool verbose = false;
if (MyPID==0) verbose = true;
// The problem is defined on a 2D grid, global size is nx * nx.
int nx = 30;
Teuchos::ParameterList GaleriList;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
Teuchos::RefCountPtr<Epetra_MultiVector> LHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
Teuchos::RefCountPtr<Epetra_MultiVector> RHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
LHS->PutScalar(0.0); RHS->Random();
// ============================ //
// Construct ILU preconditioner //
// ---------------------------- //
// I wanna test funky values to be sure that they have the same
// influence on the algorithms, both old and new
int LevelFill = 2;
double DropTol = 0.3333;
double Condest;
Teuchos::RefCountPtr<Ifpack_CrsIct> ICT;
ICT = Teuchos::rcp( new Ifpack_CrsIct(*A,DropTol,LevelFill) );
ICT->SetAbsoluteThreshold(0.00123);
ICT->SetRelativeThreshold(0.9876);
// Init values from A
ICT->InitValues(*A);
// compute the factors
ICT->Factor();
// and now estimate the condition number
ICT->Condest(false,Condest);
if( Comm.MyPID() == 0 ) {
cout << "Condition number estimate (level-of-fill = "
<< LevelFill << ") = " << Condest << endl;
}
// Define label for printing out during the solve phase
string label = "Ifpack_CrsIct Preconditioner: LevelFill = " + toString(LevelFill) +
" Overlap = 0";
ICT->SetLabel(label.c_str());
// Here we create an AztecOO object
LHS->PutScalar(0.0);
int Niters = 1200;
AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
solver.SetPrecOperator(&*ICT);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(Niters, 5.0e-5);
int OldIters = solver.NumIters();
// now rebuild the same preconditioner using ICT, we expect the same
// number of iterations
Ifpack Factory;
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec = Teuchos::rcp( Factory.Create("IC", &*A) );
Teuchos::ParameterList List;
List.get("fact: level-of-fill", 2);
List.get("fact: drop tolerance", 0.3333);
List.get("fact: absolute threshold", 0.00123);
List.get("fact: relative threshold", 0.9876);
List.get("fact: relaxation value", 0.0);
IFPACK_CHK_ERR(Prec->SetParameters(List));
IFPACK_CHK_ERR(Prec->Compute());
// Here we create an AztecOO object
LHS->PutScalar(0.0);
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
solver.SetPrecOperator(&*Prec);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(Niters, 5.0e-5);
int NewIters = solver.NumIters();
if (OldIters != NewIters)
IFPACK_CHK_ERR(-1);
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
// ======================================================================
bool TestContainer(std::string Type, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A)
{
using std::cout;
using std::endl;
int NumVectors = 3;
int NumMyRows = A->NumMyRows();
Epetra_MultiVector LHS_exact(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS_exact.Random(); LHS.PutScalar(0.0);
A->Multiply(false, LHS_exact, RHS);
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
if (verbose) {
cout << "Container type = " << Type << endl;
cout << "NumMyRows = " << NumMyRows << ", NumVectors = " << NumVectors << endl;
}
LHS.PutScalar(0.0);
Teuchos::RefCountPtr<Ifpack_Container> Container;
if (Type == "dense")
Container = Teuchos::rcp( new Ifpack_DenseContainer(A->NumMyRows(), NumVectors) );
else
Container = Teuchos::rcp( new Ifpack_SparseContainer<Ifpack_Amesos>(A->NumMyRows(), NumVectors) );
assert (Container != Teuchos::null);
IFPACK_CHK_ERR(Container->Initialize());
// set as ID all the local rows of A
for (int i = 0 ; i < A->NumMyRows() ; ++i)
Container->ID(i) = i;
// extract submatrix (in this case, the entire matrix)
// and complete setup
IFPACK_CHK_ERR(Container->Compute(*A));
// set the RHS and LHS
for (int i = 0 ; i < A->NumMyRows() ; ++i)
for (int j = 0 ; j < NumVectors ; ++j) {
Container->RHS(i,j) = RHS[j][i];
Container->LHS(i,j) = LHS[j][i];
}
// set parameters (empty for dense containers)
Teuchos::ParameterList List;
List.set("amesos: solver type", Type);
IFPACK_CHK_ERR(Container->SetParameters(List));
// solve the linear system
IFPACK_CHK_ERR(Container->ApplyInverse());
// get the computed solution, store it in LHS
for (int i = 0 ; i < A->NumMyRows() ; ++i)
for (int j = 0 ; j < NumVectors ; ++j) {
LHS[j][i] = Container->LHS(i,j);
}
double residual = Galeri::ComputeNorm(&LHS, &LHS_exact);
if (A->Comm().MyPID() == 0 && verbose) {
cout << "||x_exact - x||_2 = " << residual << endl;
cout << *Container;
}
bool passed = false;
if (residual < 1e-5)
passed = true;
return(passed);
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm (MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
// The problem is defined on a 2D grid, global size is nx * nx.
int nx = 30;
Teuchos::ParameterList GaleriList;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
Teuchos::RefCountPtr<Epetra_MultiVector> LHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
Teuchos::RefCountPtr<Epetra_MultiVector> RHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
LHS->PutScalar(0.0); RHS->Random();
// ========================================= //
// Compare IC preconditioners to no precond. //
// ----------------------------------------- //
const double tol = 1e-5;
const int maxIter = 500;
// Baseline: No preconditioning
// Compute number of iterations, to compare to IC later.
// Here we create an AztecOO object
LHS->PutScalar(0.0);
AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
//solver.SetPrecOperator(&*PrecDiag);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(maxIter, tol);
int Iters = solver.NumIters();
//cout << "No preconditioner iterations: " << Iters << endl;
#if 0
// Not sure how to use Ifpack_CrsRick - leave out for now.
//
// I wanna test funky values to be sure that they have the same
// influence on the algorithms, both old and new
int LevelFill = 2;
double DropTol = 0.3333;
double Condest;
Teuchos::RefCountPtr<Ifpack_CrsRick> IC;
Ifpack_IlukGraph mygraph (A->Graph(), 0, 0);
IC = Teuchos::rcp( new Ifpack_CrsRick(*A, mygraph) );
IC->SetAbsoluteThreshold(0.00123);
IC->SetRelativeThreshold(0.9876);
// Init values from A
IC->InitValues(*A);
// compute the factors
IC->Factor();
// and now estimate the condition number
IC->Condest(false,Condest);
if( Comm.MyPID() == 0 ) {
cout << "Condition number estimate (level-of-fill = "
<< LevelFill << ") = " << Condest << endl;
}
// Define label for printing out during the solve phase
std::string label = "Ifpack_CrsRick Preconditioner: LevelFill = " + toString(LevelFill) +
" Overlap = 0";
IC->SetLabel(label.c_str());
// Here we create an AztecOO object
LHS->PutScalar(0.0);
AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
solver.SetPrecOperator(&*IC);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(maxIter, tol);
int RickIters = solver.NumIters();
//cout << "Ifpack_Rick iterations: " << RickIters << endl;
// Compare to no preconditioning
if (RickIters > Iters/2)
IFPACK_CHK_ERR(-1);
#endif
//////////////////////////////////////////////////////
// Same test with Ifpack_IC
// This is Crout threshold Cholesky, so different than IC(0)
Ifpack Factory;
Teuchos::RefCountPtr<Ifpack_Preconditioner> PrecIC = Teuchos::rcp( Factory.Create("IC", &*A) );
Teuchos::ParameterList List;
//List.get("fact: ict level-of-fill", 2.);
//List.get("fact: drop tolerance", 0.3333);
//List.get("fact: absolute threshold", 0.00123);
//List.get("fact: relative threshold", 0.9876);
//List.get("fact: relaxation value", 0.0);
IFPACK_CHK_ERR(PrecIC->SetParameters(List));
IFPACK_CHK_ERR(PrecIC->Compute());
// Here we create an AztecOO object
LHS->PutScalar(0.0);
//AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
solver.SetPrecOperator(&*PrecIC);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(maxIter, tol);
int ICIters = solver.NumIters();
//cout << "Ifpack_IC iterations: " << ICIters << endl;
// Compare to no preconditioning
if (ICIters > Iters/2)
IFPACK_CHK_ERR(-1);
#if 0
//////////////////////////////////////////////////////
// Same test with Ifpack_ICT
// This is another threshold Cholesky
Teuchos::RefCountPtr<Ifpack_Preconditioner> PrecICT = Teuchos::rcp( Factory.Create("ICT", &*A) );
//Teuchos::ParameterList List;
//List.get("fact: level-of-fill", 2);
//List.get("fact: drop tolerance", 0.3333);
//List.get("fact: absolute threshold", 0.00123);
//List.get("fact: relative threshold", 0.9876);
//List.get("fact: relaxation value", 0.0);
IFPACK_CHK_ERR(PrecICT->SetParameters(List));
IFPACK_CHK_ERR(PrecICT->Compute());
// Here we create an AztecOO object
LHS->PutScalar(0.0);
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
solver.SetPrecOperator(&*PrecICT);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(maxIter, tol);
int ICTIters = solver.NumIters();
//cout << "Ifpack_ICT iterations: " << ICTIters << endl;
// Compare to no preconditioning
if (ICTIters > Iters/2)
IFPACK_CHK_ERR(-1);
#endif
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
bool CompareWithAztecOO(Epetra_LinearProblem& Problem, const std::string what,
int Overlap, int ival)
{
using std::cout;
using std::endl;
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,AZ_gmres);
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetAztecOption(AZ_overlap,Overlap);
AztecOOSolver.SetAztecOption(AZ_graph_fill,ival);
AztecOOSolver.SetAztecOption(AZ_poly_ord, ival);
AztecOOSolver.SetAztecParam(AZ_drop, 0.0);
AztecOOSolver.SetAztecParam(AZ_athresh, 0.0);
AztecOOSolver.SetAztecParam(AZ_rthresh, 0.0);
Epetra_MultiVector& RHS = *(Problem.GetRHS());
Epetra_MultiVector& LHS = *(Problem.GetLHS());
Teuchos::RefCountPtr<Epetra_RowMatrix> A = Teuchos::rcp(Problem.GetMatrix(), false);
LHS.Random();
A->Multiply(false,LHS,RHS);
Teuchos::ParameterList List;
List.set("fact: level-of-fill", ival);
List.set("relaxation: sweeps", ival);
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: zero starting solution", true);
//default combine mode is as for AztecOO
List.set("schwarz: combine mode", Zero);
Epetra_Time Time(A->Comm());
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec;
if (what == "Jacobi") {
Prec = Teuchos::rcp( new Ifpack_PointRelaxation(&*A) );
List.set("relaxation: type", "Jacobi");
AztecOOSolver.SetAztecOption(AZ_precond,AZ_Jacobi);
AztecOOSolver.SetAztecOption(AZ_reorder,0);
}
else if (what == "IC no reord") {
Prec = Teuchos::rcp( new Ifpack_AdditiveSchwarz<Ifpack_IC>(&*A,Overlap) );
AztecOOSolver.SetAztecOption(AZ_precond,AZ_dom_decomp);
AztecOOSolver.SetAztecOption(AZ_subdomain_solve,AZ_icc);
AztecOOSolver.SetAztecOption(AZ_reorder,0);
}
else if (what == "IC reord") {
Prec = Teuchos::rcp( new Ifpack_AdditiveSchwarz<Ifpack_IC>(&*A,Overlap) );
List.set("schwarz: use reordering", true);
AztecOOSolver.SetAztecOption(AZ_precond,AZ_dom_decomp);
AztecOOSolver.SetAztecOption(AZ_subdomain_solve,AZ_icc);
AztecOOSolver.SetAztecOption(AZ_reorder,1);
}
else if (what == "ILU no reord") {
Prec = Teuchos::rcp( new Ifpack_AdditiveSchwarz<Ifpack_ILU>(&*A,Overlap) );
AztecOOSolver.SetAztecOption(AZ_precond,AZ_dom_decomp);
AztecOOSolver.SetAztecOption(AZ_subdomain_solve,AZ_ilu);
AztecOOSolver.SetAztecOption(AZ_reorder,0);
}
else if (what == "ILU reord") {
Prec = Teuchos::rcp( new Ifpack_AdditiveSchwarz<Ifpack_ILU>(&*A,Overlap) );
List.set("schwarz: use reordering", true);
AztecOOSolver.SetAztecOption(AZ_precond,AZ_dom_decomp);
AztecOOSolver.SetAztecOption(AZ_subdomain_solve,AZ_ilu);
AztecOOSolver.SetAztecOption(AZ_reorder,1);
}
#ifdef HAVE_IFPACK_AMESOS
else if (what == "LU") {
Prec = Teuchos::rcp( new Ifpack_AdditiveSchwarz<Ifpack_Amesos>(&*A,Overlap) );
List.set("amesos: solver type", "Klu");
AztecOOSolver.SetAztecOption(AZ_precond,AZ_dom_decomp);
AztecOOSolver.SetAztecOption(AZ_subdomain_solve,AZ_lu);
}
#endif
else {
cerr << "Option not recognized" << endl;
exit(EXIT_FAILURE);
}
// ==================================== //
// Solve with AztecOO's preconditioners //
// ==================================== //
LHS.PutScalar(0.0);
Time.ResetStartTime();
AztecOOSolver.Iterate(150,1e-5);
if (verbose) {
cout << endl;
cout << "==================================================" << endl;
cout << "Testing `" << what << "', Overlap = "
<< Overlap << ", ival = " << ival << endl;
cout << endl;
cout << "[AztecOO] Total time = " << Time.ElapsedTime() << " (s)" << endl;
cout << "[AztecOO] Residual = " << AztecOOSolver.TrueResidual() << " (s)" << endl;
cout << "[AztecOO] Iterations = " << AztecOOSolver.NumIters() << endl;
cout << endl;
}
int AztecOOPrecIters = AztecOOSolver.NumIters();
// =========================================== //
// Create the IFPACK preconditioner and solver //
// =========================================== //
Epetra_Time Time2(A->Comm());
assert(Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->SetParameters(List));
Time.ResetStartTime();
IFPACK_CHK_ERR(Prec->Initialize());
if (verbose)
cout << "[IFPACK] Time for Initialize() = "
<< Time.ElapsedTime() << " (s)" << endl;
Time.ResetStartTime();
IFPACK_CHK_ERR(Prec->Compute());
if (verbose)
cout << "[IFPACK] Time for Compute() = "
<< Time.ElapsedTime() << " (s)" << endl;
AztecOOSolver.SetPrecOperator(&*Prec);
LHS.PutScalar(0.0);
Time.ResetStartTime();
AztecOOSolver.Iterate(150,1e-5);
if (verbose) {
cout << "[IFPACK] Total time = " << Time2.ElapsedTime() << " (s)" << endl;
cout << "[IFPACK] Residual = " << AztecOOSolver.TrueResidual() << " (s)" << endl;
cout << "[IFPACK] Iterations = " << AztecOOSolver.NumIters() << endl;
cout << endl;
}
int IFPACKPrecIters = AztecOOSolver.NumIters();
if (IFPACK_ABS(AztecOOPrecIters - IFPACKPrecIters) > 3) {
cerr << "TEST FAILED (" << AztecOOPrecIters << " != "
<< IFPACKPrecIters << ")" << endl;
return(false);
}
else
return(true);
}
//==============================================================================
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
// only one process
if (Comm.NumProc() != 1) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
if (Comm.MyPID() == 0)
cout << "Please run this test with one process only" << endl;
// return success not to break the tests
exit(EXIT_SUCCESS);
}
// ======================================================== //
// now create the famous "upper arrow" matrix, which //
// should be reordered as a "lower arrow". Sparsity pattern //
// will be printed on screen. //
// ======================================================== //
int NumPoints = 16;
#if !defined(EPETRA_NO_32BIT_GLOBAL_INDICES) || !defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
Epetra_Map Map(-1,NumPoints,0,Comm);
#else
Epetra_Map Map;
#endif
std::vector<int> Indices(NumPoints);
std::vector<double> Values(NumPoints);
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( new Epetra_CrsMatrix(Copy,Map,0) );
for (int i = 0 ; i < NumPoints ; ++i) {
int NumEntries;
if (i == 0) {
NumEntries = NumPoints;
for (int j = 0 ; j < NumPoints ; ++j) {
Indices[j] = j;
Values[j] = 1.0;
}
}
else {
NumEntries = 2;
Indices[0] = 0;
Indices[1] = i;
Values[0] = 1.0;
Values[1] = 1.0;
}
#if !defined(EPETRA_NO_32BIT_GLOBAL_INDICES) || !defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
A->InsertGlobalValues(i, NumEntries, &Values[0], &Indices[0]);
#endif
}
A->FillComplete();
// print the sparsity to file, postscript format
////Ifpack_PrintSparsity(A,"OrigA.ps");
// create the reordering...
Teuchos::RefCountPtr<Ifpack_RCMReordering> Reorder = Teuchos::rcp( new Ifpack_RCMReordering() );
// and compute is on A
IFPACK_CHK_ERR(Reorder->Compute(*A));
// cout information
cout << *Reorder;
// create a reordered matrix
Ifpack_ReorderFilter ReordA(A, Reorder);
// print the sparsity to file, postscript format
////Ifpack_PrintSparsity(ReordA,"ReordA.ps");
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm (MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int ierr=HIPS_Initialize(1);
HIPS_ExitOnError(ierr);
int MyPID = Comm.MyPID();
bool verbose = false;
if (MyPID==0) verbose = true;
Teuchos::ParameterList GaleriList;
int nx = 100;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
// GaleriList.set("ny", nx);
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
Teuchos::RefCountPtr<Epetra_MultiVector> LHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
Teuchos::RefCountPtr<Epetra_MultiVector> RHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
LHS->PutScalar(0.0); RHS->Random();
// ============================ //
// Construct ILU preconditioner //
// ---------------------------- //
Teuchos::RefCountPtr<Ifpack_HIPS> RILU;
RILU = Teuchos::rcp( new Ifpack_HIPS(&*A) );
Teuchos::ParameterList List;
List.set("hips: id",0);
List.set("hips: setup output",2);
List.set("hips: iteration output",0);
List.set("hips: drop tolerance",5e-3);
List.set("hips: graph symmetric",1);
RILU->SetParameters(List);
RILU->Initialize();
RILU->Compute();
// Here we create an AztecOO object
LHS->PutScalar(0.0);
int Niters = 50;
AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_gmres);
solver.SetPrecOperator(&*RILU);
solver.SetAztecOption(AZ_output, 1);
solver.Iterate(Niters, 1.0e-8);
int OldIters = solver.NumIters();
HIPS_Finalize();
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm (MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int MyPID = Comm.MyPID();
bool verbose = false;
if (MyPID==0) verbose = true;
/*int npRows = -1;
int npCols = -1;
bool useTwoD = false;
int randomize = 1;
std::string matrix = "Laplacian";
Epetra_CrsMatrix *AK = NULL;
std::string filename = "email.mtx";
read_matrixmarket_file((char*) filename.c_str(), Comm, AK,
useTwoD, npRows, npCols,
randomize, false,
(matrix.find("Laplacian")!=std::string::npos));
Teuchos::RCP<Epetra_CrsMatrix> A(AK);
const Epetra_Map *AMap = &(AK->DomainMap());
Teuchos::RCP<const Epetra_Map> Map(AMap, false);*/
int nx = 30;
Teuchos::ParameterList GaleriList;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
Teuchos::RefCountPtr<Epetra_MultiVector> LHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
Teuchos::RefCountPtr<Epetra_MultiVector> RHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
LHS->PutScalar(0.0); RHS->Random();
// ==================================================== //
// Compare support graph preconditioners to no precond. //
// ---------------------------------------------------- //
const double tol = 1e-5;
const int maxIter = 500;
// Baseline: No preconditioning
// Compute number of iterations, to compare to IC later.
// Here we create an AztecOO object
LHS->PutScalar(0.0);
AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(maxIter, tol);
int Iters = solver.NumIters();
int SupportIters;
Ifpack Factory;
Teuchos::ParameterList List;
#ifdef HAVE_IFPACK_AMESOS
//////////////////////////////////////////////////////
// Same test with Ifpack_SupportGraph
// Factored with Amesos
Teuchos::RefCountPtr<Ifpack_Preconditioner> PrecSupportAmesos = Teuchos::rcp( Factory.Create("MSF Amesos", &*A) );
List.set("amesos: solver type","Klu");
List.set("MST: keep diagonal", 1.0);
List.set("MST: randomize", 1);
//List.set("fact: absolute threshold", 3.0);
IFPACK_CHK_ERR(PrecSupportAmesos->SetParameters(List));
IFPACK_CHK_ERR(PrecSupportAmesos->Initialize());
IFPACK_CHK_ERR(PrecSupportAmesos->Compute());
// Here we create an AztecOO object
LHS->PutScalar(0.0);
//AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
solver.SetPrecOperator(&*PrecSupportAmesos);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(maxIter, tol);
SupportIters = solver.NumIters();
// Compare to no preconditioning
if (SupportIters > 2*Iters)
IFPACK_CHK_ERR(-1);
#endif
//////////////////////////////////////////////////////
// Same test with Ifpack_SupportGraph
// Factored with IC
Teuchos::RefCountPtr<Ifpack_Preconditioner> PrecSupportIC = Teuchos::rcp( Factory.Create("MSF IC", &*A) );
IFPACK_CHK_ERR(PrecSupportIC->SetParameters(List));
IFPACK_CHK_ERR(PrecSupportIC->Compute());
// Here we create an AztecOO object
LHS->PutScalar(0.0);
//AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_cg);
solver.SetPrecOperator(&*PrecSupportIC);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(maxIter, tol);
SupportIters = solver.NumIters();
// Compare to no preconditioning
if (SupportIters > 2*Iters)
IFPACK_CHK_ERR(-1);
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm (MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
Teuchos::ParameterList GaleriList;
int nx = 30;
GaleriList.set("nx", nx);
// GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("ny", nx);
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
GaleriList.set("alpha", .0);
GaleriList.set("diff", 1.0);
GaleriList.set("conv", 100.0);
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap64("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("UniFlow2D", &*Map, GaleriList) );
Teuchos::RefCountPtr<Epetra_MultiVector> LHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
Teuchos::RefCountPtr<Epetra_MultiVector> RHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
LHS->PutScalar(0.0); RHS->Random();
Ifpack Factory;
int Niters = 100;
// ============================= //
// Construct IHSS preconditioner //
// ============================= //
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec = Teuchos::rcp( Factory.Create("IHSS", &*A,0) );
Teuchos::ParameterList List;
List.set("ihss: hermetian type","ILU");
List.set("ihss: skew hermetian type","ILU");
List.set("ihss: ratio eigenvalue",100.0);
// Could set sublist values here to better control the ILU, but this isn't needed for this example.
IFPACK_CHK_ERR(Prec->SetParameters(List));
IFPACK_CHK_ERR(Prec->Compute());
// ============================= //
// Create solver Object //
// ============================= //
AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_gmres);
solver.SetPrecOperator(&*Prec);
solver.SetAztecOption(AZ_output, 1);
solver.Iterate(Niters, 1e-8);
// ============================= //
// Construct SORa preconditioner //
// ============================= //
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec2 = Teuchos::rcp( Factory.Create("SORa", &*A,0) );
Teuchos::ParameterList List2;
List2.set("sora: sweeps",1);
// Could set sublist values here to better control the ILU, but this isn't needed for this example.
IFPACK_CHK_ERR(Prec2->SetParameters(List2));
IFPACK_CHK_ERR(Prec2->Compute());
// ============================= //
// Create solver Object //
// ============================= //
AztecOO solver2;
LHS->PutScalar(0.0);
solver2.SetUserMatrix(&*A);
solver2.SetLHS(&*LHS);
solver2.SetRHS(&*RHS);
solver2.SetAztecOption(AZ_solver,AZ_gmres);
solver2.SetPrecOperator(&*Prec2);
solver2.SetAztecOption(AZ_output, 1);
solver2.Iterate(Niters, 1e-8);
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm (MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int MyPID = Comm.MyPID();
bool verbose = false;
if (MyPID==0) verbose = true;
Teuchos::ParameterList GaleriList;
int nx = 30;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
Teuchos::RefCountPtr<Epetra_MultiVector> LHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
Teuchos::RefCountPtr<Epetra_MultiVector> RHS = Teuchos::rcp( new Epetra_MultiVector(*Map, 1) );
LHS->PutScalar(0.0); RHS->Random();
// ============================ //
// Construct ILU preconditioner //
// ---------------------------- //
// I wanna test funky values to be sure that they have the same
// influence on the algorithms, both old and new
int LevelFill = 2;
double DropTol = 0.3333;
double Athresh = 0.0123;
double Rthresh = 0.9876;
double Relax = 0.1;
int Overlap = 2;
Teuchos::RefCountPtr<Ifpack_IlukGraph> Graph;
Teuchos::RefCountPtr<Ifpack_CrsRiluk> RILU;
Graph = Teuchos::rcp( new Ifpack_IlukGraph(A->Graph(), LevelFill, Overlap) );
int ierr;
ierr = Graph->ConstructFilledGraph();
IFPACK_CHK_ERR(ierr);
RILU = Teuchos::rcp( new Ifpack_CrsRiluk(*Graph) );
RILU->SetAbsoluteThreshold(Athresh);
RILU->SetRelativeThreshold(Rthresh);
RILU->SetRelaxValue(Relax);
int initerr = RILU->InitValues(*A);
if (initerr!=0) cout << Comm << "*ERR* InitValues = " << initerr;
RILU->Factor();
// Define label for printing out during the solve phase
string label = "Ifpack_CrsRiluk Preconditioner: LevelFill = " + toString(LevelFill) +
" Overlap = " + toString(Overlap) +
" Athresh = " + toString(Athresh) +
" Rthresh = " + toString(Rthresh);
// Here we create an AztecOO object
LHS->PutScalar(0.0);
int Niters = 1200;
AztecOO solver;
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_gmres);
solver.SetPrecOperator(&*RILU);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(Niters, 5.0e-5);
int OldIters = solver.NumIters();
// now rebuild the same preconditioner using RILU, we expect the same
// number of iterations
Ifpack Factory;
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec = Teuchos::rcp( Factory.Create("ILU", &*A, Overlap) );
Teuchos::ParameterList List;
List.get("fact: level-of-fill", LevelFill);
List.get("fact: drop tolerance", DropTol);
List.get("fact: absolute threshold", Athresh);
List.get("fact: relative threshold", Rthresh);
List.get("fact: relax value", Relax);
IFPACK_CHK_ERR(Prec->SetParameters(List));
IFPACK_CHK_ERR(Prec->Compute());
// Here we create an AztecOO object
LHS->PutScalar(0.0);
solver.SetUserMatrix(&*A);
solver.SetLHS(&*LHS);
solver.SetRHS(&*RHS);
solver.SetAztecOption(AZ_solver,AZ_gmres);
solver.SetPrecOperator(&*Prec);
solver.SetAztecOption(AZ_output, 16);
solver.Iterate(Niters, 5.0e-5);
int NewIters = solver.NumIters();
if (OldIters != NewIters)
IFPACK_CHK_ERR(-1);
#ifdef HAVE_IFPACK_SUPERLU
// Now test w/ SuperLU's ILU, if we've got it
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec2 = Teuchos::rcp( Factory.Create("SILU", &*A,0) );
Teuchos::ParameterList SList;
SList.set("fact: drop tolerance",1e-4);
SList.set("fact: zero pivot threshold",.1);
SList.set("fact: maximum fill factor",10.0);
// NOTE: There is a bug in SuperLU 4.0 which will crash the code if the maximum fill factor is set too low.
// This bug was reported to Sherry Li on 4/8/10.
SList.set("fact: silu drop rule",9);
IFPACK_CHK_ERR(Prec2->SetParameters(SList));
IFPACK_CHK_ERR(Prec2->Compute());
LHS->PutScalar(0.0);
solver.SetPrecOperator(&*Prec2);
solver.Iterate(Niters, 5.0e-5);
Prec2->Print(cout);
#endif
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
