![]() |
Ginkgo Generated from branch based on main. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
|
Public Member Functions | |
auto | with_local_solver (::gko::deferred_factory_parameter< local_solver_type > factory) -> std::decay_t< decltype(*(this->self()))> & |
template<typename... Args> | |
auto | with_generated_local_solver (Args &&... _value) -> std::decay_t< decltype(*(this->self()))> & |
template<typename... Args> | |
auto | with_l1_smoother (Args &&... _value) -> std::decay_t< decltype(*(this->self()))> & |
template<typename... Args> | |
auto | with_coarse_weight (Args &&... _value) -> std::decay_t< decltype(*(this->self()))> & |
auto | with_coarse_level (::gko::deferred_factory_parameter< coarse_level_type > factory) -> std::decay_t< decltype(*(this->self()))> & |
auto | with_coarse_solver (::gko::deferred_factory_parameter< coarse_solver_type > factory) -> std::decay_t< decltype(*(this->self()))> & |
Public Member Functions inherited from gko::enable_parameters_type< parameters_type, Factory > | |
parameters_type & | with_loggers (Args &&... _value) |
Provides the loggers to be added to the factory and its generated objects in a fluent interface. | |
std::unique_ptr< Factory > | on (std::shared_ptr< const Executor > exec) const |
Creates a new factory on the specified executor. |
Public Attributes | |
std::shared_ptr< const LinOpFactory > | local_solver {} |
Local solver factory. | |
std::shared_ptr< const LinOp > | generated_local_solver {nullptr} |
Generated Inner solvers. | |
bool | l1_smoother {false} |
Enable l1 smoother. | |
ValueType | coarse_weight {ValueType{-1.0}} |
Coarse weighting. | |
std::shared_ptr< const LinOpFactory > | coarse_level {} |
Operator factory list to generate the triplet (prolong_op, coarse_op, restrict_op), A_c = R * A * P | |
std::shared_ptr< const LinOpFactory > | coarse_solver {} |
Coarse solver factory. |
Additional Inherited Members | |
Public Types inherited from gko::enable_parameters_type< parameters_type, Factory > | |
using | factory |
std::shared_ptr<const LinOpFactory> gko::experimental::distributed::preconditioner::Schwarz< ValueType, LocalIndexType, GlobalIndexType >::parameters_type::coarse_level {} |
Operator factory list to generate the triplet (prolong_op, coarse_op, restrict_op), A_c = R * A * P
Note: The linop factory must generate the triplet (R, A_c, P). For example, any coarse level generator from multigrid::MultigridLevel can be used.
ValueType gko::experimental::distributed::preconditioner::Schwarz< ValueType, LocalIndexType, GlobalIndexType >::parameters_type::coarse_weight {ValueType{-1.0}} |
Coarse weighting.
By default the coarse and the local solutions are added together (when the coarse weight is < 0 or > 1). A weighting can instead be provided if the coarse solution tends to over-correct.
bool gko::experimental::distributed::preconditioner::Schwarz< ValueType, LocalIndexType, GlobalIndexType >::parameters_type::l1_smoother {false} |
Enable l1 smoother.
This creates a diagonal matrix from the row-wise absolute sum of the non-local matrix entries. The diagonal matrix is then added to the system matrix when generating the local solver.
Note: The L1 smoother will not be used for the coarse level matrix generation, and the original system matrix will still be used.