rs.hpp

// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_MULTIGRID_RS_HPP_
#define GKO_PUBLIC_CORE_MULTIGRID_RS_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/types.hpp>
#include <ginkgo/core/config/config.hpp>
#include <ginkgo/core/matrix/csr.hpp>
#include <ginkgo/core/matrix/dense.hpp>
#include <ginkgo/core/multigrid/multigrid_level.hpp>
 
#include "ginkgo/core/base/math.hpp"
 
 
namespace gko {
namespace multigrid {
 
 
template <typename ValueType = default_precision, typename IndexType = int32>
class Rs : public EnableLinOp<Rs<ValueType, IndexType>>,
           public EnableMultigridLevel<ValueType> {
    friend class EnableLinOp<Rs>;
    friend class EnablePolymorphicObject<Rs, LinOp>;
    GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
 
public:
    using value_type = ValueType;
    using index_type = IndexType;
 
    std::shared_ptr<const LinOp> get_system_matrix() const
    {
        return system_matrix_;
    }
 
 
    GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
    {
        // Strength-of-connection threshold, theta
        double GKO_FACTORY_PARAMETER_SCALAR(strength_threshold, 0.25);
 
        // Skips Csr sorting if set to true
        bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
 
        // RS-coarsening only works for M-matrices. If this is true, skips this
        // (potentially heavy) check
        bool GKO_FACTORY_PARAMETER_SCALAR(skip_m_matrix_check, false);
    };
    GKO_ENABLE_LIN_OP_FACTORY(Rs, parameters, Factory);
    GKO_ENABLE_BUILD_METHOD(Factory);
 
    static parameters_type parse(
        const config::pnode& config, const config::registry& context,
        const config::type_descriptor& td_for_child =
            config::make_type_descriptor<ValueType, IndexType>());
 
protected:
    void apply_impl(const LinOp* b, LinOp* x) const override
    {
        this->get_composition()->apply(b, x);
    }
 
    void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
                    LinOp* x) const override
    {
        this->get_composition()->apply(alpha, b, beta, x);
    }
 
    explicit Rs(std::shared_ptr<const Executor> exec)
        : EnableLinOp<Rs>(std::move(exec))
    {}
 
    explicit Rs(const Factory* factory,
                std::shared_ptr<const LinOp> system_matrix)
        : EnableLinOp<Rs>(factory->get_executor(), system_matrix->get_size()),
          EnableMultigridLevel<ValueType>(system_matrix),
          parameters_{factory->get_parameters()},
          system_matrix_{system_matrix}
    {
        if (system_matrix_->get_size()[0] != 0) {
            // generate on the existing matrix
            this->generate();
        }
    }
 
    void generate();
 
private:
    std::shared_ptr<const LinOp> system_matrix_{};
};
 
 
}  // namespace multigrid
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_MULTIGRID_RS_HPP_