preCICE v3.2.0
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
ExportCSVTest.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/ExportCSV.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(CSVExport)
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::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
37 exportCSV.doExport(0, 0.0);
38 testing::expectFiles("Mesh-io-CSVExport.init.csv");
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::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
52 exportCSV.doExport(0, 0.0);
53 testing::expectFiles("Mesh-io-CSVExport.init.csv");
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::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
66 exportCSV.doExport(0, 0.0);
67 testing::expectFiles("Mesh-io-CSVExport.init.csv");
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::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
84 exportCSV.doExport(0, 0.0);
85 testing::expectFiles(fmt::format("Mesh-io-CSVExport.{}_init.csv", context.rank));
86}
87
88PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
89BOOST_AUTO_TEST_CASE(ExportVectorParallel)
90{
91 PRECICE_TEST();
92 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
93 if (context.isPrimary()) {
94 mesh.createVertex(Eigen::Vector2d::Zero());
95 } else {
96 mesh.createVertex(Eigen::Vector2d::Constant(1));
97 }
98 mesh::PtrData data = mesh.createData("data", 2, 0_dataID);
99 data->setSampleAtTime(0, time::Sample{2, 1}.setZero());
100
101 io::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
102 exportCSV.doExport(0, 0.0);
103 testing::expectFiles(fmt::format("Mesh-io-CSVExport.{}_init.csv", context.rank));
104}
105
106PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
107BOOST_AUTO_TEST_CASE(ExportMissingParallel)
108{
109 PRECICE_TEST();
110 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
111 if (context.isPrimary()) {
112 mesh.createVertex(Eigen::Vector2d::Zero());
113 } else {
114 mesh.createVertex(Eigen::Vector2d::Constant(1));
115 }
116 mesh::PtrData data = mesh.createData("data", 2, 0_dataID);
117 BOOST_TEST_REQUIRE(data->timeStepsStorage().empty());
118 // no sample
119 io::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
120 exportCSV.doExport(0, 0.0);
121 testing::expectFiles(fmt::format("Mesh-io-CSVExport.{}_init.csv", context.rank));
122}
123
124PRECICE_TEST_SETUP(""_on(2_ranks).setupIntraComm())
125BOOST_AUTO_TEST_CASE(ExportScalarAndMissingParallel)
126{
127 PRECICE_TEST();
128 mesh::Mesh mesh("Mesh", 2, testing::nextMeshID());
129 if (context.isPrimary()) {
130 mesh.createVertex(Eigen::Vector2d::Zero());
131 } else {
132 mesh.createVertex(Eigen::Vector2d::Constant(1));
133 }
134 auto missing = mesh.createData("missing", 2, 0_dataID);
135 BOOST_TEST_REQUIRE(missing->timeStepsStorage().empty());
136 mesh::PtrData data = mesh.createData("data", 2, 1_dataID);
137 data->setSampleAtTime(0, time::Sample{2, 1}.setZero());
138 // no sample
139 io::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
140 exportCSV.doExport(0, 0.0);
141 testing::expectFiles(fmt::format("Mesh-io-CSVExport.{}_init.csv", context.rank));
142}
143
144PRECICE_TEST_SETUP(""_on(1_rank).setupIntraComm())
145BOOST_AUTO_TEST_CASE(ExportPolygonalMeshSerial)
146{
147 PRECICE_TEST();
148 int dim = 2;
149 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
150 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Zero());
151 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(1));
152 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0.0});
153
154 mesh.createEdge(v1, v2);
155 mesh.createEdge(v2, v3);
156 mesh.createEdge(v3, v1);
157
158 io::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
159 exportCSV.doExport(0, 0.0);
160 testing::expectFiles("Mesh-io-CSVExport.init.csv");
161}
162
163PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
164BOOST_AUTO_TEST_CASE(ExportPolygonalMesh)
165{
166 PRECICE_TEST();
167 int dim = 2;
168 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
169
170 if (context.isRank(0)) {
171 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Zero());
172 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(1));
173 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0});
174
175 mesh.createEdge(v1, v2);
176 mesh.createEdge(v2, v3);
177 mesh.createEdge(v3, v1);
178 mesh.setVertexOffsets({3, 3, 6, 7});
179 } else if (context.isRank(1)) {
180 // nothing
181 } else if (context.isRank(2)) {
182 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector2d::Constant(1));
183 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector2d::Constant(2));
184 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector2d{1.0, 0.0});
185
186 mesh.createEdge(v1, v2);
187 mesh.createEdge(v2, v3);
188 mesh.createEdge(v3, v1);
189 } else if (context.isRank(3)) {
190 mesh.createVertex(Eigen::Vector2d::Constant(3.0));
191 }
192
193 io::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
194 exportCSV.doExport(0, 0.0);
195 testing::expectFiles(fmt::format("Mesh-io-CSVExport.{}_init.csv", context.rank));
196}
197
198PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
199BOOST_AUTO_TEST_CASE(ExportTriangulatedMesh)
200{
201 PRECICE_TEST();
202 int dim = 3;
203 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
204
205 if (context.isRank(0)) {
206 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d::Zero());
207 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d::Constant(1));
208 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector3d{1.0, 0.0, 0.0});
209
210 mesh::Edge &e1 = mesh.createEdge(v1, v2);
211 mesh::Edge &e2 = mesh.createEdge(v2, v3);
212 mesh::Edge &e3 = mesh.createEdge(v3, v1);
213 mesh.createTriangle(e1, e2, e3);
214
215 mesh.setVertexOffsets({3, 3, 6, 7});
216 } else if (context.isRank(1)) {
217 // nothing
218 } else if (context.isRank(2)) {
219 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d::Constant(1));
220 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d::Constant(2));
221 mesh::Vertex &v3 = mesh.createVertex(Eigen::Vector3d{0.0, 1.0, 0.0});
222
223 mesh::Edge &e1 = mesh.createEdge(v1, v2);
224 mesh::Edge &e2 = mesh.createEdge(v2, v3);
225 mesh::Edge &e3 = mesh.createEdge(v3, v1);
226 mesh.createTriangle(e1, e2, e3);
227 } else if (context.isRank(3)) {
228 mesh.createVertex(Eigen::Vector3d::Constant(3.0));
229 }
230
231 io::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
232 exportCSV.doExport(0, 0.0);
233 testing::expectFiles(fmt::format("Mesh-io-CSVExport.{}_init.csv", context.rank));
234}
235
236PRECICE_TEST_SETUP(""_on(4_ranks).setupIntraComm())
237BOOST_AUTO_TEST_CASE(ExportSplitSquare)
238{
239 PRECICE_TEST();
240 int dim = 3;
241 mesh::Mesh mesh("Mesh", dim, testing::nextMeshID());
242
243 mesh::Vertex &vm = mesh.createVertex(Eigen::Vector3d::Zero());
244 if (context.isRank(0)) {
245 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{-1.0, 1.0, 0.0});
246 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 0.0});
247 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{0.0, 2.0, 0.0});
248 mesh::Edge &em1 = mesh.createEdge(vm, v1);
249 mesh::Edge &e12 = mesh.createEdge(v1, v2);
250 mesh::Edge &e2m = mesh.createEdge(v2, vm);
251 mesh.createTriangle(em1, e12, e2m);
252 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
253 mesh::Edge &e2o = mesh.createEdge(v2, vo);
254 mesh.createTriangle(eo1, e12, e2o);
255
256 mesh.setVertexOffsets({3, 6, 9, 12});
257 } else if (context.isRank(1)) {
258 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{1.0, -1.0, 0.0});
259 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{-1.0, -1.0, 0.0});
260 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{0.0, -2.0, 0.0});
261 mesh::Edge &em1 = mesh.createEdge(vm, v1);
262 mesh::Edge &e12 = mesh.createEdge(v1, v2);
263 mesh::Edge &e2m = mesh.createEdge(v2, vm);
264 mesh.createTriangle(em1, e12, e2m);
265 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
266 mesh::Edge &e2o = mesh.createEdge(v2, vo);
267 mesh.createTriangle(eo1, e12, e2o);
268 } else if (context.isRank(2)) {
269 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{-1.0, 1.0, 0.0});
270 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{-1.0, -1.0, 0.0});
271 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{-2.0, 0.0, 0.0});
272 mesh::Edge &em1 = mesh.createEdge(vm, v1);
273 mesh::Edge &e12 = mesh.createEdge(v1, v2);
274 mesh::Edge &e2m = mesh.createEdge(v2, vm);
275 mesh.createTriangle(em1, e12, e2m);
276 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
277 mesh::Edge &e2o = mesh.createEdge(v2, vo);
278 mesh.createTriangle(eo1, e12, e2o);
279 } else if (context.isRank(3)) {
280 mesh::Vertex &v1 = mesh.createVertex(Eigen::Vector3d{1.0, 1.0, 0.0});
281 mesh::Vertex &v2 = mesh.createVertex(Eigen::Vector3d{1.0, -1.0, 0.0});
282 mesh::Vertex &vo = mesh.createVertex(Eigen::Vector3d{2.0, 0.0, 0.0});
283 mesh::Edge &em1 = mesh.createEdge(vm, v1);
284 mesh::Edge &e12 = mesh.createEdge(v1, v2);
285 mesh::Edge &e2m = mesh.createEdge(v2, vm);
286 mesh.createTriangle(em1, e12, e2m);
287 mesh::Edge &eo1 = mesh.createEdge(vo, v1);
288 mesh::Edge &e2o = mesh.createEdge(v2, vo);
289 mesh.createTriangle(eo1, e12, e2o);
290 }
291
292 io::ExportCSV exportCSV{"io-CSVExport", ".", mesh, io::Export::ExportKind::TimeWindows, 1, context.rank, context.size};
293 exportCSV.doExport(0, 0.0);
294 testing::expectFiles(fmt::format("Mesh-io-CSVExport.{}_init.csv", context.rank));
295}
296
297BOOST_AUTO_TEST_SUITE_END() // IOTests
298BOOST_AUTO_TEST_SUITE_END() // CSVExport
299
300#endif // PRECICE_NO_MPI
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(testIQNIMVJPPWithSubsteps)
Definition AccelerationSerialTest.cpp:122
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::ExportCSV::doExport
void doExport(int index, double time) final override
Export the mesh and writes files.
Definition ExportCSV.cpp:48
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::setZero
Sample & setZero()
Sets values and gradients to zero.
Definition Sample.hpp:52