NonlinearKrylovAccelerator.h

Go to the documentation of this file.

#ifndef included_NonlinearKrylovAccelerator
#define included_NonlinearKrylovAccelerator
 
#include "AMP/solvers/SolverStrategy.h"
#include "AMP/utils/AMP_MPI.h"
 
namespace AMP {
class Database;
namespace Solver {
class SolverStrategyParameters;
}
} // namespace AMP
 
namespace AMP::Solver {
 
template<typename T = double>
class NonlinearKrylovAccelerator : public AMP::Solver::SolverStrategy
{
 
public:
    explicit NonlinearKrylovAccelerator(
        std::shared_ptr<AMP::Solver::SolverStrategyParameters> params );
 
    ~NonlinearKrylovAccelerator();
 
    static std::unique_ptr<AMP::Solver::SolverStrategy>
    createSolver( std::shared_ptr<AMP::Solver::SolverStrategyParameters> solverStrategyParameters )
    {
        return std::make_unique<NonlinearKrylovAccelerator<T>>( solverStrategyParameters );
    }
 
    std::string type() const override { return "NKASolver"; }
 
    void
    initialize( std::shared_ptr<const AMP::Solver::SolverStrategyParameters> parameters ) override;
 
    void reset( std::shared_ptr<AMP::Solver::SolverStrategyParameters> parameters ) override;
 
    void correction( std::shared_ptr<AMP::LinearAlgebra::Vector> f );
 
    void restart( void );
 
    void relax( void );
 
    int getMaxNonlinearIterations() const;
 
    void setMaxNonlinearIterations( int max_nli );
 
    int getMaxFunctionEvaluations() const;
 
    void setMaxFunctionEvaluations( int max_feval );
 
    void apply( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                std::shared_ptr<AMP::LinearAlgebra::Vector> u ) override;
 
    void printStatistics( std::ostream &os ) override;
 
    void registerOperator( std::shared_ptr<AMP::Operator::Operator> op ) override final;
 
private:
    NonlinearKrylovAccelerator()                                     = delete;
    NonlinearKrylovAccelerator( const NonlinearKrylovAccelerator & ) = delete;
    NonlinearKrylovAccelerator( NonlinearKrylovAccelerator && )      = delete;
    NonlinearKrylovAccelerator &operator=( const NonlinearKrylovAccelerator & ) = delete;
 
 
    void getFromInput( std::shared_ptr<AMP::Database> db );
 
    void initialize( std::shared_ptr<AMP::LinearAlgebra::Vector> solution_vector );
 
    std::shared_ptr<AMP::Operator::Operator>
    createPreconditionerOperator( std::shared_ptr<AMP::Operator::Operator> op );
 
    void factorizeNormalMatrix( void );
 
    std::vector<T> forwardbackwardSolve( std::shared_ptr<AMP::LinearAlgebra::Vector> f );
 
    bool d_subspace = false; 
    bool d_pending  = false; 
    bool d_use_qr   = false; 
 
    int d_mvec = 0;   
    T d_vtol   = 0.0; 
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_solution_vector;   
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_residual_vector;   
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_correction_vector; 
 
    std::vector<std::shared_ptr<AMP::LinearAlgebra::Vector>> d_v; 
    std::vector<std::shared_ptr<AMP::LinearAlgebra::Vector>> d_w; 
    T **d_h; 
 
    /* Linked-list organization of the vector storage. */
    int d_first = 0;         
    int d_last  = 0;         
    int d_free  = 0;         
    std::vector<int> d_next; 
    std::vector<int> d_prev; 
 
    int d_maximum_function_evals = 0;
    int d_current_correction     = 0; 
    int d_preconditioner_apply_count =
        0;                          
    int d_function_apply_count = 0; 
 
    T d_eta = 1.0; 
 
    bool d_uses_preconditioner = false; 
    bool d_freeze_pc       = true;  
    bool d_print_residuals = false; 
    bool d_solver_initialized = false;
    bool d_use_damping        = false; 
    bool d_adaptive_damping   = false; 
};
} // namespace AMP::Solver
 
#endif