preCICE v3.1.2
Loading...
Searching...
No Matches
ProvidedPartitionTest.cpp
Go to the documentation of this file.
1#ifndef PRECICE_NO_MPI
2#include <Eigen/Core>
3#include <algorithm>
4#include <deque>
5#include <map>
6#include <memory>
7#include <string>
8#include <vector>
9
10#include "com/Communication.hpp"
11#include "com/Extra.hpp"
12#include "com/SharedPointer.hpp"
13#include "m2n/M2N.hpp"
14#include "mapping/Mapping.hpp"
15#include "mapping/NearestNeighborMapping.hpp"
16#include "mapping/SharedPointer.hpp"
17#include "math/constants.hpp"
18#include "mesh/BoundingBox.hpp"
19#include "mesh/Data.hpp"
20#include "mesh/Mesh.hpp"
21#include "mesh/SharedPointer.hpp"
22#include "partition/Partition.hpp"
23#include "partition/ProvidedPartition.hpp"
24#include "partition/ReceivedPartition.hpp"
25#include "testing/TestContext.hpp"
26#include "testing/Testing.hpp"
27#include "utils/assertion.hpp"
28
29namespace precice::mesh {
30class Edge;
31class Vertex;
32} // namespace precice::mesh
33
34using namespace precice;
35using namespace partition;
36using precice::testing::TestContext;
37
38BOOST_AUTO_TEST_SUITE(PartitionTests)
39BOOST_AUTO_TEST_SUITE(ProvidedPartitionTests)
40
41BOOST_AUTO_TEST_CASE(TestGatherAndCommunicate2D)
42{
43 PRECICE_TEST("NASTIN"_on(1_rank), "SOLIDZ"_on(3_ranks).setupIntraComm(), Require::Events);
44 auto m2n = context.connectPrimaryRanks("NASTIN", "SOLIDZ");
45
46 int dimensions = 2;
47
48 if (context.isNamed("NASTIN")) { //NASTIN
49 mesh::PtrMesh pSolidzMesh(new mesh::Mesh("SolidzMesh", dimensions, testing::nextMeshID()));
50
51 double safetyFactor = 0.1;
52
53 ReceivedPartition part(pSolidzMesh, ReceivedPartition::ON_SECONDARY_RANKS, safetyFactor);
54 part.addM2N(m2n);
55 part.communicate();
56
57 BOOST_TEST(pSolidzMesh->nVertices() == 6);
58 BOOST_TEST(pSolidzMesh->edges().size() == 4);
59
60 for (int i = 0; i < 6; i++) {
61 BOOST_TEST(pSolidzMesh->vertex(i).getGlobalIndex() == i);
62 }
63 } else { //SOLIDZ
64 mesh::PtrMesh pSolidzMesh(new mesh::Mesh("SolidzMesh", dimensions, testing::nextMeshID()));
65
66 if (context.isPrimary()) { //Primary
67 Eigen::VectorXd position(dimensions);
68 position << 0.0, 0.0;
69 mesh::Vertex &v1 = pSolidzMesh->createVertex(position);
70 position << 0.0, 1.5;
71 mesh::Vertex &v2 = pSolidzMesh->createVertex(position);
72 pSolidzMesh->createEdge(v1, v2);
73 } else if (context.isRank(1)) { //SecondaryRank1
74 } else if (context.isRank(2)) { //Secondary rank 2
75 Eigen::VectorXd position(dimensions);
76 position << 0.0, 3.5;
77 mesh::Vertex &v3 = pSolidzMesh->createVertex(position);
78 position << 0.0, 4.5;
79 mesh::Vertex &v4 = pSolidzMesh->createVertex(position);
80 position << 0.0, 5.5;
81 mesh::Vertex &v5 = pSolidzMesh->createVertex(position);
82 position << 0.0, 7.0;
83 mesh::Vertex &v6 = pSolidzMesh->createVertex(position);
84 pSolidzMesh->createEdge(v3, v4);
85 pSolidzMesh->createEdge(v4, v5);
86 pSolidzMesh->createEdge(v5, v6);
87 }
88 pSolidzMesh->computeBoundingBox();
89
90 ProvidedPartition part(pSolidzMesh);
91 part.addM2N(m2n);
92 part.communicate();
93 part.compute();
94
95 BOOST_REQUIRE(pSolidzMesh->getVertexOffsets().size() == 3);
96 if (context.isPrimary()) {
97 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(0) == 2);
98 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(1) == 2);
99 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(2) == 6);
100 } else if (context.isRank(1)) { //SecondaryRank1
101 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(0) == 2);
102 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(1) == 2);
103 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(2) == 6);
104 } else {
105 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(0) == 2);
106 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(1) == 2);
107 BOOST_TEST(pSolidzMesh->getVertexOffsets().at(2) == 6);
108 }
109 }
110}
111
112BOOST_AUTO_TEST_CASE(TestGatherAndCommunicate3D)
113{
114 PRECICE_TEST("NASTIN"_on(1_rank), "SOLIDZ"_on(3_ranks).setupIntraComm(), Require::Events);
115 auto m2n = context.connectPrimaryRanks("NASTIN", "SOLIDZ");
116
117 int dimensions = 3;
118
119 if (context.isNamed("NASTIN")) { //NASTIN
120 mesh::PtrMesh pSolidzMesh(new mesh::Mesh("SolidzMesh", dimensions, testing::nextMeshID()));
121
122 double safetyFactor = 0.1;
123
124 ReceivedPartition part(pSolidzMesh, ReceivedPartition::ON_SECONDARY_RANKS, safetyFactor);
125 part.addM2N(m2n);
126 part.communicate();
127
128 BOOST_TEST(pSolidzMesh->nVertices() == 6);
129 BOOST_TEST(pSolidzMesh->edges().size() == 6);
130 BOOST_TEST(pSolidzMesh->triangles().size() == 2);
131
132 for (int i = 0; i < 6; i++) {
133 BOOST_TEST(pSolidzMesh->vertex(i).getGlobalIndex() == i);
134 }
135 } else { //SOLIDZ
136 mesh::PtrMesh pSolidzMesh(new mesh::Mesh("SolidzMesh", dimensions, testing::nextMeshID()));
137
138 if (context.isPrimary()) { //Primary
139 Eigen::VectorXd position(dimensions);
140 position << 0.0, 0.0, 0.0;
141 mesh::Vertex &v1 = pSolidzMesh->createVertex(position);
142 position << 0.0, 1.5, 1.0;
143 mesh::Vertex &v2 = pSolidzMesh->createVertex(position);
144 pSolidzMesh->createEdge(v1, v2);
145 } else if (context.isRank(1)) { //SecondaryRank1
146 } else if (context.isRank(2)) { //Secondary rank 2
147 Eigen::VectorXd position(dimensions);
148 position << 0.0, 3.5, 0.1;
149 mesh::Vertex &v3 = pSolidzMesh->createVertex(position);
150 position << 0.0, 4.5, 0.2;
151 mesh::Vertex &v4 = pSolidzMesh->createVertex(position);
152 position << 0.0, 5.5, 0.8;
153 mesh::Vertex &v5 = pSolidzMesh->createVertex(position);
154 position << 0.0, 7.0, 0.4;
155 mesh::Vertex &v6 = pSolidzMesh->createVertex(position);
156 mesh::Edge & e1 = pSolidzMesh->createEdge(v3, v4);
157 mesh::Edge & e2 = pSolidzMesh->createEdge(v4, v5);
158 mesh::Edge & e3 = pSolidzMesh->createEdge(v5, v3);
159 mesh::Edge & e4 = pSolidzMesh->createEdge(v3, v6);
160 mesh::Edge & e5 = pSolidzMesh->createEdge(v6, v5);
161
162 pSolidzMesh->createTriangle(e1, e2, e3);
163 pSolidzMesh->createTriangle(e4, e5, e3);
164 }
165 pSolidzMesh->computeBoundingBox();
166
167 ProvidedPartition part(pSolidzMesh);
168 part.addM2N(m2n);
169 part.communicate();
170 part.compute();
171
172 BOOST_TEST(pSolidzMesh->getGlobalNumberOfVertices() == 6);
173 const auto &vertices = pSolidzMesh->vertices();
174 const auto &vertexOffsets = pSolidzMesh->getVertexOffsets();
175 const auto &vertexDistribution = pSolidzMesh->getVertexDistribution();
176
177 if (context.isPrimary()) {
178 BOOST_REQUIRE(vertexOffsets.size() == 3);
179 BOOST_TEST(vertexOffsets.at(0) == 2);
180 BOOST_TEST(vertexOffsets.at(1) == 2);
181 BOOST_TEST(vertexOffsets.at(2) == 6);
182
183 BOOST_REQUIRE(vertices.size() == 2);
184 BOOST_TEST(vertices.at(0).getGlobalIndex() == 0);
185 BOOST_TEST(vertices.at(1).getGlobalIndex() == 1);
186 BOOST_TEST(vertices.at(0).isOwner() == true);
187 BOOST_TEST(vertices.at(1).isOwner() == true);
188
189 BOOST_REQUIRE((vertexDistribution.size()) == 3);
190 BOOST_TEST(vertexDistribution.at(0).size() == 2);
191 BOOST_TEST(vertexDistribution.at(1).size() == 0);
192 BOOST_TEST(vertexDistribution.at(2).size() == 4);
193 BOOST_TEST(vertexDistribution.at(0).at(0) == 0);
194 BOOST_TEST(vertexDistribution.at(0).at(1) == 1);
195 BOOST_TEST(vertexDistribution.at(2).at(0) == 2);
196 BOOST_TEST(vertexDistribution.at(2).at(1) == 3);
197 BOOST_TEST(vertexDistribution.at(2).at(2) == 4);
198 BOOST_TEST(vertexDistribution.at(2).at(3) == 5);
199 } else if (context.isRank(1)) { //SecondaryRank1
200 BOOST_REQUIRE(vertexOffsets.size() == 3);
201 BOOST_TEST(vertexOffsets.at(0) == 2);
202 BOOST_TEST(vertexOffsets.at(1) == 2);
203 BOOST_TEST(vertexOffsets.at(2) == 6);
204 } else if (context.isRank(2)) { //Secondary rank 2
205 BOOST_REQUIRE(vertexOffsets.size() == 3);
206 BOOST_TEST(vertexOffsets.at(0) == 2);
207 BOOST_TEST(vertexOffsets.at(1) == 2);
208 BOOST_TEST(vertexOffsets.at(2) == 6);
209
210 BOOST_REQUIRE(vertices.size() == 4);
211 BOOST_TEST(vertices.at(0).getGlobalIndex() == 2);
212 BOOST_TEST(vertices.at(1).getGlobalIndex() == 3);
213 BOOST_TEST(vertices.at(2).getGlobalIndex() == 4);
214 BOOST_TEST(vertices.at(3).getGlobalIndex() == 5);
215 BOOST_TEST(vertices.at(0).isOwner() == true);
216 BOOST_TEST(vertices.at(1).isOwner() == true);
217 BOOST_TEST(vertices.at(2).isOwner() == true);
218 BOOST_TEST(vertices.at(3).isOwner() == true);
219 }
220 }
221}
222
223BOOST_AUTO_TEST_CASE(TestOnlyDistribution2D)
224{
225 PRECICE_TEST("NASTIN"_on(4_ranks).setupIntraComm(), Require::Events);
226 // Create mesh object
227 std::string meshName("MyMesh");
228 int dim = 2;
229 mesh::PtrMesh pMesh(new mesh::Mesh(meshName, dim, testing::nextMeshID()));
230
231 if (context.isPrimary()) { //Primary
232 Eigen::VectorXd position(dim);
233 position << 0.0, 0.0;
234 pMesh->createVertex(position);
235 position << 1.0, 0.0;
236 pMesh->createVertex(position);
237 } else if (context.isRank(1)) { //SecondaryRank1
238 Eigen::VectorXd position(dim);
239 position << 2.0, 0.0;
240 pMesh->createVertex(position);
241 } else if (context.isRank(2)) { //Secondary rank 2
242 } else if (context.isRank(3)) { //Secondary rank 3
243 Eigen::VectorXd position(dim);
244 position << 3.0, 0.0;
245 pMesh->createVertex(position);
246 position << 4.0, 0.0;
247 pMesh->createVertex(position);
248 }
249 pMesh->computeBoundingBox();
250
251 ProvidedPartition part(pMesh);
252 part.communicate();
253 part.compute();
254
255 BOOST_TEST_CONTEXT(*pMesh)
256 {
257 if (context.isPrimary()) { //Primary
258 BOOST_TEST(pMesh->getGlobalNumberOfVertices() == 5);
259 BOOST_TEST_REQUIRE(pMesh->getVertexOffsets().size() == 4);
260 BOOST_TEST(pMesh->getVertexOffsets().at(0) == 2);
261 BOOST_TEST(pMesh->getVertexOffsets().at(1) == 3);
262 BOOST_TEST(pMesh->getVertexOffsets().at(2) == 3);
263 BOOST_TEST(pMesh->getVertexOffsets().at(3) == 5);
264 BOOST_TEST(pMesh->vertex(0).getGlobalIndex() == 0);
265 BOOST_TEST(pMesh->vertex(1).getGlobalIndex() == 1);
266 BOOST_TEST(pMesh->vertex(0).isOwner() == true);
267 BOOST_TEST(pMesh->vertex(1).isOwner() == true);
268 } else if (context.isRank(1)) { //SecondaryRank1
269 BOOST_TEST(pMesh->getGlobalNumberOfVertices() == 5);
270 BOOST_TEST_REQUIRE(pMesh->getVertexOffsets().size() == 4);
271 BOOST_TEST(pMesh->getVertexOffsets().at(0) == 2);
272 BOOST_TEST(pMesh->getVertexOffsets().at(1) == 3);
273 BOOST_TEST(pMesh->getVertexOffsets().at(2) == 3);
274 BOOST_TEST(pMesh->getVertexOffsets().at(3) == 5);
275 BOOST_TEST(pMesh->vertex(0).getGlobalIndex() == 2);
276 BOOST_TEST(pMesh->vertex(0).isOwner() == true);
277 } else if (context.isRank(2)) { //Secondary rank 2
278 BOOST_TEST(pMesh->getGlobalNumberOfVertices() == 5);
279 BOOST_TEST_REQUIRE(pMesh->getVertexOffsets().size() == 4);
280 BOOST_TEST(pMesh->getVertexOffsets().at(0) == 2);
281 BOOST_TEST(pMesh->getVertexOffsets().at(1) == 3);
282 BOOST_TEST(pMesh->getVertexOffsets().at(2) == 3);
283 BOOST_TEST(pMesh->getVertexOffsets().at(3) == 5);
284 } else if (context.isRank(3)) { //Secondary rank 3
285 BOOST_TEST(pMesh->getGlobalNumberOfVertices() == 5);
286 BOOST_TEST_REQUIRE(pMesh->getVertexOffsets().size() == 4);
287 BOOST_TEST(pMesh->getVertexOffsets().at(0) == 2);
288 BOOST_TEST(pMesh->getVertexOffsets().at(1) == 3);
289 BOOST_TEST(pMesh->getVertexOffsets().at(2) == 3);
290 BOOST_TEST(pMesh->getVertexOffsets().at(3) == 5);
291 BOOST_TEST(pMesh->vertex(0).getGlobalIndex() == 3);
292 BOOST_TEST(pMesh->vertex(1).getGlobalIndex() == 4);
293 BOOST_TEST(pMesh->vertex(0).isOwner() == true);
294 BOOST_TEST(pMesh->vertex(1).isOwner() == true);
295 }
296 }
297}
298
299BOOST_AUTO_TEST_CASE(TestCompareBoundingBoxes2D)
300{
301 PRECICE_TEST("SOLIDZ"_on(3_ranks).setupIntraComm(), "NASTIN"_on(1_rank), Require::Events);
302 testing::ConnectionOptions options;
303 options.useOnlyPrimaryCom = false;
304 options.useTwoLevelInit = true;
305 auto m2n = context.connectPrimaryRanks("NASTIN", "SOLIDZ", options);
306
307 int dimensions = 2;
308
309 if (context.isNamed("SOLIDZ")) { //SOLIDZ
310
311 mesh::PtrMesh pSolidzMesh(new mesh::Mesh("SolidzMesh", dimensions, testing::nextMeshID()));
312
313 if (context.isPrimary()) { //Primary
314 Eigen::VectorXd position(dimensions);
315 position << -1.0, 0.0;
316 mesh::Vertex &v0 = pSolidzMesh->createVertex(position);
317 position << 1.0, 2.0;
318 mesh::Vertex &v1 = pSolidzMesh->createVertex(position);
319 position << 5.0, 3.0;
320 mesh::Vertex &v2 = pSolidzMesh->createVertex(position);
321 pSolidzMesh->createEdge(v0, v1);
322 pSolidzMesh->createEdge(v1, v2);
323 }
324
325 else if (context.isRank(1)) { //SecondaryRank1
326 Eigen::VectorXd position(dimensions);
327 position << 1.0, 3.5;
328 mesh::Vertex &v3 = pSolidzMesh->createVertex(position);
329 position << 0.0, 4.5;
330 mesh::Vertex &v4 = pSolidzMesh->createVertex(position);
331 pSolidzMesh->createEdge(v3, v4);
332 } else if (context.isRank(2)) { //Secondary rank 2
333 Eigen::VectorXd position(dimensions);
334 position << 2.5, 5.5;
335 mesh::Vertex &v5 = pSolidzMesh->createVertex(position);
336 position << 4.5, 7.0;
337 mesh::Vertex &v6 = pSolidzMesh->createVertex(position);
338 pSolidzMesh->createEdge(v5, v6);
339 }
340 pSolidzMesh->computeBoundingBox();
341
342 ProvidedPartition part(pSolidzMesh);
343 part.addM2N(m2n);
344 part.compareBoundingBoxes();
345
346 if (context.isPrimary()) { //Primary
347 BOOST_TEST(pSolidzMesh->getConnectedRanks().size() == 2);
348 BOOST_TEST(pSolidzMesh->getConnectedRanks().at(0) == 1);
349 BOOST_TEST(pSolidzMesh->getConnectedRanks().at(1) == 2);
350 } else if (context.isRank(1)) { //SecondaryRank1
351 BOOST_TEST(pSolidzMesh->getConnectedRanks().size() == 2);
352 BOOST_TEST(pSolidzMesh->getConnectedRanks().at(0) == 0);
353 BOOST_TEST(pSolidzMesh->getConnectedRanks().at(1) == 2);
354 } else if (context.isRank(2)) { //Secondary rank 2
355 BOOST_TEST(pSolidzMesh->getConnectedRanks().size() == 2);
356 BOOST_TEST(pSolidzMesh->getConnectedRanks().at(0) == 0);
357 BOOST_TEST(pSolidzMesh->getConnectedRanks().at(1) == 1);
358 }
359
360 } else { //NASTIN
361 BOOST_TEST(context.isNamed("NASTIN"));
362
363 mesh::Mesh::BoundingBoxMap receivedGlobalBB;
364 mesh::BoundingBox localBB{dimensions};
365
366 mesh::Mesh::BoundingBoxMap compareBB;
367 compareBB.emplace(0, mesh::BoundingBox({-1, 5, 0, 3}));
368 compareBB.emplace(1, mesh::BoundingBox({0, 1, 3.5, 4.5}));
369 compareBB.emplace(2, mesh::BoundingBox({2.5, 4.5, 5.5, 7.0}));
370
371 // we receive other participants communicator size
372 int receivedFeedbackSize = 3;
373 m2n->getPrimaryRankCommunication()->receive(receivedFeedbackSize, 0);
374
375 for (int i = 0; i < receivedFeedbackSize; i++) {
376 receivedGlobalBB.emplace(i, localBB);
377 }
378
379 // we receive global bounding box from other participant!
380 com::receiveBoundingBoxMap(*m2n->getPrimaryRankCommunication(), 0, receivedGlobalBB);
381 // check whether we have received the correct com size
382 BOOST_TEST(receivedFeedbackSize == 3);
383
384 //check the validity of received global bounding box (globalBB)
385 BOOST_TEST(receivedGlobalBB.at(0) == compareBB.at(0));
386 BOOST_TEST(receivedGlobalBB.at(1) == compareBB.at(1));
387 BOOST_TEST(receivedGlobalBB.at(2) == compareBB.at(2));
388
389 std::vector<int> connectedRanks = {0, 1, 2};
390 m2n->getPrimaryRankCommunication()->sendRange(connectedRanks, 0);
391
392 // construct connection map
393 std::map<int, std::vector<int>> connectionMap;
394 connectionMap[0].push_back(1);
395 connectionMap[0].push_back(2);
396 connectionMap[1].push_back(0);
397 connectionMap[1].push_back(2);
398 connectionMap[2].push_back(0);
399 connectionMap[2].push_back(1);
400
401 com::sendConnectionMap(*m2n->getPrimaryRankCommunication(), 0, connectionMap);
402 }
403}
404
405BOOST_AUTO_TEST_CASE(TestSendBoundingBoxes3D)
406{
407 PRECICE_TEST("SOLIDZ"_on(3_ranks).setupIntraComm(), "NASTIN"_on(1_rank), Require::Events);
408 testing::ConnectionOptions options;
409 options.useOnlyPrimaryCom = false;
410 options.useTwoLevelInit = true;
411 auto m2n = context.connectPrimaryRanks("NASTIN", "SOLIDZ", options);
412
413 int dimensions = 3;
414
415 if (context.isNamed("SOLIDZ")) { //SOLIDZ
416
417 mesh::PtrMesh pSolidzMesh(new mesh::Mesh("SolidzMesh", dimensions, testing::nextMeshID()));
418
419 if (context.isPrimary()) { //Primary
420 Eigen::VectorXd position(dimensions);
421 position << -1.0, 0.0, -1.0;
422 mesh::Vertex &v0 = pSolidzMesh->createVertex(position);
423 position << 1.0, 2.0, 1.0;
424 mesh::Vertex &v1 = pSolidzMesh->createVertex(position);
425 position << 5.0, 3.0, 5.0;
426 mesh::Vertex &v2 = pSolidzMesh->createVertex(position);
427 pSolidzMesh->createEdge(v0, v1);
428 pSolidzMesh->createEdge(v1, v2);
429 }
430
431 else if (context.isRank(1)) { //SecondaryRank1
432 Eigen::VectorXd position(dimensions);
433 position << 1.0, 3.5, 1.0;
434 mesh::Vertex &v3 = pSolidzMesh->createVertex(position);
435 position << 0.0, 4.5, 0.0;
436 mesh::Vertex &v4 = pSolidzMesh->createVertex(position);
437 pSolidzMesh->createEdge(v3, v4);
438 } else if (context.isRank(2)) { //Secondary rank 2
439 Eigen::VectorXd position(dimensions);
440 position << 2.5, 5.5, 2.5;
441 mesh::Vertex &v5 = pSolidzMesh->createVertex(position);
442 position << 4.5, 7.0, 4.5;
443 mesh::Vertex &v6 = pSolidzMesh->createVertex(position);
444 pSolidzMesh->createEdge(v5, v6);
445 }
446 pSolidzMesh->computeBoundingBox();
447
448 ProvidedPartition part(pSolidzMesh);
449 part.addM2N(m2n);
450 part.compareBoundingBoxes();
451
452 } else { //NASTIN
453 BOOST_TEST(context.isNamed("NASTIN"));
454
455 mesh::Mesh::BoundingBoxMap receivedGlobalBB;
456 mesh::BoundingBox localBB{dimensions};
457
458 mesh::Mesh::BoundingBoxMap compareBB;
459 compareBB.emplace(0, mesh::BoundingBox({-1, 5, 0, 3, -1, 5}));
460 compareBB.emplace(1, mesh::BoundingBox({0, 1, 3.5, 4.5, 0, 1}));
461 compareBB.emplace(2, mesh::BoundingBox({2.5, 4.5, 5.5, 7.0, 2.5, 4.5}));
462
463 // we receive other participants communicator size
464 int remoteParComSize = 3;
465 m2n->getPrimaryRankCommunication()->receive(remoteParComSize, 0);
466
467 for (int i = 0; i < remoteParComSize; i++) {
468 receivedGlobalBB.emplace(i, localBB);
469 }
470
471 // we receive global bounding box from other participant!
472 com::receiveBoundingBoxMap(*m2n->getPrimaryRankCommunication(), 0, receivedGlobalBB);
473
474 // check whether we have received the correct com size
475 BOOST_TEST(remoteParComSize == 3);
476
477 //check the validity of received global bounding box (globalBB)
478 BOOST_TEST(receivedGlobalBB.at(0) == compareBB.at(0));
479 BOOST_TEST(receivedGlobalBB.at(1) == compareBB.at(1));
480 BOOST_TEST(receivedGlobalBB.at(2) == compareBB.at(2));
481
482 //send empty dummy list of connected ranks as feedback
483 std::vector<int> connectedRanksList;
484 m2n->getPrimaryRankCommunication()->sendRange(connectedRanksList, 0);
485 }
486}
487
488BOOST_AUTO_TEST_CASE(TestCommunicateLocalMeshPartitions)
489{
490 PRECICE_TEST("Solid"_on(2_ranks).setupIntraComm(), "Fluid"_on(2_ranks).setupIntraComm(), Require::Events);
491 //mesh creation
492 int dimensions = 2;
493 double safetyFactor = 0.1;
494 mesh::PtrMesh mesh(new mesh::Mesh("mesh", dimensions, testing::nextMeshID()));
495
496 testing::ConnectionOptions options;
497 options.useOnlyPrimaryCom = false;
498 options.useTwoLevelInit = true;
499 options.type = testing::ConnectionType::PointToPoint;
500 auto m2n = context.connectPrimaryRanks("Fluid", "Solid", options);
501
502 if (context.isNamed("Solid")) {
503 if (context.isPrimary()) {
504 Eigen::VectorXd position(dimensions);
505 position << 0.5, 0.0;
506 mesh::Vertex &v1 = mesh->createVertex(position);
507 position << 1.5, 0.0;
508 mesh::Vertex &v2 = mesh->createVertex(position);
509 position << 2.0, 1.0;
510 mesh::Vertex &v3 = mesh->createVertex(position);
511 position << 0.5, 1.0;
512 mesh::Vertex &v4 = mesh->createVertex(position);
513 mesh->createEdge(v1, v2);
514 mesh->createEdge(v2, v3);
515 mesh->createEdge(v3, v4);
516 mesh->createEdge(v4, v1);
517
518 mesh->setConnectedRanks({0});
519
520 } else {
521 Eigen::VectorXd position(dimensions);
522 position << 2.5, 0.0;
523 mesh::Vertex &v1 = mesh->createVertex(position);
524 position << 3.5, 0.0;
525 mesh::Vertex &v2 = mesh->createVertex(position);
526 position << 3.5, 1.0;
527 mesh::Vertex &v3 = mesh->createVertex(position);
528 position << 2.0, 1.0;
529 mesh::Vertex &v4 = mesh->createVertex(position);
530 mesh->createEdge(v1, v2);
531 mesh->createEdge(v2, v3);
532 mesh->createEdge(v3, v4);
533 mesh->createEdge(v4, v1);
534
535 mesh->setConnectedRanks({1});
536 }
537 } else {
538 BOOST_TEST(context.isNamed("Fluid"));
539 if (context.isPrimary()) {
540 mesh->setConnectedRanks({0});
541 } else {
542 mesh->setConnectedRanks({1});
543 }
544 }
545 mesh->computeBoundingBox();
546
547 if (context.isNamed("Solid")) {
548 m2n->createDistributedCommunication(mesh);
549 ProvidedPartition part(mesh);
550 m2n->acceptSecondaryRanksPreConnection("SolidSecondaryRanks", "FluidSecondaryRanks");
551 part.addM2N(m2n);
552 part.communicate();
553 } else {
554 m2n->createDistributedCommunication(mesh);
555 ReceivedPartition part(mesh, ReceivedPartition::ON_SECONDARY_RANKS, safetyFactor);
556 m2n->requestSecondaryRanksPreConnection("SolidSecondaryRanks", "FluidSecondaryRanks");
557 part.addM2N(m2n);
558
559 part.communicate();
560
561 BOOST_TEST(mesh->nVertices() == 4);
562
563 if (context.isPrimary()) {
564 BOOST_TEST(mesh->vertex(0).coord(0) == 0.5);
565 BOOST_TEST(mesh->vertex(0).coord(1) == 0.0);
566 BOOST_TEST(mesh->vertex(1).coord(0) == 1.5);
567 BOOST_TEST(mesh->vertex(1).coord(1) == 0.0);
568 BOOST_TEST(mesh->vertex(2).coord(0) == 2.0);
569 BOOST_TEST(mesh->vertex(2).coord(1) == 1.0);
570 BOOST_TEST(mesh->vertex(3).coord(0) == 0.5);
571 BOOST_TEST(mesh->vertex(3).coord(1) == 1.0);
572 } else {
573 BOOST_TEST(mesh->vertex(0).coord(0) == 2.5);
574 BOOST_TEST(mesh->vertex(0).coord(1) == 0.0);
575 BOOST_TEST(mesh->vertex(1).coord(0) == 3.5);
576 BOOST_TEST(mesh->vertex(1).coord(1) == 0.0);
577 BOOST_TEST(mesh->vertex(2).coord(0) == 3.5);
578 BOOST_TEST(mesh->vertex(2).coord(1) == 1.0);
579 BOOST_TEST(mesh->vertex(3).coord(0) == 2.0);
580 BOOST_TEST(mesh->vertex(3).coord(1) == 1.0);
581 }
582 }
583}
584
585BOOST_AUTO_TEST_CASE(TestTwoLevelRepartitioning2D)
586{
587 PRECICE_TEST("Solid"_on(2_ranks).setupIntraComm(), "Fluid"_on(2_ranks).setupIntraComm(), Require::Events);
588 //mesh creation
589 int dimensions = 2;
590 double safetyFactor = 0;
591 mesh::PtrMesh mesh(new mesh::Mesh("mesh", dimensions, testing::nextMeshID()));
592 mesh::PtrMesh receivedMesh(new mesh::Mesh("mesh", dimensions, testing::nextMeshID()));
593
594 testing::ConnectionOptions options;
595 options.useOnlyPrimaryCom = false;
596 options.useTwoLevelInit = true;
597 options.type = testing::ConnectionType::PointToPoint;
598 auto m2n = context.connectPrimaryRanks("Fluid", "Solid", options);
599
600 if (context.isNamed("Solid")) {
601 if (context.isPrimary()) {
602 Eigen::VectorXd position(dimensions);
603 position << -2.0, 0.0;
604 mesh->createVertex(position);
605 position << -1.0, 0.0;
606 mesh->createVertex(position);
607 position << 0.0, 1.0;
608 mesh->createVertex(position);
609 position << -1.0, 1.0;
610 mesh->createVertex(position);
611 position << -2.0, 1.0;
612 mesh->createVertex(position);
613 position << -2.0, 2.0;
614 mesh->createVertex(position);
615 position << -1.0, 2.0;
616 mesh->createVertex(position);
617 position << 0.0, 2.0;
618 mesh->createVertex(position);
619 } else {
620 Eigen::VectorXd position(dimensions);
621 position << -0.5, 0.0;
622 mesh->createVertex(position);
623 position << 1.0, 0.0;
624 mesh->createVertex(position);
625 position << 2.0, 0.0;
626 mesh->createVertex(position);
627 position << 2.0, 1.0;
628 mesh->createVertex(position);
629 position << 1.0, 1.0;
630 mesh->createVertex(position);
631 position << 1.0, 2.0;
632 mesh->createVertex(position);
633 position << 2.0, 2.0;
634 mesh->createVertex(position);
635 }
636 } else {
637 BOOST_TEST(context.isNamed("Fluid"));
638 if (context.isPrimary()) {
639 Eigen::VectorXd position(dimensions);
640 position << 0.0, 0.0;
641 mesh->createVertex(position);
642 position << 0.0, -1.0;
643 mesh->createVertex(position);
644 position << -1.0, 0.0;
645 mesh->createVertex(position);
646 position << -1.0, -1.0;
647 mesh->createVertex(position);
648 position << -2.0, -0.0;
649 mesh->createVertex(position);
650 position << -2.0, -1.0;
651 mesh->createVertex(position);
652 } else {
653 Eigen::VectorXd position(dimensions);
654 position << 0.0, 0.0;
655 mesh->createVertex(position);
656 position << 1.0, 0.0;
657 mesh->createVertex(position);
658 position << 0.0, -1.0;
659 mesh->createVertex(position);
660 position << 1.0, -1.0;
661 mesh->createVertex(position);
662 position << 2.0, 0.0;
663 mesh->createVertex(position);
664 position << 2.0, -1.0;
665 mesh->createVertex(position);
666 }
667 }
668 mesh->computeBoundingBox();
669
670 if (context.isNamed("Solid")) {
671 m2n->createDistributedCommunication(mesh);
672 ProvidedPartition part(mesh);
673 part.addM2N(m2n);
674
675 part.compareBoundingBoxes();
676
677 if (context.isPrimary()) {
678 BOOST_TEST(mesh->getConnectedRanks().size() == 2);
679 BOOST_TEST(mesh->getConnectedRanks().at(0) == 0);
680 BOOST_TEST(mesh->getConnectedRanks().at(1) == 1);
681 } else {
682 BOOST_TEST(mesh->getConnectedRanks().size() == 2);
683 BOOST_TEST(mesh->getConnectedRanks().at(0) == 0);
684 BOOST_TEST(mesh->getConnectedRanks().at(1) == 1);
685 }
686
687 m2n->acceptSecondaryRanksPreConnection("FluidSecondaryRanks", "SolidSecondaryRanks");
688
689 part.communicate();
690 part.compute();
691
692 if (context.isPrimary()) {
693 BOOST_TEST(mesh->getCommunicationMap().at(0).at(0) == 0);
694 BOOST_TEST(mesh->getCommunicationMap().at(0).at(1) == 1);
695 } else {
696 BOOST_TEST(mesh->getCommunicationMap().at(0).at(0) == 0);
697 BOOST_TEST(mesh->getCommunicationMap().at(1).at(0) == 1);
698 BOOST_TEST(mesh->getCommunicationMap().at(1).at(1) == 2);
699 }
700 } else {
701 m2n->createDistributedCommunication(receivedMesh);
702 mapping::PtrMapping boundingFromMapping = mapping::PtrMapping(new mapping::NearestNeighborMapping(mapping::Mapping::CONSISTENT, dimensions));
703 mapping::PtrMapping boundingToMapping = mapping::PtrMapping(new mapping::NearestNeighborMapping(mapping::Mapping::CONSERVATIVE, dimensions));
704 boundingFromMapping->setMeshes(receivedMesh, mesh);
705 boundingToMapping->setMeshes(mesh, receivedMesh);
706
707 ReceivedPartition part(receivedMesh, ReceivedPartition::ON_SECONDARY_RANKS, safetyFactor);
708
709 part.addM2N(m2n);
710
711 part.addFromMapping(boundingFromMapping);
712 part.addToMapping(boundingToMapping);
713
714 part.compareBoundingBoxes();
715
716 m2n->requestSecondaryRanksPreConnection("FluidSecondaryRanks", "SolidSecondaryRanks");
717
718 part.communicate();
719 part.compute();
720 }
721}
722
723BOOST_AUTO_TEST_CASE(TestTwoLevelRepartitioning3D)
724{
725 PRECICE_TEST("Solid"_on(2_ranks).setupIntraComm(), "Fluid"_on(2_ranks).setupIntraComm(), Require::Events);
726
727 //mesh creation
728 int dimensions = 3;
729 double safetyFactor = 0.0;
730 mesh::PtrMesh mesh(new mesh::Mesh("mesh", dimensions, testing::nextMeshID()));
731 mesh::PtrMesh receivedMesh(new mesh::Mesh("mesh", dimensions, testing::nextMeshID()));
732
733 // create the communicator for m2n mesh and communication map exchange
734 testing::ConnectionOptions options;
735 options.useOnlyPrimaryCom = false;
736 options.useTwoLevelInit = true;
737 options.type = testing::ConnectionType::PointToPoint;
738 auto m2n = context.connectPrimaryRanks("Fluid", "Solid", options);
739
740 if (context.isNamed("Solid")) {
741 if (context.isPrimary()) {
742 Eigen::VectorXd position(dimensions);
743 position << -2.0, 0.0, 0.0;
744 mesh->createVertex(position);
745 position << -1.0, 0.0, 0.0;
746 mesh->createVertex(position);
747 position << 0.0, 1.0, 1.0;
748 mesh->createVertex(position);
749 position << -1.0, 1.0, 1.0;
750 mesh->createVertex(position);
751 position << -2.0, 1.0, 1.0;
752 mesh->createVertex(position);
753 } else {
754 Eigen::VectorXd position(dimensions);
755 position << -0.5, 0.0, 0.0;
756 mesh->createVertex(position);
757 position << 1.0, 0.0, 0.0;
758 mesh->createVertex(position);
759 position << 2.0, 0.0, 0.0;
760 mesh->createVertex(position);
761 position << 2.0, 1.0, 1.0;
762 mesh->createVertex(position);
763 position << 1.0, 1.0, 1.0;
764 mesh->createVertex(position);
765 }
766 } else {
767 if (context.isPrimary()) {
768 Eigen::VectorXd position(dimensions);
769 position << 0.0, 0.0, 0.0;
770 mesh->createVertex(position);
771 position << 0.0, -1.0, 1.0;
772 mesh->createVertex(position);
773 position << -1.0, 0.0, 0.0;
774 mesh->createVertex(position);
775 position << -1.0, -1.0, 1.0;
776 mesh->createVertex(position);
777 position << -2.0, -0.0, 0.0;
778 mesh->createVertex(position);
779 position << -2.0, -1.0, 1.0;
780 mesh->createVertex(position);
781 } else {
782 Eigen::VectorXd position(dimensions);
783 position << 0.0, 0.0, 0.0;
784 mesh->createVertex(position);
785 position << 1.0, 0.0, 0.0;
786 mesh->createVertex(position);
787 position << 0.0, -1.0, 1.0;
788 mesh->createVertex(position);
789 position << 1.0, -1.0, 1.0;
790 mesh->createVertex(position);
791 position << 2.0, 0.0, 0.0;
792 mesh->createVertex(position);
793 position << 2.0, -1.0, 0.0;
794 mesh->createVertex(position);
795 }
796 }
797 mesh->computeBoundingBox();
798
799 if (context.isNamed("Solid")) {
800 m2n->createDistributedCommunication(mesh);
801 ProvidedPartition part(mesh);
802 part.addM2N(m2n);
803
804 part.compareBoundingBoxes();
805
806 if (context.isPrimary()) {
807 BOOST_TEST(mesh->getConnectedRanks().size() == 2);
808 BOOST_TEST(mesh->getConnectedRanks().at(0) == 0);
809 BOOST_TEST(mesh->getConnectedRanks().at(1) == 1);
810 } else {
811 BOOST_TEST(mesh->getConnectedRanks().size() == 2);
812 BOOST_TEST(mesh->getConnectedRanks().at(0) == 0);
813 BOOST_TEST(mesh->getConnectedRanks().at(1) == 1);
814 }
815
816 m2n->acceptSecondaryRanksPreConnection("FluidSecondaryRanks", "SolidSecondaryRanks");
817
818 part.communicate();
819 part.compute();
820
821 if (context.isPrimary()) {
822 BOOST_TEST(mesh->getCommunicationMap().at(0).at(0) == 0);
823 BOOST_TEST(mesh->getCommunicationMap().at(0).at(1) == 1);
824 } else {
825 BOOST_TEST(mesh->getCommunicationMap().at(0).at(0) == 0);
826 BOOST_TEST(mesh->getCommunicationMap().at(1).at(0) == 1);
827 BOOST_TEST(mesh->getCommunicationMap().at(1).at(1) == 2);
828 }
829 } else {
830 m2n->createDistributedCommunication(receivedMesh);
831 mapping::PtrMapping boundingFromMapping = mapping::PtrMapping(new mapping::NearestNeighborMapping(mapping::Mapping::CONSISTENT, dimensions));
832 mapping::PtrMapping boundingToMapping = mapping::PtrMapping(new mapping::NearestNeighborMapping(mapping::Mapping::CONSERVATIVE, dimensions));
833 boundingFromMapping->setMeshes(receivedMesh, mesh);
834 boundingToMapping->setMeshes(mesh, receivedMesh);
835
836 ReceivedPartition part(receivedMesh, ReceivedPartition::ON_SECONDARY_RANKS, safetyFactor);
837 part.addM2N(m2n);
838
839 part.addFromMapping(boundingFromMapping);
840 part.addToMapping(boundingToMapping);
841
842 part.compareBoundingBoxes();
843
844 m2n->requestSecondaryRanksPreConnection("FluidSecondaryRanks", "SolidSecondaryRanks");
845
846 part.communicate();
847 part.compute();
848 }
849}
850
851BOOST_AUTO_TEST_SUITE_END()
852BOOST_AUTO_TEST_SUITE_END()
853
854#endif // PRECICE_NO_MPI
BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(PreProcess)
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(TestGatherAndCommunicate2D)
Definition ProvidedPartitionTest.cpp:41
PRECICE_TEST
#define PRECICE_TEST(...)
Definition Testing.hpp:27
std::map::at
T at(T... args)
precice::mapping::NearestNeighborMapping
Mapping using nearest neighboring vertices.
Definition NearestNeighborMapping.hpp:12
precice::mesh::BoundingBox
An axis-aligned bounding box around a (partition of a) mesh.
Definition BoundingBox.hpp:18
precice::mesh::Edge
Linear edge of a mesh, defined by two Vertex objects.
Definition Edge.hpp:16
precice::mesh::Mesh
Container and creator for meshes.
Definition Mesh.hpp:39
precice::mesh::Vertex
Vertex of a mesh.
Definition Vertex.hpp:16
precice::partition::Partition::addFromMapping
void addFromMapping(mapping::PtrMapping fromMapping)
Definition Partition.hpp:47
precice::partition::Partition::addM2N
void addM2N(m2n::PtrM2N m2n)
Definition Partition.hpp:57
precice::partition::Partition::addToMapping
void addToMapping(mapping::PtrMapping toMapping)
Definition Partition.hpp:52
precice::partition::ProvidedPartition
A partition that is provided by the participant.
Definition ProvidedPartition.hpp:18
precice::partition::ProvidedPartition::compute
void compute() override
All distribution data structures are set up.
Definition ProvidedPartition.cpp:228
precice::partition::ProvidedPartition::communicate
void communicate() override
The mesh is gathered and sent to another participant (if required)
Definition ProvidedPartition.cpp:35
precice::partition::ProvidedPartition::compareBoundingBoxes
void compareBoundingBoxes() override
Intersections between bounding boxes around each rank are computed.
Definition ProvidedPartition.cpp:241
precice::partition::ReceivedPartition
A partition that is computed from a mesh received from another participant.
Definition ReceivedPartition.hpp:25
precice::partition::ReceivedPartition::compute
void compute() override
The partition is computed, i.e. the mesh re-partitioned if required and all data structures are set u...
Definition ReceivedPartition.cpp:90
precice::partition::ReceivedPartition::compareBoundingBoxes
void compareBoundingBoxes() override
Intersections between bounding boxes around each rank are computed.
Definition ReceivedPartition.cpp:378
precice::partition::ReceivedPartition::ON_SECONDARY_RANKS
@ ON_SECONDARY_RANKS
Filter after communication on all secondary ranks.
Definition ReceivedPartition.hpp:39
precice::partition::ReceivedPartition::communicate
void communicate() override
The mesh is communicated between both primary ranks (if required)
Definition ReceivedPartition.cpp:43
std::map::emplace
T emplace(T... args)
precice::com::receiveBoundingBoxMap
void receiveBoundingBoxMap(Communication &communication, int rankSender, mesh::Mesh::BoundingBoxMap &bbm)
Definition Extra.cpp:63
precice::com::sendConnectionMap
void sendConnectionMap(Communication &communication, int rankReceiver, const mesh::Mesh::ConnectionMap &cm)
Definition Extra.cpp:28
precice::mapping::PtrMapping
std::shared_ptr< Mapping > PtrMapping
Definition SharedPointer.hpp:11
precice::mesh
provides Mesh, Data and primitives.
Definition ScaleActionTest.cpp:20
precice
Main namespace of the precice library.
Definition Acceleration.cpp:5
std::partition
T partition(T... args)