TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(ParameterListInterpreter, SetParameterList, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include <MueLu_UseShortNames.hpp>
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,Node);
#if defined(HAVE_MUELU_TPETRA) && defined(HAVE_MUELU_EPETRA) && defined(HAVE_MUELU_IFPACK) && defined(HAVE_MUELU_IFPACK2) && defined(HAVE_MUELU_AMESOS) && defined(HAVE_MUELU_AMESOS2)
RCP<Matrix> A = TestHelpers::TestFactory<SC, LO, GO, NO>::Build1DPoisson(99);
RCP<const Teuchos::Comm<int> > comm = TestHelpers::Parameters::getDefaultComm();
ArrayRCP<std::string> fileList = TestHelpers::GetFileList(std::string("ParameterList/ParameterListInterpreter/"), std::string(".xml"));
for(int i=0; i< fileList.size(); i++) {
out << "Processing file: " << fileList[i] << std::endl;
ParameterListInterpreter mueluFactory("ParameterList/ParameterListInterpreter/" + fileList[i],*comm);
RCP<Hierarchy> H = mueluFactory.CreateHierarchy();
H->GetLevel(0)->Set("A", A);
mueluFactory.SetupHierarchy(*H);
//TODO: check no unused parameters
//TODO: check results of Iterate()
}
# else
out << "Skipping test because some required packages are not enabled (Tpetra, Epetra, EpetraExt, Ifpack, Ifpack2, Amesos, Amesos2)." << std::endl;
# endif
}
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(TransPFactory, Correctness, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include <MueLu_UseShortNames.hpp>
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,Node);
out << "version: " << MueLu::Version() << std::endl;
RCP<const Teuchos::Comm<int> > comm = TestHelpers::Parameters::getDefaultComm();
Level fineLevel, coarseLevel;
TestHelpers::TestFactory<SC, LO, GO, NO>::createTwoLevelHierarchy(fineLevel, coarseLevel);
// Test of createTwoLevelHierarchy: to be moved...
TEST_EQUALITY(fineLevel.GetLevelID(), 0);
TEST_EQUALITY(coarseLevel.GetLevelID(), 1);
//compilation warning TEST_EQUALITY(fineLevel.GetPreviousLevel().get(), NULL);
//TEST_EQUALITY(coarseLevel.GetPreviousLevel().get(), &fineLevel);
// --
RCP<Matrix> Op = TestHelpers::TestFactory<SC, LO, GO, NO>::Build1DPoisson(27*comm->getSize());
fineLevel.Set("A",Op);
SaPFactory sapFactory;
TransPFactory transPFact;
transPFact.SetFactory("P", rcpFromRef(sapFactory));
coarseLevel.Request(sapFactory);
coarseLevel.Request(transPFact);
coarseLevel.Request("P", &sapFactory);
coarseLevel.Request("R", &transPFact);
sapFactory.BuildP(fineLevel,coarseLevel);
transPFact.Build(fineLevel,coarseLevel);
RCP<Matrix> P = coarseLevel.Get< RCP<Matrix> >("P", &sapFactory);
RCP<Matrix> R = coarseLevel.Get< RCP<Matrix> >("R", &transPFact);
RCP<MultiVector> result1 = MultiVectorFactory::Build(P->getDomainMap(),1);
RCP<MultiVector> result2 = MultiVectorFactory::Build(R->getRangeMap(),1);
RCP<MultiVector> X = MultiVectorFactory::Build(P->getRangeMap(),1);
X->randomize();
//Calculate P^T * X
P->apply(*X,*result1,Teuchos::TRANS,(SC)1.0,(SC)0.0);
//Calculate R * X
R->apply(*X,*result2,Teuchos::NO_TRANS,(SC)1.0,(SC)0.0);
Teuchos::Array<typename Teuchos::ScalarTraits<SC>::magnitudeType> normX(1), normResult1(1),normResult2(1);
X->norm2(normX);
out << "This test checks the correctness of the R created by TransPFactory." << std::endl;
out << "||X||_2 = " << normX << std::endl;
result1->norm2(normResult1);
result2->norm2(normResult2);
TEST_FLOATING_EQUALITY(normResult1[0], normResult2[0], 1e-12);
} //Correctness test
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(SaPFactory_kokkos, Constructor, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include "MueLu_UseShortNames.hpp"
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,Node);
out << "version: " << MueLu::Version() << std::endl;
RCP<SaPFactory_kokkos> sapFactory = rcp(new SaPFactory_kokkos);
TEST_EQUALITY(sapFactory != Teuchos::null, true);
out << *sapFactory << std::endl;
}
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(CoalesceDropFactory_kokkos, Constructor, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include "MueLu_UseShortNames.hpp"
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,NO);
out << "version: " << MueLu::Version() << std::endl;
RCP<CoalesceDropFactory_kokkos> coalesceDropFact = rcp(new CoalesceDropFactory_kokkos());
TEST_EQUALITY(coalesceDropFact != Teuchos::null, true);
out << *coalesceDropFact << std::endl;
}
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(TransPFactory, Constructor, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include <MueLu_UseShortNames.hpp>
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,Node);
out << "version: " << MueLu::Version() << std::endl;
RCP<TransPFactory> transPFact = rcp(new TransPFactory);
TEST_EQUALITY(transPFact != Teuchos::null, true);
out << *transPFact << std::endl;
}
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(SaPFactory_kokkos, Build, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include "MueLu_UseShortNames.hpp"
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,Node);
out << "version: " << MueLu::Version() << std::endl;
RCP<const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
// construct two levels
Level fineLevel, coarseLevel;
TestHelpers_kokkos::TestFactory<SC, LO, GO, NO>::createTwoLevelHierarchy(fineLevel, coarseLevel);
// construct matrices
const SC lambdaMax = 5;
RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::Build2DPoisson(27*comm->getSize());
A->SetMaxEigenvalueEstimate(lambdaMax);
RCP<Matrix> Ptent = TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::Build2DPoisson(27*comm->getSize());
// set level matrices
fineLevel .Set("A", A);
coarseLevel.Set("P", Ptent);
// construct the factory to be tested
const double dampingFactor = 0.5;
RCP<SaPFactory_kokkos> sapFactory = rcp(new SaPFactory_kokkos);
ParameterList Pparams;
Pparams.set("sa: damping factor", dampingFactor);
sapFactory->SetParameterList(Pparams);
sapFactory->SetFactory("A", MueLu::NoFactory::getRCP());
sapFactory->SetFactory("P", MueLu::NoFactory::getRCP());
// build the data
coarseLevel.Request("P", sapFactory.get());
sapFactory->Build(fineLevel, coarseLevel);
// fetch the data
RCP<Matrix> Pfact = coarseLevel.Get<RCP<Matrix>>("P", sapFactory.get());
// construct the data to compare
SC omega = dampingFactor / lambdaMax;
RCP<Vector> invDiag = Utilities_kokkos::GetMatrixDiagonalInverse(*A);
RCP<ParameterList> APparams = rcp(new ParameterList);
RCP<Matrix> Ptest = Xpetra::IteratorOps<SC,LO,GO,NO>::Jacobi(omega, *invDiag, *A, *Ptent, Teuchos::null, out, "label", APparams);
// compare matrices by multiplying them by a random vector
RCP<MultiVector> X = MultiVectorFactory::Build(A->getDomainMap(), 1);
X->setSeed(846930886);
X->randomize();
RCP<MultiVector> Bfact = MultiVectorFactory::Build(A->getRangeMap(), 1);
RCP<MultiVector> Btest = MultiVectorFactory::Build(A->getRangeMap(), 1);
typedef Teuchos::ScalarTraits<SC> STS;
SC zero = STS::zero(), one = STS::one();
Pfact->apply(*X, *Bfact, Teuchos::NO_TRANS, one, zero);
Ptest->apply(*X, *Btest, Teuchos::NO_TRANS, one, zero);
Btest->update(-one, *Bfact, one);
Array<typename STS::magnitudeType> norms(1);
Btest->norm2(norms);
out << "|| B_factory - B_test || = " << norms[0] << std::endl;
TEST_EQUALITY(norms[0] < 1e-12, true);
}
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(SubBlockAFactory, Constructor, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include "MueLu_UseShortNames.hpp"
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,NO);
out << "version: " << MueLu::Version() << std::endl;
RCP<const Teuchos::Comm<int> > comm = TestHelpers::Parameters::getDefaultComm();
/**********************************************************************************/
/* CREATE INITIAL MATRIX */
/**********************************************************************************/
RCP<const Map> bigMap;
RCP<const Map> map1;
RCP<const Map> map2;
GO numElements = 500;
GO numElements1 = 400;
GO numElements2 = 100;
Xpetra::UnderlyingLib lib = MueLuTests::TestHelpers::Parameters::getLib();
std::vector<size_t> stridingInfo;
stridingInfo.push_back(1);
map1 = StridedMapFactory::Build(lib, numElements1, 0, stridingInfo, comm);
map2 = StridedMapFactory::Build(lib, numElements2, numElements1, stridingInfo, comm);
std::vector<GlobalOrdinal> localGids; // vector with all local GIDs on cur proc
Teuchos::ArrayView< const GlobalOrdinal > map1eleList = map1->getNodeElementList(); // append all local gids from map1 and map2
localGids.insert(localGids.end(), map1eleList.begin(), map1eleList.end());
Teuchos::ArrayView< const GlobalOrdinal > map2eleList = map2->getNodeElementList();
localGids.insert(localGids.end(), map2eleList.begin(), map2eleList.end());
Teuchos::ArrayView<GlobalOrdinal> eleList(&localGids[0],localGids.size());
bigMap = MapFactory::Build(lib, numElements, eleList, 0, comm); // create full big map (concatenation of map1 and map2)
std::vector<Teuchos::RCP<const Map> > maps;
maps.push_back(map1); maps.push_back(map2);
Teuchos::RCP<const Xpetra::MapExtractor<Scalar, LO, GO, Node> > mapExtractor = Xpetra::MapExtractorFactory<Scalar,LO,GO,Node>::Build(bigMap, maps);
RCP<CrsMatrixWrap> Op11 = GenerateProblemMatrix<Scalar, LO, GO, Node>(map1,2,-1,-1);
RCP<CrsMatrixWrap> Op22 = GenerateProblemMatrix<Scalar, LO, GO, Node>(map2,3,-2,-1);
// build blocked operator
Teuchos::RCP<Xpetra::BlockedCrsMatrix<Scalar,LO,GO,Node> > bOp = Teuchos::rcp(new Xpetra::BlockedCrsMatrix<Scalar,LO,GO,Node>(mapExtractor,mapExtractor,10));
Teuchos::RCP<Xpetra::CrsMatrix<Scalar,LO,GO,Node> > crsMat11 = Op11->getCrsMatrix();
Teuchos::RCP<Xpetra::CrsMatrix<Scalar,LO,GO,Node> > crsMat22 = Op22->getCrsMatrix();
bOp->setMatrix(0,0,crsMat11);
bOp->setMatrix(1,1,crsMat22);
bOp->fillComplete();
TEST_EQUALITY(bOp!=Teuchos::null, true);
// build hierarchy
RCP<Level> levelOne = rcp(new Level());
#ifdef HAVE_MUELU_TIMER_SYNCHRONIZATION
levelOne->SetComm(comm);
#endif
levelOne->Set("A", Teuchos::rcp_dynamic_cast<Matrix>(bOp)); // set blocked operator
// define sub block factories for blocked operator "A"
RCP<SubBlockAFactory> A11Fact = Teuchos::rcp(new SubBlockAFactory());
A11Fact->SetFactory("A",MueLu::NoFactory::getRCP());
A11Fact->SetParameter("block row",Teuchos::ParameterEntry(0));
A11Fact->SetParameter("block col",Teuchos::ParameterEntry(0));
RCP<SubBlockAFactory> A22Fact = Teuchos::rcp(new SubBlockAFactory());
A22Fact->SetFactory("A",MueLu::NoFactory::getRCP());
A22Fact->SetParameter("block row",Teuchos::ParameterEntry(1));
A22Fact->SetParameter("block col",Teuchos::ParameterEntry(1));
// request subblocks of A
levelOne->Request("A", A11Fact.get(), MueLu::NoFactory::get());
levelOne->Request("A", A22Fact.get(), MueLu::NoFactory::get());
TEST_EQUALITY(levelOne->IsRequested("A", A11Fact.get()),true);
TEST_EQUALITY(levelOne->IsRequested("A", A22Fact.get()),true);
RCP<Matrix> A11 = levelOne->Get<RCP<Matrix> >("A",A11Fact.get());
RCP<Matrix> A22 = levelOne->Get<RCP<Matrix> >("A",A22Fact.get());
TEST_EQUALITY(levelOne->IsAvailable("A", A11Fact.get()),true);
TEST_EQUALITY(levelOne->IsAvailable("A", A22Fact.get()),true);
levelOne->Release("A", A11Fact.get());
levelOne->Release("A", A22Fact.get());
TEST_EQUALITY(levelOne->IsAvailable("A", A11Fact.get()),false);
TEST_EQUALITY(levelOne->IsAvailable("A", A22Fact.get()),false);
TEST_EQUALITY(A11->getRowMap()->isSameAs(*(Op11->getRowMap())), true);
TEST_EQUALITY(A11->getColMap()->isSameAs(*(Op11->getColMap())), true);
TEST_EQUALITY(A11->getRangeMap()->isSameAs(*(Op11->getRangeMap())), true);
TEST_EQUALITY(A11->getDomainMap()->isSameAs(*(Op11->getDomainMap())), true);
TEST_EQUALITY(A11->getNodeNumEntries(),Op11->getNodeNumEntries());
TEST_EQUALITY(A22->getRowMap()->isSameAs(*(Op22->getRowMap())), true);
TEST_EQUALITY(A22->getColMap()->isSameAs(*(Op22->getColMap())), true);
TEST_EQUALITY(A22->getRangeMap()->isSameAs(*(Op22->getRangeMap())), true);
TEST_EQUALITY(A22->getDomainMap()->isSameAs(*(Op22->getDomainMap())), true);
TEST_EQUALITY(A22->getNodeNumEntries(),Op22->getNodeNumEntries());
//levelOne->print(out,Teuchos::VERB_EXTREME);
} //Constructor
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(CoalesceDropFactory_kokkos, ClassicScalarWithoutFiltering, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include "MueLu_UseShortNames.hpp"
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,NO);
out << "version: " << MueLu::Version() << std::endl;
RCP<const Teuchos::Comm<int> > comm = Parameters::getDefaultComm();
Level fineLevel;
TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::createSingleLevelHierarchy(fineLevel);
RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::Build1DPoisson(36);
fineLevel.Set("A", A);
CoalesceDropFactory_kokkos dropFact;
fineLevel.Request("Graph", &dropFact);
fineLevel.Request("DofsPerNode", &dropFact);
fineLevel.Request("Filtering", &dropFact);
dropFact.Build(fineLevel);
auto graph = fineLevel.Get<RCP<LWGraph_kokkos> >("Graph", &dropFact);
auto myDofsPerNode = fineLevel.Get<LO> ("DofsPerNode", &dropFact);
auto filtering = fineLevel.Get<bool> ("Filtering", &dropFact);
TEST_EQUALITY(as<int>(myDofsPerNode) == 1, true);
TEST_EQUALITY(filtering, false);
bool bCorrectGraph = false;
if (comm->getSize() == 1) {
auto v0 = graph->getNeighborVertices(0);
auto v1 = graph->getNeighborVertices(1);
auto v2 = graph->getNeighborVertices(2);
if (v0.size() == 2 && ((v0(0) == 0 && v0(1) == 1) || (v0(0) == 1 && v0(1) == 0)) &&
v1.size() == 3 && v2.size() == 3)
bCorrectGraph = true;
} else {
if (comm->getRank() == 0 ) {
if (graph->getNeighborVertices(0).size() == 2)
bCorrectGraph = true;
} else {
if (graph->getNeighborVertices(0).size() == 3)
bCorrectGraph = true;
}
}
TEST_EQUALITY(bCorrectGraph, true);
auto myImportMap = graph->GetImportMap(); // < note that the ImportMap is built from the column map of the matrix A WITHOUT dropping!
auto myDomainMap = graph->GetDomainMap();
TEST_EQUALITY(myImportMap->getMaxAllGlobalIndex(), 35);
TEST_EQUALITY(myImportMap->getMinAllGlobalIndex(), 0);
TEST_EQUALITY(myImportMap->getMinLocalIndex(), 0);
TEST_EQUALITY(myImportMap->getGlobalNumElements(), as<size_t>(36 + (comm->getSize()-1)*2));
TEST_EQUALITY(myDomainMap->getMaxAllGlobalIndex(), 35);
TEST_EQUALITY(myDomainMap->getMinAllGlobalIndex(), 0);
TEST_EQUALITY(myDomainMap->getMinLocalIndex(), 0);
TEST_EQUALITY(myDomainMap->getGlobalNumElements(), 36);
}
TEUCHOS_UNIT_TEST(CoalesceDropFactory, AmalgamationStrided2LW)
{
# include "MueLu_UseShortNames.hpp"
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,NO);
out << "version: " << MueLu::Version() << std::endl;
// unit test for block size 3 = (2,1). wrap block 0
// lightweight wrap = true
RCP<const Teuchos::Comm<int> > comm = Parameters::getDefaultComm();
Xpetra::UnderlyingLib lib = TestHelpers::Parameters::getLib();
// create strided map information
std::vector<size_t> stridingInfo;
stridingInfo.push_back(as<size_t>(2));
stridingInfo.push_back(as<size_t>(1));
LocalOrdinal stridedBlockId = 0;
int blockSize=3;
RCP<const StridedMap> dofMap = Xpetra::StridedMapFactory<LocalOrdinal, GlobalOrdinal, Node>::Build(lib, blockSize*comm->getSize(), 0,
stridingInfo, comm,
stridedBlockId /*blockId*/, 0 /*offset*/);
/////////////////////////////////////////////////////
Teuchos::RCP<Matrix> mtx = TestHelpers::TestFactory<SC,LO,GO,NO>::BuildTridiag(dofMap, 2.0, -1.0, -1.0);
Level fineLevel;
TestHelpers::TestFactory<SC,LO,GO,NO>::createSingleLevelHierarchy(fineLevel);
RCP<const Xpetra::StridedMap<LocalOrdinal, GlobalOrdinal, Node> > stridedRangeMap = Xpetra::StridedMapFactory<LocalOrdinal, GlobalOrdinal, Node>::Build(
mtx->getRangeMap(),
stridingInfo,
stridedBlockId,
0 /*offset*/
);
RCP<const Map> stridedDomainMap = Xpetra::StridedMapFactory<LocalOrdinal, GlobalOrdinal, Node>::Build(
mtx->getDomainMap(),
stridingInfo,
stridedBlockId,
0 /*offset*/
);
if(mtx->IsView("stridedMaps") == true) mtx->RemoveView("stridedMaps");
mtx->CreateView("stridedMaps", stridedRangeMap, stridedDomainMap);
fineLevel.Set("A", mtx);
CoalesceDropFactory dropFact = CoalesceDropFactory();
dropFact.SetParameter("lightweight wrap",Teuchos::ParameterEntry(true));
fineLevel.Request("Graph", &dropFact);
fineLevel.Request("DofsPerNode", &dropFact);
dropFact.Build(fineLevel);
fineLevel.print(out);
RCP<GraphBase> graph = fineLevel.Get<RCP<GraphBase> >("Graph", &dropFact);
LO myDofsPerNode = fineLevel.Get<LO>("DofsPerNode", &dropFact);
TEST_EQUALITY(as<int>(graph->GetDomainMap()->getGlobalNumElements()) == comm->getSize(), true);
TEST_EQUALITY(as<int>(myDofsPerNode) == blockSize, true);
bool bCorrectGraph = false;
if (comm->getSize() == 1 && graph->getNeighborVertices(0).size() == 1) {
bCorrectGraph = true;
} else {
if (comm->getRank() == 0 || comm->getRank() == comm->getSize()-1) {
if (graph->getNeighborVertices(0).size() == 2) bCorrectGraph = true;
}
else {
if (graph->getNeighborVertices(0).size() == blockSize) bCorrectGraph = true;
}
}
TEST_EQUALITY(bCorrectGraph, true);
const RCP<const Map> myImportMap = graph->GetImportMap(); // < note that the ImportMap is built from the column map of the matrix A WITHOUT dropping!
const RCP<const Map> myDomainMap = graph->GetDomainMap();
TEST_EQUALITY(myImportMap->getMaxAllGlobalIndex(), comm->getSize()-1);
TEST_EQUALITY(myImportMap->getMinAllGlobalIndex(), 0);
TEST_EQUALITY(myImportMap->getMinLocalIndex(),0);
TEST_EQUALITY(myImportMap->getGlobalNumElements(),as<size_t>(comm->getSize()+2*(comm->getSize()-1)));
if (comm->getSize()>1) {
size_t numLocalRowMapElts = graph->GetNodeNumVertices();
size_t numLocalImportElts = myImportMap->getNodeNumElements();
if (comm->getRank() == 0 || comm->getRank() == comm->getSize()-1) {
TEST_EQUALITY(as<bool>(numLocalImportElts==numLocalRowMapElts+1), true);
} else {
TEST_EQUALITY(as<bool>(numLocalImportElts==numLocalRowMapElts+2), true);
}
}
if (comm->getSize()>1) {
size_t numLocalRowMapElts = graph->GetNodeNumVertices();
size_t maxLocalIndex = myImportMap->getMaxLocalIndex();
if (comm->getRank() == 0 || comm->getRank() == comm->getSize()-1) {
TEST_EQUALITY(as<bool>(maxLocalIndex==numLocalRowMapElts*blockSize-2), true);
} else {
TEST_EQUALITY(as<bool>(maxLocalIndex==numLocalRowMapElts*blockSize-1), true);
}
}
TEST_EQUALITY(myDomainMap->getMaxAllGlobalIndex(), comm->getSize()-1);
TEST_EQUALITY(myDomainMap->getMinAllGlobalIndex(), 0);
TEST_EQUALITY(myDomainMap->getMinLocalIndex(),0);
TEST_EQUALITY(myDomainMap->getMaxLocalIndex(),0);
TEST_EQUALITY(myDomainMap->getGlobalNumElements(),as<size_t>(comm->getSize()));
TEST_EQUALITY(as<bool>(myDomainMap->getNodeNumElements()==1), true);
} // AmalgamationStrided2LW
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(CoalesceDropFactory_kokkos, ClassicBlockWithFiltering, Scalar, LocalOrdinal, GlobalOrdinal, Node)
{
# include "MueLu_UseShortNames.hpp"
MUELU_TESTING_SET_OSTREAM;
MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,NO);
out << "version: " << MueLu::Version() << std::endl;
RCP<const Teuchos::Comm<int> > comm = Parameters::getDefaultComm();
Xpetra::UnderlyingLib lib = TestHelpers_kokkos::Parameters::getLib();
Level fineLevel;
TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::createSingleLevelHierarchy(fineLevel);
auto dofMap = MapFactory::Build(lib, 3*comm->getSize(), 0, comm);
auto mtx = TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::BuildTridiag(dofMap, 2.0, -1.0, 0.00001);
mtx->SetFixedBlockSize(3, 0);
fineLevel.Set("A", mtx);
CoalesceDropFactory_kokkos dropFact = CoalesceDropFactory_kokkos();
dropFact.SetParameter("aggregation: drop tol", Teuchos::ParameterEntry(1.0));
fineLevel.Request("Graph", &dropFact);
fineLevel.Request("DofsPerNode", &dropFact);
fineLevel.Request("Filtering", &dropFact);
dropFact.Build(fineLevel);
auto graph = fineLevel.Get<RCP<LWGraph_kokkos> >("Graph", &dropFact);
auto myDofsPerNode = fineLevel.Get<LO> ("DofsPerNode", &dropFact);
auto filtering = fineLevel.Get<bool> ("Filtering", &dropFact);
TEST_EQUALITY(as<int>(myDofsPerNode) == 3, true);
TEST_EQUALITY(filtering, true);
TEST_EQUALITY(as<int>(graph->GetDomainMap()->getGlobalNumElements()) == comm->getSize(), true);
TEST_EQUALITY(graph->getNeighborVertices(0).size(), 1);
auto myImportMap = graph->GetImportMap(); // < note that the ImportMap is built from the column map of the matrix A WITHOUT dropping!
auto myDomainMap = graph->GetDomainMap();
TEST_EQUALITY(myImportMap->getMaxAllGlobalIndex(), comm->getSize()-1);
TEST_EQUALITY(myImportMap->getMinAllGlobalIndex(), 0);
TEST_EQUALITY(myImportMap->getMinLocalIndex(), 0);
TEST_EQUALITY(myImportMap->getGlobalNumElements(), as<size_t>(comm->getSize()+2*(comm->getSize()-1)));
if (comm->getSize() > 1) {
size_t numLocalRowMapElts = graph->GetNodeNumVertices();
size_t numLocalImportElts = myImportMap->getNodeNumElements();
if (comm->getRank() == 0 || comm->getRank() == comm->getSize()-1) {
TEST_EQUALITY(numLocalImportElts, numLocalRowMapElts+1);
} else {
TEST_EQUALITY(numLocalImportElts, numLocalRowMapElts+2);
}
}
TEST_EQUALITY(myDomainMap->getMaxAllGlobalIndex(), comm->getSize()-1);
TEST_EQUALITY(myDomainMap->getMinAllGlobalIndex(), 0);
TEST_EQUALITY(myDomainMap->getMaxLocalIndex(), 0);
TEST_EQUALITY(myDomainMap->getMinLocalIndex(), 0);
TEST_EQUALITY(myDomainMap->getGlobalNumElements(), as<size_t>(comm->getSize()));
TEST_EQUALITY(myDomainMap->getNodeNumElements(), 1);
}
