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
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/config/config.hpp>
23#include <ginkgo/core/config/registry.hpp>
24#include <ginkgo/core/config/type_descriptor.hpp>
25#include <ginkgo/core/log/logger.hpp>
26#include <ginkgo/core/matrix/dense.hpp>
27#include <ginkgo/core/matrix/identity.hpp>
28#include <ginkgo/core/multigrid/multigrid_level.hpp>
29#include <ginkgo/core/solver/solver_base.hpp>
30#include <ginkgo/core/stop/combined.hpp>
31#include <ginkgo/core/stop/criterion.hpp>
32
33
34namespace gko {
35namespace solver {
36
37
43namespace multigrid {
44
45
55enum class cycle { v, f, w };
56
57
71enum class mid_smooth_type { both, post_smoother, pre_smoother, standalone };
72
73
74namespace detail {
75
76
77// It should only be used internally
78class MultigridState;
79
80
81} // namespace detail
82} // namespace multigrid
83
84
108class Multigrid : public EnableLinOp<Multigrid>,
109 public EnableSolverBase<Multigrid>,
110 public EnableIterativeBase<Multigrid>,
111 public EnableApplyWithInitialGuess<Multigrid> {
112 friend class EnableLinOp<Multigrid>;
115
116public:
123 bool apply_uses_initial_guess() const override
124 {
125 return this->get_default_initial_guess() ==
127 }
128
134 std::vector<std::shared_ptr<const gko::multigrid::MultigridLevel>>
136 {
137 return mg_level_list_;
138 }
139
145 std::vector<std::shared_ptr<const LinOp>> get_pre_smoother_list() const
146 {
147 return pre_smoother_list_;
148 }
149
155 std::vector<std::shared_ptr<const LinOp>> get_mid_smoother_list() const
156 {
157 return mid_smoother_list_;
158 }
159
165 std::vector<std::shared_ptr<const LinOp>> get_post_smoother_list() const
166 {
167 return post_smoother_list_;
168 }
169
175 std::shared_ptr<const LinOp> get_coarsest_solver() const
176 {
177 return coarsest_solver_;
178 }
179
185 multigrid::cycle get_cycle() const { return parameters_.cycle; }
186
192 void set_cycle(multigrid::cycle cycle) { parameters_.cycle = cycle; }
193
194
195 class Factory;
196
198 : public enable_iterative_solver_factory_parameters<parameters_type,
199 Factory> {
203 std::vector<std::shared_ptr<const LinOpFactory>>
204 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(mg_level);
205
232 std::function<size_type(const size_type, const LinOp*)>
234
249 std::vector<std::shared_ptr<const LinOpFactory>>
250 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(pre_smoother);
251
257 std::vector<std::shared_ptr<const LinOpFactory>>
258 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(post_smoother);
259
267 std::vector<std::shared_ptr<const LinOpFactory>>
268 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(mid_smoother);
269
275
284 mid_case, multigrid::mid_smooth_type::standalone);
285
294
301
308 std::vector<std::shared_ptr<const LinOpFactory>>
309 GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(coarsest_solver);
310
333 std::function<size_type(const size_type, const LinOp*)>
335
342 multigrid::cycle::v);
343
353
362
368
374
381 };
384
399 static parameters_type parse(const config::pnode& config,
400 const config::registry& context,
401 const config::type_descriptor& td_for_child =
402 config::make_type_descriptor<>());
403
404protected:
405 void apply_impl(const LinOp* b, LinOp* x) const override;
406
407 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
408 LinOp* x) const override;
409
410 void apply_with_initial_guess_impl(const LinOp* b, LinOp* x,
411 initial_guess_mode guess) const override;
412
413 void apply_with_initial_guess_impl(const LinOp* alpha, const LinOp* b,
414 const LinOp* beta, LinOp* x,
415 initial_guess_mode guess) const override;
416
417 template <typename VectorType>
418 void apply_dense_impl(const VectorType* b, VectorType* x,
419 initial_guess_mode guess) const;
420
425 void generate();
426
427 explicit Multigrid(std::shared_ptr<const Executor> exec);
428
429 explicit Multigrid(const Factory* factory,
430 std::shared_ptr<const LinOp> system_matrix);
431
435 void validate();
436
446 void verify_legal_length(bool checked, size_type len, size_type ref_len);
447
448 void create_state() const;
449
450private:
451 std::vector<std::shared_ptr<const gko::multigrid::MultigridLevel>>
452 mg_level_list_{};
453 std::vector<std::shared_ptr<const LinOp>> pre_smoother_list_{};
454 std::vector<std::shared_ptr<const LinOp>> mid_smoother_list_{};
455 std::vector<std::shared_ptr<const LinOp>> post_smoother_list_{};
456 std::shared_ptr<const LinOp> coarsest_solver_{};
457 std::function<size_type(const size_type, const LinOp*)> level_selector_;
458 std::function<size_type(const size_type, const LinOp*)> solver_selector_;
459
470 mutable struct cache_struct {
471 cache_struct() = default;
472
473 ~cache_struct() = default;
474
475 cache_struct(const cache_struct&) {}
476
477 cache_struct(cache_struct&&) {}
478
479 cache_struct& operator=(const cache_struct&) { return *this; }
480
481 cache_struct& operator=(cache_struct&&) { return *this; }
482
483 // unique_ptr with default destructor does not work with the incomplete
484 // type.
485 std::shared_ptr<multigrid::detail::MultigridState> state{};
486 } cache_;
487};
488
489template <>
491 using Solver = Multigrid;
492 // number of vectors used by this workspace
493 static int num_vectors(const Solver&);
494 // number of arrays used by this workspace
495 static int num_arrays(const Solver&);
496 // array containing the num_vectors names for the workspace vectors
497 static std::vector<std::string> op_names(const Solver&);
498 // array containing the num_arrays names for the workspace vectors
499 static std::vector<std::string> array_names(const Solver&);
500 // array containing all varying scalar vectors (independent of problem size)
501 static std::vector<int> scalars(const Solver&);
502 // array containing all varying vectors (dependent on problem size)
503 static std::vector<int> vectors(const Solver&);
504
505 // stopping status array
506 constexpr static int stop = 0;
507};
508
509
510} // namespace solver
511} // namespace gko
512
513
514#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
LinOp(const LinOp &)=default
Copy-constructs a LinOp.
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
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:382
Multigrid methods have a hierarchy of many levels, whose corase level is a subset of the fine level,...
Definition multigrid.hpp:111
std::shared_ptr< const LinOp > get_coarsest_solver() const
Gets the operator at the coarsest level.
Definition multigrid.hpp:175
std::vector< std::shared_ptr< const gko::multigrid::MultigridLevel > > get_mg_level_list() const
Gets the list of MultigridLevel operators.
Definition multigrid.hpp:135
void set_cycle(multigrid::cycle cycle)
Set the cycle of multigrid.
Definition multigrid.hpp:192
std::vector< std::shared_ptr< const LinOp > > get_mid_smoother_list() const
Gets the list of mid-smoother operators.
Definition multigrid.hpp:155
multigrid::cycle get_cycle() const
Get the cycle of multigrid.
Definition multigrid.hpp:185
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:123
std::vector< std::shared_ptr< const LinOp > > get_pre_smoother_list() const
Gets the list of pre-smoother operators.
Definition multigrid.hpp:145
std::vector< std::shared_ptr< const LinOp > > get_post_smoother_list() const
Gets the list of post-smoother operators.
Definition multigrid.hpp:165
static parameters_type parse(const config::pnode &config, const config::registry &context, const config::type_descriptor &td_for_child=config::make_type_descriptor<>())
Create the parameters from the property_tree.
#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:71
cycle
cycle defines which kind of multigrid cycle can be used.
Definition multigrid.hpp:55
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
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:86
Definition multigrid.hpp:199
std::vector< std::shared_ptr< const LinOpFactory > > coarsest_solver
Coarsest factory list.
Definition multigrid.hpp:309
std::vector< std::shared_ptr< const LinOpFactory > > post_smoother
Post-smooth Factory list.
Definition multigrid.hpp:258
size_type max_levels
The maximum number of mg_level (without coarsest solver level) that can be used.
Definition multigrid.hpp:293
std::complex< double > smoother_relax
smoother_relax is the relaxation factor of default generated smoother.
Definition multigrid.hpp:367
size_type min_coarse_rows
The minimal number of coarse rows.
Definition multigrid.hpp:300
initial_guess_mode default_initial_guess
Default initial guess mode.
Definition multigrid.hpp:380
std::vector< std::shared_ptr< const LinOpFactory > > pre_smoother
Pre-smooth Factory list.
Definition multigrid.hpp:250
size_type kcycle_base
kcycle_base is a factor to choose how often enable FCG/GCR step.
Definition multigrid.hpp:352
size_type smoother_iters
smoother_iters is the number of iteration of default generated smoother.
Definition multigrid.hpp:373
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:233
multigrid::cycle cycle
Multigrid cycle type.
Definition multigrid.hpp:342
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:284
bool post_uses_pre
Whether post-smoothing-related calls use corresponding pre-smoothing-related calls.
Definition multigrid.hpp:274
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:334
std::vector< std::shared_ptr< const LinOpFactory > > mid_smoother
Mid-smooth Factory list.
Definition multigrid.hpp:268
double kcycle_rel_tol
kcycle_rel_tol decides whether run the second iteration of FCG/GCR step.
Definition multigrid.hpp:361
std::vector< std::shared_ptr< const LinOpFactory > > mg_level
MultigridLevel Factory list.
Definition multigrid.hpp:204
Traits class providing information on the type and location of workspace vectors inside a solver.
Definition solver_base.hpp:239