6#ifndef DUNE_ISTL_SOLVERFACTORY_HH
7#define DUNE_ISTL_SOLVERFACTORY_HH
9#include <unordered_map>
13#include <dune/common/parametertree.hh>
14#include <dune/common/singleton.hh>
27 template<
class M,
class X,
class Y>
29 template<
class M,
class X,
class Y>
33 template<
class M,
class X,
class Y>
35 template<
class M,
class X,
class Y>
39 template<
class X,
class Y>
40 using IterativeSolverSignature = std::shared_ptr<InverseOperator<X,Y>>(
const std::shared_ptr<LinearOperator<X,Y>>&,
const std::shared_ptr<ScalarProduct<X>>&,
const std::shared_ptr<Preconditioner<X,Y>>,
const ParameterTree&);
41 template<
class X,
class Y>
54 int initSolverFactories(){
55 using M =
typename O::matrix_type;
56 using X =
typename O::range_type;
57 using Y =
typename O::domain_type;
58 using TL = Dune::TypeList<M,X,Y>;
60 addRegistryToFactory<TL>(dsfac, DirectSolverTag{});
62 addRegistryToFactory<TL>(pfac, PreconditionerTag{});
63 using TLS = Dune::TypeList<X,Y>;
65 return addRegistryToFactory<TLS>(isfac, IterativeSolverTag{});
77 template<
class O,
class X,
class Y>
78 [[deprecated(
"Use method 'initSolverFactories<O>' instead")]]
79 int initSolverFactories() {
80 return initSolverFactories<O>();
85 template<
class O,
class Preconditioner>
92 template<
class M,
class X,
class Y,
class C,
class Preconditioner>
93 std::shared_ptr<Preconditioner>
97 return std::make_shared<BlockPreconditioner<X,Y,C,Preconditioner> >(prec, op->getCommunication());
100 template<
class M,
class X,
class Y,
class C,
class Preconditioner>
101 std::shared_ptr<Preconditioner>
105 return std::make_shared<NonoverlappingBlockPreconditioner<C,Preconditioner> >(prec, op->getCommunication());
108 template<
class M,
class X,
class Y>
111 return std::make_shared<SeqScalarProduct<X>>();
113 template<
class M,
class X,
class Y,
class C>
116 return createScalarProduct<X>(op->getCommunication(), op->category());
119 template<
class M,
class X,
class Y,
class C>
122 return createScalarProduct<X>(op->getCommunication(), op->category());
144 template<
class Operator>
146 using Domain =
typename Operator::domain_type;
147 using Range =
typename Operator::range_type;
152 using _matrix_type =
typename O::matrix_type;
153 using matrix_type = Std::detected_or_t<int, _matrix_type, Operator>;
154 static constexpr bool isAssembled = !std::is_same<matrix_type, int>::value;
156 static const matrix_type* getmat(std::shared_ptr<Operator> op){
157 std::shared_ptr<AssembledLinearOperator<matrix_type, Domain, Range>> aop
158 = std::dynamic_pointer_cast<AssembledLinearOperator<matrix_type, Domain, Range>>(op);
160 return &aop->getmat();
168 static std::shared_ptr<Solver>
get(std::shared_ptr<Operator> op,
169 const ParameterTree& config,
170 std::shared_ptr<Preconditioner> prec =
nullptr){
171 std::string type = config.get<std::string>(
"type");
172 std::shared_ptr<Solver> result;
173 const matrix_type*
mat = getmat(op);
177 DUNE_THROW(NotImplemented,
"The solver factory does not support parallel direct solvers!");
185 DUNE_THROW(Dune::InvalidStateException,
"Solver not found in the factory.");
188 const ParameterTree& precConfig = config.sub(
"preconditioner");
189 std::string prec_type = precConfig.get<std::string>(
"type");
204 const ParameterTree& config){
205 const matrix_type*
mat = getmat(op);
207 std::string prec_type = config.get<std::string>(
"type");
210 DUNE_THROW(InvalidStateException,
"Could not obtain matrix from operator. Please pass in an AssembledLinearOperator.");
225 template<
class Operator>
226 std::shared_ptr<InverseOperator<
typename Operator::domain_type,
228 const ParameterTree& config,
230 typename Operator::range_type>> prec =
nullptr){
Define general, extensible interface for inverse operators.
Matrix & mat
Definition: matrixmatrix.hh:347
Singleton< ParameterizedObjectFactory< PreconditionerSignature< M, X, Y > > > PreconditionerFactory
Definition: solverfactory.hh:36
Singleton< ParameterizedObjectFactory< DirectSolverSignature< M, X, Y > > > DirectSolverFactory
Definition: solverfactory.hh:30
std::shared_ptr< InverseOperator< X, Y > >(const std::shared_ptr< LinearOperator< X, Y > > &, const std::shared_ptr< ScalarProduct< X > > &, const std::shared_ptr< Preconditioner< X, Y > >, const ParameterTree &) IterativeSolverSignature
Definition: solverfactory.hh:40
std::shared_ptr< Preconditioner > wrapPreconditioner4Parallel(const std::shared_ptr< Preconditioner > &prec, const O &)
Definition: solverfactory.hh:86
std::shared_ptr< InverseOperator< X, Y > >(const M &, const ParameterTree &) DirectSolverSignature
Definition: solverfactory.hh:28
std::shared_ptr< InverseOperator< typename Operator::domain_type, typename Operator::range_type > > getSolverFromFactory(std::shared_ptr< Operator > op, const ParameterTree &config, std::shared_ptr< Preconditioner< typename Operator::domain_type, typename Operator::range_type > > prec=nullptr)
Instantiates an InverseOperator from an Operator and a configuration given as a ParameterTree.
Definition: solverfactory.hh:227
Singleton< ParameterizedObjectFactory< IterativeSolverSignature< X, Y > > > IterativeSolverFactory
Definition: solverfactory.hh:42
std::shared_ptr< Preconditioner< X, Y > >(const std::shared_ptr< M > &, const ParameterTree &) PreconditionerSignature
Definition: solverfactory.hh:34
Definition: allocator.hh:11
std::shared_ptr< ScalarProduct< X > > createScalarProduct(const Comm &comm, SolverCategory::Category category)
Definition: scalarproducts.hh:242
A nonoverlapping operator with communication object.
Definition: novlpschwarz.hh:61
Adapter to turn a matrix into a linear operator.
Definition: operators.hh:137
An overlapping Schwarz operator.
Definition: schwarz.hh:75
Base class for matrix free definition of preconditioners.
Definition: preconditioner.hh:32
@ sequential
Category for sequential solvers.
Definition: solvercategory.hh:25
Factory to assembly solvers configured by a ParameterTree.
Definition: solverfactory.hh:145
static std::shared_ptr< Solver > get(std::shared_ptr< Operator > op, const ParameterTree &config, std::shared_ptr< Preconditioner > prec=nullptr)
get a solver from the factory
Definition: solverfactory.hh:168
static std::shared_ptr< Preconditioner > getPreconditioner(std::shared_ptr< Operator > op, const ParameterTree &config)
Construct a Preconditioner for a given Operator.
Definition: solverfactory.hh:203