Arcane  v3.16.8.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
core/matvec/Matrix.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* Matrix.h (C) 2000-2025 */
9/* */
10/* Matrix d'algèbre linéraire. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_MATVEC_MATRIX_H
13#define ARCANE_CORE_MATVEC_MATRIX_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/Array.h"
18#include "arcane/utils/Numeric.h"
19
20#include "arcane/core/matvec/Vector.h"
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24
25namespace Arcane::MatVec
26{
27
28/*---------------------------------------------------------------------------*/
29/*---------------------------------------------------------------------------*/
30
31class Vector;
32class MatrixImpl;
33class IPreconditioner;
34class AMG;
35
36/*---------------------------------------------------------------------------*/
37/*---------------------------------------------------------------------------*/
43class ARCANE_CORE_EXPORT Matrix
44{
45 public:
46
47 Matrix()
48 : m_impl(0)
49 {}
50 Matrix(Integer nb_row, Integer nb_column);
51 Matrix(const Matrix& rhs);
52 ~Matrix();
53 void operator=(const Matrix& rhs);
54
55 private:
56
57 Matrix(MatrixImpl* impl);
58
59 public:
60
62 Matrix clone() const;
63
64 public:
65
66 // Nombre de lignes de la matrice
67 Integer nbRow() const;
68 // Nombre de colonnes de la matrice
69 Integer nbColumn() const;
71 void setRowsSize(IntegerConstArrayView rows_size);
75 void dump(std::ostream& o) const;
89 void setValue(Integer row, Integer column, Real value);
91 Real value(Integer row, Integer column) const;
93 void sortDiagonale();
95 static Matrix read(const String& filename);
97 static Matrix readHypre(const String& filename);
98
99 private:
100
103};
104
105/*---------------------------------------------------------------------------*/
106/*---------------------------------------------------------------------------*/
115class ARCANE_CORE_EXPORT IPreconditioner
116{
117 public:
118
119 virtual ~IPreconditioner() {}
120
121 public:
122
123 virtual void apply(Vector& out_vec, const Vector& vec) = 0;
124};
125
126/*---------------------------------------------------------------------------*/
127/*---------------------------------------------------------------------------*/
128
129class ARCANE_CORE_EXPORT ConjugateGradientSolver
130{
131 public:
132
133 ConjugateGradientSolver()
134 : m_nb_iteration(0)
135 , m_residual_norm(0.0)
136 , m_max_iteration(5000)
137 {}
138 bool solve(const Matrix& a, const Vector& b, Vector& x, Real epsilon, IPreconditioner* p = 0);
139 Integer nbIteration() const { return m_nb_iteration; }
140 Real residualNorm() const { return m_residual_norm; }
141 void setMaxIteration(Integer max_iteration)
142 {
143 m_max_iteration = max_iteration;
144 }
145
146 private:
147
148 Integer m_nb_iteration;
149 Real m_residual_norm;
150 Integer m_max_iteration;
151
152 private:
153
154 void _applySolver(const Matrix& a, const Vector& b, Vector& x, Real epsilon, IPreconditioner* p);
155 void _applySolver2(const Matrix& a, const Vector& b, Vector& x, Real epsilon, IPreconditioner* precond);
156 void _applySolverAsHypre(const Matrix& a, const Vector& b, Vector& x, Real tol, IPreconditioner* precond);
157};
158
159/*---------------------------------------------------------------------------*/
160/*---------------------------------------------------------------------------*/
167class ARCANE_CORE_EXPORT DiagonalPreconditioner
168: public IPreconditioner
169{
170 public:
171
172 DiagonalPreconditioner(const Matrix& matrix);
173
174 public:
175
176 virtual void apply(Vector& out_vec, const Vector& vec);
177
178 private:
179
180 Vector m_inverse_diagonal;
181};
182
183/*---------------------------------------------------------------------------*/
184/*---------------------------------------------------------------------------*/
185
186class ARCANE_CORE_EXPORT MatrixOperation
187{
188 public:
189
190 void matrixVectorProduct(const Matrix& mat, const Vector& vec, Vector& out_vec);
191 void matrixVectorProduct2(const Matrix& mat, const Vector& vec, Vector& out_vec);
192 Real dot(const Vector& vec);
193 Real dot(const Vector& vec1, const Vector& vec2);
194 void negateVector(Vector& vec);
195 void scaleVector(Vector& vec, Real mul);
196 void addVector(Vector& out_vec, const Vector& vec);
197};
198
199class ARCANE_CORE_EXPORT MatrixOperation2
200{
201 public:
202
203 Matrix matrixMatrixProduct(const Matrix& left_matrix, const Matrix& right_matrix);
204 Matrix matrixMatrixProductFast(const Matrix& left_matrix, const Matrix& right_matrix);
205 Matrix transpose(const Matrix& matrix);
206 Matrix transposeFast(const Matrix& matrix);
207 // Applique le produit de matrice L * M * R avec L = transpose(R)
208 Matrix applyGalerkinOperator(const Matrix& left_matrix, const Matrix& matrix, const Matrix& right_matrix);
209 Matrix applyGalerkinOperator2(const Matrix& left_matrix, const Matrix& matrix,
210 const Matrix& right_matrix);
211
212 private:
213
214 void _dumpColumnMatrix(std::ostream& o, IntegerConstArrayView columns_index,
216 RealConstArrayView values);
217};
218
219/*---------------------------------------------------------------------------*/
220/*---------------------------------------------------------------------------*/
221
222class ARCANE_CORE_EXPORT AMGPreconditioner
223: public IPreconditioner
224{
225 public:
226
227 AMGPreconditioner(ITraceMng* tm)
228 : m_trace_mng(tm)
229 , m_amg(0)
230 {}
231 virtual ~AMGPreconditioner();
232
233 public:
234
235 virtual void build(const Matrix& matrix);
236
237 public:
238
239 virtual void apply(Vector& out_vec, const Vector& vec);
240
241 private:
242
243 ITraceMng* m_trace_mng;
244 AMG* m_amg;
245};
246
247/*---------------------------------------------------------------------------*/
248/*---------------------------------------------------------------------------*/
249
250class ARCANE_CORE_EXPORT AMGSolver
251{
252 public:
253
254 AMGSolver(ITraceMng* tm)
255 : m_trace_mng(tm)
256 , m_amg(0)
257 {}
258 virtual ~AMGSolver();
259
260 public:
261
262 virtual void build(const Matrix& matrix);
263
264 public:
265
266 virtual void solve(const Vector& vector_b, Vector& vector_x);
267
268 private:
269
270 ITraceMng* m_trace_mng;
271 AMG* m_amg;
272};
273
274/*---------------------------------------------------------------------------*/
275/*---------------------------------------------------------------------------*/
282class ARCANE_CORE_EXPORT DirectSolver
283{
284 public:
285
286 void solve(const Matrix& matrix, const Vector& vector_b, Vector& vector_x);
287
288 private:
289
290 void _solve(RealArrayView mat_values, RealArrayView vec_values, Integer size);
291};
292
293/*---------------------------------------------------------------------------*/
294/*---------------------------------------------------------------------------*/
295
296} // namespace Arcane::MatVec
297
298/*---------------------------------------------------------------------------*/
299/*---------------------------------------------------------------------------*/
300
301#endif
Interface du gestionnaire de traces.
Solveur direct utilisant le pivot de gauss.
Interface d'un préconditionneur.
Matrice avec stockage CSR.
Definition Matrix.cc:40
Matrice avec stockage CSR.
MatrixImpl * m_impl
Implémentation.
static Matrix readHypre(const String &filename)
Lit la matrice au format Hypre.
Definition Matrix.cc:1135
void sortDiagonale()
Arrange le stockage pour que la diagonale soit le premier élément.
Definition Matrix.cc:180
IntegerConstArrayView rowsIndex() const
Indices des premiers éléments de chaque ligne.
Definition Matrix.cc:208
Real value(Integer row, Integer column) const
Retourne la valeur d'un élément de la matrice.
Definition Matrix.cc:235
void setRowsSize(IntegerConstArrayView rows_size)
Positionne le nombre d'éléments non nuls de chaque ligne.
Definition Matrix.cc:253
void setValues(IntegerConstArrayView columns, RealConstArrayView values)
Positionne les valeurs des éléments de la matrice.
Definition Matrix.cc:244
IntegerConstArrayView columns() const
Indices des colonnes des valeurs.
Definition Matrix.cc:298
void setValue(Integer row, Integer column, Real value)
Positionne la valeur d'un élément de la matrice.
Definition Matrix.cc:226
static Matrix read(const String &filename)
Lit la matrice au format X Y.
Definition Matrix.cc:1100
void dump(std::ostream &o) const
Imprime la matrice.
Definition Matrix.cc:217
RealConstArrayView values() const
Valeurs de la matrice.
Definition Matrix.cc:262
Matrix clone() const
Clone la matrice.
Definition Matrix.cc:198
Vecteur d'algèbre linéraire.
Chaîne de caractères unicode.
Int32 Integer
Type représentant un entier.
ArrayView< Integer > IntegerArrayView
Equivalent C d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:544
double Real
Type représentant un réel.
ConstArrayView< Integer > IntegerConstArrayView
Equivalent C d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:573
ArrayView< Real > RealArrayView
Equivalent C d'un tableau à une dimension de réels.
Definition UtilsTypes.h:546
ConstArrayView< Real > RealConstArrayView
Equivalent C d'un tableau à une dimension de réels.
Definition UtilsTypes.h:575