Ginkgo: ginkgo/core/factorization/ilu.hpp Source File

| Ginkgo Generated from branch based on main. Ginkgo version 1.11.0 A numerical linear algebra library targeting many-core architectures

Loading...
Searching...
No Matches
ilu.hpp
1// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_FACTORIZATION_ILU_HPP_
6#define GKO_PUBLIC_CORE_FACTORIZATION_ILU_HPP_
7
8
9#include <memory>
10
11#include <ginkgo/core/base/composition.hpp>
12#include <ginkgo/core/base/lin_op.hpp>
13#include <ginkgo/core/base/types.hpp>
14#include <ginkgo/core/config/config.hpp>
15#include <ginkgo/core/config/registry.hpp>
16#include <ginkgo/core/factorization/incomplete_factorization.hpp>
17#include <ginkgo/core/matrix/csr.hpp>
18
19
20namespace gko {
26namespace factorization {
27
28
43template <typename ValueType = gko::default_precision,
44 typename IndexType = gko::int32>
45 class Ilu : public Composition<ValueType> {
46 GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
47
48public:
49 using value_type = ValueType;
50 using index_type = IndexType;
51 using matrix_type = matrix::Csr<ValueType, IndexType>;
52
53 std::shared_ptr<const matrix_type> get_l_factor() const
54 {
55 // Can be `static_cast` since the type is guaranteed in this class
56 return std::static_pointer_cast<const matrix_type>(
57 this->get_operators()[0]);
58 }
59
60 std::shared_ptr<const matrix_type> get_u_factor() const
61 {
62 // Can be `static_cast` since the type is guaranteed in this class
63 return std::static_pointer_cast<const matrix_type>(
64 this->get_operators()[1]);
65 }
66
67 // Remove the possibility of calling `create`, which was enabled by
68 // `Composition`
69 template <typename... Args>
70 static std::unique_ptr<Composition<ValueType>> create(Args&&... args) =
71 delete;
72
73 GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
74 {
79 std::shared_ptr<typename matrix_type::strategy_type>
80 GKO_FACTORY_PARAMETER_SCALAR(l_strategy, nullptr);
81
86 std::shared_ptr<typename matrix_type::strategy_type>
87 GKO_FACTORY_PARAMETER_SCALAR(u_strategy, nullptr);
88
99 bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
100
108 incomplete_algorithm GKO_FACTORY_PARAMETER_SCALAR(
109 algorithm, incomplete_algorithm::sparselib);
110 };
111 GKO_ENABLE_LIN_OP_FACTORY(Ilu, parameters, Factory);
112 GKO_ENABLE_BUILD_METHOD(Factory);
113
127 static parameters_type parse(
128 const config::pnode& config, const config::registry& context,
129 const config::type_descriptor& td_for_child =
130 config::make_type_descriptor<ValueType, IndexType>());
131
132protected:
133 Ilu(const Factory* factory, std::shared_ptr<const gko::LinOp> system_matrix)
134 : Composition<ValueType>{factory->get_executor()},
135 parameters_{factory->get_parameters()}
136 {
137 if (parameters_.l_strategy == nullptr) {
138 parameters_.l_strategy =
139 std::make_shared<typename matrix_type::classical>();
140 }
141 if (parameters_.u_strategy == nullptr) {
142 parameters_.u_strategy =
143 std::make_shared<typename matrix_type::classical>();
144 }
145 generate_l_u(system_matrix, parameters_.skip_sorting)->move_to(this);
146 }
147
163 std::unique_ptr<Composition<ValueType>> generate_l_u(
164 const std::shared_ptr<const LinOp>& system_matrix,
165 bool skip_sorting) const;
166};
167
168
169} // namespace factorization
170} // namespace gko
171
172
173#endif // GKO_PUBLIC_CORE_FACTORIZATION_ILU_HPP_
gko::Composition< gko::default_precision >::Composition
Composition(const Composition &)
gko::Composition< gko::default_precision >::get_operators
const std::vector< std::shared_ptr< const LinOp > > & get_operators() const noexcept
Definition composition.hpp:55
gko::config::pnode
pnode describes a tree of properties.
Definition property_tree.hpp:28
gko::config::registry
This class stores additional context for creating Ginkgo objects from configuration files.
Definition registry.hpp:167
gko::config::type_descriptor
This class describes the value and index types to be used when building a Ginkgo type from a configur...
Definition type_descriptor.hpp:39
gko::factorization::Ilu::Factory
Definition ilu.hpp:111
gko::factorization::Ilu::parse
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 >())
Create the parameters from the property_tree.
gko::matrix::Csr
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:126
GKO_CREATE_FACTORY_PARAMETERS
#define GKO_CREATE_FACTORY_PARAMETERS(_parameters_name, _factory_name)
This Macro will generate a new type containing the parameters for the factory _factory_name.
Definition abstract_factory.hpp:280
GKO_FACTORY_PARAMETER_SCALAR
#define GKO_FACTORY_PARAMETER_SCALAR(_name, _default)
Creates a scalar factory parameter in the factory parameters structure.
Definition abstract_factory.hpp:445
GKO_ENABLE_BUILD_METHOD
#define GKO_ENABLE_BUILD_METHOD(_factory_name)
Defines a build method for the factory, simplifying its construction by removing the repetitive typin...
Definition abstract_factory.hpp:394
GKO_ENABLE_LIN_OP_FACTORY
#define GKO_ENABLE_LIN_OP_FACTORY(_lin_op, _parameters_name, _factory_name)
This macro will generate a default implementation of a LinOpFactory for the LinOp subclass it is defi...
Definition lin_op.hpp:1017
gko::factorization
The Factorization namespace.
Definition ic.hpp:26
gko::factorization::incomplete_algorithm
incomplete_algorithm
An enum class for algorithm selection in the incomplete factorization.
Definition incomplete_factorization.hpp:19
gko
The Ginkgo namespace.
Definition abstract_factory.hpp:20
gko::int32
std::int32_t int32
32-bit signed integral type.
Definition types.hpp:107
gko::default_precision
double default_precision
Precision used if no precision is explicitly specified.
Definition types.hpp:172
gko::factorization::Ilu::parameters_type
Definition ilu.hpp:74
gko::factorization::Ilu::parameters_type::skip_sorting
bool skip_sorting
The system_matrix, which will be given to this factory, must be sorted (first by row,...
Definition ilu.hpp:99
gko::factorization::Ilu::parameters_type::l_strategy
std::shared_ptr< typename matrix_type::strategy_type > l_strategy
Strategy which will be used by the L matrix.
Definition ilu.hpp:80
gko::factorization::Ilu::parameters_type::algorithm
incomplete_algorithm algorithm
Select the implementation which is supposed to be used for the incomplete factorization.
Definition ilu.hpp:109
gko::factorization::Ilu::parameters_type::u_strategy
std::shared_ptr< typename matrix_type::strategy_type > u_strategy
Strategy which will be used by the U matrix.
Definition ilu.hpp:87