Debian Codegraph @

include/deal.II/lac/trilinos_tpetra_precondition.templates.h

raw
1 // ------------------------------------------------------------------------
2 //
3 // SPDX-License-Identifier: LGPL-2.1-or-later
4 // Copyright (C) 2024 - 2025 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // Part of the source code is dual licensed under Apache-2.0 WITH
9 // LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10 // governing the source code and code contributions can be found in
11 // LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12 //
13 // ------------------------------------------------------------------------
14
15 #ifndef dealii_trilinos_tpetra_precondition_templates_h
16 #define dealii_trilinos_tpetra_precondition_templates_h
17
18
19 #include <deal.II/base/config.h>
20
21 #include <deal.II/base/exceptions.h>
22 #include <deal.II/base/index_set.h>
23
24 #include <deal.II/lac/trilinos_tpetra_types.h>
25
26 #include <string>
27
28 #ifdef DEAL_II_TRILINOS_WITH_TPETRA
29 # ifdef DEAL_II_TRILINOS_WITH_IFPACK2
30 # include <deal.II/lac/trilinos_tpetra_precondition.h>
31 # include <deal.II/lac/trilinos_tpetra_sparse_matrix.h>
32
33 # include <Ifpack2_Factory.hpp>
34 # include <Ifpack2_IdentitySolver.hpp>
35 # include <Ifpack2_IdentitySolver_decl.hpp>
36 # include <Ifpack2_Preconditioner.hpp>
37 # include <Kokkos_Core.hpp>
38 # include <Kokkos_DualView.hpp>
39 # include <Teuchos_RCPDecl.hpp>
40 # include <Tpetra_CrsMatrix_decl.hpp>
41 # include <Tpetra_Vector_decl.hpp>
42
43 DEAL_II_NAMESPACE_OPEN
44
45
46 namespace LinearAlgebra
47 {
48 namespace TpetraWrappers
49 {
50 /* ---------------------- PreconditionBase ------------------------ */
51 template <typename Number, typename MemorySpace>
52 void
53 PreconditionBase<Number, MemorySpace>::clear()
54 {
55 preconditioner.reset();
56 }
57
58
59
60 template <typename Number, typename MemorySpace>
61 const TpetraTypes::LinearOperator<Number, MemorySpace> &
62 PreconditionBase<Number, MemorySpace>::trilinos_operator() const
63 {
64 return *preconditioner;
65 }
66
67
68
69 template <typename Number, typename MemorySpace>
70 Teuchos::RCP<TpetraTypes::LinearOperator<Number, MemorySpace>>
71 PreconditionBase<Number, MemorySpace>::trilinos_rcp() const
72 {
73 return preconditioner;
74 }
75
76
77
78 template <typename Number, typename MemorySpace>
79 IndexSet
80 PreconditionBase<Number, MemorySpace>::locally_owned_domain_indices() const
81 {
82 return IndexSet(preconditioner->getDomainMap());
83 }
84
85
86
87 template <typename Number, typename MemorySpace>
88 IndexSet
89 PreconditionBase<Number, MemorySpace>::locally_owned_range_indices() const
90 {
91 return IndexSet(preconditioner->getRangeMap());
92 }
93
94
95
96 template <typename Number, typename MemorySpace>
97 inline void
98 PreconditionBase<Number, MemorySpace>::vmult(
99 Vector<Number, MemorySpace> &dst,
100 const Vector<Number, MemorySpace> &src) const
101 {
102 Assert(dst.trilinos_vector().getMap()->isSameAs(
103 *(preconditioner->getRangeMap())),
104 ExcNonMatchingMaps("dst"));
105 Assert(src.trilinos_rcp()->getMap()->isSameAs(
106 *(preconditioner->getDomainMap())),
107 ExcNonMatchingMaps("src"));
108
109 preconditioner->apply(src.trilinos_vector(), dst.trilinos_vector());
110 }
111
112
113
114 template <typename Number, typename MemorySpace>
115 inline void
116 PreconditionBase<Number, MemorySpace>::Tvmult(
117 Vector<Number, MemorySpace> &dst,
118 const Vector<Number, MemorySpace> &src) const
119 {
120 Assert(preconditioner->hasTransposeApply(), ExcTransposeNotSupported());
121
122 Assert(dst.trilinos_rcp()->getMap()->isSameAs(
123 *(preconditioner->getDomainMap())),
124 ExcNonMatchingMaps("dst"));
125
126 Assert(src.trilinos_rcp()->getMap()->isSameAs(
127 *(preconditioner->getRangeMap())),
128 ExcNonMatchingMaps("src"));
129
130 preconditioner->apply(src.trilinos_vector(),
131 dst.trilinos_vector(),
132 Teuchos::TRANS);
133 }
134
135
136
137 template <typename Number, typename MemorySpace>
138 inline void
139 PreconditionBase<Number, MemorySpace>::vmult(
140 dealii::Vector<Number> &dst,
141 dealii::Vector<Number> &src) const
142 {
143 AssertDimension(dst.size(),
144 preconditioner->getRangeMap()->getGlobalNumElements());
145 AssertDimension(src.size(),
146 preconditioner->getDomainMap()->getGlobalNumElements());
147
148 // Construct Tpetra Vectors as views to the actual dealii::Vector data
149 // Since all of Tpetra is based on Kokkos::DualView this is a bit of a
150 // process
151
152 // 1. Make host view with underlying dealii::Vector data.
153 // (This is always a n x 1 matrix since multivector expects that.)
154
155 // Tpetra uses Kokkos::complex<> internally for std::complex<>
156 using value_type = typename TpetraTypes::HostViewType<Number>::value_type;
157 static_assert((numbers::NumberTraits<Number>::is_complex &&
158 sizeof(value_type) == sizeof(Number)) ||
159 (!numbers::NumberTraits<Number>::is_complex &&
160 std::is_same_v<value_type, Number>));
161
162 TpetraTypes::HostViewType<Number> host_src(
163 reinterpret_cast<value_type *>(src.data()), src.size(), 1);
164 TpetraTypes::HostViewType<Number> host_dst(
165 reinterpret_cast<value_type *>(dst.data()), dst.size(), 1);
166
167 // 2. Create device mirror (if Device == Host, no alloc )
168 auto dev_src = Kokkos::create_mirror_view_and_copy(
169 typename MemorySpace::kokkos_space::execution_space(), host_src);
170
171 auto dev_dst = Kokkos::create_mirror_view_and_copy(
172 typename MemorySpace::kokkos_space::execution_space(), host_dst);
173
174 // 3. Create dual views from the previous ones
175 TpetraTypes::DualViewType<Number, MemorySpace> dual_src(dev_src,
176 host_src);
177 TpetraTypes::DualViewType<Number, MemorySpace> dual_dst(dev_dst,
178 host_dst);
179
180 // 4. Create Tpetra Vector from
181 TpetraTypes::VectorType<Number, MemorySpace> tpetra_dst(
182 preconditioner->getRangeMap(), dual_dst);
183 TpetraTypes::VectorType<Number, MemorySpace> tpetra_src(
184 preconditioner->getDomainMap(), dual_src);
185
186 // 5. Finally, apply our preconditioner
187 preconditioner->apply(tpetra_src, tpetra_dst);
188 }
189
190
191
192 template <typename Number, typename MemorySpace>
193 inline void
194 PreconditionBase<Number, MemorySpace>::Tvmult(
195 dealii::Vector<Number> &dst,
196 dealii::Vector<Number> &src) const
197 {
198 AssertDimension(dst.size(),
199 preconditioner->getDomainMap()->getGlobalNumElements());
200 AssertDimension(src.size(),
201 preconditioner->getRangeMap()->getGlobalNumElements());
202
203 Assert(preconditioner->hasTransposeApply(), ExcTransposeNotSupported());
204 // Construct Tpetra Vectors as views to the actual dealii::Vector data
205 // Since all of Tpetra is based on Kokkos::DualView this is a bit of a
206 // process
207
208 // 1. Make host view with underlying dealii::Vector data.
209 // (This is always a n x 1 matrix since multivector expects that.)
210
211 // Tpetra uses Kokkos::complex<> internally for std::complex<>
212 using value_type = typename TpetraTypes::HostViewType<Number>::value_type;
213 static_assert((numbers::NumberTraits<Number>::is_complex &&
214 sizeof(value_type) == sizeof(Number)) ||
215 (!numbers::NumberTraits<Number>::is_complex &&
216 std::is_same_v<value_type, Number>));
217
218 TpetraTypes::HostViewType<Number> host_src(
219 reinterpret_cast<value_type *>(src.data()), src.size(), 1);
220 TpetraTypes::HostViewType<Number> host_dst(
221 reinterpret_cast<value_type *>(dst.data()), dst.size(), 1);
222
223 // 2. Create device mirror (if Device == Host, no alloc )
224 auto dev_src = Kokkos::create_mirror_view_and_copy(
225 typename MemorySpace::kokkos_space::execution_space(), host_src);
226
227 auto dev_dst = Kokkos::create_mirror_view_and_copy(
228 typename MemorySpace::kokkos_space::execution_space(), host_dst);
229
230 // 3. Create dual views from the previous ones
231 TpetraTypes::DualViewType<Number, MemorySpace> dual_src(dev_src,
232 host_src);
233 TpetraTypes::DualViewType<Number, MemorySpace> dual_dst(dev_dst,
234 host_dst);
235
236 // 4. Create Tpetra Vector from
237 TpetraTypes::VectorType<Number, MemorySpace> tpetra_dst(
238 preconditioner->getRangeMap(), dual_dst);
239 TpetraTypes::VectorType<Number, MemorySpace> tpetra_src(
240 preconditioner->getDomainMap(), dual_src);
241
242 // 5. Finally, apply our preconditioner
243 preconditioner->apply(tpetra_src, tpetra_dst, Teuchos::TRANS);
244 }
245
246
247
248 /* ---------------------- PreconditionIdentity ------------------------ */
249 template <typename Number, typename MemorySpace>
250 void
251 PreconditionIdentity<Number, MemorySpace>::initialize(
252 const SparseMatrix<Number, MemorySpace> &A)
253 {
254 Teuchos::RCP<Ifpack2::IdentitySolver<
255 TpetraTypes::RowMatrixType<Number, MemorySpace>>>
256 ifpack2Preconditioner;
257 ifpack2Preconditioner =
258 rcp(new Ifpack2::IdentitySolver<
259 TpetraTypes::RowMatrixType<Number, MemorySpace>>(A.trilinos_rcp()));
260
261 ifpack2Preconditioner->initialize();
262 ifpack2Preconditioner->compute();
263 this->preconditioner = ifpack2Preconditioner;
264 }
265
266
267
268 /* ---------------------- PreconditionIfpackBase ------------------------ */
269 template <typename Number, typename MemorySpace>
270 PreconditionIfpackBase<Number, MemorySpace>::PreconditionIfpackBase(
271 const std::string &preconditioner_type)
272 : preconditioner_type(preconditioner_type)
273 {
274 # if DEAL_II_TRILINOS_VERSION_GTE(13, 0, 0)
275 Ifpack2::Factory factory;
276 AssertThrow(
277 (factory.isSupported<TpetraTypes::MatrixType<Number, MemorySpace>>(
278 preconditioner_type)),
279 ExcTrilinosIpack2PreconditionerUnsupported(preconditioner_type));
280 # endif
281 }
282
283
284
285 template <typename Number, typename MemorySpace>
286 void
287 PreconditionIfpackBase<Number, MemorySpace>::initialize(
288 const SparseMatrix<Number, MemorySpace> &A)
289 {
290 Ifpack2::Factory factory;
291 Teuchos::RCP<TpetraTypes::Ifpack2PreconType<Number, MemorySpace>>
292 ifpack2Preconditioner;
293 ifpack2Preconditioner =
294 factory.create(preconditioner_type, A.trilinos_rcp());
295 ifpack2Preconditioner->setParameters(this->parameter_list);
296 ifpack2Preconditioner->initialize();
297 ifpack2Preconditioner->compute();
298 this->preconditioner = ifpack2Preconditioner;
299 }
300
301
302
303 /* ---------------------- PreconditionIfpack ------------------------ */
304 template <typename Number, typename MemorySpace>
305 PreconditionIfpack<Number, MemorySpace>::PreconditionIfpack(
306 const std::string &preconditioner_type)
307 : PreconditionIfpackBase<Number, MemorySpace>(preconditioner_type)
308 {}
309
310
311
312 template <typename Number, typename MemorySpace>
313 void
314 PreconditionIfpack<Number, MemorySpace>::set_parameter_list(
315 Teuchos::ParameterList &parameter_list)
316 {
317 this->parameter_list.setParameters(parameter_list);
318 }
319
320
321
322 /* ---------------------- PreconditionJacobi ------------------------ */
323 template <typename Number, typename MemorySpace>
324 PreconditionJacobi<Number, MemorySpace>::AdditionalData::AdditionalData(
325 const double omega,
326 const bool fix_diagonal,
327 const double min_diagonal,
328 const int n_sweeps)
329 : omega(omega)
330 , fix_diagonal(fix_diagonal)
331 , min_diagonal(min_diagonal)
332 , n_sweeps(n_sweeps)
333 {}
334
335
336
337 template <typename Number, typename MemorySpace>
338 PreconditionJacobi<Number, MemorySpace>::PreconditionJacobi()
339 : PreconditionIfpackBase<Number, MemorySpace>("RELAXATION")
340 {}
341
342
343
344 template <typename Number, typename MemorySpace>
345 void
346 PreconditionJacobi<Number, MemorySpace>::initialize(
347 const SparseMatrix<Number, MemorySpace> &A,
348 const AdditionalData &ad)
349 {
350 this->parameter_list.set("relaxation: type", "Jacobi");
351 this->parameter_list.set("relaxation: damping factor", ad.omega);
352 this->parameter_list.set("relaxation: sweeps", ad.n_sweeps);
353 this->parameter_list.set("relaxation: fix tiny diagonal entries",
354 ad.fix_diagonal);
355 this->parameter_list.set("relaxation: min diagonal value",
356 ad.min_diagonal);
357 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
358 }
359
360
361
362 /* ---------------------- PreconditionL1Jacobi ------------------------ */
363 template <typename Number, typename MemorySpace>
364 PreconditionL1Jacobi<Number, MemorySpace>::AdditionalData::AdditionalData(
365 const double omega,
366 const bool fix_diagonal,
367 const double min_diagonal,
368 const int n_sweeps)
369 : omega(omega)
370 , fix_diagonal(fix_diagonal)
371 , min_diagonal(min_diagonal)
372 , n_sweeps(n_sweeps)
373 {}
374
375
376
377 template <typename Number, typename MemorySpace>
378 PreconditionL1Jacobi<Number, MemorySpace>::PreconditionL1Jacobi()
379 : PreconditionIfpackBase<Number, MemorySpace>("RELAXATION")
380 {}
381
382
383
384 template <typename Number, typename MemorySpace>
385 void
386 PreconditionL1Jacobi<Number, MemorySpace>::initialize(
387 const SparseMatrix<Number, MemorySpace> &A,
388 const AdditionalData &ad)
389 {
390 this->parameter_list.set("relaxation: type", "Jacobi");
391 this->parameter_list.set("relaxation: use l1", true);
392 this->parameter_list.set("relaxation: damping factor", ad.omega);
393 this->parameter_list.set("relaxation: sweeps", ad.n_sweeps);
394 this->parameter_list.set("relaxation: fix tiny diagonal entries",
395 ad.fix_diagonal);
396 this->parameter_list.set("relaxation: min diagonal value",
397 ad.min_diagonal);
398 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
399 }
400
401
402
403 /* ---------------------- PreconditionL1GaussSeidel -------------------- */
404 template <typename Number, typename MemorySpace>
405 PreconditionL1GaussSeidel<Number, MemorySpace>::AdditionalData::
406 AdditionalData(const double omega,
407 const double eta,
408 const bool fix_diagonal,
409 const double min_diagonal,
410 const int n_sweeps)
411 : omega(omega)
412 , eta(eta)
413 , fix_diagonal(fix_diagonal)
414 , min_diagonal(min_diagonal)
415 , n_sweeps(n_sweeps)
416 {}
417
418
419
420 template <typename Number, typename MemorySpace>
421 PreconditionL1GaussSeidel<Number, MemorySpace>::PreconditionL1GaussSeidel()
422 : PreconditionIfpackBase<Number, MemorySpace>("RELAXATION")
423 {}
424
425
426
427 template <typename Number, typename MemorySpace>
428 void
429 PreconditionL1GaussSeidel<Number, MemorySpace>::initialize(
430 const SparseMatrix<Number, MemorySpace> &A,
431 const AdditionalData &ad)
432 {
433 this->parameter_list.set("relaxation: type", "Gauss-Seidel");
434 this->parameter_list.set("relaxation: use l1", true);
435 this->parameter_list.set("relaxation: damping factor", ad.omega);
436 this->parameter_list.set("relaxation: l1 eta", ad.eta);
437 this->parameter_list.set("relaxation: sweeps", ad.n_sweeps);
438 this->parameter_list.set("relaxation: fix tiny diagonal entries",
439 ad.fix_diagonal);
440 this->parameter_list.set("relaxation: min diagonal value",
441 ad.min_diagonal);
442 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
443 }
444
445
446
447 /* ---------------------- PreconditionSOR ------------------------ */
448 template <typename Number, typename MemorySpace>
449 PreconditionSOR<Number, MemorySpace>::AdditionalData::AdditionalData(
450 const double omega,
451 const int overlap,
452 const bool fix_diagonal,
453 const double min_diagonal,
454 const int n_sweeps)
455 : omega(omega)
456 , overlap(overlap)
457 , fix_diagonal(fix_diagonal)
458 , min_diagonal(min_diagonal)
459 , n_sweeps(n_sweeps)
460 {}
461
462
463
464 template <typename Number, typename MemorySpace>
465 PreconditionSOR<Number, MemorySpace>::PreconditionSOR()
466 : PreconditionIfpackBase<Number, MemorySpace>("SCHWARZ")
467 {}
468
469
470
471 template <typename Number, typename MemorySpace>
472 void
473 PreconditionSOR<Number, MemorySpace>::initialize(
474 const SparseMatrix<Number, MemorySpace> &A,
475 const AdditionalData &ad)
476 {
477 this->parameter_list.set("schwarz: subdomain solver name", "RELAXATION");
478 {
479 Teuchos::ParameterList &relaxParams =
480 this->parameter_list.sublist("schwarz: subdomain solver parameters",
481 false);
482 relaxParams.set("relaxation: type", "Gauss-Seidel");
483 relaxParams.set("relaxation: damping factor", ad.omega);
484 relaxParams.set("relaxation: sweeps", ad.n_sweeps);
485 relaxParams.set("relaxation: fix tiny diagonal entries",
486 ad.fix_diagonal);
487 relaxParams.set("relaxation: min diagonal value", ad.min_diagonal);
488 }
489 this->parameter_list.set("schwarz: combine mode", "ADD");
490 this->parameter_list.set("schwarz: overlap level", ad.overlap);
491 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
492 }
493
494
495
496 /* ---------------------- PreconditionSSOR ----------------------*/
497 template <typename Number, typename MemorySpace>
498 PreconditionSSOR<Number, MemorySpace>::AdditionalData::AdditionalData(
499 const double omega,
500 const int overlap,
501 const bool fix_diagonal,
502 const double min_diagonal,
503 const int n_sweeps)
504 : omega(omega)
505 , overlap(overlap)
506 , fix_diagonal(fix_diagonal)
507 , min_diagonal(min_diagonal)
508 , n_sweeps(n_sweeps)
509 {}
510
511
512
513 template <typename Number, typename MemorySpace>
514 PreconditionSSOR<Number, MemorySpace>::PreconditionSSOR()
515 : PreconditionIfpackBase<Number, MemorySpace>("SCHWARZ")
516 {}
517
518
519
520 template <typename Number, typename MemorySpace>
521 void
522 PreconditionSSOR<Number, MemorySpace>::initialize(
523 const SparseMatrix<Number, MemorySpace> &A,
524 const AdditionalData &ad)
525 {
526 this->parameter_list.set("schwarz: subdomain solver name", "RELAXATION");
527 {
528 Teuchos::ParameterList &relaxParams =
529 this->parameter_list.sublist("schwarz: subdomain solver parameters",
530 false);
531 relaxParams.set("relaxation: type", "Symmetric Gauss-Seidel");
532 relaxParams.set("relaxation: damping factor", ad.omega);
533 relaxParams.set("relaxation: sweeps", ad.n_sweeps);
534 relaxParams.set("relaxation: fix tiny diagonal entries",
535 ad.fix_diagonal);
536 relaxParams.set("relaxation: min diagonal value", ad.min_diagonal);
537 }
538 this->parameter_list.set("schwarz: combine mode", "ADD");
539 this->parameter_list.set("schwarz: overlap level", ad.overlap);
540 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
541 }
542
543
544
545 /* ---------------------- PreconditionBlockJacobi ----------------------*/
546 template <typename Number, typename MemorySpace>
547 PreconditionBlockJacobi<Number, MemorySpace>::AdditionalData::
548 AdditionalData(const int n_local_parts,
549 const double omega,
550 const int block_overlap,
551 const int n_sweeps)
552 : n_local_parts(n_local_parts)
553 , omega(omega)
554 , block_overlap(block_overlap)
555 , n_sweeps(n_sweeps)
556 {}
557
558
559
560 template <typename Number, typename MemorySpace>
561 PreconditionBlockJacobi<Number, MemorySpace>::PreconditionBlockJacobi()
562 : PreconditionIfpackBase<Number, MemorySpace>("BLOCK_RELAXATION")
563 {}
564
565
566
567 template <typename Number, typename MemorySpace>
568 void
569 PreconditionBlockJacobi<Number, MemorySpace>::initialize(
570 const SparseMatrix<Number, MemorySpace> &A,
571 const AdditionalData &ad)
572 {
573 this->parameter_list.set("relaxation: type", "Jacobi");
574 this->parameter_list.set("relaxation: damping factor", ad.omega);
575 this->parameter_list.set("relaxation: sweeps", ad.n_sweeps);
576 this->parameter_list.set("partitioner: local parts", ad.n_local_parts);
577 this->parameter_list.set("partitioner: overlap", ad.block_overlap);
578 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
579 }
580
581
582
583 /* ---------------------- PreconditionBlockSOR ----------------------*/
584 template <typename Number, typename MemorySpace>
585 PreconditionBlockSOR<Number, MemorySpace>::AdditionalData::AdditionalData(
586 const int n_local_parts,
587 const double omega,
588 const int overlap,
589 const int n_sweeps)
590 : n_local_parts(n_local_parts)
591 , omega(omega)
592 , overlap(overlap)
593 , n_sweeps(n_sweeps)
594 {}
595
596
597
598 template <typename Number, typename MemorySpace>
599 PreconditionBlockSOR<Number, MemorySpace>::PreconditionBlockSOR()
600 : PreconditionIfpackBase<Number, MemorySpace>("SCHWARZ")
601 {}
602
603
604
605 template <typename Number, typename MemorySpace>
606 void
607 PreconditionBlockSOR<Number, MemorySpace>::initialize(
608 const SparseMatrix<Number, MemorySpace> &A,
609 const AdditionalData &ad)
610 {
611 this->parameter_list.set("schwarz: subdomain solver name",
612 "BLOCK_RELAXATION");
613 {
614 Teuchos::ParameterList &relaxParams =
615 this->parameter_list.sublist("schwarz: subdomain solver parameters",
616 false);
617 relaxParams.set("relaxation: type", "Gauss-Seidel");
618 relaxParams.set("relaxation: damping factor", ad.omega);
619 relaxParams.set("relaxation: sweeps", ad.n_sweeps);
620 relaxParams.set("partitioner: local parts", ad.n_local_parts);
621 }
622 this->parameter_list.set("schwarz: combine mode", "ADD");
623 this->parameter_list.set("schwarz: overlap level", ad.overlap);
624 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
625 }
626
627
628
629 /* ---------------------- PreconditionBlockSSOR ----------------------*/
630 template <typename Number, typename MemorySpace>
631 PreconditionBlockSSOR<Number, MemorySpace>::AdditionalData::AdditionalData(
632 const int n_local_parts,
633 const double omega,
634 const int overlap,
635 const int n_sweeps)
636 : n_local_parts(n_local_parts)
637 , omega(omega)
638 , overlap(overlap)
639 , n_sweeps(n_sweeps)
640 {}
641
642
643
644 template <typename Number, typename MemorySpace>
645 PreconditionBlockSSOR<Number, MemorySpace>::PreconditionBlockSSOR()
646 : PreconditionIfpackBase<Number, MemorySpace>("SCHWARZ")
647 {}
648
649
650
651 template <typename Number, typename MemorySpace>
652 void
653 PreconditionBlockSSOR<Number, MemorySpace>::initialize(
654 const SparseMatrix<Number, MemorySpace> &A,
655 const AdditionalData &ad)
656 {
657 this->parameter_list.set("schwarz: subdomain solver name",
658 "BLOCK_RELAXATION");
659 {
660 Teuchos::ParameterList &relaxParams =
661 this->parameter_list.sublist("schwarz: subdomain solver parameters",
662 false);
663 relaxParams.set("relaxation: type", "Symmetric Gauss-Seidel");
664 relaxParams.set("relaxation: damping factor", ad.omega);
665 relaxParams.set("relaxation: sweeps", ad.n_sweeps);
666 relaxParams.set("partitioner: local parts", ad.n_local_parts);
667 }
668 this->parameter_list.set("schwarz: combine mode", "ADD");
669 this->parameter_list.set("schwarz: overlap level", ad.overlap);
670 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
671 }
672
673
674
675 /* ---------------------- PreconditionChebyshev ----------------------*/
676 template <typename Number, typename MemorySpace>
677 PreconditionChebyshev<Number, MemorySpace>::AdditionalData::AdditionalData(
678 const int degree,
679 const double max_eigenvalue,
680 const double eigenvalue_ratio,
681 const double min_eigenvalue,
682 const double min_diagonal,
683 const bool nonzero_starting)
684 : degree(degree)
685 , max_eigenvalue(max_eigenvalue)
686 , min_eigenvalue(min_eigenvalue)
687 , eigenvalue_ratio(eigenvalue_ratio)
688 , min_diagonal(min_diagonal)
689 , nonzero_starting(nonzero_starting)
690 {}
691
692
693
694 template <typename Number, typename MemorySpace>
695 PreconditionChebyshev<Number, MemorySpace>::PreconditionChebyshev()
696 : PreconditionIfpackBase<Number, MemorySpace>("CHEBYSHEV")
697 {}
698
699
700
701 template <typename Number, typename MemorySpace>
702 void
703 PreconditionChebyshev<Number, MemorySpace>::initialize(
704 const SparseMatrix<Number, MemorySpace> &A,
705 const AdditionalData &ad)
706 {
707 this->parameter_list.set("chebyshev: degree", ad.degree);
708 this->parameter_list.set("chebyshev: max eigenvalue", ad.max_eigenvalue);
709 this->parameter_list.set("chebyshev: min eigenvalue", ad.min_eigenvalue);
710 this->parameter_list.set("chebyshev: ratio eigenvalue",
711 ad.eigenvalue_ratio);
712 this->parameter_list.set("chebyshev: min diagonal value",
713 ad.min_diagonal);
714 this->parameter_list.set("chebyshev: zero starting solution",
715 !ad.nonzero_starting);
716 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
717 }
718
719
720
721 /* ---------------------- PreconditionILU ----------------------*/
722 template <typename Number, typename MemorySpace>
723 PreconditionILU<Number, MemorySpace>::AdditionalData::AdditionalData(
724 const int ilu_fill,
725 const double ilu_atol,
726 const double ilu_rtol,
727 const int overlap)
728 : ilu_fill(ilu_fill)
729 , ilu_atol(ilu_atol)
730 , ilu_rtol(ilu_rtol)
731 , overlap(overlap)
732 {}
733
734
735
736 template <typename Number, typename MemorySpace>
737 PreconditionILU<Number, MemorySpace>::PreconditionILU()
738 : PreconditionIfpackBase<Number, MemorySpace>("SCHWARZ")
739 {}
740
741
742
743 template <typename Number, typename MemorySpace>
744 void
745 PreconditionILU<Number, MemorySpace>::initialize(
746 const SparseMatrix<Number, MemorySpace> &A,
747 const AdditionalData &ad)
748 {
749 this->parameter_list.set("schwarz: subdomain solver name", "RILUK");
750 {
751 Teuchos::ParameterList &rilukParams =
752 this->parameter_list.sublist("schwarz: subdomain solver parameters",
753 false);
754 rilukParams.set("fact: iluk level-of-fill", ad.ilu_fill);
755 rilukParams.set("fact: absolute threshold", ad.ilu_atol);
756 rilukParams.set("fact: relative threshold", ad.ilu_rtol);
757 }
758 this->parameter_list.set("schwarz: combine mode", "ADD");
759 this->parameter_list.set("schwarz: overlap level", ad.overlap);
760 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
761 }
762
763
764
765 /* ---------------------- PreconditionILUT ----------------------*/
766 template <typename Number, typename MemorySpace>
767 PreconditionILUT<Number, MemorySpace>::AdditionalData::AdditionalData(
768 const double ilut_drop,
769 const double ilut_fill,
770 const double ilut_atol,
771 const double ilut_rtol,
772 const int overlap)
773 : ilut_drop(ilut_drop)
774 , ilut_fill(ilut_fill)
775 , ilut_atol(ilut_atol)
776 , ilut_rtol(ilut_rtol)
777 , overlap(overlap)
778 {}
779
780
781
782 template <typename Number, typename MemorySpace>
783 PreconditionILUT<Number, MemorySpace>::PreconditionILUT()
784 : PreconditionIfpackBase<Number, MemorySpace>("SCHWARZ")
785 {}
786
787
788
789 template <typename Number, typename MemorySpace>
790 void
791 PreconditionILUT<Number, MemorySpace>::initialize(
792 const SparseMatrix<Number, MemorySpace> &A,
793 const AdditionalData &ad)
794 {
795 this->parameter_list.set("schwarz: subdomain solver name", "ILUT");
796 {
797 Teuchos::ParameterList &ilutParams =
798 this->parameter_list.sublist("schwarz: subdomain solver parameters",
799 false);
800 ilutParams.set("fact: drop tolerance", ad.ilut_drop);
801 ilutParams.set("fact: ilut level-of-fill", ad.ilut_fill);
802 ilutParams.set("fact: absolute threshold", ad.ilut_atol);
803 ilutParams.set("fact: relative threshold", ad.ilut_rtol);
804 }
805 this->parameter_list.set("schwarz: combine mode", "ADD");
806 this->parameter_list.set("schwarz: overlap level", ad.overlap);
807 PreconditionIfpackBase<Number, MemorySpace>::initialize(A);
808 }
809 } // namespace TpetraWrappers
810 } // namespace LinearAlgebra
811
812 DEAL_II_NAMESPACE_CLOSE
813
814 # endif // DEAL_II_TRILINOS_WITH_IFPACK2
815 #else
816
817 // Make sure the scripts that create the C++20 module input files have
818 // something to latch on if the preprocessor #ifdef above would
819 // otherwise lead to an empty content of the file.
820 DEAL_II_NAMESPACE_OPEN
821 DEAL_II_NAMESPACE_CLOSE
822
823 #endif // DEAL_II_TRILINOS_WITH_TPETRA
824
825 #endif