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