Add tests for findEdgeNodesCommMultiGPU

src/gpu/VirtualFluids_GPU/Parameter/ParameterTest.cpp

@@ -155,4 +155,221 @@ TEST(ParameterTest, check_all_Parameter_CanBePassedToConstructor)
 }
 
 
+TEST(ParameterTest, findEdgeNodesXY_shouldReturnCorrectVector)
+{
+
+    std::filesystem::path filePath = __FILE__;
+    filePath.replace_filename("parameterTest.cfg");
+    vf::basics::ConfigurationFile config;
+    config.load(filePath.string());
+    Parameter para(config, 1, 0);
+
+    para.initLBMSimulationParameter();
+
+    int level = 0;
+    para.parH[level]->recvProcessNeighborX.push_back(ProcessNeighbor27());
+    para.parH[level]->sendProcessNeighborY.push_back(ProcessNeighbor27());
+    para.parH[level]->sendProcessNeighborY.push_back(ProcessNeighbor27());
+
+    int numRecvNeighbor = (int)para.parH[level]->recvProcessNeighborX.size() - 1;
+    int numSendNeighbor = (int)para.parH[level]->sendProcessNeighborY.size() - 1;
+
+    const int sizeRecv                                                    = 6;
+    const int sizeSend                                                    = 10;
+    para.parH[level]->recvProcessNeighborX[numRecvNeighbor].numberOfNodes = sizeRecv;
+    para.parH[level]->sendProcessNeighborY[numSendNeighbor].numberOfNodes = sizeSend;
+
+    int recvNeighbors[sizeRecv]                                   = { 1, 2, 3, 4, 5, 6 };
+    para.parH[level]->recvProcessNeighborX[numRecvNeighbor].index = recvNeighbors;
+
+    int sendNeighbors[sizeSend]                                   = { 20, 1, 21, 22, 6, 23, 5, 24, 25, 26 };
+    para.parH[level]->sendProcessNeighborY[numSendNeighbor].index = sendNeighbors;
+
+
+    para.findEdgeNodesCommMultiGPU();
+
+
+    std::vector<std::pair<int, int>> expectedEdgeNodesXtoYRecv = { std::pair(numRecvNeighbor, 0),
+                                                                     std::pair(numRecvNeighbor, 4),
+                                                                     std::pair(numRecvNeighbor, 5) };
+
+    std::vector<std::pair<int, int>> expectedEdgeNodesXtoYSend = { std::pair(numSendNeighbor, 1),
+                                                                     std::pair(numSendNeighbor, 6),
+                                                                     std::pair(numSendNeighbor, 4) };
+
+    EXPECT_THAT(para.parH[level]->edgeNodesXtoY.size(), testing::Eq(expectedEdgeNodesXtoYRecv.size()));
+
+    bool vectorsAreIdentical = true;
+    for (int i = 0; i < (int)expectedEdgeNodesXtoYRecv.size(); i++) {
+        if (para.parH[level]->edgeNodesXtoY[i].indexOfProcessNeighborRecv != expectedEdgeNodesXtoYRecv[i].first) {
+            vectorsAreIdentical = false;
+            break;
+        }
+        if (para.parH[level]->edgeNodesXtoY[i].indexInRecvBuffer != expectedEdgeNodesXtoYRecv[i].second) {
+            vectorsAreIdentical = false;
+            break;
+        }
+    }
+
+    EXPECT_TRUE(vectorsAreIdentical);
+
+    vectorsAreIdentical = true;
+    for (int i = 0; i < (int)expectedEdgeNodesXtoYSend.size(); i++) {
+        if (para.parH[level]->edgeNodesXtoY[i].indexOfProcessNeighborSend != expectedEdgeNodesXtoYSend[i].first) {
+            vectorsAreIdentical = false;
+            break;
+        }
+        if (para.parH[level]->edgeNodesXtoY[i].indexInSendBuffer != expectedEdgeNodesXtoYSend[i].second) {
+            vectorsAreIdentical = false;
+            break;
+        }
+    }
+
+    EXPECT_TRUE(vectorsAreIdentical);
+}
+
+TEST(ParameterTest, findEdgeNodesXZ_shouldReturnCorrectVector)
+{
+
+    std::filesystem::path filePath = __FILE__;
+    filePath.replace_filename("parameterTest.cfg");
+    vf::basics::ConfigurationFile config;
+    config.load(filePath.string());
+    Parameter para(config, 1, 0);
+
+    para.initLBMSimulationParameter();
+
+    int level = 0;
+    para.parH[level]->recvProcessNeighborX.push_back(ProcessNeighbor27());
+    para.parH[level]->sendProcessNeighborZ.push_back(ProcessNeighbor27());
+    para.parH[level]->sendProcessNeighborZ.push_back(ProcessNeighbor27());
+
+    int numRecvNeighbor = (int)para.parH[level]->recvProcessNeighborX.size() - 1;
+    int numSendNeighbor = (int)para.parH[level]->sendProcessNeighborZ.size() - 1;
+
+    const int sizeRecv = 10;
+    const int sizeSend = 6;
+
+    para.parH[level]->recvProcessNeighborX[numRecvNeighbor].numberOfNodes = sizeRecv;
+    para.parH[level]->sendProcessNeighborZ[numSendNeighbor].numberOfNodes = sizeSend;
+
+    int recvNeighbors[sizeRecv]                                   = { 20, 1, 21, 22, 6, 23, 5, 24, 25, 26 };
+    para.parH[level]->recvProcessNeighborX[numRecvNeighbor].index = recvNeighbors;
+
+    int sendNeighbors[sizeSend]                                   = { 1, 2, 3, 4, 5, 6 };
+    para.parH[level]->sendProcessNeighborZ[numSendNeighbor].index = sendNeighbors;
+
+
+    para.findEdgeNodesCommMultiGPU();
+
+
+    std::vector<std::pair<int, int>> expectedEdgeNodesXtoZRecv = { std::pair(numRecvNeighbor, 1),
+                                                                     std::pair(numRecvNeighbor, 4),
+                                                                     std::pair(numRecvNeighbor, 6) };
+    std::vector<std::pair<int, int>> expectedEdgeNodesXtoZSend = { std::pair(numSendNeighbor, 0),
+                                                                     std::pair(numSendNeighbor, 5),
+                                                                     std::pair(numSendNeighbor, 4) };
+
+    EXPECT_THAT(para.parH[level]->edgeNodesXtoZ.size(), testing::Eq(expectedEdgeNodesXtoZRecv.size()));
+
+    bool vectorsAreIdentical = true;
+    for (int i = 0; i < (int)expectedEdgeNodesXtoZRecv.size(); i++) {
+        if (para.parH[level]->edgeNodesXtoZ[i].indexOfProcessNeighborRecv != expectedEdgeNodesXtoZRecv[i].first) {
+            vectorsAreIdentical = false;
+            break;
+        }
+        if (para.parH[level]->edgeNodesXtoZ[i].indexInRecvBuffer != expectedEdgeNodesXtoZRecv[i].second) {
+            vectorsAreIdentical = false;
+            break;
+        }
+    }
+
+    EXPECT_TRUE(vectorsAreIdentical);
+
+    vectorsAreIdentical = true;
+    for (int i = 0; i < (int)expectedEdgeNodesXtoZRecv.size(); i++) {
+        if (para.parH[level]->edgeNodesXtoZ[i].indexOfProcessNeighborSend != expectedEdgeNodesXtoZSend[i].first){
+            vectorsAreIdentical = false;
+            break;
+        }
+        if (para.parH[level]->edgeNodesXtoZ[i].indexInSendBuffer != expectedEdgeNodesXtoZSend[i].second) {
+            vectorsAreIdentical = false;
+            break;
+        }
+    }
+
+    EXPECT_TRUE(vectorsAreIdentical);
+}
+
+TEST(ParameterTest, findEdgeNodesYZ_shouldReturnCorrectVector)
+{
+
+    std::filesystem::path filePath = __FILE__;
+    filePath.replace_filename("parameterTest.cfg");
+    vf::basics::ConfigurationFile config;
+    config.load(filePath.string());
+    Parameter para(config, 1, 0);
+
+    para.initLBMSimulationParameter();
+
+    int level = 0;
+
+    para.parH[level]->recvProcessNeighborY.push_back(ProcessNeighbor27());
+    para.parH[level]->sendProcessNeighborZ.push_back(ProcessNeighbor27());
+    para.parH[level]->sendProcessNeighborZ.push_back(ProcessNeighbor27());
+
+    const int sizeRecv  = 10;
+    const int sizeSend1 = 6;
+    const int sizeSend2 = 5;
+
+    para.parH[level]->recvProcessNeighborY[0].numberOfNodes = sizeRecv;
+    para.parH[level]->sendProcessNeighborZ[0].numberOfNodes = sizeSend1;
+    para.parH[level]->sendProcessNeighborZ[1].numberOfNodes = sizeSend2;
+
+    int recvNeighbors[sizeRecv]                     = { 20, 1, 9, 22, 6, 23, 5, 24, 11, 26 };
+    para.parH[level]->recvProcessNeighborY[0].index = recvNeighbors;
+
+    int sendNeighbors1[sizeSend1]                   = { 1, 2, 3, 4, 5, 6 };
+    int sendNeighbors2[sizeSend2]                   = { 7, 8, 9, 10, 11 };
+    para.parH[level]->sendProcessNeighborZ[0].index = sendNeighbors1;
+    para.parH[level]->sendProcessNeighborZ[1].index = sendNeighbors2;
+
+
+    para.findEdgeNodesCommMultiGPU();
+
+
+    std::vector<std::pair<int, int>> expectedEdgeNodesXtoZRecv = { std::pair(0, 1), std::pair(0, 2), std::pair(0, 4),
+                                                                     std::pair(0, 6), std::pair(0, 8) };
+    std::vector<std::pair<int, int>> expectedEdgeNodesXtoZSend = { std::pair(0, 0), std::pair(1, 2), std::pair(0, 5),
+                                                                     std::pair(0, 4), std::pair(1, 4) };
+
+    EXPECT_THAT(para.parH[level]->edgeNodesYtoZ.size(), testing::Eq(expectedEdgeNodesXtoZRecv.size()));
+
+    bool vectorsAreIdentical = true;
+    for (int i = 0; i < (int)expectedEdgeNodesXtoZRecv.size(); i++) {
+        if (para.parH[level]->edgeNodesYtoZ[i].indexOfProcessNeighborRecv != expectedEdgeNodesXtoZRecv[i].first) {
+            vectorsAreIdentical = false;
+            break;
+        }
+        if (para.parH[level]->edgeNodesYtoZ[i].indexInRecvBuffer != expectedEdgeNodesXtoZRecv[i].second) {
+            vectorsAreIdentical = false;
+            break;
+        }
+    }
+
+    EXPECT_TRUE(vectorsAreIdentical);
+
+    vectorsAreIdentical = true;
+    for (int i = 0; i < (int)expectedEdgeNodesXtoZRecv.size(); i++) {
+        if (para.parH[level]->edgeNodesYtoZ[i].indexOfProcessNeighborSend != expectedEdgeNodesXtoZSend[i].first) {
+            vectorsAreIdentical = false;
+            break;
+        }
+        if (para.parH[level]->edgeNodesYtoZ[i].indexInSendBuffer != expectedEdgeNodesXtoZSend[i].second) {
+            vectorsAreIdentical = false;
+            break;
+        }
+    }
 
+    EXPECT_TRUE(vectorsAreIdentical);
+}
\ No newline at end of file