pgm.hpp

// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_MULTIGRID_PGM_HPP_
#define GKO_PUBLIC_CORE_MULTIGRID_PGM_HPP_
 
 
#include <vector>
 
#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/config/registry.hpp>
#include <ginkgo/core/config/type_descriptor.hpp>
#include <ginkgo/core/distributed/matrix.hpp>
#include <ginkgo/core/matrix/csr.hpp>
#include <ginkgo/core/matrix/dense.hpp>
#include <ginkgo/core/matrix/sparsity_csr.hpp>
#include <ginkgo/core/multigrid/multigrid_level.hpp>
 
 
namespace gko {
namespace multigrid {
 
 
template <typename ValueType = default_precision, typename IndexType = int32>
class Pgm : public LinOp, public EnableMultigridLevel<ValueType> {
    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_;
    }
 
    IndexType* get_agg() noexcept { return agg_.get_data(); }
 
    const IndexType* get_const_agg() const noexcept
    {
        return agg_.get_const_data();
    }
 
    GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
    {
        unsigned GKO_FACTORY_PARAMETER_SCALAR(max_iterations, 15u);
 
        double GKO_FACTORY_PARAMETER_SCALAR(max_unassigned_ratio, 0.05);
 
        bool GKO_FACTORY_PARAMETER_SCALAR(deterministic, false);
 
        bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
    };
    class reuse_data_type;
    GKO_ENABLE_LIN_OP_FACTORY_WITH_REUSE(Pgm, parameters, Factory,
                                         reuse_data_type);
    GKO_ENABLE_BUILD_METHOD(Factory);
 
    class reuse_data_type : public LinOpFactory::ReuseData {
        friend class Pgm;
 
        bool initialized_ = false;
        bool distributed_ = false;
        dim<2> size_{};
        array<IndexType> agg_;
        std::shared_ptr<const LinOp> prolong_op_;
        std::shared_ptr<const LinOp> restrict_op_;
        std::shared_ptr<const LinOp> coarse_op_;
        std::shared_ptr<const matrix::SparsityCsr<ValueType, IndexType>>
            mapping_local_;
        std::shared_ptr<const matrix::SparsityCsr<ValueType, IndexType>>
            mapping_off_diag_;
    };
 
    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 Pgm(std::shared_ptr<const Executor> exec) : LinOp(std::move(exec))
    {}
 
    explicit Pgm(const Factory* factory,
                 std::shared_ptr<const LinOp> system_matrix)
        : Pgm(factory, std::move(system_matrix), nullptr)
    {}
 
    Pgm(const Factory* factory, std::shared_ptr<const LinOp> system_matrix,
        reuse_data_type& reuse_data)
        : Pgm(factory, std::move(system_matrix), &reuse_data)
    {}
 
    Pgm(const Factory* factory, std::shared_ptr<const LinOp> system_matrix,
        reuse_data_type* reuse_data)
        : LinOp(factory->get_executor(), system_matrix->get_size()),
          EnableMultigridLevel<ValueType>(system_matrix),
          parameters_{factory->get_parameters()},
          system_matrix_{system_matrix},
          agg_(factory->get_executor(), system_matrix_->get_size()[0])
    {
        GKO_ASSERT(parameters_.max_unassigned_ratio <= 1.0);
        GKO_ASSERT(parameters_.max_unassigned_ratio >= 0.0);
        if (system_matrix_->get_size()[0] != 0) {
            // generate on the existed matrix
            if (reuse_data && reuse_data->initialized_) {
                this->generate_from(*reuse_data);
            } else {
                this->generate(reuse_data);
            }
        }
    }
 
    void generate(reuse_data_type* reuse_data);
 
    void generate_from(const reuse_data_type& reuse_data);
 
    static void check_reuse_consistent(const Factory* factory,
                                       const LinOp* input,
                                       const reuse_data_type& reuse_data);
 
    std::tuple<std::shared_ptr<LinOp>, std::shared_ptr<LinOp>,
               std::shared_ptr<LinOp>>
    generate_local(
        std::shared_ptr<const matrix::Csr<ValueType, IndexType>> local_matrix,
        std::shared_ptr<const matrix::SparsityCsr<ValueType, IndexType>>*
            mapping = nullptr);
 
    std::shared_ptr<const matrix::Csr<ValueType, IndexType>>
    convert_local_fine_op(std::shared_ptr<const LinOp> system_matrix) const;
 
#if GINKGO_BUILD_MPI
 
    std::shared_ptr<const LinOp> convert_distributed_fine_op(
        std::shared_ptr<const LinOp> system_matrix) const;
 
    template <typename GlobalIndexType>
    array<GlobalIndexType> communicate_off_diag_agg(
        std::shared_ptr<const experimental::distributed::Matrix<
            ValueType, IndexType, GlobalIndexType>>
            matrix,
        std::shared_ptr<
            experimental::distributed::Partition<IndexType, GlobalIndexType>>
            coarse_partition,
        const array<IndexType>& local_agg);
#endif
 
private:
    std::shared_ptr<const LinOp> system_matrix_{};
    array<IndexType> agg_;
};
 
 
template <typename ValueType = default_precision, typename IndexType = int32>
using AmgxPgm GKO_DEPRECATED(
    "This class is deprecated and will be removed in the next "
    "major release. Please use Pgm instead.") = Pgm<ValueType, IndexType>;
 
 
}  // namespace multigrid
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_MULTIGRID_PGM_HPP_