5#ifndef GKO_PUBLIC_CORE_PRECONDITIONER_IC_HPP_
6#define GKO_PUBLIC_CORE_PRECONDITIONER_IC_HPP_
13#include <ginkgo/core/base/abstract_factory.hpp>
14#include <ginkgo/core/base/composition.hpp>
15#include <ginkgo/core/base/exception.hpp>
16#include <ginkgo/core/base/exception_helpers.hpp>
17#include <ginkgo/core/base/lin_op.hpp>
18#include <ginkgo/core/base/precision_dispatch.hpp>
19#include <ginkgo/core/base/std_extensions.hpp>
20#include <ginkgo/core/factorization/par_ic.hpp>
21#include <ginkgo/core/matrix/dense.hpp>
22#include <ginkgo/core/solver/solver_traits.hpp>
23#include <ginkgo/core/solver/triangular.hpp>
24#include <ginkgo/core/stop/combined.hpp>
25#include <ginkgo/core/stop/iteration.hpp>
26#include <ginkgo/core/stop/residual_norm.hpp>
30namespace preconditioner {
78template <
typename LSolverType = solver::LowerTrs<>,
typename IndexType =
int32>
85 std::is_same<
typename LSolverType::transposed_type::transposed_type,
87 "LSolverType::transposed_type must be symmetric");
88 using value_type =
typename LSolverType::value_type;
90 using lh_solver_type =
typename LSolverType::transposed_type;
91 using index_type = IndexType;
101 std::shared_ptr<const typename l_solver_type::Factory>
109 GKO_DEPRECATED(
"use with_l_solver instead")
114 return with_l_solver(std::move(solver));
117 parameters_type& with_l_solver(
121 this->l_solver_generator = std::move(solver);
122 this->deferred_factories[
"l_solver"] = [](
const auto& exec,
124 if (!
params.l_solver_generator.is_empty()) {
126 params.l_solver_generator.on(exec);
132 GKO_DEPRECATED(
"use with_factorization instead")
133 parameters_type& with_factorization_factory(
134 deferred_factory_parameter<
const LinOpFactory> factorization)
136 return with_factorization(std::move(factorization));
139 parameters_type& with_factorization(
142 this->factorization_generator = std::move(factorization);
143 this->deferred_factories[
"factorization"] = [](
const auto& exec,
145 if (!
params.factorization_generator.is_empty()) {
146 params.factorization_factory =
147 params.factorization_generator.on(exec);
154 deferred_factory_parameter<const typename l_solver_type::Factory>
220 if (&
other !=
this) {
223 l_solver_ =
other.l_solver_;
224 lh_solver_ =
other.lh_solver_;
225 parameters_ =
other.parameters_;
226 if (
other.get_executor() != exec) {
242 if (&
other !=
this) {
245 l_solver_ = std::move(
other.l_solver_);
246 lh_solver_ = std::move(
other.lh_solver_);
248 if (
other.get_executor() != exec) {
270 void apply_impl(
const LinOp* b,
LinOp* x)
const override
276 l_solver_->apply(
dense_b, cache_.intermediate);
277 if (lh_solver_->apply_uses_initial_guess()) {
278 dense_x->copy_from(cache_.intermediate);
280 lh_solver_->apply(cache_.intermediate,
dense_x);
285 void apply_impl(
const LinOp* alpha,
const LinOp* b,
const LinOp* beta,
286 LinOp* x)
const override
291 l_solver_->apply(
dense_b, cache_.intermediate);
298 explicit Ic(std::shared_ptr<const Executor> exec)
299 : EnableLinOp<
Ic>(std::
move(exec))
302 explicit Ic(
const Factory* factory, std::shared_ptr<const LinOp>
lin_op)
304 parameters_{
factory->get_parameters()}
307 std::dynamic_pointer_cast<const Composition<value_type>>(
lin_op);
308 std::shared_ptr<const LinOp>
l_factor;
312 auto exec =
lin_op->get_executor();
315 factorization::ParIc<value_type, index_type>::build()
316 .with_both_factors(
false)
319 auto fact = std::shared_ptr<const LinOp>(
323 std::dynamic_pointer_cast<const Composition<value_type>>(
fact);
325 GKO_NOT_SUPPORTED(
comp);
329 if (
comp->get_operators().size() > 2 ||
comp->get_operators().empty()) {
330 GKO_NOT_SUPPORTED(
comp);
333 GKO_ASSERT_IS_SQUARE_MATRIX(
l_factor);
342 if (
comp->get_operators().size() == 2) {
362 void set_cache_to(
const LinOp* b)
const
364 if (cache_.intermediate ==
nullptr) {
365 cache_.intermediate =
369 cache_.intermediate->copy_from(b);
380 template <
typename SolverType>
381 static std::enable_if_t<solver::has_with_criteria<SolverType>::value,
382 std::unique_ptr<SolverType>>
383 generate_default_solver(
const std::shared_ptr<const Executor>& exec,
384 const std::shared_ptr<const LinOp>&
mtx)
388 static_cast<unsigned int>(
mtx->get_size()[0])};
390 return SolverType::build()
402 template <
typename SolverType>
403 static std::enable_if_t<!solver::has_with_criteria<SolverType>::value,
404 std::unique_ptr<SolverType>>
405 generate_default_solver(
const std::shared_ptr<const Executor>& exec,
406 const std::shared_ptr<const LinOp>&
mtx)
408 return SolverType::build().on(exec)->generate(
mtx);
412 std::shared_ptr<const l_solver_type> l_solver_{};
413 std::shared_ptr<const lh_solver_type> lh_solver_{};
424 mutable struct cache_struct {
425 cache_struct() =
default;
426 ~cache_struct() =
default;
427 cache_struct(
const cache_struct&) {}
428 cache_struct(cache_struct&&) {}
429 cache_struct& operator=(
const cache_struct&) {
return *
this; }
430 cache_struct& operator=(cache_struct&&) {
return *
this; }
431 std::unique_ptr<LinOp> intermediate{};
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:880
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:663
Definition lin_op.hpp:118
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition polymorphic_object.hpp:235
Linear operators which support transposition should implement the Transposable interface.
Definition lin_op.hpp:434
Represents a factory parameter of factory type that can either initialized by a pre-existing factory ...
Definition abstract_factory.hpp:309
The enable_parameters_type mixin is used to create a base implementation of the factory parameters st...
Definition abstract_factory.hpp:211
static std::unique_ptr< Dense > create(std::shared_ptr< const Executor > exec, const dim< 2 > &size={}, size_type stride=0)
Creates an uninitialized Dense matrix of the specified size.
The Incomplete Cholesky (IC) preconditioner solves the equation for a given lower triangular matrix ...
Definition ic.hpp:79
std::shared_ptr< const lh_solver_type > get_lh_solver() const
Returns the solver which is used for the L^H matrix.
Definition ic.hpp:178
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.
Definition ic.hpp:183
Ic(const Ic &other)
Copy-constructs an IC preconditioner.
Definition ic.hpp:260
Ic & operator=(Ic &&other)
Move-assigns an IC preconditioner.
Definition ic.hpp:240
Ic(Ic &&other)
Move-constructs an IC preconditioner.
Definition ic.hpp:267
std::shared_ptr< const l_solver_type > get_l_solver() const
Returns the solver which is used for the provided L matrix.
Definition ic.hpp:168
Ic & operator=(const Ic &other)
Copy-assigns an IC preconditioner.
Definition ic.hpp:218
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.
Definition ic.hpp:198
The ResidualNorm class is a stopping criterion which stops the iteration process when the actual resi...
Definition residual_norm.hpp:110
#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
@ factory
LinOpFactory events.
The Ginkgo namespace.
Definition abstract_factory.hpp:20
constexpr T one()
Returns the multiplicative identity for T.
Definition math.hpp:775
typename detail::remove_complex_s< T >::type remove_complex
Obtain the type which removed the complex of complex/scalar type or the template parameter of class b...
Definition math.hpp:326
detail::cloned_type< Pointer > clone(const Pointer &p)
Creates a unique clone of the object pointed to by p.
Definition utils_helper.hpp:175
batch_dim< 2, DimensionType > transpose(const batch_dim< 2, DimensionType > &input)
Returns a batch_dim object with its dimensions swapped for batched operators.
Definition batch_dim.hpp:120
detail::shared_type< OwningPointer > share(OwningPointer &&p)
Marks the object pointed to by p as shared.
Definition utils_helper.hpp:226
std::shared_ptr< const typename l_solver_type::Factory > l_solver_factory
Factory for the L solver.
Definition ic.hpp:102
std::shared_ptr< const LinOpFactory > factorization_factory
Factory for the factorization.
Definition ic.hpp:107