SolverStrategy.h

Go to the documentation of this file.

#ifndef included_AMP_SolverStrategy
#define included_AMP_SolverStrategy
 
#include "AMP/operators/Operator.h"
#include "AMP/solvers/SolverStrategyParameters.h"
#include "AMP/utils/Backend.h"
#include "AMP/utils/Memory.h"
#include "AMP/vectors/Vector.h"
 
#include <memory>
 
 
// Declare some classes
namespace AMP::IO {
class Writer;
} // namespace AMP::IO
 
 
namespace AMP::Solver {
 
class SolverStrategy
{
public:
    typedef std::shared_ptr<AMP::Solver::SolverStrategy> shared_ptr;
 
    SolverStrategy();
 
    explicit SolverStrategy( std::shared_ptr<const SolverStrategyParameters> parameters );
 
    virtual ~SolverStrategy();
 
    virtual std::string type() const = 0;
 
    enum class SolverStatus {
        ConvergedOnAbsTol,
        ConvergedOnRelTol,
        ConvergedUserCondition,
        MaxIterations,
        DivergedLineSearch,
        DivergedStepSize,
        DivergedFunctionCount,
        DivergedOnNan,
        DivergedNestedSolver,
        DivergedOther
    };
 
    static std::string statusToString( SolverStatus status )
    {
        switch ( status ) {
        case SolverStatus::ConvergedOnAbsTol:
            return "ConvergedOnAbsTol";
        case SolverStatus::ConvergedOnRelTol:
            return "ConvergedOnRelTol";
        case SolverStatus::ConvergedUserCondition:
            return "ConvergedUserCondition";
        case SolverStatus::MaxIterations:
            return "MaxIterations";
        case SolverStatus::DivergedLineSearch:
            return "DivergedLineSearch";
        case SolverStatus::DivergedStepSize:
            return "DivergedStepSize";
        case SolverStatus::DivergedFunctionCount:
            return "DivergedFunctionCount";
        case SolverStatus::DivergedOnNan:
            return "DivergedOnNan";
        case SolverStatus::DivergedNestedSolver:
            return "DivergedNestedSolver";
        default:
            return "DivergedOther";
        }
    }
 
    virtual void apply( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                        std::shared_ptr<AMP::LinearAlgebra::Vector> u ) = 0;
 
    virtual void initialize( std::shared_ptr<const SolverStrategyParameters> parameters );
 
    virtual void setInitialGuess( std::shared_ptr<AMP::LinearAlgebra::Vector> initialGuess );
 
    virtual void setDebugPrintInfoLevel( int print_level ) { d_iDebugPrintInfoLevel = print_level; }
 
    int getDebugPrintInfoLevel( void ) { return d_iDebugPrintInfoLevel; }
 
    virtual int getIterations( void ) const { return ( d_iNumberIterations ); }
 
    virtual void setZeroInitialGuess( bool use_zero_guess )
    {
        d_bUseZeroInitialGuess = use_zero_guess;
    }
 
    virtual void setNestedSolver( std::shared_ptr<SolverStrategy> solver )
    {
        d_pNestedSolver = solver;
        d_pNestedSolver->setIsNestedSolver( true );
    }
 
    void setIsNestedSolver( bool is_nested ) { d_bIsNestedSolver = is_nested; }
 
    virtual std::shared_ptr<SolverStrategy> getNestedSolver( void ) { return d_pNestedSolver; }
 
    virtual void registerOperator( std::shared_ptr<AMP::Operator::Operator> op );
 
    virtual void registerWriter( std::shared_ptr<AMP::IO::Writer> writer ) { d_writer = writer; }
 
    virtual void
    resetOperator( std::shared_ptr<const AMP::Operator::OperatorParameters> parameters );
 
    virtual void reset( std::shared_ptr<SolverStrategyParameters> parameters );
 
    virtual std::shared_ptr<AMP::Operator::Operator> getOperator( void );
 
    AMP::Scalar getAbsoluteTolerance() const { return ( d_dAbsoluteTolerance ); }
 
    virtual void setAbsoluteTolerance( AMP::Scalar abs_tol ) { d_dAbsoluteTolerance = abs_tol; }
 
    AMP::Scalar getRelativeTolerance() const { return ( d_dRelativeTolerance ); }
 
