TrilinosMLSolver.h

Go to the documentation of this file.

#ifndef included_AMP_TrilinosMLSolver
#define included_AMP_TrilinosMLSolver
 
#include "AMP/solvers/SolverStrategy.h"
#include "AMP/solvers/SolverStrategyParameters.h"
#include "AMP/solvers/trilinos/ml/MLoptions.h"
 
DISABLE_WARNINGS
#include "Teuchos_ParameterList.hpp"
ENABLE_WARNINGS
 
 
// Forward declare Trilinos classes
typedef struct ML_Struct ML;
typedef struct ML_Aggregate_Struct ML_Aggregate;
namespace ML_Epetra {
class MultiLevelPreconditioner;
}
 
 
// Forward declare EpetraMatrix
namespace AMP::LinearAlgebra {
class ManagedEpetraMatrix;
}
 
namespace AMP::Solver {
 
 
typedef SolverStrategyParameters TrilinosMLSolverParameters;
 
 
class TrilinosMLSolver : public SolverStrategy
{
 
public:
    TrilinosMLSolver();
 
    explicit TrilinosMLSolver( std::shared_ptr<TrilinosMLSolverParameters> parameters );
 
    virtual ~TrilinosMLSolver();
 
    std::string type() const override { return "TrilinosMLSolver"; }
 
    static std::unique_ptr<SolverStrategy>
    createSolver( std::shared_ptr<SolverStrategyParameters> solverStrategyParameters )
    {
        return std::make_unique<TrilinosMLSolver>( solverStrategyParameters );
    }
 
    void apply( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                std::shared_ptr<AMP::LinearAlgebra::Vector> u ) override;
 
    inline std::shared_ptr<ML_Epetra::MultiLevelPreconditioner> getMLSolver( void )
    {
        return d_mlSolver;
    }
 
    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<AMP::Database> db );
 
    void convertMLoptionsToTeuchosParameterList();
 
    void buildML();
 
    void computeCoordinates( std::shared_ptr<AMP::Operator::Operator> op );
    void computeNullSpace( std::shared_ptr<AMP::Operator::Operator> op );
 
private:
    bool d_bUseEpetra;
    ML *d_ml;
    ML_Aggregate *d_mlAggregate;
 
    AMP_MPI d_comm;
 
    bool d_bCreationPhase; 
    bool d_bRobustMode;
 
    std::shared_ptr<MLoptions> d_mlOptions;
 
    std::shared_ptr<ML_Epetra::MultiLevelPreconditioner> d_mlSolver;
    std::shared_ptr<AMP::LinearAlgebra::ManagedEpetraMatrix> d_matrix;
    Teuchos::ParameterList d_MLParameterList;
 
    std::vector<double> d_x_values;
    std::vector<double> d_y_values;
    std::vector<double> d_z_values;
    std::vector<double> d_null_space;
};
 
} // namespace AMP::Solver
 
#endif