3 #include <amdis/CreatorInterface.hpp> 4 #include <amdis/CreatorMap.hpp> 5 #include <amdis/linearalgebra/istl/AMGPrecon.hpp> 6 #include <amdis/linearalgebra/istl/CreatorInterfaces.hpp> 7 #include <amdis/linearalgebra/istl/PreconWrapper.hpp> 8 #include <amdis/linearalgebra/istl/precompiled/Preconditioners.hpp> 26 template <
class Model,
class Traits>
35 return std::make_unique<Model>(prefix);
56 template <
class Precon,
class Traits>
63 std::unique_ptr<typename Traits::Prec>
64 create(
typename Traits::M
const& mat, [[maybe_unused]]
typename Traits::Comm
const& comm)
const override 66 return std::make_unique<Precon>(mat, this->iter_, this->w_);
72 template <
class X,
class Y,
class Traits>
79 std::unique_ptr<typename Traits::Prec>
80 create([[maybe_unused]]
typename Traits::M
const& mat, [[maybe_unused]]
typename Traits::Comm
const& comm)
const override 82 using Precon = Dune::Richardson<X, Y>;
83 return std::make_unique<Precon>(this->w_);
89 template <
class M,
class X,
class Y,
class Traits>
96 std::unique_ptr<typename Traits::Prec>
97 create(
typename Traits::M
const& mat, [[maybe_unused]]
typename Traits::Comm
const& comm)
const override 99 using Precon = Dune::SeqILDL<M, X, Y>;
100 return std::make_unique<Precon>(mat, this->w_);
110 template <
class M,
class X,
class Y,
class Comm,
class Traits>
112 :
public ISTLPreconCreator<PreconCreator<Dune::ParSSOR<M,X,Y,Comm>, Traits>, Traits>
117 std::unique_ptr<typename Traits::Prec>
118 create(
typename Traits::M
const& mat,
typename Traits::Comm
const& comm)
const override 120 test_exit(Dune::SolverCategory::category(comm) == Dune::SolverCategory::overlapping,
121 "Dune::ParSSOR preconditioner can be used with overlapping domain decomposition.");
123 using Precon = Dune::ParSSOR<M,X,Y,Comm>;
124 return std::make_unique<Precon>(mat, this->iter_, this->w_, comm.get());
138 template <
class Traits>
147 std::string solver =
"default";
152 solverCreator_ = creator->createWithString(prefix +
"->solver");
153 assert(solverCreator_);
156 std::unique_ptr<typename Traits::Prec>
157 create(
typename Traits::M
const& mat,
typename Traits::Comm
const& comm)
const override 159 using InverseOp = Dune::InverseOperator<typename Traits::X, typename Traits::Y>;
160 using Precon = Dune::InverseOperator2Preconditioner<InverseOp>;
162 return std::make_unique<Wrapper>(solverCreator_->create(mat, comm));
166 std::shared_ptr<ISTLSolverCreatorInterface<Traits>> solverCreator_;
182 template <
class Traits>
192 std::string subPrecon =
"default";
197 subPreconCreator_ = creator->createWithString(prefix +
"->sub precon");
198 assert(subPreconCreator_);
201 std::unique_ptr<typename Traits::Prec>
202 create(
typename Traits::M
const& mat,
typename Traits::Comm
const& comm)
const override 204 return Traits::ParPrecCreator::create(Dune::SolverCategory::category(comm),
205 subPreconCreator_->create(mat, comm.sequential()),
210 std::shared_ptr<ISTLPreconCreatorInterface<SeqTraits>> subPreconCreator_;
229 template <
class Traits>
232 using M =
typename Traits::M;
233 using X =
typename Traits::X;
234 using Y =
typename Traits::Y;
236 template <
class Precon>
240 using FTraits = Dune::FieldTraits<typename M::field_type>;
245 auto jacobi =
new PreconCreator<Dune::SeqJac<M,X,Y>>;
246 Map::addCreator(
"diag", jacobi);
247 Map::addCreator(
"jacobi", jacobi);
249 auto gs =
new PreconCreator<Dune::SeqGS<M,X,Y>>;
250 Map::addCreator(
"gs", gs);
251 Map::addCreator(
"gauss_seidel", gs);
253 auto sor =
new PreconCreator<Dune::SeqSOR<M,X,Y>>;
254 Map::addCreator(
"sor", sor);
256 auto ssor =
new PreconCreator<Dune::SeqSSOR<M,X,Y>>;
257 Map::addCreator(
"ssor", ssor);
259 init_ilu(std::is_arithmetic<typename FTraits::field_type>{});
260 init_amg(std::is_same<typename FTraits::real_type, double>{});
262 auto richardson =
new PreconCreator<Dune::Richardson<X,Y>>;
263 Map::addCreator(
"richardson", richardson);
264 Map::addCreator(
"default", richardson);
266 auto solver =
new PreconCreator<tag::solver>;
267 Map::addCreator(
"solver", solver);
269 init_bjacobi(
Types<TYPEOF(std::declval<typename Traits::Comm>().
get())>{}, Dune::PriorityTag<10>{});
272 static void init_ilu(std::false_type)
274 warning(
"ILU preconditioners not created for the matrix with field_type = {}.",
275 Dune::className<typename FTraits::field_type>());
278 static void init_ilu(std::true_type)
280 auto ilu =
new PreconCreator<Dune::SeqILU<M,X,Y>>;
281 Map::addCreator(
"ilu", ilu);
282 Map::addCreator(
"ilu0", ilu);
284 auto ildl =
new PreconCreator<Dune::SeqILDL<M,X,Y>>;
285 Map::addCreator(
"ildl", ildl);
288 static void init_amg(std::false_type)
290 warning(
"AMG preconditioners not created for the matrix with real_type = {}.",
291 Dune::className<typename FTraits::real_type>());
294 static void init_amg(std::true_type)
297 Map::addCreator(
"amg", amg);
299 Map::addCreator(
"fastamg", fastamg);
301 Map::addCreator(
"kamg", kamg);
306 template <
class Comm>
307 static void init_bjacobi(
Types<Comm>, Dune::PriorityTag<1>)
309 auto pssor =
new PreconCreator<Dune::ParSSOR<M,X,Y,Comm>>;
310 Map::addCreator(
"pssor", pssor);
312 auto bjacobi =
new PreconCreator<tag::bjacobi>;
313 Map::addCreator(
"bjacobi", bjacobi);
Definition: CreatorInterfaces.hpp:11
Definition: Traits.hpp:59
Definition: PreconCreator.hpp:15
A variadic type list.
Definition: TypeTraits.hpp:88
std::unique_ptr< Interface > createWithString(std::string prefix) override
Must be implemented by sub classes of CreatorInterfaceName. Creates a new instance of the sub class o...
Definition: PreconCreator.hpp:33
Interface for creators with name.
Definition: CreatorInterface.hpp:42
A CreatorMap is used to construct objects, which types depends on key words determined at run time...
Definition: CreatorMap.hpp:29
Contains all classes needed for solving linear and non linear equation systems.
Definition: AdaptBase.hpp:6
Definition: PreconCreator.hpp:31
Default precon creator.
Definition: PreconCreator.hpp:57
Definition: PreconCreator.hpp:14
static std::optional< T > get(std::string const &key)
Get parameter-values from parameter-tree.
Definition: Initfile.hpp:25
CreatorInterfaceName< BaseClass > * named(CreatorInterface< BaseClass > *ptr)
cast a ptr of CreatorInterface to CreatorInterfaceName
Definition: CreatorInterface.hpp:64
Definition: CreatorMap.hpp:16
A creator for AMGPrecon, reads the smoother type from initfile:
Definition: AMGPrecon.hpp:166
static CreatorInterface< BaseClass > * getCreator(std::string key, std::string initFileStr)
Creates a object of the type corresponding to key.
Definition: CreatorMap.hpp:44
Definition: PreconWrapper.hpp:20
Base class for precon creators,.
Definition: PreconCreator.hpp:27
void init(int &argc, char **&argv, std::string const &initFileName="")
Initialized the Environment for MPI.
Definition: AMDiS.hpp:29
void test_exit(bool condition, std::string const &str, Args &&... args)
test for condition and in case of failure print message and exit
Definition: Output.hpp:163