Ginkgo Generated from branch based on master. Ginkgo version 1.8.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
par_ic.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_IC_HPP_
6#define GKO_PUBLIC_CORE_FACTORIZATION_PAR_IC_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/config/config.hpp>
16#include <ginkgo/core/config/registry.hpp>
17#include <ginkgo/core/matrix/csr.hpp>
18
19
20namespace gko {
26namespace factorization {
27
28
69template <typename ValueType = default_precision, typename IndexType = int32>
70class ParIc : public Composition<ValueType> {
71public:
72 using value_type = ValueType;
73 using index_type = IndexType;
75
76 std::shared_ptr<const matrix_type> get_l_factor() const
77 {
78 // Can be `static_cast` since the type is guaranteed in this class
79 return std::static_pointer_cast<const matrix_type>(
80 this->get_operators()[0]);
81 }
82
83 std::shared_ptr<const matrix_type> get_lt_factor() const
84 {
85 if (this->get_operators().size() == 2) {
86 // Can be `static_cast` since the type is guaranteed in this class
87 return std::static_pointer_cast<const matrix_type>(
88 this->get_operators()[1]);
89 } else {
90 return std::static_pointer_cast<const matrix_type>(
91 share(get_l_factor()->conj_transpose()));
92 }
93 }
94
95 // Remove the possibility of calling `create`, which was enabled by
96 // `Composition`
97 template <typename... Args>
98 static std::unique_ptr<Composition<ValueType>> create(Args&&... args) =
99 delete;
100
102 {
110
121 bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
122
127 std::shared_ptr<typename matrix_type::strategy_type>
128 GKO_FACTORY_PARAMETER_SCALAR(l_strategy, nullptr);
129
135 bool GKO_FACTORY_PARAMETER_SCALAR(both_factors, true);
136 };
139
154 const config::pnode& config, const config::registry& context,
155 const config::type_descriptor& td_for_child =
156 config::make_type_descriptor<ValueType, IndexType>());
157
158protected:
159 explicit ParIc(const Factory* factory,
160 std::shared_ptr<const LinOp> system_matrix)
161 : Composition<ValueType>(factory->get_executor()),
162 parameters_{factory->get_parameters()}
163 {
164 if (parameters_.l_strategy == nullptr) {
165 parameters_.l_strategy =
166 std::make_shared<typename matrix_type::classical>();
167 }
168 generate(system_matrix, parameters_.skip_sorting,
169 parameters_.both_factors)
170 ->move_to(this);
171 }
172
173 std::unique_ptr<Composition<ValueType>> generate(
174 const std::shared_ptr<const LinOp>& system_matrix, bool skip_sorting,
175 bool both_factors) const;
176};
177
178
179} // namespace factorization
180} // namespace gko
181
182
183#endif // GKO_PUBLIC_CORE_FACTORIZATION_PAR_IC_HPP_
The Composition class can be used to compose linear operators op1, op2, ..., opn and obtain the opera...
Definition composition.hpp:41
std::unique_ptr< LinOp > conj_transpose() const override
const std::vector< std::shared_ptr< const LinOp > > & get_operators() const noexcept
Definition composition.hpp:54
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition polymorphic_object.hpp:235
pnode describes a tree of properties.
Definition property_tree.hpp:28
This class stores additional context for creating Ginkgo objects from configuration files.
Definition registry.hpp:168
This class describes the value and index types to be used when building a Ginkgo type from a configur...
Definition type_descriptor.hpp:37
Definition par_ic.hpp:137
ParIC is an incomplete Cholesky factorization which is computed in parallel.
Definition par_ic.hpp:70
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.
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition sparsity_csr.hpp:22
#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
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:86
detail::shared_type< OwningPointer > share(OwningPointer &&p)
Marks the object pointed to by p as shared.
Definition utils_helper.hpp:226
bool skip_sorting
The system_matrix, which will be given to this factory, must be sorted (first by row,...
Definition par_ic.hpp:121
bool both_factors
true will generate both L and L^H, false will only generate the L factor, resulting in a Composition ...
Definition par_ic.hpp:135
std::shared_ptr< typename matrix_type::strategy_type > l_strategy
Strategy which will be used by the L matrix.
Definition par_ic.hpp:128