int main(void) { reduce_test(); printf("Reduce passed\n"); add_test(); printf("Add passed\n"); multiply_test(); printf("Multiply passed\n"); printf("\n"); return 0; }
/** * This test was written at the request of Chris Siefert * in order to verity that A^T * I produces correct results * when A's rowmap and rangemap are differnt. * KLN 23/06/2011 */ TEUCHOS_UNIT_TEST(Tpetra_MatMat, ATI_range_row_test){ RCP<const Comm<int> > comm = DefaultPlatform::getDefaultPlatform().getComm(); ParameterList defaultParameters; RCP<node_type> node = rcp(new node_type(defaultParameters)); int numProcs = comm->getSize(); //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! //THIS NUMBER MUST BE EVEN SO THAT WHEN I CALCULATE THE NUMBER //OF ROWS IN THE DOMAIN MAP I DON'T ENCOUNTER ANY //WEIRD RESULTS DUE TO INTEGER DIVISION //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! int numRowsPerProc = 4; int rank = comm->getRank(); global_size_t globalNumRows = numRowsPerProc*numProcs; //Create identity matrix RCP<CrsMatrix<double,int,int,node_type> > identityMatrix = getIdentityMatrix<double,int,int,int>(globalNumRows, comm, node); //Create A Array<int> aMyRows = tuple<int>( rank*numRowsPerProc, rank*numRowsPerProc+1, rank*numRowsPerProc+2, rank*numRowsPerProc+3); RCP<const Map<int,int,node_type> > aRowMap = Tpetra::createNonContigMapWithNode<int,int,node_type>( aMyRows, comm, node); RCP<const Map<int,int,node_type> > aDomainMap = Tpetra::createUniformContigMapWithNode<int,int,node_type>( globalNumRows/2, comm, node); Array<int> aRangeElements; if(rank == 0){ aRangeElements = tuple<int>( (numProcs-1)*numRowsPerProc+1, (numProcs-1)*numRowsPerProc+2, (numProcs-1)*numRowsPerProc, (numProcs-1)*numRowsPerProc+3); } else{ aRangeElements = tuple<int>( (rank-1)*numRowsPerProc+1, (rank-1)*numRowsPerProc+2, (rank-1)*numRowsPerProc, (rank-1)*numRowsPerProc+3); } RCP<const Map<int,int,node_type> > aRangeMap = Tpetra::createNonContigMapWithNode<int,int,node_type>( aRangeElements, comm, node); RCP<CrsMatrix<double,int,int,node_type> > aMat = Tpetra::createCrsMatrix<double,int,int,node_type>(aRowMap, 1); for( ArrayView<const int>::iterator it = aRowMap->getNodeElementList().begin(); it != aRowMap->getNodeElementList().end(); ++it) { Array<int> col(1,(*it)/2); Array<double> val(1,3.0); aMat->insertGlobalValues(*it, col(), val()); } aMat->fillComplete(aDomainMap, aRangeMap); RowMatrixTransposer<double,int,int,node_type> transposer (aMat); RCP<CrsMatrix<double, int, int, node_type> > knownAMat = transposer.createTranspose(); out << "Regular I*P" << std::endl; mult_test_results results = multiply_test( "Different Range and Row Maps", aMat, identityMatrix, true, false, knownAMat, comm, out); if(verbose){ out << "Results:" <<std::endl; out << "\tEpsilon: " << results.epsilon << std::endl; out << "\tcNorm: " << results.cNorm << std::endl; out << "\tcompNorm: " << results.compNorm << std::endl; } TEST_COMPARE(results.epsilon, <, defaultEpsilon) }
/* * This test was created at the request of Chris Siefert to verify * that some inexplicable behaviour in MueLu was not due to a faulty * assumption in the Matrix Matrix Multiply Kernel. * KLN 15/06/2011 */ TEUCHOS_UNIT_TEST(Tpetra_MatMat, range_row_test){ RCP<const Comm<int> > comm = DefaultPlatform::getDefaultPlatform().getComm(); ParameterList defaultParameters; RCP<node_type> node = rcp(new node_type(defaultParameters)); int numProcs = comm->getSize(); //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! //THIS NUMBER MUST BE EVEN SO THAT WHEN I CALCULATE THE NUMBER //OF ROWS IN THE DOMAIN MAP I DON'T ENCOUNTER ANY //WEIRD RESULTS DUE TO INTEGER DIVISION //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! int numRowsPerProc = 4; int rank = comm->getRank(); global_size_t globalNumRows = numRowsPerProc*numProcs; RCP<CrsMatrix<double,int,int,node_type> > identityMatrix = getIdentityMatrix<double,int,int,int>(globalNumRows, comm, node); //Create "B" Array<int> myRows = tuple<int>( rank*numRowsPerProc, rank*numRowsPerProc+1, rank*numRowsPerProc+2, rank*numRowsPerProc+3); Array<int> rangeElements; if(rank == 0){ rangeElements = tuple<int>( (numProcs-1)*numRowsPerProc+1, (numProcs-1)*numRowsPerProc+2, (numProcs-1)*numRowsPerProc, (numProcs-1)*numRowsPerProc+3); } else{ rangeElements = tuple<int>( (rank-1)*numRowsPerProc+1, (rank-1)*numRowsPerProc+2, (rank-1)*numRowsPerProc, (rank-1)*numRowsPerProc+3); } RCP<const Map<int,int,node_type> > bRowMap = Tpetra::createNonContigMapWithNode<int,int,node_type>(myRows, comm, node); RCP<const Map<int,int,node_type> > bRangeMap = Tpetra::createNonContigMapWithNode<int,int,node_type>(rangeElements, comm, node); //We divide by 2 to make the matrix tall and "skinny" RCP<const Map<int,int,node_type> > bDomainMap = Tpetra::createUniformContigMapWithNode<int,int,node_type>( globalNumRows/2, comm, node); RCP<CrsMatrix<double,int,int,node_type> > bMatrix = Tpetra::createCrsMatrix<double,int,int,node_type>(bRowMap, 1); for( ArrayView<const int>::iterator it = bRowMap->getNodeElementList().begin(); it != bRowMap->getNodeElementList().end(); ++it) { Array<int> col(1,(*it)/2); Array<double> val(1,3.0); bMatrix->insertGlobalValues(*it, col(), val()); } bMatrix->fillComplete(bDomainMap, bRangeMap); out << "Regular I*P" << std::endl; mult_test_results results = multiply_test( "Different Range and Row Maps", identityMatrix, bMatrix, false, false, bMatrix, comm, out); if(verbose){ out << "Results:" <<std::endl; out << "\tEpsilon: " << results.epsilon << std::endl; out << "\tcNorm: " << results.cNorm << std::endl; out << "\tcompNorm: " << results.compNorm << std::endl; } TEST_COMPARE(results.epsilon, <, defaultEpsilon) RCP<CrsMatrix<double,int,int,node_type> > identity2 = getIdentityMatrix<double,int,int,int>(globalNumRows/2, comm, node); RCP<const Map<int,int,node_type> > bTransRowMap = Tpetra::createUniformContigMapWithNode<int,int,node_type>(globalNumRows/2,comm,node); RCP<CrsMatrix<double,int,int,node_type> > bTrans = Tpetra::createCrsMatrix<double,int,int,node_type>(bTransRowMap, 1); Array<int> bTransRangeElements; if(rank == 0){ bTransRangeElements = tuple<int>( (numProcs-1)*(numRowsPerProc/2)+1, (numProcs-1)*(numRowsPerProc/2)); } else{ bTransRangeElements = tuple<int>( (rank-1)*(numRowsPerProc/2)+1, (rank-1)*(numRowsPerProc/2)); } out << bTransRangeElements << std::endl; RCP<const Map<int,int,node_type> > bTransRangeMap = Tpetra::createNonContigMapWithNode<int,int,node_type>(bTransRangeElements, comm, node); RCP<const Map<int,int,node_type> > bTransDomainMap = Tpetra::createUniformContigMapWithNode<int,int,node_type>(globalNumRows,comm,node); Tpetra::MatrixMatrix::Multiply(*identity2,false,*bMatrix, true, *bTrans, false); bTrans->fillComplete(bTransDomainMap, bTransRangeMap); RCP<CrsMatrix<double,int,int,node_type> > bTransTest = Tpetra::createCrsMatrix<double,int,int,node_type>(bTransRowMap, 1); for( ArrayView<const int>::iterator it = bRowMap->getNodeElementList().begin(); it != bRowMap->getNodeElementList().end(); ++it) { Array<int> col(1,*it); Array<double> val(1,3.0); bTransTest->insertGlobalValues((*it)/2, col(), val()); } bTransTest->fillComplete(bTransDomainMap, bTransRangeMap); out << "Regular I*P^T" << std::endl; RCP<CrsMatrix<double,int,int,node_type> > bTransDiff = Tpetra::createCrsMatrix<double,int,int,node_type>(bTransRowMap, 1); Tpetra::MatrixMatrix::Add<double,int,int,node_type>(*bTransTest, false, -1.0, *bTrans, false, 1.0,bTransDiff); bTransDiff->fillComplete(bTransDomainMap, bDomainMap); double diffNorm = bTransDiff->getFrobeniusNorm (); double realNorm = bTransTest->getFrobeniusNorm (); double calcEpsilon = diffNorm/realNorm; out << "B" << std::endl; if(verbose){ out << "Results:" <<std::endl; out << "\tEpsilon: " << calcEpsilon<< std::endl; out << "\treal norm: " << realNorm<< std::endl; out << "\tcompNorm: " << diffNorm<< std::endl; } TEST_COMPARE(calcEpsilon, <, defaultEpsilon) }