    virtual void setRelativeTolerance( AMP::Scalar rel_tol ) { d_dRelativeTolerance = rel_tol; }
 
    virtual void setMaxIterations( const int max_iterations ) { d_iMaxIterations = max_iterations; }
 
    int getMaxIterations( void ) const { return d_iMaxIterations; }
 
    virtual void printStatistics( std::ostream &os = AMP::pout )
    {
        os << "Not implemented for this solver!" << std::endl;
    }
 
    bool getConverged( void ) const
    {
        return d_ConvergenceStatus <= SolverStatus::ConvergedUserCondition ? 1 : 0;
    }
 
    SolverStatus getConvergenceStatus( void ) const { return d_ConvergenceStatus; }
 
    std::string getConvergenceStatusString( void ) const
    {
        return statusToString( d_ConvergenceStatus );
    }
 
    virtual void print( std::ostream & ) {}
 
    virtual AMP::Scalar getResidualNorm( void ) const { return d_dResidualNorm; }
 
    virtual AMP::Scalar getInitialResidual( void ) const { return d_dInitialResidual; }
 
    virtual const std::vector<int> &getIterationHistory( void ) { return d_iterationHistory; }
 
    int getTotalNumberOfIterations( void );
 
    virtual void residual( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                           std::shared_ptr<const AMP::LinearAlgebra::Vector> u,
                           std::shared_ptr<AMP::LinearAlgebra::Vector> r );
 
    virtual void printConvergenceStatus( SolverStrategy::SolverStatus,
                                         std::ostream & = AMP::pout ) const
    {
    }
 
    // and nonlinear function for correct solution.
    // The first vector is for solution scaling, the second for function
    void setComponentScalings( std::shared_ptr<AMP::LinearAlgebra::Vector> s,
                               std::shared_ptr<AMP::LinearAlgebra::Vector> f )
    {
        d_pSolutionScaling = s;
        d_pFunctionScaling = f;
    }
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> getSolutionScaling() { return d_pSolutionScaling; }
    std::shared_ptr<AMP::LinearAlgebra::Vector> getFunctionScaling() { return d_pFunctionScaling; }
 
    AMP::Utilities::ExecutionSpace getExecutionSpace() const { return d_exec_space; }
    void setExecutionSpace( AMP::Utilities::ExecutionSpace space ) { d_exec_space = space; }
 
protected:
    void getBaseFromInput( std::shared_ptr<AMP::Database> db );
    virtual bool checkStoppingCriteria( AMP::Scalar res_norm, bool check_iters = true );
 
    SolverStatus d_ConvergenceStatus = SolverStatus::DivergedOther;
 
    std::string d_sName;
 
    int d_iNumberIterations = 0; // iterations in solver
 
    int d_iMaxIterations = 0;
 
    AMP::Scalar d_dResidualNorm;
    AMP::Scalar d_dInitialResidual;
 
    AMP::Scalar d_dAbsoluteTolerance = 1.0e-14;
    AMP::Scalar d_dRelativeTolerance = 1.0e-09;
 
    int d_iDebugPrintInfoLevel = 0;
 
    bool d_bUseZeroInitialGuess = true;
 
    bool d_bIsNestedSolver  = false;
    bool d_bComputeResidual = false;
 
    int d_iObjectId;
 
    static int d_iInstanceId; // used to differentiate between different instances of the class
 
    std::vector<int> d_iterationHistory;
 
    std::shared_ptr<AMP::Database> d_db = nullptr;
 
    std::shared_ptr<AMP::Database> d_global_db = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_pSolutionScaling;
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_pFunctionScaling;
 
    std::shared_ptr<AMP::Operator::Operator> d_pOperator = nullptr;
 
    std::shared_ptr<AMP::Solver::SolverStrategy> d_pNestedSolver = nullptr;
 
    std::shared_ptr<AMP::IO::Writer> d_writer = nullptr;
 
    AMP::Utilities::ExecutionSpace d_exec_space = AMP::Utilities::ExecutionSpace::unspecified;
 
    AMP::Utilities::MemoryType d_memory_location = AMP::Utilities::MemoryType::none;
 
private:
};
 
} // namespace AMP::Solver
 
#endif