Cycle.h

Go to the documentation of this file.

#ifndef included_AMP_AMG_Cycle
#define included_AMP_AMG_Cycle
 
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
#include "AMP/operators/LinearOperator.h"
#include "AMP/solvers/SolverStrategy.h"
#include "AMP/solvers/amg/DeferConsistency.h"
 
namespace AMP::Solver::AMG {
struct LevelOperator : HasDeferConsistency<AMP::Operator::LinearOperator> {
    using base = HasDeferConsistency<AMP::Operator::LinearOperator>;
    using base::base;
    explicit LevelOperator( const AMP::Operator::LinearOperator &linop );
 
    virtual void apply( std::shared_ptr<const LinearAlgebra::Vector> u,
                        std::shared_ptr<LinearAlgebra::Vector> f ) override;
};
 
struct Level {
    std::shared_ptr<LevelOperator> A;
    std::shared_ptr<AMP::Operator::Operator> R, P;
    std::unique_ptr<AMP::Solver::SolverStrategy> pre_relaxation, post_relaxation;
    std::shared_ptr<LinearAlgebra::Vector> x, b, r, correction;
    mutable std::size_t nrelax = 0;
};
 
template<std::size_t N>
struct LevelWithWorkspace : Level {
    // extra work vectors used in cycling
    std::array<std::shared_ptr<LinearAlgebra::Vector>, N> work;
};
 
template<class T>
constexpr bool is_level_v = std::is_base_of_v<Level, T>;
 
template<std::size_t N>
void clone_workspace( LevelWithWorkspace<N> &level, const LinearAlgebra::Vector &donor );
 
inline constexpr std::size_t num_work_kcycle = 5;
using KCycleLevel                            = LevelWithWorkspace<num_work_kcycle>;
 
void save_hierarchy( std::string_view base_name, const std::vector<KCycleLevel> &levels );
 
struct KappaKCycle {
    using level = KCycleLevel;
    enum class krylov_type { fcg, gcr };
    static krylov_type parseType( const std::string &kcycle_type );
    static std::string_view krylovTypeName( const krylov_type t );
 
    struct settings {
        size_t kappa = 1;
        float tol = 0;
        bool comm_free_interp = false;
        krylov_type type = krylov_type::fcg;
    };
 
    KappaKCycle( const settings & );
 
    void operator()( std::shared_ptr<const LinearAlgebra::Vector> b,
                     std::shared_ptr<LinearAlgebra::Vector> x,
                     const std::vector<level> &levels,
                     SolverStrategy &coarse_solver ) const;
 
private:
    void cycle( size_t lvl,
                size_t kappa,
                std::shared_ptr<const LinearAlgebra::Vector> b,
                std::shared_ptr<LinearAlgebra::Vector> x,
                const std::vector<level> &levels,
                SolverStrategy &coarse_solver ) const;
    settings d_settings;
    static inline std::map<std::string, krylov_type> type_map{ { "fcg", krylov_type::fcg },
                                                               { "gcr", krylov_type::gcr } };
};
} // namespace AMP::Solver::AMG
 
#endif