TrilinosMueLuSolver.h

Go to the documentation of this file.

#ifndef included_AMP_TrilinosMueLuSolver
#define included_AMP_TrilinosMueLuSolver
 
#include "AMP/matrices/trilinos/ManagedEpetraMatrix.h"
#include "AMP/solvers/SolverStrategy.h"
#include "AMP/solvers/SolverStrategyParameters.h"
#include "AMP/solvers/trilinos/ml/MLoptions.h"
 
// Trilinos includes
DISABLE_WARNINGS
#include "MueLu_FactoryManager.hpp"
#include "MueLu_HierarchyManager_fwd.hpp"
#include "Teuchos_ParameterList.hpp"
#include "Xpetra_Matrix.hpp"
#include "Xpetra_Operator_fwd.hpp"
#include "Xpetra_Parameters.hpp"
ENABLE_WARNINGS
 
#include <vector>
 
 
namespace MueLu {
class EpetraOperator;
template<typename Scalar, typename LocalOrdinal, typename GlobalOrdinal, typename Node>
class Hierarchy;
template<typename Scalar, typename LocalOrdinal, typename GlobalOrdinal, typename Node>
class TentativePFactory;
template<typename Scalar, typename LocalOrdinal, typename GlobalOrdinal, typename Node>
class SaPFactory;
template<typename Scalar, typename LocalOrdinal, typename GlobalOrdinal, typename Node>
class TransPFactory;
template<typename Scalar, typename LocalOrdinal, typename GlobalOrdinal, typename Node>
class DirectSolver;
template<typename Scalar, typename LocalOrdinal, typename GlobalOrdinal, typename Node>
class SmootherFactory;
 
using Scalar        = double;
using LocalOrdinal  = int;
using GlobalOrdinal = int;
using Node          = Xpetra::EpetraNode;
} // namespace MueLu
 
namespace AMP {
 
namespace Operator {
class LinearOperator;
}
 
namespace Solver {
 
 
using TrilinosMueLuSolverParameters = SolverStrategyParameters;
using SC                            = MueLu::Scalar;
using LO                            = MueLu::LocalOrdinal;
using GO                            = MueLu::GlobalOrdinal;
using NO                            = MueLu::Node;
 
class TrilinosMueLuSolver : public SolverStrategy
{
 
public:
    TrilinosMueLuSolver();
 
    explicit TrilinosMueLuSolver( std::shared_ptr<TrilinosMueLuSolverParameters> parameters );
 
    virtual ~TrilinosMueLuSolver();
 
    std::string type() const override { return "TrilinosMueLuSolver"; }
 
    static std::unique_ptr<SolverStrategy>
    createSolver( std::shared_ptr<SolverStrategyParameters> solverStrategyParameters )
    {
        return std::make_unique<TrilinosMueLuSolver>( solverStrategyParameters );
    }
 
    void apply( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                std::shared_ptr<AMP::LinearAlgebra::Vector> u ) override;
 
    void solveWithHierarchy( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                             std::shared_ptr<AMP::LinearAlgebra::Vector> u );
 
    inline std::shared_ptr<MueLu::EpetraOperator> getMLSolver( void ) { return d_mueluSolver; }
 
    void initialize( std::shared_ptr<const SolverStrategyParameters> parameters ) override;
 
    void registerOperator( std::shared_ptr<AMP::Operator::Operator> op ) override;
 
    void resetOperator( std::shared_ptr<const AMP::Operator::OperatorParameters> params ) override;
 
    void reset( std::shared_ptr<SolverStrategyParameters> params ) override;
 
protected:
    void reSolveWithLU( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                        std::shared_ptr<AMP::LinearAlgebra::Vector> u );
 
    void getFromInput( std::shared_ptr<const AMP::Database> db );
 
    void buildHierarchyFromDefaults( void );
 
    void buildHierarchyByLevel( void );
 
    Teuchos::RCP<Xpetra::Matrix<SC, LO, GO, NO>> getXpetraMatrix();
 
    Teuchos::RCP<MueLu::TentativePFactory<SC, LO, GO, NO>> getTentativePFactory( void );
    Teuchos::RCP<MueLu::SaPFactory<SC, LO, GO, NO>> getSaPFactory( void );
    Teuchos::RCP<MueLu::TransPFactory<SC, LO, GO, NO>> getRFactory( void );
    Teuchos::RCP<MueLu::SmootherFactory<SC, LO, GO, NO>> getCoarseSolverFactory( void );
    Teuchos::RCP<MueLu::SmootherFactory<SC, LO, GO, NO>> getSmootherFactory( const int level );
 
    Teuchos::ParameterList &getSmootherParameters( const int level );
    MueLu::MsgType getVerbosityLevel();
 
private:
    bool d_bUseEpetra      = true;  
    bool d_build_hierarchy = false; 
    bool d_build_hierarchy_from_defaults =
        true; 
#if 0
    // ifpack related -- could be used in future
    bool d_construct_partition = false; 
#endif
    bool d_bCreationPhase = false; 
    bool d_bRobustMode    = false; 
 
    AMP_MPI d_comm;
 
    size_t d_maxLevels; 
 
    std::string d_smoother_type; 
 
    std::shared_ptr<MueLu::EpetraOperator> d_mueluSolver;
 
    std::shared_ptr<AMP::LinearAlgebra::ManagedEpetraMatrix> d_matrix;
    Teuchos::ParameterList d_MueLuParameterList;
 
    Teuchos::RCP<MueLu::HierarchyManager<SC, LO, GO, NO>> d_mueluHierarchyManager;
 
    Teuchos::RCP<MueLu::Hierarchy<SC, LO, GO, NO>> d_mueluHierarchy;
 
    MueLu::FactoryManager<SC, LO, GO, NO> d_factoryManager;
    std::vector<Teuchos::RCP<MueLu::FactoryManager<SC, LO, GO, NO>>> d_levelFactoryManager;
};
} // namespace Solver
} // namespace AMP
 
#endif