// ======================================================================
int CompareBlockSizes(string PrecType, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A, int NumParts)
{
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", PrecType);
List.set("relaxation: sweeps",1);
List.set("partitioner: type", "linear");
List.set("partitioner: local parts", NumParts);
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > Prec(&*A);
Prec.SetParameters(List);
Prec.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Prec);
AztecOOSolver.Iterate(2550,1e-5);
return(AztecOOSolver.NumIters());
}
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 AllSingle(const Teuchos::RefCountPtr<Epetra_RowMatrix>& A, Teuchos::RCP<Epetra_MultiVector> coord)
{
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", "symmetric Gauss-Seidel");
List.set("relaxation: sweeps",1);
List.set("partitioner: overlap",0);
List.set("partitioner: type", "line");
List.set("partitioner: line detection threshold",1.0);
List.set("partitioner: x-coordinates",&(*coord)[0][0]);
List.set("partitioner: y-coordinates",&(*coord)[1][0]);
List.set("partitioner: z-coordinates",(double*) 0);
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > Prec(&*A);
Prec.SetParameters(List);
Prec.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Prec);
AztecOOSolver.Iterate(2550,1e-5);
printf(" AllSingle iters %d \n",AztecOOSolver.NumIters());
return(AztecOOSolver.NumIters());
}
// ======================================================================
int CompareLineSmootherEntries(const Teuchos::RefCountPtr<Epetra_RowMatrix>& A)
{
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", "symmetric Gauss-Seidel");
List.set("relaxation: sweeps",1);
List.set("partitioner: overlap",0);
List.set("partitioner: type", "line");
List.set("partitioner: line mode","matrix entries");
List.set("partitioner: line detection threshold",10.0);
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > Prec(&*A);
Prec.SetParameters(List);
Prec.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Prec);
AztecOOSolver.Iterate(2550,1e-5);
return(AztecOOSolver.NumIters());
}
// ======================================================================
bool KrylovTest(string PrecType, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A, bool backward, bool reorder=false)
{
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
// Set up the list
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", PrecType);
if(backward) List.set("relaxation: backward mode",backward);
// Reordering if needed
int NumRows=A->NumMyRows();
std::vector<int> RowList(NumRows);
if(reorder) {
for(int i=0; i<NumRows; i++)
RowList[i]=i;
List.set("relaxation: number of local smoothing indices",NumRows);
List.set("relaxation: local smoothing indices",RowList.size()>0? &RowList[0] : (int*)0);
}
int Iters1, Iters10;
if (verbose) {
cout << "Krylov test: Using " << PrecType
<< " with AztecOO" << endl;
}
// ============================================== //
// get the number of iterations with 1 sweep only //
// ============================================== //
{
List.set("relaxation: sweeps",1);
Ifpack_PointRelaxation Point(&*A);
Point.SetParameters(List);
Point.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Point);
AztecOOSolver.Iterate(2550,1e-5);
double TrueResidual = AztecOOSolver.TrueResidual();
// some output
if (verbose && Problem.GetMatrix()->Comm().MyPID() == 0) {
cout << "Norm of the true residual = " << TrueResidual << endl;
}
Iters1 = AztecOOSolver.NumIters();
}
// ======================================================== //
// now re-run with 10 sweeps, solver should converge faster
// ======================================================== //
{
List.set("relaxation: sweeps",10);
Ifpack_PointRelaxation Point(&*A);
Point.SetParameters(List);
Point.Compute();
LHS.PutScalar(0.0);
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Point);
AztecOOSolver.Iterate(2550,1e-5);
double TrueResidual = AztecOOSolver.TrueResidual();
// some output
if (verbose && Problem.GetMatrix()->Comm().MyPID() == 0) {
cout << "Norm of the true residual = " << TrueResidual << endl;
}
Iters10 = AztecOOSolver.NumIters();
}
if (verbose) {
cout << "Iters_1 = " << Iters1 << ", Iters_10 = " << Iters10 << endl;
cout << "(second number should be smaller than first one)" << endl;
}
if (Iters10 > Iters1) {
if (verbose)
cout << "KrylovTest TEST FAILED!" << endl;
return(false);
}
else {
if (verbose)
cout << "KrylovTest TEST PASSED" << endl;
return(true);
}
}
// ======================================================================
bool ComparePointAndBlock(string PrecType, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A, int sweeps)
{
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
// Set up the list
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", PrecType);
List.set("relaxation: sweeps",sweeps);
List.set("partitioner: type", "linear");
List.set("partitioner: local parts", A->NumMyRows());
int ItersPoint, ItersBlock;
// ================================================== //
// get the number of iterations with point relaxation //
// ================================================== //
{
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_PointRelaxation Point(&*A);
Point.SetParameters(List);
Point.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Point);
AztecOOSolver.Iterate(2550,1e-2);
double TrueResidual = AztecOOSolver.TrueResidual();
ItersPoint = AztecOOSolver.NumIters();
// some output
if (verbose && Problem.GetMatrix()->Comm().MyPID() == 0) {
cout << "Iterations = " << ItersPoint << endl;
cout << "Norm of the true residual = " << TrueResidual << endl;
}
}
// ================================================== //
// get the number of iterations with block relaxation //
// ================================================== //
{
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > Block(&*A);
Block.SetParameters(List);
Block.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Block);
AztecOOSolver.Iterate(2550,1e-2);
double TrueResidual = AztecOOSolver.TrueResidual();
ItersBlock = AztecOOSolver.NumIters();
// some output
if (verbose && Problem.GetMatrix()->Comm().MyPID() == 0) {
cout << "Iterations " << ItersBlock << endl;
cout << "Norm of the true residual = " << TrueResidual << endl;
}
}
int diff = ItersPoint - ItersBlock;
if (diff < 0) diff = -diff;
if (diff > 10)
{
if (verbose)
cout << "ComparePointandBlock TEST FAILED!" << endl;
return(false);
}
else {
if (verbose)
cout << "ComparePointandBlock TEST PASSED" << endl;
return(true);
}
}
