preCICE v3.2.0
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
ExportVTUTest.cpp
Go to the documentation of this file.
1#ifndef PRECICE_NO_MPI
2
3#include <Eigen/Core>
4#include <algorithm>
5#include <map>
6#include <string>
7#include "com/SharedPointer.hpp"
8#include "io/Export.hpp"
9#include "io/ExportVTU.hpp"
10#include "mesh/Mesh.hpp"
11#include "testing/TestContext.hpp"
12#include "testing/Testing.hpp"
13#include "utils/Parallel.hpp"
14
15namespace precice::mesh {
16class Edge;
17class Vertex;
18} // namespace precice::mesh
19
20BOOST_AUTO_TEST_SUITE(IOTests)
21
22using namespace precice;
23
24BOOST_AUTO_TEST_SUITE(VTUExport)
25
26PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm())
27BOOST_AUTO_TEST_CASE(ExportScalar)
28{
29 PRECICE_TEST();
30 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
31 mesh.createVertex(Eigen::Vector2d::Zero());
32 mesh.createVertex(Eigen::Vector2d::Constant(1));
33 mesh::PtrData data = mesh.createData("data", 1, 0_dataID);
34 data->setSampleAtTime(0, time::Sample{1, 2}.setZero());
35
36 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
37 exportVTU.doExport(0, 0.0);
38 testing::expectFiles("Mesh-io-VTUExport.init.vtu");
39}
40
41PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm())
42BOOST_AUTO_TEST_CASE(ExportVector)
43{
44 PRECICE_TEST();
45 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
46 mesh.createVertex(Eigen::Vector2d::Zero());
47 mesh.createVertex(Eigen::Vector2d::Constant(1));
48 mesh::PtrData data = mesh.createData("data", 2, 0_dataID);
49 data->setSampleAtTime(0, time::Sample{2, 2}.setZero());
50
51 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
52 exportVTU.doExport(0, 0.0);
53 testing::expectFiles("Mesh-io-VTUExport.init.vtu");
54}
55
56PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm())
57BOOST_AUTO_TEST_CASE(ExportMissing)
58{
59 PRECICE_TEST();
60 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
61 mesh.createVertex(Eigen::Vector2d::Zero());
62 mesh.createVertex(Eigen::Vector2d::Constant(1));
63 mesh::PtrData data = mesh.createData("data", 2, 0_dataID);
64 // no sample
65 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
66 exportVTU.doExport(0, 0.0);
67 testing::expectFiles("Mesh-io-VTUExport.init.vtu");
68}
69
70PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
71BOOST_AUTO_TEST_CASE(ExportScalarParallel)
72{
73 PRECICE_TEST();
74 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
75 if (context.isPrimary()) {
76 mesh.createVertex(Eigen::Vector2d::Zero());
77 } else {
78 mesh.createVertex(Eigen::Vector2d::Constant(1));
79 }
80 mesh::PtrData data = mesh.createData("data", 1, 0_dataID);
81 data->setSampleAtTime(0, time::Sample{1, 1}.setZero());
82
83 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
84 exportVTU.doExport(0, 0.0);
85
86 testing::expectFiles(fmt::format("Mesh-io-VTUExport.init_{}.vtu", context.rank));
87 if (context.isPrimary()) {
88 testing::expectFiles("Mesh-io-VTUExport.init.pvtu");
89 }
90}
91
92PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
93BOOST_AUTO_TEST_CASE(ExportVectorParallel)
94{
95 PRECICE_TEST();
96 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
97 if (context.isPrimary()) {
98 mesh.createVertex(Eigen::Vector2d::Zero());
99 } else {
100 mesh.createVertex(Eigen::Vector2d::Constant(1));
101 }
102 mesh::PtrData data = mesh.createData("data", 2, 0_dataID);
103 data->setSampleAtTime(0, time::Sample{2, 1}.setZero());
104
105 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
106 exportVTU.doExport(0, 0.0);
107
108 testing::expectFiles(fmt::format("Mesh-io-VTUExport.init_{}.vtu", context.rank));
109 if (context.isPrimary()) {
110 testing::expectFiles("Mesh-io-VTUExport.init.pvtu");
111 }
112}
113
114PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
115BOOST_AUTO_TEST_CASE(ExportMissingParallel)
116{
117 PRECICE_TEST();
118 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
119 if (context.isPrimary()) {
120 mesh.createVertex(Eigen::Vector2d::Zero());
121 } else {
122 mesh.createVertex(Eigen::Vector2d::Constant(1));
123 }
124 mesh::PtrData data = mesh.createData("data", 2, 0_dataID);
125 BOOST_TEST_REQUIRE(data->timeStepsStorage().empty());
126 // no sample
127 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
128 exportVTU.doExport(0, 0.0);
129
130 testing::expectFiles(fmt::format("Mesh-io-VTUExport.init_{}.vtu", context.rank));
131 if (context.isPrimary()) {
132 testing::expectFiles("Mesh-io-VTUExport.init.pvtu");
133 }
134}
135
136PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
137BOOST_AUTO_TEST_CASE(ExportScalarAndMissingParallel)
138{
139 PRECICE_TEST();
140 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
141 if (context.isPrimary()) {
142 mesh.createVertex(Eigen::Vector2d::Zero());
143 } else {
144 mesh.createVertex(Eigen::Vector2d::Constant(1));
145 }
146 auto missing = mesh.createData("missing", 2, 0_dataID);
147 BOOST_TEST_REQUIRE(missing->timeStepsStorage().empty());
148 mesh::PtrData data = mesh.createData("data", 2, 1_dataID);
149 data->setSampleAtTime(0, time::Sample{2, 1}.setZero());
150 // no sample
151 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
152 exportVTU.doExport(0, 0.0);
153
154 testing::expectFiles(fmt::format("Mesh-io-VTUExport.init_{}.vtu", context.rank));
155 if (context.isPrimary()) {
156 testing::expectFiles("Mesh-io-VTUExport.init.pvtu");
157 }
158}
159
160PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm())
161BOOST_AUTO_TEST_CASE(ExportDataWithGradient2D)
162{
163 PRECICE_TEST();
164
165 // Create mesh to map from
166 int dimensions = 2;
167 mesh::Mesh mesh("Mesh", dimensions, testing::nextMeshID());
168 mesh::PtrData dataScalar = mesh.createData("dataScalar", 1, 0_dataID);
169 mesh::PtrData dataVector = mesh.createData("dataVector", dimensions, 1_dataID);
170 dataScalar->requireDataGradient();
171 dataVector->requireDataGradient();
172
173 mesh.createVertex(Eigen::Vector2d::Constant(0.0));
174 mesh.createVertex(Eigen::Vector2d::Constant(1.0));
175
176 time::Sample scalar(1, 2, dimensions);
177 scalar.values.setLinSpaced(0, 1);
178 scalar.gradients.setOnes();
179 dataScalar->setSampleAtTime(0, scalar);
180
181 time::Sample vectorial(dimensions, 2, dimensions);
182 vectorial.values.setLinSpaced(0, 1);
183 vectorial.gradients.setOnes();
184 dataVector->setSampleAtTime(0, vectorial);
185
186 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
187 exportVTU.doExport(0, 0.0);
188 exportVTU.doExport(1, 1.0);
189 testing::expectFiles("Mesh-io-VTUExport.init.vtu", "Mesh-io-VTUExport.dt1.vtu");
190}
191
192PRECICE_TEST_SETUP(1_rank)
193BOOST_AUTO_TEST_CASE(ExportDataWithGradient3D)
194{
195 PRECICE_TEST();
196 int dimensions = 3;
197 // Create mesh to map from
198 mesh::Mesh mesh("Mesh", dimensions, testing::nextMeshID());
199 mesh::PtrData dataScalar = mesh.createData("dataScalar", 1, 0_dataID);
200 mesh::PtrData dataVector = mesh.createData("dataVector", dimensions, 1_dataID);
201 dataScalar->requireDataGradient();
202 dataVector->requireDataGradient();
203
204 mesh.createVertex(Eigen::Vector3d::Constant(0.0));
205 mesh.createVertex(Eigen::Vector3d::Constant(1.0));
206
207 time::Sample scalar(1, 2, dimensions);
208 scalar.values.setLinSpaced(0, 1);
209 scalar.gradients.setOnes();
210 dataScalar->setSampleAtTime(0, scalar);
211
212 time::Sample vectorial(dimensions, 2, dimensions);
213 vectorial.values.setLinSpaced(0, 1);
214 vectorial.gradients.setOnes();
215 dataVector->setSampleAtTime(0, vectorial);
216
217 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
218 exportVTU.doExport(0, 0.0);
219 exportVTU.doExport(1, 1.0);
220 testing::expectFiles("Mesh-io-VTUExport.init.vtu", "Mesh-io-VTUExport.dt1.vtu");
221}
222
223PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm())
224BOOST_AUTO_TEST_CASE(ExportPolygonalMeshSerial)
225{
226 PRECICE_TEST();
227 int dim = 2;
228 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
229 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Zero());
230 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(1));
231 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0.0});
232
233 mesh.createEdge(v1, v2);
234 mesh.createEdge(v2, v3);
235 mesh.createEdge(v3, v1);
236
237 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
238 exportVTU.doExport(0, 0.0);
239 exportVTU.doExport(1, 1.0);
240 testing::expectFiles("Mesh-io-VTUExport.init.vtu", "Mesh-io-VTUExport.dt1.vtu");
241}
242
243PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
244BOOST_AUTO_TEST_CASE(ExportPolygonalMesh)
245{
246 PRECICE_TEST();
247 int dim = 2;
248 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
249
250 if (context.isRank(0)) {
251 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Zero());
252 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(1));
253 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0});
254
255 mesh.createEdge(v1, v2);
256 mesh.createEdge(v2, v3);
257 mesh.createEdge(v3, v1);
258 mesh.setVertexOffsets({3, 3, 6, 7});
259
260 } else if (context.isRank(1)) {
261 // nothing
262 } else if (context.isRank(2)) {
263 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Constant(1));
264 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(2));
265 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0.0});
266
267 mesh.createEdge(v1, v2);
268 mesh.createEdge(v2, v3);
269 mesh.createEdge(v3, v1);
270 } else if (context.isRank(3)) {
271 mesh.createVertex(Eigen::Vector2d::Constant(3.0));
272 }
273
274 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
275 exportVTU.doExport(0, 0.0);
276 exportVTU.doExport(1, 1.0);
277
278 testing::expectFiles(fmt::format("Mesh-io-VTUExport.init_{}.vtu", context.rank), fmt::format("Mesh-io-VTUExport.dt1_{}.vtu", context.rank));
279 if (context.isPrimary()) {
280 testing::expectFiles("Mesh-io-VTUExport.init.pvtu", "Mesh-io-VTUExport.dt1.pvtu");
281 }
282}
283
284PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
285BOOST_AUTO_TEST_CASE(ExportTriangulatedMesh)
286{
287 PRECICE_TEST();
288 int dim = 3;
289 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
290
291 if (context.isRank(0)) {
292 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d::Zero());
293 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d::Constant(1));
294 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector3d{1.0, 0.0, 0.0});
295
296 mesh::Edge &e1 = mesh.createEdge(v1, v2);
297 mesh::Edge &e2 = mesh.createEdge(v2, v3);
298 mesh::Edge &e3 = mesh.createEdge(v3, v1);
299 mesh.createTriangle(e1, e2, e3);
300
301 mesh.setVertexOffsets({3, 3, 6, 7});
302
303 } else if (context.isRank(1)) {
304 // nothing
305 } else if (context.isRank(2)) {
306 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d::Constant(1));
307 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d::Constant(2));
308 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector3d{0.0, 1.0, 0.0});
309
310 mesh::Edge &e1 = mesh.createEdge(v1, v2);
311 mesh::Edge &e2 = mesh.createEdge(v2, v3);
312 mesh::Edge &e3 = mesh.createEdge(v3, v1);
313 mesh.createTriangle(e1, e2, e3);
314 } else if (context.isRank(3)) {
315 mesh.createVertex(Eigen::Vector3d::Constant(3.0));
316 }
317
318 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
319 exportVTU.doExport(0, 0.0);
320 exportVTU.doExport(1, 1.0);
321
322 testing::expectFiles(fmt::format("Mesh-io-VTUExport.init_{}.vtu", context.rank), fmt::format("Mesh-io-VTUExport.dt1_{}.vtu", context.rank));
323 if (context.isPrimary()) {
324 testing::expectFiles("Mesh-io-VTUExport.init.pvtu", "Mesh-io-VTUExport.dt1.pvtu");
325 }
326}
327
328PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
329BOOST_AUTO_TEST_CASE(ExportSplitSquare)
330{
331 PRECICE_TEST();
332 int dim = 3;
333 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
334
335 mesh::Vertex &vm = mesh.createVertex(Eigen::Vector3d::Zero());
336 if (context.isRank(0)) {
337 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{-1.0, 1.0, 0.0});
338 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 0.0});
339 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{0.0, 2.0, 0.0});
340 mesh::Edge &em1 = mesh.createEdge(vm, v1);
341 mesh::Edge &e12 = mesh.createEdge(v1, v2);
342 mesh::Edge &e2m = mesh.createEdge(v2, vm);
343 mesh.createTriangle(em1, e12, e2m);
344 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
345 mesh::Edge &e2o = mesh.createEdge(v2, vo);
346 mesh.createTriangle(eo1, e12, e2o);
347 mesh.setVertexOffsets({3, 6, 9, 12});
348
349 } else if (context.isRank(1)) {
350 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{1.0, -1.0, 0.0});
351 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{-1.0, -1.0, 0.0});
352 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{0.0, -2.0, 0.0});
353 mesh::Edge &em1 = mesh.createEdge(vm, v1);
354 mesh::Edge &e12 = mesh.createEdge(v1, v2);
355 mesh::Edge &e2m = mesh.createEdge(v2, vm);
356 mesh.createTriangle(em1, e12, e2m);
357 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
358 mesh::Edge &e2o = mesh.createEdge(v2, vo);
359 mesh.createTriangle(eo1, e12, e2o);
360 } else if (context.isRank(2)) {
361 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{-1.0, 1.0, 0.0});
362 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{-1.0, -1.0, 0.0});
363 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{-2.0, 0.0, 0.0});
364 mesh::Edge &em1 = mesh.createEdge(vm, v1);
365 mesh::Edge &e12 = mesh.createEdge(v1, v2);
366 mesh::Edge &e2m = mesh.createEdge(v2, vm);
367 mesh.createTriangle(em1, e12, e2m);
368 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
369 mesh::Edge &e2o = mesh.createEdge(v2, vo);
370 mesh.createTriangle(eo1, e12, e2o);
371 } else if (context.isRank(3)) {
372 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 0.0});
373 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{1.0, -1.0, 0.0});
374 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{2.0, 0.0, 0.0});
375 mesh::Edge &em1 = mesh.createEdge(vm, v1);
376 mesh::Edge &e12 = mesh.createEdge(v1, v2);
377 mesh::Edge &e2m = mesh.createEdge(v2, vm);
378 mesh.createTriangle(em1, e12, e2m);
379 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
380 mesh::Edge &e2o = mesh.createEdge(v2, vo);
381 mesh.createTriangle(eo1, e12, e2o);
382 }
383
384 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
385 exportVTU.doExport(0, 0.0);
386 exportVTU.doExport(1, 1.0);
387
388 testing::expectFiles(fmt::format("Mesh-io-VTUExport.init_{}.vtu", context.rank), fmt::format("Mesh-io-VTUExport.dt1_{}.vtu", context.rank));
389 if (context.isPrimary()) {
390 testing::expectFiles("Mesh-io-VTUExport.init.pvtu", "Mesh-io-VTUExport.dt1.pvtu");
391 }
392}
393
394PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm())
395BOOST_AUTO_TEST_CASE(ExportOneTetrahedron)
396{
397 PRECICE_TEST();
398 int dim = 3;
399 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
400 mesh::Vertex &v0 = mesh.createVertex(Eigen::Vector3d::Zero());
401 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{1.0, 0.0, 0.0});
402 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{0.0, 1.0, 0.0});
403 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector3d{0.0, 0.0, 1.0});
404
405 mesh.createTetrahedron(v0, v1, v2, v3);
406
407 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
408 exportVTU.doExport(0, 0.0);
409 exportVTU.doExport(1, 1.0);
410 testing::expectFiles("Mesh-io-VTUExport.init.vtu", "Mesh-io-VTUExport.dt1.vtu");
411}
412
413PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
414BOOST_AUTO_TEST_CASE(ExportPartitionedCube)
415{
416 PRECICE_TEST();
417 // Unit cube is made of 6 tetrahedra. We have 3 ranks with 2 tetra each
418 // as well as en empty rank. Empty rank is the 3rd
419 int dim = 3;
420 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
421
422 if (context.isRank(0)) {
423 mesh::Vertex &v000 = mesh.createVertex(Eigen::Vector3d{0.0, 0.0, 0.0});
424 mesh::Vertex &v001 = mesh.createVertex(Eigen::Vector3d{0.0, 0.0, 1.0});
425 mesh::Vertex &v011 = mesh.createVertex(Eigen::Vector3d{0.0, 1.0, 1.0});
426 mesh::Vertex &v111 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 1.0});
427 mesh::Vertex &v010 = mesh.createVertex(Eigen::Vector3d{0.0, 1.0, 0.0});
428
429 mesh.createTetrahedron(v000, v001, v011, v111);
430 mesh.createTetrahedron(v000, v010, v011, v111);
431 mesh.setVertexOffsets({4, 8, 8, 12});
432
433 } else if (context.isRank(1)) {
434 mesh::Vertex &v000 = mesh.createVertex(Eigen::Vector3d{0.0, 0.0, 0.0});
435 mesh::Vertex &v001 = mesh.createVertex(Eigen::Vector3d{0.0, 0.0, 1.0});
436 mesh::Vertex &v101 = mesh.createVertex(Eigen::Vector3d{1.0, 0.0, 1.0});
437 mesh::Vertex &v111 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 1.0});
438 mesh::Vertex &v100 = mesh.createVertex(Eigen::Vector3d{1.0, 0.0, 0.0});
439
440 mesh.createTetrahedron(v000, v001, v101, v111);
441 mesh.createTetrahedron(v000, v100, v101, v111);
442 } else if (context.isRank(3)) {
443 mesh::Vertex &v000 = mesh.createVertex(Eigen::Vector3d{0.0, 0.0, 0.0});
444 mesh::Vertex &v010 = mesh.createVertex(Eigen::Vector3d{0.0, 1.0, 0.0});
445 mesh::Vertex &v100 = mesh.createVertex(Eigen::Vector3d{1.0, 0.0, 0.0});
446 mesh::Vertex &v111 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 1.0});
447 mesh::Vertex &v110 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 0.0});
448
449 mesh.createTetrahedron(v000, v010, v110, v111);
450 mesh.createTetrahedron(v000, v100, v110, v111);
451 }
452
453 io::ExportVTU exportVTU{"io-VTUExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
454 exportVTU.doExport(0, 0.0);
455 exportVTU.doExport(1, 1.0);
456
457 testing::expectFiles(fmt::format("Mesh-io-VTUExport.init_{}.vtu", context.rank), fmt::format("Mesh-io-VTUExport.dt1_{}.vtu", context.rank));
458 if (context.isPrimary()) {
459 testing::expectFiles("Mesh-io-VTUExport.init.pvtu", "Mesh-io-VTUExport.dt1.pvtu");
460 }
461}
462
463BOOST_AUTO_TEST_SUITE_END() // IOTests
464BOOST_AUTO_TEST_SUITE_END() // VTUExport
465
466#endif // PRECICE_NO_MPI
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(ExportDataWithGradient3D)
Definition ExportVTUTest.cpp:193
BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(PreProcess)
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
PRECICE_TEST
#define PRECICE_TEST()
Definition Testing.hpp:39
PRECICE_TEST_SETUP
#define PRECICE_TEST_SETUP(...)
Creates and attaches a TestSetup to a Boost test case.
Definition Testing.hpp:29
precice::io::ExportXML::doExport
void doExport(int index, double time) final override
Export the mesh and writes files.
Definition ExportXML.cpp:33
precice::mesh::Edge
Linear edge of a mesh, defined by two Vertex objects.
Definition Edge.hpp:15
precice::mesh::Mesh
Container and creator for meshes.
Definition Mesh.hpp:38
precice::mesh::Mesh::createData
PtrData & createData(const std::string &name, int dimension, DataID id, int waveformDegree=time::Time::DEFAULT_WAVEFORM_DEGREE)
Create only data for vertex.
Definition Mesh.cpp:153
precice::mesh::Mesh::setVertexOffsets
void setVertexOffsets(VertexOffsets vertexOffsets)
Only used for tests.
Definition Mesh.hpp:260
precice::mesh::Mesh::createEdge
Edge & createEdge(Vertex &vertexOne, Vertex &vertexTwo)
Creates and initializes an Edge object.
Definition Mesh.cpp:113
precice::mesh::Mesh::createVertex
Vertex & createVertex(const Eigen::Ref< const Eigen::VectorXd > &coords)
Creates and initializes a Vertex object.
Definition Mesh.cpp:105
precice::mesh::Vertex
Vertex of a mesh.
Definition Vertex.hpp:16
std::data
T data(T... args)
precice::mesh
provides Mesh, Data and primitives.
Definition ScaleActionTest.cpp:20
precice::testing::expectFiles
void expectFiles(Args... args)
Definition Testing.hpp:166
precice
Main namespace of the precice library.
Definition Acceleration.cpp:5
precice::time::Sample::gradients
Eigen::MatrixXd gradients
The gradients of the data. Use gradients.col(d*i+k) to get the gradient of vertex i,...
Definition Sample.hpp:67
precice::time::Sample::setZero
Sample & setZero()
Sets values and gradients to zero.
Definition Sample.hpp:52
precice::time::Sample::values
Eigen::VectorXd values
Definition Sample.hpp:64