//========================================================================== int Ifpack_CrsRiluk::InitValues(const Epetra_CrsMatrix & A) { UserMatrixIsCrs_ = true; if (!Allocated()) AllocateCrs(); Teuchos::RefCountPtr<Epetra_CrsMatrix> OverlapA = Teuchos::rcp( (Epetra_CrsMatrix *) &A, false ); if (IsOverlapped_) { OverlapA = Teuchos::rcp( new Epetra_CrsMatrix(Copy, *Graph_.OverlapGraph()) ); EPETRA_CHK_ERR(OverlapA->Import(A, *Graph_.OverlapImporter(), Insert)); EPETRA_CHK_ERR(OverlapA->FillComplete()); } // Get Maximun Row length int MaxNumEntries = OverlapA->MaxNumEntries(); // Set L range map and U domain map U_DomainMap_ = Teuchos::rcp( &(A.DomainMap()), false ); L_RangeMap_ = Teuchos::rcp( &(A.RangeMap()), false ); // Do the rest using generic Epetra_RowMatrix interface EPETRA_CHK_ERR(InitAllValues(*OverlapA, MaxNumEntries)); return(0); }
// Main driver int main( int argc, char **argv ) { // Initialise MPI Teuchos::GlobalMPISession mpiSession(&argc,&argv); try { #ifdef HAVE_MPI // Create a communicator Teuchos::RefCountPtr <Epetra_MpiComm> comm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD)); #else // Create a communicator Teuchos::RefCountPtr <Epetra_SerialComm> comm = Teuchos::rcp(new Epetra_SerialComm); #endif std::string fileName = "task.xml"; if (argc>1) fileName = argv[1]; // Instantiate the continuation manager Teuchos::RefCountPtr <ContinuationManager> contManager = Teuchos::rcp(new ContinuationManager(comm,fileName)); // Instantiate the problem Teuchos::RefCountPtr <LinearSystem> problem = Teuchos::rcp(new LinearSystem(comm)); // Set the problem in the continuation manager contManager->SetLOCAProblem(problem); // Prepare to run LOCA contManager->BuildLOCAStepper(); // Run LOCA bool status = contManager->RunLOCAStepper(); if (status) std::cout << "\nAll tests passed" << std::endl; } catch (std::exception& e) { std::cout << e.what() << std::endl; } catch (const char *s) { std::cout << s << std::endl; } catch (...) { std::cout << "Caught unknown exception!" << std::endl; } return(EXIT_SUCCESS); }
//============================================================================== Ifpack_ReorderFilter::Ifpack_ReorderFilter(const Teuchos::RefCountPtr<Epetra_RowMatrix>& Matrix_in, const Teuchos::RefCountPtr<Ifpack_Reordering>& Reordering_in) : A_(Matrix_in), Reordering_(Reordering_in), NumMyRows_(Matrix_in->NumMyRows()), MaxNumEntries_(Matrix_in->MaxNumEntries()) { }
NOX::Abstract::Group::ReturnType LOCA::Epetra::ModelEvaluatorInterface:: computeDfDp(LOCA::MultiContinuation::AbstractGroup& grp, const vector<int>& param_ids, NOX::Abstract::MultiVector& result, bool isValidF) const { // Break result into f and df/dp NOX::Epetra::Vector& f = dynamic_cast<NOX::Epetra::Vector&>(result[0]); Epetra_Vector& epetra_f = f.getEpetraVector(); std::vector<int> dfdp_index(result.numVectors()-1); for (unsigned int i=0; i<dfdp_index.size(); i++) dfdp_index[i] = i+1; Teuchos::RefCountPtr<NOX::Epetra::MultiVector> dfdp = Teuchos::rcp_dynamic_cast<NOX::Epetra::MultiVector>(result.subView(dfdp_index)); Epetra_MultiVector& epetra_dfdp = dfdp->getEpetraMultiVector(); // Create inargs EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs(); const NOX::Epetra::Vector& x = dynamic_cast<const NOX::Epetra::Vector&>(grp.getX()); const Epetra_Vector& epetra_x = x.getEpetraVector(); inargs.set_x(Teuchos::rcp(&epetra_x, false)); inargs.set_p(0, Teuchos::rcp(¶m_vec, false)); if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot)) { // Create x_dot, filled with zeros if (x_dot == NULL) x_dot = new Epetra_Vector(epetra_x.Map()); inargs.set_x_dot(Teuchos::rcp(x_dot, false)); } // Create outargs EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs(); if (!isValidF) { EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f; Teuchos::RefCountPtr<Epetra_Vector> F = Teuchos::rcp(&epetra_f, false); eval_f.reset(F, EpetraExt::ModelEvaluator::EVAL_TYPE_EXACT); outargs.set_f(eval_f); } Teuchos::RefCountPtr<Epetra_MultiVector> DfDp = Teuchos::rcp(&epetra_dfdp, false); Teuchos::Array<int> param_indexes(param_ids.size()); for (unsigned int i=0; i<param_ids.size(); i++) param_indexes[i] = param_ids[i]; EpetraExt::ModelEvaluator::DerivativeMultiVector dmv(DfDp, EpetraExt::ModelEvaluator::DERIV_MV_BY_COL, param_indexes); EpetraExt::ModelEvaluator::Derivative deriv(dmv); outargs.set_DfDp(0, deriv); model_->evalModel(inargs, outargs); return NOX::Abstract::Group::Ok; }
// ====================================================================== bool BasicTest(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(); double starting_residual = Galeri::ComputeNorm(&*A, &LHS, &RHS); Epetra_LinearProblem Problem(&*A, &LHS, &RHS); // Set up the list Teuchos::ParameterList List; List.set("relaxation: damping factor", 1.0); List.set("relaxation: sweeps",2550); 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); } Ifpack_PointRelaxation Point(&*A); Point.SetParameters(List); Point.Compute(); // use the preconditioner as solver, with 1550 iterations Point.ApplyInverse(RHS,LHS); // compute the real residual double residual = Galeri::ComputeNorm(&*A, &LHS, &RHS); if (A->Comm().MyPID() == 0 && verbose) cout << "||A * x - b||_2 (scaled) = " << residual / starting_residual << endl; // Jacobi is very slow to converge here if (residual / starting_residual < 1e-2) { if (verbose) cout << "BasicTest Test passed" << endl; return(true); } else { if (verbose) cout << "BasicTest Test failed!" << endl; return(false); } }
// ====================================================================== 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()); }
//============================================================================== int Ifpack_IlukGraph::ConstructOverlapGraph() { OverlapGraph_ = Teuchos::rcp( (Epetra_CrsGraph *) &Graph_, false ); OverlapRowMap_ = Teuchos::rcp( (Epetra_BlockMap *) &Graph_.RowMap(), false ); if (LevelOverlap_==0 || !Graph_.DomainMap().DistributedGlobal()) return(0); // Nothing to do Teuchos::RefCountPtr<Epetra_CrsGraph> OldGraph; Teuchos::RefCountPtr<Epetra_BlockMap> OldRowMap; Epetra_BlockMap * DomainMap_tmp = (Epetra_BlockMap *) &Graph_.DomainMap(); Epetra_BlockMap * RangeMap_tmp = (Epetra_BlockMap *) &Graph_.RangeMap(); for (int level=1; level <= LevelOverlap_; level++) { OldGraph = OverlapGraph_; OldRowMap = OverlapRowMap_; OverlapImporter_ = Teuchos::rcp( (Epetra_Import *) OldGraph->Importer(), false ); OverlapRowMap_ = Teuchos::rcp( new Epetra_BlockMap(OverlapImporter_->TargetMap()) ); if (level<LevelOverlap_) OverlapGraph_ = Teuchos::rcp( new Epetra_CrsGraph(Copy, *OverlapRowMap_, 0) ); else // On last iteration, we want to filter out all columns except those that correspond // to rows in the graph. This assures that our matrix is square OverlapGraph_ = Teuchos::rcp( new Epetra_CrsGraph(Copy, *OverlapRowMap_, *OverlapRowMap_, 0) ); EPETRA_CHK_ERR(OverlapGraph_->Import( Graph_, *OverlapImporter_, Insert)); if (level<LevelOverlap_) { EPETRA_CHK_ERR(OverlapGraph_->FillComplete(*DomainMap_tmp, *RangeMap_tmp)); } else { // Copy last OverlapImporter because we will use it later OverlapImporter_ = Teuchos::rcp( new Epetra_Import(*OverlapRowMap_, *DomainMap_tmp) ); EPETRA_CHK_ERR(OverlapGraph_->FillComplete(*DomainMap_tmp, *RangeMap_tmp)); } } NumMyBlockRows_ = OverlapGraph_->NumMyBlockRows(); NumMyBlockCols_ = OverlapGraph_->NumMyBlockCols(); NumMyRows_ = OverlapGraph_->NumMyRows(); NumMyCols_ = OverlapGraph_->NumMyCols(); return(0); }
// ***************************************************************** // ***************************************************************** LOCA::Epetra::ModelEvaluatorInterface:: ModelEvaluatorInterface( const Teuchos::RCP<LOCA::GlobalData>& global_data, const Teuchos::RefCountPtr<EpetraExt::ModelEvaluator>& m, double perturb) : NOX::Epetra::ModelEvaluatorInterface(m), LOCA::DerivUtils(global_data, perturb), param_vec(*(m->get_p_init(0))), loca_param_vec(), x_dot(NULL), alpha_prev(0), beta_prev(1), observer(Teuchos::null) { // Get parameter names Teuchos::RefCountPtr<const Teuchos::Array<std::string> > param_names = m->get_p_names(0); for (std::size_t i=0; i< Teuchos::as<std::size_t>(param_names->size()); i++) loca_param_vec.addParameter((*param_names)[i], param_vec[i]); }
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 Ifpack_CrsRiluk::InitValues(const Epetra_VbrMatrix & A) { UserMatrixIsVbr_ = true; if (!Allocated()) AllocateVbr(); //cout << "Original Graph " << endl << A.Graph() << endl << flush; //A.Comm().Barrier(); //if (A.Comm().MyPID()==0) cout << "*****************************************************" <<endl; //cout << "Original Matrix " << endl << A << endl << flush; //A.Comm().Barrier(); //if (A.Comm().MyPID()==0) cout << "*****************************************************" <<endl; //cout << "Overlap Graph " << endl << *Graph_.OverlapGraph() << endl << flush; //A.Comm().Barrier(); //if (A.Comm().MyPID()==0) cout << "*****************************************************" <<endl; Teuchos::RefCountPtr<Epetra_VbrMatrix> OverlapA = Teuchos::rcp( (Epetra_VbrMatrix *) &A, false ); if (IsOverlapped_) { OverlapA = Teuchos::rcp( new Epetra_VbrMatrix(Copy, *Graph_.OverlapGraph()) ); EPETRA_CHK_ERR(OverlapA->Import(A, *Graph_.OverlapImporter(), Insert)); EPETRA_CHK_ERR(OverlapA->FillComplete()); } //cout << "Overlap Matrix " << endl << *OverlapA << endl << flush; // Get Maximun Row length int MaxNumEntries = OverlapA->MaxNumNonzeros(); // Do the rest using generic Epetra_RowMatrix interface EPETRA_CHK_ERR(InitAllValues(*OverlapA, MaxNumEntries)); return(0); }
// ====================================================================== 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()); }
//============================================================================== int Ifpack_Chebyshev:: ApplyInverse(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const { if (!IsComputed()) IFPACK_CHK_ERR(-3); if (PolyDegree_ == 0) return 0; int nVec = X.NumVectors(); int len = X.MyLength(); if (nVec != Y.NumVectors()) IFPACK_CHK_ERR(-2); Time_->ResetStartTime(); // AztecOO gives X and Y pointing to the same memory location, // need to create an auxiliary vector, Xcopy Teuchos::RefCountPtr<const Epetra_MultiVector> Xcopy; if (X.Pointers()[0] == Y.Pointers()[0]) Xcopy = Teuchos::rcp( new Epetra_MultiVector(X) ); else Xcopy = Teuchos::rcp( &X, false ); double **xPtr = 0, **yPtr = 0; Xcopy->ExtractView(&xPtr); Y.ExtractView(&yPtr); #ifdef HAVE_IFPACK_EPETRAEXT EpetraExt_PointToBlockDiagPermute* IBD=0; if (UseBlockMode_) IBD=&*InvBlockDiagonal_; #endif //--- Do a quick solve when the matrix is identity double *invDiag=0; if(!UseBlockMode_) invDiag=InvDiagonal_->Values(); if ((LambdaMin_ == 1.0) && (LambdaMax_ == LambdaMin_)) { #ifdef HAVE_IFPACK_EPETRAEXT if(UseBlockMode_) IBD->ApplyInverse(*Xcopy,Y); else #endif if (nVec == 1) { double *yPointer = yPtr[0], *xPointer = xPtr[0]; for (int i = 0; i < len; ++i) yPointer[i] = xPointer[i]*invDiag[i]; } else { int i, k; for (i = 0; i < len; ++i) { double coeff = invDiag[i]; for (k = 0; k < nVec; ++k) yPtr[k][i] = xPtr[k][i] * coeff; } } // if (nVec == 1) return 0; } // if ((LambdaMin_ == 1.0) && (LambdaMax_ == LambdaMin_)) //--- Initialize coefficients // Note that delta stores the inverse of ML_Cheby::delta double alpha = LambdaMax_ / EigRatio_; double beta = 1.1 * LambdaMax_; double delta = 2.0 / (beta - alpha); double theta = 0.5 * (beta + alpha); double s1 = theta * delta; //--- Define vectors // In ML_Cheby, V corresponds to pAux and W to dk Epetra_MultiVector V(X); Epetra_MultiVector W(X); #ifdef HAVE_IFPACK_EPETRAEXT Epetra_MultiVector Temp(X); #endif double *vPointer = V.Values(), *wPointer = W.Values(); double oneOverTheta = 1.0/theta; int i, j, k; //--- If solving normal equations, multiply RHS by A^T if(SolveNormalEquations_){ Apply_Transpose(Operator_,Y,V); Y=V; } // Do the smoothing when block scaling is turned OFF // --- Treat the initial guess if (ZeroStartingSolution_ == false) { Operator_->Apply(Y, V); // Compute W = invDiag * ( X - V )/ Theta #ifdef HAVE_IFPACK_EPETRAEXT if(UseBlockMode_) { Temp.Update(oneOverTheta,X,-oneOverTheta,V,0.0); IBD->ApplyInverse(Temp,W); // Perform additional matvecs for normal equations // CMS: Testing this only in block mode FOR NOW if(SolveNormalEquations_){ IBD->ApplyInverse(W,Temp); Apply_Transpose(Operator_,Temp,W); } } else #endif if (nVec == 1) { double *xPointer = xPtr[0]; for (i = 0; i < len; ++i) wPointer[i] = invDiag[i] * (xPointer[i] - vPointer[i]) * oneOverTheta; } else { for (i = 0; i < len; ++i) { double coeff = invDiag[i]*oneOverTheta; double *wi = wPointer + i, *vi = vPointer + i; for (k = 0; k < nVec; ++k) { *wi = (xPtr[k][i] - (*vi)) * coeff; wi = wi + len; vi = vi + len; } } } // if (nVec == 1) // Update the vector Y Y.Update(1.0, W, 1.0); } else { // Compute W = invDiag * X / Theta #ifdef HAVE_IFPACK_EPETRAEXT if(UseBlockMode_) { IBD->ApplyInverse(X,W); // Perform additional matvecs for normal equations // CMS: Testing this only in block mode FOR NOW if(SolveNormalEquations_){ IBD->ApplyInverse(W,Temp); Apply_Transpose(Operator_,Temp,W); } W.Scale(oneOverTheta); Y.Update(1.0, W, 0.0); } else #endif if (nVec == 1) { double *xPointer = xPtr[0]; for (i = 0; i < len; ++i){ wPointer[i] = invDiag[i] * xPointer[i] * oneOverTheta; } memcpy(yPtr[0], wPointer, len*sizeof(double)); } else { for (i = 0; i < len; ++i) { double coeff = invDiag[i]*oneOverTheta; double *wi = wPointer + i; for (k = 0; k < nVec; ++k) { *wi = xPtr[k][i] * coeff; wi = wi + len; } } for (k = 0; k < nVec; ++k) memcpy(yPtr[k], wPointer + k*len, len*sizeof(double)); } // if (nVec == 1) } // if (ZeroStartingSolution_ == false) //--- Apply the polynomial double rhok = 1.0/s1, rhokp1; double dtemp1, dtemp2; int degreeMinusOne = PolyDegree_ - 1; if (nVec == 1) { double *xPointer = xPtr[0]; for (k = 0; k < degreeMinusOne; ++k) { Operator_->Apply(Y, V); rhokp1 = 1.0 / (2.0*s1 - rhok); dtemp1 = rhokp1 * rhok; dtemp2 = 2.0 * rhokp1 * delta; rhok = rhokp1; // Compute W = dtemp1 * W W.Scale(dtemp1); // Compute W = W + dtemp2 * invDiag * ( X - V ) #ifdef HAVE_IFPACK_EPETRAEXT if(UseBlockMode_) { //NTS: We can clobber V since it will be reset in the Apply V.Update(dtemp2,X,-dtemp2); IBD->ApplyInverse(V,Temp); // Perform additional matvecs for normal equations // CMS: Testing this only in block mode FOR NOW if(SolveNormalEquations_){ IBD->ApplyInverse(V,Temp); Apply_Transpose(Operator_,Temp,V); } W.Update(1.0,Temp,1.0); } else{ #endif for (i = 0; i < len; ++i) wPointer[i] += dtemp2* invDiag[i] * (xPointer[i] - vPointer[i]); #ifdef HAVE_IFPACK_EPETRAEXT } #endif // Update the vector Y Y.Update(1.0, W, 1.0); } // for (k = 0; k < degreeMinusOne; ++k) } else { for (k = 0; k < degreeMinusOne; ++k) { Operator_->Apply(Y, V); rhokp1 = 1.0 / (2.0*s1 - rhok); dtemp1 = rhokp1 * rhok; dtemp2 = 2.0 * rhokp1 * delta; rhok = rhokp1; // Compute W = dtemp1 * W W.Scale(dtemp1); // Compute W = W + dtemp2 * invDiag * ( X - V ) #ifdef HAVE_IFPACK_EPETRAEXT if(UseBlockMode_) { //We can clobber V since it will be reset in the Apply V.Update(dtemp2,X,-dtemp2); IBD->ApplyInverse(V,Temp); // Perform additional matvecs for normal equations // CMS: Testing this only in block mode FOR NOW if(SolveNormalEquations_){ IBD->ApplyInverse(V,Temp); Apply_Transpose(Operator_,Temp,V); } W.Update(1.0,Temp,1.0); } else{ #endif for (i = 0; i < len; ++i) { double coeff = invDiag[i]*dtemp2; double *wi = wPointer + i, *vi = vPointer + i; for (j = 0; j < nVec; ++j) { *wi += (xPtr[j][i] - (*vi)) * coeff; wi = wi + len; vi = vi + len; } } #ifdef HAVE_IFPACK_EPETRAEXT } #endif // Update the vector Y Y.Update(1.0, W, 1.0); } // for (k = 0; k < degreeMinusOne; ++k) } // if (nVec == 1) // Flops are updated in each of the following. ++NumApplyInverse_; ApplyInverseTime_ += Time_->ElapsedTime(); return(0); }
// ====================================================================== 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); } }
// ====================================================================== 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); }
void resize(int n, Scalar p) { std_vec_->resize(n,p); }
//========================================================================== int Ifpack_CrsIct::InitValues(const Epetra_CrsMatrix & A) { int ierr = 0; int i, j; int NumIn, NumL, NumU; bool DiagFound; int NumNonzeroDiags = 0; Teuchos::RefCountPtr<Epetra_CrsMatrix> OverlapA = Teuchos::rcp( (Epetra_CrsMatrix *) &A_ , false ); if (LevelOverlap_>0) { EPETRA_CHK_ERR(-1); // Not implemented yet //OverlapA = new Epetra_CrsMatrix(Copy, *Graph_.OverlapGraph()); //EPETRA_CHK_ERR(OverlapA->Import(A, *Graph_.OverlapImporter(), Insert)); //EPETRA_CHK_ERR(OverlapA->FillComplete()); } // Get Maximun Row length int MaxNumEntries = OverlapA->MaxNumEntries(); vector<int> InI(MaxNumEntries); // Allocate temp space vector<int> UI(MaxNumEntries); vector<double> InV(MaxNumEntries); vector<double> UV(MaxNumEntries); double *DV; ierr = D_->ExtractView(&DV); // Get view of diagonal // First we copy the user's matrix into diagonal vector and U, regardless of fill level int NumRows = OverlapA->NumMyRows(); for (i=0; i< NumRows; i++) { OverlapA->ExtractMyRowCopy(i, MaxNumEntries, NumIn, &InV[0], &InI[0]); // Get Values and Indices // Split into L and U (we don't assume that indices are ordered). NumL = 0; NumU = 0; DiagFound = false; for (j=0; j< NumIn; j++) { int k = InI[j]; if (k==i) { DiagFound = true; DV[i] += Rthresh_ * InV[j] + EPETRA_SGN(InV[j]) * Athresh_; // Store perturbed diagonal in Epetra_Vector D_ } else if (k < 0) return(-1); // Out of range else if (i<k && k<NumRows) { UI[NumU] = k; UV[NumU] = InV[j]; NumU++; } } // Check in things for this row of L and U if (DiagFound) NumNonzeroDiags++; if (NumU) U_->InsertMyValues(i, NumU, &UV[0], &UI[0]); } U_->FillComplete(A_.OperatorDomainMap(), A_.OperatorRangeMap()); SetValuesInitialized(true); SetFactored(false); int ierr1 = 0; if (NumNonzeroDiags<U_->NumMyRows()) ierr1 = 1; A_.Comm().MaxAll(&ierr1, &ierr, 1); EPETRA_CHK_ERR(ierr); return(0); }
Teuchos::RefCountPtr<StdVector<Scalar> > Create() const { return Teuchos::rcp( new StdVector<Scalar>( Teuchos::rcp(new std::vector<Scalar>(std_vec_->size(),0)))); }
void Set( Scalar alpha ) { int dimension = (int)(std_vec_->size()); for (int i=0; i<dimension; i++) (*std_vec_)[i] = alpha; }
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); }
// ====================================================================== int main(int argc, char *argv[]) { #ifdef HAVE_MPI MPI_Init(&argc,&argv); Epetra_MpiComm Comm( MPI_COMM_WORLD ); #else Epetra_SerialComm Comm; #endif verbose = (Comm.MyPID() == 0); for (int i = 1 ; i < argc ; ++i) { if (strcmp(argv[i],"-s") == 0) { SymmetricGallery = true; Solver = AZ_cg; } } // size of the global matrix. 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; if (SymmetricGallery) A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) ); else A = Teuchos::rcp( Galeri::CreateCrsMatrix("Recirc2D", &*Map, GaleriList) ); // coordinates Teuchos::RCP<Epetra_MultiVector> coord = Teuchos::rcp( Galeri::CreateCartesianCoordinates("2D",&*Map,GaleriList)); // test the preconditioner int TestPassed = true; // ======================================== // // first verify that we can get convergence // // with all point relaxation methods // // ======================================== // if(!BasicTest("Jacobi",A,false)) TestPassed = false; if(!BasicTest("symmetric Gauss-Seidel",A,false)) TestPassed = false; if(!BasicTest("symmetric Gauss-Seidel",A,false,true)) TestPassed = false; if (!SymmetricGallery) { if(!BasicTest("Gauss-Seidel",A,false)) TestPassed = false; if(!BasicTest("Gauss-Seidel",A,true)) TestPassed = false; if(!BasicTest("Gauss-Seidel",A,false,true)) TestPassed = false; if(!BasicTest("Gauss-Seidel",A,true,true)) TestPassed = false; } // ============================= // // check uses as preconditioners // // ============================= // if(!KrylovTest("symmetric Gauss-Seidel",A,false)) TestPassed = false; if(!KrylovTest("symmetric Gauss-Seidel",A,false,true)) TestPassed = false; if (!SymmetricGallery) { if(!KrylovTest("Gauss-Seidel",A,false)) TestPassed = false; if(!KrylovTest("Gauss-Seidel",A,true)) TestPassed = false; if(!KrylovTest("Gauss-Seidel",A,false,true)) TestPassed = false; if(!KrylovTest("Gauss-Seidel",A,true,true)) TestPassed = false; } // ================================== // // compare point and block relaxation // // ================================== // //TestPassed = TestPassed && // ComparePointAndBlock("Jacobi",A,1); TestPassed = TestPassed && ComparePointAndBlock("Jacobi",A,10); //TestPassed = TestPassed && //ComparePointAndBlock("symmetric Gauss-Seidel",A,1); TestPassed = TestPassed && ComparePointAndBlock("symmetric Gauss-Seidel",A,10); if (!SymmetricGallery) { //TestPassed = TestPassed && //ComparePointAndBlock("Gauss-Seidel",A,1); TestPassed = TestPassed && ComparePointAndBlock("Gauss-Seidel",A,10); } // ============================ // // verify effect of # of blocks // // ============================ // { int Iters4, Iters8, Iters16; Iters4 = CompareBlockSizes("Jacobi",A,4); Iters8 = CompareBlockSizes("Jacobi",A,8); Iters16 = CompareBlockSizes("Jacobi",A,16); if ((Iters16 > Iters8) && (Iters8 > Iters4)) { if (verbose) cout << "CompareBlockSizes Test passed" << endl; } else { if (verbose) cout << "CompareBlockSizes TEST FAILED!" << endl; TestPassed = TestPassed && false; } } // ================================== // // verify effect of overlap in Jacobi // // ================================== // { int Iters0, Iters2, Iters4; Iters0 = CompareBlockOverlap(A,0); Iters2 = CompareBlockOverlap(A,2); Iters4 = CompareBlockOverlap(A,4); if ((Iters4 < Iters2) && (Iters2 < Iters0)) { if (verbose) cout << "CompareBlockOverlap Test passed" << endl; } else { if (verbose) cout << "CompareBlockOverlap TEST FAILED!" << endl; TestPassed = TestPassed && false; } } // ================================== // // check if line smoothing works // // ================================== // { int Iters1= CompareLineSmoother(A,coord); printf(" comparelinesmoother iters %d \n",Iters1); } // ================================== // // check if All singleton version of CompareLineSmoother // // ================================== // { AllSingle(A,coord); } // ================================== // // test variable blocking // // ================================== // { TestPassed = TestPassed && TestVariableBlocking(A->Comm()); } // ================================== // // test variable blocking // // ================================== // { TestPassed = TestPassed && TestTriDiVariableBlocking(A->Comm()); } // ============ // // final output // // ============ // if (!TestPassed) { cout << "Test `TestRelaxation.exe' failed!" << endl; exit(EXIT_FAILURE); } #ifdef HAVE_MPI MPI_Finalize(); #endif cout << endl; cout << "Test `TestRelaxation.exe' passed!" << endl; cout << endl; 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 size() { return (int)std_vec_->size(); }
void Update( Scalar alpha, StdVector<Scalar> & s ) { int dimension = (int)(std_vec_->size()); for (int i=0; i<dimension; i++) (*std_vec_)[i] += alpha*s[i]; }
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::CreateMap64("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; // builds an Ifpack_AdditiveSchwarz. This is templated with // the local solvers, in this case Ifpack_ICT. Note that any // other Ifpack_Preconditioner-derived class can be used // instead of Ifpack_ICT. // In this example the overlap is zero. Use // Prec(A,OverlapLevel) for the general case. Ifpack_AdditiveSchwarz<Ifpack_ICT> Prec(&*A); // `1.0' means that the factorization should approximatively // keep the same number of nonzeros per row of the original matrix. List.set("fact: ict level-of-fill", 1.0); // no modifications on the diagonal List.set("fact: absolute threshold", 0.0); List.set("fact: relative threshold", 1.0); List.set("fact: relaxation value", 0.0); // matrix `laplace_2d_bc' is not symmetric because of the way // boundary conditions are imposed. We can filter the singletons, // (that is, Dirichlet nodes) and end up with a symmetric // matrix (as ICT requires). List.set("schwarz: filter singletons", true); // 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()); LHS.PutScalar(0.0); 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_cg_condnum); 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-5); // Prints out some information about the preconditioner cout << Prec; #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; // 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); }
void clear() { std_vec_->clear(); }