Dune Core Modules (2.8.0)

supermatrix.hh
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2// vi: set et ts=4 sw=2 sts=2:
3#ifndef DUNE_ISTL_SUPERMATRIX_HH
4#define DUNE_ISTL_SUPERMATRIX_HH
5
6#if HAVE_SUPERLU
7
8#include "bcrsmatrix.hh"
9#include "bvector.hh"
13#include <limits>
14
15#include <dune/istl/bccsmatrixinitializer.hh>
16
17#include "superlufunctions.hh"
18
19namespace Dune
20{
21
22 template<class T>
23 struct SuperMatrixCreateSparseChooser
24 {};
25
26 template<class T>
27 struct SuperMatrixPrinter
28 {};
29
30#if __has_include("slu_sdefs.h")
31 template<>
32 struct SuperMatrixCreateSparseChooser<float>
33 {
34 static void create(SuperMatrix *mat, int n, int m, int offset,
35 float *values, int *rowindex, int* colindex,
36 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
37 {
38 sCreate_CompCol_Matrix(mat, n, m, offset, values, rowindex, colindex,
39 stype, dtype, mtype);
40 }
41 };
42
43 template<>
44 struct SuperMatrixPrinter<float>
45 {
46 static void print(char* name, SuperMatrix* mat)
47 {
48 sPrint_CompCol_Matrix(name, mat);
49 }
50 };
51#endif
52
53#if __has_include("slu_ddefs.h")
54 template<>
55 struct SuperMatrixCreateSparseChooser<double>
56 {
57 static void create(SuperMatrix *mat, int n, int m, int offset,
58 double *values, int *rowindex, int* colindex,
59 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
60 {
61 dCreate_CompCol_Matrix(mat, n, m, offset, values, rowindex, colindex,
62 stype, dtype, mtype);
63 }
64 };
65
66 template<>
67 struct SuperMatrixPrinter<double>
68 {
69 static void print(char* name, SuperMatrix* mat)
70 {
71 dPrint_CompCol_Matrix(name, mat);
72 }
73 };
74#endif
75
76#if __has_include("slu_cdefs.h")
77 template<>
78 struct SuperMatrixCreateSparseChooser<std::complex<float> >
79 {
80 static void create(SuperMatrix *mat, int n, int m, int offset,
81 std::complex<float> *values, int *rowindex, int* colindex,
82 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
83 {
84 cCreate_CompCol_Matrix(mat, n, m, offset, reinterpret_cast< ::complex*>(values),
85 rowindex, colindex, stype, dtype, mtype);
86 }
87 };
88
89 template<>
90 struct SuperMatrixPrinter<std::complex<float> >
91 {
92 static void print(char* name, SuperMatrix* mat)
93 {
94 cPrint_CompCol_Matrix(name, mat);
95 }
96 };
97#endif
98
99#if __has_include("slu_zdefs.h")
100 template<>
101 struct SuperMatrixCreateSparseChooser<std::complex<double> >
102 {
103 static void create(SuperMatrix *mat, int n, int m, int offset,
104 std::complex<double> *values, int *rowindex, int* colindex,
105 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
106 {
107 zCreate_CompCol_Matrix(mat, n, m, offset, reinterpret_cast<doublecomplex*>(values),
108 rowindex, colindex, stype, dtype, mtype);
109 }
110 };
111
112 template<>
113 struct SuperMatrixPrinter<std::complex<double> >
114 {
115 static void print(char* name, SuperMatrix* mat)
116 {
117 zPrint_CompCol_Matrix(name, mat);
118 }
119 };
120#endif
121
122 template<class T>
123 struct BaseGetSuperLUType
124 {
125 static const Dtype_t type;
126 };
127
128 template<class T>
129 struct GetSuperLUType
130 {};
131
132 template<class T>
133 const Dtype_t BaseGetSuperLUType<T>::type =
134 std::is_same<T,float>::value ? SLU_S :
135 ( std::is_same<T,std::complex<double> >::value ? SLU_Z :
136 ( std::is_same<T,std::complex<float> >::value ? SLU_C : SLU_D ));
137
138 template<>
139 struct GetSuperLUType<double>
140 : public BaseGetSuperLUType<double>
141 {
142 typedef double float_type;
143 };
144
145 template<>
146 struct GetSuperLUType<float>
147 : public BaseGetSuperLUType<float>
148 {
149 typedef float float_type;
150 };
151
152 template<>
153 struct GetSuperLUType<std::complex<double> >
154 : public BaseGetSuperLUType<std::complex<double> >
155 {
156 typedef double float_type;
157 };
158
159 template<>
160 struct GetSuperLUType<std::complex<float> >
161 : public BaseGetSuperLUType<std::complex<float> >
162 {
163 typedef float float_type;
164
165 };
166
171 template<class M>
173 {};
174
175 template<class M>
176 struct SuperMatrixInitializer
177 {};
178
179 template<class T>
180 class SuperLU;
181
182 template<class M, class X, class TM, class TD, class T1>
183 class SeqOverlappingSchwarz;
184
185 template<class T, bool flag>
186 struct SeqOverlappingSchwarzAssemblerHelper;
187
191 template<class B, class TA>
193 : public ISTL::Impl::BCCSMatrix<typename BCRSMatrix<B,TA>::field_type, int>
194 {
195 template<class M, class X, class TM, class TD, class T1>
196 friend class SeqOverlappingSchwarz;
197 friend struct SuperMatrixInitializer<BCRSMatrix<B,TA> >;
198 public:
201
202 friend struct SeqOverlappingSchwarzAssemblerHelper<SuperLU<Matrix>, true>;
203
204 typedef typename Matrix::size_type size_type;
205
210 explicit SuperLUMatrix(const Matrix& mat) : ISTL::Impl::BCCSMatrix<BCRSMatrix<B,TA>, int>(mat)
211 {}
212
213 SuperLUMatrix() : ISTL::Impl::BCCSMatrix<typename BCRSMatrix<B,TA>::field_type, int>()
214 {}
215
218 {
219 if (this->N_+this->M_*this->Nnz_ != 0)
220 free();
221 }
222
224 operator SuperMatrix&()
225 {
226 return A;
227 }
228
230 operator const SuperMatrix&() const
231 {
232 return A;
233 }
234
235 SuperLUMatrix<BCRSMatrix<B,TA> >& operator=(const BCRSMatrix<B,TA>& mat)
236 {
237 if (this->N_ + this->M_ + this->Nnz_!=0)
238 free();
239
240 using Matrix = BCRSMatrix<B,TA>;
241 this->N_ = MatrixDimension<Matrix>::rowdim(mat);
242 this->M_ = MatrixDimension<Matrix>::coldim(mat);
243 ISTL::Impl::BCCSMatrixInitializer<Matrix, int> initializer(*this);
244
245 copyToBCCSMatrix(initializer, mat);
246
247 SuperMatrixCreateSparseChooser<typename Matrix::field_type>
248 ::create(&A, this->N_, this->M_, this->colstart[this->N_],
249 this->values,this->rowindex, this->colstart, SLU_NC,
250 static_cast<Dtype_t>(GetSuperLUType<typename Matrix::field_type>::type), SLU_GE);
251 return *this;
252 }
253
254 SuperLUMatrix<BCRSMatrix<B,TA> >& operator=(const SuperLUMatrix <BCRSMatrix<B,TA> >& mat)
255 {
256 if (this->N_ + this->M_ + this->Nnz_!=0)
257 free();
258
259 using Matrix = BCRSMatrix<B,TA>;
260 this->N_ = MatrixDimension<Matrix>::rowdim(mat);
261 this->M_ = MatrixDimension<Matrix>::coldim(mat);
262 ISTL::Impl::BCCSMatrixInitializer<Matrix, int> initializer(*this);
263
264 copyToBCCSMatrix(initializer, mat);
265
266 SuperMatrixCreateSparseChooser<B>
267 ::create(&A, this->N_, this->M_, this->colstart[this->N_],
268 this->values,this->rowindex, this->colstart, SLU_NC,
269 static_cast<Dtype_t>(GetSuperLUType<B>::type), SLU_GE);
270 return *this;
271 }
272
279 virtual void setMatrix(const Matrix& mat, const std::set<std::size_t>& mrs)
280 {
281 if(this->N_+this->M_+this->Nnz_!=0)
282 free();
283 this->N_=mrs.size()*MatrixDimension<typename Matrix::block_type>::rowdim(*(mat[0].begin()));
284 this->M_=mrs.size()*MatrixDimension<typename Matrix::block_type>::coldim(*(mat[0].begin()));
285 SuperMatrixInitializer<Matrix> initializer(*this);
286
287 copyToBCCSMatrix(initializer, ISTL::Impl::MatrixRowSubset<Matrix,std::set<std::size_t> >(mat,mrs));
288 }
289
291 virtual void setMatrix(const Matrix& mat)
292 {
293 this->N_=MatrixDimension<Matrix>::rowdim(mat);
294 this->M_=MatrixDimension<Matrix>::coldim(mat);
295 SuperMatrixInitializer<Matrix> initializer(*this);
296
297 copyToBCCSMatrix(initializer, mat);
298 }
299
301 virtual void free()
302 {
303 ISTL::Impl::BCCSMatrix<typename BCRSMatrix<B,TA>::field_type, int>::free();
304 SUPERLU_FREE(A.Store);
305 }
306 private:
307 SuperMatrix A;
308 };
309
310 template<class B, class A>
311 class SuperMatrixInitializer<BCRSMatrix<B,A> >
312 : public ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<B,A>, int>
313 {
314 template<class I, class S, class D>
315 friend class OverlappingSchwarzInitializer;
316 public:
317 typedef BCRSMatrix<B,A> Matrix;
318 typedef Dune::SuperLUMatrix<Matrix> SuperLUMatrix;
319
320 SuperMatrixInitializer(SuperLUMatrix& lum) : ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<B,A>, int>(lum)
321 ,slumat(&lum)
322 {}
323
324 SuperMatrixInitializer() : ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<B,A>, int>()
325 {}
326
327 virtual void createMatrix() const
328 {
329 ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<B,A>, int>::createMatrix();
330 SuperMatrixCreateSparseChooser<typename Matrix::field_type>
331 ::create(&slumat->A, slumat->N_, slumat->M_, slumat->colstart[this->cols],
332 slumat->values,slumat->rowindex, slumat->colstart, SLU_NC,
333 static_cast<Dtype_t>(GetSuperLUType<typename Matrix::field_type>::type), SLU_GE);
334 }
335 private:
336 SuperLUMatrix* slumat;
337 };
338}
339#endif // HAVE_SUPERLU
340#endif
Implementation of the BCRSMatrix class.
This file implements a vector space as a tensor product of a given vector space. The number of compon...
A sparse block matrix with compressed row storage.
Definition: bcrsmatrix.hh:464
A::size_type size_type
The type for the index access and the size.
Definition: bcrsmatrix.hh:498
A generic dynamic dense matrix.
Definition: matrix.hh:559
Sequential overlapping Schwarz preconditioner.
Definition: overlappingschwarz.hh:753
virtual void free()
free allocated space.
Definition: supermatrix.hh:301
SuperLUMatrix(const Matrix &mat)
Constructor that initializes the data.
Definition: supermatrix.hh:210
virtual void setMatrix(const Matrix &mat)
Initialize data from given matrix.
Definition: supermatrix.hh:291
BCRSMatrix< B, TA > Matrix
The type of the matrix to convert.
Definition: supermatrix.hh:200
virtual void setMatrix(const Matrix &mat, const std::set< std::size_t > &mrs)
Initialize data from a given set of matrix rows and columns.
Definition: supermatrix.hh:279
virtual ~SuperLUMatrix()
Destructor.
Definition: supermatrix.hh:217
SuperLu Solver.
Definition: superlu.hh:269
Traits for type conversions and type information.
Implements a matrix constructed from a given type representing a field and compile-time given number ...
Implements a vector constructed from a given type representing a field and a compile-time given size.
Dune namespace.
Definition: alignedallocator.hh:11
STL namespace.
Utility class for converting an ISTL Matrix into a SuperLU Matrix.
Definition: supermatrix.hh:173
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Nov 12, 23:30, 2024)