SASolver.h

Go to the documentation of this file.

#ifndef included_AMP_SASolver_H_
#define included_AMP_SASolver_H_
 
#include "AMP/matrices/CSRMatrix.h"
#include "AMP/matrices/data/CSRLocalMatrixData.h"
#include "AMP/matrices/data/CSRMatrixData.h"
#include "AMP/solvers/SolverFactory.h"
#include "AMP/solvers/SolverStrategy.h"
#include "AMP/solvers/SolverStrategyParameters.h"
#include "AMP/solvers/amg/Aggregation.h"
#include "AMP/solvers/amg/AggregationSettings.h"
#include "AMP/solvers/amg/Aggregator.h"
#include "AMP/solvers/amg/Cycle.h"
#include "AMP/solvers/amg/Relaxation.h"
#include "AMP/utils/Database.h"
#include "AMP/vectors/Variable.h"
 
#include <memory>
#include <vector>
 
namespace AMP::Solver::AMG {
 
struct SASolver : SolverStrategy {
public:
    explicit SASolver( std::shared_ptr<SolverStrategyParameters> );
 
    static std::unique_ptr<SolverStrategy>
    createSolver( std::shared_ptr<SolverStrategyParameters> params )
    {
        return std::make_unique<SASolver>( params );
    }
 
    std::string type() const override { return "SASolver"; }
 
    void registerOperator( std::shared_ptr<Operator::Operator> ) override;
 
    void getFromInput( std::shared_ptr<Database> );
 
    void apply( std::shared_ptr<const LinearAlgebra::Vector> f,
                std::shared_ptr<LinearAlgebra::Vector> u ) override;
 
protected:
    // **** settings applicable to solver as a whole **** //
    Utilities::MemoryType d_mem_loc;
    size_t d_max_levels;
    int d_min_coarse_local;
    size_t d_min_coarse_global;
    KappaKCycle::settings d_cycle_settings;
    bool d_save_to_file;
    bool d_save_to_file_on_ftc;
    std::string d_save_to_file_name;
 
    // **** settings that can change level-by-level **** //
    int d_num_smooth_prol;
    float d_prol_spec_lower;
    float d_prol_trunc;
    std::string d_agg_type;
    CoarsenSettings d_coarsen_settings;
    PairwiseCoarsenSettings d_pair_coarsen_settings;
    std::shared_ptr<AMP::Database> d_pre_relax_db;
    std::shared_ptr<AMP::Database> d_post_relax_db;
 
    std::vector<AMG::KCycleLevel> d_levels;
    std::shared_ptr<AMG::Aggregator> d_aggregator;
    std::shared_ptr<AMG::RelaxationParameters> d_pre_relax_params;
    std::shared_ptr<AMG::RelaxationParameters> d_post_relax_params;
    std::shared_ptr<SolverStrategyParameters> d_coarse_solver_params;
    std::unique_ptr<SolverStrategy> d_coarse_solver;
 
    void resetLevelOptions();
    void setLevelOptions( const size_t lvl );
 
    void setup( std::shared_ptr<LinearAlgebra::Variable> xVar,
                std::shared_ptr<LinearAlgebra::Variable> bVar );
 
    void makeCoarseSolver();
 
    std::unique_ptr<SolverStrategy>
    createRelaxation( size_t lvl,
                      std::shared_ptr<Operator::Operator> A,
                      std::shared_ptr<AMG::RelaxationParameters> params );
 
    void smoothP_JacobiL1( std::shared_ptr<LinearAlgebra::Matrix> A,
                           std::shared_ptr<LinearAlgebra::Matrix> &P ) const;
};
 
} // namespace AMP::Solver::AMG
 
#endif