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