preCICE v3.2.0
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
ExportVTPTest.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/ExportVTP.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(VTPExport)
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::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
37 exportVTP.doExport(0, 0.0);
38 testing::expectFiles("Mesh-io-VTPExport.init.vtp");
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::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
52 exportVTP.doExport(0, 0.0);
53 testing::expectFiles("Mesh-io-VTPExport.init.vtp");
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::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
66 exportVTP.doExport(0, 0.0);
67 testing::expectFiles("Mesh-io-VTPExport.init.vtp");
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::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
84 exportVTP.doExport(0, 0.0);
85 if (context.isPrimary()) {
86 testing::expectFiles(
87 "Mesh-io-VTPExport.init_0.vtp",
88 "Mesh-io-VTPExport.init.pvtp");
89 } else {
90 testing::expectFiles("Mesh-io-VTPExport.init_1.vtp");
91 }
92}
93
94PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
95BOOST_AUTO_TEST_CASE(ExportVectorParallel)
96{
97 PRECICE_TEST();
98 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
99 if (context.isPrimary()) {
100 mesh.createVertex(Eigen::Vector2d::Zero());
101 } else {
102 mesh.createVertex(Eigen::Vector2d::Constant(1));
103 }
104 mesh::PtrData data = mesh.createData("data", 2, 0_dataID);
105 data->setSampleAtTime(0, time::Sample{2, 1}.setZero());
106
107 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
108 exportVTP.doExport(0, 0.0);
109 if (context.isPrimary()) {
110 testing::expectFiles(
111 "Mesh-io-VTPExport.init_0.vtp",
112 "Mesh-io-VTPExport.init.pvtp");
113 } else {
114 testing::expectFiles("Mesh-io-VTPExport.init_1.vtp");
115 }
116}
117
118PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
119BOOST_AUTO_TEST_CASE(ExportMissingParallel)
120{
121 PRECICE_TEST();
122 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
123 if (context.isPrimary()) {
124 mesh.createVertex(Eigen::Vector2d::Zero());
125 } else {
126 mesh.createVertex(Eigen::Vector2d::Constant(1));
127 }
128 mesh::PtrData data = mesh.createData("data", 2, 0_dataID);
129 BOOST_TEST_REQUIRE(data->timeStepsStorage().empty());
130 // no sample
131 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
132 exportVTP.doExport(0, 0.0);
133 if (context.isPrimary()) {
134 testing::expectFiles(
135 "Mesh-io-VTPExport.init_0.vtp",
136 "Mesh-io-VTPExport.init.pvtp");
137 } else {
138 testing::expectFiles("Mesh-io-VTPExport.init_1.vtp");
139 }
140}
141
142PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
143BOOST_AUTO_TEST_CASE(ExportScalarAndMissingParallel)
144{
145 PRECICE_TEST();
146 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
147 if (context.isPrimary()) {
148 mesh.createVertex(Eigen::Vector2d::Zero());
149 } else {
150 mesh.createVertex(Eigen::Vector2d::Constant(1));
151 }
152 auto missing = mesh.createData("missing", 2, 0_dataID);
153 BOOST_TEST_REQUIRE(missing->timeStepsStorage().empty());
154 mesh::PtrData data = mesh.createData("data", 2, 1_dataID);
155 data->setSampleAtTime(0, time::Sample{2, 1}.setZero());
156 // no sample
157 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
158 exportVTP.doExport(0, 0.0);
159 if (context.isPrimary()) {
160 testing::expectFiles(
161 "Mesh-io-VTPExport.init_0.vtp",
162 "Mesh-io-VTPExport.init.pvtp");
163 } else {
164 testing::expectFiles("Mesh-io-VTPExport.init_1.vtp");
165 }
166}
167
168PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm());
169BOOST_AUTO_TEST_CASE(ExportDataWithGradient2D)
170{
171 PRECICE_TEST();
172 const int dimensions = 2;
173 // Create mesh to map from
174 mesh::Mesh mesh("Mesh", dimensions, testing::nextMeshID());
175 mesh::PtrData dataScalar = mesh.createData("dataScalar", 1, 0_dataID);
176 mesh::PtrData dataVector = mesh.createData("dataVector", dimensions, 1_dataID);
177 dataScalar->requireDataGradient();
178 dataVector->requireDataGradient();
179 mesh.createVertex(Eigen::Vector2d::Constant(0.0));
180 mesh.createVertex(Eigen::Vector2d::Constant(1.0));
181
182 time::Sample scalar(1, 2, dimensions);
183 scalar.values.setLinSpaced(0, 1);
184 scalar.gradients.setOnes();
185 dataScalar->setSampleAtTime(0, scalar);
186
187 time::Sample vectorial(dimensions, 2, dimensions);
188 vectorial.values.setLinSpaced(0, 1);
189 vectorial.gradients.setOnes();
190 dataVector->setSampleAtTime(0, vectorial);
191
192 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
193 exportVTP.doExport(0, 0.0);
194 exportVTP.doExport(1, 1.0);
195 testing::expectFiles("Mesh-io-VTPExport.init.vtp", "Mesh-io-VTPExport.dt1.vtp");
196}
197
198PRECICE_TEST_SETUP(1_rank)
199BOOST_AUTO_TEST_CASE(ExportDataWithGradient3D)
200{
201 PRECICE_TEST();
202 const int dimensions = 3;
203 // Create mesh to map from
204 mesh::Mesh mesh("Mesh", dimensions, testing::nextMeshID());
205 mesh::PtrData dataScalar = mesh.createData("dataScalar", 1, 0_dataID);
206 mesh::PtrData dataVector = mesh.createData("dataVector", dimensions, 1_dataID);
207 dataScalar->requireDataGradient();
208 dataVector->requireDataGradient();
209 mesh.createVertex(Eigen::Vector3d::Constant(0.0));
210 mesh.createVertex(Eigen::Vector3d::Constant(1.0));
211
212 time::Sample scalar(1, 2, dimensions);
213 scalar.values.setLinSpaced(0, 1);
214 scalar.gradients.setOnes();
215 dataScalar->setSampleAtTime(0, scalar);
216
217 time::Sample vectorial(dimensions, 2, dimensions);
218 vectorial.values.setLinSpaced(0, 1);
219 vectorial.gradients.setOnes();
220 dataVector->setSampleAtTime(0, vectorial);
221
222 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
223 exportVTP.doExport(0, 0.0);
224 exportVTP.doExport(1, 1.0);
225 testing::expectFiles("Mesh-io-VTPExport.init.vtp", "Mesh-io-VTPExport.dt1.vtp");
226}
227
228PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm())
229BOOST_AUTO_TEST_CASE(ExportPolygonalMeshSerial)
230{
231 PRECICE_TEST();
232 int dim = 2;
233 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
234 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Zero());
235 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(1));
236 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0.0});
237
238 mesh.createEdge(v1, v2);
239 mesh.createEdge(v2, v3);
240 mesh.createEdge(v3, v1);
241
242 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
243 exportVTP.doExport(0, 0.0);
244 exportVTP.doExport(1, 1.0);
245 testing::expectFiles("Mesh-io-VTPExport.init.vtp", "Mesh-io-VTPExport.dt1.vtp");
246}
247
248PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
249BOOST_AUTO_TEST_CASE(ExportPolygonalMesh)
250{
251 PRECICE_TEST();
252 int dim = 2;
253 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
254
255 if (context.isRank(0)) {
256 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Zero());
257 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(1));
258 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0});
259
260 mesh.createEdge(v1, v2);
261 mesh.createEdge(v2, v3);
262 mesh.createEdge(v3, v1);
263 mesh.setVertexOffsets({3, 3, 6, 7});
264 } else if (context.isRank(1)) {
265 // nothing
266 } else if (context.isRank(2)) {
267 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Constant(1));
268 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(2));
269 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0.0});
270
271 mesh.createEdge(v1, v2);
272 mesh.createEdge(v2, v3);
273 mesh.createEdge(v3, v1);
274 } else if (context.isRank(3)) {
275 mesh.createVertex(Eigen::Vector2d::Constant(3.0));
276 }
277
278 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
279 exportVTP.doExport(0, 0.0);
280 exportVTP.doExport(1, 1.0);
281 testing::expectFiles(fmt::format("Mesh-io-VTPExport.init_{}.vtp", context.rank),
282 fmt::format("Mesh-io-VTPExport.dt1_{}.vtp", context.rank));
283 if (context.isPrimary()) {
284 testing::expectFiles(
285 "Mesh-io-VTPExport.init.pvtp",
286 "Mesh-io-VTPExport.dt1.pvtp");
287 }
288}
289
290PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
291BOOST_AUTO_TEST_CASE(ExportTriangulatedMesh)
292{
293 PRECICE_TEST();
294 int dim = 3;
295 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
296
297 if (context.isRank(0)) {
298 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d::Zero());
299 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d::Constant(1));
300 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector3d{1.0, 0.0, 0.0});
301
302 mesh::Edge &e1 = mesh.createEdge(v1, v2);
303 mesh::Edge &e2 = mesh.createEdge(v2, v3);
304 mesh::Edge &e3 = mesh.createEdge(v3, v1);
305 mesh.createTriangle(e1, e2, e3);
306 mesh.setVertexOffsets({3, 3, 6, 7});
307
308 } else if (context.isRank(1)) {
309 // nothing
310 } else if (context.isRank(2)) {
311 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d::Constant(1));
312 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d::Constant(2));
313 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector3d{0.0, 1.0, 0.0});
314
315 mesh::Edge &e1 = mesh.createEdge(v1, v2);
316 mesh::Edge &e2 = mesh.createEdge(v2, v3);
317 mesh::Edge &e3 = mesh.createEdge(v3, v1);
318 mesh.createTriangle(e1, e2, e3);
319 } else if (context.isRank(3)) {
320 mesh.createVertex(Eigen::Vector3d::Constant(3.0));
321 }
322
323 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
324 exportVTP.doExport(0, 0.0);
325 exportVTP.doExport(1, 1.0);
326 testing::expectFiles(fmt::format("Mesh-io-VTPExport.init_{}.vtp", context.rank),
327 fmt::format("Mesh-io-VTPExport.dt1_{}.vtp", context.rank));
328 if (context.isPrimary()) {
329 testing::expectFiles(
330 "Mesh-io-VTPExport.init.pvtp",
331 "Mesh-io-VTPExport.dt1.pvtp");
332 }
333}
334
335PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
336BOOST_AUTO_TEST_CASE(ExportSplitSquare)
337{
338 PRECICE_TEST();
339 int dim = 3;
340 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
341
342 mesh::Vertex &vm = mesh.createVertex(Eigen::Vector3d::Zero());
343 if (context.isRank(0)) {
344 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{-1.0, 1.0, 0.0});
345 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 0.0});
346 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{0.0, 2.0, 0.0});
347 mesh::Edge &em1 = mesh.createEdge(vm, v1);
348 mesh::Edge &e12 = mesh.createEdge(v1, v2);
349 mesh::Edge &e2m = mesh.createEdge(v2, vm);
350 mesh.createTriangle(em1, e12, e2m);
351 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
352 mesh::Edge &e2o = mesh.createEdge(v2, vo);
353 mesh.createTriangle(eo1, e12, e2o);
354
355 mesh.setVertexOffsets({3, 6, 9, 12});
356 } else if (context.isRank(1)) {
357 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{1.0, -1.0, 0.0});
358 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{-1.0, -1.0, 0.0});
359 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{0.0, -2.0, 0.0});
360 mesh::Edge &em1 = mesh.createEdge(vm, v1);
361 mesh::Edge &e12 = mesh.createEdge(v1, v2);
362 mesh::Edge &e2m = mesh.createEdge(v2, vm);
363 mesh.createTriangle(em1, e12, e2m);
364 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
365 mesh::Edge &e2o = mesh.createEdge(v2, vo);
366 mesh.createTriangle(eo1, e12, e2o);
367 } else if (context.isRank(2)) {
368 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{-1.0, 1.0, 0.0});
369 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{-1.0, -1.0, 0.0});
370 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{-2.0, 0.0, 0.0});
371 mesh::Edge &em1 = mesh.createEdge(vm, v1);
372 mesh::Edge &e12 = mesh.createEdge(v1, v2);
373 mesh::Edge &e2m = mesh.createEdge(v2, vm);
374 mesh.createTriangle(em1, e12, e2m);
375 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
376 mesh::Edge &e2o = mesh.createEdge(v2, vo);
377 mesh.createTriangle(eo1, e12, e2o);
378 } else if (context.isRank(3)) {
379 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 0.0});
380 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{1.0, -1.0, 0.0});
381 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{2.0, 0.0, 0.0});
382 mesh::Edge &em1 = mesh.createEdge(vm, v1);
383 mesh::Edge &e12 = mesh.createEdge(v1, v2);
384 mesh::Edge &e2m = mesh.createEdge(v2, vm);
385 mesh.createTriangle(em1, e12, e2m);
386 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
387 mesh::Edge &e2o = mesh.createEdge(v2, vo);
388 mesh.createTriangle(eo1, e12, e2o);
389 }
390
391 io::ExportVTP exportVTP{"io-VTPExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
392 exportVTP.doExport(0, 0.0);
393 exportVTP.doExport(1, 1.0);
394 testing::expectFiles(fmt::format("Mesh-io-VTPExport.init_{}.vtp", context.rank),
395 fmt::format("Mesh-io-VTPExport.dt1_{}.vtp", context.rank));
396 if (context.isPrimary()) {
397 testing::expectFiles(
398 "Mesh-io-VTPExport.init.pvtp",
399 "Mesh-io-VTPExport.dt1.pvtp");
400 }
401}
402
403BOOST_AUTO_TEST_SUITE_END() // IOTests
404BOOST_AUTO_TEST_SUITE_END() // VTPExport
405
406#endif // PRECICE_NO_MPI
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(ExportScalar)
Definition ExportVTPTest.cpp:27
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