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