diff --git a/src/gpu/VirtualFluids_GPU/Output/NeighborDebugWriter.hpp b/src/gpu/VirtualFluids_GPU/Output/NeighborDebugWriter.hpp
index d325a0c9777954705d1b8eb5f848ac5207633641..57139d25ae4d046e1dd1be1f3ef5e179daf0872e 100644
--- a/src/gpu/VirtualFluids_GPU/Output/NeighborDebugWriter.hpp
+++ b/src/gpu/VirtualFluids_GPU/Output/NeighborDebugWriter.hpp
@@ -5,44 +5,48 @@
#include "Logger.h"
#include "Parameter/Parameter.h"
#include "basics/utilities/UbSystem.h"
-#include "grid/NodeValues.h"
+#include "gpu/GridGenerator/grid/NodeValues.h"
#include "lbm/constants/D3Q27.h"
#include <basics/writer/WbWriterVtkXmlBinary.h>
-#include "Utilities/FindNeighbors.h"
-#include "VirtualFluids_GPU/Communication/Communicator.h"
#include "Core/StringUtilities/StringUtil.h"
+#include "Utilities/FindNeighbors.h"
+#include "gpu/VirtualFluids_GPU/Communication/Communicator.h"
namespace NeighborDebugWriter
{
-inline void writeNeighborLinkLines(Parameter *para, const int level, const unsigned long long numberOfNodes, const int direction,
- const std::string &name)
+inline void writeNeighborLinkLines(LBMSimulationParameter *parH, int direction, const std::string &name,
+ WbWriter *writer)
{
VF_LOG_INFO("Write node links in direction {}.", direction);
- std::vector<UbTupleFloat3> nodes(numberOfNodes * 2);
- std::vector<UbTupleInt2> cells(numberOfNodes);
+
+ const unsigned long long numberOfNodes = parH->numberOfNodes;
+ std::vector<UbTupleFloat3> nodes;
+ nodes.reserve(numberOfNodes);
+ std::vector<UbTupleInt2> cells;
+ cells.reserve(numberOfNodes/2);
for (size_t position = 0; position < numberOfNodes; position++) {
- if (para->getParH(level)->typeOfGridNode[position] != GEO_FLUID)
+ if (parH->typeOfGridNode[position] != GEO_FLUID)
continue;
- const double x1 = para->getParH(level)->coordinateX[position];
- const double x2 = para->getParH(level)->coordinateY[position];
- const double x3 = para->getParH(level)->coordinateZ[position];
+ const double x1 = parH->coordinateX[position];
+ const double x2 = parH->coordinateY[position];
+ const double x3 = parH->coordinateZ[position];
- const uint positionNeighbor = getNeighborIndex(para->getParH(level).get(), (uint)position, direction);
+ const uint positionNeighbor = getNeighborIndex(parH, (uint)position, direction);
- const double x1Neighbor = para->getParH(level)->coordinateX[positionNeighbor];
- const double x2Neighbor = para->getParH(level)->coordinateY[positionNeighbor];
- const double x3Neighbor = para->getParH(level)->coordinateZ[positionNeighbor];
+ const double x1Neighbor = parH->coordinateX[positionNeighbor];
+ const double x2Neighbor = parH->coordinateY[positionNeighbor];
+ const double x3Neighbor = parH->coordinateZ[positionNeighbor];
nodes.emplace_back(float(x1), float(x2), float(x3));
nodes.emplace_back(float(x1Neighbor), float(x2Neighbor), float(x3Neighbor));
cells.emplace_back((int)nodes.size() - 2, (int)nodes.size() - 1);
}
- WbWriterVtkXmlBinary::getInstance()->writeLines(name, nodes, cells);
+ writer->writeLines(name, nodes, cells);
}
inline void writeNeighborLinkLinesDebug(Parameter *para)
@@ -51,7 +55,7 @@ inline void writeNeighborLinkLinesDebug(Parameter *para)
for (size_t direction = vf::lbm::dir::STARTDIR; direction <= vf::lbm::dir::ENDDIR; direction++) {
const std::string fileName = para->getFName() + "_" + StringUtil::toString<int>(level) + "_Link_" +
std::to_string(direction) + "_Debug.vtk";
- writeNeighborLinkLines(para, level, para->getParH(level)->numberOfNodes, (int)direction, fileName);
+ writeNeighborLinkLines(para->getParH(level).get(), (int)direction, fileName, WbWriterVtkXmlBinary::getInstance());
}
}
}
diff --git a/src/gpu/VirtualFluids_GPU/Output/NeighborDebugWriterTest.cpp b/src/gpu/VirtualFluids_GPU/Output/NeighborDebugWriterTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a19ed3d723f28998f5d27cd15ebf4bab8ba061c4
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Output/NeighborDebugWriterTest.cpp
@@ -0,0 +1,79 @@
+#include <gmock/gmock.h>
+#include "NeighborDebugWriter.hpp"
+#include "gpu/VirtualFluids_GPU/Utilities/testUtilitiesGPU.h"
+
+class WbWriterSpy : public WbWriter
+{
+public:
+ std::string writeLines(const std::string & /*filename*/, std::vector<UbTupleFloat3> &nodes,
+ std::vector<UbTupleInt2> &lines) override
+ {
+ this->nodes = nodes;
+ this->lines = lines;
+ return "";
+ }
+ std::vector<UbTupleFloat3> nodes;
+ std::vector<UbTupleInt2> lines;
+
+ std::string getFileExtension() override { return ""; }
+};
+
+class NeighborDebugWriterTest : public testing::Test
+{
+protected:
+ void SetUp() override
+ {
+ typeOfGridNode = std::vector<uint>(numberOfNodes, GEO_FLUID);
+ neighbors = std::vector<uint>(numberOfNodes, 2);
+ coordinates = std::vector<real>(numberOfNodes, 1.0);
+ coordinates[2] = 3.0;
+
+ parH->numberOfNodes = numberOfNodes;
+ parH->coordinateX = coordinates.data();
+ parH->coordinateY = coordinates.data();
+ parH->coordinateZ = coordinates.data();
+ parH->neighborX = neighbors.data();
+ parH->typeOfGridNode = typeOfGridNode.data();
+ }
+
+ const int level = 0;
+ const unsigned long long numberOfNodes = 3;
+ const uint direction = vf::lbm::dir::DIR_P00; // x
+ std::unique_ptr<LBMSimulationParameter> parH = std::make_unique<LBMSimulationParameter>();
+ WbWriterSpy writerSpy;
+ std::vector<uint> typeOfGridNode;
+ std::vector<uint> neighbors;
+ std::vector<real> coordinates;
+};
+
+TEST_F(NeighborDebugWriterTest, writeNeighborLinkLines_onlyFLuidNodes_writesAllNodes)
+{
+ UbTupleFloat3 oneCoord(1.0, 1.0, 1.0);
+ UbTupleFloat3 threeCoord(3.0, 3.0, 3.0);
+ std::vector<UbTupleFloat3> expectedNodes = { oneCoord, threeCoord, oneCoord, threeCoord, threeCoord, threeCoord };
+ std::vector<UbTupleInt2> expectedLines = { UbTupleInt2(0, 1), UbTupleInt2(2, 3), UbTupleInt2(4, 5) };
+
+ NeighborDebugWriter::writeNeighborLinkLines(parH.get(), direction, "name", &writerSpy);
+
+ EXPECT_THAT(writerSpy.nodes.size(), testing::Eq(numberOfNodes * 2));
+ EXPECT_THAT(writerSpy.lines.size(), testing::Eq(numberOfNodes));
+ EXPECT_THAT(writerSpy.nodes, testing::Eq(expectedNodes));
+ EXPECT_THAT(writerSpy.lines, testing::Eq(expectedLines));
+}
+
+TEST_F(NeighborDebugWriterTest, writeNeighborLinkLines_fluidAndSolidNodes_writesOnlyFluidNodes)
+{
+ typeOfGridNode[2] = GEO_SOLID;
+
+ UbTupleFloat3 oneCoord(1.0, 1.0, 1.0);
+ UbTupleFloat3 threeCoord(3.0, 3.0, 3.0);
+ std::vector<UbTupleFloat3> expectedNodes = { oneCoord, threeCoord, oneCoord, threeCoord};
+ std::vector<UbTupleInt2> expectedLines = { UbTupleInt2(0, 1), UbTupleInt2(2, 3)};
+
+ NeighborDebugWriter::writeNeighborLinkLines(parH.get(), direction, "name", &writerSpy);
+
+ EXPECT_THAT(writerSpy.nodes.size(), testing::Eq((numberOfNodes-1) * 2));
+ EXPECT_THAT(writerSpy.lines.size(), testing::Eq(numberOfNodes-1));
+ EXPECT_THAT(writerSpy.nodes, testing::Eq(expectedNodes));
+ EXPECT_THAT(writerSpy.lines, testing::Eq(expectedLines));
+}