multigrid_level.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_MULTIGRID_MULTIGRID_LEVEL_HPP_
#define GKO_PUBLIC_CORE_MULTIGRID_MULTIGRID_LEVEL_HPP_
 
 
#include <functional>
#include <memory>
 
#include <ginkgo/core/base/abstract_factory.hpp>
#include <ginkgo/core/base/composition.hpp>
#include <ginkgo/core/base/exception_helpers.hpp>
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/utils.hpp>
 
 
namespace gko {
namespace multigrid {
 
 
class MultigridLevel {
public:
    virtual std::shared_ptr<const LinOp> get_fine_op() const = 0;
 
    virtual std::shared_ptr<const LinOp> get_restrict_op() const = 0;
 
    virtual std::shared_ptr<const LinOp> get_coarse_op() const = 0;
 
    virtual std::shared_ptr<const LinOp> get_prolong_op() const = 0;
};
 
 
template <typename ValueType>
class EnableMultigridLevel : public MultigridLevel,
                             public UseComposition<ValueType> {
public:
    using value_type = ValueType;
 
    std::shared_ptr<const LinOp> get_fine_op() const override
    {
        return fine_op_;
    }
 
    std::shared_ptr<const LinOp> get_restrict_op() const override
    {
        return this->get_operator_at(2);
    }
 
    std::shared_ptr<const LinOp> get_coarse_op() const override
    {
        return this->get_operator_at(1);
    }
 
    std::shared_ptr<const LinOp> get_prolong_op() const override
    {
        return this->get_operator_at(0);
    }
 
protected:
    void set_multigrid_level(std::shared_ptr<const LinOp> prolong_op,
                             std::shared_ptr<const LinOp> coarse_op,
                             std::shared_ptr<const LinOp> restrict_op)
    {
        gko::dim<2> mg_size{prolong_op->get_size()[0],
                            restrict_op->get_size()[1]};
        GKO_ASSERT_EQUAL_DIMENSIONS(fine_op_->get_size(), mg_size);
        // check mg_size is the same as fine_size
        this->set_composition(prolong_op, coarse_op, restrict_op);
    }
 
    void set_fine_op(std::shared_ptr<const LinOp> fine_op)
    {
        GKO_ASSERT_EQUAL_DIMENSIONS(fine_op_->get_size(), fine_op->get_size());
        fine_op_ = fine_op;
    }
 
    explicit EnableMultigridLevel() {}
 
    explicit EnableMultigridLevel(std::shared_ptr<const LinOp> fine_op)
        : fine_op_(fine_op)
    {}
 
private:
    std::shared_ptr<const LinOp> fine_op_;
};
 
 
}  // namespace multigrid
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_MULTIGRID_MULTIGRID_LEVEL_HPP_