Ginkgo Generated from develop branch based on develop. Ginkgo version 1.8.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
par_ict.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_
6#define GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_
7
8
9#include <memory>
10
11
12#include <ginkgo/core/base/composition.hpp>
13#include <ginkgo/core/base/lin_op.hpp>
14#include <ginkgo/core/base/types.hpp>
15#include <ginkgo/core/matrix/csr.hpp>
16
17
18namespace gko {
24namespace factorization {
25
26
67template <typename ValueType = default_precision, typename IndexType = int32>
68class ParIct : public Composition<ValueType> {
69public:
70 using value_type = ValueType;
71 using index_type = IndexType;
73
74 std::shared_ptr<const matrix_type> get_l_factor() const
75 {
76 // Can be `static_cast` since the type is guaranteed in this class
77 return std::static_pointer_cast<const matrix_type>(
78 this->get_operators()[0]);
79 }
80
81 std::shared_ptr<const matrix_type> get_lt_factor() const
82 {
83 // Can be `static_cast` since the type is guaranteed in this class
84 return std::static_pointer_cast<const matrix_type>(
85 this->get_operators()[1]);
86 }
87
88 // Remove the possibility of calling `create`, which was enabled by
89 // `Composition`
90 template <typename... Args>
91 static std::unique_ptr<Composition<ValueType>> create(Args&&... args) =
92 delete;
93
95 {
101
119 bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
120
135 bool GKO_FACTORY_PARAMETER_SCALAR(approximate_select, true);
136
154 bool GKO_FACTORY_PARAMETER_SCALAR(deterministic_sample, false);
155
168 double GKO_FACTORY_PARAMETER_SCALAR(fill_in_limit, 2.0);
169
174 std::shared_ptr<typename matrix_type::strategy_type>
175 GKO_FACTORY_PARAMETER_SCALAR(l_strategy, nullptr);
176
181 std::shared_ptr<typename matrix_type::strategy_type>
182 GKO_FACTORY_PARAMETER_SCALAR(lt_strategy, nullptr);
183 };
186
187protected:
188 explicit ParIct(const Factory* factory,
189 std::shared_ptr<const LinOp> system_matrix)
190 : Composition<ValueType>(factory->get_executor()),
191 parameters_{factory->get_parameters()}
192 {
193 if (parameters_.l_strategy == nullptr) {
194 parameters_.l_strategy =
195 std::make_shared<typename matrix_type::classical>();
196 }
197 if (parameters_.lt_strategy == nullptr) {
198 parameters_.lt_strategy =
199 std::make_shared<typename matrix_type::classical>();
200 }
201 generate_l_lt(std::move(system_matrix))->move_to(this);
202 }
203
216 std::unique_ptr<Composition<ValueType>> generate_l_lt(
217 const std::shared_ptr<const LinOp>& system_matrix) const;
218};
219
220
221} // namespace factorization
222} // namespace gko
223
224
225#endif // GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_
The Composition class can be used to compose linear operators op1, op2, ..., opn and obtain the opera...
Definition composition.hpp:41
const std::vector< std::shared_ptr< const LinOp > > & get_operators() const noexcept
Returns a list of operators of the composition.
Definition composition.hpp:54
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition polymorphic_object.hpp:235
Definition par_ict.hpp:184
ParICT is an incomplete threshold-based Cholesky factorization which is computed in parallel.
Definition par_ict.hpp:68
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:117
#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
#define GKO_FACTORY_PARAMETER_SCALAR(_name, _default)
Creates a scalar factory parameter in the factory parameters structure.
Definition abstract_factory.hpp:445
#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
#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:1018
The Ginkgo namespace.
Definition abstract_factory.hpp:20
constexpr T one()
Returns the multiplicative identity for T.
Definition math.hpp:775
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:92
std::shared_ptr< typename matrix_type::strategy_type > l_strategy
Strategy which will be used by the L matrix.
Definition par_ict.hpp:175
std::shared_ptr< typename matrix_type::strategy_type > lt_strategy
Strategy which will be used by the L^T matrix.
Definition par_ict.hpp:182