Alien  1.3.0
Developer documentation
Loading...
Searching...
No Matches
SystemWriter.cc
1/*
2 * Copyright 2020 IFPEN-CEA
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 * SPDX-License-Identifier: Apache-2.0
17 */
18
19/*
20 * MatrixWriter.cpp
21 *
22 * Created on: Apr 7, 2015
23 * Author: gratienj
24 */
25
26#include <alien/ref/import_export/SystemWriter.h>
27
28#include <sstream>
29#include <string>
30#include <vector>
31
32#ifdef ALIEN_USE_HDF5
33#include <hdf5.h>
34#endif
35
36#ifdef ALIEN_USE_LIBXML2
37#include <libxml/parser.h>
38#include <libxml/xmlmemory.h>
39#endif
40
41#include <alien/kernels/simple_csr/SimpleCSRMatrix.h>
42#include <alien/kernels/simple_csr/SimpleCSRVector.h>
43
44#include <alien/core/impl/MultiVectorImpl.h>
45
46#include "HDF5Tools.h"
47#include <alien/ref/data/block/BlockMatrix.h>
48#include <alien/ref/data/block/BlockVector.h>
49#include <alien/ref/data/scalar/Matrix.h>
50#include <alien/ref/data/scalar/Vector.h>
51#include <alien/ref/import_export/SystemInfo.h>
52#include <alien/ref/import_export/SystemReader.h>
53
54namespace Alien
55{
56
57SystemWriter::SystemWriter(
58std::string const& filename, std::string format, IMessagePassingMng* parallel_mng)
59: m_filename(filename)
60, m_format(format)
61, m_prec(6)
62, m_parallel_mng(parallel_mng)
63{
64 m_rank = 0;
65 m_nproc = 1;
66 if (m_parallel_mng) {
67 m_rank = m_parallel_mng->commRank();
68 m_nproc = m_parallel_mng->commSize();
69 std::stringstream suf;
70 suf << "-R" << m_rank << "P" << m_nproc;
71 m_filename = filename + suf.str();
72 }
73 else {
74 m_filename = filename;
75 }
76
77 // N2_ABS_RES = ||Ax-b||2
78 // N2_RELATIVE2RHS_RES = ||Ax-b||2 / ||b||2
79 // N2_RELATIVE2X0_RES = ||Ax-b||2 / ||x0||2
80 m_conv_crit_to_str[SolutionInfo::N2_ABS_RES] = std::string("||Ax-b||2");
81 m_conv_crit_to_str[SolutionInfo::N2_RELATIVE2RHS_RES] =
82 std::string("||Ax-b||2 / ||b||2");
83 m_conv_crit_to_str[SolutionInfo::N2_RELATIVE2X0_RES] =
84 std::string("||Ax-b||2 / ||x0||2");
85}
86
87SystemWriter::~SystemWriter() {}
88
89template <typename FileNodeT>
90void SystemWriter::_writeMatrixInfo(Exporter& exporter, FileNodeT& parent_node, int nrows,
91 int ncols, int nnz, int blk_size, int blk_size2)
92{
93 FileNodeT matrix_info_node = exporter.createFileNode(parent_node, "matrix-info");
94
95 exporter.write(matrix_info_node, "nrows", nrows);
96 exporter.write(matrix_info_node, "ncols", ncols);
97 exporter.write(matrix_info_node, "nnz", nnz);
98 {
99 std::vector<int>& i32buffer = exporter.i32buffer;
100 i32buffer.reserve(2);
101 i32buffer.push_back(blk_size);
102 i32buffer.push_back(blk_size2);
103 exporter.write(matrix_info_node, "blk-size", i32buffer);
104 }
105
106 exporter.closeFileNode(matrix_info_node);
107}
108
109template <typename FileNodeT>
110void SystemWriter::_writeCSRProfile(Exporter& exporter, FileNodeT& parent_node, int nrows,
111 int nnz, int const* kcol, int const* cols)
112{
113 std::vector<int>& i32buffer = exporter.i32buffer;
114 FileNodeT profile_node = exporter.createFileNode(parent_node, "profile");
115 exporter.write(profile_node, "profile-type", std::string("CSR"));
116
117 exporter.write(profile_node, "nrows", nrows);
118 exporter.write(profile_node, "nnz", nnz);
119
120 {
121 i32buffer.reserve(nrows + 1);
122 for (Integer i = 0; i < nrows + 1; ++i)
123 i32buffer.push_back(kcol[i]);
124 exporter.write(profile_node, "kcol", i32buffer);
125 }
126 {
127 i32buffer.reserve(nnz);
128 for (Integer i = 0; i < nnz; ++i)
129 i32buffer.push_back(cols[i]);
130 exporter.write(profile_node, "cols", i32buffer);
131 }
132 exporter.closeFileNode(profile_node);
133}
134
135template <typename FileNodeT>
136void SystemWriter::_writeMatrixValues(Exporter& exporter, FileNodeT& parent_node, int nnz,
137 int blk_size, int blk_size2, double const* values)
138{
139 std::vector<double>& rbuffer = exporter.rbuffer;
140 std::vector<int>& i32buffer = exporter.i32buffer;
141 FileNodeT data_node = exporter.createFileNode(parent_node, "data");
142 {
143 {
144 FileNodeT info_node = exporter.createFileNode(data_node, "struct-info");
145
146 exporter.write(info_node, "size", nnz);
147
148 {
149 i32buffer.reserve(2);
150 i32buffer.push_back(blk_size);
151 i32buffer.push_back(blk_size2);
152 exporter.write(info_node, "blk-size", i32buffer);
153 }
154 exporter.closeFileNode(info_node);
155 }
156 rbuffer.reserve(nnz * blk_size * blk_size2);
157 for (Integer i = 0; i < nnz * blk_size * blk_size2; ++i)
158 rbuffer.push_back(values[i]);
159 exporter.write(data_node, "values", rbuffer);
160 }
161 exporter.closeFileNode(data_node);
162}
163
164template <typename FileNodeT>
165void SystemWriter::_writeVector(Exporter& exporter, FileNodeT& parent_node, int nrows,
166 int blk_size, double const* values)
167{
168 std::vector<double>& rbuffer = exporter.rbuffer;
169 FileNodeT data_node = exporter.createFileNode(parent_node, "data");
170 {
171 FileNodeT info_node = exporter.createFileNode(data_node, "struct-info");
172
173 exporter.write(info_node, "size", nrows);
174 exporter.write(info_node, "blk-size", blk_size);
175
176 exporter.closeFileNode(info_node);
177 }
178 {
179 rbuffer.reserve(nrows * blk_size);
180 for (Integer i = 0; i < nrows * blk_size; ++i)
181 rbuffer.push_back(values[i]);
182 exporter.write(data_node, "values", rbuffer);
183 }
184 exporter.closeFileNode(data_node);
185}
186
187template <typename FileNodeT>
188void SystemWriter::_writeSolutionInfo(
189Exporter& exporter, FileNodeT& parent_node, const SolutionInfo& sol_info)
190{
191
192 FileNodeT solution_info_node = exporter.createFileNode(parent_node, "solution_info");
193
194 exporter.write(parent_node, "conv-crit", m_conv_crit_to_str[sol_info.m_conv_crit]);
195 exporter.write(parent_node, "conv-crit-value", sol_info.m_conv_crit_value);
196 exporter.write(parent_node, "solver-comment", sol_info.m_solver_comment);
197
198 exporter.closeFileNode(solution_info_node);
199}
200
201template <typename FileNodeT>
202void SystemWriter::_beginDump(Exporter*& exporter, FileNodeT& base_node)
203{
204 exporter = new Exporter(m_filename, m_format, m_prec);
205 base_node = exporter->createFileNode("system");
206}
207
208template <typename FileNodeT>
209void SystemWriter::_endDump(Exporter* exporter, FileNodeT& base_node)
210{
211 exporter->closeFileNode(base_node);
212 delete exporter;
213}
214
215void SystemWriter::dump(Matrix const& A)
216{
217 const SimpleCSRMatrix<Real>& csr = A.impl()->get<BackEnd::tag::simplecsr>();
218 const SimpleCSRMatrix<Real>::ProfileType& profile = csr.getProfile();
219 int nrows = profile.getNRows();
220 int blk_size = 1;
221 int nnz = profile.getNnz();
222 typedef Exporter::FileNode FileNode;
223 Exporter* exporter;
224 FileNode root_node;
225
226 _beginDump(exporter, root_node);
227
228 FileNode matrix_node = exporter->createFileNode(root_node, "matrix");
229 {
230 _writeMatrixInfo(*exporter, matrix_node, nrows, nrows, nnz, blk_size, blk_size);
231
232 const int* cols = profile.cols();
233 const int* kcol = profile.kcol();
234 _writeCSRProfile(*exporter, matrix_node, nrows, nnz, kcol, cols);
235
236 const double* values = csr.getAddressData();
237 _writeMatrixValues(*exporter, matrix_node, nnz, blk_size, blk_size, values);
238 }
239 exporter->closeFileNode(matrix_node);
240
241 _endDump(exporter, root_node);
242}
243
244void SystemWriter::dump(Matrix const& A, Vector const& rhs)
245{
246 // A is supposed to be square
247
248 const SimpleCSRMatrix<Real>& csr = A.impl()->get<BackEnd::tag::simplecsr>();
249 const SimpleCSRMatrix<Real>::ProfileType& profile = csr.getProfile();
250 int nrows = profile.getNRows();
251 int blk_size = 1;
252 int nnz = profile.getNnz();
253 typedef Exporter::FileNode FileNode;
254 Exporter* exporter;
255 FileNode root_node;
256
257 _beginDump(exporter, root_node);
258
259 FileNode matrix_node = exporter->createFileNode(root_node, "matrix");
260 {
261 _writeMatrixInfo(*exporter, matrix_node, nrows, nrows, nnz, blk_size, blk_size);
262
263 const int* cols = profile.cols();
264 const int* kcol = profile.kcol();
265 _writeCSRProfile(*exporter, matrix_node, nrows, nnz, kcol, cols);
266
267 const double* values = csr.getAddressData();
268 _writeMatrixValues(*exporter, matrix_node, nnz, blk_size, blk_size, values);
269 }
270 exporter->closeFileNode(matrix_node);
271
272 FileNode vector_node = exporter->createFileNode(root_node, "rhs-0");
273 {
274 const SimpleCSRVector<Real>& v = rhs.impl()->get<BackEnd::tag::simplecsr>();
275 const double* values = v.getAddressData();
276 _writeVector(*exporter, vector_node, nrows, blk_size, values);
277 }
278 exporter->closeFileNode(vector_node);
279
280 _endDump(exporter, root_node);
281}
282
283void SystemWriter::dump(
284Matrix const& A, Vector const& rhs, Vector const& sol, SolutionInfo const& sol_info)
285{
286 const SimpleCSRMatrix<Real>& csr = A.impl()->get<BackEnd::tag::simplecsr>();
287 const SimpleCSRMatrix<Real>::ProfileType& profile = csr.getProfile();
288 int nrows = profile.getNRows();
289 int blk_size = 1;
290 int nnz = profile.getNnz();
291 typedef Exporter::FileNode FileNode;
292 Exporter* exporter;
293 FileNode root_node;
294
295 _beginDump(exporter, root_node);
296
297 FileNode matrix_node = exporter->createFileNode(root_node, "matrix");
298 {
299 _writeMatrixInfo(*exporter, matrix_node, nrows, nrows, nnz, blk_size, blk_size);
300
301 const int* cols = profile.cols();
302 const int* kcol = profile.kcol();
303 _writeCSRProfile(*exporter, matrix_node, nrows, nnz, kcol, cols);
304
305 const double* values = csr.getAddressData();
306 _writeMatrixValues(*exporter, matrix_node, nnz, blk_size, blk_size, values);
307 }
308 exporter->closeFileNode(matrix_node);
309
310 FileNode rhs_node = exporter->createFileNode(root_node, "rhs-0");
311 {
312 const SimpleCSRVector<Real>& v = rhs.impl()->get<BackEnd::tag::simplecsr>();
313 const double* values = v.getAddressData();
314 _writeVector(*exporter, rhs_node, nrows, blk_size, values);
315 }
316 exporter->closeFileNode(rhs_node);
317
318 FileNode solution_node = exporter->createFileNode(root_node, "solution-0");
319 {
320
321 _writeSolutionInfo(*exporter, solution_node, sol_info);
322
323 exporter->write(solution_node, "rhs-ref", std::string("rhs-0"));
324
325 FileNode solution_vector_node =
326 exporter->createFileNode(solution_node, "solution-vector");
327 const SimpleCSRVector<Real>& v = sol.impl()->get<BackEnd::tag::simplecsr>();
328 const double* values = v.getAddressData();
329 _writeVector(*exporter, solution_vector_node, nrows, blk_size, values);
330 exporter->closeFileNode(solution_vector_node);
331 }
332 exporter->closeFileNode(solution_node);
333
334 _endDump(exporter, root_node);
335}
336
337void SystemWriter::dump(BlockMatrix const& A, BlockVector const& rhs)
338{
339 const SimpleCSRMatrix<Real>& csr = A.impl()->get<BackEnd::tag::simplecsr>();
340 const SimpleCSRMatrix<Real>::ProfileType& profile = csr.getProfile();
341 int nrows = profile.getNRows();
342 int blk_size = A.block().size();
343 int nnz = profile.getNnz();
344 typedef Exporter::FileNode FileNode;
345 Exporter* exporter;
346 FileNode root_node;
347
348 _beginDump(exporter, root_node);
349
350 FileNode matrix_node = exporter->createFileNode(root_node, "matrix");
351 {
352 _writeMatrixInfo(*exporter, matrix_node, nrows, nrows, nnz, blk_size, blk_size);
353
354 const int* cols = profile.cols();
355 const int* kcol = profile.kcol();
356 _writeCSRProfile(*exporter, matrix_node, nrows, nnz, kcol, cols);
357
358 const double* values = csr.getAddressData();
359 _writeMatrixValues(*exporter, matrix_node, nnz, blk_size, blk_size, values);
360 }
361 exporter->closeFileNode(matrix_node);
362
363 FileNode vector_node = exporter->createFileNode(root_node, "rhs-0");
364 {
365 const SimpleCSRVector<Real>& v = rhs.impl()->get<BackEnd::tag::simplecsr>();
366 const double* values = v.getAddressData();
367 _writeVector(*exporter, vector_node, nrows, blk_size, values);
368 }
369 exporter->closeFileNode(vector_node);
370 _endDump(exporter, root_node);
371}
372
373void SystemWriter::dump(BlockMatrix const& A, BlockVector const& rhs, BlockVector const& sol,
374 SolutionInfo const& sol_info)
375{
376 const SimpleCSRMatrix<Real>& csr = A.impl()->get<BackEnd::tag::simplecsr>();
377 const SimpleCSRMatrix<Real>::ProfileType& profile = csr.getProfile();
378 int nrows = profile.getNRows();
379 int blk_size = A.block().size();
380 int nnz = profile.getNnz();
381 typedef Exporter::FileNode FileNode;
382 Exporter* exporter;
383 FileNode root_node;
384
385 _beginDump(exporter, root_node);
386
387 FileNode matrix_node = exporter->createFileNode(root_node, "matrix");
388 {
389 _writeMatrixInfo(*exporter, matrix_node, nrows, nrows, nnz, blk_size, blk_size);
390
391 const int* cols = profile.cols();
392 const int* kcol = profile.kcol();
393 _writeCSRProfile(*exporter, matrix_node, nrows, nnz, kcol, cols);
394
395 const double* values = csr.getAddressData();
396 _writeMatrixValues(*exporter, matrix_node, nnz, blk_size, blk_size, values);
397 }
398 exporter->closeFileNode(matrix_node);
399
400 FileNode rhs_node = exporter->createFileNode(root_node, "rhs-0");
401 {
402 const SimpleCSRVector<Real>& v = rhs.impl()->get<BackEnd::tag::simplecsr>();
403 const double* values = v.getAddressData();
404 _writeVector(*exporter, rhs_node, nrows, blk_size, values);
405 }
406
407 exporter->closeFileNode(rhs_node);
408
409 FileNode sol_node = exporter->createFileNode(root_node, "sol");
410 {
411 const SimpleCSRVector<Real>& v = sol.impl()->get<BackEnd::tag::simplecsr>();
412 const double* values = v.getAddressData();
413 _writeVector(*exporter, sol_node, nrows, blk_size, values);
414 }
415 exporter->closeFileNode(rhs_node);
416
417 _endDump(exporter, root_node);
418}
419
420} /* namespace Alien */
MultiVectorImpl.h
MultiVectorImpl.h.
Alien
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition BackEnd.h:17