HypreSolver.h

Go to the documentation of this file.

#ifndef included_AMP_HypreSolver
#define included_AMP_HypreSolver
 
 
#include "AMP/matrices/Matrix.h"
#include "AMP/solvers/SolverStrategy.h"
#include "AMP/solvers/SolverStrategyParameters.h"
 
#include "HYPRE_utilities.h"
 
// Forward declares
struct hypre_Solver_struct;
struct hypre_IJMatrix_struct;
struct hypre_IJVector_struct;
typedef struct hypre_Solver_struct *HYPRE_Solver;
typedef struct hypre_IJMatrix_struct *HYPRE_IJMatrix;
typedef struct hypre_IJVector_struct *HYPRE_IJVector;
 
 
namespace AMP::LinearAlgebra {
class HypreMatrixAdaptor;
}
 
namespace AMP::Solver {
 
 
using HypreSolverParameters = SolverStrategyParameters;
 
 
class HypreSolver : public SolverStrategy
{
 
public:
    HypreSolver();
 
    explicit HypreSolver( std::shared_ptr<HypreSolverParameters> parameters );
 
    virtual ~HypreSolver();
 
    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;
 
    void setMemoryLocation( HYPRE_MemoryLocation location ) { d_hypre_memory_location = location; }
 
    void setExecutionPolicy( HYPRE_ExecutionPolicy policy ) { d_hypre_exec_policy = policy; }
 
    HYPRE_Solver getHYPRESolver() { return d_solver; }
 
    void apply( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                std::shared_ptr<AMP::LinearAlgebra::Vector> u ) override;
 
protected:
    void createHypreSolver();
 
    void destroyHypreSolver();
 
    void setCommonParameters( std::shared_ptr<const AMP::Database> db );
 
    void createHYPREMatrix( std::shared_ptr<AMP::LinearAlgebra::Matrix> matrix );
 
    void createHYPREVectors();
 
    void copyToHypre( std::shared_ptr<const AMP::LinearAlgebra::Vector> amp_v,
                      HYPRE_IJVector hypre_v );
 
    void copyFromHypre( HYPRE_IJVector hypre_v, std::shared_ptr<AMP::LinearAlgebra::Vector> amp_v );
 
 
    void setParameters( void ); 
 
    void setupHypreMatrixAndRhs();
 
    void setupSolver();
 
    void setupNestedSolver( std::shared_ptr<const SolverStrategyParameters> parameters );
 
    void hypreSolve();
 
    void preSolve( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                   std::shared_ptr<AMP::LinearAlgebra::Vector> u );
    void postSolve( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                    std::shared_ptr<AMP::LinearAlgebra::Vector> u );
 
    bool d_bMatrixInitialized = false;
 
    bool d_bUsesPreconditioner = false;
    bool d_bDiagScalePC        = false; 
 
 
    AMP_MPI d_comm;
 
    std::shared_ptr<AMP::LinearAlgebra::Matrix> d_castedMatrix;
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_compat_amp_v;
    std::shared_ptr<AMP::LinearAlgebra::HypreMatrixAdaptor> d_HypreMatrixAdaptor;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_r;
 
    HYPRE_IJMatrix d_ijMatrix  = nullptr; 
    HYPRE_IJVector d_hypre_rhs = nullptr; 
    HYPRE_IJVector d_hypre_sol = nullptr; 
    HYPRE_Solver d_solver      = nullptr; 
 
    HYPRE_MemoryLocation d_hypre_memory_location;
    HYPRE_ExecutionPolicy d_hypre_exec_policy;
 
    HYPRE_Int d_logging = 0;
 
    HYPRE_Int ( *d_hypreCreateSolver )( MPI_Comm comm, HYPRE_Solver *solver ) = nullptr;
    HYPRE_Int ( *d_hypreDestroySolver )( HYPRE_Solver solver )                = nullptr;
 
    HYPRE_PtrToSolverFcn d_hypreSolve                                      = nullptr;
    HYPRE_Int ( *d_hypreGetNumIterations )( HYPRE_Solver solver,
                                            HYPRE_Int *num_iterations )    = nullptr;
    HYPRE_Int ( *d_hypreSetPreconditioner )( HYPRE_Solver solver,
                                             HYPRE_PtrToSolverFcn precond,
                                             HYPRE_PtrToSolverFcn precond_setup,
                                             HYPRE_Solver precond_solver ) = nullptr;
    HYPRE_Int ( *d_hypreSolverSetup )( HYPRE_Solver solver,
                                       HYPRE_Matrix A,
                                       HYPRE_Vector b,
                                       HYPRE_Vector x )                    = nullptr;
 
    HYPRE_Int ( *d_hypreSetRelativeTolerance )( HYPRE_Solver solver, HYPRE_Real tol ) = nullptr;
    HYPRE_Int ( *d_hypreSetAbsoluteTolerance )( HYPRE_Solver solver, HYPRE_Real tol ) = nullptr;
    HYPRE_Int ( *d_hypreSetMaxIterations )( HYPRE_Solver solver, HYPRE_Int max_iter ) = nullptr;
    HYPRE_Int ( *d_hypreSetPrintLevel )( HYPRE_Solver solver, HYPRE_Int level )       = nullptr;
    HYPRE_Int ( *d_hypreSetLogging )( HYPRE_Solver solver, HYPRE_Int logging )        = nullptr;
};
} // namespace AMP::Solver
 
#endif