void Test(const string what, Epetra_RowMatrix& A) { T Prec(&A); bool UseTranspose = true; IFPACK_CHK_ERRV(Prec.Initialize()); IFPACK_CHK_ERRV(Prec.Compute()); IFPACK_CHK_ERRV(Prec.SetUseTranspose(UseTranspose)); Epetra_MultiVector LHS_exact(A.OperatorDomainMap(), 2); Epetra_MultiVector LHS(A.OperatorDomainMap(), 2); Epetra_MultiVector RHS(A.OperatorRangeMap(), 2); LHS_exact.Random(); LHS.PutScalar(0.0); A.Multiply(UseTranspose, LHS_exact, RHS); Prec.ApplyInverse(RHS, LHS); LHS.Update(1.0, LHS_exact, -1.0); double norm[2]; LHS.Norm2(norm); norm[0] += norm[1]; if (norm[0] > 1e-5) { cout << what << ": Test failed: norm = " << norm[0] << endl; exit(EXIT_FAILURE); } cout << what << ": Test passed: norm = " << norm[0] << endl; }
int RowMatrixToHandle(FILE * handle, const Epetra_RowMatrix & A) { Epetra_Map map = A.RowMatrixRowMap(); const Epetra_Comm & comm = map.Comm(); int numProc = comm.NumProc(); if (numProc==1 || !A.Map().DistributedGlobal()) writeRowMatrix(handle, A); else { int numRows = map.NumMyElements(); Epetra_Map allGidsMap((int_type) -1, numRows, (int_type) 0,comm); typename Epetra_GIDTypeVector<int_type>::impl allGids(allGidsMap); for (int i=0; i<numRows; i++) allGids[i] = (int_type) map.GID64(i); // Now construct a RowMatrix on PE 0 by strip-mining the rows of the input matrix A. int numChunks = numProc; int stripSize = allGids.GlobalLength64()/numChunks; int remainder = allGids.GlobalLength64()%numChunks; int curStart = 0; int curStripSize = 0; typename Epetra_GIDTypeSerialDenseVector<int_type>::impl importGidList; if (comm.MyPID()==0) importGidList.Size(stripSize+1); // Set size of vector to max needed for (int i=0; i<numChunks; i++) { if (comm.MyPID()==0) { // Only PE 0 does this part curStripSize = stripSize; if (i<remainder) curStripSize++; // handle leftovers for (int j=0; j<curStripSize; j++) importGidList[j] = j + curStart; curStart += curStripSize; } // The following import map will be non-trivial only on PE 0. if (comm.MyPID()>0) assert(curStripSize==0); Epetra_Map importGidMap(-1, curStripSize, importGidList.Values(), 0, comm); Epetra_Import gidImporter(importGidMap, allGidsMap); typename Epetra_GIDTypeVector<int_type>::impl importGids(importGidMap); if (importGids.Import(allGids, gidImporter, Insert)!=0) {EPETRA_CHK_ERR(-1); } // importGids now has a list of GIDs for the current strip of matrix rows. // Use these values to build another importer that will get rows of the matrix. // The following import map will be non-trivial only on PE 0. Epetra_Map importMap(-1, importGids.MyLength(), importGids.Values(), map.IndexBase64(), comm); Epetra_Import importer(importMap, map); Epetra_CrsMatrix importA(Copy, importMap, 0); if (importA.Import(A, importer, Insert)!=0) {EPETRA_CHK_ERR(-1); } if (importA.FillComplete(A.OperatorDomainMap(), importMap)!=0) {EPETRA_CHK_ERR(-1);} // Finally we are ready to write this strip of the matrix to ostream if (writeRowMatrix(handle, importA)!=0) {EPETRA_CHK_ERR(-1);} } } return(0); }
//============================================================================== int Komplex_LinearProblem::TestMaps (const Epetra_RowMatrix & A0, const Epetra_RowMatrix & A1, const Epetra_MultiVector & Xr, const Epetra_MultiVector & Xi, const Epetra_MultiVector & Br, const Epetra_MultiVector & Bi){ TEUCHOS_TEST_FOR_EXCEPT(!A0.RowMatrixRowMap().SameAs(A1.RowMatrixRowMap())); TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorDomainMap().SameAs(A1.OperatorDomainMap())); TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorRangeMap().SameAs(A1.OperatorRangeMap())); TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorDomainMap().SameAs(Xr.Map())); TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorRangeMap().SameAs(Br.Map())); TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorDomainMap().SameAs(Xi.Map())); TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorRangeMap().SameAs(Bi.Map())); // Test number of vectors also TEUCHOS_TEST_FOR_EXCEPT(Xr.NumVectors()!=Xi.NumVectors()); TEUCHOS_TEST_FOR_EXCEPT(Xr.NumVectors()!=Br.NumVectors()); TEUCHOS_TEST_FOR_EXCEPT(Xr.NumVectors()!=Bi.NumVectors()); return(0); }
int check(Epetra_RowMatrix& A, Epetra_RowMatrix & B, bool verbose) { int ierr = 0; EPETRA_TEST_ERR(!A.Comm().NumProc()==B.Comm().NumProc(),ierr); EPETRA_TEST_ERR(!A.Comm().MyPID()==B.Comm().MyPID(),ierr); EPETRA_TEST_ERR(!A.Filled()==B.Filled(),ierr); EPETRA_TEST_ERR(!A.HasNormInf()==B.HasNormInf(),ierr); EPETRA_TEST_ERR(!A.LowerTriangular()==B.LowerTriangular(),ierr); EPETRA_TEST_ERR(!A.Map().SameAs(B.Map()),ierr); EPETRA_TEST_ERR(!A.MaxNumEntries()==B.MaxNumEntries(),ierr); EPETRA_TEST_ERR(!A.NumGlobalCols64()==B.NumGlobalCols64(),ierr); EPETRA_TEST_ERR(!A.NumGlobalDiagonals64()==B.NumGlobalDiagonals64(),ierr); EPETRA_TEST_ERR(!A.NumGlobalNonzeros64()==B.NumGlobalNonzeros64(),ierr); EPETRA_TEST_ERR(!A.NumGlobalRows64()==B.NumGlobalRows64(),ierr); EPETRA_TEST_ERR(!A.NumMyCols()==B.NumMyCols(),ierr); EPETRA_TEST_ERR(!A.NumMyDiagonals()==B.NumMyDiagonals(),ierr); EPETRA_TEST_ERR(!A.NumMyNonzeros()==B.NumMyNonzeros(),ierr); for (int i=0; i<A.NumMyRows(); i++) { int nA, nB; A.NumMyRowEntries(i,nA); B.NumMyRowEntries(i,nB); EPETRA_TEST_ERR(!nA==nB,ierr); } EPETRA_TEST_ERR(!A.NumMyRows()==B.NumMyRows(),ierr); EPETRA_TEST_ERR(!A.OperatorDomainMap().SameAs(B.OperatorDomainMap()),ierr); EPETRA_TEST_ERR(!A.OperatorRangeMap().SameAs(B.OperatorRangeMap()),ierr); EPETRA_TEST_ERR(!A.RowMatrixColMap().SameAs(B.RowMatrixColMap()),ierr); EPETRA_TEST_ERR(!A.RowMatrixRowMap().SameAs(B.RowMatrixRowMap()),ierr); EPETRA_TEST_ERR(!A.UpperTriangular()==B.UpperTriangular(),ierr); EPETRA_TEST_ERR(!A.UseTranspose()==B.UseTranspose(),ierr); int NumVectors = 5; { // No transpose case Epetra_MultiVector X(A.OperatorDomainMap(), NumVectors); Epetra_MultiVector YA1(A.OperatorRangeMap(), NumVectors); Epetra_MultiVector YA2(YA1); Epetra_MultiVector YB1(YA1); Epetra_MultiVector YB2(YA1); X.Random(); bool transA = false; A.SetUseTranspose(transA); B.SetUseTranspose(transA); A.Apply(X,YA1); A.Multiply(transA, X, YA2); EPETRA_TEST_ERR(checkMultiVectors(YA1,YA2,"A Multiply and A Apply", verbose),ierr); B.Apply(X,YB1); EPETRA_TEST_ERR(checkMultiVectors(YA1,YB1,"A Multiply and B Multiply", verbose),ierr); B.Multiply(transA, X, YB2); EPETRA_TEST_ERR(checkMultiVectors(YA1,YB2,"A Multiply and B Apply", verbose), ierr); } {// transpose case Epetra_MultiVector X(A.OperatorRangeMap(), NumVectors); Epetra_MultiVector YA1(A.OperatorDomainMap(), NumVectors); Epetra_MultiVector YA2(YA1); Epetra_MultiVector YB1(YA1); Epetra_MultiVector YB2(YA1); X.Random(); bool transA = true; A.SetUseTranspose(transA); B.SetUseTranspose(transA); A.Apply(X,YA1); A.Multiply(transA, X, YA2); EPETRA_TEST_ERR(checkMultiVectors(YA1,YA2, "A Multiply and A Apply (transpose)", verbose),ierr); B.Apply(X,YB1); EPETRA_TEST_ERR(checkMultiVectors(YA1,YB1, "A Multiply and B Multiply (transpose)", verbose),ierr); B.Multiply(transA, X,YB2); EPETRA_TEST_ERR(checkMultiVectors(YA1,YB2, "A Multiply and B Apply (transpose)", verbose),ierr); } Epetra_Vector diagA(A.RowMatrixRowMap()); EPETRA_TEST_ERR(A.ExtractDiagonalCopy(diagA),ierr); Epetra_Vector diagB(B.RowMatrixRowMap()); EPETRA_TEST_ERR(B.ExtractDiagonalCopy(diagB),ierr); EPETRA_TEST_ERR(checkMultiVectors(diagA,diagB, "ExtractDiagonalCopy", verbose),ierr); Epetra_Vector rowA(A.RowMatrixRowMap()); EPETRA_TEST_ERR(A.InvRowSums(rowA),ierr); Epetra_Vector rowB(B.RowMatrixRowMap()); EPETRA_TEST_ERR(B.InvRowSums(rowB),ierr) EPETRA_TEST_ERR(checkMultiVectors(rowA,rowB, "InvRowSums", verbose),ierr); Epetra_Vector colA(A.RowMatrixColMap()); EPETRA_TEST_ERR(A.InvColSums(colA),ierr); Epetra_Vector colB(B.RowMatrixColMap()); EPETRA_TEST_ERR(B.InvColSums(colB),ierr); EPETRA_TEST_ERR(checkMultiVectors(colA,colB, "InvColSums", verbose),ierr); EPETRA_TEST_ERR(checkValues(A.NormInf(), B.NormInf(), "NormInf before scaling", verbose), ierr); EPETRA_TEST_ERR(checkValues(A.NormOne(), B.NormOne(), "NormOne before scaling", verbose),ierr); EPETRA_TEST_ERR(A.RightScale(colA),ierr); EPETRA_TEST_ERR(B.RightScale(colB),ierr); EPETRA_TEST_ERR(A.LeftScale(rowA),ierr); EPETRA_TEST_ERR(B.LeftScale(rowB),ierr); EPETRA_TEST_ERR(checkValues(A.NormInf(), B.NormInf(), "NormInf after scaling", verbose), ierr); EPETRA_TEST_ERR(checkValues(A.NormOne(), B.NormOne(), "NormOne after scaling", verbose),ierr); vector<double> valuesA(A.MaxNumEntries()); vector<int> indicesA(A.MaxNumEntries()); vector<double> valuesB(B.MaxNumEntries()); vector<int> indicesB(B.MaxNumEntries()); return(0); for (int i=0; i<A.NumMyRows(); i++) { int nA, nB; EPETRA_TEST_ERR(A.ExtractMyRowCopy(i, A.MaxNumEntries(), nA, &valuesA[0], &indicesA[0]),ierr); EPETRA_TEST_ERR(B.ExtractMyRowCopy(i, B.MaxNumEntries(), nB, &valuesB[0], &indicesB[0]),ierr); EPETRA_TEST_ERR(!nA==nB,ierr); for (int j=0; j<nA; j++) { double curVal = valuesA[j]; int curIndex = indicesA[j]; bool notfound = true; int jj = 0; while (notfound && jj< nB) { if (!checkValues(curVal, valuesB[jj])) notfound = false; jj++; } EPETRA_TEST_ERR(notfound, ierr); vector<int>::iterator p = find(indicesB.begin(),indicesB.end(),curIndex); // find curIndex in indicesB EPETRA_TEST_ERR(p==indicesB.end(), ierr); } } if (verbose) cout << "RowMatrix Methods check OK" << endl; return (ierr); }
//============================================================================== int Komplex_LinearProblem::ProcessValues(double c0r, double c0i, const Epetra_RowMatrix & A0, double c1r, double c1i, const Epetra_RowMatrix & A1, const Epetra_MultiVector & Xr, const Epetra_MultiVector & Xi, const Epetra_MultiVector & Br, const Epetra_MultiVector & Bi, bool firstTime) { TEUCHOS_TEST_FOR_EXCEPT(TestMaps(A0, A1, Xr, Xi, Br, Bi)!=0); TEUCHOS_TEST_FOR_EXCEPT(InitMatrixAccess(A0, A1)!=0); TEUCHOS_TEST_FOR_EXCEPT(ConstructKomplexMaps(A0.OperatorDomainMap(), A0.OperatorRangeMap(), A0.RowMatrixRowMap())!=0); if (firstTime) { KomplexMatrix_ = Teuchos::rcp(new Epetra_CrsMatrix(Copy,*KomplexMatrixRowMap_,0)); KomplexLHS_ = Teuchos::rcp(new Epetra_MultiVector(*KomplexMatrixDomainMap_, Xr.NumVectors())); KomplexRHS_ = Teuchos::rcp(new Epetra_MultiVector(*KomplexMatrixRangeMap_, Xr.NumVectors())); } int NumMyRows = A0.NumMyRows(); // Process X and B values for (int j=0; j<Xr.NumVectors(); j++) { double *localKX = &((*KomplexLHS_)[j][0]); double *localKB = &((*KomplexRHS_)[j][0]); for (int i=0; i< NumMyRows; i++) { localKX[2*i] = Xr[j][i]; localKX[2*i+1] = Xi[j][i]; localKB[2*i] = Br[j][i]; localKB[2*i+1] = Bi[j][i]; } } int NumIndices0; int NumIndices1; int * Indices0; int * Indices1; double * Values0; double * Values1; std::vector<int> KIndices0(MaxNumMyEntries0_); std::vector<double> KValues0(MaxNumMyEntries0_); std::vector<int> KIndices1(MaxNumMyEntries1_); std::vector<double> KValues1(MaxNumMyEntries1_); int * A0_ColGids = A0.RowMatrixColMap().MyGlobalElements(); int * A1_ColGids = A1.RowMatrixColMap().MyGlobalElements(); // For each row of A0 and A1 find the real and imag parts and place entries: // A_r -A_i // A_i A_r for ( int i=0; i<NumMyRows; i++) { // Get ith row TEUCHOS_TEST_FOR_EXCEPT(GetRow(i, A0, A1, NumIndices0, Values0, Indices0, NumIndices1, Values1, Indices1)<0); int globalRow = A0.RowMatrixRowMap().GID(i); // Process real part due to c0r*A0 if (c0r!=0.0) { // Upper Left for (int j=0; j<NumIndices0; j++) { KIndices0[j] = 2*A0_ColGids[Indices0[j]]; KValues0[j] = c0r*Values0[j]; } TEUCHOS_TEST_FOR_EXCEPT(PutRow(2*globalRow, NumIndices0, &KValues0[0], &KIndices0[0], firstTime)<0); // Lower Right for (int j=0; j<NumIndices0; j++) { KIndices0[j]++; // KValues0[j] = c0r*Values0[j]; } TEUCHOS_TEST_FOR_EXCEPT(PutRow(2*globalRow+1, NumIndices0, &KValues0[0], &KIndices0[0], firstTime)<0); } // Process imag part due to c0i*A0 if (c0i!=0.0) { // Upper Right (negate values) for (int j=0; j<NumIndices0; j++) { KIndices0[j] = 2*A0_ColGids[Indices0[j]]+1; KValues0[j] = - c0i*Values0[j]; } TEUCHOS_TEST_FOR_EXCEPT(PutRow(2*globalRow, NumIndices0, &KValues0[0], &KIndices0[0], firstTime)<0); // Lower Left for (int j=0; j<NumIndices0; j++) { KIndices0[j]--; KValues0[j] *= -1.0; } TEUCHOS_TEST_FOR_EXCEPT(PutRow(2*globalRow+1, NumIndices0, &KValues0[0], &KIndices0[0], firstTime)<0); } // Process real part due to c1r*A1 if (c1r!=0.0) { // Upper Left for (int j=0; j<NumIndices1; j++) { KIndices1[j] = 2*A1_ColGids[Indices1[j]]; KValues1[j] = c1r*Values1[j]; } TEUCHOS_TEST_FOR_EXCEPT(PutRow(2*globalRow, NumIndices1, &KValues1[0], &KIndices1[0], firstTime)<0); // Lower Right for (int j=0; j<NumIndices1; j++) { KIndices1[j]++; //KValues1[j] = c1r*Values1[j]; } TEUCHOS_TEST_FOR_EXCEPT(PutRow(2*globalRow+1, NumIndices1, &KValues1[0], &KIndices1[0], firstTime)<0); } // Process imag part due to c1i*A1 if (c1i!=0.0) { // Upper Right (negate values) for (int j=0; j<NumIndices1; j++) { KIndices1[j] = 2*A1_ColGids[Indices1[j]]+1; KValues1[j] = - c1i*Values1[j]; } TEUCHOS_TEST_FOR_EXCEPT(PutRow(2*globalRow, NumIndices1, &KValues1[0], &KIndices1[0], firstTime)<0); // Lower Left for (int j=0; j<NumIndices1; j++) { KIndices1[j]--; KValues1[j] *= -1.0; } TEUCHOS_TEST_FOR_EXCEPT(PutRow(2*globalRow+1, NumIndices1, &KValues1[0], &KIndices1[0], firstTime)<0); } } return(0); }