Debian Codegraph @

include/deal.II/lac/trilinos_tpetra_solver_direct.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_solver_templates_h
16 #define dealii_trilinos_tpetra_solver_templates_h
17
18 #include <deal.II/base/config.h>
19
20 #include <deal.II/lac/solver_control.h>
21 #include <deal.II/lac/trilinos_tpetra_types.h>
22
23 #include <string>
24
25
26 #ifdef DEAL_II_TRILINOS_WITH_TPETRA
27 # ifdef DEAL_II_TRILINOS_WITH_AMESOS2
28
29 # include <deal.II/base/conditional_ostream.h>
30 # include <deal.II/base/template_constraints.h>
31
32 # include <deal.II/lac/trilinos_tpetra_solver_direct.h>
33
34
35 DEAL_II_NAMESPACE_OPEN
36
37 namespace LinearAlgebra
38 {
39 namespace TpetraWrappers
40 {
41 /* ---------------------- SolverDirectBase ------------------------ */
42
43 template <typename Number, typename MemorySpace>
44 SolverDirectBase<Number, MemorySpace>::SolverDirectBase(
45 SolverControl &cn,
46 const std::string &solver_type)
47 : solver_control(cn)
48 , solver_type(solver_type)
49 {
50 AssertThrow(Amesos2::query(solver_type),
51 ExcTrilinosAmesos2SolverUnsupported(solver_type));
52 }
53
54
55
56 template <typename Number, typename MemorySpace>
57 SolverControl &
58 SolverDirectBase<Number, MemorySpace>::control() const
59 {
60 return solver_control;
61 }
62
63
64
65 template <typename Number, typename MemorySpace>
66 void
67 SolverDirectBase<Number, MemorySpace>::initialize(
68 const SparseMatrix<Number, MemorySpace> &A)
69 {
70 // Allocate the Amesos2 solver with the concrete solver, if possible.
71 solver =
72 Amesos2::create<TpetraTypes::MatrixType<Number, MemorySpace>,
73 TpetraTypes::MultiVectorType<Number, MemorySpace>>(
74 solver_type, A.trilinos_rcp());
75
76 solver->setParameters(Teuchos::rcpFromRef(parameter_list));
77 // Now do the actual factorization, which is a two step procedure.
78 // The symbolic factorization determines the structure of the inverse,
79 // while the numeric factorization does to actual computation of L and U
80 solver->symbolicFactorization();
81
82 solver->numericFactorization();
83 }
84
85
86
87 template <typename Number, typename MemorySpace>
88 void
89 SolverDirectBase<Number, MemorySpace>::solve(
90 Vector<Number, MemorySpace> &x,
91 const Vector<Number, MemorySpace> &b)
92 {
93 // Assign the empty solution vector
94 solver->setX(x.trilinos_rcp());
95
96 // Assign the RHS vector
97 solver->setB(b.trilinos_rcp());
98
99 solver->solve();
100
101 // Finally, force the SolverControl object to report convergence
102 solver_control.check(0, 0);
103 if (solver_control.last_check() != SolverControl::success)
104 AssertThrow(false,
105 SolverControl::NoConvergence(solver_control.last_step(),
106 solver_control.last_value()));
107 }
108
109
110
111 template <typename Number, typename MemorySpace>
112 void
113 SolverDirectBase<Number, MemorySpace>::do_solve()
114 {
115 // Set the parameter list. If it is empty defaults will be used.
116 solver->setParameters(Teuchos::rcpFromRef(parameter_list));
117 // Now do the actual factorization, which is a two step procedure.
118 // The symbolic factorization determines the structure of the inverse,
119 // while the numeric factorization does to actual computation of L and U
120 solver->symbolicFactorization();
121
122 solver->numericFactorization();
123
124 solver->solve();
125
126 // Finally, force the SolverControl object to report convergence
127 solver_control.check(0, 0);
128
129 if (solver_control.last_check() != SolverControl::success)
130 AssertThrow(false,
131 SolverControl::NoConvergence(solver_control.last_step(),
132 solver_control.last_value()));
133 }
134
135
136
137 template <typename Number, typename MemorySpace>
138 void
139 SolverDirectBase<Number, MemorySpace>::solve(
140 const SparseMatrix<Number, MemorySpace> &A,
141 Vector<Number, MemorySpace> &x,
142 const Vector<Number, MemorySpace> &b)
143 {
144 solver =
145 Amesos2::create<TpetraTypes::MatrixType<Number, MemorySpace>,
146 TpetraTypes::MultiVectorType<Number, MemorySpace>>(
147 solver_type, A.trilinos_rcp(), x.trilinos_rcp(), b.trilinos_rcp());
148 do_solve();
149 }
150
151
152
153 template <typename Number, typename MemorySpace>
154 SolverDirect<Number, MemorySpace>::AdditionalData::AdditionalData(
155 const std::string &solver_name)
156 : solver_name(solver_name)
157 {}
158
159
160
161 template <typename Number, typename MemorySpace>
162 SolverDirect<Number, MemorySpace>::SolverDirect(SolverControl &cn,
163 const AdditionalData &ad)
164 : SolverDirectBase<Number, MemorySpace>(cn, ad.solver_name)
165 {}
166
167
168
169 template <typename Number, typename MemorySpace>
170 void
171 SolverDirect<Number, MemorySpace>::set_pararameter_list(
172 Teuchos::ParameterList &parameter_list)
173 {
174 this->parameter_list.setParameters(parameter_list);
175 }
176
177
178
179 template <typename Number, typename MemorySpace>
180 SolverDirectKLU2<Number, MemorySpace>::AdditionalData::AdditionalData(
181 const std::string &transpose_mode,
182 const bool symmetric_mode,
183 const bool equilibrate_matrix,
184 const std::string &column_permutation,
185 const std::string &iterative_refinement)
186 : transpose_mode(transpose_mode)
187 , symmetric_mode(symmetric_mode)
188 , equilibrate_matrix(equilibrate_matrix)
189 , column_permutation(column_permutation)
190 , iterative_refinement(iterative_refinement)
191 {}
192
193
194
195 template <typename Number, typename MemorySpace>
196 SolverDirectKLU2<Number, MemorySpace>::SolverDirectKLU2(
197 SolverControl &cn,
198 const AdditionalData &ad)
199 : SolverDirectBase<Number, MemorySpace>(cn, "KLU2")
200 {
201 this->parameter_list = Teuchos::ParameterList("Amesos2");
202 Teuchos::ParameterList klu2_params = this->parameter_list.sublist("KLU2");
203 klu2_params.set("Trans", ad.transpose_mode);
204 klu2_params.set("Equil", ad.equilibrate_matrix);
205 klu2_params.set("IterRefine", ad.iterative_refinement);
206 klu2_params.set("SymmetricMode", ad.symmetric_mode);
207 klu2_params.set("ColPerm", ad.column_permutation);
208 }
209
210 } // namespace TpetraWrappers
211 } // namespace LinearAlgebra
212
213 DEAL_II_NAMESPACE_CLOSE
214
215 # endif // DEAL_II_TRILINOS_WITH_AMESOS2
216 #else
217
218 // Make sure the scripts that create the C++20 module input files have
219 // something to latch on if the preprocessor #ifdef above would
220 // otherwise lead to an empty content of the file.
221 DEAL_II_NAMESPACE_OPEN
222 DEAL_II_NAMESPACE_CLOSE
223
224 #endif // DEAL_II_TRILINOS_WITH_TPETRA
225
226 #endif