deal.II version GIT relicensing-6834-g5b78e6bcdf 2026-10-01 11:20:01+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
trilinos_precondition.cc
Go to the documentation of this file.
1// -----------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
4// Copyright (C) 2008 - 2026 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Detailed license information governing the source code and contributions
9// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
10//
11// -----------------------------------------------------------------------------
12
13#include <deal.II/lac/trilinos_precondition.h>
14
15#ifdef DEAL_II_WITH_TRILINOS
16
17# include <deal.II/lac/sparse_matrix.h>
18# include <deal.II/lac/trilinos_sparse_matrix.h>
19# include <deal.II/lac/vector.h>
20
21DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
22# include <Epetra_MultiVector.h>
23# include <Ifpack.h>
24# include <Ifpack_Chebyshev.h>
25# include <Teuchos_ParameterList.hpp>
26# include <Teuchos_RCP.hpp>
27DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
28
29
30#endif // DEAL_II_WITH_TRILINOS
31
32DEAL_II_NAMESPACE_OPEN
33
34#ifdef DEAL_II_WITH_TRILINOS
35
36namespace TrilinosWrappers
37{
38 PreconditionBase::PreconditionBase()
39 : communicator(MPI_COMM_SELF)
40 {}
41
42
43 void
44 PreconditionBase::clear()
45 {
46 preconditioner.reset();
47 communicator = MPI_COMM_SELF;
48 }
49
50
51 MPI_Comm
52 PreconditionBase::get_mpi_communicator() const
53 {
54 return communicator.Comm();
55 }
56
57
58 Epetra_Operator &
59 PreconditionBase::trilinos_operator() const
60 {
61 AssertThrow(!preconditioner.is_null(),
62 ExcMessage("Trying to dereference a null pointer."));
63 return (*preconditioner);
64 }
65
66
67 IndexSet
68 PreconditionBase::locally_owned_domain_indices() const
69 {
70 return IndexSet(preconditioner->OperatorDomainMap());
71 }
72
73
74 IndexSet
75 PreconditionBase::locally_owned_range_indices() const
76 {
77 return IndexSet(preconditioner->OperatorRangeMap());
78 }
79
80 /* -------------------------- PreconditionJacobi -------------------------- */
81
82 PreconditionJacobi::AdditionalData::AdditionalData(
83 const double omega,
84 const double min_diagonal,
85 const unsigned int n_sweeps)
86 : omega(omega)
87 , min_diagonal(min_diagonal)
88 , n_sweeps(n_sweeps)
89 {}
90
91
92
93 void
94 PreconditionJacobi::initialize(const SparseMatrix &matrix,
95 const AdditionalData &additional_data)
96 {
97 // release memory before reallocation
98 preconditioner.reset();
99 preconditioner.reset(
100 Ifpack().Create("point relaxation",
101 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
102 0));
103
104 Ifpack_Preconditioner *ifpack =
105 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
106 Assert(ifpack != nullptr,
107 ExcMessage("Trilinos could not create this "
108 "preconditioner"));
109
110 int ierr;
111
112 Teuchos::ParameterList parameter_list;
113 parameter_list.set("relaxation: sweeps",
114 static_cast<int>(additional_data.n_sweeps));
115 parameter_list.set("relaxation: type", "Jacobi");
116 parameter_list.set("relaxation: damping factor", additional_data.omega);
117 parameter_list.set("relaxation: min diagonal value",
118 additional_data.min_diagonal);
119
120 ierr = ifpack->SetParameters(parameter_list);
121 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
122
123 ierr = ifpack->Initialize();
124 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
125
126 ierr = ifpack->Compute();
127 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
128 }
129
130
131
132 /* -------------------------- PreconditionSSOR -------------------------- */
133
134 PreconditionSSOR::AdditionalData::AdditionalData(const double omega,
135 const double min_diagonal,
136 const unsigned int overlap,
137 const unsigned int n_sweeps)
138 : omega(omega)
139 , min_diagonal(min_diagonal)
140 , overlap(overlap)
141 , n_sweeps(n_sweeps)
142 {}
143
144
145
146 void
147 PreconditionSSOR::initialize(const SparseMatrix &matrix,
148 const AdditionalData &additional_data)
149 {
150 preconditioner.reset();
151 preconditioner.reset(
152 Ifpack().Create("point relaxation",
153 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
154 additional_data.overlap));
155
156 Ifpack_Preconditioner *ifpack =
157 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
158 Assert(ifpack != nullptr,
159 ExcMessage("Trilinos could not create this "
160 "preconditioner"));
161
162 int ierr;
163
164 Teuchos::ParameterList parameter_list;
165 parameter_list.set("relaxation: sweeps",
166 static_cast<int>(additional_data.n_sweeps));
167 parameter_list.set("relaxation: type", "symmetric Gauss-Seidel");
168 parameter_list.set("relaxation: damping factor", additional_data.omega);
169 parameter_list.set("relaxation: min diagonal value",
170 additional_data.min_diagonal);
171 parameter_list.set("schwarz: combine mode", "Add");
172
173 ierr = ifpack->SetParameters(parameter_list);
174 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
175
176 ierr = ifpack->Initialize();
177 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
178
179 ierr = ifpack->Compute();
180 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
181 }
182
183
184
185 /* -------------------------- PreconditionSOR -------------------------- */
186
187 PreconditionSOR::AdditionalData::AdditionalData(const double omega,
188 const double min_diagonal,
189 const unsigned int overlap,
190 const unsigned int n_sweeps)
191 : omega(omega)
192 , min_diagonal(min_diagonal)
193 , overlap(overlap)
194 , n_sweeps(n_sweeps)
195 {}
196
197
198
199 void
200 PreconditionSOR::initialize(const SparseMatrix &matrix,
201 const AdditionalData &additional_data)
202 {
203 preconditioner.reset();
204 preconditioner.reset(
205 Ifpack().Create("point relaxation",
206 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
207 additional_data.overlap));
208
209 Ifpack_Preconditioner *ifpack =
210 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
211 Assert(ifpack != nullptr,
212 ExcMessage("Trilinos could not create this "
213 "preconditioner"));
214
215 int ierr;
216
217 Teuchos::ParameterList parameter_list;
218 parameter_list.set("relaxation: sweeps",
219 static_cast<int>(additional_data.n_sweeps));
220 parameter_list.set("relaxation: type", "Gauss-Seidel");
221 parameter_list.set("relaxation: damping factor", additional_data.omega);
222 parameter_list.set("relaxation: min diagonal value",
223 additional_data.min_diagonal);
224 parameter_list.set("schwarz: combine mode", "Add");
225
226 ierr = ifpack->SetParameters(parameter_list);
227 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
228
229 ierr = ifpack->Initialize();
230 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
231
232 ierr = ifpack->Compute();
233 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
234 }
235
236
237
238 /* ----------------------- PreconditionBlockJacobi ---------------------- */
239
240 PreconditionBlockJacobi::AdditionalData::AdditionalData(
241 const unsigned int block_size,
242 const std::string &block_creation_type,
243 const double omega,
244 const double min_diagonal,
245 const unsigned int n_sweeps)
246 : block_size(block_size)
247 , block_creation_type(block_creation_type)
248 , omega(omega)
249 , min_diagonal(min_diagonal)
250 , n_sweeps(n_sweeps)
251 {}
252
253
254
255 void
256 PreconditionBlockJacobi::initialize(const SparseMatrix &matrix,
257 const AdditionalData &additional_data)
258 {
259 // release memory before reallocation
260 preconditioner.reset();
261
262 // Block relaxation setup fails if we have no locally owned rows. As a
263 // work-around we just pretend to use point relaxation on those processors:
264 preconditioner.reset(
265 Ifpack().Create((matrix.trilinos_matrix().NumMyRows() == 0) ?
266 "point relaxation" :
267 "block relaxation",
268 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
269 0));
270
271 Ifpack_Preconditioner *ifpack =
272 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
273 Assert(ifpack != nullptr,
274 ExcMessage("Trilinos could not create this "
275 "preconditioner"));
276
277 int ierr;
278
279 Teuchos::ParameterList parameter_list;
280 parameter_list.set("relaxation: sweeps",
281 static_cast<int>(additional_data.n_sweeps));
282 parameter_list.set("relaxation: type", "Jacobi");
283 parameter_list.set("relaxation: damping factor", additional_data.omega);
284 parameter_list.set("relaxation: min diagonal value",
285 additional_data.min_diagonal);
286 parameter_list.set("partitioner: type",
287 additional_data.block_creation_type);
288 int n_local_parts =
289 (matrix.trilinos_matrix().NumMyRows() + additional_data.block_size - 1) /
290 additional_data.block_size;
291 parameter_list.set("partitioner: local parts", n_local_parts);
292
293 ierr = ifpack->SetParameters(parameter_list);
294 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
295
296 ierr = ifpack->Initialize();
297 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
298
299 ierr = ifpack->Compute();
300 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
301 }
302
303
304
305 /* ----------------------- PreconditionBlockSSOR ------------------------ */
306
307 PreconditionBlockSSOR::AdditionalData::AdditionalData(
308 const unsigned int block_size,
309 const std::string &block_creation_type,
310 const double omega,
311 const double min_diagonal,
312 const unsigned int overlap,
313 const unsigned int n_sweeps)
314 : block_size(block_size)
315 , block_creation_type(block_creation_type)
316 , omega(omega)
317 , min_diagonal(min_diagonal)
318 , overlap(overlap)
319 , n_sweeps(n_sweeps)
320 {}
321
322
323
324 void
325 PreconditionBlockSSOR::initialize(const SparseMatrix &matrix,
326 const AdditionalData &additional_data)
327 {
328 preconditioner.reset();
329
330 // Block relaxation setup fails if we have no locally owned rows. As a
331 // work-around we just pretend to use point relaxation on those processors:
332 preconditioner.reset(
333 Ifpack().Create((matrix.trilinos_matrix().NumMyRows() == 0) ?
334 "point relaxation" :
335 "block relaxation",
336 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
337 additional_data.overlap));
338
339 Ifpack_Preconditioner *ifpack =
340 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
341 Assert(ifpack != nullptr,
342 ExcMessage("Trilinos could not create this "
343 "preconditioner"));
344
345 int ierr;
346
347 Teuchos::ParameterList parameter_list;
348 parameter_list.set("relaxation: sweeps",
349 static_cast<int>(additional_data.n_sweeps));
350 parameter_list.set("relaxation: type", "symmetric Gauss-Seidel");
351 parameter_list.set("relaxation: damping factor", additional_data.omega);
352 parameter_list.set("relaxation: min diagonal value",
353 additional_data.min_diagonal);
354 parameter_list.set("schwarz: combine mode", "Add");
355 parameter_list.set("partitioner: type",
356 additional_data.block_creation_type);
357 int n_local_parts =
358 (matrix.trilinos_matrix().NumMyRows() + additional_data.block_size - 1) /
359 additional_data.block_size;
360 parameter_list.set("partitioner: local parts", n_local_parts);
361
362 ierr = ifpack->SetParameters(parameter_list);
363 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
364
365 ierr = ifpack->Initialize();
366 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
367
368 ierr = ifpack->Compute();
369 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
370 }
371
372
373
374 /* ------------------------ PreconditionBlockSOR ------------------------ */
375
376 PreconditionBlockSOR::AdditionalData::AdditionalData(
377 const unsigned int block_size,
378 const std::string &block_creation_type,
379 const double omega,
380 const double min_diagonal,
381 const unsigned int overlap,
382 const unsigned int n_sweeps)
383 : block_size(block_size)
384 , block_creation_type(block_creation_type)
385 , omega(omega)
386 , min_diagonal(min_diagonal)
387 , overlap(overlap)
388 , n_sweeps(n_sweeps)
389 {}
390
391
392
393 void
394 PreconditionBlockSOR::initialize(const SparseMatrix &matrix,
395 const AdditionalData &additional_data)
396 {
397 preconditioner.reset();
398
399 // Block relaxation setup fails if we have no locally owned rows. As a
400 // work-around we just pretend to use point relaxation on those processors:
401 preconditioner.reset(
402 Ifpack().Create((matrix.trilinos_matrix().NumMyRows() == 0) ?
403 "point relaxation" :
404 "block relaxation",
405 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
406 additional_data.overlap));
407
408 Ifpack_Preconditioner *ifpack =
409 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
410 Assert(ifpack != nullptr,
411 ExcMessage("Trilinos could not create this "
412 "preconditioner"));
413
414 int ierr;
415
416 Teuchos::ParameterList parameter_list;
417 parameter_list.set("relaxation: sweeps",
418 static_cast<int>(additional_data.n_sweeps));
419 parameter_list.set("relaxation: type", "Gauss-Seidel");
420 parameter_list.set("relaxation: damping factor", additional_data.omega);
421 parameter_list.set("relaxation: min diagonal value",
422 additional_data.min_diagonal);
423 parameter_list.set("schwarz: combine mode", "Add");
424 parameter_list.set("partitioner: type",
425 additional_data.block_creation_type);
426 int n_local_parts =
427 (matrix.trilinos_matrix().NumMyRows() + additional_data.block_size - 1) /
428 additional_data.block_size;
429 parameter_list.set("partitioner: local parts", n_local_parts);
430
431 ierr = ifpack->SetParameters(parameter_list);
432 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
433
434 ierr = ifpack->Initialize();
435 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
436
437 ierr = ifpack->Compute();
438 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
439 }
440
441
442
443 /* -------------------------- PreconditionIC -------------------------- */
444
445 PreconditionIC::AdditionalData::AdditionalData(const unsigned int ic_fill,
446 const double ic_atol,
447 const double ic_rtol,
448 const unsigned int overlap)
449 : ic_fill(ic_fill)
450 , ic_atol(ic_atol)
451 , ic_rtol(ic_rtol)
452 , overlap(overlap)
453 {}
454
455
456
457 void
458 PreconditionIC::initialize(const SparseMatrix &matrix,
459 const AdditionalData &additional_data)
460 {
461 preconditioner.reset();
462 preconditioner.reset(
463 Ifpack().Create("IC",
464 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
465 additional_data.overlap));
466
467 Ifpack_Preconditioner *ifpack =
468 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
469 Assert(ifpack != nullptr,
470 ExcMessage("Trilinos could not create this "
471 "preconditioner"));
472
473 int ierr;
474
475 Teuchos::ParameterList parameter_list;
476 parameter_list.set("fact: level-of-fill", additional_data.ic_fill);
477 parameter_list.set("fact: absolute threshold", additional_data.ic_atol);
478 parameter_list.set("fact: relative threshold", additional_data.ic_rtol);
479 parameter_list.set("schwarz: combine mode", "Add");
480
481 ierr = ifpack->SetParameters(parameter_list);
482 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
483
484 ierr = ifpack->Initialize();
485 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
486
487 ierr = ifpack->Compute();
488 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
489 }
490
491
492
493 /* -------------------------- PreconditionILU -------------------------- */
494
495 PreconditionILU::AdditionalData::AdditionalData(const unsigned int ilu_fill,
496 const double ilu_atol,
497 const double ilu_rtol,
498 const unsigned int overlap)
499 : ilu_fill(ilu_fill)
500 , ilu_atol(ilu_atol)
501 , ilu_rtol(ilu_rtol)
502 , overlap(overlap)
503 {}
504
505
506
507 void
508 PreconditionILU::initialize(const SparseMatrix &matrix,
509 const AdditionalData &additional_data)
510 {
511 preconditioner.reset();
512 preconditioner.reset(
513 Ifpack().Create("ILU",
514 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
515 additional_data.overlap));
516
517 Ifpack_Preconditioner *ifpack =
518 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
519 Assert(ifpack != nullptr,
520 ExcMessage("Trilinos could not create this "
521 "preconditioner"));
522
523 int ierr;
524
525 Teuchos::ParameterList parameter_list;
526 parameter_list.set("fact: level-of-fill",
527 static_cast<int>(additional_data.ilu_fill));
528 parameter_list.set("fact: absolute threshold", additional_data.ilu_atol);
529 parameter_list.set("fact: relative threshold", additional_data.ilu_rtol);
530 parameter_list.set("schwarz: combine mode", "Add");
531
532 ierr = ifpack->SetParameters(parameter_list);
533 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
534
535 ierr = ifpack->Initialize();
536 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
537
538 ierr = ifpack->Compute();
539 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
540 }
541
542
543
544 /* -------------------------- PreconditionILUT -------------------------- */
545
546 PreconditionILUT::AdditionalData::AdditionalData(const double ilut_drop,
547 const unsigned int ilut_fill,
548 const double ilut_atol,
549 const double ilut_rtol,
550 const unsigned int overlap)
551 : ilut_drop(ilut_drop)
552 , ilut_fill(ilut_fill)
553 , ilut_atol(ilut_atol)
554 , ilut_rtol(ilut_rtol)
555 , overlap(overlap)
556 {}
557
558
559
560 void
561 PreconditionILUT::initialize(const SparseMatrix &matrix,
562 const AdditionalData &additional_data)
563 {
564 preconditioner.reset();
565 preconditioner.reset(
566 Ifpack().Create("ILUT",
567 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
568 additional_data.overlap));
569
570 Ifpack_Preconditioner *ifpack =
571 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
572 Assert(ifpack != nullptr,
573 ExcMessage("Trilinos could not create this "
574 "preconditioner"));
575
576 int ierr;
577
578 Teuchos::ParameterList parameter_list;
579 parameter_list.set("fact: drop value", additional_data.ilut_drop);
580 parameter_list.set("fact: level-of-fill",
581 static_cast<int>(additional_data.ilut_fill));
582 parameter_list.set("fact: absolute threshold", additional_data.ilut_atol);
583 parameter_list.set("fact: relative threshold", additional_data.ilut_rtol);
584 parameter_list.set("schwarz: combine mode", "Add");
585
586 ierr = ifpack->SetParameters(parameter_list);
587 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
588
589 ierr = ifpack->Initialize();
590 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
591
592 ierr = ifpack->Compute();
593 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
594 }
595
596
597
598 /* ---------------------- PreconditionBlockDirect --------------------- */
599
600 PreconditionBlockwiseDirect::AdditionalData::AdditionalData(
601 const unsigned int overlap)
602 : overlap(overlap)
603 {}
604
605
606
607 void
608 PreconditionBlockwiseDirect::initialize(const SparseMatrix &matrix,
609 const AdditionalData &additional_data)
610 {
611 preconditioner.reset();
612 preconditioner.reset(
613 Ifpack().Create("Amesos",
614 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
615 additional_data.overlap));
616
617 Ifpack_Preconditioner *ifpack =
618 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
619 Assert(ifpack != nullptr,
620 ExcMessage("Trilinos could not create this "
621 "preconditioner"));
622
623 int ierr;
624
625 Teuchos::ParameterList parameter_list;
626 parameter_list.set("schwarz: combine mode", "Add");
627
628 ierr = ifpack->SetParameters(parameter_list);
629 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
630
631 ierr = ifpack->Initialize();
632 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
633
634 ierr = ifpack->Compute();
635 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
636 }
637
638
639
640 /* ---------------------- PreconditionBlockDirect --------------------- */
641
642 PreconditionChebyshev::AdditionalData::AdditionalData(
643 const unsigned int degree,
644 const double max_eigenvalue,
645 const double eigenvalue_ratio,
646 const double min_eigenvalue,
647 const double min_diagonal,
648 const bool nonzero_starting)
649 : degree(degree)
650 , max_eigenvalue(max_eigenvalue)
651 , eigenvalue_ratio(eigenvalue_ratio)
652 , min_eigenvalue(min_eigenvalue)
653 , min_diagonal(min_diagonal)
654 , nonzero_starting(nonzero_starting)
655 {}
656
657
658
659 void
660 PreconditionChebyshev::initialize(const SparseMatrix &matrix,
661 const AdditionalData &additional_data)
662 {
663 preconditioner =
664 Teuchos::rcp(new Ifpack_Chebyshev(&matrix.trilinos_matrix()));
665
666 Ifpack_Chebyshev *ifpack =
667 dynamic_cast<Ifpack_Chebyshev *>(preconditioner.get());
668 Assert(ifpack != nullptr,
669 ExcMessage("Trilinos could not create this "
670 "preconditioner"));
671
672 int ierr;
673
674 Teuchos::ParameterList parameter_list;
675 parameter_list.set("chebyshev: ratio eigenvalue",
676 additional_data.eigenvalue_ratio);
677 parameter_list.set("chebyshev: min eigenvalue",
678 additional_data.min_eigenvalue);
679 parameter_list.set("chebyshev: max eigenvalue",
680 additional_data.max_eigenvalue);
681 parameter_list.set("chebyshev: degree",
682 static_cast<int>(additional_data.degree));
683 parameter_list.set("chebyshev: min diagonal value",
684 additional_data.min_diagonal);
685 parameter_list.set("chebyshev: zero starting solution",
686 !additional_data.nonzero_starting);
687
688 ierr = ifpack->SetParameters(parameter_list);
689 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
690
691 ierr = ifpack->Initialize();
692 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
693
694 ierr = ifpack->Compute();
695 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
696 }
697
698
699
700 /* -------------------------- PreconditionIdentity --------------------- */
701
702 void
703 PreconditionIdentity::initialize(const SparseMatrix &matrix,
704 const AdditionalData &)
705 {
706 // What follows just configures a dummy preconditioner that
707 // sets up the domain and range maps, as well as the communicator.
708 // It is never used as the vmult, Tvmult operations are
709 // given a custom definition.
710 // Note: This is only required in order to wrap this
711 // preconditioner in a LinearOperator without an exemplar
712 // matrix.
713
714 // From PreconditionJacobi:
715 // release memory before reallocation
716 preconditioner.reset();
717 preconditioner.reset(
718 Ifpack().Create("point relaxation",
719 const_cast<Epetra_CrsMatrix *>(&matrix.trilinos_matrix()),
720 0));
721
722 Ifpack_Preconditioner *ifpack =
723 dynamic_cast<Ifpack_Preconditioner *>(preconditioner.get());
724 Assert(ifpack != nullptr,
725 ExcMessage("Trilinos could not create this "
726 "preconditioner"));
727
728 int ierr;
729
730 Teuchos::ParameterList parameter_list;
731 parameter_list.set("relaxation: sweeps", 1);
732 parameter_list.set("relaxation: type", "Jacobi");
733 parameter_list.set("relaxation: damping factor", 1.0);
734 parameter_list.set("relaxation: min diagonal value", 0.0);
735
736 ierr = ifpack->SetParameters(parameter_list);
737 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
738
739 ierr = ifpack->Initialize();
740 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
741
742 ierr = ifpack->Compute();
743 AssertThrow(ierr == 0, ExcTrilinosError(ierr));
744 }
745
746 void
747 PreconditionIdentity::vmult(MPI::Vector &dst, const MPI::Vector &src) const
748 {
749 dst = src;
750 }
751
752 void
753 PreconditionIdentity::Tvmult(MPI::Vector &dst, const MPI::Vector &src) const
754 {
755 dst = src;
756 }
757
758 void
759 PreconditionIdentity::vmult(::Vector<double> &dst,
760 const ::Vector<double> &src) const
761 {
762 dst = src;
763 }
764
765 void
766 PreconditionIdentity::Tvmult(::Vector<double> &dst,
767 const ::Vector<double> &src) const
768 {
769 dst = src;
770 }
771
772# ifndef DOXYGEN
773 void
774 PreconditionIdentity::vmult(
775 LinearAlgebra::distributed::Vector<double> &dst,
776 const LinearAlgebra::distributed::Vector<double> &src) const
777 {
778 dst = src;
779 }
780
781 void
782 PreconditionIdentity::Tvmult(
783 LinearAlgebra::distributed::Vector<double> &dst,
784 const LinearAlgebra::distributed::Vector<double> &src) const
785 {
786 dst = src;
787 }
788# endif // DOXYGEN
789} // namespace TrilinosWrappers
790
791
792#endif // DEAL_II_WITH_TRILINOS
793DEAL_II_NAMESPACE_CLOSE
Epetra_Operator
MPI_Comm
TrilinosWrappers::PreconditionBase::trilinos_operator
Epetra_Operator & trilinos_operator() const
Definition trilinos_precondition.cc:59
TrilinosWrappers::PreconditionBase::preconditioner
Teuchos::RCP< Epetra_Operator > preconditioner
Definition trilinos_precondition.h:231
TrilinosWrappers::PreconditionBlockJacobi::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:256
TrilinosWrappers::PreconditionBlockSOR::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:394
TrilinosWrappers::PreconditionBlockSSOR::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:325
TrilinosWrappers::PreconditionBlockwiseDirect::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:608
TrilinosWrappers::PreconditionChebyshev::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:660
TrilinosWrappers::PreconditionIC::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:458
TrilinosWrappers::PreconditionILUT::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:561
TrilinosWrappers::PreconditionILU::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:508
TrilinosWrappers::PreconditionIdentity::vmult
void vmult(MPI::Vector &dst, const MPI::Vector &src) const override
Definition trilinos_precondition.cc:747
TrilinosWrappers::PreconditionIdentity::Tvmult
void Tvmult(MPI::Vector &dst, const MPI::Vector &src) const override
Definition trilinos_precondition.cc:753
TrilinosWrappers::PreconditionIdentity::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:703
TrilinosWrappers::PreconditionJacobi::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:94
TrilinosWrappers::PreconditionSOR::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:200
TrilinosWrappers::PreconditionSSOR::initialize
void initialize(const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
Definition trilinos_precondition.cc:147
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:38
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
#define DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
Definition config.h:636
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:39
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
#define DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
Definition config.h:680
Assert
#define Assert(cond, exc)
Definition exception_macros.h:543
LACExceptions::ExcTrilinosError
static ::ExceptionBase & ExcTrilinosError(int arg1)
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
AssertThrow
#define AssertThrow(cond, exc)
Definition exception_macros.h:647
sparse_matrix.h
TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::AdditionalData
AdditionalData(const unsigned int block_size=1, const std::string &block_creation_type="linear", const double omega=1, const double min_diagonal=0, const unsigned int n_sweeps=1)
Definition trilinos_precondition.cc:240
TrilinosWrappers::PreconditionBlockSOR::AdditionalData::AdditionalData
AdditionalData(const unsigned int block_size=1, const std::string &block_creation_type="linear", const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)
Definition trilinos_precondition.cc:376
TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::AdditionalData
AdditionalData(const unsigned int block_size=1, const std::string &block_creation_type="linear", const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)
Definition trilinos_precondition.cc:307
TrilinosWrappers::PreconditionChebyshev::AdditionalData::AdditionalData
AdditionalData(const unsigned int degree=1, const double max_eigenvalue=10., const double eigenvalue_ratio=30., const double min_eigenvalue=1., const double min_diagonal=1e-12, const bool nonzero_starting=false)
Definition trilinos_precondition.cc:642
TrilinosWrappers::PreconditionIC::AdditionalData::AdditionalData
AdditionalData(const unsigned int ic_fill=0, const double ic_atol=0., const double ic_rtol=1., const unsigned int overlap=0)
Definition trilinos_precondition.cc:445
TrilinosWrappers::PreconditionILUT::AdditionalData::AdditionalData
AdditionalData(const double ilut_drop=0., const unsigned int ilut_fill=0, const double ilut_atol=0., const double ilut_rtol=1., const unsigned int overlap=0)
Definition trilinos_precondition.cc:546
TrilinosWrappers::PreconditionILU::AdditionalData::AdditionalData
AdditionalData(const unsigned int ilu_fill=0, const double ilu_atol=0., const double ilu_rtol=1., const unsigned int overlap=0)
Definition trilinos_precondition.cc:495
TrilinosWrappers::PreconditionJacobi::AdditionalData::AdditionalData
AdditionalData(const double omega=1, const double min_diagonal=0, const unsigned int n_sweeps=1)
Definition trilinos_precondition.cc:82
TrilinosWrappers::PreconditionSOR::AdditionalData::AdditionalData
AdditionalData(const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)
Definition trilinos_precondition.cc:187
TrilinosWrappers::PreconditionSSOR::AdditionalData::AdditionalData
AdditionalData(const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)
Definition trilinos_precondition.cc:134
trilinos_precondition.h
trilinos_sparse_matrix.h
Generated by doxygen 1.9.8