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
multigrid.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_SOLVER_MULTIGRID_HPP_
6#define GKO_PUBLIC_CORE_SOLVER_MULTIGRID_HPP_
7
8
9#include <complex>
10#include <functional>
11#include <memory>
12#include <utility>
13
14
15#include <ginkgo/core/base/abstract_factory.hpp>
16#include <ginkgo/core/base/array.hpp>
17#include <ginkgo/core/base/exception_helpers.hpp>
18#include <ginkgo/core/base/lin_op.hpp>
19#include <ginkgo/core/base/math.hpp>
20#include <ginkgo/core/base/precision_dispatch.hpp>
21#include <ginkgo/core/base/types.hpp>
22#include <ginkgo/core/log/logger.hpp>
23#include <ginkgo/core/matrix/dense.hpp>
24#include <ginkgo/core/matrix/identity.hpp>
25#include <ginkgo/core/multigrid/multigrid_level.hpp>
26#include <ginkgo/core/solver/solver_base.hpp>
27#include <ginkgo/core/stop/combined.hpp>
28#include <ginkgo/core/stop/criterion.hpp>
29
30
31namespace gko {
32namespace solver {
33
34
40namespace multigrid {
41
42
52enum class cycle { v, f, w };
53
54
68enum class mid_smooth_type { both, post_smoother, pre_smoother, standalone };
69
70
71namespace detail {
72
73
74// It should only be used internally
75class MultigridState;
76
77
78} // namespace detail
79} // namespace multigrid
80
81
105class Multigrid : public EnableLinOp<Multigrid>,
106 public EnableSolverBase<Multigrid>,
107 public EnableIterativeBase<Multigrid>,
108 public EnableApplyWithInitialGuess<Multigrid> {
109 friend class EnableLinOp<Multigrid>;
112
113public:
120 bool apply_uses_initial_guess() const override
121 {
122 return this->get_default_initial_guess() ==
124 }
125
131 std::vector<std::shared_ptr<const gko::multigrid::MultigridLevel>>
133 {
134 return mg_level_list_;
135 }
136
142 std::vector<std::shared_ptr<const LinOp>> get_pre_smoother_list() const
143 {
144 return pre_smoother_list_;
145 }
146
152 std::vector<std::shared_ptr<const LinOp>> get_mid_smoother_list() const
153 {
154 return mid_smoother_list_;
155 }
156
162 std::vector<std::shared_ptr<const LinOp>> get_post_smoother_list() const
163 {
164 return post_smoother_list_;
165 }
166
172 std::shared_ptr<const LinOp> get_coarsest_solver() const
173 {
174 return coarsest_solver_;
175 }
176
182 multigrid::cycle get_cycle() const { return parameters_.cycle; }
183
189 void set_cycle(multigrid::cycle cycle) { parameters_.cycle = cycle; }
190
191
192 class Factory;
193
195 : public enable_iterative_solver_factory_parameters<parameters_type,
196 Factory> {
200 std::vector<std::shared_ptr<const LinOpFactory>>
201 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(mg_level);
202
229 std::function<size_type(const size_type, const LinOp*)>
231
246 std::vector<std::shared_ptr<const LinOpFactory>>
247 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(pre_smoother);
248
254 std::vector<std::shared_ptr<const LinOpFactory>>
255 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(post_smoother);
256
264 std::vector<std::shared_ptr<const LinOpFactory>>
265 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(mid_smoother);
266
272
281 mid_case, multigrid::mid_smooth_type::standalone);
282
291
298
305 std::vector<std::shared_ptr<const LinOpFactory>>
306 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(coarsest_solver);
307
330 std::function<size_type(const size_type, const LinOp*)>
332
339 multigrid::cycle::v);
340
350
359
365
371
378 };
381
382protected:
383 void apply_impl(const LinOp* b, LinOp* x) const override;
384
385 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
386 LinOp* x) const override;
387
388 void apply_with_initial_guess_impl(const LinOp* b, LinOp* x,
389 initial_guess_mode guess) const override;
390
391 void apply_with_initial_guess_impl(const LinOp* alpha, const LinOp* b,
392 const LinOp* beta, LinOp* x,
393 initial_guess_mode guess) const override;
394
395 template <typename VectorType>
396 void apply_dense_impl(const VectorType* b, VectorType* x,
398
403 void generate();
404
405 explicit Multigrid(std::shared_ptr<const Executor> exec);
406
407 explicit Multigrid(const Factory* factory,
408 std::shared_ptr<const LinOp> system_matrix);
409
413 void validate();
414
424 void verify_legal_length(bool checked, size_type len, size_type ref_len);
425
426 void create_state() const;
427
428private:
429 std::vector<std::shared_ptr<const gko::multigrid::MultigridLevel>>
430 mg_level_list_{};
431 std::vector<std::shared_ptr<const LinOp>> pre_smoother_list_{};
432 std::vector<std::shared_ptr<const LinOp>> mid_smoother_list_{};
433 std::vector<std::shared_ptr<const LinOp>> post_smoother_list_{};
434 std::shared_ptr<const LinOp> coarsest_solver_{};
435 std::function<size_type(const size_type, const LinOp*)> level_selector_;
436 std::function<size_type(const size_type, const LinOp*)> solver_selector_;
437
448 mutable struct cache_struct {
449 cache_struct() = default;
450
451 ~cache_struct() = default;
452
453 cache_struct(const cache_struct&) {}
454
455 cache_struct(cache_struct&&) {}
456
457 cache_struct& operator=(const cache_struct&) { return *this; }
458
459 cache_struct& operator=(cache_struct&&) { return *this; }
460
461 // unique_ptr with default destructor does not work with the incomplete
462 // type.
463 std::shared_ptr<multigrid::detail::MultigridState> state{};
464 } cache_;
465};
466
467template <>
469 using Solver = Multigrid;
470 // number of vectors used by this workspace
471 static int num_vectors(const Solver&);
472 // number of arrays used by this workspace
473 static int num_arrays(const Solver&);
474 // array containing the num_vectors names for the workspace vectors
475 static std::vector<std::string> op_names(const Solver&);
476 // array containing the num_arrays names for the workspace vectors
477 static std::vector<std::string> array_names(const Solver&);
478 // array containing all varying scalar vectors (independent of problem size)
479 static std::vector<int> scalars(const Solver&);
480 // array containing all varying vectors (dependent on problem size)
481 static std::vector<int> vectors(const Solver&);
482
483 // stopping status array
484 constexpr static int stop = 0;
485};
486
487
488} // namespace solver
489} // namespace gko
490
491
492#endif // GKO_PUBLIC_CORE_SOLVER_MULTIGRID_HPP_
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
EnableApplyWithInitialGuess providing default operation for ApplyWithInitialGuess with correct valida...
Definition solver_base.hpp:162
A LinOp deriving from this CRTP class stores a stopping criterion factory and allows applying with a ...
Definition solver_base.hpp:704
A LinOp deriving from this CRTP class stores a system matrix.
Definition solver_base.hpp:542
Definition multigrid.hpp:379
Multigrid methods have a hierarchy of many levels, whose corase level is a subset of the fine level,...
Definition multigrid.hpp:108
std::shared_ptr< const LinOp > get_coarsest_solver() const
Gets the operator at the coarsest level.
Definition multigrid.hpp:172
std::vector< std::shared_ptr< const gko::multigrid::MultigridLevel > > get_mg_level_list() const
Gets the list of MultigridLevel operators.
Definition multigrid.hpp:132
void set_cycle(multigrid::cycle cycle)
Set the cycle of multigrid.
Definition multigrid.hpp:189
std::vector< std::shared_ptr< const LinOp > > get_mid_smoother_list() const
Gets the list of mid-smoother operators.
Definition multigrid.hpp:152
multigrid::cycle get_cycle() const
Get the cycle of multigrid.
Definition multigrid.hpp:182
bool apply_uses_initial_guess() const override
Return true as iterative solvers use the data in x as an initial guess or false if multigrid always s...
Definition multigrid.hpp:120
std::vector< std::shared_ptr< const LinOp > > get_pre_smoother_list() const
Gets the list of pre-smoother operators.
Definition multigrid.hpp:142
std::vector< std::shared_ptr< const LinOp > > get_post_smoother_list() const
Gets the list of post-smoother operators.
Definition multigrid.hpp:162
#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
mid_smooth_type
mid_smooth_type gives the options to handle the middle smoother behavior between the two cycles in th...
Definition multigrid.hpp:68
cycle
cycle defines which kind of multigrid cycle can be used.
Definition multigrid.hpp:52
initial_guess_mode
Give a initial guess mode about the input of the apply method.
Definition solver_base.hpp:34
@ provided
the input is provided
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
Definition multigrid.hpp:196
std::vector< std::shared_ptr< const LinOpFactory > > coarsest_solver
Coarsest factory list.
Definition multigrid.hpp:306
std::vector< std::shared_ptr< const LinOpFactory > > post_smoother
Post-smooth Factory list.
Definition multigrid.hpp:255
size_type max_levels
The maximum number of mg_level (without coarsest solver level) that can be used.
Definition multigrid.hpp:290
std::complex< double > smoother_relax
smoother_relax is the relaxation factor of default generated smoother.
Definition multigrid.hpp:364
std::function< size_type(const size_type, const LinOp *) solver_selector)
Custom coarsest_solver selector size_type (size_type level, const LinOp *coarsest_matrix) Selector fu...
Definition multigrid.hpp:331
size_type min_coarse_rows
The minimal number of coarse rows.
Definition multigrid.hpp:297
initial_guess_mode default_initial_guess
Default initial guess mode.
Definition multigrid.hpp:377
std::vector< std::shared_ptr< const LinOpFactory > > pre_smoother
Pre-smooth Factory list.
Definition multigrid.hpp:247
size_type kcycle_base
kcycle_base is a factor to choose how often enable FCG/GCR step.
Definition multigrid.hpp:349
size_type smoother_iters
smoother_iters is the number of iteration of default generated smoother.
Definition multigrid.hpp:370
multigrid::cycle cycle
Multigrid cycle type.
Definition multigrid.hpp:339
multigrid::mid_smooth_type mid_case
Choose the behavior of mid smoother between two cycles close to each other in the same level.
Definition multigrid.hpp:281
bool post_uses_pre
Whether post-smoothing-related calls use corresponding pre-smoothing-related calls.
Definition multigrid.hpp:271
std::vector< std::shared_ptr< const LinOpFactory > > mid_smoother
Mid-smooth Factory list.
Definition multigrid.hpp:265
double kcycle_rel_tol
kcycle_rel_tol decides whether run the second iteration of FCG/GCR step.
Definition multigrid.hpp:358
std::function< size_type(const size_type, const LinOp *) level_selector)
Custom selector size_type (size_type level, const LinOp* fine_matrix) Selector function returns the e...
Definition multigrid.hpp:230
std::vector< std::shared_ptr< const LinOpFactory > > mg_level
MultigridLevel Factory list.
Definition multigrid.hpp:201
Traits class providing information on the type and location of workspace vectors inside a solver.
Definition solver_base.hpp:239