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); }