v0.13.1
Loading...
Searching...
No Matches
MatrixManager.hpp
Go to the documentation of this file.
1/** \file MatrixManager.hpp
2 * \brief Interface for creating matrices and managing matrices
3 * \ingroup mofem_mat_interface
4 *
5 * Creating and managing matrices
6 *
7 */
8
9#ifndef __MATMANAGER_HPP__
10#define __MATMANAGER_HPP__
11
12#include "UnknownInterface.hpp"
13
14namespace MoFEM {
15
16/**
17 * \brief Matrix manager is used to build and partition problems
18 * \ingroup mofem_mat_interface
19 *
20 */
22
23 MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
24 UnknownInterface **iface) const;
25
27 MatrixManager(const MoFEM::Core &core);
28
29 /**
30 * \brief Destructor
31 */
32 virtual ~MatrixManager() = default;
33
34 /**
35 * @brief Creates a MPI AIJ matrix using arrays that contain in standard CSR
36 * format the local rows.
37 *
38 * <a
39 href=https://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Mat/MatCreateMPIAIJWithArrays.html>See
40 PETSc for details</a>
41
42 * @tparam Tag
43 * @param name
44 * @param Aij
45 * @param verb
46 * @return MoFEMErrorCode
47 */
48 template <class Tag>
49 MoFEMErrorCode createMPIAIJWithArrays(const std::string name, Mat *Aij,
50 int verb = QUIET) {
51 static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
52 return 0;
53 }
54
55 /** \copydoc MoFEM::MatrixManager::createMPIAIJWithArrays
56 */
57 template <class Tag>
58 MoFEMErrorCode createMPIAIJWithArrays(const std::string name,
59 SmartPetscObj<Mat> &aij_ptr,
60 int verb = QUIET) {
62 Mat aij;
63 CHKERR createMPIAIJWithArrays<Tag>(name, &aij, verb);
64 aij_ptr.reset(aij, false);
66 }
67
68 template <class Tag>
70 Mat *Aij, int verb = QUIET) {
71 static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
72 return 0;
73 }
74
75 /** \copydoc MoFEM::MatrixManager::createMPIAIJCUSPARSEWithArrays
76 */
77 template <class Tag>
79 SmartPetscObj<Mat> &aij_ptr,
80 int verb = QUIET) {
82 Mat aij;
83 CHKERR createMPIAIJCUSPARSEWithArrays<Tag>(name, &aij, verb);
84 aij_ptr.reset(aij, false);
86 }
87
88 template <class Tag>
90 Mat *Aij, int verb = QUIET) {
91 static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
92 return 0;
93 }
94
95 /** \copydoc MoFEM::MatrixManager::createSeqAIJCUSPARSEWithArrays
96 */
97 template <class Tag>
99 SmartPetscObj<Mat> &aij_ptr,
100 int verb = QUIET) {
102 Mat aij;
103 CHKERR createSeqAIJCUSPARSEWithArrays<Tag>(name, &aij, verb);
104 aij_ptr.reset(aij, false);
106 }
107
108 /**
109 * @brief Creates a MPI AIJ matrix using arrays that contain in standard CSR
110 * format the local rows.
111 *
112 * <a
113 href=https://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Mat/MATMPIAIJ.html>See
114 PETSc for details</a>
115
116 * @tparam Tag
117 * @param name
118 * @param Aij
119 * @param verb
120 * @return MoFEMErrorCode
121 */
122 template <class Tag>
123 MoFEMErrorCode createMPIAIJ(const std::string name, Mat *Aij,
124 int verb = QUIET) {
125 static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
126 return 0;
127 }
128
129 /** \copydoc MoFEM::MatrixManager::createMPIAIJ
130 */
131 template <class Tag>
132 MoFEMErrorCode createMPIAIJ(const std::string name,
133 SmartPetscObj<Mat> &aij_ptr,
134 int verb = QUIET) {
136 Mat aij;
137 CHKERR createMPIAIJ<Tag>(name, &aij, verb);
138 aij_ptr.reset(aij, false);
140 }
141
142 /**
143 * @brief Creates a sparse matrix representing an adjacency list.
144 *
145 * The matrix
146 * does not have numerical values associated with it, but is intended for
147 * ordering (to reduce bandwidth etc) and partitioning.
148 *
149 * <a
150 * href=https://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Mat/MatCreateMPIAdj.html>See
151 * PETSc for details</a>
152 *
153 * \note This matrix object does not support most matrix operations, include
154 * MatSetValues(). You must NOT free the ii, values and jj arrays yourself.
155 * PETSc will free them when the matrix is destroyed; you must allocate them
156 * with PetscMalloc(). If you call from Fortran you need not create the arrays
157 * with PetscMalloc(). Should not include the matrix diagonals.
158 *
159 * @tparam Tag
160 * @param name
161 * @param Adj
162 * @param verb
163 * @return MoFEMErrorCode
164 */
165 template <class Tag>
166 MoFEMErrorCode createMPIAdjWithArrays(const std::string name, Mat *Adj,
167 int verb = QUIET) {
168 static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
170 }
171
172 /**
173 * @brief Create sequencial matrix
174 *
175 * Creates a sparse matrix in AIJ (compressed row) format (the default
176 * parallel PETSc format). For good matrix assembly performance the user
177 * should preallocate the matrix storage by setting the parameter nz (or the
178 * array nnz). By setting these parameters accurately, performance during
179 * matrix assembly can be increased by more than a factor of 50.
180 *
181 * <a
182 * href=https://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Mat/MatCreateSeqAIJ.html>See
183 * PETSc for details</a>
184 *
185 * @tparam Tag
186 * @param name
187 * @param Aij
188 * @param i
189 * @param j
190 * @param v
191 * @param verb
192 * @return MoFEMErrorCode
193 */
194 template <class Tag>
195 MoFEMErrorCode createSeqAIJWithArrays(const std::string name, Mat *Aij,
196 int verb = QUIET) {
197 static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
198 return 0;
199 }
200
201 /**
202 * @brief Create sequencial matrix
203 *
204 * Creates a sparse matrix in AIJ (compressed row) format (the default
205 * parallel PETSc format). For good matrix assembly performance the user
206 * should preallocate the matrix storage by setting the parameter nz (or the
207 * array nnz). By setting these parameters accurately, performance during
208 * matrix assembly can be increased by more than a factor of 50.
209 *
210 * <a
211 * href=https://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Mat/MatCreateSeqAIJ.html>See
212 * PETSc for details</a>
213 *
214 * @tparam Tag
215 * @param name
216 * @param Aij (SmartPetscObj)
217 * @param i
218 * @param j
219 * @param v
220 * @param verb
221 * @return MoFEMErrorCode
222 */
223 template <class Tag>
225 SmartPetscObj<Mat> &aij_ptr,
226 int verb = QUIET) {
228 Mat aij;
229 CHKERR createSeqAIJWithArrays<Tag>(name, &aij, verb);
230 aij_ptr.reset(aij, false);
232 }
233
234 /** \brief check if matrix fill in correspond to finite element indices
235
236 This is used to check consistency of code. If problem is notices with
237 additional non-zero elements in matrix, this function can help detect
238 problem. Should be used as a part of atom tests
239
240 * @param problem_name
241 * @param row print info at particular row
242 * @param col print info at particular col
243 * @return MoFEMErrorCode
244
245 */
246 MoFEMErrorCode checkMatrixFillIn(const std::string problem_name,
247 int row_print, int col_print, Mat A,
248 int verb = QUIET);
249
250 /** \brief check if matrix fill in correspond to finite element indices
251
252 This is used to check consistency of code. If problem is notices with
253 additional non-zero elements in matrix, this function can help detect
254 problem. Should be used as a part of atom tests
255
256 * @tparam Tag
257 * @param problem_name
258 * @param row print info at particular row
259 * @param col print info at particular col
260 * @return MoFEMErrorCode
261
262 */
263 template <class Tag>
265 checkMPIAIJWithArraysMatrixFillIn(const std::string problem_name,
266 int row_print, int col_print,
267 int verb = QUIET) {
268 static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
269 return 0;
270 }
271
272 /** \brief check if matrix fill in correspond to finite element indices
273
274 This is used to check consistency of code. If problem is notices with
275 additional non-zero elements in matrix, this function can help detect
276 problem. Should be used as a part of atom tests
277
278 * @tparam Tag
279 * @param problem_name
280 * @param row print info at particular row
281 * @param col print info at particular col
282 * @return MoFEMErrorCode
283
284 */
285 template <class Tag>
286 MoFEMErrorCode checkMPIAIJMatrixFillIn(const std::string problem_name,
287 int row_print, int col_print,
288 int verb = QUIET) {
289 static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
290 return 0;
291 }
292
293private:
301};
302
303template <>
304MoFEMErrorCode MatrixManager::createMPIAIJWithArrays<PetscGlobalIdx_mi_tag>(
305 const std::string name, Mat *Aij, int verb);
306
307template <>
309MatrixManager::createMPIAIJCUSPARSEWithArrays<PetscGlobalIdx_mi_tag>(
310 const std::string name, Mat *Aij, int verb);
311
312template <>
314MatrixManager::createMPIAIJ<PetscGlobalIdx_mi_tag>(const std::string name,
315 Mat *Aij, int verb);
316
317template <>
319MatrixManager::createMPIAdjWithArrays<Idx_mi_tag>(const std::string name,
320 Mat *Adj, int verb);
321
322template <>
323MoFEMErrorCode MatrixManager::createSeqAIJWithArrays<PetscLocalIdx_mi_tag>(
324 const std::string name, Mat *Aij, int verb);
325
326template <>
328MatrixManager::createSeqAIJCUSPARSEWithArrays<PetscLocalIdx_mi_tag>(
329 const std::string name, Mat *Aij, int verb);
330
331template <>
333MatrixManager::checkMPIAIJWithArraysMatrixFillIn<PetscGlobalIdx_mi_tag>(
334 const std::string problem_name, int row_print, int col_print, int verb);
335
336template <>
337MoFEMErrorCode MatrixManager::checkMPIAIJMatrixFillIn<PetscGlobalIdx_mi_tag>(
338 const std::string problem_name, int row_print, int col_print, int verb);
339
340} // namespace MoFEM
341
342#endif // __MATMANAGER_HPP__a
343
344/**
345 * \defgroup mofem_mat_interface Matrix Manager
346 * \brief Creating and managing matrices
347 *
348 * \ingroup mofem
349 */
MoFEM interface.
@ QUIET
Definition: definitions.h:208
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
@ MOFEM_NOT_IMPLEMENTED
Definition: definitions.h:32
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
#define CHKERR
Inline error check.
Definition: definitions.h:535
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
constexpr AssemblyType A
Definition: plastic.cpp:35
Core (interface) class.
Definition: Core.hpp:82
Matrix manager is used to build and partition problems.
MoFEMErrorCode query_interface(boost::typeindex::type_index type_index, UnknownInterface **iface) const
PetscLogEvent MOFEM_EVENT_createSeqAIJCUSPARSEWithArrays
MoFEMErrorCode createMPIAIJCUSPARSEWithArrays(const std::string name, Mat *Aij, int verb=QUIET)
MoFEMErrorCode createMPIAdjWithArrays(const std::string name, Mat *Adj, int verb=QUIET)
Creates a sparse matrix representing an adjacency list.
MoFEMErrorCode createMPIAIJ(const std::string name, Mat *Aij, int verb=QUIET)
Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.
MoFEMErrorCode createSeqAIJCUSPARSEWithArrays(const std::string name, Mat *Aij, int verb=QUIET)
PetscLogEvent MOFEM_EVENT_createMPIAdjWithArrays
virtual ~MatrixManager()=default
Destructor.
PetscLogEvent MOFEM_EVENT_checkMatrixFillIn
PetscLogEvent MOFEM_EVENT_createMPIAIJ
MoFEMErrorCode createMPIAIJWithArrays(const std::string name, Mat *Aij, int verb=QUIET)
Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.
PetscLogEvent MOFEM_EVENT_createMPIAIJWithArrays
MoFEMErrorCode checkMatrixFillIn(const std::string problem_name, int row_print, int col_print, Mat A, int verb=QUIET)
check if matrix fill in correspond to finite element indices
MoFEMErrorCode createMPIAIJ(const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.
PetscLogEvent MOFEM_EVENT_createSeqAIJWithArrays
MoFEMErrorCode createSeqAIJWithArrays(const std::string name, Mat *Aij, int verb=QUIET)
Create sequencial matrix.
MoFEMErrorCode createSeqAIJCUSPARSEWithArrays(const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
MoFEMErrorCode checkMPIAIJMatrixFillIn(const std::string problem_name, int row_print, int col_print, int verb=QUIET)
check if matrix fill in correspond to finite element indices
MoFEMErrorCode createMPIAIJWithArrays(const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.
MoFEMErrorCode createSeqAIJWithArrays(const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
Create sequencial matrix.
PetscLogEvent MOFEM_EVENT_createMPIAIJCUSPARSEWithArrays
MoFEMErrorCode checkMPIAIJWithArraysMatrixFillIn(const std::string problem_name, int row_print, int col_print, int verb=QUIET)
check if matrix fill in correspond to finite element indices
MoFEMErrorCode createMPIAIJCUSPARSEWithArrays(const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
intrusive_ptr for managing petsc objects
base class for all interface classes