From 5473ba6d18690a69137bb165c80df880c758fe65 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Fri, 6 Jul 2018 11:33:32 +0200 Subject: [PATCH 01/20] interface start --- .../adapters/Stratimikos_FROSchHelpers.cpp | 0 .../adapters/Stratimikos_FROSchHelpers.hpp | 37 +++ ...Sch_TwoLevelPreconditionerFactory_decl.hpp | 304 ++++++++++++++++++ ...OSch_TwoLevelPreconditionerFactory_def.hpp | 257 +++++++++++++++ 4 files changed, 598 insertions(+) create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.cpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.cpp b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.cpp new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp new file mode 100644 index 000000000000..59ae042e3d73 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp @@ -0,0 +1,37 @@ + + +#include "Stratimikos_DefaultLinearSolverBuilder.hpp" + +#include "Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp" + + +#include "Teuchos_RCP.hpp" +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_TestForException.hpp" +#include "Teuchos_AbstractFactoryStd.hpp" + +#include +#include "Kokkos_DefaultNode.hpp" + + +namespace Stratimikos { + + template + void enableFROSchTwoLevel(DefaultLinearSolverBuilder& builder, const std::string& stratName = "FROSchTwoLevel") + { + const Teuchos::RCP precValidParams = Teuchos::sublist(builder.getValidParameters(), "Preconditioner Types"); + + TEUCHOS_TEST_FOR_EXCEPTION(precValidParams->isParameter(stratName), std::logic_error, + "Stratimikos::enableFROSch_TwoLevel cannot add \"" + stratName +"\" because it is already included in builder!"); + + typedef Thyra::PreconditionerFactoryBase Base; + typedef Thyra::FROSch_TwoLevelPreconditionerFactory Impl; + + builder.setPreconditioningStrategyFactory(Teuchos::abstractFactoryStd(), stratName); + } + + + +} // namespace Stratimikos + + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp new file mode 100644 index 000000000000..6e2808b0d993 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp @@ -0,0 +1,304 @@ +#ifndef THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DECL_HPP +#define THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DECL_HPP + + +// Stratimikos needs Thyra, so we don't need special guards for Thyra here +#include "Thyra_DefaultPreconditioner.hpp" +#include "Thyra_BlockedLinearOpBase.hpp" +#include "Thyra_XpetraLinearOp.hpp" +#ifdef HAVE_MUELU_TPETRA +#include "Thyra_TpetraLinearOp.hpp" +#include "Thyra_TpetraThyraWrappers.hpp" +#endif +#include "Thyra_EpetraLinearOp.hpp" +#include "Thyra_TpetraLinearOp.hpp" +#include "Thyra_TpetraThyraWrappers.hpp" + +#include "Teuchos_Ptr.hpp" +#include "Teuchos_TestForException.hpp" +#include "Teuchos_Assert.hpp" +#include "Teuchos_Time.hpp" + +#include +#include +#include +#include +//PUT FROSch includes here + +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_RCP.hpp" +#include "Teuchos_ArrayRCP.hpp" +#include "Teuchos_Array.hpp" + +#include +#include +#include +#include +#include + +#include +#include +#include + + +//#include +#include +#include + +#include +#include +// + +#include "Thyra_PreconditionerFactoryBase.hpp" + +#include "Kokkos_DefaultNode.hpp" + +namespace Thyra { + + template + class FROSch_TwoLevelPreconditionerFactory:public Thyra::PreconditionerFactoryBase{ + public: + + //Constructor + FROSch_TwoLevelPreconditionerFactory(); + + //Overridden from PreconditionerFactory Base + bool isCompatible(const LinearOpSourceBase& fwdOp) const; + + Teuchos::RCP > createPrec() const; + + void initializePrec(const Teuchos::RCP >& fwdOpSrc, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const; + + void uninitializePrec(PreconditionerBase* prec, + Teuchos::RCP >* fwdOp, + ESupportSolveUse* supportSolveUse + ) const; + + void setParameterList(const Teuchos::RCP& paramList); + + Teuchos::RCP unsetParameterList(); + + Teuchos::RCP getNonconstParameterList(); + + Teuchos::RCP getParameterList() const; + + Teuchos::RCP getValidParameters() const; + + std::string description() const; + private: + Teuchos::RCP paramList_; + + + + }; + +#ifdef HAVE_FROSCH_EPETRA + + //special fpr Epetra + template<> + class FROSch_TwoLevelPreconditionerFactory:public PreconditionerFactoryBase{ + public: + typedef double Scalar; + typedef int LocalOrdinal; + typedef int GlobalOrdinal; + typedef Xpetra::EpetraNode Node; + + //Constructor + FROSch_TwoLevelPreconditionerFactory():paramList_(rcp(new ParameterList())) { }; + + //Overridden from PreconditionerFactory Base + bool isCompatible(const LinearOpSourceBase& fwdOpSrc) const{ + const RCP > fwdOp = fwdOpSrc.getOp(); + + if(Xpetra::ThyraUtils::isBlockedOperator(fwdOp)) return true; + + return false; + + }; + + Teuchos::RCP > createPrec() const { + return Teuchos::rcp(new DefaultPreconditioner); + }; + + + voidd initializePrec(const Teuchos::RCP >& fwdOp, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const{ + + using Teuchos::rcp_dynamic_cast; + //Some Typedefs + typedef Xpetra::Map XpMap; + typedef Xpetra::Operator XpOp; + typedef Xpetra::ThyraUtils XpThyUtils; + typedef Xpetra::CrsMatrix XpCrsMat; + typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; + typedef Xpetra::Matrix XpMat; + typedef Xpetra::MultiVector XpMultVec; + typedef Xpetra::MultiVector XpMultVecDouble; + typedef Thyra::LinearOpBase ThyLinOpBase; + + //PreCheck + TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); + TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); + TEUCHOS_ASSERT(prec); + + // Create a copy, as we may remove some things from the list + ParameterList paramList = *paramList_; + + // Retrieve wrapped concrete Xpetra matrix from FwdOp + const RCP fwdOp = fwdOpSrc->getOp(); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); + + // Check whether it is Epetra/Tpetra + bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); + bool bIsTpetra = XpThyUtils::isTpetra(fwdOp); + bool bIsBlocked = XpThyUtils::isBlockedOperator(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == true && bIsTpetra == true)); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == bIsTpetra) && bIsBlocked == false); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); + + RCP A = Teuchos::null; + if(bIsBlocked) { + Teuchos::RCP > ThyBlockedOp = + Teuchos::rcp_dynamic_cast >(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(ThyBlockedOp)); + + TEUCHOS_TEST_FOR_EXCEPT(ThyBlockedOp->blockExists(0,0)==false); + + Teuchos::RCP > b00 = ThyBlockedOp->getBlock(0,0); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(b00)); + + RCP xpetraFwdCrsMat00 = XpThyUtils::toXpetra(b00); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat00)); + + // TwoLevelPreconditioner needs Xpetra CRS Matrix ans input object as input + RCP xpetraFwdCrsMatNonConst00 = Teuchos::rcp_const_cast(xpetraFwdCrsMat00); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst00)); + + // wrap the forward operator as an Xpetra::Matrix that TwoLevelPreconditioner can work with + RCP A00 = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst00)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A00)); + + RCP rowmap00 = A00->getRowMap(); + RCP< const Teuchos::Comm< int > > comm = rowmap00->getComm(); + + // create a Xpetra::BlockedCrsMatrix which derives from Xpetra::Matrix that FROSCH can work with + RCP bMat = Teuchos::rcp(new XpCrsMat(ThyBlockedOp, comm)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(bMat)); + + // save blocked matrix + A = bMat; + } else { + RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); + + // FROSCH needs a non-const object as input + RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); + + // wrap the forward operator as an Xpetra::Matrix that MueLu can work with + A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); + } + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); + + // Retrieve concrete preconditioner object + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + // extract preconditioner operator + RCP thyra_precOp = Teuchos::null; + thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); + + //Later needs to be a utility ExtractCoordinatesFromParameterList + //not implemented yet + // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); + + RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,paramList)); + + //Initialize-> Only Works for laplce (cause defaults are used) and compute + TwoLevelPrec->inialize(); + TwoLevelPrec->compute(); + + //Wrap tp thyra + RCP thyraPrecOp = Teuchos::null; + + if(bIsBlocked) { + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); + + //create const Operator + const RCP > frosch_op = rcp(new FROSch::TwoLevelPreconditioner(TwoLevelPrec)); + + RCP > thyraRangeSpace = Xpetra::ThyraUtils::toThyra(frosch_op->getRangeMap()); + + RCP > thyraDomainSpace = Xpetra::ThyraUtils::toThyra(frosch_op->getDomainMap()); + + RCP > xpOp = Teuchos::rcp_dynamic_cast >(frosch_op); + thyraPrecOp = Thyra::xpetraLinearOp(thyraRangeSpace, thyraDomainSpace,xpOp); + + + } + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyraPrecOp)); + + defaultPrec->initializeUnspecified(thyraPrecOp); + + }; + + void uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { + TEUCHOS_ASSERT(prec); + + // Retrieve concrete preconditioner object + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + if (fwdOp) { + // TODO: Implement properly instead of returning default value + *fwdOp = Teuchos::null; + } + + if (supportSolveUse) { + // TODO: Implement properly instead of returning default value + *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; + } + + defaultPrec->uninitialize(); + }; + + void setParameterList(RCP const & paramList){ + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); + paramList_ = paramList; + }; + + RCPgetNonconstParameterList(){ + return paramList_; + }; + + RCP getParameterList() const { + return paramList_; + }; + + RCP getValidParameters() const { + static RCP validPL; + + if (Teuchos::is_null(validPL)) + validPL = rcp(new ParameterList()); + + return validPL; + }; + + std::string description() const { + return "Thyra::FROSch_TwoLevelPreconditionerFactory"; + }; + + private: + Teuchos::RCP paramList_; + }; + + } +#endif +} +#endif + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp new file mode 100644 index 000000000000..d6bedee84f3e --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp @@ -0,0 +1,257 @@ +#ifndef THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DEF_HPP +#define THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DEF_HPP + +#include "Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp" + + +#include +#include + + +namespace Thyra { + using Teuchos::RCP; + using Teuchos::rcp; + using Teuchos::ParameterList; + + //Constructor + template + FROSch_TwoLevelPreconditionerFactory::FROSch_TwoLevelPreconditionerFactory() + { + paramList_ = rcp(new Teuchos::ParameterList()); + } +//----------------------------------------------------------- + template + bool FROSch_TwoLevelPreconditionerFactory::isCompatible(const LinearOpSourceBase& fwdOpSrc) const + { + const RCP > fwdOp = fwdOpSrc.getOp(); + //so far only Epetra is allowed + if (Xpetra::ThyraUtils::isBlockedOperator(fwdOp)) return true; + + return false; + } +//-------------------------------------------------------------- + template + RCP >FROSch_TwoLevelPreconditionerFactory::createPrec() const{ + return Teuchos::rcp(new DefaultPreconditioner); + + } +//------------------------------------------------------------- + template + void FROSch_TwoLevelPreconditionerFactory::initializePrec + (const Teuchos::RCP >& fwdOpSrc, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const{ + + Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); + + + using Teuchos::rcp_dynamic_cast; + //Some Typedefs + typedef Xpetra::Map XpMap; + typedef Xpetra::Operator XpOp; + typedef Xpetra::ThyraUtils XpThyUtils; + typedef Xpetra::CrsMatrix XpCrsMat; + typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; + typedef Xpetra::Matrix XpMat; + typedef Xpetra::MultiVector XpMultVec; + typedef Xpetra::MultiVector XpMultVecDouble; + typedef Thyra::LinearOpBase ThyLinOpBase; + + + + + //PreCheck + TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); + //TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); + TEUCHOS_ASSERT(prec); + + // Create a copy, as we may remove some things from the list + ParameterList paramList = *paramList_; + + // Retrieve wrapped concrete Xpetra matrix from FwdOp + const RCP fwdOp = fwdOpSrc->getOp(); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); + + // Check whether it is Epetra/Tpetra + bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); + bool bIsTpetra = XpThyUtils::isTpetra(fwdOp); + bool bIsBlocked = XpThyUtils::isBlockedOperator(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == true && bIsTpetra == true)); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == bIsTpetra) && bIsBlocked == false); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); + + RCP A = Teuchos::null; + if(bIsBlocked) { + Teuchos::RCP > ThyBlockedOp = + Teuchos::rcp_dynamic_cast >(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(ThyBlockedOp)); + + TEUCHOS_TEST_FOR_EXCEPT(ThyBlockedOp->blockExists(0,0)==false); + + Teuchos::RCP > b00 = ThyBlockedOp->getBlock(0,0); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(b00)); + + RCP xpetraFwdCrsMat00 = XpThyUtils::toXpetra(b00); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat00)); + + // TwoLevelPreconditioner needs Xpetra CRS Matrix ans input object as input + RCP xpetraFwdCrsMatNonConst00 = Teuchos::rcp_const_cast(xpetraFwdCrsMat00); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst00)); + + // wrap the forward operator as an Xpetra::Matrix that TwoLevelPreconditioner can work with + RCP A00 = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst00)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A00)); + + RCP rowmap00 = A00->getRowMap(); + RCP< const Teuchos::Comm< int > > comm = rowmap00->getComm(); + + // create a Xpetra::BlockedCrsMatrix which derives from Xpetra::Matrix that FROSCH can work with + RCP bMat = Teuchos::rcp(new XpBlockedCrsMat(ThyBlockedOp, comm)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(bMat)); + + // save blocked matrix + A = bMat; + } else { + std::cout<<"Not Blocked\n"; + + RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); + + // FROSCH needs a non-const object as input + RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); + + // wrap the forward operator as an Xpetra::Matrix that FROSch can work with + A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); + //A->describe(*fancy,Teuchos::VERB_EXTREME); + + } + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); + + // Retrieve concrete preconditioner object--->Here Mem Leak? + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + // extract preconditioner operator + RCP thyra_precOp = Teuchos::null; + thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); + + //Later needs to be a utility ExtractCoordinatesFromParameterList + //not implemented yet + // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); + + const RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); + + RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); + + + //Initialize-> Only Works for laplce (cause defaults are used) and compute + TwoLevelPrec->initialize(); + std::cout<<"Initialize Two Level Prec\n"; + + TwoLevelPrec->compute(); + + //Wrap tp thyra + RCP thyraPrecOp = Teuchos::null; + Comm->barrier(); Comm->barrier(); Comm->barrier(); + std::cout<<"Compute Two Level Prec\n"; + + // if(bIsBlocked) { + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); + + //create const Operator + //RCP > frosch_op = Teuchos::rcp_implicit_cast >(TwoLevelPrec); + //Teuchos::rcp_const_cast > (frosch_op) = TwoLevelPrec; + //TwoLevelPrec->getRangeMap()->describe(*fancy,Teuchos::VERB_EXTREME); + RCP > thyraRangeSpace = Xpetra::ThyraUtils::toThyra(TwoLevelPrec->getRangeMap()); + Comm->barrier(); Comm->barrier(); Comm->barrier(); + RCP > thyraDomainSpace = Xpetra::ThyraUtils::toThyra(TwoLevelPrec->getDomainMap()); + + RCP > xpOp = Teuchos::rcp_dynamic_cast >(TwoLevelPrec); + thyraPrecOp = Thyra::xpetraLinearOp(thyraRangeSpace, thyraDomainSpace,xpOp); + + //} + Comm->barrier(); + Comm->barrier(); + Comm->barrier(); + + std::cout<<"Test for null pointer\n"; + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyraPrecOp)); + + defaultPrec->initializeUnspecified(thyraPrecOp); + Comm->barrier(); + Comm->barrier(); + Comm->barrier(); + std::cout<<"Thyra OP\n"; + + } +//------------------------------------------------------------- + template + void FROSch_TwoLevelPreconditionerFactory:: + uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { + TEUCHOS_ASSERT(prec); + + // Retrieve concrete preconditioner object + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + if (fwdOp) { + // TODO: Implement properly instead of returning default value + *fwdOp = Teuchos::null; + } + + if (supportSolveUse) { + // TODO: Implement properly instead of returning default value + *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; + } + + defaultPrec->uninitialize(); + } +//----------------------------------------------------------------- + template + void FROSch_TwoLevelPreconditionerFactory::setParameterList(RCP const & paramList){ + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); + paramList_ = paramList; + } + +//------------------------------------------------------------------ + template + RCP FROSch_TwoLevelPreconditionerFactory::getNonconstParameterList(){ + return paramList_; + } + +//----------------------------------------------------------------------- + template + RCP + FROSch_TwoLevelPreconditionerFactory::getParameterList() const { + return paramList_; + } +//-------------------------------------------------------------------- + template + RCP FROSch_TwoLevelPreconditionerFactory::getValidParameters() const { + static RCP validPL; + + if (Teuchos::is_null(validPL)) + validPL = rcp(new ParameterList()); + + return validPL; + } +//----------------------------------------------------------------------- + template + std::string FROSch_TwoLevelPreconditionerFactory::description() const { + return "Thyra::FROSch_TwoLevelPreconditionerFactory"; + } +//-------------------------------------------------------------------------- + template + RCP FROSch_TwoLevelPreconditionerFactory::unsetParameterList(){ + RCP savedParamList = paramList_; + paramList_ = Teuchos::null; + return savedParamList; + + } + +} +#endif + From edc4ddbcaac06ac5c9cfade3730fa6ed0f5c7b32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Tue, 17 Jul 2018 07:11:05 +0200 Subject: [PATCH 02/20] =?UTF-8?q?Test=20Thyra=5FFROSch=20=E2=80=94not=20wo?= =?UTF-8?q?rking=20yet!?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../shylu/shylu_dd/frosch/test/CMakeLists.txt | 1 + .../frosch/test/Stratimikos/CMakeLists.txt | 22 ++ .../shylu_dd/frosch/test/Stratimikos/main.cpp | 245 ++++++++++++++ .../Stratimikos/stratimikos_ParameterList.xml | 320 ++++++++++++++++++ 4 files changed, 588 insertions(+) create mode 100644 packages/shylu/shylu_dd/frosch/test/Stratimikos/CMakeLists.txt create mode 100644 packages/shylu/shylu_dd/frosch/test/Stratimikos/main.cpp create mode 100644 packages/shylu/shylu_dd/frosch/test/Stratimikos/stratimikos_ParameterList.xml diff --git a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt index 53d514d04631..99f221dfc932 100644 --- a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt @@ -7,4 +7,5 @@ ADD_SUBDIRECTORIES( LocalPartitionOfUnityBasis InterfacePartitionOfUnity TwoLevelPreconditionerInputFiles + Stratimikos ) diff --git a/packages/shylu/shylu_dd/frosch/test/Stratimikos/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/Stratimikos/CMakeLists.txt new file mode 100644 index 000000000000..f71c58c3d19a --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/test/Stratimikos/CMakeLists.txt @@ -0,0 +1,22 @@ +TRIBITS_ADD_EXECUTABLE( + stratimikos_frosch + SOURCES main.cpp +) + +TRIBITS_COPY_FILES_TO_BINARY_DIR(StratimikosCopyFiles + DEST_FILES stratimikos_ParameterList.xml stratimikos_ParameterList.xml + SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} + DEST_DIR ${CMAKE_CURRENT_BINARY_DIR} + EXEDEPS stratimikos_frosch +) + +#FR 17/07/2018: Adding Tests +TRIBITS_ADD_TEST( + stratimikos_frosch + NAME test_stratimikos_frosch + ARGS "--DIM=2" + COMM mpi + NUM_MPI_PROCS 4 +) + + diff --git a/packages/shylu/shylu_dd/frosch/test/Stratimikos/main.cpp b/packages/shylu/shylu_dd/frosch/test/Stratimikos/main.cpp new file mode 100644 index 000000000000..594dab4ed037 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/test/Stratimikos/main.cpp @@ -0,0 +1,245 @@ +#include +// Teuchos includes +#include +#include +#include +#include +#include + +// Epetra includes +#include + + +// Thyra includes +#include +#include +#include + +// Stratimikos includes +#include +#include + +// Xpetra include +#include + +// MueLu includes +#include + +// Galeri +#include +#include +#include +#include +// Galeri +#include +#include +#include + + + + +#include +#include +#include + +typedef unsigned UN; +typedef double SC; +typedef int LO; +typedef int GO; +typedef KokkosClassic::DefaultNode::DefaultNodeType EpetraNode; +typedef EpetraNode NO; + + +using namespace std; +using namespace Teuchos; +using namespace Xpetra; +using namespace Belos; + + +int main(int argc, char *argv[]) +{ + + using Teuchos::RCP; // reference count pointers + using Teuchos::rcp; + using Teuchos::TimeMonitor; + + // TUTORIALSPLIT =========================================================== + Teuchos::GlobalMPISession mpiSession(&argc, &argv, NULL); + Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); + + bool success = false; + RCP< const Teuchos::Comm > comm = Teuchos::DefaultComm::getComm(); + int MyPID = comm->getRank(); + int NumProc = comm->getSize(); + + const Teuchos::RCP epComm = Teuchos::rcp_const_cast(Xpetra::toEpetra(comm)); + + // TUTORIALSPLIT =========================================================== + // ================================ + // Convenient definitions + // ================================ + //SC zero = Teuchos::ScalarTraits::zero(); + SC one = Teuchos::ScalarTraits::one(); + + // Instead of checking each time for rank, create a rank 0 stream + Teuchos::FancyOStream& fancyout = *fancy; + fancyout.setOutputToRootOnly(0); + + + + // ================================ + // Parameters initialization + // ================================ + Teuchos::CommandLineProcessor clp(false); + GO nx = 100; clp.setOption("nx", &nx, "mesh size in x direction"); + GO ny = 100; clp.setOption("ny", &ny, "mesh size in y direction"); + int mgridSweeps = 1; clp.setOption("mgridSweeps", &mgridSweeps, "number of multigrid sweeps within Multigrid solver."); + std::string printTimings = "no"; clp.setOption("timings", &printTimings, "print timings to screen [yes/no]"); + double tol = 1e-12; clp.setOption("tol", &tol, "solver convergence tolerance"); + int importOldData = 0; clp.setOption("importOldData", &importOldData, "import map and matrix from previous run (highly experimental)."); + + std::string xmlFileName = "stratimikos_ParameterList.xml"; clp.setOption("xml", &xmlFileName, "read parameters from a file. Otherwise, this example uses by default 'stratimikos_ParameterList.xml'."); + + switch (clp.parse(argc,argv)) { + case Teuchos::CommandLineProcessor::PARSE_HELP_PRINTED: return EXIT_SUCCESS; break; + case Teuchos::CommandLineProcessor::PARSE_ERROR: + case Teuchos::CommandLineProcessor::PARSE_UNRECOGNIZED_OPTION: return EXIT_FAILURE; break; + case Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL: break; + } + + + + Teuchos::RCP paramList = Teuchos::getParametersFromXmlFile(xmlFileName); + // ================================ + // Problem construction + // ================================ + RCP globalTimeMonitor = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: S - Global Time"))), tm; + + comm->barrier(); + tm = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: 1 - Matrix Build"))); + + Teuchos::ParameterList GaleriList; + GaleriList.set("nx", nx); + GaleriList.set("ny", ny); + GaleriList.set("mx", epComm->NumProc()); + GaleriList.set("my", 1); + GaleriList.set("lx", 1.0); // length of x-axis + GaleriList.set("ly", 1.0); // length of y-axis + + Teuchos::RCP epMap = Teuchos::null; + Teuchos::RCP epCoord = Teuchos::null; + Teuchos::RCP epA = Teuchos::null; + + + // TUTORIALSPLIT =========================================================== + // create map + epMap = Teuchos::rcp(Galeri::CreateMap("Cartesian2D", *epComm, GaleriList)); + + // create coordinates + epCoord = Teuchos::rcp(Galeri::CreateCartesianCoordinates("2D", epMap.get(), GaleriList)); + + // create matrix + epA = Teuchos::rcp(Galeri::CreateCrsMatrix("Laplace2D", epMap.get(), GaleriList)); + + double hx = 1./(nx-1); double hy = 1./(ny-1); + epA->Scale(1./(hx*hy)); + + + // TUTORIALSPLIT =========================================================== + // Epetra -> Xpetra + Teuchos::RCP > exA = Teuchos::rcp(new Xpetra::EpetraCrsMatrixT(epA)); + Teuchos::RCP > exAWrap = Teuchos::rcp(new CrsMatrixWrap (exA)); + + RCP > A = Teuchos::rcp_dynamic_cast>(exAWrap); + A->SetFixedBlockSize(1); + + // TUTORIALSPLIT =========================================================== + // set rhs and solution vector + RCP B = Teuchos::rcp(new Epetra_Vector(*epMap)); + RCP X = Teuchos::rcp(new Epetra_Vector(*epMap)); + B->PutScalar(1.0); + X->PutScalar(0.0); + + // Epetra -> Xpetra + RCP > xB = Teuchos::rcp(new Xpetra::EpetraVectorT(B)); + RCP > xX = Teuchos::rcp(new Xpetra::EpetraVectorT(X)); + RCP > coords = Teuchos::rcp(new Xpetra::EpetraMultiVectorT(epCoord)); + + xX->setSeed(100); + xX->randomize(); + + // TUTORIALSPLIT =========================================================== + // build null space vector + RCP > map = A->getRowMap(); + + // TUTORIALSPLIT =========================================================== + comm->barrier(); + tm = Teuchos::null; + + fancyout << "========================================================\nGaleri complete.\n========================================================" << std::endl; + + // ================================ + // + // Build Thyra linear algebra objects + // + + RCP > thyraA = Xpetra::ThyraUtils::toThyra(exAWrap->getCrsMatrix()); + + RCP< Thyra::VectorBase >thyraX = Teuchos::rcp_const_cast >(Xpetra::ThyraUtils::toThyraVector(xX)); + RCP >thyraB = Xpetra::ThyraUtils::toThyraVector(xB); + + // + //Stratimikos + // + + + Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder; // This is the Stratimikos main class (= factory of solver factory). + Stratimikos::enableFROSchTwoLevel(linearSolverBuilder); + + comm->barrier(); + comm->barrier(); + comm->barrier(); + + fancyout <<"Stratimikos enable FROSCh\n"; + + // Register FROSCH TwoLevelPreconditioner as a Stratimikos preconditioner strategy. + linearSolverBuilder.setParameterList(paramList); // Setup solver parameters using a Stratimikos parameter list. + comm->barrier(); + comm->barrier(); + comm->barrier(); + + fancyout <<"Stratimikos Op\n"; + + // Build a new "solver factory" according to the previously specified parameter list. + RCP > solverFactory = Thyra::createLinearSolveStrategy(linearSolverBuilder); + comm->barrier(); + comm->barrier(); + comm->barrier(); + + fancyout <<"Solver Factory\n"; + + //Build Thyra operator corresponding to A^-1 computed using stratimikos + Teuchos::RCP > thyraInversA = Thyra::linearOpWithSolve(*solverFactory,thyraA); + comm->barrier(); + comm->barrier(); + comm->barrier(); + + fancyout <<"Thyra Op A-1\n"; + //Solve Ax = b + + Thyra::SolveStatus status = Thyra::solve(*thyraInversA,Thyra::NOTRANS,*thyraB,thyraX.ptr()); + comm->barrier(); + comm->barrier(); + comm->barrier(); + + fancyout <<"Status\n"; + + success = (status.solveStatus == Thyra::SOLVE_STATUS_CONVERGED); + + + MPI_Finalize(); + + return(success ? EXIT_SUCCESS:EXIT_FAILURE); +} + + diff --git a/packages/shylu/shylu_dd/frosch/test/Stratimikos/stratimikos_ParameterList.xml b/packages/shylu/shylu_dd/frosch/test/Stratimikos/stratimikos_ParameterList.xml new file mode 100644 index 000000000000..a8c6d5c54004 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/test/Stratimikos/stratimikos_ParameterList.xml @@ -0,0 +1,320 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 6d3e409a8990fd233cbf61c7da55d0a7f2c9b903 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Tue, 17 Jul 2018 17:10:16 +0200 Subject: [PATCH 03/20] Test Thyra Adapters-> still not working -> wrong Map --- .../shylu_dd/frosch/test/Stratimikos/main.cpp | 352 ++++++++---------- 1 file changed, 161 insertions(+), 191 deletions(-) diff --git a/packages/shylu/shylu_dd/frosch/test/Stratimikos/main.cpp b/packages/shylu/shylu_dd/frosch/test/Stratimikos/main.cpp index 594dab4ed037..55d9417d8fe0 100644 --- a/packages/shylu/shylu_dd/frosch/test/Stratimikos/main.cpp +++ b/packages/shylu/shylu_dd/frosch/test/Stratimikos/main.cpp @@ -1,14 +1,26 @@ -#include -// Teuchos includes -#include -#include -#include -#include -#include -// Epetra includes -#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include +#include + +#include +#include +#include +//#include + +#include +#include // Thyra includes #include @@ -25,221 +37,179 @@ // MueLu includes #include -// Galeri -#include -#include -#include -#include -// Galeri -#include -#include -#include - - - - -#include -#include -#include typedef unsigned UN; typedef double SC; typedef int LO; typedef int GO; -typedef KokkosClassic::DefaultNode::DefaultNodeType EpetraNode; +typedef Kokkos::Compat::KokkosSerialWrapperNode EpetraNode; // Hier Default verwenden??? typedef EpetraNode NO; - using namespace std; using namespace Teuchos; using namespace Xpetra; +using namespace FROSch; using namespace Belos; - int main(int argc, char *argv[]) { + MPI_Init(&argc,&argv); - using Teuchos::RCP; // reference count pointers - using Teuchos::rcp; - using Teuchos::TimeMonitor; - - // TUTORIALSPLIT =========================================================== - Teuchos::GlobalMPISession mpiSession(&argc, &argv, NULL); - Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); - - bool success = false; - RCP< const Teuchos::Comm > comm = Teuchos::DefaultComm::getComm(); - int MyPID = comm->getRank(); - int NumProc = comm->getSize(); + { + + Epetra_MpiComm CommWorld(MPI_COMM_WORLD); - const Teuchos::RCP epComm = Teuchos::rcp_const_cast(Xpetra::toEpetra(comm)); + CommandLineProcessor My_CLP; - // TUTORIALSPLIT =========================================================== - // ================================ - // Convenient definitions - // ================================ - //SC zero = Teuchos::ScalarTraits::zero(); - SC one = Teuchos::ScalarTraits::one(); + Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); - // Instead of checking each time for rank, create a rank 0 stream Teuchos::FancyOStream& fancyout = *fancy; fancyout.setOutputToRootOnly(0); - - - // ================================ - // Parameters initialization - // ================================ - Teuchos::CommandLineProcessor clp(false); - GO nx = 100; clp.setOption("nx", &nx, "mesh size in x direction"); - GO ny = 100; clp.setOption("ny", &ny, "mesh size in y direction"); - int mgridSweeps = 1; clp.setOption("mgridSweeps", &mgridSweeps, "number of multigrid sweeps within Multigrid solver."); - std::string printTimings = "no"; clp.setOption("timings", &printTimings, "print timings to screen [yes/no]"); - double tol = 1e-12; clp.setOption("tol", &tol, "solver convergence tolerance"); - int importOldData = 0; clp.setOption("importOldData", &importOldData, "import map and matrix from previous run (highly experimental)."); - - std::string xmlFileName = "stratimikos_ParameterList.xml"; clp.setOption("xml", &xmlFileName, "read parameters from a file. Otherwise, this example uses by default 'stratimikos_ParameterList.xml'."); - - switch (clp.parse(argc,argv)) { - case Teuchos::CommandLineProcessor::PARSE_HELP_PRINTED: return EXIT_SUCCESS; break; - case Teuchos::CommandLineProcessor::PARSE_ERROR: - case Teuchos::CommandLineProcessor::PARSE_UNRECOGNIZED_OPTION: return EXIT_FAILURE; break; - case Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL: break; + int M = 4; + My_CLP.setOption("M",&M,"H / h."); + int Dimension = 3; + My_CLP.setOption("DIM",&Dimension,"Dimension."); + int Overlap = 1; + My_CLP.setOption("OL",&Overlap,"Overlap."); + bool Reduced = false; + My_CLP.setOption("RGDSW","GDSW",&Reduced,"Using the reduced coarse space."); + + My_CLP.recogniseAllOptions(true); + My_CLP.throwExceptions(false); + CommandLineProcessor::EParseCommandLineReturn parseReturn = My_CLP.parse(argc,argv); + if(parseReturn == CommandLineProcessor::PARSE_HELP_PRINTED) { + MPI_Finalize(); + return 0; } + int N; + MPI_Comm COMM; + int color=1; + //bool onFirstLevelComm=false; + if (Dimension == 2) { + N = (int) (pow(CommWorld.NumProc(),1/2.) + 100*numeric_limits::epsilon()); // 1/H + if (CommWorld.MyPID()::epsilon()); // 1/H + if (CommWorld.MyPID() Comm(new Epetra_MpiComm(COMM)); - Teuchos::RCP paramList = Teuchos::getParametersFromXmlFile(xmlFileName); - // ================================ - // Problem construction - // ================================ - RCP globalTimeMonitor = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: S - Global Time"))), tm; - - comm->barrier(); - tm = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: 1 - Matrix Build"))); - - Teuchos::ParameterList GaleriList; - GaleriList.set("nx", nx); - GaleriList.set("ny", ny); - GaleriList.set("mx", epComm->NumProc()); - GaleriList.set("my", 1); - GaleriList.set("lx", 1.0); // length of x-axis - GaleriList.set("ly", 1.0); // length of y-axis - - Teuchos::RCP epMap = Teuchos::null; - Teuchos::RCP epCoord = Teuchos::null; - Teuchos::RCP epA = Teuchos::null; - - - // TUTORIALSPLIT =========================================================== - // create map - epMap = Teuchos::rcp(Galeri::CreateMap("Cartesian2D", *epComm, GaleriList)); + if (color==0) { - // create coordinates - epCoord = Teuchos::rcp(Galeri::CreateCartesianCoordinates("2D", epMap.get(), GaleriList)); + RCP parameterList; + if (!Reduced) { + parameterList = getParametersFromXmlFile("stratimikos_ParameterList.xml"); + } else { + parameterList = getParametersFromXmlFile("stratimikos_ParameterList.xml"); + } + /*if (Comm->MyPID()==0) { + cout << "--------------------------------------------------------------------------------\nPARAMETERS:" << endl; + parameterList->print(cout); + cout << "--------------------------------------------------------------------------------\n\n"; + }*/ - // create matrix - epA = Teuchos::rcp(Galeri::CreateCrsMatrix("Laplace2D", epMap.get(), GaleriList)); + if (Comm->MyPID()==0) cout << "ASSEMBLY..."; - double hx = 1./(nx-1); double hy = 1./(ny-1); - epA->Scale(1./(hx*hy)); - - - // TUTORIALSPLIT =========================================================== - // Epetra -> Xpetra - Teuchos::RCP > exA = Teuchos::rcp(new Xpetra::EpetraCrsMatrixT(epA)); - Teuchos::RCP > exAWrap = Teuchos::rcp(new CrsMatrixWrap (exA)); - - RCP > A = Teuchos::rcp_dynamic_cast>(exAWrap); - A->SetFixedBlockSize(1); - - // TUTORIALSPLIT =========================================================== - // set rhs and solution vector - RCP B = Teuchos::rcp(new Epetra_Vector(*epMap)); - RCP X = Teuchos::rcp(new Epetra_Vector(*epMap)); - B->PutScalar(1.0); - X->PutScalar(0.0); - - // Epetra -> Xpetra - RCP > xB = Teuchos::rcp(new Xpetra::EpetraVectorT(B)); - RCP > xX = Teuchos::rcp(new Xpetra::EpetraVectorT(X)); - RCP > coords = Teuchos::rcp(new Xpetra::EpetraMultiVectorT(epCoord)); - - xX->setSeed(100); - xX->randomize(); - - // TUTORIALSPLIT =========================================================== - // build null space vector - RCP > map = A->getRowMap(); - - // TUTORIALSPLIT =========================================================== - comm->barrier(); - tm = Teuchos::null; - - fancyout << "========================================================\nGaleri complete.\n========================================================" << std::endl; - - // ================================ - // - // Build Thyra linear algebra objects - // - - RCP > thyraA = Xpetra::ThyraUtils::toThyra(exAWrap->getCrsMatrix()); - - RCP< Thyra::VectorBase >thyraX = Teuchos::rcp_const_cast >(Xpetra::ThyraUtils::toThyraVector(xX)); - RCP >thyraB = Xpetra::ThyraUtils::toThyraVector(xB); - - // - //Stratimikos - // - - - Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder; // This is the Stratimikos main class (= factory of solver factory). - Stratimikos::enableFROSchTwoLevel(linearSolverBuilder); - - comm->barrier(); - comm->barrier(); - comm->barrier(); - - fancyout <<"Stratimikos enable FROSCh\n"; - - // Register FROSCH TwoLevelPreconditioner as a Stratimikos preconditioner strategy. - linearSolverBuilder.setParameterList(paramList); // Setup solver parameters using a Stratimikos parameter list. - comm->barrier(); - comm->barrier(); - comm->barrier(); - - fancyout <<"Stratimikos Op\n"; + ParameterList GalerList; + GalerList.set("nx", N*M); + GalerList.set("ny", N*M); + GalerList.set("nz", N*M); + GalerList.set("mx", N); + GalerList.set("my", N); + GalerList.set("mz", N); + + RCP UniqueMap; + RCP RepeatedMap; + RCP K; + + if (Dimension==2) { + UniqueMap.reset(Galeri::CreateMap("Cartesian2D", *Comm, GalerList)); + K.reset(Galeri::CreateCrsMatrix("Laplace2D", UniqueMap.get(), GalerList)); + } else if (Dimension==3) { + UniqueMap.reset(Galeri::CreateMap("Cartesian3D", *Comm, GalerList)); + K.reset(Galeri::CreateCrsMatrix("Laplace3D", UniqueMap.get(), GalerList)); + } + + EpetraCrsMatrixT xK(K); + RCP > xCrsMat = rcpFromRef(xK); + RCP > xMat = rcp(new CrsMatrixWrap(xCrsMat)); + xMat->describe(*fancy,Teuchos::VERB_EXTREME); + if (Comm->MyPID()==0) cout << "done" < solution(new Epetra_MultiVector(*UniqueMap,1)); + EpetraMultiVectorT eSolution(solution); + RCP > xSolution = rcpFromRef(eSolution); - // Build a new "solver factory" according to the previously specified parameter list. - RCP > solverFactory = Thyra::createLinearSolveStrategy(linearSolverBuilder); - comm->barrier(); - comm->barrier(); - comm->barrier(); + + + RCP rightHandSide(new Epetra_MultiVector(*UniqueMap,1)); + EpetraMultiVectorT eRightHandSide(rightHandSide); + RCP > xRightHandSide = rcpFromRef(eRightHandSide); + + xSolution->putScalar(0.0); + xRightHandSide->putScalar(1.0); + + RCP > map = xMat->getRowMap(); + Comm->Barrier(); + + fancyout<<"-------Create Null Space----------\n"; + + RCP > thyraA = Xpetra::ThyraUtils::toThyra(xCrsMat + ); + RCP >thyraX = Teuchos::rcp_const_cast >(Xpetra::ThyraUtils::toThyraMultiVector(xSolution)); + RCP >thyraB = Xpetra::ThyraUtils::toThyraMultiVector(xRightHandSide); + + Comm->Barrier(); + + fancyout<<"-------To Thyra----------\n"; + //Stratimikos + Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder; // This is the Stratimikos main class (= factory of solver factory). + Stratimikos::enableFROSchTwoLevel(linearSolverBuilder); + + Comm->Barrier(); + + fancyout<<"-------Stratimikos enable FROSch----------\n"; + + linearSolverBuilder.setParameterList(parameterList); + + + RCP > solverFactory = Thyra::createLinearSolveStrategy(linearSolverBuilder); + + Comm->Barrier(); + + fancyout<<"-------Thyra_LinearOpWithSolveFactory----------\n"; - fancyout <<"Solver Factory\n"; + Teuchos::RCP > thyraInversA = Thyra::linearOpWithSolve(*solverFactory,thyraA); + + Comm->Barrier(); + + fancyout<<"-------Thyra Invers----------\n"; + Thyra::SolveStatus status = Thyra::solve(*thyraInversA,Thyra::NOTRANS,*thyraB,thyraX.ptr()); + Comm->Barrier(); + + fancyout <<"Status\n"; + bool success = false; - //Build Thyra operator corresponding to A^-1 computed using stratimikos - Teuchos::RCP > thyraInversA = Thyra::linearOpWithSolve(*solverFactory,thyraA); - comm->barrier(); - comm->barrier(); - comm->barrier(); + success = (status.solveStatus == Thyra::SOLVE_STATUS_CONVERGED); + - fancyout <<"Thyra Op A-1\n"; - //Solve Ax = b - - Thyra::SolveStatus status = Thyra::solve(*thyraInversA,Thyra::NOTRANS,*thyraB,thyraX.ptr()); - comm->barrier(); - comm->barrier(); - comm->barrier(); - - fancyout <<"Status\n"; + } + MPI_Comm_free(&COMM); + + } - success = (status.solveStatus == Thyra::SOLVE_STATUS_CONVERGED); - - MPI_Finalize(); - - return(success ? EXIT_SUCCESS:EXIT_FAILURE); + + return(EXIT_SUCCESS); } - From f1a054b3a39409fca635012e5e349b16ff0d64a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Tue, 14 Aug 2018 06:45:28 +0200 Subject: [PATCH 04/20] Thyra -> New start --- .../shylu/shylu_dd/frosch/src/CMakeLists.txt | 14 ++ .../adapters/FROSch_PreconFactory_decl.hpp | 103 ++++++++++ .../src/adapters/FROSch_PreconFactory_def.hpp | 194 ++++++++++++++++++ .../src/adapters/Stratimikos_FROSchHelp.hpp | 30 +++ .../shylu/shylu_dd/frosch/test/CMakeLists.txt | 1 - 5 files changed, 341 insertions(+), 1 deletion(-) create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_decl.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_def.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelp.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt index 918ed0721025..3d62c6569f50 100644 --- a/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt @@ -35,6 +35,8 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/InterfaceSets) INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/SchwarzOperators) INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/SchwarzPreconditioners) INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/Tools) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/adapters) + APPEND_SET(HEADERS @@ -102,12 +104,24 @@ APPEND_SET(HEADERS Tools/FROSch_SubdomainSolver_def.hpp Tools/FROSch_Tools_decl.hpp Tools/FROSch_Tools_def.hpp + adapters/FROSch_PreconFactory_decl.hpp + adapters/FROSch_PreconFactory_def.hpp + adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp + adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp + adapters/Stratimikos_FROSchHelp.hpp + adapters/Stratimikos_FROSchHelpers.hpp + + + + + ) # Set sources APPEND_SET(SOURCES dummy.cpp + adapters/Stratimikos_FROSchHelpers.cpp ) TRIBITS_ADD_LIBRARY( diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_decl.hpp new file mode 100644 index 000000000000..a2a4e5318c33 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_decl.hpp @@ -0,0 +1,103 @@ +#ifndef FROSCH_PRECONFACTORY_HPP +#define FROSCH_PRECONFACTORY_HPP + +#include "Thyra_DefaultPreconditioner.hpp" +#include "Thyra_BlockedLinearOpBase.hpp" +#include "Thyra_XpetraLinearOp.hpp" + + +#include "Thyra_EpetraLinearOp.hpp" +#include "Thyra_TpetraLinearOp.hpp" +#include "Thyra_TpetraThyraWrappers.hpp" + +#include "Teuchos_Ptr.hpp" +#include "Teuchos_TestForException.hpp" +#include "Teuchos_Assert.hpp" +#include "Teuchos_Time.hpp" + +#include +#include +#include +#include + +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_RCP.hpp" +#include "Teuchos_ArrayRCP.hpp" +#include "Teuchos_Array.hpp" + +#include +#include +#include +#include +#include + +#include +#include +#include + + +//#include +#include +#include + +#include +#include +// + +#include "Thyra_PreconditionerFactoryBase.hpp" + +#include "Kokkos_DefaultNode.hpp" + +namespace Thyra { + template + class FROSch_PreconFactory : public PreconditionerFactoryBase { + + public: + FROSch_PreconFactory(); + //Overwritten form PreconditionerFactoryBase + bool isCompatible(const LinearOpSourceBase& fwdOp) const; + + Teuchos::RCP > createPrec() const; + + void initializePrec(const Teuchos::RCP >& fwdOp, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const; + + void uninitializePrec(PreconditionerBase* prec, + Teuchos::RCP >* fwdOp, + ESupportSolveUse* supportSolveUse + ) const; + void setParameterList(const Teuchos::RCP& paramList); + /** \brief . */ + Teuchos::RCP unsetParameterList(); + /** \brief . */ + Teuchos::RCP getNonconstParameterList(); + /** \brief . */ + Teuchos::RCP getParameterList() const; + /** \brief . */ + Teuchos::RCP getValidParameters() const; + //@} + + /** \name Public functions overridden from Describable. */ + //@{ + + /** \brief . */ + std::string description() const; + + // ToDo: Add an override of describe(...) to give more detail! + + //@} + + private: + + Teuchos::RCP paramList_; + + }; +} +#endif + + + + + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_def.hpp new file mode 100644 index 000000000000..32c95cc1c9ff --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_def.hpp @@ -0,0 +1,194 @@ +#include + + +//#include +#include +#include + +#include +#include +// + +#include "FROSch_PreconFactory_decl.hpp" + +#include "Kokkos_DefaultNode.hpp" + +namespace Thyra { + using Teuchos::RCP; + using Teuchos::rcp; + using Teuchos::ParameterList; + + //Constructor---------------- + template + FROSch_PreconFactory::FROSch_PreconFactory() + { + paramList_ = rcp(new Teuchos::ParameterList()); + } + //---------------------------- + + //----------------------------------------------------------- + template + bool FROSch_PreconFactory::isCompatible(const LinearOpSourceBase& fwdOpSrc) const + { + std::cout<<"Only Epetra works fine->Insert CHECK\n"; + return true; + } + //----------------------------------------------------------- + + //-------------------------------------------------------------- + template + RCP >FROSch_PreconFactory::createPrec() const + { + return Teuchos::rcp(new DefaultPreconditioner); + + } + //------------------------------------------------------------- + + //------------------------------------------------------------- + template + void FROSch_PreconFactory::initializePrec + (const Teuchos::RCP >& fwdOpSrc, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const{ + + Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); + + + using Teuchos::rcp_dynamic_cast; + //Some Typedefs + typedef Xpetra::Map XpMap; + typedef Xpetra::Operator XpOp; + typedef Xpetra::ThyraUtils XpThyUtils; + typedef Xpetra::CrsMatrix XpCrsMat; + typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; + typedef Xpetra::Matrix XpMat; + typedef Xpetra::MultiVector XpMultVec; + typedef Xpetra::MultiVector XpMultVecDouble; + typedef Thyra::LinearOpBase ThyLinOpBase; + + TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); + TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); + TEUCHOS_ASSERT(prec); + + // Create a copy, as we may remove some things from the list + ParameterList paramList = *paramList_; + + // Retrieve wrapped concrete Xpetra matrix from FwdOp + const RCP fwdOp = fwdOpSrc->getOp(); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); + + //Check fpr Epetra + bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); + + RCP > K = Teuchos::null; + + RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); + + // FROSCH needs a non-const object as input + RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); + + K = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); + + // Retrieve concrete preconditioner object + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + // extract preconditioner operator + RCP thyra_precOp = Teuchos::null; + thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); + + if (bIsEpetra){ + std::cout<<"Korrekt\n"; + } + else{ + std::cout<<"Did not use Epetra this might cause problem\n"; + } + + + + + } + //------------------------------------------------------------- + + //------------------------------------------------------------- + template + void FROSch_PreconFactory:: + uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { + TEUCHOS_ASSERT(prec); + + // Retrieve concrete preconditioner object + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + if (fwdOp) { + // TODO: Implement properly instead of returning default value + *fwdOp = Teuchos::null; + } + + if (supportSolveUse) { + // TODO: Implement properly instead of returning default value + *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; + } + + defaultPrec->uninitialize(); + } + //------------------------------------------------------------- + + //------------------------------------------------------------- + template + void FROSch_PreconFactory::setParameterList(RCP const & paramList){ + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); + paramList_ = paramList; + } + //------------------------------------------------------------- + + //------------------------------------------------------------------ + template + RCP FROSch_PreconFactory::getNonconstParameterList(){ + return paramList_; + } + + //----------------------------------------------------------------------- + + + //----------------------------------------------------------------------- + template + RCP + FROSch_PreconFactory::getParameterList() const { + return paramList_; + } + //-------------------------------------------------------------------- + + //-------------------------------------------------------------------- + template + RCP FROSch_PreconFactory::getValidParameters() const { + static RCP validPL; + + if (Teuchos::is_null(validPL)) + validPL = rcp(new ParameterList()); + + return validPL; + } + //----------------------------------------------------------------------- + + //----------------------------------------------------------------------- + template + std::string FROSch_PreconFactory::description() const { + return "Thyra::FROSch_TwoLevelPreconditionerFactory"; + } + //-------------------------------------------------------------------------- + + //-------------------------------------------------------------------------- + template + RCP FROSch_PreconFactory::unsetParameterList(){ + RCP savedParamList = paramList_; + paramList_ = Teuchos::null; + return savedParamList; + + } + + +} diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelp.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelp.hpp new file mode 100644 index 000000000000..0e53a0a6d65e --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelp.hpp @@ -0,0 +1,30 @@ +#include "Stratimikos_DefaultLinearSolverBuilder.hpp" + +#include "FROSch_PreconFactory.hpp" + + +#include "Teuchos_RCP.hpp" +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_TestForException.hpp" +#include "Teuchos_AbstractFactoryStd.hpp" + +#include +#include "Kokkos_DefaultNode.hpp" + + +namespace Stratimikos { + + template + void enableFROSch(DefaultLinearSolverBuilder& builder, const std::string& stratName = "FROSch"){ + const Teuchos::RCP precValidParams = Teuchos::sublist(builder.getValidParameters(), "Preconditioner Types"); + + TEUCHOS_TEST_FOR_EXCEPTION(precValidParams->isParameter(stratName), std::logic_error, + "Stratimikos::enableFROSch cannot add \"" + stratName +"\" because it is already included in builder!"); + + typedef Thyra::PreconditionerFactoryBase Base; + typedef Thyra::FROSch_PreconFactory Impl; + + builder.setPreconditioningStrategyFactory(Teuchos::abstractFactoryStd(), stratName); + } + +} diff --git a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt index 99f221dfc932..53d514d04631 100644 --- a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt @@ -7,5 +7,4 @@ ADD_SUBDIRECTORIES( LocalPartitionOfUnityBasis InterfacePartitionOfUnity TwoLevelPreconditionerInputFiles - Stratimikos ) From 5f28b8e97143166f2e6f3c78d20d485bea0752a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Tue, 14 Aug 2018 08:09:14 +0200 Subject: [PATCH 05/20] Thyra_FROSch_Epetra --- .../shylu/shylu_dd/frosch/src/CMakeLists.txt | 8 +- .../src/adapters/FROSch_EpetraOp_decl.hpp | 171 ++++++++++ .../src/adapters/FROSch_EpetraOp_def.hpp | 96 ++++++ .../Thyra_FROSchEpetraPreconFactory_decl.hpp | 310 ++++++++++++++++++ .../Thyra_FROSchEpetraPreconFactory_def.hpp | 229 +++++++++++++ .../src/adapters/stratimikos_froschEpetra.hpp | 35 ++ 6 files changed, 846 insertions(+), 3 deletions(-) create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt index 3d62c6569f50..a1d62b3e2758 100644 --- a/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt @@ -110,9 +110,11 @@ APPEND_SET(HEADERS adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp adapters/Stratimikos_FROSchHelp.hpp adapters/Stratimikos_FROSchHelpers.hpp - - - + adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp + adapters/Thyra_FROSchEpetraPreconFactory_def.hpp + adapters/stratimikos_froschEpetra.hpp + adapters/FROSch_EpetraOp_decl.hpp + adapters/FROSch_EpetraOp_def.hpp ) diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp new file mode 100644 index 000000000000..17c012599ef1 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp @@ -0,0 +1,171 @@ +// @HEADER +// +// *********************************************************************** +// +// MueLu: A package for multigrid based preconditioning +// Copyright 2012 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact +// Jonathan Hu (jhu@sandia.gov) +// Andrey Prokopenko (aprokop@sandia.gov) +// Ray Tuminaro (rstumin@sandia.gov) +// +// *********************************************************************** +// +// @HEADER +#ifndef FROSch_EPETRAOPERATOR_DECL_HPP +#define FROSch_EPETRAOPERATOR_DECL_HPP + +//! @file + +#include +#include "FROSch_TwoLevelPreconditioner_def.hpp" +//TODO: Kokkos headers + + +namespace FROSch { + + using namespace Teuchos; + + + /*! @class EpetraOperator + @brief Turns a MueLu::Hierarchy into a Epetra_Operator. + It allows MueLu to be used as a preconditioner for AztecOO (for instance). + */ + class FROSch_EpetraOperator : public Epetra_Operator { + typedef double SC; + typedef int LO; + typedef int GO; + typedef Xpetra::EpetraNode NO; + + typedef Xpetra::Matrix Matrix; + typedef FROSch::TwoLevelPreconditioner TwoLevelPrec; + + + + + public: + + //! @name Constructor/Destructor + //@{ + + //! Constructor + FROSch_EpetraOperator(const RCP& T) : TwoLevelPrec_(T) { } + + //! Destructor. + virtual ~FROSch_EpetraOperator() { } + + //@} + + int SetUseTranspose(bool UseTransposeBool) { return -1; } + + //! @name Mathematical functions + //@{ + + //! Returns the result of a Epetra_Operator applied to a Epetra_MultiVector X in Y. + /*! + \param Int + X - A Epetra_MultiVector of dimension NumVectors to multiply with matrix. + \param Out + Y -A Epetra_MultiVector of dimension NumVectors containing result. + + \return Integer error code, set to 0 if successful. + */ + int Apply(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const { return -1; } + + //! Returns the result of a Epetra_Operator inverse applied to an Epetra_MultiVector X in Y. + /*! + \param In + X - A Epetra_MultiVector of dimension NumVectors to solve for. + \param Out + Y -A Epetra_MultiVector of dimension NumVectors containing result. + + \return Integer error code, set to 0 if successful. + + \warning In order to work with AztecOO, any implementation of this method must + support the case where X and Y are the same object. + */ + int ApplyInverse(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const; + + //! Returns the infinity norm of the global matrix. + /* Returns the quantity \f$ \| A \|_\infty\f$ such that + \f[\| A \|_\infty = \max_{1\lei\lem} \sum_{j=1}^n |a_{ij}| \f]. + + \warning This method must not be called unless HasNormInf() returns true. + */ + double NormInf() const { return 0; } + //@} + + //! @name Attribute access functions + //@{ + + //! Returns a character string describing the operator + const char * Label() const { return "FROSch::TwoLevelPrec"; } + + //! Returns the current UseTranspose setting. + bool UseTranspose() const { return false; } + + //! Returns true if the \e this object can provide an approximate Inf-norm, false otherwise. + bool HasNormInf() const { return 0; } + + //! Returns a pointer to the Epetra_Comm communicator associated with this operator. + const Epetra_Comm & Comm() const; + + //! Returns the Epetra_Map object associated with the domain of this operator. + const Epetra_Map & OperatorDomainMap() const; + + //! Returns the Epetra_Map object associated with the range of this operator. + const Epetra_Map & OperatorRangeMap() const; + + //@} + + //! @name MueLu specific + //@{ + + //! Direct access to the underlying MueLu::Hierarchy. + RCP GetTwoLevelPrec() const { return TwoLevelPrec_; } + + //@} + + + private: + + RCP TwoLevelPrec_; + + }; + +} // namespace + + +#endif // MUELU_EPETRAOPERATOR_HPP + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp new file mode 100644 index 000000000000..d9c35b191c9a --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp @@ -0,0 +1,96 @@ +#ifndef FROSch_EPETRAOPERATOR_DEF_HPP +#define FROSch_EPETRAOPERATOR_DEF_HPP + +#include +#include +#include +#include + +#include "FROSch_EpetraOp_decl.hpp" + +namespace FROSch { + int FROSch_EpetraOperator::ApplyInverse(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const { + try { + // There is no rcpFromRef(const T&), so we need to do const_cast + const Xpetra::EpetraMultiVectorT eX(rcpFromRef(const_cast(X))); + const RCP > xX= rcpFromRef(const_cast&> (eX)); + + Xpetra::EpetraMultiVectorT eY(rcpFromRef(Y)); + RCP > xY = rcpFromRef(eY); + // Generally, we assume two different vectors, but AztecOO uses a single vector + if (X.Values() == Y.Values()) { + // X and Y point to the same memory, use an additional vector + RCP > tmpY = Teuchos::rcp(new Xpetra::EpetraMultiVectorT(eY.getMap(), eY.getNumVectors())); + + RCP > xtmpY = tmpY; + // InitialGuessIsZero in MueLu::Hierarchy.Iterate() does not zero out components, it + // only assumes that user provided an already zeroed out vector + bool usePreconOnly = true; + tmpY->putScalar(0.0); + // apply one V-cycle as preconditioner + TwoLevelPrec_->apply(*xX, *xtmpY,NO_TRANS,Teuchos::ScalarTraits::one(),Teuchos::ScalarTraits::zero()); + // deep copy solution from MueLu + xY->update(1.0, *xtmpY, 0.0); + } else { + // X and Y point to different memory, pass the vectors through + bool usePreconOnly = true; + xY->putScalar(0.0); + TwoLevelPrec_->apply(*xX, *xY,NO_TRANS,Teuchos::ScalarTraits::one(),Teuchos::ScalarTraits::zero()); + + } + + } catch (std::exception& e) { + //TODO: error msg directly on std::cerr? + std::cerr << "Caught an exception in MueLu::EpetraOperator::ApplyInverse():" << std::endl + << e.what() << std::endl; + return -1; + } + return 0; + } + + const Epetra_Comm& FROSch_EpetraOperator::Comm() const { + RCP A = TwoLevelPrec_->getCrsMatrix(); + + RCP > crsOp = rcp_dynamic_cast >(A); + if (crsOp == Teuchos::null) + std::cerr<<"Caution Bad Cast!\n"; + const RCP> &tmp_ECrsMtx = rcp_dynamic_cast>(crsOp->getCrsMatrix()); + if (tmp_ECrsMtx == Teuchos::null) + std::cerr<<"Caution Bad Cast!\n"; + return tmp_ECrsMtx->getEpetra_CrsMatrixNonConst()->Comm(); + /*} + + RCP> tmp_ECrsMtx = rcp_dynamic_cast >(A); + RCP epA = tmp_ECrsMtx->getEpetra_CrsMatrixNonConst(); + return epA->Comm();*/ + } + + const Epetra_Map& FROSch_EpetraOperator::OperatorDomainMap() const { + RCP A = TwoLevelPrec_->getCrsMatrix(); + + RCP > crsOp = rcp_dynamic_cast >(A); + if (crsOp == Teuchos::null) + std::cerr<<"Caution Bad Cast!\n"; + const RCP> &tmp_ECrsMtx = rcp_dynamic_cast>(crsOp->getCrsMatrix()); + if (tmp_ECrsMtx == Teuchos::null) + std::cerr<<"Caution Bad Cast!\n"; + return tmp_ECrsMtx->getEpetra_CrsMatrixNonConst()->DomainMap(); + } + + + const Epetra_Map & FROSch_EpetraOperator::OperatorRangeMap() const { + RCP A = TwoLevelPrec_->getCrsMatrix(); + + + RCP > crsOp = rcp_dynamic_cast >(A); + if (crsOp == Teuchos::null) + std::cerr<<"Caution Bad Cast!\n"; + const RCP &tmp_ECrsMtx = rcp_dynamic_cast(crsOp->getCrsMatrix()); + if (tmp_ECrsMtx == Teuchos::null) + std::cerr<<"Caution Bad Cast!\n"; + return tmp_ECrsMtx->getEpetra_CrsMatrixNonConst()->RangeMap(); + } + + +} +#endif diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp new file mode 100644 index 000000000000..a71a82ab4c86 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp @@ -0,0 +1,310 @@ + +#ifndef THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DECL_HPP +#define THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DECL_HPP + + +// Stratimikos needs Thyra, so we don't need special guards for Thyra here +#include "Thyra_DefaultPreconditioner.hpp" +#include "Thyra_BlockedLinearOpBase.hpp" +#include "Thyra_XpetraLinearOp.hpp" + +#include "Teuchos_Ptr.hpp" +#include "Teuchos_TestForException.hpp" +#include "Teuchos_Assert.hpp" +#include "Teuchos_Time.hpp" + +#include +#include +#include +#include +//PUT FROSch includes here + +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_RCP.hpp" +#include "Teuchos_ArrayRCP.hpp" +#include "Teuchos_Array.hpp" + +#include +#include +#include +#include +#include + +#include +#include +#include + + +//#include +#include +#include +#includ "FROSch_EpetraOp_def.hpp" +#include +// + +#include "Thyra_PreconditionerFactoryBase.hpp" + +#include "Kokkos_DefaultNode.hpp" + +namespace Thyra { + + template + class FROSch_EpetraPreconFactory:public Thyra::PreconditionerFactoryBase{ + public: + + //Constructor + FROSch_EpetraPreconFactory(); + + //Overridden from PreconditionerFactory Base + bool isCompatible(const LinearOpSourceBase& fwdOp) const; + + Teuchos::RCP > createPrec() const; + + void initializePrec(const Teuchos::RCP >& fwdOpSrc, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const; + + void uninitializePrec(PreconditionerBase* prec, + Teuchos::RCP >* fwdOp, + ESupportSolveUse* supportSolveUse + ) const; + + void setParameterList(const Teuchos::RCP& paramList); + + Teuchos::RCP unsetParameterList(); + + Teuchos::RCP getNonconstParameterList(); + + Teuchos::RCP getParameterList() const; + + Teuchos::RCP getValidParameters() const; + + std::string description() const; + private: + Teuchos::RCP paramList_; + + + + }; + + using Teuchos::RCP; + using Teuchos::rcp; + using Teuchos::ParameterList; + + //Constructor + template + FROSch_EpetraPreconFactory::FROSch_EpetraPreconFactory() + { + paramList_ = rcp(new Teuchos::ParameterList()); + } + //----------------------------------------------------------- + template + bool FROSch_EpetraPreconFactory::isCompatible(const LinearOpSourceBase& fwdOpSrc) const + { + const RCP > fwdOp = fwdOpSrc.getOp(); + //so far only Epetra is allowed + if (Xpetra::ThyraUtils::isEpetra(fwdOp)) return true; + + return false; + } + //-------------------------------------------------------------- + template + RCP >FROSch_EpetraPreconFactory::createPrec() const{ + return Teuchos::rcp(new DefaultPreconditioner); + + } + //------------------------------------------------------------- + template + void FROSch_EpetraPreconFactory::initializePrec + (const Teuchos::RCP >& fwdOpSrc, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const{ + + Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); + + + using Teuchos::rcp_dynamic_cast; + //Some Typedefs + typedef Xpetra::Map XpMap; + typedef Xpetra::Operator XpOp; + typedef Xpetra::ThyraUtils XpThyUtils; + typedef Xpetra::CrsMatrix XpCrsMat; + typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; + typedef Xpetra::Matrix XpMat; + typedef Xpetra::MultiVector XpMultVec; + typedef Xpetra::MultiVector XpMultVecDouble; + typedef Thyra::LinearOpBase ThyLinOpBase; + + + + + //PreCheck + TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); + //TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); + TEUCHOS_ASSERT(prec); + + // Create a copy, as we may remove some things from the list + ParameterList paramList = *paramList_; + + // Retrieve wrapped concrete Xpetra matrix from FwdOp + const RCP fwdOp = fwdOpSrc->getOp(); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); + + // Check whether it is Epetra/Tpetra + bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); + bool bIsTpetra = XpThyUtils::isTpetra(fwdOp); + bool bIsBlocked = XpThyUtils::isBlockedOperator(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == true && bIsTpetra == true)); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == bIsTpetra) && bIsBlocked == false); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); + + RCP A = Teuchos::null; + RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); + + // FROSCH needs a non-const object as input + RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); + + // wrap the forward operator as an Xpetra::Matrix that FROSch can work with + A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); + //A->describe(*fancy,Teuchos::VERB_EXTREME); + + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); + + // Retrieve concrete preconditioner object--->Here Mem Leak? + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + // extract preconditioner operator + RCP thyra_precOp = Teuchos::null; + thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); + + //Later needs to be a utility ExtractCoordinatesFromParameterList + //not implemented yet + // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); + + //-------Build New Two Level Prec-------------- + const RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); + + RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); + //Initialize-> Only Works for laplce (cause defaults are used) and compute + TwoLevelPrec->initialize(); + TwoLevelPrec->compute(); + //----------------------------------------------- + + + //Prepare for FROSch Epetra Op------------------- + RCP epetraTwoLevel = rcp_dynamic_cast(TwoLevelPrec); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(epetraTwoLevel)); + RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(frosch_epetraop)); + + //attach to fwdOp + set_extra_data(fwdOp,"IFPF::fwdOp", Teuchos::inOutArg(frosch_epetraop), Teuchos::POST_DESTROY,false); + + RCP thyra_epetraOp = Thyra::nonconstEpetraLinearOp(frosch_epetraop, NOTRANS, EPETRA_OP_APPLY_APPLY_INVERSE, EPETRA_OP_ADJOINT_UNSUPPORTED); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyra_epetraOp)); + + + + + + + + //Wrap tp thyra + RCP thyraPrecOp = Teuchos::null; + Comm->barrier(); Comm->barrier(); Comm->barrier(); + std::cout<<"Compute Two Level Prec\n"; + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); + + thyraPrecOp = rcp_dynamic_cast(thyra_epetraOp); + + Comm->barrier(); + Comm->barrier(); + Comm->barrier(); + + std::cout<<"Test for null pointer\n"; + + + defaultPrec->initializeUnspecified(thyraPrecOp); + Comm->barrier(); + Comm->barrier(); + Comm->barrier(); + std::cout<<"Thyra OP\n"; + + } + //------------------------------------------------------------- + template + void FROSch_EpetraPreconFactory:: + uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { + TEUCHOS_ASSERT(prec); + + // Retrieve concrete preconditioner object + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + if (fwdOp) { + // TODO: Implement properly instead of returning default value + *fwdOp = Teuchos::null; + } + + if (supportSolveUse) { + // TODO: Implement properly instead of returning default value + *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; + } + + defaultPrec->uninitialize(); + } + //----------------------------------------------------------------- + template + void FROSch_EpetraPreconFactory::setParameterList(RCP const & paramList){ + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); + paramList_ = paramList; + } + + //------------------------------------------------------------------ + template + RCP FROSch_TwoLevelPreconditionerFactory::getNonconstParameterList(){ + return paramList_; + } + + //----------------------------------------------------------------------- + template + RCP + FROSch_EpetraPreconFactory::getParameterList() const { + return paramList_; + } + //-------------------------------------------------------------------- + template + RCP FROSch_EpetraPreconFactory::getValidParameters() const { + static RCP validPL; + + if (Teuchos::is_null(validPL)) + validPL = rcp(new ParameterList()); + + return validPL; + } + //----------------------------------------------------------------------- + template + std::string FROSch_EpetraPreconFactory::description() const { + return "Thyra::FROSch_TwoLevelPreconditionerFactory"; + } + //-------------------------------------------------------------------------- + template + RCP FROSch_EpetraPreconFactory::unsetParameterList(){ + RCP savedParamList = paramList_; + paramList_ = Teuchos::null; + return savedParamList; + + } + +} + +#endif + + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp new file mode 100644 index 000000000000..f97c7e93e04f --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp @@ -0,0 +1,229 @@ +#ifndef THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DEF_HPP +#define THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DEF_HPP + +#include "Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp" + + +#include +#include "Thyra_FROSchEpetraPreconFactory_decl.hpp" + +namespace Thyra { + using Teuchos::RCP; + using Teuchos::rcp; + using Teuchos::ParameterList; + + //Constructor + template +FROSch_EpetraPreconFactory::FROSch_EpetraPreconFactory() + { + paramList_ = rcp(new Teuchos::ParameterList()); + } + //----------------------------------------------------------- + template + bool FROSch_EpetraPreconFactory::isCompatible(const LinearOpSourceBase& fwdOpSrc) const + { + const RCP > fwdOp = fwdOpSrc.getOp(); + //so far only Epetra is allowed + if (Xpetra::ThyraUtils::isEpetra(fwdOp)) return true; + + return false; + } + //-------------------------------------------------------------- + template + RCP >FROSch_EpetraPreconFactory::createPrec() const{ + return Teuchos::rcp(new DefaultPreconditioner); + + } + //------------------------------------------------------------- + template + void FROSch_EpetraPreconFactory::initializePrec + (const Teuchos::RCP >& fwdOpSrc, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const{ + + Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); + + + using Teuchos::rcp_dynamic_cast; + //Some Typedefs + typedef Xpetra::Map XpMap; + typedef Xpetra::Operator XpOp; + typedef Xpetra::ThyraUtils XpThyUtils; + typedef Xpetra::CrsMatrix XpCrsMat; + typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; + typedef Xpetra::Matrix XpMat; + typedef Xpetra::MultiVector XpMultVec; + typedef Xpetra::MultiVector XpMultVecDouble; + typedef Thyra::LinearOpBase ThyLinOpBase; + + + + + //PreCheck + TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); + //TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); + TEUCHOS_ASSERT(prec); + + // Create a copy, as we may remove some things from the list + ParameterList paramList = *paramList_; + + // Retrieve wrapped concrete Xpetra matrix from FwdOp + const RCP fwdOp = fwdOpSrc->getOp(); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); + + // Check whether it is Epetra/Tpetra + bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); + bool bIsTpetra = XpThyUtils::isTpetra(fwdOp); + bool bIsBlocked = XpThyUtils::isBlockedOperator(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == true && bIsTpetra == true)); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == bIsTpetra) && bIsBlocked == false); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); + + RCP A = Teuchos::null; + RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); + + // FROSCH needs a non-const object as input + RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); + + // wrap the forward operator as an Xpetra::Matrix that FROSch can work with + A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); + //A->describe(*fancy,Teuchos::VERB_EXTREME); + + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); + + // Retrieve concrete preconditioner object--->Here Mem Leak? + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + // extract preconditioner operator + RCP thyra_precOp = Teuchos::null; + thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); + + //Later needs to be a utility ExtractCoordinatesFromParameterList + //not implemented yet + // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); + + //-------Build New Two Level Prec-------------- + const RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); + + RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); + //Initialize-> Only Works for laplce (cause defaults are used) and compute + TwoLevelPrec->initialize(); + TwoLevelPrec->compute(); + //----------------------------------------------- + + + //Prepare for FROSch Epetra Op------------------- + RCP epetraTwoLevel = rcp_dynamic_cast(TwoLevelPrec); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(epetraTwoLevel)); + RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(frosch_epetraop)); + + //attach to fwdOp + set_extra_data(fwdOp,"IFPF::fwdOp", Teuchos::inOutArg(frosch_epetraop), Teuchos::POST_DESTROY,false); + + RCP thyra_epetraOp = Thyra::nonconstEpetraLinearOp(frosch_epetraop, NOTRANS, EPETRA_OP_APPLY_APPLY_INVERSE, EPETRA_OP_ADJOINT_UNSUPPORTED); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyra_epetraOp)); + + + + + + + + //Wrap tp thyra + RCP thyraPrecOp = Teuchos::null; + Comm->barrier(); Comm->barrier(); Comm->barrier(); + std::cout<<"Compute Two Level Prec\n"; + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); + + thyraPrecOp = rcp_dynamic_cast(thyra_epetraOp); + + Comm->barrier(); + Comm->barrier(); + Comm->barrier(); + + std::cout<<"Test for null pointer\n"; + + + defaultPrec->initializeUnspecified(thyraPrecOp); + Comm->barrier(); + Comm->barrier(); + Comm->barrier(); + std::cout<<"Thyra OP\n"; + + } + //------------------------------------------------------------- + template + void FROSch_EpetraPreconFactory:: + uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { + TEUCHOS_ASSERT(prec); + + // Retrieve concrete preconditioner object + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + if (fwdOp) { + // TODO: Implement properly instead of returning default value + *fwdOp = Teuchos::null; + } + + if (supportSolveUse) { + // TODO: Implement properly instead of returning default value + *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; + } + + defaultPrec->uninitialize(); + } + //----------------------------------------------------------------- + template + void FROSch_EpetraPreconFactory::setParameterList(RCP const & paramList){ + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); + paramList_ = paramList; + } + + //------------------------------------------------------------------ + template + RCP FROSch_TwoLevelPreconditionerFactory::getNonconstParameterList(){ + return paramList_; + } + + //----------------------------------------------------------------------- + template + RCP + FROSch_EpetraPreconFactory::getParameterList() const { + return paramList_; + } + //-------------------------------------------------------------------- + template + RCP FROSch_EpetraPreconFactory::getValidParameters() const { + static RCP validPL; + + if (Teuchos::is_null(validPL)) + validPL = rcp(new ParameterList()); + + return validPL; + } + //----------------------------------------------------------------------- + template + std::string FROSch_EpetraPreconFactory::description() const { + return "Thyra::FROSch_TwoLevelPreconditionerFactory"; + } + //-------------------------------------------------------------------------- + template + RCP FROSch_EpetraPreconFactory::unsetParameterList(){ + RCP savedParamList = paramList_; + paramList_ = Teuchos::null; + return savedParamList; + + } + +} +#endif + + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp new file mode 100644 index 000000000000..3b0b68310f97 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp @@ -0,0 +1,35 @@ + + +#include "Stratimikos_DefaultLinearSolverBuilder.hpp" + + + +#include "Thyra_FROSchEpetraPreconFactory_decl.hpp" + + +#include "Teuchos_RCP.hpp" +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_TestForException.hpp" +#include "Teuchos_AbstractFactoryStd.hpp" + +#include +#include "Kokkos_DefaultNode.hpp" + + +namespace Stratimikos { + + template + void enableFROSch(DefaultLinearSolverBuilder& builder, const std::string& stratName = "FROSch"){ + const Teuchos::RCP precValidParams = Teuchos::sublist(builder.getValidParameters(), "Preconditioner Types"); + + TEUCHOS_TEST_FOR_EXCEPTION(precValidParams->isParameter(stratName), std::logic_error, + "Stratimikos::enableFROSch cannot add \"" + stratName +"\" because it is already included in builder!"); + + typedef Thyra::PreconditionerFactoryBase Base; + typedef Thyra::FROSch_EpetraPreconFactory Impl; + + builder.setPreconditioningStrategyFactory(Teuchos::abstractFactoryStd(), stratName); + } + +} + From fcbb3d35a63ff59be612514cbe2d14dd5ec25d29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Fri, 17 Aug 2018 08:04:40 +0200 Subject: [PATCH 06/20] ZwischenStand Thyra --- .../adapters/epetra/MueLu_EpetraOperator.cpp | 1 + .../Thyra_MueLuPreconditionerFactory_def.hpp | 46 +++---- .../stratimikos/Thyra_XpetraLinearOp_def.hpp | 9 +- .../FROSch_OneLevelPreconditioner_decl.hpp | 2 + .../FROSch_OneLevelPreconditioner_def.hpp | 6 + .../Thyra_FROSchEpetraPreconFactory_decl.hpp | 2 +- .../Thyra_FROSchEpetraPreconFactory_def.hpp | 4 +- ...OSch_TwoLevelPreconditionerFactory_def.hpp | 118 ++++++------------ .../src/adapters/stratimikos_froschEpetra.hpp | 3 +- ...hyra_BelosLinearOpWithSolveFactory_def.hpp | 2 +- .../epetra/src/Thyra_EpetraLinearOp.cpp | 88 +++++++++++-- 11 files changed, 162 insertions(+), 119 deletions(-) diff --git a/packages/muelu/adapters/epetra/MueLu_EpetraOperator.cpp b/packages/muelu/adapters/epetra/MueLu_EpetraOperator.cpp index 12bbbf6accd1..22aac3ad7048 100644 --- a/packages/muelu/adapters/epetra/MueLu_EpetraOperator.cpp +++ b/packages/muelu/adapters/epetra/MueLu_EpetraOperator.cpp @@ -88,6 +88,7 @@ int EpetraOperator::ApplyInverse(const Epetra_MultiVector& X, Epetra_MultiVector << e.what() << std::endl; return -1; } + return 0; } diff --git a/packages/muelu/adapters/stratimikos/Thyra_MueLuPreconditionerFactory_def.hpp b/packages/muelu/adapters/stratimikos/Thyra_MueLuPreconditionerFactory_def.hpp index c9574d818245..c19746b01095 100644 --- a/packages/muelu/adapters/stratimikos/Thyra_MueLuPreconditionerFactory_def.hpp +++ b/packages/muelu/adapters/stratimikos/Thyra_MueLuPreconditionerFactory_def.hpp @@ -127,37 +127,37 @@ namespace Thyra { TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); RCP A = Teuchos::null; - if(bIsBlocked) { - Teuchos::RCP > ThyBlockedOp = - Teuchos::rcp_dynamic_cast >(fwdOp); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(ThyBlockedOp)); + if(bIsBlocked) { + Teuchos::RCP > ThyBlockedOp = + Teuchos::rcp_dynamic_cast >(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(ThyBlockedOp)); - TEUCHOS_TEST_FOR_EXCEPT(ThyBlockedOp->blockExists(0,0)==false); + TEUCHOS_TEST_FOR_EXCEPT(ThyBlockedOp->blockExists(0,0)==false); - Teuchos::RCP > b00 = ThyBlockedOp->getBlock(0,0); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(b00)); + Teuchos::RCP > b00 = ThyBlockedOp->getBlock(0,0); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(b00)); - RCP xpetraFwdCrsMat00 = XpThyUtils::toXpetra(b00); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat00)); + RCP xpetraFwdCrsMat00 = XpThyUtils::toXpetra(b00); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat00)); - // MueLu needs a non-const object as input - RCP xpetraFwdCrsMatNonConst00 = Teuchos::rcp_const_cast(xpetraFwdCrsMat00); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst00)); + // MueLu needs a non-const object as input + RCP xpetraFwdCrsMatNonConst00 = Teuchos::rcp_const_cast(xpetraFwdCrsMat00); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst00)); - // wrap the forward operator as an Xpetra::Matrix that MueLu can work with - RCP A00 = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst00)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A00)); + // wrap the forward operator as an Xpetra::Matrix that MueLu can work with + RCP A00 = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst00)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A00)); - RCP rowmap00 = A00->getRowMap(); - RCP< const Teuchos::Comm< int > > comm = rowmap00->getComm(); + RCP rowmap00 = A00->getRowMap(); + RCP< const Teuchos::Comm< int > > comm = rowmap00->getComm(); - // create a Xpetra::BlockedCrsMatrix which derives from Xpetra::Matrix that MueLu can work with - RCP bMat = Teuchos::rcp(new XpBlockedCrsMat(ThyBlockedOp, comm)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(bMat)); + // create a Xpetra::BlockedCrsMatrix which derives from Xpetra::Matrix that MueLu can work with + RCP bMat = Teuchos::rcp(new XpBlockedCrsMat(ThyBlockedOp, comm)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(bMat)); - // save blocked matrix - A = bMat; - } else { + // save blocked matrix + A = bMat; + } else { RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); diff --git a/packages/muelu/adapters/stratimikos/Thyra_XpetraLinearOp_def.hpp b/packages/muelu/adapters/stratimikos/Thyra_XpetraLinearOp_def.hpp index ce8733201436..036bfbf92e36 100644 --- a/packages/muelu/adapters/stratimikos/Thyra_XpetraLinearOp_def.hpp +++ b/packages/muelu/adapters/stratimikos/Thyra_XpetraLinearOp_def.hpp @@ -157,9 +157,16 @@ void XpetraLinearOp::applyImpl( TEUCHOS_TEST_FOR_EXCEPTION(getConstXpetraOperator() == Teuchos::null, MueLu::Exceptions::RuntimeError, "XpetraLinearOp::applyImpl: internal Xpetra::Operator is null."); RCP< const Teuchos::Comm< int > > comm = getConstXpetraOperator()->getRangeMap()->getComm(); - + comm->barrier(); + comm->barrier(); + comm->barrier(); + if(comm->getRank() == 0) std::cout<<"LinearOP Base line 163\n"; const RCP > tX_in = Xpetra::ThyraUtils::toXpetra(rcpFromRef(X_in), comm); + comm->barrier(); + comm->barrier(); + comm->barrier(); + if(comm->getRank() == 0) std::cout<<"LinearOP Base line 169\n"; RCP > tY_inout = Xpetra::ThyraUtils::toXpetra(rcpFromPtr(Y_inout), comm); Teuchos::ETransp transp; diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_decl.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_decl.hpp index 116b6ea66ad4..41263ecfd1c4 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_decl.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_decl.hpp @@ -96,6 +96,8 @@ namespace FROSch { virtual std::string description() const; + virtual CrsMatrixPtr getCrsMatrix() const; + protected: diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_def.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_def.hpp index 7e5b52f46418..7d391d893f4a 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_def.hpp @@ -128,6 +128,12 @@ namespace FROSch { return K_->getRangeMap(); } + template + typename OneLevelPreconditioner::CrsMatrixPtr OneLevelPreconditioner::getCrsMatrix() const + { + return K_; + } + template void OneLevelPreconditioner::describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp index a71a82ab4c86..c5cf8d6556fd 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp @@ -38,7 +38,7 @@ //#include #include #include -#includ "FROSch_EpetraOp_def.hpp" +#include #include // diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp index f97c7e93e04f..93cb335d5153 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp @@ -1,7 +1,7 @@ #ifndef THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DEF_HPP #define THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DEF_HPP -#include "Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp" +//#include "Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp" #include @@ -30,7 +30,7 @@ FROSch_EpetraPreconFactory::FROSch_Epetr } //-------------------------------------------------------------- template - RCP >FROSch_EpetraPreconFactory::createPrec() const{ + RCP > FROSch_EpetraPreconFactory::createPrec() const{ return Teuchos::rcp(new DefaultPreconditioner); } diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp index d6bedee84f3e..b67d0f86acf8 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp @@ -3,6 +3,7 @@ #include "Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp" +#include #include #include @@ -25,7 +26,7 @@ namespace Thyra { { const RCP > fwdOp = fwdOpSrc.getOp(); //so far only Epetra is allowed - if (Xpetra::ThyraUtils::isBlockedOperator(fwdOp)) return true; + if (Xpetra::ThyraUtils::isEpetra(fwdOp)) return true; return false; } @@ -44,7 +45,7 @@ namespace Thyra { ) const{ Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); - + using Teuchos::rcp_dynamic_cast; //Some Typedefs @@ -57,6 +58,9 @@ namespace Thyra { typedef Xpetra::MultiVector XpMultVec; typedef Xpetra::MultiVector XpMultVecDouble; typedef Thyra::LinearOpBase ThyLinOpBase; + typedef Thyra::EpetraLinearOp ThyEpLinOp; + + @@ -82,51 +86,18 @@ namespace Thyra { TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); RCP A = Teuchos::null; - if(bIsBlocked) { - Teuchos::RCP > ThyBlockedOp = - Teuchos::rcp_dynamic_cast >(fwdOp); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(ThyBlockedOp)); - - TEUCHOS_TEST_FOR_EXCEPT(ThyBlockedOp->blockExists(0,0)==false); - - Teuchos::RCP > b00 = ThyBlockedOp->getBlock(0,0); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(b00)); - - RCP xpetraFwdCrsMat00 = XpThyUtils::toXpetra(b00); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat00)); - - // TwoLevelPreconditioner needs Xpetra CRS Matrix ans input object as input - RCP xpetraFwdCrsMatNonConst00 = Teuchos::rcp_const_cast(xpetraFwdCrsMat00); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst00)); - - // wrap the forward operator as an Xpetra::Matrix that TwoLevelPreconditioner can work with - RCP A00 = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst00)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A00)); - - RCP rowmap00 = A00->getRowMap(); - RCP< const Teuchos::Comm< int > > comm = rowmap00->getComm(); - - // create a Xpetra::BlockedCrsMatrix which derives from Xpetra::Matrix that FROSCH can work with - RCP bMat = Teuchos::rcp(new XpBlockedCrsMat(ThyBlockedOp, comm)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(bMat)); - - // save blocked matrix - A = bMat; - } else { - std::cout<<"Not Blocked\n"; - - RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); - - // FROSCH needs a non-const object as input - RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); - - // wrap the forward operator as an Xpetra::Matrix that FROSch can work with - A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); - //A->describe(*fancy,Teuchos::VERB_EXTREME); - - } + RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); + + // FROSCH needs a non-const object as input + RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); + + // wrap the forward operator as an Xpetra::Matrix that FROSch can work with + A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); + //A->describe(*fancy,Teuchos::VERB_EXTREME); + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); // Retrieve concrete preconditioner object--->Here Mem Leak? @@ -141,50 +112,35 @@ namespace Thyra { //not implemented yet // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); + //-------Build New Two Level Prec-------------- const RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); - - //Initialize-> Only Works for laplce (cause defaults are used) and compute TwoLevelPrec->initialize(); - std::cout<<"Initialize Two Level Prec\n"; - TwoLevelPrec->compute(); - + //----------------------------------------------- + //Prepare for FROSch Epetra Op------------------- + RCP > epetraTwoLevel = rcp_dynamic_cast >(TwoLevelPrec); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(epetraTwoLevel)); + RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(frosch_epetraop)); + + //attach to fwdOp + set_extra_data(fwdOp,"IFPF::fwdOp", Teuchos::inOutArg(frosch_epetraop), Teuchos::POST_DESTROY,false); + + RCP thyra_epetraOp = Thyra::nonconstEpetraLinearOp(frosch_epetraop, NOTRANS, EPETRA_OP_APPLY_APPLY_INVERSE, EPETRA_OP_ADJOINT_UNSUPPORTED); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyra_epetraOp)); + //Wrap tp thyra RCP thyraPrecOp = Teuchos::null; - Comm->barrier(); Comm->barrier(); Comm->barrier(); - std::cout<<"Compute Two Level Prec\n"; - - // if(bIsBlocked) { - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); - - //create const Operator - //RCP > frosch_op = Teuchos::rcp_implicit_cast >(TwoLevelPrec); - //Teuchos::rcp_const_cast > (frosch_op) = TwoLevelPrec; - //TwoLevelPrec->getRangeMap()->describe(*fancy,Teuchos::VERB_EXTREME); - RCP > thyraRangeSpace = Xpetra::ThyraUtils::toThyra(TwoLevelPrec->getRangeMap()); - Comm->barrier(); Comm->barrier(); Comm->barrier(); - RCP > thyraDomainSpace = Xpetra::ThyraUtils::toThyra(TwoLevelPrec->getDomainMap()); - - RCP > xpOp = Teuchos::rcp_dynamic_cast >(TwoLevelPrec); - thyraPrecOp = Thyra::xpetraLinearOp(thyraRangeSpace, thyraDomainSpace,xpOp); - - //} - Comm->barrier(); - Comm->barrier(); - Comm->barrier(); - - std::cout<<"Test for null pointer\n"; - - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyraPrecOp)); + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); + + thyraPrecOp = rcp_dynamic_cast(thyra_epetraOp); defaultPrec->initializeUnspecified(thyraPrecOp); - Comm->barrier(); - Comm->barrier(); - Comm->barrier(); - std::cout<<"Thyra OP\n"; + } //------------------------------------------------------------- diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp index 3b0b68310f97..b5bf1a6b006e 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp @@ -4,7 +4,8 @@ -#include "Thyra_FROSchEpetraPreconFactory_decl.hpp" +#include + #include "Teuchos_RCP.hpp" diff --git a/packages/stratimikos/adapters/belos/src/Thyra_BelosLinearOpWithSolveFactory_def.hpp b/packages/stratimikos/adapters/belos/src/Thyra_BelosLinearOpWithSolveFactory_def.hpp index 9b4ccdb368e0..c72f1688ecc0 100644 --- a/packages/stratimikos/adapters/belos/src/Thyra_BelosLinearOpWithSolveFactory_def.hpp +++ b/packages/stratimikos/adapters/belos/src/Thyra_BelosLinearOpWithSolveFactory_def.hpp @@ -893,7 +893,7 @@ void BelosLinearOpWithSolveFactory::initializeOpImpl( } #endif if(out.get() && static_cast(verbLevel) > static_cast(Teuchos::VERB_LOW)) - *out << "\nLeaving Thyra::BelosLinearOpWithSolveFactory<"<::initializeOpImpl(...) ...\n"; + *out << "\nLeaving Thyra::BelosLinearOpWithSolveFactory< kann man sehen?"<::initializeOpImpl(...) ...\n"; } diff --git a/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp b/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp index 336305306868..0dd85d6711d5 100644 --- a/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp +++ b/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp @@ -89,20 +89,31 @@ void EpetraLinearOp::initialize( "Thyra::EpetraLinearOp::initialize(...): Error!" ); // ToDo: Validate spmdRange, spmdDomain against op maps! #endif - + std::cout<<"Epetra LinOp line 92\n"; RCP l_spmdRange; - if(!is_null(range_in)) - l_spmdRange = rcp_dynamic_cast(range_in,true); - else + if(!is_null(range_in)){ + l_spmdRange = rcp_dynamic_cast(range_in,true); + std::cout<<"Epetra LinOp line 96\n"; + } + + else{ l_spmdRange = ( applyAs==EPETRA_OP_APPLY_APPLY ? allocateRange(op,opTrans) : allocateDomain(op,opTrans) ); + std::cout<<"Epetra LinOp line 102\n"; + } RCP l_spmdDomain; - if(!is_null(domain_in)) - l_spmdDomain = rcp_dynamic_cast(domain_in,true); - else + if(!is_null(domain_in)){ + l_spmdDomain = rcp_dynamic_cast(domain_in,true); + std::cout<<"Epetra LinOp line 108\n"; + } + else{ l_spmdDomain = ( applyAs==EPETRA_OP_APPLY_APPLY - ? allocateDomain(op,opTrans) : allocateRange(op,opTrans) ); + ? allocateDomain(op,opTrans) : allocateRange(op,opTrans) ); + std::cout<<"Epetra LinOp line 113\n"; + + + } // Set data (no exceptions should be thrown now) isFullyInitialized_ = true; @@ -113,6 +124,7 @@ void EpetraLinearOp::initialize( adjointSupport_ = adjointSupport; range_ = l_spmdRange; domain_ = l_spmdDomain; + std::cout<<"Epetra LinOp line 127\n"; } @@ -139,12 +151,16 @@ void EpetraLinearOp::partiallyInitialize( TEUCHOS_TEST_FOR_EXCEPTION( is_null(op), std::invalid_argument, "Thyra::EpetraLinearOp::partiallyInitialize(...): Error!" ); #endif + std::cout<<"Epetra LinOp line 154\n"; RCP l_spmdRange = rcp_dynamic_cast(range_in,true); + std::cout<<"Epetra LinOp line 158\n"; + RCP l_spmdDomain = rcp_dynamic_cast(domain_in,true); - + std::cout<<"Epetra LinOp line 162\n"; + // Set data (no exceptions should be thrown now) isFullyInitialized_ = false; op_ = op; @@ -383,9 +399,16 @@ void EpetraLinearOp::applyImpl( "are not supported when initialized." ); #endif + + std::cout<<"Epetra LinOp line 404\n"; + const RCP > XY_domain = X_in.domain(); + std::cout<<"Epetra LinOp line 407\n"; + const int numCols = XY_domain->dim(); + std::cout<<"Epetra LinOp line 410\n"; + // // Get Epetra_MultiVector objects for the arguments @@ -404,9 +427,13 @@ void EpetraLinearOp::applyImpl( X = get_Epetra_MultiVector( real_M_trans==NOTRANS ? getDomainMap() : getRangeMap(), X_in ); // Y + std::cout<<"Epetra LinOp line 430\n"; + if( beta == 0 ) { Y = get_Epetra_MultiVector( real_M_trans==NOTRANS ? getRangeMap() : getDomainMap(), *Y_inout ); + std::cout<<"Epetra LinOp line 435\n"; + } } @@ -418,9 +445,12 @@ void EpetraLinearOp::applyImpl( * application. The reason for this is that if we later apply the * operator outside Thyra (in Aztec, for instance), it will remember * the transpose flag set here. */ + RCP Comm(new Epetra_MpiComm(MPI_COMM_WORLD)); bool oldState = op_->UseTranspose(); op_->SetUseTranspose( real_trans(trans_trans(opTrans_,M_trans)) == NOTRANS ? false : true ); + std::cout<<"Epetra LinOp line 451\n"; + // // Perform the apply operation @@ -431,16 +461,26 @@ void EpetraLinearOp::applyImpl( if( beta == 0.0 ) { // Y = M * X if( applyAs_ == EPETRA_OP_APPLY_APPLY ) { + Comm->Barrier();Comm->Barrier();Comm->Barrier(); + std::cout<<"Epetra LinOp line 463\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): Apply", ApplyApply); op_->Apply( *X, *Y ); + Comm->Barrier();Comm->Barrier();Comm->Barrier(); + std::cout<<"Epetra LinOp line 469\n"; + } else if( applyAs_ == EPETRA_OP_APPLY_APPLY_INVERSE ) { + std::cout<<"Epetra LinOp line 473\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): ApplyInverse", ApplyApplyInverse); op_->ApplyInverse( *X, *Y ); + std::cout<<"Epetra LinOp line 479\n"; + } else { #ifdef TEUCHOS_DEBUG @@ -449,42 +489,64 @@ void EpetraLinearOp::applyImpl( } // Y = alpha * Y if( alpha != 1.0 ) { + std::cout<<"Epetra LinOp line 489\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): Scale Y", Scale); Y->Scale(alpha); + std::cout<<"Epetra LinOp line 495\n"; + } } else { // beta != 0.0 // Y_inout = beta * Y_inout if(beta != 0.0) { + std::cout<<"Epetra LinOp line 502\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Scale Y", Scale); scale( beta, Y_inout ); + std::cout<<"Epetra LinOp line 508\n"; + } else { + std::cout<<"Epetra LinOp line 512\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Y=0", Apply2); assign( Y_inout, 0.0 ); + std::cout<<"Epetra LinOp line 518\n"; + } // T = M * X Epetra_MultiVector T(op_->OperatorRangeMap(), numCols, false); + std::cout<<"Epetra LinOp line 523\n"; + // NOTE: Above, op_->OperatorRange() will be right for either // non-transpose or transpose because we have already set the // UseTranspose flag correctly. if( applyAs_ == EPETRA_OP_APPLY_APPLY ) { + std::cout<<"Epetra LinOp line 529\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Apply", Apply2); op_->Apply( *X, T ); + std::cout<<"Epetra LinOp line 535\n"; + } else if( applyAs_ == EPETRA_OP_APPLY_APPLY_INVERSE ) { + std::cout<<"Epetra LinOp line 539\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): ApplyInverse", ApplyInverse); op_->ApplyInverse( *X, T ); + std::cout<<"Epetra LinOp line 545\n"; + } else { #ifdef TEUCHOS_DEBUG @@ -493,9 +555,13 @@ void EpetraLinearOp::applyImpl( } // Y_inout += alpha * T { + std::cout<<"Epetra LinOp line 555\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Update Y", Update); + std::cout<<"Epetra LinOp line 560\n"; + update( alpha, *create_MultiVector( @@ -505,12 +571,16 @@ void EpetraLinearOp::applyImpl( ), Y_inout ); + std::cout<<"Epetra LinOp line 571\n"; + } } } + std::cout<<"Epetra LinOp line 576\n"; // Reset the transpose state op_->SetUseTranspose(oldState); + std::cout<<"Epetra LinOp line 580\n"; // 2009/04/14: ToDo: This will not reset the transpose flag correctly if an // exception is thrown! From d13a13c68326b9964f65079e296b6e61c7a44d90 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Mon, 20 Aug 2018 07:42:09 +0200 Subject: [PATCH 07/20] ParameterList Issue --- .../FROSch_OverlappingOperator_def.hpp | 7 +- .../FROSch_SumOperator_def.hpp | 5 ++ .../FROSch_OneLevelPreconditioner_decl.hpp | 5 +- .../FROSch_OneLevelPreconditioner_def.hpp | 4 + .../FROSch_TwoLevelPreconditioner_decl.hpp | 2 + .../FROSch_TwoLevelPreconditioner_def.hpp | 10 +++ .../src/adapters/FROSch_EpetraOp_decl.hpp | 13 ++-- .../src/adapters/FROSch_EpetraOp_def.hpp | 73 ++++++++++++++++++- ...OSch_TwoLevelPreconditionerFactory_def.hpp | 38 +++++++++- 9 files changed, 142 insertions(+), 15 deletions(-) diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_OverlappingOperator_def.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_OverlappingOperator_def.hpp index 12aa2bdb9352..3838fecf458a 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_OverlappingOperator_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_OverlappingOperator_def.hpp @@ -77,7 +77,7 @@ namespace FROSch { MultiVectorPtr xTmp = Xpetra::MultiVectorFactory::Build(x.getMap(),x.getNumVectors()); *xTmp = x; - + Teuchos::RCP > Comm = x.getMap()->getComm(); if (!usePreconditionerOnly && mode == Teuchos::NO_TRANS) { this->K_->apply(x,*xTmp,mode,1.0,0.0); } @@ -88,8 +88,11 @@ namespace FROSch { xOverlap->doImport(*xTmp,*Scatter_,Xpetra::INSERT); xOverlap->replaceMap(OverlappingMatrix_->getRangeMap()); - + Comm->barrier(); Comm->barrier(); Comm->barrier(); + if(Comm->getRank()==0)std::cout<<"Overlapping Op Before Subdomain Solve\n"; SubdomainSolver_->apply(*xOverlap,*yOverlap,mode,1.0,0.0); + Comm->barrier(); Comm->barrier(); Comm->barrier(); + if(Comm->getRank()==0)std::cout<<"Overlapping Op After Subdomain Solve\n"; yOverlap->replaceMap(OverlappingMap_); diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SumOperator_def.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SumOperator_def.hpp index d03ca1e5c583..977ecd80415e 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SumOperator_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SumOperator_def.hpp @@ -113,6 +113,11 @@ namespace FROSch { SC alpha, SC beta) const { + Teuchos::RCP > Comm = x.getMap()->getComm(); + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0) std::cout<<"SumOperator Apply\n"; + this->ParameterList_->print(); + if (OperatorVector_.size()>0) { MultiVectorPtr xTmp = Xpetra::MultiVectorFactory::Build(x.getMap(),x.getNumVectors()); *xTmp = x; // Das brauche ich für den Fall das x=y diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_decl.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_decl.hpp index 41263ecfd1c4..d36f1d52945a 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_decl.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_decl.hpp @@ -91,13 +91,14 @@ namespace FROSch { virtual ConstMapPtr getRangeMap() const; + virtual CrsMatrixPtr getCrsMatrix() const; + + virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const; virtual std::string description() const; - virtual CrsMatrixPtr getCrsMatrix() const; - protected: diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_def.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_def.hpp index 7d391d893f4a..a3a2e751b7cd 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_OneLevelPreconditioner_def.hpp @@ -113,6 +113,9 @@ namespace FROSch { SC alpha, SC beta) const { + if(this->Verbose_)std::cout<<"Overlapping Prec Apply\n"; + + //ParameterListPtr list = sublist(this->ParameterList_,"AlgebraicOverlappingOperator"); return SumOperator_->apply(x,y,true,mode,alpha,beta); } @@ -134,6 +137,7 @@ namespace FROSch { return K_; } + template void OneLevelPreconditioner::describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_TwoLevelPreconditioner_decl.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_TwoLevelPreconditioner_decl.hpp index 9bd73660a108..ce46b27fd1af 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_TwoLevelPreconditioner_decl.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_TwoLevelPreconditioner_decl.hpp @@ -108,6 +108,8 @@ namespace FROSch { std::string description() const; + void setParameterList(ParameterListPtr para); + protected: diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_TwoLevelPreconditioner_def.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_TwoLevelPreconditioner_def.hpp index a9fd27dc4dac..e393b7addf95 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_TwoLevelPreconditioner_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzPreconditioners/FROSch_TwoLevelPreconditioner_def.hpp @@ -210,9 +210,19 @@ namespace FROSch { template std::string TwoLevelPreconditioner::description() const { + this->ParameterList_->print(); return "GDSW Preconditioner"; } + template + void TwoLevelPreconditioner::setParameterList(ParameterListPtr para){ + this->ParameterList_=para; + if(this->Verbose_){ + std::cout<<"In set ParameterList\n"; + this->ParameterList_->print(); + } + } + } #endif diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp index 17c012599ef1..eccea287b67d 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp @@ -59,8 +59,7 @@ namespace FROSch { /*! @class EpetraOperator - @brief Turns a MueLu::Hierarchy into a Epetra_Operator. - It allows MueLu to be used as a preconditioner for AztecOO (for instance). + */ class FROSch_EpetraOperator : public Epetra_Operator { typedef double SC; @@ -69,8 +68,8 @@ namespace FROSch { typedef Xpetra::EpetraNode NO; typedef Xpetra::Matrix Matrix; - typedef FROSch::TwoLevelPreconditioner TwoLevelPrec; - + typedef FROSch::TwoLevelPreconditioner TwoLevelPrec; + typedef RCP ParameterListPtr; @@ -80,8 +79,11 @@ namespace FROSch { //@{ //! Constructor - FROSch_EpetraOperator(const RCP& T) : TwoLevelPrec_(T) { } + FROSch_EpetraOperator(const RCP& T,const ParameterListPtr &P) : TwoLevelPrec_(T),paramList_(P) + + { } + FROSch_EpetraOperator(RCP K,ParameterListPtr paramList); //! Destructor. virtual ~FROSch_EpetraOperator() { } @@ -161,6 +163,7 @@ namespace FROSch { private: RCP TwoLevelPrec_; + ParameterListPtr paramList_; }; diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp index d9c35b191c9a..6b47e3da0bae 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp @@ -9,39 +9,106 @@ #include "FROSch_EpetraOp_decl.hpp" namespace FROSch { + + FROSch_EpetraOperator::FROSch_EpetraOperator(RCP K, + ParameterListPtr paramList): + TwoLevelPrec_(new FROSch::TwoLevelPreconditioner(K,paramList)), + paramList_(paramList) + { + + RCP< const Teuchos::Comm< int > > Comm = K->getRowMap()->getComm(); + Comm->barrier();Comm->barrier();Comm->barrier(); + if (Comm->getRank()== 0) { + std::cout<<"ParamList FROSchEpetraOp\n"; + } + //sublist(paramList,"TwoLevelPreconditioner")->print(std::cout); + RCP fancy = fancyOStream(rcpFromRef(std::cout)); + TwoLevelPrec_->describe(*fancy,Teuchos::VERB_EXTREME); + + Comm->barrier();Comm->barrier();Comm->barrier(); + if (Comm->getRank()== 0) { + std::cout<<"-------------------------------------------\n"; + //para->print(); + + } + + TwoLevelPrec_->initialize(); + TwoLevelPrec_->compute(); + + } + int FROSch_EpetraOperator::ApplyInverse(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const { try { + + RCP > Comm = rcp(new MpiComm (MPI_COMM_WORLD)); + + //Teuchos::RCP para = TwoLevelPrec_->getParameterList(); + //Comm->barrier();Comm->barrier();Comm->barrier(); + /*if(Comm->getRank() == 0){ + { + std::cout<<"Print now Parameters\n"; + para->print(); + + }}*/ + TwoLevelPrec_->setParameterList(paramList_); + TwoLevelPrec_->description(); + + Comm->barrier();Comm->barrier();Comm->barrier(); + RCP fancy = fancyOStream(rcpFromRef(std::cout)); + + //TwoLevelPrec_->describe(*fancy,Teuchos::VERB_EXTREME); // There is no rcpFromRef(const T&), so we need to do const_cast + const Xpetra::EpetraMultiVectorT eX(rcpFromRef(const_cast(X))); + /*Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra line 20\n";*/ const RCP > xX= rcpFromRef(const_cast&> (eX)); - + /*Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra line 23\n";*/ Xpetra::EpetraMultiVectorT eY(rcpFromRef(Y)); RCP > xY = rcpFromRef(eY); + /*Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra line 27\n";*/ // Generally, we assume two different vectors, but AztecOO uses a single vector if (X.Values() == Y.Values()) { + /*Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra line 31\n";*/ // X and Y point to the same memory, use an additional vector RCP > tmpY = Teuchos::rcp(new Xpetra::EpetraMultiVectorT(eY.getMap(), eY.getNumVectors())); - + /*Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra line 35\n";*/ RCP > xtmpY = tmpY; // InitialGuessIsZero in MueLu::Hierarchy.Iterate() does not zero out components, it // only assumes that user provided an already zeroed out vector bool usePreconOnly = true; tmpY->putScalar(0.0); // apply one V-cycle as preconditioner + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra Apply Two Level If\n"; TwoLevelPrec_->apply(*xX, *xtmpY,NO_TRANS,Teuchos::ScalarTraits::one(),Teuchos::ScalarTraits::zero()); + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra line 44\n"; // deep copy solution from MueLu xY->update(1.0, *xtmpY, 0.0); } else { // X and Y point to different memory, pass the vectors through + /* Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra line 50\n";*/ bool usePreconOnly = true; xY->putScalar(0.0); + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra Two Level Apply else\n"; + TwoLevelPrec_->apply(*xX, *xY,NO_TRANS,Teuchos::ScalarTraits::one(),Teuchos::ScalarTraits::zero()); + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"FROSch Epetra after TwoLevel Apply\n"; + } } catch (std::exception& e) { //TODO: error msg directly on std::cerr? - std::cerr << "Caught an exception in MueLu::EpetraOperator::ApplyInverse():" << std::endl + std::cerr << "Caught an exception in FROSch::EpetraOperator::ApplyInverse():" << std::endl << e.what() << std::endl; return -1; } diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp index b67d0f86acf8..592330aac4f0 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp @@ -4,6 +4,8 @@ #include "Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp" #include +#include + #include #include @@ -113,17 +115,45 @@ namespace Thyra { // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); //-------Build New Two Level Prec-------------- - const RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); + RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); + RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); + Comm->barrier(); + /*if(Comm->getRank() ==0){std::cout<<"Create Epetra Op new Constructor\n"; + + cout << "--------------------------------------------------------------------------------\nPARAMETERS Two Level Precon Factory:" << endl; + paramList.print(std::cout); + cout << "--------------------------------------------------------------------------------\n\n"; + + }*/ //Initialize-> Only Works for laplce (cause defaults are used) and compute + TwoLevelPrec->initialize(); TwoLevelPrec->compute(); //----------------------------------------------- //Prepare for FROSch Epetra Op------------------- RCP > epetraTwoLevel = rcp_dynamic_cast >(TwoLevelPrec); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(epetraTwoLevel)); - RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel)); + + + RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel,rcpFromRef(paramList))); + + Comm->barrier(); + /*if(Comm->getRank() ==0){std::cout<<"Create Epetra Op new Constructor\n"; + + cout << "--------------------------------------------------------------------------------\nPARAMETERS Two Level Precon Factory:" << endl; + paramList.print(std::cout); + cout << "--------------------------------------------------------------------------------\n\n"; + + }*/ + Comm->barrier();Comm->barrier();Comm->barrier(); + + + // RCP frosch_epetraop(new FROSch::FROSch_EpetraOperator(A,rcpFromRef(paramList))) + ; + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(frosch_epetraop)); //attach to fwdOp @@ -131,7 +161,7 @@ namespace Thyra { RCP thyra_epetraOp = Thyra::nonconstEpetraLinearOp(frosch_epetraop, NOTRANS, EPETRA_OP_APPLY_APPLY_INVERSE, EPETRA_OP_ADJOINT_UNSUPPORTED); TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyra_epetraOp)); - + //thyra_epetraOp->describe(*fancy,Teuchos::VERB_EXTREME); //Wrap tp thyra RCP thyraPrecOp = Teuchos::null; @@ -139,6 +169,8 @@ namespace Thyra { TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); thyraPrecOp = rcp_dynamic_cast(thyra_epetraOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyraPrecOp)); + defaultPrec->initializeUnspecified(thyraPrecOp); From 879546b9477a6eefe1e98b97b431430dadd7acdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Mon, 20 Aug 2018 07:57:42 +0200 Subject: [PATCH 08/20] example stratimikos --- .../frosch/example/stratimikos/main5.cpp | 303 ++++++++++++++++++ .../stratimikos/stratimikos_ParameterList.xml | 139 ++++++++ 2 files changed, 442 insertions(+) create mode 100644 packages/shylu/shylu_dd/frosch/example/stratimikos/main5.cpp create mode 100644 packages/shylu/shylu_dd/frosch/example/stratimikos/stratimikos_ParameterList.xml diff --git a/packages/shylu/shylu_dd/frosch/example/stratimikos/main5.cpp b/packages/shylu/shylu_dd/frosch/example/stratimikos/main5.cpp new file mode 100644 index 000000000000..b0d9eac26ba5 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/example/stratimikos/main5.cpp @@ -0,0 +1,303 @@ + +#include +#include + +#include +#include + +#include +#include + +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include + +// Thyra includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Stratimikos includes +#include +#include +//#include "stratimikos_froschEpetra.hpp" + +// Xpetra include +#include + +// FROSCH thyra includes +#include +//#include "Thyra_FROSchEpetraPreconFactory_decl.hpp" +#include "Frosch_EpetraOp_def.hpp" + +typedef unsigned UN; +typedef double SC; +typedef int LO; +typedef int GO; +typedef Kokkos::Compat::KokkosSerialWrapperNode EpetraNode; // Hier Default verwenden??? +typedef EpetraNode NO; + +using namespace std; +using namespace Teuchos; +using namespace Xpetra; +using namespace FROSch; +using namespace Belos; + +int main(int argc, char *argv[]) +{ + MPI_Init(&argc,&argv); + + { + Epetra_MpiComm CommWorld(MPI_COMM_WORLD); + + CommandLineProcessor My_CLP; + + Teuchos::RCP + + out = Teuchos::VerboseObjectBase::getDefaultOStream(); + + int M = 4; + My_CLP.setOption("M",&M,"H / h."); + int Dimension = 2; + My_CLP.setOption("Dim",&Dimension,"Dimension."); + int Overlap = 1; + My_CLP.setOption("Overlap",&Overlap,"Overlap."); + int DofsPerNode = 1; + My_CLP.setOption("DPN",&DofsPerNode,"Dofs per node."); + int DOFOrdering = 0; + My_CLP.setOption("Ordering",&DOFOrdering,"Dofs ordering (NodeWise=0,DimensionWise=1,Custom=2)."); + string xmlFile = "stratimikos_ParameterList.xml"; + My_CLP.setOption("List",&xmlFile,"File name of the parameter list."); + + My_CLP.recogniseAllOptions(true); + My_CLP.throwExceptions(false); + CommandLineProcessor::EParseCommandLineReturn parseReturn = My_CLP.parse(argc,argv); + if(parseReturn == CommandLineProcessor::PARSE_HELP_PRINTED) { + MPI_Finalize(); + return 0; + } + + int N; + MPI_Comm COMM; + int color=1; + //bool onFirstLevelComm=false; + if (Dimension == 2) { + N = (int) (pow(CommWorld.NumProc(),1/2.) + 100*numeric_limits::epsilon()); // 1/H + if (CommWorld.MyPID()::epsilon()); // 1/H + if (CommWorld.MyPID() Comm(new Epetra_MpiComm(COMM)); + RCP > TeuchosComm = rcp(new MpiComm (COMM)); + if (color==0) { + + RCP parameterList = getParametersFromXmlFile(xmlFile); + + if(Comm->MyPID()==0) { + cout << "--------------------------------------------------------------------------------\nPARAMETERS:" << endl; + parameterList->print(cout); + cout << "--------------------------------------------------------------------------------\n\n"; + } + + if (Comm->MyPID()==0) cout << "----------------ASSEMBLY-----------\n"; + + ParameterList GalerList; + GalerList.set("nx", N*M); + GalerList.set("ny", N*M); + GalerList.set("nz", N*M); + GalerList.set("mx", N); + GalerList.set("my", N); + GalerList.set("mz", N); + + RCP UniqueMapEpetra; + RCP KEpetra; + + if (Dimension==2) { + UniqueMapEpetra.reset(Galeri::CreateMap("Cartesian2D", *Comm, GalerList)); + KEpetra.reset(Galeri::CreateCrsMatrix("Laplace2D", UniqueMapEpetra.get(), GalerList)); + } else if (Dimension==3) { + UniqueMapEpetra.reset(Galeri::CreateMap("Cartesian3D", *Comm, GalerList)); + KEpetra.reset(Galeri::CreateCrsMatrix("Laplace3D", UniqueMapEpetra.get(), GalerList)); + } + + RCP > UniqueMap; + RCP > K; + DofOrdering Ord; + + if (DOFOrdering == 0) { + Ord = NodeWise; + Array uniqueMapArray(DofsPerNode*UniqueMapEpetra->NumMyElements()); + for (LO i=0; iNumMyElements(); i++) { + for (LO j=0; jGID(i)+j; + } + } + + UniqueMap = MapFactory::Build(UseEpetra,-1,uniqueMapArray(),0,TeuchosComm); + K = MatrixFactory::Build(UniqueMap,KEpetra->MaxNumEntries()); + for (LO i=0; iNumMyElements(); i++) { + LO numEntries; + GO* indices; + SC* values; + KEpetra->ExtractMyRowView(i,numEntries,values,indices); + + for (LO j=0; j indicesArray(numEntries); + ArrayView valuesArrayView(values,numEntries); + for (LO k=0; kColMap().GID(indices[k])+j; + } + K->insertGlobalValues(DofsPerNode*KEpetra->RowMap().GID(i)+j,indicesArray(),valuesArrayView); + } + } + K->fillComplete(); + } else if (DOFOrdering == 1) { + Ord = DimensionWise; + Array uniqueMapArray(DofsPerNode*UniqueMapEpetra->NumMyElements()); + for (LO i=0; iNumMyElements(); i++) { + for (LO j=0; jNumMyElements()*j] = UniqueMapEpetra->GID(i)+(UniqueMapEpetra->MaxAllGID()+1)*j; + } + } + + UniqueMap = MapFactory::Build(UseEpetra,-1,uniqueMapArray(),0,TeuchosComm); + K = MatrixFactory::Build(UniqueMap,KEpetra->MaxNumEntries()); + for (LO i=0; iNumMyElements(); i++) { + LO numEntries; + GO* indices; + SC* values; + KEpetra->ExtractMyRowView(i,numEntries,values,indices); + + for (LO j=0; j indicesArray(numEntries); + ArrayView valuesArrayView(values,numEntries); + for (LO k=0; kColMap().GID(indices[k])+(KEpetra->ColMap().MaxAllGID()+1)*j; + } + K->insertGlobalValues(UniqueMapEpetra->GID(i)+(UniqueMapEpetra->MaxAllGID()+1)*j,indicesArray(),valuesArrayView); + } + } + K->fillComplete(); + } else if (DOFOrdering == 2) { + assert(0!=0); // TODO: Andere Sortierung implementieren + } else { + assert(0!=0); + } + // RCP fancy = fancyOStream(rcpFromRef(std::cout)); UniqueMap->describe(*fancy,Teuchos::VERB_EXTREME); UniqueMap->getComm()->barrier(); UniqueMap->getComm()->barrier(); + + + RCP > xSolution = MultiVectorFactory::Build(UniqueMap,1); + RCP > xRightHandSide = MultiVectorFactory::Build(UniqueMap,1); + + xSolution->putScalar(0.0); + xRightHandSide->putScalar(1.0); + + auto lows_factory = Thyra::BelosLinearOpWithSolveFactory (); + auto pl = Teuchos::rcp(new Teuchos::ParameterList()); + pl->set("Solver Type", "Block GMRES"); + Teuchos::ParameterList& solver_pl = pl->sublist("Solver Types").sublist("Block GMRES"); + solver_pl.set("Convergence Tolerance", 1e-6); + solver_pl.set("Maximum Iterations", 100); + solver_pl.set("Num Blocks", 1); + lows_factory.setParameterList(pl); + lows_factory.setVerbLevel(Teuchos::VERB_HIGH); + //auto lows = lows_factory.createOp(); + + Teuchos::RCP > exA = Teuchos::rcp(new Xpetra::EpetraCrsMatrixT(KEpetra)); + Teuchos::RCP > exAWrap = Teuchos::rcp(new CrsMatrixWrap (exA)); + + RCP > K_thyra = Xpetra::ThyraUtils::toThyra(exAWrap->getCrsMatrix()); + RCP >thyraX = + Teuchos::rcp_const_cast >(Xpetra::ThyraUtils::toThyraMultiVector(xSolution)); + RCP >thyraB = Xpetra::ThyraUtils::toThyraMultiVector(xRightHandSide); + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + + //This Basic solve without Preconditioner + //Thyra::initializeOp(lows_factory, K_thyra, lows.ptr()); + //auto status = Thyra::solve(*lows, Thyra::NOTRANS, *thyraB, thyraX.ptr()); + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------Stratimikos LinearSolverBuilder-----------\n"; + + Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder; + Stratimikos::enableFROSchTwoLevel(linearSolverBuilder); + + linearSolverBuilder.setParameterList(parameterList); + + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------Thyra PrepForSolve-----------\n"; + + + + RCP > lowsFactory = + linearSolverBuilder.createLinearSolveStrategy(""); + + lowsFactory->setOStream(out); + lowsFactory->setVerbLevel(Teuchos::VERB_HIGH); + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + if (Comm->MyPID()==0) cout << "----------------Thyra LinearOpWithSolve-----------\n"; + + RCP > lows = + Thyra::linearOpWithSolve(*lowsFactory, K_thyra); + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + if (Comm->MyPID()==0) cout << "----------------Solve-----------\n"; + Thyra::SolveStatus status = + Thyra::solve(*lows, Thyra::NOTRANS, *thyraB, thyraX.ptr()); + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + + } + MPI_Comm_free(&COMM); + + } + + MPI_Finalize(); + + return(EXIT_SUCCESS); + +} + + + diff --git a/packages/shylu/shylu_dd/frosch/example/stratimikos/stratimikos_ParameterList.xml b/packages/shylu/shylu_dd/frosch/example/stratimikos/stratimikos_ParameterList.xml new file mode 100644 index 000000000000..bdea8d75a619 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/example/stratimikos/stratimikos_ParameterList.xml @@ -0,0 +1,139 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 1e959b86314bad1f8c11976f1f5ba2858cc003c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Mon, 20 Aug 2018 08:25:18 +0200 Subject: [PATCH 09/20] no message --- .../epetra/src/Thyra_EpetraLinearOp.cpp | 31 +++---------------- 1 file changed, 4 insertions(+), 27 deletions(-) diff --git a/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp b/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp index 0dd85d6711d5..6cc9cda8dda5 100644 --- a/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp +++ b/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp @@ -427,12 +427,10 @@ void EpetraLinearOp::applyImpl( X = get_Epetra_MultiVector( real_M_trans==NOTRANS ? getDomainMap() : getRangeMap(), X_in ); // Y - std::cout<<"Epetra LinOp line 430\n"; if( beta == 0 ) { Y = get_Epetra_MultiVector( real_M_trans==NOTRANS ? getRangeMap() : getDomainMap(), *Y_inout ); - std::cout<<"Epetra LinOp line 435\n"; } } @@ -445,11 +443,9 @@ void EpetraLinearOp::applyImpl( * application. The reason for this is that if we later apply the * operator outside Thyra (in Aztec, for instance), it will remember * the transpose flag set here. */ - RCP Comm(new Epetra_MpiComm(MPI_COMM_WORLD)); bool oldState = op_->UseTranspose(); op_->SetUseTranspose( real_trans(trans_trans(opTrans_,M_trans)) == NOTRANS ? false : true ); - std::cout<<"Epetra LinOp line 451\n"; // @@ -461,26 +457,23 @@ void EpetraLinearOp::applyImpl( if( beta == 0.0 ) { // Y = M * X if( applyAs_ == EPETRA_OP_APPLY_APPLY ) { - Comm->Barrier();Comm->Barrier();Comm->Barrier(); - std::cout<<"Epetra LinOp line 463\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): Apply", ApplyApply); op_->Apply( *X, *Y ); - Comm->Barrier();Comm->Barrier();Comm->Barrier(); - std::cout<<"Epetra LinOp line 469\n"; + } else if( applyAs_ == EPETRA_OP_APPLY_APPLY_INVERSE ) { - std::cout<<"Epetra LinOp line 473\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): ApplyInverse", ApplyApplyInverse); op_->ApplyInverse( *X, *Y ); - std::cout<<"Epetra LinOp line 479\n"; - + } else { #ifdef TEUCHOS_DEBUG @@ -489,63 +482,52 @@ void EpetraLinearOp::applyImpl( } // Y = alpha * Y if( alpha != 1.0 ) { - std::cout<<"Epetra LinOp line 489\n"; THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): Scale Y", Scale); Y->Scale(alpha); - std::cout<<"Epetra LinOp line 495\n"; } } else { // beta != 0.0 // Y_inout = beta * Y_inout if(beta != 0.0) { - std::cout<<"Epetra LinOp line 502\n"; THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Scale Y", Scale); scale( beta, Y_inout ); - std::cout<<"Epetra LinOp line 508\n"; } else { - std::cout<<"Epetra LinOp line 512\n"; THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Y=0", Apply2); assign( Y_inout, 0.0 ); - std::cout<<"Epetra LinOp line 518\n"; } // T = M * X Epetra_MultiVector T(op_->OperatorRangeMap(), numCols, false); - std::cout<<"Epetra LinOp line 523\n"; // NOTE: Above, op_->OperatorRange() will be right for either // non-transpose or transpose because we have already set the // UseTranspose flag correctly. if( applyAs_ == EPETRA_OP_APPLY_APPLY ) { - std::cout<<"Epetra LinOp line 529\n"; THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Apply", Apply2); op_->Apply( *X, T ); - std::cout<<"Epetra LinOp line 535\n"; } else if( applyAs_ == EPETRA_OP_APPLY_APPLY_INVERSE ) { - std::cout<<"Epetra LinOp line 539\n"; THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): ApplyInverse", ApplyInverse); op_->ApplyInverse( *X, T ); - std::cout<<"Epetra LinOp line 545\n"; } else { @@ -555,12 +537,10 @@ void EpetraLinearOp::applyImpl( } // Y_inout += alpha * T { - std::cout<<"Epetra LinOp line 555\n"; THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Update Y", Update); - std::cout<<"Epetra LinOp line 560\n"; update( alpha, @@ -571,16 +551,13 @@ void EpetraLinearOp::applyImpl( ), Y_inout ); - std::cout<<"Epetra LinOp line 571\n"; } } } - std::cout<<"Epetra LinOp line 576\n"; // Reset the transpose state op_->SetUseTranspose(oldState); - std::cout<<"Epetra LinOp line 580\n"; // 2009/04/14: ToDo: This will not reset the transpose flag correctly if an // exception is thrown! From 545da81acad32a7fb0288e9af5a37a0a563220cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Mon, 20 Aug 2018 09:10:44 +0200 Subject: [PATCH 10/20] no message --- .../FROSch_SubdomainSolver_def.hpp | 275 ++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SubdomainSolver_def.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SubdomainSolver_def.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SubdomainSolver_def.hpp new file mode 100644 index 000000000000..31b160d3f564 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SubdomainSolver_def.hpp @@ -0,0 +1,275 @@ +//@HEADER +// ************************************************************************ +// +// ShyLU: Hybrid preconditioner package +// Copyright 2012 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Alexander Heinlein (alexander.heinlein@uni-koeln.de) +// +// ************************************************************************ +//@HEADER + +#ifndef _FROSCH_SUBDOMAINSOLVER_DEF_hpp +#define _FROSCH_SUBDOMAINSOLVER_DEF_hpp + +#include + +namespace FROSch { + + template + SubdomainSolver::SubdomainSolver(CrsMatrixPtr k, + ParameterListPtr parameterList) : + K_ (k), + ParameterList_ (parameterList), + EpetraLinearProblem_ (), + AmesosSolver_ (), + IsInitialized_ (false), + IsComputed_ (false) + { + + Teuchos::RCP > Comm = K_->getRowMap()->getComm(); + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"Constructor Subdomain Solver\n"; + + if (!ParameterList_->get("SolverType","Amesos").compare("Amesos")) { + FROSCH_ASSERT(K_->getRowMap()->lib()==Xpetra::UseEpetra,"UnderlyingLib!=Xpetra::UseEpetra"); + // AH 10/18/2017: Dies könnten wir nach initialize() verschieben, oder? + Xpetra::CrsMatrixWrap& crsOp = dynamic_cast&>(*K_); + Xpetra::EpetraCrsMatrixT& xEpetraMat = dynamic_cast&>(*crsOp.getCrsMatrix()); + EpetraCrsMatrixPtr epetraMat = xEpetraMat.getEpetra_CrsMatrixNonConst(); + + EpetraMultiVectorPtr xTmp; + EpetraMultiVectorPtr bTmp; + + EpetraLinearProblem_.reset(new Epetra_LinearProblem(epetraMat.get(),xTmp.get(),bTmp.get())); + + Amesos amesosFactory; + AmesosSolver_.reset(amesosFactory.Create(ParameterList_->get("Solver","Mumps"),*EpetraLinearProblem_)); + AmesosSolver_->SetParameters(ParameterList_->sublist("Amesos")); + } else if (!ParameterList_->get("SolverType","Amesos").compare("Amesos2")) { + if (K_->getRowMap()->lib()==Xpetra::UseEpetra) { + Xpetra::CrsMatrixWrap& crsOp = dynamic_cast&>(*K_); + Xpetra::EpetraCrsMatrixT& xEpetraMat = dynamic_cast&>(*crsOp.getCrsMatrix()); + EpetraCrsMatrixPtr epetraMat = xEpetraMat.getEpetra_CrsMatrixNonConst(); + + EpetraMultiVectorPtr xTmp; + EpetraMultiVectorPtr bTmp; + + Amesos2SolverEpetra_ = Amesos2::create(ParameterList_->get("Solver","Mumps"),epetraMat,xTmp,bTmp); + Amesos2SolverEpetra_->setParameters(sublist(ParameterList_,"Amesos2")); + } else if (K_->getRowMap()->lib()==Xpetra::UseTpetra) { + Xpetra::CrsMatrixWrap& crsOp = dynamic_cast&>(*K_); + Xpetra::TpetraCrsMatrix& xTpetraMat = dynamic_cast&>(*crsOp.getCrsMatrix()); + TpetraCrsMatrixPtr tpetraMat = xTpetraMat.getTpetra_CrsMatrixNonConst(); + + TpetraMultiVectorPtr xTmp; + TpetraMultiVectorPtr bTmp; + + Amesos2SolverTpetra_ = Amesos2::create,Tpetra::MultiVector >(ParameterList_->get("Solver","Mumps"),tpetraMat,xTmp,bTmp); + Amesos2SolverTpetra_->setParameters(sublist(ParameterList_,"Amesos2")); + } else { + FROSCH_ASSERT(0!=0,"This can't happen..."); + } + } else { + FROSCH_ASSERT(0!=0,"SolverType nicht bekannt..."); + } + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"Constructor Subdomain Solver end\n"; + } + + template + SubdomainSolver::~SubdomainSolver() + { + AmesosSolver_.reset(); + EpetraLinearProblem_.reset(); + } + + template + int SubdomainSolver::initialize() + { + Teuchos::RCP > Comm = K_->getRowMap()->getComm(); + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"Initialize Subdomain Solver\n"; + + if (!ParameterList_->get("SolverType","Amesos").compare("Amesos")) { + IsInitialized_ = true; + IsComputed_ = false; + AMESOS_CHK_ERR(AmesosSolver_->SymbolicFactorization()); + } else if (!ParameterList_->get("SolverType","Amesos").compare("Amesos2")) { + if (K_->getRowMap()->lib()==Xpetra::UseEpetra) { + IsInitialized_ = true; + IsComputed_ = false; + Amesos2SolverEpetra_->symbolicFactorization(); + } else { + IsInitialized_ = true; + IsComputed_ = false; + Amesos2SolverTpetra_->symbolicFactorization(); + } + } else { + FROSCH_ASSERT(0!=0,"SolverType nicht bekannt..."); + } + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"Initialize Subdomain Solver end\n"; + + return 0; + } + + template + int SubdomainSolver::compute() + { + Teuchos::RCP > Comm = K_->getRowMap()->getComm(); + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"Compute Subdomain Solver end\n"; + FROSCH_ASSERT(IsInitialized_,"!IsInitialized_."); + if (!ParameterList_->get("SolverType","Amesos").compare("Amesos")) { + IsComputed_ = true; + AMESOS_CHK_ERR(AmesosSolver_->NumericFactorization()); + } else if (!ParameterList_->get("SolverType","Amesos").compare("Amesos2")) { + if (K_->getRowMap()->lib()==Xpetra::UseEpetra) { + IsComputed_ = true; + Amesos2SolverEpetra_->numericFactorization(); + } else { + IsComputed_ = true; + Amesos2SolverTpetra_->numericFactorization(); + } + } else { + FROSCH_ASSERT(0!=0,"SolverType nicht bekannt..."); + } + Comm->barrier();Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"Compute Subdomain Solver end\n"; + return 0; + } + + // Y = alpha * A^mode * X + beta * Y + template + void SubdomainSolver::apply(const MultiVector &x, + MultiVector &y, + Teuchos::ETransp mode, + SC alpha, + SC beta) const + { + FROSCH_ASSERT(IsComputed_,"!IsComputed_."); + + MultiVectorPtr yTmp; + Teuchos::RCP > Comm = x.getMap()->getComm(); + Comm->barrier();Comm->barrier(); + if(Comm->getRank() == 0)std::cout<<"Subdomain Apply\n"; + + if (!ParameterList_->get("SolverType","Amesos").compare("Amesos")) { + const Xpetra::EpetraMultiVectorT * xEpetraMultiVectorX = dynamic_cast *>(&x); + Teuchos::RCP epetraMultiVectorX = xEpetraMultiVectorX->getEpetra_MultiVector(); + + yTmp = Xpetra::MultiVectorFactory::Build(y.getMap(),x.getNumVectors()); + *yTmp = y; + Xpetra::EpetraMultiVectorT * xEpetraMultiVectorY = dynamic_cast *>(yTmp.get()); + Teuchos::RCP epetraMultiVectorY = xEpetraMultiVectorY->getEpetra_MultiVector(); + + EpetraLinearProblem_->SetLHS(epetraMultiVectorY.get()); + EpetraLinearProblem_->SetRHS(epetraMultiVectorX.get()); + + EpetraLinearProblem_->GetMatrix()->SetUseTranspose(mode==Teuchos::TRANS); + AmesosSolver_->Solve(); + } else if (!ParameterList_->get("SolverType","Amesos").compare("Amesos2")) { + if (K_->getRowMap()->lib()==Xpetra::UseEpetra) { + const Xpetra::EpetraMultiVectorT * xEpetraMultiVectorX = dynamic_cast *>(&x); + Teuchos::RCP epetraMultiVectorX = xEpetraMultiVectorX->getEpetra_MultiVector(); + + yTmp = Xpetra::MultiVectorFactory::Build(y.getMap(),x.getNumVectors()); + *yTmp = y; + Xpetra::EpetraMultiVectorT * xEpetraMultiVectorY = dynamic_cast *>(yTmp.get()); + Teuchos::RCP epetraMultiVectorY = xEpetraMultiVectorY->getEpetra_MultiVector(); + + Amesos2SolverEpetra_->setX(epetraMultiVectorY); + Amesos2SolverEpetra_->setB(epetraMultiVectorX); + + Amesos2SolverEpetra_->solve(); // Was ist, wenn man mit der transponierten Matrix lösen will + } else { + const Xpetra::TpetraMultiVector * xTpetraMultiVectorX = dynamic_cast *>(&x); + TpetraMultiVectorPtr tpetraMultiVectorX = xTpetraMultiVectorX->getTpetra_MultiVector(); + + yTmp = Xpetra::MultiVectorFactory::Build(y.getMap(),x.getNumVectors()); + *yTmp = y; + const Xpetra::TpetraMultiVector * xTpetraMultiVectorY = dynamic_cast *>(yTmp.get()); + TpetraMultiVectorPtr tpetraMultiVectorY = xTpetraMultiVectorY->getTpetra_MultiVector(); + + Amesos2SolverTpetra_->setX(tpetraMultiVectorY); + Amesos2SolverTpetra_->setB(tpetraMultiVectorX); + + Amesos2SolverTpetra_->solve(); // Was ist, wenn man mit der transponierten Matrix lösen will + } + } else { + FROSCH_ASSERT(0!=0,"SolverType nicht bekannt..."); + } + y.update(alpha,*yTmp,beta); + } + + template + typename SubdomainSolver::ConstMapPtr SubdomainSolver::getDomainMap() const + { + return K_->getDomainMap(); + } + + template + typename SubdomainSolver::ConstMapPtr SubdomainSolver::getRangeMap() const + { + return K_->getRangeMap(); + } + + template + void SubdomainSolver::describe(Teuchos::FancyOStream &out, + const Teuchos::EVerbosityLevel verbLevel) const + { + FROSCH_ASSERT(0!=0,"describe() has be implemented properly..."); + } + + template + std::string SubdomainSolver::description() const + { + return "Subdomain Solver"; + } + + template + bool SubdomainSolver::isInitialized() const + { + return IsInitialized_; + } + + template + bool SubdomainSolver::isComputed() const + { + return IsComputed_; + } + +} + +#endif From 94a475cc5cd0998e48d6d0e6c6ef1af8ecbbab08 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Mon, 20 Aug 2018 11:52:29 +0200 Subject: [PATCH 11/20] TwoLevelPreconditioner+ExtractCoordinates(not tested ) --- .../frosch/src/Tools/FROSch_Tools_decl.hpp | 5 +++++ .../frosch/src/Tools/FROSch_Tools_def.hpp | 16 ++++++++++++++++ .../src/adapters/Stratimikos_FROSchHelpers.hpp | 2 +- 3 files changed, 22 insertions(+), 1 deletion(-) diff --git a/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_decl.hpp b/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_decl.hpp index ab50795a8be4..1f81771d8c4e 100644 --- a/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_decl.hpp +++ b/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_decl.hpp @@ -122,6 +122,11 @@ namespace FROSch { Teuchos::RCP > ConvertToXpetra(Xpetra::UnderlyingLib lib, Epetra_MultiVector &vector, Teuchos::RCP > comm); + + template + Teuchos::RCP > ExtractCoordinatesFromParameterList (Teuchos::ParameterList& paramList); + + } #endif diff --git a/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_def.hpp b/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_def.hpp index b3c963e69d37..ca9861bd0030 100644 --- a/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_def.hpp @@ -677,6 +677,22 @@ namespace FROSch { } return xMultiVector; } + + template + Teuchos::RCP > ExtractCoordinatesFromParameterList (Teuchos::ParameterList& paramList){ + Teuchos::RCP > coordinates = Teuchos::null; + + if(paramList.isParameter ("Coordinates") == false) + return coordinates; + + if(paramList.isType("Coordinates")) { + coordinates = paramList.get("Coordinates"); + } else{ + std::cerr<<"Wrong Type of Multovector\n"; + } + + return coordinates; + } } #endif diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp index 59ae042e3d73..d4239ebaf4c5 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp @@ -17,7 +17,7 @@ namespace Stratimikos { template - void enableFROSchTwoLevel(DefaultLinearSolverBuilder& builder, const std::string& stratName = "FROSchTwoLevel") + void enableFROSchTwoLevel(DefaultLinearSolverBuilder& builder, const std::string& stratName = "TwoLevelPreconditioner") { const Teuchos::RCP precValidParams = Teuchos::sublist(builder.getValidParameters(), "Preconditioner Types"); From 3243337ed46e5deea70ec3f46a53122a62960196 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Tue, 21 Aug 2018 09:34:56 +0200 Subject: [PATCH 12/20] ExtractFromParameterList --- .../FROSch_SumOperator_def.hpp | 2 +- .../frosch/src/Tools/FROSch_Tools_decl.hpp | 5 ++ .../frosch/src/Tools/FROSch_Tools_def.hpp | 18 ++++- .../src/adapters/FROSch_EpetraOp_def.hpp | 11 ++-- ...OSch_TwoLevelPreconditionerFactory_def.hpp | 13 ++++ .../epetra/src/Thyra_EpetraLinearOp.cpp | 65 +++---------------- 6 files changed, 50 insertions(+), 64 deletions(-) diff --git a/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SumOperator_def.hpp b/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SumOperator_def.hpp index 977ecd80415e..6c456898a446 100644 --- a/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SumOperator_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/SchwarzOperators/FROSch_SumOperator_def.hpp @@ -116,7 +116,7 @@ namespace FROSch { Teuchos::RCP > Comm = x.getMap()->getComm(); Comm->barrier();Comm->barrier();Comm->barrier(); if(Comm->getRank() == 0) std::cout<<"SumOperator Apply\n"; - this->ParameterList_->print(); + if (OperatorVector_.size()>0) { MultiVectorPtr xTmp = Xpetra::MultiVectorFactory::Build(x.getMap(),x.getNumVectors()); diff --git a/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_decl.hpp b/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_decl.hpp index 1f81771d8c4e..6c8ed938bc73 100644 --- a/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_decl.hpp +++ b/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_decl.hpp @@ -126,6 +126,11 @@ namespace FROSch { template Teuchos::RCP > ExtractCoordinatesFromParameterList (Teuchos::ParameterList& paramList); + template < + class LO,class GO,class NO> + Teuchos::RCP > ExtractRepeatedMapFromParameterList(Teuchos::ParameterList& paramList); + + } diff --git a/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_def.hpp b/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_def.hpp index ca9861bd0030..092c742a21a4 100644 --- a/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/Tools/FROSch_Tools_def.hpp @@ -679,7 +679,7 @@ namespace FROSch { } template - Teuchos::RCP > ExtractCoordinatesFromParameterList (Teuchos::ParameterList& paramList){ + Teuchos::RCP > ExtractCoordinatesFromParameterList(Teuchos::ParameterList& paramList){ Teuchos::RCP > coordinates = Teuchos::null; if(paramList.isParameter ("Coordinates") == false) @@ -688,11 +688,25 @@ namespace FROSch { if(paramList.isType("Coordinates")) { coordinates = paramList.get("Coordinates"); } else{ - std::cerr<<"Wrong Type of Multovector\n"; + std::cerr<<"Wrong Type of Multivector\n"; } return coordinates; } + + template + Teuchos::RCP >ExtractRepeatedMapFromParameterList(Teuchos::ParameterList& paramList){ + Teuchos::RCP > repMap = Teuchos::null; + if(paramList.isParameter("RepeatedMap") == false){ + return repMap; + } + if(paramList.isType("RepeatedMap")){ + repMap = paramList.get("RepeatedMap"); + }else{ + std::cerr<<"Wrong Type of Map\n"; + } + return repMap; + } } #endif diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp index 6b47e3da0bae..3a225114d4b4 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp @@ -44,14 +44,15 @@ namespace FROSch { //Teuchos::RCP para = TwoLevelPrec_->getParameterList(); //Comm->barrier();Comm->barrier();Comm->barrier(); - /*if(Comm->getRank() == 0){ + if(Comm->getRank() == 0){ { std::cout<<"Print now Parameters\n"; - para->print(); + //para->print(); - }}*/ - TwoLevelPrec_->setParameterList(paramList_); - TwoLevelPrec_->description(); + }} + + //TwoLevelPrec_->setParameterList(paramList_); + //TwoLevelPrec_->description(); Comm->barrier();Comm->barrier();Comm->barrier(); RCP fancy = fancyOStream(rcpFromRef(std::cout)); diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp index 592330aac4f0..3f6a00df1b7c 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp @@ -127,6 +127,19 @@ namespace Thyra { cout << "--------------------------------------------------------------------------------\n\n"; }*/ + if(paramList.isParameter("Coordinates")){ + Teuchos::RCP > coord = FROSch::ExtractCoordinatesFromParameterList(paramList); + coord->describe(*fancy,Teuchos::VERB_EXTREME); + + } + + if(paramList.isParameter("RepeatedMap")){ + Teuchos::RCP > RepeatedMap = Teuchos::null; + + RepeatedMap = FROSch::ExtractRepeatedMapFromParameterList(paramList); + RepeatedMap->describe(*fancy,Teuchos::VERB_EXTREME); + + } //Initialize-> Only Works for laplce (cause defaults are used) and compute TwoLevelPrec->initialize(); diff --git a/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp b/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp index 6cc9cda8dda5..336305306868 100644 --- a/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp +++ b/packages/thyra/adapters/epetra/src/Thyra_EpetraLinearOp.cpp @@ -89,31 +89,20 @@ void EpetraLinearOp::initialize( "Thyra::EpetraLinearOp::initialize(...): Error!" ); // ToDo: Validate spmdRange, spmdDomain against op maps! #endif - std::cout<<"Epetra LinOp line 92\n"; - RCP l_spmdRange; - if(!is_null(range_in)){ - l_spmdRange = rcp_dynamic_cast(range_in,true); - std::cout<<"Epetra LinOp line 96\n"; - } - else{ + RCP l_spmdRange; + if(!is_null(range_in)) + l_spmdRange = rcp_dynamic_cast(range_in,true); + else l_spmdRange = ( applyAs==EPETRA_OP_APPLY_APPLY ? allocateRange(op,opTrans) : allocateDomain(op,opTrans) ); - std::cout<<"Epetra LinOp line 102\n"; - } RCP l_spmdDomain; - if(!is_null(domain_in)){ - l_spmdDomain = rcp_dynamic_cast(domain_in,true); - std::cout<<"Epetra LinOp line 108\n"; - } - else{ + if(!is_null(domain_in)) + l_spmdDomain = rcp_dynamic_cast(domain_in,true); + else l_spmdDomain = ( applyAs==EPETRA_OP_APPLY_APPLY - ? allocateDomain(op,opTrans) : allocateRange(op,opTrans) ); - std::cout<<"Epetra LinOp line 113\n"; - - - } + ? allocateDomain(op,opTrans) : allocateRange(op,opTrans) ); // Set data (no exceptions should be thrown now) isFullyInitialized_ = true; @@ -124,7 +113,6 @@ void EpetraLinearOp::initialize( adjointSupport_ = adjointSupport; range_ = l_spmdRange; domain_ = l_spmdDomain; - std::cout<<"Epetra LinOp line 127\n"; } @@ -151,16 +139,12 @@ void EpetraLinearOp::partiallyInitialize( TEUCHOS_TEST_FOR_EXCEPTION( is_null(op), std::invalid_argument, "Thyra::EpetraLinearOp::partiallyInitialize(...): Error!" ); #endif - std::cout<<"Epetra LinOp line 154\n"; RCP l_spmdRange = rcp_dynamic_cast(range_in,true); - std::cout<<"Epetra LinOp line 158\n"; - RCP l_spmdDomain = rcp_dynamic_cast(domain_in,true); - std::cout<<"Epetra LinOp line 162\n"; - + // Set data (no exceptions should be thrown now) isFullyInitialized_ = false; op_ = op; @@ -399,16 +383,9 @@ void EpetraLinearOp::applyImpl( "are not supported when initialized." ); #endif - - std::cout<<"Epetra LinOp line 404\n"; - const RCP > XY_domain = X_in.domain(); - std::cout<<"Epetra LinOp line 407\n"; - const int numCols = XY_domain->dim(); - std::cout<<"Epetra LinOp line 410\n"; - // // Get Epetra_MultiVector objects for the arguments @@ -427,11 +404,9 @@ void EpetraLinearOp::applyImpl( X = get_Epetra_MultiVector( real_M_trans==NOTRANS ? getDomainMap() : getRangeMap(), X_in ); // Y - if( beta == 0 ) { Y = get_Epetra_MultiVector( real_M_trans==NOTRANS ? getRangeMap() : getDomainMap(), *Y_inout ); - } } @@ -447,7 +422,6 @@ void EpetraLinearOp::applyImpl( op_->SetUseTranspose( real_trans(trans_trans(opTrans_,M_trans)) == NOTRANS ? false : true ); - // // Perform the apply operation // @@ -457,23 +431,16 @@ void EpetraLinearOp::applyImpl( if( beta == 0.0 ) { // Y = M * X if( applyAs_ == EPETRA_OP_APPLY_APPLY ) { - - THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): Apply", ApplyApply); op_->Apply( *X, *Y ); - - } else if( applyAs_ == EPETRA_OP_APPLY_APPLY_INVERSE ) { - - THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): ApplyInverse", ApplyApplyInverse); op_->ApplyInverse( *X, *Y ); - } else { #ifdef TEUCHOS_DEBUG @@ -482,53 +449,42 @@ void EpetraLinearOp::applyImpl( } // Y = alpha * Y if( alpha != 1.0 ) { - THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta==0): Scale Y", Scale); Y->Scale(alpha); - } } else { // beta != 0.0 // Y_inout = beta * Y_inout if(beta != 0.0) { - THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Scale Y", Scale); scale( beta, Y_inout ); - } else { - THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Y=0", Apply2); assign( Y_inout, 0.0 ); - } // T = M * X Epetra_MultiVector T(op_->OperatorRangeMap(), numCols, false); - // NOTE: Above, op_->OperatorRange() will be right for either // non-transpose or transpose because we have already set the // UseTranspose flag correctly. if( applyAs_ == EPETRA_OP_APPLY_APPLY ) { - THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Apply", Apply2); op_->Apply( *X, T ); - } else if( applyAs_ == EPETRA_OP_APPLY_APPLY_INVERSE ) { - THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): ApplyInverse", ApplyInverse); op_->ApplyInverse( *X, T ); - } else { #ifdef TEUCHOS_DEBUG @@ -537,11 +493,9 @@ void EpetraLinearOp::applyImpl( } // Y_inout += alpha * T { - THYRA_FUNC_TIME_MONITOR_DIFF( "Thyra::EpetraLinearOp::euclideanApply: Apply(beta!=0): Update Y", Update); - update( alpha, *create_MultiVector( @@ -551,7 +505,6 @@ void EpetraLinearOp::applyImpl( ), Y_inout ); - } } } From 399f9b654c6186aa368596b86830816713f907bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Tue, 21 Aug 2018 10:10:19 +0200 Subject: [PATCH 13/20] New initialize() --- ...OSch_TwoLevelPreconditionerFactory_def.hpp | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp index 3f6a00df1b7c..2fd8b4112374 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp @@ -127,22 +127,33 @@ namespace Thyra { cout << "--------------------------------------------------------------------------------\n\n"; }*/ + Teuchos::RCP > coord = Teuchos::null; + Teuchos::RCP > RepeatedMap = Teuchos::null; + if(paramList.isParameter("Coordinates")){ - Teuchos::RCP > coord = FROSch::ExtractCoordinatesFromParameterList(paramList); + coord = FROSch::ExtractCoordinatesFromParameterList(paramList); coord->describe(*fancy,Teuchos::VERB_EXTREME); } if(paramList.isParameter("RepeatedMap")){ - Teuchos::RCP > RepeatedMap = Teuchos::null; RepeatedMap = FROSch::ExtractRepeatedMapFromParameterList(paramList); RepeatedMap->describe(*fancy,Teuchos::VERB_EXTREME); } - //Initialize-> Only Works for laplce (cause defaults are used) and compute + + if(coord.get()!=NULL && RepeatedMap.get()!=NULL){ + + + TwoLevelPrec->initialize(paramList.get("Dimension",1),paramList.get("Overlap",1),RepeatedMap,paramList.get("DofsPerNode",1),FROSch::NodeWise,coord); + + + }else{ + TwoLevelPrec->initialize(); + } - TwoLevelPrec->initialize(); + TwoLevelPrec->compute(); //----------------------------------------------- //Prepare for FROSch Epetra Op------------------- From 556d117b5e6e8b70782195cab06d38061437874a Mon Sep 17 00:00:00 2001 From: Alexander Heinlein Date: Wed, 22 Aug 2018 11:04:54 +0200 Subject: [PATCH 14/20] thyra test --- .../shylu/shylu_dd/frosch/test/CMakeLists.txt | 2 ++ .../frosch/test/Thyra_Epetra/CMakeLists.txt | 18 ++++++++++++++++++ .../main5.cpp => test/Thyra_Epetra/main.cpp} | 0 .../stratimikos_ParameterList.xml | 0 4 files changed, 20 insertions(+) create mode 100644 packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/CMakeLists.txt rename packages/shylu/shylu_dd/frosch/{example/stratimikos/main5.cpp => test/Thyra_Epetra/main.cpp} (100%) rename packages/shylu/shylu_dd/frosch/{example/stratimikos => test/Thyra_Epetra}/stratimikos_ParameterList.xml (100%) diff --git a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt index e879fc21e530..cbba1f61346d 100644 --- a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt @@ -6,5 +6,7 @@ ADD_SUBDIRECTORIES( Import_Tpetra LocalPartitionOfUnityBasis # InterfacePartitionOfUnity + Thyra_Epetra TwoLevelPreconditionerInputFiles + ) diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/CMakeLists.txt new file mode 100644 index 000000000000..9df399771f39 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/CMakeLists.txt @@ -0,0 +1,18 @@ +TRIBITS_ADD_EXECUTABLE( + thyra_epetra + SOURCES main.cpp +) + +TRIBITS_COPY_FILES_TO_BINARY_DIR(ThyraEpetraCopyFiles + DEST_FILES stratimikos_ParameterList.xml + SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} + DEST_DIR ${CMAKE_CURRENT_BINARY_DIR} + EXEDEPS thyra_epetra +) + +TRIBITS_ADD_TEST( + thyra_epetra + NAME test_thyra_epetra + COMM mpi + NUM_MPI_PROCS 4 +) \ No newline at end of file diff --git a/packages/shylu/shylu_dd/frosch/example/stratimikos/main5.cpp b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/main.cpp similarity index 100% rename from packages/shylu/shylu_dd/frosch/example/stratimikos/main5.cpp rename to packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/main.cpp diff --git a/packages/shylu/shylu_dd/frosch/example/stratimikos/stratimikos_ParameterList.xml b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml similarity index 100% rename from packages/shylu/shylu_dd/frosch/example/stratimikos/stratimikos_ParameterList.xml rename to packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml From 526490213f57a0d062472e4275b0216540d9929a Mon Sep 17 00:00:00 2001 From: Alexander Heinlein Date: Wed, 22 Aug 2018 12:44:58 +0200 Subject: [PATCH 15/20] fix #1 --- ..._FROSch_TwoLevelPreconditionerFactory_def.hpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp index 2fd8b4112374..9ebe249b080e 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp @@ -73,7 +73,7 @@ namespace Thyra { TEUCHOS_ASSERT(prec); // Create a copy, as we may remove some things from the list - ParameterList paramList = *paramList_; + RCP paramList(new ParameterList(*paramList_)); // AH: Muessen wir diese Kopie machen? Irgendwie wäre es doch besser, wenn man die nicht kopieren müsste, oder? // Retrieve wrapped concrete Xpetra matrix from FwdOp const RCP fwdOp = fwdOpSrc->getOp(); @@ -115,7 +115,7 @@ namespace Thyra { // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); //-------Build New Two Level Prec-------------- - RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); + RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,paramList)); RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); @@ -130,15 +130,15 @@ namespace Thyra { Teuchos::RCP > coord = Teuchos::null; Teuchos::RCP > RepeatedMap = Teuchos::null; - if(paramList.isParameter("Coordinates")){ - coord = FROSch::ExtractCoordinatesFromParameterList(paramList); + if(paramList->isParameter("Coordinates")){ + coord = FROSch::ExtractCoordinatesFromParameterList(*paramList); coord->describe(*fancy,Teuchos::VERB_EXTREME); } - if(paramList.isParameter("RepeatedMap")){ + if(paramList->isParameter("RepeatedMap")){ - RepeatedMap = FROSch::ExtractRepeatedMapFromParameterList(paramList); + RepeatedMap = FROSch::ExtractRepeatedMapFromParameterList(*paramList); RepeatedMap->describe(*fancy,Teuchos::VERB_EXTREME); } @@ -146,7 +146,7 @@ namespace Thyra { if(coord.get()!=NULL && RepeatedMap.get()!=NULL){ - TwoLevelPrec->initialize(paramList.get("Dimension",1),paramList.get("Overlap",1),RepeatedMap,paramList.get("DofsPerNode",1),FROSch::NodeWise,coord); + TwoLevelPrec->initialize(paramList->get("Dimension",1),paramList->get("Overlap",1),RepeatedMap,paramList->get("DofsPerNode",1),FROSch::NodeWise,coord); }else{ @@ -162,7 +162,7 @@ namespace Thyra { TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(epetraTwoLevel)); - RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel,rcpFromRef(paramList))); + RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel,paramList)); Comm->barrier(); /*if(Comm->getRank() ==0){std::cout<<"Create Epetra Op new Constructor\n"; From f0886a53a2081f6f0ee8ee41fca05b9d45c7c6c6 Mon Sep 17 00:00:00 2001 From: Alexander Heinlein Date: Wed, 22 Aug 2018 12:56:06 +0200 Subject: [PATCH 16/20] Use Amesos Klu as subdomain solver --- .../frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml index bdea8d75a619..a4b6a714643b 100644 --- a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml +++ b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml @@ -31,8 +31,8 @@ - - + + From a38eadee8824f2e808faa372b615dadf73fbafe3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Fri, 24 Aug 2018 11:13:31 +0200 Subject: [PATCH 17/20] Thyra_FROSCh_Xpetra --- .../shylu/shylu_dd/frosch/src/CMakeLists.txt | 7 +- .../adapters/FROSch_XpetraOperator_decl.hpp | 104 ++++++ .../adapters/Thyra_FROSchLinearOp_decl.hpp | 146 ++++++++ .../src/adapters/Thyra_FROSchLinearOp_def.hpp | 262 ++++++++++++++ .../Thyra_FROSchXpetraFactory_decl.hpp | 103 ++++++ .../Thyra_FROSchXpetraFactory_def.hpp | 256 ++++++++++++++ .../src/adapters/stratimikos_FROSchXpetra.hpp | 40 +++ .../shylu/shylu_dd/frosch/test/CMakeLists.txt | 1 + .../frosch/test/Thyra_Xpetra/CMakeLists.txt | 18 + .../frosch/test/Thyra_Xpetra/main.cpp | 328 ++++++++++++++++++ .../Thyra_Xpetra/xpetra_ParameterList.xml | 139 ++++++++ 11 files changed, 1403 insertions(+), 1 deletion(-) create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/FROSch_XpetraOperator_decl.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchLinearOp_decl.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchLinearOp_def.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_decl.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_def.hpp create mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_FROSchXpetra.hpp create mode 100644 packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/CMakeLists.txt create mode 100644 packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/main.cpp create mode 100644 packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/xpetra_ParameterList.xml diff --git a/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt index a1d62b3e2758..8e5e822fe871 100644 --- a/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt @@ -115,7 +115,12 @@ APPEND_SET(HEADERS adapters/stratimikos_froschEpetra.hpp adapters/FROSch_EpetraOp_decl.hpp adapters/FROSch_EpetraOp_def.hpp - + adapters/FROSch_XpetraOperator_decl.hpp + adapters/stratimikos_FROSchXpetra.hpp + adapters/Thyra_FROSchLinearOp_decl.hpp + adapters/Thyra_FROSchLinearOp_def.hpp + adapters/Thyra_FROSchXpetraFactory_decl.hpp + adapters/Thyra_FROSchXpetraFactory_def.hpp ) diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_XpetraOperator_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_XpetraOperator_decl.hpp new file mode 100644 index 000000000000..813385d1127a --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_XpetraOperator_decl.hpp @@ -0,0 +1,104 @@ +#ifndef FROSCH_XPETRAOPERATOR_DECL_HPP +#define FROSCH_XPETRAOPERATOR_DECL_HPP + + +#include +#include + +using namespace Teuchos; + +namespace FROSch { + + /*! @brief Wraps an existing MueLu::Hierarchy as a Xpetra::Operator. + */ + template ::scalar_type, + class LocalOrdinal = typename Xpetra::Operator::local_ordinal_type, + class GlobalOrdinal = typename Xpetra::Operator::global_ordinal_type, + class Node = typename Xpetra::Operator::node_type> + class FROSch_XpetraOperator : public Xpetra::Operator { + typedef Xpetra::Matrix Matrix; + typedef FROSch::TwoLevelPreconditioner TwoLevelPrec; + typedef RCP ParameterListPtr; + //protected: + //XpetraOperator() { } + public: + + //! @name Constructor/Destructor + //@{ + + //! Constructor + FROSch_XpetraOperator(const RCP& T) : TwoLevel_(T) { } + + //! Destructor. + virtual ~FROSch_XpetraOperator() { } + + //@} + + //! Returns the Tpetra::Map object associated with the domain of this operator. + Teuchos::RCP > getDomainMap() const { + + return TwoLevel_->getDomainMap(); + } + + //! Returns the Tpetra::Map object associated with the range of this operator. + Teuchos::RCP > getRangeMap() const { + return TwoLevel_->getRangeMap(); + } + + //! Returns in Y the result of a Xpetra::Operator applied to a Xpetra::MultiVector X. + /*! + \param[in] X - Xpetra::MultiVector of dimension NumVectors to multiply with matrix. + \param[out] Y - Xpetra::MultiVector of dimension NumVectors containing result. + */ + void apply(const Xpetra::MultiVector& X, + Xpetra::MultiVector& Y, + Teuchos::ETransp mode = Teuchos::NO_TRANS, + Scalar alpha = Teuchos::ScalarTraits::one(), + Scalar beta = Teuchos::ScalarTraits::one()) const{ + try { + + + // X is supposed to live in the range map of the operator (const rhs = B) + RCP> Xop = Xpetra::MultiVectorFactory::Build(TwoLevel_->getRangeMap(),X.getNumVectors()); + RCP > Yop = Xpetra::MultiVectorFactory::Build(TwoLevel_->getDomainMap(),Y.getNumVectors()); + TEUCHOS_TEST_FOR_EXCEPTION(TwoLevel_->getRangeMap()->isSameAs(*(Xop->getMap())) == false, std::logic_error, + "FROSch::XpetraOperator::apply: map of X is incompatible with range map of TwoLevelPreconditioner"); + TEUCHOS_TEST_FOR_EXCEPTION(TwoLevel_->getDomainMap()->isSameAs(*(Yop->getMap())) == false, std::logic_error, + "FROSch::XpetraOperator::apply: map of Y is incompatible with domain map of TwoLevelPreconditioner"); + + + Y.putScalar(Teuchos::ScalarTraits::zero()); + TwoLevel_->apply(X,Y,NO_TRANS,Teuchos::ScalarTraits::one(),Teuchos::ScalarTraits::zero()); + } catch (std::exception& e) { + + //FIXME add message and rethrow + std::cerr << "Caught an exception in FROSch::XpetraOperator::apply():" << std::endl + << e.what() << std::endl; + } + } + + //! Indicates whether this operator supports applying the adjoint operator. + bool hasTransposeApply() const { return false; } + + template + Teuchos::RCP< FROSch_XpetraOperator > + clone(const RCP& new_node) const { + return Teuchos::rcp (new FROSch_XpetraOperator (TwoLevel_->template clone (new_node))); + } + + //! @name MueLu specific + //@{ + + //! Direct access to the underlying MueLu::Hierarchy. + RCP GetTwoLevelPreconditioner() const { return TwoLevel_; } + + //@} + + private: + RCP TwoLevel_; + }; + +} // namespace + +#endif // MUELU_XPETRAOPERATOR_DECL_HPP + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchLinearOp_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchLinearOp_decl.hpp new file mode 100644 index 000000000000..e2e0490a4ea8 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchLinearOp_decl.hpp @@ -0,0 +1,146 @@ +#ifndef THYRA_FROSCH_LINEAR_OP_DECL_HPP +#define THYRA_FROSCH_LINEAR_OP_DECL_HPP + +#include "Thyra_LinearOpDefaultBase.hpp" +#include "Xpetra_Operator.hpp" +#include "Teuchos_ConstNonconstObjectContainer.hpp" + + +namespace Thyra { + + + /** \brief Concrete Thyra::LinearOpBase subclass for Xpetra::Operator. + * + * \todo Move this to Thyra?? + * + * \ingroup Xpetra_Thyra_Op_Vec_adapters_grp + */ + template + class FROSchLinearOp + : virtual public Thyra::LinearOpDefaultBase + { + public: + + /** \name Constructors/initializers. */ + //@{ + + /** \brief Construct to uninitialized. */ + FROSchLinearOp(); + + /** \brief Initialize. */ + void initialize( + const RCP > &rangeSpace, + const RCP > &domainSpace, + const RCP > &xpetraOperator + ); + + /** \brief Initialize. */ + void constInitialize( + const RCP > &rangeSpace, + const RCP > &domainSpace, + const RCP > &xpetraOperator + ); + + /** \brief Get embedded non-const Xpetra::Operator. */ + RCP > + getXpetraOperator(); + + /** \brief Get embedded const Xpetra::Operator. */ + RCP > + getConstXpetraOperator() const; + + //@} + + /** \name Public Overridden functions from LinearOpBase. */ + //@{ + + /** \brief . */ + RCP > range() const; + + /** \brief . */ + RCP > domain() const; + + //@} + + protected: + + /** \name Protected Overridden functions from LinearOpBase. */ + //@{ + + /** \brief . */ + bool opSupportedImpl(Thyra::EOpTransp M_trans) const; + + /** \brief . */ + void applyImpl( + const Thyra::EOpTransp M_trans, + const Thyra::MultiVectorBase &X_in, + const Teuchos::Ptr > &Y_inout, + const Scalar alpha, + const Scalar beta + ) const; + + //@} + + private: + + RCP > + rangeSpace_; + + RCP > + domainSpace_; + + Teuchos::ConstNonconstObjectContainer > + xpetraOperator_; + + template + void initializeImpl( + const RCP > &rangeSpace, + const RCP > &domainSpace, + const RCP &xpetraOperator + ); + + }; + + + /** \brief Nonmmeber constructor for XpetraLinearOp. + * + * \relates XpetraLinearOp + */ + template + RCP > + fROSchLinearOp( + const RCP > &rangeSpace, + const RCP > &domainSpace, + const RCP > &xpetraOperator + ) + { + const RCP > op = + Teuchos::rcp(new FROSchLinearOp); + op->initialize(rangeSpace, domainSpace, xpetraOperator); + return op; + } + + + /** \brief Nonmmeber constructor for XpetraLinearOp. + * + * \relates XpetraLinearOp + */ + template + RCP > + constFROSchLinearOp( + const RCP > &rangeSpace, + const RCP > &domainSpace, + const RCP > &xpetraOperator + ) + { + const RCP > op = + Teuchos::rcp(new FROSchLinearOp); + op->constInitialize(rangeSpace, domainSpace, xpetraOperator); + return op; + } + +} // namespace Thyra + +#endif // THYRA_XPETRA_LINEAR_OP_DECL_HPP + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchLinearOp_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchLinearOp_def.hpp new file mode 100644 index 000000000000..e145533882c7 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchLinearOp_def.hpp @@ -0,0 +1,262 @@ +#ifndef THYRA_FROSCH_LINEAR_OP_HPP +#define THYRA_FROSCH_LINEAR_OP_HPP +#include "Thyra_EpetraLinearOp.hpp" +#include "Thyra_EpetraThyraWrappers.hpp" +#include "Thyra_SpmdMultiVectorBase.hpp" +#include "Thyra_MultiVectorStdOps.hpp" +#include "Thyra_AssertOp.hpp" +#include "Teuchos_dyn_cast.hpp" +#include "Teuchos_Assert.hpp" +#include "Teuchos_getConst.hpp" +#include "Teuchos_as.hpp" +#include "Teuchos_TimeMonitor.hpp" +# +#include "Thyra_FROSchLinearOp_decl.hpp" +#include "Teuchos_ScalarTraits.hpp" +#include +#include "Teuchos_TypeNameTraits.hpp" +#include +#include "FROSch_XpetraOperator_decl.hpp" +#include "Xpetra_MapExtractor.hpp" +#include +#include +#include +#include + +#include "Epetra_Map.h" +#include "Epetra_Vector.h" +#include "Epetra_Operator.h" +#include "Epetra_CrsMatrix.h" + +#include "Thyra_LinearOpBase.hpp" +#include "Thyra_EpetraLinearOpBase.hpp" +#include "Thyra_ScaledLinearOpBase.hpp" +#include "Thyra_RowStatLinearOpBase.hpp" +#include "Thyra_SpmdVectorSpaceBase.hpp" + +#include "Epetra_RowMatrix.h" + + +#include "Thyra_EpetraThyraWrappers.hpp" + +using namespace std; +using namespace Teuchos; +using namespace Xpetra; +using namespace FROSch; +using namespace Belos; +namespace Thyra { + + + // Constructors/initializers + + + template + FROSchLinearOp::FROSchLinearOp() + {} + + + template + void FROSchLinearOp::initialize( + const RCP > &rangeSpace, + const RCP > &domainSpace, + const RCP > &xpetraOperator + ) + { + initializeImpl(rangeSpace, domainSpace, xpetraOperator); + } + + + template + void FROSchLinearOp::constInitialize( + const RCP > &rangeSpace, + const RCP > &domainSpace, + const RCP > &xpetraOperator + ) + { + initializeImpl(rangeSpace, domainSpace, xpetraOperator); + } + + + template + RCP > + FROSchLinearOp::getXpetraOperator() + { + return xpetraOperator_.getNonconstObj(); + } + + + template + RCP > + FROSchLinearOp::getConstXpetraOperator() const + { + return xpetraOperator_; + } + + + // Public Overridden functions from LinearOpBase + + + template + RCP > + FROSchLinearOp::range() const + { + return rangeSpace_; + } + + + template + RCP > + FROSchLinearOp::domain() const + { + return domainSpace_; + } + + // Protected Overridden functions from LinearOpBase + + template + bool FROSchLinearOp::opSupportedImpl( + Thyra::EOpTransp M_trans) const + { + if (is_null(xpetraOperator_)) + return false; + + if (M_trans == NOTRANS) + return true; + + if (M_trans == CONJ) { + // For non-complex scalars, CONJ is always supported since it is equivalent to NO_TRANS. + // For complex scalars, Xpetra does not support conjugation without transposition. + return !Teuchos::ScalarTraits::isComplex; + } + + return xpetraOperator_->hasTransposeApply(); + } + + + template + void FROSchLinearOp::applyImpl( + const Thyra::EOpTransp M_trans, + const Thyra::MultiVectorBase &X_in, + const Teuchos::Ptr > &Y_inout, + const Scalar alpha, + const Scalar beta + ) const + { + using Teuchos::rcpFromRef; + using Teuchos::rcpFromPtr; + + const EOpTransp real_M_trans = real_trans(M_trans); + + TEUCHOS_TEST_FOR_EXCEPTION(getConstXpetraOperator() == Teuchos::null, MueLu::Exceptions::RuntimeError, "XpetraLinearOp::applyImpl: internal Xpetra::Operator is null."); + RCP< const Teuchos::Comm > comm = getConstXpetraOperator()->getRangeMap()->getComm(); + + + const RCP > XY_domain = X_in.domain(); + const int numCols = XY_domain->dim(); + + Teuchos::RCP > DomainM = this->xpetraOperator_->getDomainMap(); + + Teuchos::RCP >RangeM = this->xpetraOperator_->getRangeMap(); + + RCP > eDomainM = Teuchos::rcp_dynamic_cast >(DomainM); + + const Epetra_Map epetraDomain = eDomainM->getEpetra_Map(); + + RCP > eRangeM = Teuchos::rcp_dynamic_cast >(RangeM); + + const Epetra_Map epetraRange = eRangeM->getEpetra_Map(); + + RCP X; + + RCP Y; + + comm->barrier(); + comm->barrier(); + comm->barrier(); + if(comm->getRank() == 0) std::cout<<"FROSchLinearOP XXin (134)\n"; + THYRA_FUNC_TIME_MONITOR_DIFF( + "Thyra::EpetraLinearOp::euclideanApply: Convert MultiVectors", MultiVectors); + // X + X = Thyra::get_Epetra_MultiVector(real_M_trans==NOTRANS ? epetraDomain: epetraRange, X_in ); + RCP X_nonconst = Teuchos::rcp_const_cast(X); + RCP > xX = FROSch::ConvertToXpetra(UseEpetra,*X_nonconst,comm); + // Y + Y = Thyra::get_Epetra_MultiVector(real_M_trans==NOTRANS ? epetraRange: epetraDomain, *Y_inout ); + RCP > xY = FROSch::ConvertToXpetra(UseEpetra,*Y,comm); + + Teuchos::ETransp transp; + switch (M_trans) { + case NOTRANS: transp = Teuchos::NO_TRANS; break; + case TRANS: transp = Teuchos::TRANS; break; + case CONJTRANS: transp = Teuchos::CONJ_TRANS; break; + default: TEUCHOS_TEST_FOR_EXCEPTION(true, MueLu::Exceptions::NotImplemented, "Thyra::XpetraLinearOp::apply. Unknown value for M_trans. Only NOTRANS, TRANS and CONJTRANS are supported."); + } + + xpetraOperator_->apply(*xX, *xY, transp, alpha, beta); + + + + comm->barrier(); + comm->barrier(); + comm->barrier(); + if(comm->getRank() == 0) std::cout<<"FROSchLinearOP update (lin186)\n"; + + RCP >thyraX = + Teuchos::rcp_const_cast >(Xpetra::ThyraUtils::toThyraMultiVector(xY)); + + // copy back Xpetra results from tY to Thyra vector Y + /*Xpetra::ThyraUtils::updateThyra( + xY_in, + rgMapExtractor, + Teuchos::rcpFromPtr(Y_inout));*/ + typedef Thyra::SpmdVectorSpaceBase ThySpmdVecSpaceBase; + RCP mpi_vs = rcp_dynamic_cast(Teuchos::rcpFromPtr(Y_inout)->range()); + + TEUCHOS_TEST_FOR_EXCEPTION(mpi_vs == Teuchos::null, std::logic_error, "Failed to cast Thyra::VectorSpaceBase to Thyra::SpmdVectorSpaceBase."); + const LocalOrdinal localOffset = ( mpi_vs != Teuchos::null ? mpi_vs->localOffset() : 0 ); + const LocalOrdinal localSubDim = ( mpi_vs != Teuchos::null ? mpi_vs->localSubDim() : Teuchos::rcpFromPtr(Y_inout)->range()->dim() ); + + RCP > thyData = + Teuchos::rcp(new Thyra::DetachedMultiVectorView(*Teuchos::rcpFromPtr(Y_inout),Teuchos::Range1D(localOffset,localOffset+localSubDim-1))); + + for(size_t j = 0; j getNumVectors(); ++j) { + Teuchos::ArrayRCP< const Scalar > xpData = xY->getData(j); // access const data from Xpetra object + // loop over all local rows + for(LocalOrdinal i = 0; i < localSubDim; ++i) { + (*thyData)(i,j) = xpData[i]; + } + } + + + + } + + + // private + + + template + template + void FROSchLinearOp::initializeImpl( + const RCP > &rangeSpace, + const RCP > &domainSpace, + const RCP &xpetraOperator + ) + { + +#ifdef THYRA_DEBUG + TEUCHOS_ASSERT(nonnull(rangeSpace)); + TEUCHOS_ASSERT(nonnull(domainSpace)); + TEUCHOS_ASSERT(nonnull(xpetraOperator)); +#endif + rangeSpace_ = rangeSpace; + domainSpace_ = domainSpace; + xpetraOperator_ = xpetraOperator; + } + + +} // namespace Thyra + + +#endif // THYRA_XPETRA_LINEAR_OP_HPP diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_decl.hpp new file mode 100644 index 000000000000..83f86e70547c --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_decl.hpp @@ -0,0 +1,103 @@ +#ifndef THYRA_FROSCH_XPETRA_FACTORY_DECL_HPP +#define THYRA_FROSCH_XPETRA_FACTORY_DECL_HPP + + +// Stratimikos needs Thyra, so we don't need special guards for Thyra here +#include "Thyra_DefaultPreconditioner.hpp" +#include "Thyra_BlockedLinearOpBase.hpp" +#include "Thyra_XpetraLinearOp.hpp" +#ifdef HAVE_MUELU_TPETRA +#include "Thyra_TpetraLinearOp.hpp" +#include "Thyra_TpetraThyraWrappers.hpp" +#endif +#include "Thyra_EpetraLinearOp.hpp" +#include "Thyra_TpetraLinearOp.hpp" +#include "Thyra_TpetraThyraWrappers.hpp" + +#include "Teuchos_Ptr.hpp" +#include "Teuchos_TestForException.hpp" +#include "Teuchos_Assert.hpp" +#include "Teuchos_Time.hpp" + +#include +#include +#include +#include +//PUT FROSch includes here + +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_RCP.hpp" +#include "Teuchos_ArrayRCP.hpp" +#include "Teuchos_Array.hpp" + +#include +#include +//#include +#include +#include + +#include +#include +#include + + +//#include +#include +#include +#include "FROSch_XpetraOperator_decl.hpp" +#include "Thyra_FROSchLinearOP_def.hpp" +#include +// + +#include "Thyra_PreconditionerFactoryBase.hpp" + +#include "Kokkos_DefaultNode.hpp" + +namespace Thyra { + + template + class FROSch_XpetraFactory:public Thyra::PreconditionerFactoryBase{ + public: + + //Constructor + FROSch_XpetraFactory(); + + //Overridden from PreconditionerFactory Base + bool isCompatible(const LinearOpSourceBase& fwdOp) const; + + Teuchos::RCP > createPrec() const; + + void initializePrec(const Teuchos::RCP >& fwdOpSrc, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const; + + void uninitializePrec(PreconditionerBase* prec, + Teuchos::RCP >* fwdOp, + ESupportSolveUse* supportSolveUse + ) const; + + void setParameterList(const Teuchos::RCP& paramList); + + Teuchos::RCP unsetParameterList(); + + Teuchos::RCP getNonconstParameterList(); + + Teuchos::RCP getParameterList() const; + + Teuchos::RCP getValidParameters() const; + + std::string description() const; + private: + Teuchos::RCP paramList_; + + + + }; +} + + + +#endif + + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_def.hpp new file mode 100644 index 000000000000..c37dc27f208a --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_def.hpp @@ -0,0 +1,256 @@ +#ifndef THYRA_FROSCH_XPETRA_FACTORY_DEF_HPP +#define THYRA_FROSCH_XPETRA_DEF_HPP + +#include "Thyra_FROSchXpetraFactory_decl.hpp" + +#include +#include + + +#include +#include + + +namespace Thyra { + using Teuchos::RCP; + using Teuchos::rcp; + using Teuchos::ParameterList; + + //Constructor + template + FROSch_XpetraFactory::FROSch_XpetraFactory() + + + + + + + { + paramList_ = rcp(new Teuchos::ParameterList()); + } + //----------------------------------------------------------- + template + bool FROSch_XpetraFactory::isCompatible(const LinearOpSourceBase& fwdOpSrc) const + { + const RCP > fwdOp = fwdOpSrc.getOp(); + //so far only Epetra is allowed + if (Xpetra::ThyraUtils::isEpetra(fwdOp)) return true; + + return false; + } + //-------------------------------------------------------------- + template + RCP >FROSch_XpetraFactory::createPrec() const{ + return Teuchos::rcp(new DefaultPreconditioner); + + } + //------------------------------------------------------------- + template + void FROSch_XpetraFactory::initializePrec + (const Teuchos::RCP >& fwdOpSrc, + PreconditionerBase* prec, + const ESupportSolveUse supportSolveUse + ) const{ + + Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); + + + using Teuchos::rcp_dynamic_cast; + //Some Typedefs + typedef Xpetra::Map XpMap; + typedef Xpetra::Operator XpOp; + typedef Xpetra::ThyraUtils XpThyUtils; + typedef Xpetra::CrsMatrix XpCrsMat; + typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; + typedef Xpetra::Matrix XpMat; + typedef Xpetra::MultiVector XpMultVec; + typedef Xpetra::MultiVector XpMultVecDouble; + typedef Thyra::LinearOpBase ThyLinOpBase; + typedef Thyra::EpetraLinearOp ThyEpLinOp; + + + + + + + //PreCheck + TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); + //TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); + TEUCHOS_ASSERT(prec); + + // Create a copy, as we may remove some things from the list + RCP paramList(new ParameterList(*paramList_)); // AH: Muessen wir diese Kopie machen? Irgendwie wäre es doch besser, wenn man die nicht kopieren müsste, oder? + + // Retrieve wrapped concrete Xpetra matrix from FwdOp + const RCP fwdOp = fwdOpSrc->getOp(); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); + + // Check whether it is Epetra/Tpetra + bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); + bool bIsTpetra = XpThyUtils::isTpetra(fwdOp); + bool bIsBlocked = XpThyUtils::isBlockedOperator(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == true && bIsTpetra == true)); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == bIsTpetra) && bIsBlocked == false); + TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); + + RCP A = Teuchos::null; + RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); + + // FROSCH needs a non-const object as input + RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); + + // wrap the forward operator as an Xpetra::Matrix that FROSch can work with + A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); + //A->describe(*fancy,Teuchos::VERB_EXTREME); + + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); + + // Retrieve concrete preconditioner object--->Here Mem Leak? + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + // extract preconditioner operator + RCP thyra_precOp = Teuchos::null; + thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); + + //Later needs to be a utility ExtractCoordinatesFromParameterList + //not implemented yet + // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); + + //-------Build New Two Level Prec-------------- + RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,paramList)); + + + RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); + Comm->barrier(); + /*if(Comm->getRank() ==0){std::cout<<"Create Epetra Op new Constructor\n"; + + cout << "--------------------------------------------------------------------------------\nPARAMETERS Two Level Precon Factory:" << endl; + paramList.print(std::cout); + cout << "--------------------------------------------------------------------------------\n\n"; + + }*/ + Teuchos::RCP > coord = Teuchos::null; + Teuchos::RCP > RepeatedMap = Teuchos::null; + + if(paramList->isParameter("Coordinates")){ + coord = FROSch::ExtractCoordinatesFromParameterList(*paramList); + coord->describe(*fancy,Teuchos::VERB_EXTREME); + + } + + if(paramList->isParameter("RepeatedMap")){ + + RepeatedMap = FROSch::ExtractRepeatedMapFromParameterList(* + paramList); + RepeatedMap->describe(*fancy,Teuchos::VERB_EXTREME); + + } + + if(coord.get()!=NULL && RepeatedMap.get()!=NULL){ + + + TwoLevelPrec->initialize(paramList->get("Dimension",1),paramList->get("Overlap",1),RepeatedMap,paramList->get("DofsPerNode",1),FROSch::NodeWise,coord); + + + + }else{ + TwoLevelPrec->initialize(); + } + + + TwoLevelPrec->compute(); + //----------------------------------------------- + //FROSCh_XpetraOP + RCP > froschXOP (new FROSch_XpetraOperator(TwoLevelPrec)); + + + RCP thyraPrecOp = Teuchos::null; + + // RCP frosch_epetraop(new FROSch::FROSch_EpetraOperator(A,rcpFromRef(paramList))) + ; + + RCP > thyraRangeSpace = Xpetra::ThyraUtils::toThyra(froschXOP->getRangeMap()); + RCP > thyraDomainSpace = Xpetra::ThyraUtils::toThyra(froschXOP->getDomainMap()); + + RCP > xpOp = Teuchos::rcp_dynamic_cast >(froschXOP); + thyraPrecOp = Thyra::fROSchLinearOp(thyraRangeSpace, thyraDomainSpace,xpOp); + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyraPrecOp)); + + defaultPrec->initializeUnspecified(thyraPrecOp); + + } + //------------------------------------------------------------- + template + void FROSch_XpetraFactory:: + uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { + TEUCHOS_ASSERT(prec); + + // Retrieve concrete preconditioner object + const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); + + if (fwdOp) { + // TODO: Implement properly instead of returning default value + *fwdOp = Teuchos::null; + } + + if (supportSolveUse) { + // TODO: Implement properly instead of returning default value + *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; + } + + defaultPrec->uninitialize(); + } + //----------------------------------------------------------------- + template + void FROSch_XpetraFactory::setParameterList(RCP const & paramList){ + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); + paramList_ = paramList; + } + + //------------------------------------------------------------------ + template + RCP FROSch_XpetraFactory::getNonconstParameterList(){ + return paramList_; + + } + + //----------------------------------------------------------------------- + template + RCP + FROSch_XpetraFactory::getParameterList() const { + return paramList_; + } + //-------------------------------------------------------------------- + template + RCP FROSch_XpetraFactory::getValidParameters() const { + static RCP validPL; + + if (Teuchos::is_null(validPL)) + validPL = rcp(new ParameterList()); + + return validPL; + } + //----------------------------------------------------------------------- + template + std::string FROSch_XpetraFactory::description() const { + return "Thyra::FROSch_XpetraFactory"; + } + //-------------------------------------------------------------------------- + template + RCP FROSch_XpetraFactory::unsetParameterList(){ + RCP savedParamList = paramList_; + paramList_ = Teuchos::null; + return savedParamList; + + } + +} +#endif + + diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_FROSchXpetra.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_FROSchXpetra.hpp new file mode 100644 index 000000000000..09d75fe80ced --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_FROSchXpetra.hpp @@ -0,0 +1,40 @@ + + +#include "Stratimikos_DefaultLinearSolverBuilder.hpp" + +#include "Thyra_FROSchXpetraFactory_decl.hpp" + + + +#include "Teuchos_RCP.hpp" +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_TestForException.hpp" +#include "Teuchos_AbstractFactoryStd.hpp" + +#include +#include "Kokkos_DefaultNode.hpp" + + +namespace Stratimikos { + + template + void enableXpetraFROSch + (DefaultLinearSolverBuilder& builder, const std::string& stratName = "FROSchXpetra") + { + const Teuchos::RCP precValidParams = Teuchos::sublist(builder.getValidParameters(), "Preconditioner Types"); + + TEUCHOS_TEST_FOR_EXCEPTION(precValidParams->isParameter(stratName), std::logic_error, + "Stratimikos::enableFROSch_TwoLevel cannot add \"" + stratName +"\" because it is already included in builder!"); + + typedef Thyra::PreconditionerFactoryBase Base; + typedef Thyra::FROSch_XpetraFactory Impl; + + builder.setPreconditioningStrategyFactory(Teuchos::abstractFactoryStd(), stratName); + } + + + +} // namespace Stratimikos + + + diff --git a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt index cbba1f61346d..e7f2f8e62b44 100644 --- a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt @@ -8,5 +8,6 @@ ADD_SUBDIRECTORIES( # InterfacePartitionOfUnity Thyra_Epetra TwoLevelPreconditionerInputFiles + Thyra_Xpetra ) diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/CMakeLists.txt new file mode 100644 index 000000000000..c09768cdd1d2 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/CMakeLists.txt @@ -0,0 +1,18 @@ +TRIBITS_ADD_EXECUTABLE( + thyra_xpetra + SOURCES main.cpp +) + +TRIBITS_COPY_FILES_TO_BINARY_DIR(ThyraXpetraCopyFiles + DEST_FILES xpetra_ParameterList.xml + SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} + DEST_DIR ${CMAKE_CURRENT_BINARY_DIR} + EXEDEPS thyra_xpetra +) + +TRIBITS_ADD_TEST( + thyra_xpetra + NAME test_thyra_xpetra + COMM mpi + NUM_MPI_PROCS 4 +) \ No newline at end of file diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/main.cpp b/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/main.cpp new file mode 100644 index 000000000000..631ae92d9c13 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/main.cpp @@ -0,0 +1,328 @@ + +#include +#include + +#include +#include + +#include +#include +#include "Galeri_Utils.h" + + +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include + +// Thyra includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Stratimikos includes +#include +#include +#include "stratimikos_FROSchXpetra.hpp" +//#include "stratimikos_froschEpetra.hpp" + +// Xpetra include +#include + +// FROSCH thyra includes +#include +//#include "Thyra_FROSchEpetraPreconFactory_decl.hpp" +#include "Frosch_EpetraOp_def.hpp" +#include "Thyra_FROSchLinearOp_def.hpp" +#include "Thyra_FROSchXpetraFactory_def.hpp" + +typedef unsigned UN; +typedef double SC; +typedef int LO; +typedef int GO; +typedef Kokkos::Compat::KokkosSerialWrapperNode EpetraNode; // Hier Default verwenden??? +typedef EpetraNode NO; + +using namespace std; +using namespace Teuchos; +using namespace Xpetra; +using namespace FROSch; +using namespace Belos; + +int main(int argc, char *argv[]) +{ + MPI_Init(&argc,&argv); + + { + Epetra_MpiComm CommWorld(MPI_COMM_WORLD); + + CommandLineProcessor My_CLP; + + Teuchos::RCP + + out = Teuchos::VerboseObjectBase::getDefaultOStream(); + + int M = 4; + My_CLP.setOption("M",&M,"H / h."); + int Dimension = 2; + My_CLP.setOption("Dim",&Dimension,"Dimension."); + int Overlap = 1; + My_CLP.setOption("Overlap",&Overlap,"Overlap."); + int DofsPerNode = 1; + My_CLP.setOption("DPN",&DofsPerNode,"Dofs per node."); + int DOFOrdering = 0; + My_CLP.setOption("Ordering",&DOFOrdering,"Dofs ordering (NodeWise=0,DimensionWise=1,Custom=2)."); + string xmlFile = "xpetra_ParameterList.xml"; + My_CLP.setOption("List",&xmlFile,"File name of the parameter list."); + + My_CLP.recogniseAllOptions(true); + My_CLP.throwExceptions(false); + CommandLineProcessor::EParseCommandLineReturn parseReturn = My_CLP.parse(argc,argv); + if(parseReturn == CommandLineProcessor::PARSE_HELP_PRINTED) { + MPI_Finalize(); + return 0; + } + + int N; + MPI_Comm COMM; + int color=1; + //bool onFirstLevelComm=false; + if (Dimension == 2) { + N = (int) (pow(CommWorld.NumProc(),1/2.) + 100*numeric_limits::epsilon()); // 1/H + if (CommWorld.MyPID()::epsilon()); // 1/H + if (CommWorld.MyPID() Comm(new Epetra_MpiComm(COMM)); + RCP > TeuchosComm = rcp(new MpiComm (COMM)); + if (color==0) { + + RCP parameterList = getParametersFromXmlFile(xmlFile); + + if(Comm->MyPID()==0) { + cout << "--------------------------------------------------------------------------------\nPARAMETERS:" << endl; + parameterList->print(cout); + cout << "--------------------------------------------------------------------------------\n\n"; + } + + if (Comm->MyPID()==0) cout << "----------------ASSEMBLY-----------\n"; + + ParameterList GalerList; + GalerList.set("nx", N*M); + GalerList.set("ny", N*M); + GalerList.set("nz", N*M); + GalerList.set("mx", N); + GalerList.set("my", N); + GalerList.set("mz", N); + + RCP UniqueMapEpetra; + RCP KEpetra; + Teuchos::RCP epCoord = Teuchos::null; + + if (Dimension==2) { + UniqueMapEpetra.reset(Galeri::CreateMap("Cartesian2D", *Comm, GalerList)); + KEpetra.reset(Galeri::CreateCrsMatrix("Laplace2D", UniqueMapEpetra.get(), GalerList)); + epCoord = Teuchos::rcp(Galeri::CreateCartesianCoordinates("2D", UniqueMapEpetra.get(), GalerList)); + + } else if (Dimension==3) { + UniqueMapEpetra.reset(Galeri::CreateMap("Cartesian3D", *Comm, GalerList)); + KEpetra.reset(Galeri::CreateCrsMatrix("Laplace3D", UniqueMapEpetra.get(), GalerList)); + epCoord = Teuchos::rcp(Galeri::CreateCartesianCoordinates("3D", UniqueMapEpetra.get(), GalerList)); + } + + RCP > UniqueMap; + RCP > K; + DofOrdering Ord; + + if (DOFOrdering == 0) { + Ord = NodeWise; + Array uniqueMapArray(DofsPerNode*UniqueMapEpetra->NumMyElements()); + for (LO i=0; iNumMyElements(); i++) { + for (LO j=0; jGID(i)+j; + } + } + + UniqueMap = MapFactory::Build(UseEpetra,-1,uniqueMapArray(),0,TeuchosComm); + K = MatrixFactory::Build(UniqueMap,KEpetra->MaxNumEntries()); + for (LO i=0; iNumMyElements(); i++) { + LO numEntries; + GO* indices; + SC* values; + KEpetra->ExtractMyRowView(i,numEntries,values,indices); + + for (LO j=0; j indicesArray(numEntries); + ArrayView valuesArrayView(values,numEntries); + for (LO k=0; kColMap().GID(indices[k])+j; + } + K->insertGlobalValues(DofsPerNode*KEpetra->RowMap().GID(i)+j,indicesArray(),valuesArrayView); + } + } + K->fillComplete(); + } else if (DOFOrdering == 1) { + Ord = DimensionWise; + Array uniqueMapArray(DofsPerNode*UniqueMapEpetra->NumMyElements()); + for (LO i=0; iNumMyElements(); i++) { + for (LO j=0; jNumMyElements()*j] = UniqueMapEpetra->GID(i)+(UniqueMapEpetra->MaxAllGID()+1)*j; + } + } + + UniqueMap = MapFactory::Build(UseEpetra,-1,uniqueMapArray(),0,TeuchosComm); + K = MatrixFactory::Build(UniqueMap,KEpetra->MaxNumEntries()); + for (LO i=0; iNumMyElements(); i++) { + LO numEntries; + GO* indices; + SC* values; + KEpetra->ExtractMyRowView(i,numEntries,values,indices); + + for (LO j=0; j indicesArray(numEntries); + ArrayView valuesArrayView(values,numEntries); + for (LO k=0; kColMap().GID(indices[k])+(KEpetra->ColMap().MaxAllGID()+1)*j; + } + K->insertGlobalValues(UniqueMapEpetra->GID(i)+(UniqueMapEpetra->MaxAllGID()+1)*j,indicesArray(),valuesArrayView); + } + } + K->fillComplete(); + } else if (DOFOrdering == 2) { + assert(0!=0); // TODO: Andere Sortierung implementieren + } else { + assert(0!=0); + } + // RCP fancy = fancyOStream(rcpFromRef(std::cout)); UniqueMap->describe(*fancy,Teuchos::VERB_EXTREME); UniqueMap->getComm()->barrier(); UniqueMap->getComm()->barrier(); + + + RCP > xSolution = MultiVectorFactory::Build(UniqueMap,1); + RCP > xRightHandSide = MultiVectorFactory::Build(UniqueMap,1); + + xSolution->putScalar(0.0); + xRightHandSide->putScalar(1.0); + + auto lows_factory = Thyra::BelosLinearOpWithSolveFactory (); + auto pl = Teuchos::rcp(new Teuchos::ParameterList()); + pl->set("Solver Type", "Block GMRES"); + Teuchos::ParameterList& solver_pl = pl->sublist("Solver Types").sublist("Block GMRES"); + solver_pl.set("Convergence Tolerance", 1e-6); + solver_pl.set("Maximum Iterations", 100); + solver_pl.set("Num Blocks", 1); + lows_factory.setParameterList(pl); + lows_factory.setVerbLevel(Teuchos::VERB_HIGH); + //auto lows = lows_factory.createOp(); + + Teuchos::RCP > exA = Teuchos::rcp(new Xpetra::EpetraCrsMatrixT(KEpetra)); + Teuchos::RCP > exAWrap = Teuchos::rcp(new CrsMatrixWrap (exA)); + + RCP >Coord = ConvertToXpetra(UseEpetra,*epCoord,TeuchosComm); + + RCP > RepMapX = FROSch::BuildRepeatedMap(K); + + + + + + + + + + RCP > K_thyra = Xpetra::ThyraUtils::toThyra(exAWrap->getCrsMatrix()); + RCP >thyraX = + Teuchos::rcp_const_cast >(Xpetra::ThyraUtils::toThyraMultiVector(xSolution)); + RCP >thyraB = Xpetra::ThyraUtils::toThyraMultiVector(xRightHandSide); + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + + //This Basic solve without Preconditioner + //Thyra::initializeOp(lows_factory, K_thyra, lows.ptr()); + //auto status = Thyra::solve(*lows, Thyra::NOTRANS, *thyraB, thyraX.ptr()); + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------Stratimikos LinearSolverBuilder-----------\n"; + + // RCP plList = sublist(parameterList,"Preconditioner Types"); + // sublist(plList,"TwoLevelPreconditioner")->set("Coordinates",Coord); + // sublist(plList,"TwoLevelPreconditioner")->set("RepeatedMap",RepMapX); + + Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder; + Stratimikos::enableXpetraFROSch(linearSolverBuilder); + + linearSolverBuilder.setParameterList(parameterList); + + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------Thyra PrepForSolve-----------\n"; + + + + RCP > lowsFactory = + linearSolverBuilder.createLinearSolveStrategy(""); + + lowsFactory->setOStream(out); + lowsFactory->setVerbLevel(Teuchos::VERB_HIGH); + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + if (Comm->MyPID()==0) cout << "----------------Thyra LinearOpWithSolve-----------\n"; + + RCP > lows = + Thyra::linearOpWithSolve(*lowsFactory, K_thyra); + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + if (Comm->MyPID()==0) cout << "----------------Solve-----------\n"; + Thyra::SolveStatus status = + Thyra::solve(*lows, Thyra::NOTRANS, *thyraB, thyraX.ptr()); + + Comm->Barrier(); + if (Comm->MyPID()==0) cout << "----------------done-----------\n"; + + } + MPI_Comm_free(&COMM); + + } + + MPI_Finalize(); + + return(EXIT_SUCCESS); + +} + + + diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/xpetra_ParameterList.xml b/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/xpetra_ParameterList.xml new file mode 100644 index 000000000000..a6a372ec0b64 --- /dev/null +++ b/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/xpetra_ParameterList.xml @@ -0,0 +1,139 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 9422dc9fdb01e20c503a38caef9936a7623f684a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Mon, 27 Aug 2018 06:51:10 +0200 Subject: [PATCH 18/20] Eliminate Epetra Version->Files located at src/adapters/Epetra --- .../shylu/shylu_dd/frosch/src/CMakeLists.txt | 12 - .../{ => Epetra}/FROSch_EpetraOp_decl.hpp | 0 .../{ => Epetra}/FROSch_EpetraOp_def.hpp | 0 .../Stratimikos_FROSchHelpers.hpp | 0 ...Sch_TwoLevelPreconditionerFactory_decl.hpp | 0 ...OSch_TwoLevelPreconditionerFactory_def.hpp | 0 .../adapters/FROSch_PreconFactory_decl.hpp | 103 ------ .../src/adapters/FROSch_PreconFactory_def.hpp | 194 ----------- .../src/adapters/Stratimikos_FROSchHelp.hpp | 30 -- .../adapters/Stratimikos_FROSchHelpers.cpp | 0 .../Thyra_FROSchEpetraPreconFactory_decl.hpp | 310 ------------------ .../Thyra_FROSchEpetraPreconFactory_def.hpp | 229 ------------- .../src/adapters/stratimikos_froschEpetra.hpp | 36 -- .../shylu/shylu_dd/frosch/test/CMakeLists.txt | 1 - .../frosch/test/Thyra_Epetra/CMakeLists.txt | 18 - .../frosch/test/Thyra_Epetra/main.cpp | 303 ----------------- .../stratimikos_ParameterList.xml | 139 -------- 17 files changed, 1375 deletions(-) rename packages/shylu/shylu_dd/frosch/src/adapters/{ => Epetra}/FROSch_EpetraOp_decl.hpp (100%) rename packages/shylu/shylu_dd/frosch/src/adapters/{ => Epetra}/FROSch_EpetraOp_def.hpp (100%) rename packages/shylu/shylu_dd/frosch/src/adapters/{ => Epetra}/Stratimikos_FROSchHelpers.hpp (100%) rename packages/shylu/shylu_dd/frosch/src/adapters/{ => Epetra}/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp (100%) rename packages/shylu/shylu_dd/frosch/src/adapters/{ => Epetra}/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp (100%) delete mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_decl.hpp delete mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_def.hpp delete mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelp.hpp delete mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.cpp delete mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp delete mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp delete mode 100644 packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp delete mode 100644 packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/CMakeLists.txt delete mode 100644 packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/main.cpp delete mode 100644 packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml diff --git a/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt index 8e5e822fe871..0e5dc1309bfd 100644 --- a/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/src/CMakeLists.txt @@ -104,17 +104,6 @@ APPEND_SET(HEADERS Tools/FROSch_SubdomainSolver_def.hpp Tools/FROSch_Tools_decl.hpp Tools/FROSch_Tools_def.hpp - adapters/FROSch_PreconFactory_decl.hpp - adapters/FROSch_PreconFactory_def.hpp - adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp - adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp - adapters/Stratimikos_FROSchHelp.hpp - adapters/Stratimikos_FROSchHelpers.hpp - adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp - adapters/Thyra_FROSchEpetraPreconFactory_def.hpp - adapters/stratimikos_froschEpetra.hpp - adapters/FROSch_EpetraOp_decl.hpp - adapters/FROSch_EpetraOp_def.hpp adapters/FROSch_XpetraOperator_decl.hpp adapters/stratimikos_FROSchXpetra.hpp adapters/Thyra_FROSchLinearOp_decl.hpp @@ -128,7 +117,6 @@ APPEND_SET(HEADERS APPEND_SET(SOURCES dummy.cpp - adapters/Stratimikos_FROSchHelpers.cpp ) TRIBITS_ADD_LIBRARY( diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Epetra/FROSch_EpetraOp_decl.hpp similarity index 100% rename from packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_decl.hpp rename to packages/shylu/shylu_dd/frosch/src/adapters/Epetra/FROSch_EpetraOp_decl.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Epetra/FROSch_EpetraOp_def.hpp similarity index 100% rename from packages/shylu/shylu_dd/frosch/src/adapters/FROSch_EpetraOp_def.hpp rename to packages/shylu/shylu_dd/frosch/src/adapters/Epetra/FROSch_EpetraOp_def.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Epetra/Stratimikos_FROSchHelpers.hpp similarity index 100% rename from packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.hpp rename to packages/shylu/shylu_dd/frosch/src/adapters/Epetra/Stratimikos_FROSchHelpers.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Epetra/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp similarity index 100% rename from packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp rename to packages/shylu/shylu_dd/frosch/src/adapters/Epetra/Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Epetra/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp similarity index 100% rename from packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp rename to packages/shylu/shylu_dd/frosch/src/adapters/Epetra/Thyra_FROSch_TwoLevelPreconditionerFactory_def.hpp diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_decl.hpp deleted file mode 100644 index a2a4e5318c33..000000000000 --- a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_decl.hpp +++ /dev/null @@ -1,103 +0,0 @@ -#ifndef FROSCH_PRECONFACTORY_HPP -#define FROSCH_PRECONFACTORY_HPP - -#include "Thyra_DefaultPreconditioner.hpp" -#include "Thyra_BlockedLinearOpBase.hpp" -#include "Thyra_XpetraLinearOp.hpp" - - -#include "Thyra_EpetraLinearOp.hpp" -#include "Thyra_TpetraLinearOp.hpp" -#include "Thyra_TpetraThyraWrappers.hpp" - -#include "Teuchos_Ptr.hpp" -#include "Teuchos_TestForException.hpp" -#include "Teuchos_Assert.hpp" -#include "Teuchos_Time.hpp" - -#include -#include -#include -#include - -#include "Teuchos_ParameterList.hpp" -#include "Teuchos_RCP.hpp" -#include "Teuchos_ArrayRCP.hpp" -#include "Teuchos_Array.hpp" - -#include -#include -#include -#include -#include - -#include -#include -#include - - -//#include -#include -#include - -#include -#include -// - -#include "Thyra_PreconditionerFactoryBase.hpp" - -#include "Kokkos_DefaultNode.hpp" - -namespace Thyra { - template - class FROSch_PreconFactory : public PreconditionerFactoryBase { - - public: - FROSch_PreconFactory(); - //Overwritten form PreconditionerFactoryBase - bool isCompatible(const LinearOpSourceBase& fwdOp) const; - - Teuchos::RCP > createPrec() const; - - void initializePrec(const Teuchos::RCP >& fwdOp, - PreconditionerBase* prec, - const ESupportSolveUse supportSolveUse - ) const; - - void uninitializePrec(PreconditionerBase* prec, - Teuchos::RCP >* fwdOp, - ESupportSolveUse* supportSolveUse - ) const; - void setParameterList(const Teuchos::RCP& paramList); - /** \brief . */ - Teuchos::RCP unsetParameterList(); - /** \brief . */ - Teuchos::RCP getNonconstParameterList(); - /** \brief . */ - Teuchos::RCP getParameterList() const; - /** \brief . */ - Teuchos::RCP getValidParameters() const; - //@} - - /** \name Public functions overridden from Describable. */ - //@{ - - /** \brief . */ - std::string description() const; - - // ToDo: Add an override of describe(...) to give more detail! - - //@} - - private: - - Teuchos::RCP paramList_; - - }; -} -#endif - - - - - diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_def.hpp deleted file mode 100644 index 32c95cc1c9ff..000000000000 --- a/packages/shylu/shylu_dd/frosch/src/adapters/FROSch_PreconFactory_def.hpp +++ /dev/null @@ -1,194 +0,0 @@ -#include - - -//#include -#include -#include - -#include -#include -// - -#include "FROSch_PreconFactory_decl.hpp" - -#include "Kokkos_DefaultNode.hpp" - -namespace Thyra { - using Teuchos::RCP; - using Teuchos::rcp; - using Teuchos::ParameterList; - - //Constructor---------------- - template - FROSch_PreconFactory::FROSch_PreconFactory() - { - paramList_ = rcp(new Teuchos::ParameterList()); - } - //---------------------------- - - //----------------------------------------------------------- - template - bool FROSch_PreconFactory::isCompatible(const LinearOpSourceBase& fwdOpSrc) const - { - std::cout<<"Only Epetra works fine->Insert CHECK\n"; - return true; - } - //----------------------------------------------------------- - - //-------------------------------------------------------------- - template - RCP >FROSch_PreconFactory::createPrec() const - { - return Teuchos::rcp(new DefaultPreconditioner); - - } - //------------------------------------------------------------- - - //------------------------------------------------------------- - template - void FROSch_PreconFactory::initializePrec - (const Teuchos::RCP >& fwdOpSrc, - PreconditionerBase* prec, - const ESupportSolveUse supportSolveUse - ) const{ - - Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); - - - using Teuchos::rcp_dynamic_cast; - //Some Typedefs - typedef Xpetra::Map XpMap; - typedef Xpetra::Operator XpOp; - typedef Xpetra::ThyraUtils XpThyUtils; - typedef Xpetra::CrsMatrix XpCrsMat; - typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; - typedef Xpetra::Matrix XpMat; - typedef Xpetra::MultiVector XpMultVec; - typedef Xpetra::MultiVector XpMultVecDouble; - typedef Thyra::LinearOpBase ThyLinOpBase; - - TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); - TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); - TEUCHOS_ASSERT(prec); - - // Create a copy, as we may remove some things from the list - ParameterList paramList = *paramList_; - - // Retrieve wrapped concrete Xpetra matrix from FwdOp - const RCP fwdOp = fwdOpSrc->getOp(); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); - - //Check fpr Epetra - bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); - - RCP > K = Teuchos::null; - - RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); - - // FROSCH needs a non-const object as input - RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); - - K = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); - - // Retrieve concrete preconditioner object - const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); - - // extract preconditioner operator - RCP thyra_precOp = Teuchos::null; - thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); - - if (bIsEpetra){ - std::cout<<"Korrekt\n"; - } - else{ - std::cout<<"Did not use Epetra this might cause problem\n"; - } - - - - - } - //------------------------------------------------------------- - - //------------------------------------------------------------- - template - void FROSch_PreconFactory:: - uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { - TEUCHOS_ASSERT(prec); - - // Retrieve concrete preconditioner object - const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); - - if (fwdOp) { - // TODO: Implement properly instead of returning default value - *fwdOp = Teuchos::null; - } - - if (supportSolveUse) { - // TODO: Implement properly instead of returning default value - *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; - } - - defaultPrec->uninitialize(); - } - //------------------------------------------------------------- - - //------------------------------------------------------------- - template - void FROSch_PreconFactory::setParameterList(RCP const & paramList){ - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); - paramList_ = paramList; - } - //------------------------------------------------------------- - - //------------------------------------------------------------------ - template - RCP FROSch_PreconFactory::getNonconstParameterList(){ - return paramList_; - } - - //----------------------------------------------------------------------- - - - //----------------------------------------------------------------------- - template - RCP - FROSch_PreconFactory::getParameterList() const { - return paramList_; - } - //-------------------------------------------------------------------- - - //-------------------------------------------------------------------- - template - RCP FROSch_PreconFactory::getValidParameters() const { - static RCP validPL; - - if (Teuchos::is_null(validPL)) - validPL = rcp(new ParameterList()); - - return validPL; - } - //----------------------------------------------------------------------- - - //----------------------------------------------------------------------- - template - std::string FROSch_PreconFactory::description() const { - return "Thyra::FROSch_TwoLevelPreconditionerFactory"; - } - //-------------------------------------------------------------------------- - - //-------------------------------------------------------------------------- - template - RCP FROSch_PreconFactory::unsetParameterList(){ - RCP savedParamList = paramList_; - paramList_ = Teuchos::null; - return savedParamList; - - } - - -} diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelp.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelp.hpp deleted file mode 100644 index 0e53a0a6d65e..000000000000 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelp.hpp +++ /dev/null @@ -1,30 +0,0 @@ -#include "Stratimikos_DefaultLinearSolverBuilder.hpp" - -#include "FROSch_PreconFactory.hpp" - - -#include "Teuchos_RCP.hpp" -#include "Teuchos_ParameterList.hpp" -#include "Teuchos_TestForException.hpp" -#include "Teuchos_AbstractFactoryStd.hpp" - -#include -#include "Kokkos_DefaultNode.hpp" - - -namespace Stratimikos { - - template - void enableFROSch(DefaultLinearSolverBuilder& builder, const std::string& stratName = "FROSch"){ - const Teuchos::RCP precValidParams = Teuchos::sublist(builder.getValidParameters(), "Preconditioner Types"); - - TEUCHOS_TEST_FOR_EXCEPTION(precValidParams->isParameter(stratName), std::logic_error, - "Stratimikos::enableFROSch cannot add \"" + stratName +"\" because it is already included in builder!"); - - typedef Thyra::PreconditionerFactoryBase Base; - typedef Thyra::FROSch_PreconFactory Impl; - - builder.setPreconditioningStrategyFactory(Teuchos::abstractFactoryStd(), stratName); - } - -} diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.cpp b/packages/shylu/shylu_dd/frosch/src/adapters/Stratimikos_FROSchHelpers.cpp deleted file mode 100644 index e69de29bb2d1..000000000000 diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp deleted file mode 100644 index c5cf8d6556fd..000000000000 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_decl.hpp +++ /dev/null @@ -1,310 +0,0 @@ - -#ifndef THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DECL_HPP -#define THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DECL_HPP - - -// Stratimikos needs Thyra, so we don't need special guards for Thyra here -#include "Thyra_DefaultPreconditioner.hpp" -#include "Thyra_BlockedLinearOpBase.hpp" -#include "Thyra_XpetraLinearOp.hpp" - -#include "Teuchos_Ptr.hpp" -#include "Teuchos_TestForException.hpp" -#include "Teuchos_Assert.hpp" -#include "Teuchos_Time.hpp" - -#include -#include -#include -#include -//PUT FROSch includes here - -#include "Teuchos_ParameterList.hpp" -#include "Teuchos_RCP.hpp" -#include "Teuchos_ArrayRCP.hpp" -#include "Teuchos_Array.hpp" - -#include -#include -#include -#include -#include - -#include -#include -#include - - -//#include -#include -#include -#include -#include -// - -#include "Thyra_PreconditionerFactoryBase.hpp" - -#include "Kokkos_DefaultNode.hpp" - -namespace Thyra { - - template - class FROSch_EpetraPreconFactory:public Thyra::PreconditionerFactoryBase{ - public: - - //Constructor - FROSch_EpetraPreconFactory(); - - //Overridden from PreconditionerFactory Base - bool isCompatible(const LinearOpSourceBase& fwdOp) const; - - Teuchos::RCP > createPrec() const; - - void initializePrec(const Teuchos::RCP >& fwdOpSrc, - PreconditionerBase* prec, - const ESupportSolveUse supportSolveUse - ) const; - - void uninitializePrec(PreconditionerBase* prec, - Teuchos::RCP >* fwdOp, - ESupportSolveUse* supportSolveUse - ) const; - - void setParameterList(const Teuchos::RCP& paramList); - - Teuchos::RCP unsetParameterList(); - - Teuchos::RCP getNonconstParameterList(); - - Teuchos::RCP getParameterList() const; - - Teuchos::RCP getValidParameters() const; - - std::string description() const; - private: - Teuchos::RCP paramList_; - - - - }; - - using Teuchos::RCP; - using Teuchos::rcp; - using Teuchos::ParameterList; - - //Constructor - template - FROSch_EpetraPreconFactory::FROSch_EpetraPreconFactory() - { - paramList_ = rcp(new Teuchos::ParameterList()); - } - //----------------------------------------------------------- - template - bool FROSch_EpetraPreconFactory::isCompatible(const LinearOpSourceBase& fwdOpSrc) const - { - const RCP > fwdOp = fwdOpSrc.getOp(); - //so far only Epetra is allowed - if (Xpetra::ThyraUtils::isEpetra(fwdOp)) return true; - - return false; - } - //-------------------------------------------------------------- - template - RCP >FROSch_EpetraPreconFactory::createPrec() const{ - return Teuchos::rcp(new DefaultPreconditioner); - - } - //------------------------------------------------------------- - template - void FROSch_EpetraPreconFactory::initializePrec - (const Teuchos::RCP >& fwdOpSrc, - PreconditionerBase* prec, - const ESupportSolveUse supportSolveUse - ) const{ - - Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); - - - using Teuchos::rcp_dynamic_cast; - //Some Typedefs - typedef Xpetra::Map XpMap; - typedef Xpetra::Operator XpOp; - typedef Xpetra::ThyraUtils XpThyUtils; - typedef Xpetra::CrsMatrix XpCrsMat; - typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; - typedef Xpetra::Matrix XpMat; - typedef Xpetra::MultiVector XpMultVec; - typedef Xpetra::MultiVector XpMultVecDouble; - typedef Thyra::LinearOpBase ThyLinOpBase; - - - - - //PreCheck - TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); - //TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); - TEUCHOS_ASSERT(prec); - - // Create a copy, as we may remove some things from the list - ParameterList paramList = *paramList_; - - // Retrieve wrapped concrete Xpetra matrix from FwdOp - const RCP fwdOp = fwdOpSrc->getOp(); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); - - // Check whether it is Epetra/Tpetra - bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); - bool bIsTpetra = XpThyUtils::isTpetra(fwdOp); - bool bIsBlocked = XpThyUtils::isBlockedOperator(fwdOp); - TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == true && bIsTpetra == true)); - TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == bIsTpetra) && bIsBlocked == false); - TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); - - RCP A = Teuchos::null; - RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); - - // FROSCH needs a non-const object as input - RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); - - // wrap the forward operator as an Xpetra::Matrix that FROSch can work with - A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); - //A->describe(*fancy,Teuchos::VERB_EXTREME); - - - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); - - // Retrieve concrete preconditioner object--->Here Mem Leak? - const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); - - // extract preconditioner operator - RCP thyra_precOp = Teuchos::null; - thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); - - //Later needs to be a utility ExtractCoordinatesFromParameterList - //not implemented yet - // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); - - //-------Build New Two Level Prec-------------- - const RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); - - RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); - //Initialize-> Only Works for laplce (cause defaults are used) and compute - TwoLevelPrec->initialize(); - TwoLevelPrec->compute(); - //----------------------------------------------- - - - //Prepare for FROSch Epetra Op------------------- - RCP epetraTwoLevel = rcp_dynamic_cast(TwoLevelPrec); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(epetraTwoLevel)); - RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(frosch_epetraop)); - - //attach to fwdOp - set_extra_data(fwdOp,"IFPF::fwdOp", Teuchos::inOutArg(frosch_epetraop), Teuchos::POST_DESTROY,false); - - RCP thyra_epetraOp = Thyra::nonconstEpetraLinearOp(frosch_epetraop, NOTRANS, EPETRA_OP_APPLY_APPLY_INVERSE, EPETRA_OP_ADJOINT_UNSUPPORTED); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyra_epetraOp)); - - - - - - - - //Wrap tp thyra - RCP thyraPrecOp = Teuchos::null; - Comm->barrier(); Comm->barrier(); Comm->barrier(); - std::cout<<"Compute Two Level Prec\n"; - - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); - - thyraPrecOp = rcp_dynamic_cast(thyra_epetraOp); - - Comm->barrier(); - Comm->barrier(); - Comm->barrier(); - - std::cout<<"Test for null pointer\n"; - - - defaultPrec->initializeUnspecified(thyraPrecOp); - Comm->barrier(); - Comm->barrier(); - Comm->barrier(); - std::cout<<"Thyra OP\n"; - - } - //------------------------------------------------------------- - template - void FROSch_EpetraPreconFactory:: - uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { - TEUCHOS_ASSERT(prec); - - // Retrieve concrete preconditioner object - const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); - - if (fwdOp) { - // TODO: Implement properly instead of returning default value - *fwdOp = Teuchos::null; - } - - if (supportSolveUse) { - // TODO: Implement properly instead of returning default value - *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; - } - - defaultPrec->uninitialize(); - } - //----------------------------------------------------------------- - template - void FROSch_EpetraPreconFactory::setParameterList(RCP const & paramList){ - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); - paramList_ = paramList; - } - - //------------------------------------------------------------------ - template - RCP FROSch_TwoLevelPreconditionerFactory::getNonconstParameterList(){ - return paramList_; - } - - //----------------------------------------------------------------------- - template - RCP - FROSch_EpetraPreconFactory::getParameterList() const { - return paramList_; - } - //-------------------------------------------------------------------- - template - RCP FROSch_EpetraPreconFactory::getValidParameters() const { - static RCP validPL; - - if (Teuchos::is_null(validPL)) - validPL = rcp(new ParameterList()); - - return validPL; - } - //----------------------------------------------------------------------- - template - std::string FROSch_EpetraPreconFactory::description() const { - return "Thyra::FROSch_TwoLevelPreconditionerFactory"; - } - //-------------------------------------------------------------------------- - template - RCP FROSch_EpetraPreconFactory::unsetParameterList(){ - RCP savedParamList = paramList_; - paramList_ = Teuchos::null; - return savedParamList; - - } - -} - -#endif - - diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp deleted file mode 100644 index 93cb335d5153..000000000000 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchEpetraPreconFactory_def.hpp +++ /dev/null @@ -1,229 +0,0 @@ -#ifndef THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DEF_HPP -#define THYRA_FROSCH_TWOLEVELPRECONDITIONER_FACTORY_DEF_HPP - -//#include "Thyra_FROSch_TwoLevelPreconditionerFactory_decl.hpp" - - -#include -#include "Thyra_FROSchEpetraPreconFactory_decl.hpp" - -namespace Thyra { - using Teuchos::RCP; - using Teuchos::rcp; - using Teuchos::ParameterList; - - //Constructor - template -FROSch_EpetraPreconFactory::FROSch_EpetraPreconFactory() - { - paramList_ = rcp(new Teuchos::ParameterList()); - } - //----------------------------------------------------------- - template - bool FROSch_EpetraPreconFactory::isCompatible(const LinearOpSourceBase& fwdOpSrc) const - { - const RCP > fwdOp = fwdOpSrc.getOp(); - //so far only Epetra is allowed - if (Xpetra::ThyraUtils::isEpetra(fwdOp)) return true; - - return false; - } - //-------------------------------------------------------------- - template - RCP > FROSch_EpetraPreconFactory::createPrec() const{ - return Teuchos::rcp(new DefaultPreconditioner); - - } - //------------------------------------------------------------- - template - void FROSch_EpetraPreconFactory::initializePrec - (const Teuchos::RCP >& fwdOpSrc, - PreconditionerBase* prec, - const ESupportSolveUse supportSolveUse - ) const{ - - Teuchos::RCP fancy = fancyOStream(Teuchos::rcpFromRef(std::cout)); - - - using Teuchos::rcp_dynamic_cast; - //Some Typedefs - typedef Xpetra::Map XpMap; - typedef Xpetra::Operator XpOp; - typedef Xpetra::ThyraUtils XpThyUtils; - typedef Xpetra::CrsMatrix XpCrsMat; - typedef Xpetra::BlockedCrsMatrix XpBlockedCrsMat; - typedef Xpetra::Matrix XpMat; - typedef Xpetra::MultiVector XpMultVec; - typedef Xpetra::MultiVector XpMultVecDouble; - typedef Thyra::LinearOpBase ThyLinOpBase; - - - - - //PreCheck - TEUCHOS_ASSERT(Teuchos::nonnull(fwdOpSrc)); - //TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); - TEUCHOS_ASSERT(prec); - - // Create a copy, as we may remove some things from the list - ParameterList paramList = *paramList_; - - // Retrieve wrapped concrete Xpetra matrix from FwdOp - const RCP fwdOp = fwdOpSrc->getOp(); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(fwdOp)); - - // Check whether it is Epetra/Tpetra - bool bIsEpetra = XpThyUtils::isEpetra(fwdOp); - bool bIsTpetra = XpThyUtils::isTpetra(fwdOp); - bool bIsBlocked = XpThyUtils::isBlockedOperator(fwdOp); - TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == true && bIsTpetra == true)); - TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra == bIsTpetra) && bIsBlocked == false); - TEUCHOS_TEST_FOR_EXCEPT((bIsEpetra != bIsTpetra) && bIsBlocked == true); - - RCP A = Teuchos::null; - RCP xpetraFwdCrsMat = XpThyUtils::toXpetra(fwdOp); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMat)); - - // FROSCH needs a non-const object as input - RCP xpetraFwdCrsMatNonConst = Teuchos::rcp_const_cast(xpetraFwdCrsMat); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(xpetraFwdCrsMatNonConst)); - - // wrap the forward operator as an Xpetra::Matrix that FROSch can work with - A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); - //A->describe(*fancy,Teuchos::VERB_EXTREME); - - - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); - - // Retrieve concrete preconditioner object--->Here Mem Leak? - const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); - - // extract preconditioner operator - RCP thyra_precOp = Teuchos::null; - thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); - - //Later needs to be a utility ExtractCoordinatesFromParameterList - //not implemented yet - // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); - - //-------Build New Two Level Prec-------------- - const RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,rcpFromRef(paramList))); - - RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); - //Initialize-> Only Works for laplce (cause defaults are used) and compute - TwoLevelPrec->initialize(); - TwoLevelPrec->compute(); - //----------------------------------------------- - - - //Prepare for FROSch Epetra Op------------------- - RCP epetraTwoLevel = rcp_dynamic_cast(TwoLevelPrec); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(epetraTwoLevel)); - RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(frosch_epetraop)); - - //attach to fwdOp - set_extra_data(fwdOp,"IFPF::fwdOp", Teuchos::inOutArg(frosch_epetraop), Teuchos::POST_DESTROY,false); - - RCP thyra_epetraOp = Thyra::nonconstEpetraLinearOp(frosch_epetraop, NOTRANS, EPETRA_OP_APPLY_APPLY_INVERSE, EPETRA_OP_ADJOINT_UNSUPPORTED); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyra_epetraOp)); - - - - - - - - //Wrap tp thyra - RCP thyraPrecOp = Teuchos::null; - Comm->barrier(); Comm->barrier(); Comm->barrier(); - std::cout<<"Compute Two Level Prec\n"; - - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); - - thyraPrecOp = rcp_dynamic_cast(thyra_epetraOp); - - Comm->barrier(); - Comm->barrier(); - Comm->barrier(); - - std::cout<<"Test for null pointer\n"; - - - defaultPrec->initializeUnspecified(thyraPrecOp); - Comm->barrier(); - Comm->barrier(); - Comm->barrier(); - std::cout<<"Thyra OP\n"; - - } - //------------------------------------------------------------- - template - void FROSch_EpetraPreconFactory:: - uninitializePrec(PreconditionerBase* prec, RCP >* fwdOp, ESupportSolveUse* supportSolveUse) const { - TEUCHOS_ASSERT(prec); - - // Retrieve concrete preconditioner object - const Teuchos::Ptr > defaultPrec = Teuchos::ptr(dynamic_cast *>(prec)); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(defaultPrec)); - - if (fwdOp) { - // TODO: Implement properly instead of returning default value - *fwdOp = Teuchos::null; - } - - if (supportSolveUse) { - // TODO: Implement properly instead of returning default value - *supportSolveUse = Thyra::SUPPORT_SOLVE_UNSPECIFIED; - } - - defaultPrec->uninitialize(); - } - //----------------------------------------------------------------- - template - void FROSch_EpetraPreconFactory::setParameterList(RCP const & paramList){ - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(paramList)); - paramList_ = paramList; - } - - //------------------------------------------------------------------ - template - RCP FROSch_TwoLevelPreconditionerFactory::getNonconstParameterList(){ - return paramList_; - } - - //----------------------------------------------------------------------- - template - RCP - FROSch_EpetraPreconFactory::getParameterList() const { - return paramList_; - } - //-------------------------------------------------------------------- - template - RCP FROSch_EpetraPreconFactory::getValidParameters() const { - static RCP validPL; - - if (Teuchos::is_null(validPL)) - validPL = rcp(new ParameterList()); - - return validPL; - } - //----------------------------------------------------------------------- - template - std::string FROSch_EpetraPreconFactory::description() const { - return "Thyra::FROSch_TwoLevelPreconditionerFactory"; - } - //-------------------------------------------------------------------------- - template - RCP FROSch_EpetraPreconFactory::unsetParameterList(){ - RCP savedParamList = paramList_; - paramList_ = Teuchos::null; - return savedParamList; - - } - -} -#endif - - diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp deleted file mode 100644 index b5bf1a6b006e..000000000000 --- a/packages/shylu/shylu_dd/frosch/src/adapters/stratimikos_froschEpetra.hpp +++ /dev/null @@ -1,36 +0,0 @@ - - -#include "Stratimikos_DefaultLinearSolverBuilder.hpp" - - - -#include - - - -#include "Teuchos_RCP.hpp" -#include "Teuchos_ParameterList.hpp" -#include "Teuchos_TestForException.hpp" -#include "Teuchos_AbstractFactoryStd.hpp" - -#include -#include "Kokkos_DefaultNode.hpp" - - -namespace Stratimikos { - - template - void enableFROSch(DefaultLinearSolverBuilder& builder, const std::string& stratName = "FROSch"){ - const Teuchos::RCP precValidParams = Teuchos::sublist(builder.getValidParameters(), "Preconditioner Types"); - - TEUCHOS_TEST_FOR_EXCEPTION(precValidParams->isParameter(stratName), std::logic_error, - "Stratimikos::enableFROSch cannot add \"" + stratName +"\" because it is already included in builder!"); - - typedef Thyra::PreconditionerFactoryBase Base; - typedef Thyra::FROSch_EpetraPreconFactory Impl; - - builder.setPreconditioningStrategyFactory(Teuchos::abstractFactoryStd(), stratName); - } - -} - diff --git a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt index e7f2f8e62b44..50d9b2bb45bc 100644 --- a/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt +++ b/packages/shylu/shylu_dd/frosch/test/CMakeLists.txt @@ -6,7 +6,6 @@ ADD_SUBDIRECTORIES( Import_Tpetra LocalPartitionOfUnityBasis # InterfacePartitionOfUnity - Thyra_Epetra TwoLevelPreconditionerInputFiles Thyra_Xpetra diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/CMakeLists.txt b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/CMakeLists.txt deleted file mode 100644 index 9df399771f39..000000000000 --- a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/CMakeLists.txt +++ /dev/null @@ -1,18 +0,0 @@ -TRIBITS_ADD_EXECUTABLE( - thyra_epetra - SOURCES main.cpp -) - -TRIBITS_COPY_FILES_TO_BINARY_DIR(ThyraEpetraCopyFiles - DEST_FILES stratimikos_ParameterList.xml - SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} - DEST_DIR ${CMAKE_CURRENT_BINARY_DIR} - EXEDEPS thyra_epetra -) - -TRIBITS_ADD_TEST( - thyra_epetra - NAME test_thyra_epetra - COMM mpi - NUM_MPI_PROCS 4 -) \ No newline at end of file diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/main.cpp b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/main.cpp deleted file mode 100644 index b0d9eac26ba5..000000000000 --- a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/main.cpp +++ /dev/null @@ -1,303 +0,0 @@ - -#include -#include - -#include -#include - -#include -#include - -#include -#include - -#include -#include - -#include -#include -#include -#include - -#include -#include - -// Thyra includes -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// Stratimikos includes -#include -#include -//#include "stratimikos_froschEpetra.hpp" - -// Xpetra include -#include - -// FROSCH thyra includes -#include -//#include "Thyra_FROSchEpetraPreconFactory_decl.hpp" -#include "Frosch_EpetraOp_def.hpp" - -typedef unsigned UN; -typedef double SC; -typedef int LO; -typedef int GO; -typedef Kokkos::Compat::KokkosSerialWrapperNode EpetraNode; // Hier Default verwenden??? -typedef EpetraNode NO; - -using namespace std; -using namespace Teuchos; -using namespace Xpetra; -using namespace FROSch; -using namespace Belos; - -int main(int argc, char *argv[]) -{ - MPI_Init(&argc,&argv); - - { - Epetra_MpiComm CommWorld(MPI_COMM_WORLD); - - CommandLineProcessor My_CLP; - - Teuchos::RCP - - out = Teuchos::VerboseObjectBase::getDefaultOStream(); - - int M = 4; - My_CLP.setOption("M",&M,"H / h."); - int Dimension = 2; - My_CLP.setOption("Dim",&Dimension,"Dimension."); - int Overlap = 1; - My_CLP.setOption("Overlap",&Overlap,"Overlap."); - int DofsPerNode = 1; - My_CLP.setOption("DPN",&DofsPerNode,"Dofs per node."); - int DOFOrdering = 0; - My_CLP.setOption("Ordering",&DOFOrdering,"Dofs ordering (NodeWise=0,DimensionWise=1,Custom=2)."); - string xmlFile = "stratimikos_ParameterList.xml"; - My_CLP.setOption("List",&xmlFile,"File name of the parameter list."); - - My_CLP.recogniseAllOptions(true); - My_CLP.throwExceptions(false); - CommandLineProcessor::EParseCommandLineReturn parseReturn = My_CLP.parse(argc,argv); - if(parseReturn == CommandLineProcessor::PARSE_HELP_PRINTED) { - MPI_Finalize(); - return 0; - } - - int N; - MPI_Comm COMM; - int color=1; - //bool onFirstLevelComm=false; - if (Dimension == 2) { - N = (int) (pow(CommWorld.NumProc(),1/2.) + 100*numeric_limits::epsilon()); // 1/H - if (CommWorld.MyPID()::epsilon()); // 1/H - if (CommWorld.MyPID() Comm(new Epetra_MpiComm(COMM)); - RCP > TeuchosComm = rcp(new MpiComm (COMM)); - if (color==0) { - - RCP parameterList = getParametersFromXmlFile(xmlFile); - - if(Comm->MyPID()==0) { - cout << "--------------------------------------------------------------------------------\nPARAMETERS:" << endl; - parameterList->print(cout); - cout << "--------------------------------------------------------------------------------\n\n"; - } - - if (Comm->MyPID()==0) cout << "----------------ASSEMBLY-----------\n"; - - ParameterList GalerList; - GalerList.set("nx", N*M); - GalerList.set("ny", N*M); - GalerList.set("nz", N*M); - GalerList.set("mx", N); - GalerList.set("my", N); - GalerList.set("mz", N); - - RCP UniqueMapEpetra; - RCP KEpetra; - - if (Dimension==2) { - UniqueMapEpetra.reset(Galeri::CreateMap("Cartesian2D", *Comm, GalerList)); - KEpetra.reset(Galeri::CreateCrsMatrix("Laplace2D", UniqueMapEpetra.get(), GalerList)); - } else if (Dimension==3) { - UniqueMapEpetra.reset(Galeri::CreateMap("Cartesian3D", *Comm, GalerList)); - KEpetra.reset(Galeri::CreateCrsMatrix("Laplace3D", UniqueMapEpetra.get(), GalerList)); - } - - RCP > UniqueMap; - RCP > K; - DofOrdering Ord; - - if (DOFOrdering == 0) { - Ord = NodeWise; - Array uniqueMapArray(DofsPerNode*UniqueMapEpetra->NumMyElements()); - for (LO i=0; iNumMyElements(); i++) { - for (LO j=0; jGID(i)+j; - } - } - - UniqueMap = MapFactory::Build(UseEpetra,-1,uniqueMapArray(),0,TeuchosComm); - K = MatrixFactory::Build(UniqueMap,KEpetra->MaxNumEntries()); - for (LO i=0; iNumMyElements(); i++) { - LO numEntries; - GO* indices; - SC* values; - KEpetra->ExtractMyRowView(i,numEntries,values,indices); - - for (LO j=0; j indicesArray(numEntries); - ArrayView valuesArrayView(values,numEntries); - for (LO k=0; kColMap().GID(indices[k])+j; - } - K->insertGlobalValues(DofsPerNode*KEpetra->RowMap().GID(i)+j,indicesArray(),valuesArrayView); - } - } - K->fillComplete(); - } else if (DOFOrdering == 1) { - Ord = DimensionWise; - Array uniqueMapArray(DofsPerNode*UniqueMapEpetra->NumMyElements()); - for (LO i=0; iNumMyElements(); i++) { - for (LO j=0; jNumMyElements()*j] = UniqueMapEpetra->GID(i)+(UniqueMapEpetra->MaxAllGID()+1)*j; - } - } - - UniqueMap = MapFactory::Build(UseEpetra,-1,uniqueMapArray(),0,TeuchosComm); - K = MatrixFactory::Build(UniqueMap,KEpetra->MaxNumEntries()); - for (LO i=0; iNumMyElements(); i++) { - LO numEntries; - GO* indices; - SC* values; - KEpetra->ExtractMyRowView(i,numEntries,values,indices); - - for (LO j=0; j indicesArray(numEntries); - ArrayView valuesArrayView(values,numEntries); - for (LO k=0; kColMap().GID(indices[k])+(KEpetra->ColMap().MaxAllGID()+1)*j; - } - K->insertGlobalValues(UniqueMapEpetra->GID(i)+(UniqueMapEpetra->MaxAllGID()+1)*j,indicesArray(),valuesArrayView); - } - } - K->fillComplete(); - } else if (DOFOrdering == 2) { - assert(0!=0); // TODO: Andere Sortierung implementieren - } else { - assert(0!=0); - } - // RCP fancy = fancyOStream(rcpFromRef(std::cout)); UniqueMap->describe(*fancy,Teuchos::VERB_EXTREME); UniqueMap->getComm()->barrier(); UniqueMap->getComm()->barrier(); - - - RCP > xSolution = MultiVectorFactory::Build(UniqueMap,1); - RCP > xRightHandSide = MultiVectorFactory::Build(UniqueMap,1); - - xSolution->putScalar(0.0); - xRightHandSide->putScalar(1.0); - - auto lows_factory = Thyra::BelosLinearOpWithSolveFactory (); - auto pl = Teuchos::rcp(new Teuchos::ParameterList()); - pl->set("Solver Type", "Block GMRES"); - Teuchos::ParameterList& solver_pl = pl->sublist("Solver Types").sublist("Block GMRES"); - solver_pl.set("Convergence Tolerance", 1e-6); - solver_pl.set("Maximum Iterations", 100); - solver_pl.set("Num Blocks", 1); - lows_factory.setParameterList(pl); - lows_factory.setVerbLevel(Teuchos::VERB_HIGH); - //auto lows = lows_factory.createOp(); - - Teuchos::RCP > exA = Teuchos::rcp(new Xpetra::EpetraCrsMatrixT(KEpetra)); - Teuchos::RCP > exAWrap = Teuchos::rcp(new CrsMatrixWrap (exA)); - - RCP > K_thyra = Xpetra::ThyraUtils::toThyra(exAWrap->getCrsMatrix()); - RCP >thyraX = - Teuchos::rcp_const_cast >(Xpetra::ThyraUtils::toThyraMultiVector(xSolution)); - RCP >thyraB = Xpetra::ThyraUtils::toThyraMultiVector(xRightHandSide); - Comm->Barrier(); - if (Comm->MyPID()==0) cout << "----------------done-----------\n"; - - //This Basic solve without Preconditioner - //Thyra::initializeOp(lows_factory, K_thyra, lows.ptr()); - //auto status = Thyra::solve(*lows, Thyra::NOTRANS, *thyraB, thyraX.ptr()); - Comm->Barrier(); - if (Comm->MyPID()==0) cout << "----------------Stratimikos LinearSolverBuilder-----------\n"; - - Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder; - Stratimikos::enableFROSchTwoLevel(linearSolverBuilder); - - linearSolverBuilder.setParameterList(parameterList); - - - Comm->Barrier(); - if (Comm->MyPID()==0) cout << "----------------done-----------\n"; - - Comm->Barrier(); - if (Comm->MyPID()==0) cout << "----------------Thyra PrepForSolve-----------\n"; - - - - RCP > lowsFactory = - linearSolverBuilder.createLinearSolveStrategy(""); - - lowsFactory->setOStream(out); - lowsFactory->setVerbLevel(Teuchos::VERB_HIGH); - - Comm->Barrier(); - if (Comm->MyPID()==0) cout << "----------------done-----------\n"; - if (Comm->MyPID()==0) cout << "----------------Thyra LinearOpWithSolve-----------\n"; - - RCP > lows = - Thyra::linearOpWithSolve(*lowsFactory, K_thyra); - - Comm->Barrier(); - if (Comm->MyPID()==0) cout << "----------------done-----------\n"; - if (Comm->MyPID()==0) cout << "----------------Solve-----------\n"; - Thyra::SolveStatus status = - Thyra::solve(*lows, Thyra::NOTRANS, *thyraB, thyraX.ptr()); - - Comm->Barrier(); - if (Comm->MyPID()==0) cout << "----------------done-----------\n"; - - } - MPI_Comm_free(&COMM); - - } - - MPI_Finalize(); - - return(EXIT_SUCCESS); - -} - - - diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml b/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml deleted file mode 100644 index a4b6a714643b..000000000000 --- a/packages/shylu/shylu_dd/frosch/test/Thyra_Epetra/stratimikos_ParameterList.xml +++ /dev/null @@ -1,139 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - From ce7cdb64011c37e294b02332f1401f960d3d96cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Mon, 27 Aug 2018 07:01:06 +0200 Subject: [PATCH 19/20] Epetra Version --- .../Thyra_FROSchXpetraFactory_def.hpp | 63 ++++++++++--------- 1 file changed, 32 insertions(+), 31 deletions(-) diff --git a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_def.hpp b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_def.hpp index c37dc27f208a..fdb56d4d02ee 100644 --- a/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_def.hpp +++ b/packages/shylu/shylu_dd/frosch/src/adapters/Thyra_FROSchXpetraFactory_def.hpp @@ -3,7 +3,7 @@ #include "Thyra_FROSchXpetraFactory_decl.hpp" -#include +//#include #include @@ -78,7 +78,6 @@ namespace Thyra { //TEUCHOS_ASSERT(this->isCompatible(*fwdOpSrc)); TEUCHOS_ASSERT(prec); - // Create a copy, as we may remove some things from the list RCP paramList(new ParameterList(*paramList_)); // AH: Muessen wir diese Kopie machen? Irgendwie wäre es doch besser, wenn man die nicht kopieren müsste, oder? // Retrieve wrapped concrete Xpetra matrix from FwdOp @@ -103,8 +102,6 @@ namespace Thyra { // wrap the forward operator as an Xpetra::Matrix that FROSch can work with A = rcp(new Xpetra::CrsMatrixWrap(xpetraFwdCrsMatNonConst)); - //A->describe(*fancy,Teuchos::VERB_EXTREME); - TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(A)); @@ -116,29 +113,18 @@ namespace Thyra { RCP thyra_precOp = Teuchos::null; thyra_precOp = rcp_dynamic_cast >(defaultPrec->getNonconstUnspecifiedPrecOp(), true); - //Later needs to be a utility ExtractCoordinatesFromParameterList - //not implemented yet - // FROSCH::Tools::ExtractCoordinatesFromParameterList(paramList); - //-------Build New Two Level Prec-------------- RCP > TwoLevelPrec (new FROSch::TwoLevelPreconditioner(A,paramList)); - RCP< const Teuchos::Comm< int > > Comm = A->getRowMap()->getComm(); Comm->barrier(); - /*if(Comm->getRank() ==0){std::cout<<"Create Epetra Op new Constructor\n"; - - cout << "--------------------------------------------------------------------------------\nPARAMETERS Two Level Precon Factory:" << endl; - paramList.print(std::cout); - cout << "--------------------------------------------------------------------------------\n\n"; - - }*/ + Teuchos::RCP > coord = Teuchos::null; Teuchos::RCP > RepeatedMap = Teuchos::null; if(paramList->isParameter("Coordinates")){ coord = FROSch::ExtractCoordinatesFromParameterList(*paramList); - coord->describe(*fancy,Teuchos::VERB_EXTREME); + } @@ -146,32 +132,20 @@ namespace Thyra { RepeatedMap = FROSch::ExtractRepeatedMapFromParameterList(* paramList); - RepeatedMap->describe(*fancy,Teuchos::VERB_EXTREME); - } if(coord.get()!=NULL && RepeatedMap.get()!=NULL){ - - TwoLevelPrec->initialize(paramList->get("Dimension",1),paramList->get("Overlap",1),RepeatedMap,paramList->get("DofsPerNode",1),FROSch::NodeWise,coord); - - - }else{ TwoLevelPrec->initialize(); } - TwoLevelPrec->compute(); //----------------------------------------------- - //FROSCh_XpetraOP - RCP > froschXOP (new FROSch_XpetraOperator(TwoLevelPrec)); - RCP thyraPrecOp = Teuchos::null; - - // RCP frosch_epetraop(new FROSch::FROSch_EpetraOperator(A,rcpFromRef(paramList))) - ; + //FROSCh_XpetraOP + RCP > froschXOP (new FROSch_XpetraOperator(TwoLevelPrec)); RCP > thyraRangeSpace = Xpetra::ThyraUtils::toThyra(froschXOP->getRangeMap()); RCP > thyraDomainSpace = Xpetra::ThyraUtils::toThyra(froschXOP->getDomainMap()); @@ -181,6 +155,33 @@ namespace Thyra { TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyraPrecOp)); + /*##############################Epetra-Version############################### + //Prepare for FROSch Epetra Op------------------- + RCP > epetraTwoLevel = rcp_dynamic_cast >(TwoLevelPrec); + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(epetraTwoLevel)); + + + RCP frosch_epetraop = rcp(new FROSch::FROSch_EpetraOperator(epetraTwoLevel,paramList)); + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(frosch_epetraop)); + + //attach to fwdOp + set_extra_data(fwdOp,"IFPF::fwdOp", Teuchos::inOutArg(frosch_epetraop), Teuchos::POST_DESTROY,false); + + //Thyra Epetra Linear Operator + RCP thyra_epetraOp = Thyra::nonconstEpetraLinearOp(frosch_epetraop, NOTRANS, EPETRA_OP_APPLY_APPLY_INVERSE, EPETRA_OP_ADJOINT_UNSUPPORTED); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyra_epetraOp)); + + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::nonnull(thyraPrecOp)); + + thyraPrecOp = rcp_dynamic_cast(thyra_epetraOp); + TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(thyraPrecOp)); + + ############################################################################*/ + + + defaultPrec->initializeUnspecified(thyraPrecOp); } From e0fbdb566a1f7a584b5a52da8a65f6e216304cb7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Friederike=20Ro=CC=88ver?= Date: Mon, 27 Aug 2018 07:05:33 +0200 Subject: [PATCH 20/20] Clean Up --- .../frosch/test/Thyra_Xpetra/main.cpp | 33 +++---------------- 1 file changed, 4 insertions(+), 29 deletions(-) diff --git a/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/main.cpp b/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/main.cpp index 631ae92d9c13..d233352022f4 100644 --- a/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/main.cpp +++ b/packages/shylu/shylu_dd/frosch/test/Thyra_Xpetra/main.cpp @@ -1,4 +1,3 @@ - #include #include @@ -45,17 +44,12 @@ // Stratimikos includes #include -#include #include "stratimikos_FROSchXpetra.hpp" -//#include "stratimikos_froschEpetra.hpp" // Xpetra include #include // FROSCH thyra includes -#include -//#include "Thyra_FROSchEpetraPreconFactory_decl.hpp" -#include "Frosch_EpetraOp_def.hpp" #include "Thyra_FROSchLinearOp_def.hpp" #include "Thyra_FROSchXpetraFactory_def.hpp" @@ -225,8 +219,7 @@ int main(int argc, char *argv[]) } else { assert(0!=0); } - // RCP fancy = fancyOStream(rcpFromRef(std::cout)); UniqueMap->describe(*fancy,Teuchos::VERB_EXTREME); UniqueMap->getComm()->barrier(); UniqueMap->getComm()->barrier(); - + RCP > xSolution = MultiVectorFactory::Build(UniqueMap,1); RCP > xRightHandSide = MultiVectorFactory::Build(UniqueMap,1); @@ -234,16 +227,6 @@ int main(int argc, char *argv[]) xSolution->putScalar(0.0); xRightHandSide->putScalar(1.0); - auto lows_factory = Thyra::BelosLinearOpWithSolveFactory (); - auto pl = Teuchos::rcp(new Teuchos::ParameterList()); - pl->set("Solver Type", "Block GMRES"); - Teuchos::ParameterList& solver_pl = pl->sublist("Solver Types").sublist("Block GMRES"); - solver_pl.set("Convergence Tolerance", 1e-6); - solver_pl.set("Maximum Iterations", 100); - solver_pl.set("Num Blocks", 1); - lows_factory.setParameterList(pl); - lows_factory.setVerbLevel(Teuchos::VERB_HIGH); - //auto lows = lows_factory.createOp(); Teuchos::RCP > exA = Teuchos::rcp(new Xpetra::EpetraCrsMatrixT(KEpetra)); Teuchos::RCP > exAWrap = Teuchos::rcp(new CrsMatrixWrap (exA)); @@ -251,13 +234,7 @@ int main(int argc, char *argv[]) RCP >Coord = ConvertToXpetra(UseEpetra,*epCoord,TeuchosComm); RCP > RepMapX = FROSch::BuildRepeatedMap(K); - - - - - - - + RCP > K_thyra = Xpetra::ThyraUtils::toThyra(exAWrap->getCrsMatrix()); @@ -267,12 +244,10 @@ int main(int argc, char *argv[]) Comm->Barrier(); if (Comm->MyPID()==0) cout << "----------------done-----------\n"; - //This Basic solve without Preconditioner - //Thyra::initializeOp(lows_factory, K_thyra, lows.ptr()); - //auto status = Thyra::solve(*lows, Thyra::NOTRANS, *thyraB, thyraX.ptr()); Comm->Barrier(); if (Comm->MyPID()==0) cout << "----------------Stratimikos LinearSolverBuilder-----------\n"; - + + //-----------Set Coordinates and RepMap in ParameterList-------------------------- // RCP plList = sublist(parameterList,"Preconditioner Types"); // sublist(plList,"TwoLevelPreconditioner")->set("Coordinates",Coord); // sublist(plList,"TwoLevelPreconditioner")->set("RepeatedMap",RepMapX);