Merge branch 'extendWriter' into 'develop'

Add vtk writer for lists of coordinates

See merge request irmb/VirtualFluids_dev!249

src/basics/writer/WbWriter.h

@@ -40,6 +40,7 @@
 #include <string>
 #include <vector>
 
+#include <basics/DataTypes.h>
 #include <basics/utilities/UbException.h>
 #include <basics/utilities/UbSystem.h>
 #include <basics/utilities/UbTuple.h>
@@ -83,6 +84,16 @@ public:
     {
         throw UbException(UB_EXARGS, "not implemented for " + (std::string) typeid(*this).name());
     }
+    virtual std::string writePolyLines(const std::string & /*filename*/, real*  /*coordinatesX*/,
+                                                            real*  /*coordinatesY*/, real* /*coordinatesZ*/, uint  /*numberOfCoordinates*/)
+    {
+        throw UbException(UB_EXARGS, "not implemented for " + (std::string) typeid(*this).name());
+    }
+    virtual std::string writePolyLines(const std::string & /*filename*/, std::vector<real>&  /*coordinatesX*/,
+                                                            std::vector<real>&  /*coordinatesY*/,  std::vector<real>& /*coordinatesZ*/)
+    {
+        throw UbException(UB_EXARGS, "not implemented for " + (std::string) typeid(*this).name());
+    }
     virtual std::string writeLinesWithNodeData(const std::string & /*filename*/, std::vector<UbTupleFloat3> & /*nodes*/,
                                                std::vector<UbTupleInt2> & /*lines*/)
     {

src/basics/writer/WbWriterVtkXmlBinary.cpp

@@ -328,6 +328,32 @@ string WbWriterVtkXmlBinary::writeLines(const string &filename, vector<UbTupleFl
     return vtkfilename;
 }
 
+/*===============================================================================*/
+std::string WbWriterVtkXmlBinary::writePolyLines(const std::string &filename,
+                                                 real *coordinatesX, real *coordinatesY, real *coordinatesZ,
+                                                 uint numberOfCoordinates)
+{
+    std::vector<UbTupleFloat3> nodes;
+    std::vector<UbTupleInt2> lines;
+
+    auto actualNodeNumber = 0;
+
+    for (uint i = 0; i < numberOfCoordinates - 1; i++) {
+        nodes.push_back(makeUbTuple(float(coordinatesX[i]), float(coordinatesY[i]), float(coordinatesZ[i])));
+        nodes.push_back(makeUbTuple(float(coordinatesX[i + 1]), float(coordinatesY[i + 1]), float(coordinatesZ[i + 1])));
+        lines.push_back(makeUbTuple(actualNodeNumber, actualNodeNumber + 1));
+        actualNodeNumber += 2;
+    }
+    return WbWriterVtkXmlBinary::writeLines(filename, nodes, lines);
+}
+
+std::string WbWriterVtkXmlBinary::writePolyLines(const std::string & filename, std::vector<real>& coordinatesX,
+                                                 std::vector<real>& coordinatesY,  std::vector<real>& coordinatesZ)
+{
+    return this->writePolyLines(filename, coordinatesX.data(), coordinatesY.data(), coordinatesZ.data(),
+                                                                       (uint)coordinatesX.size());
+}
+
 /*===============================================================================*/
 string WbWriterVtkXmlBinary::writeLinesWithLineData(const string &filename, vector<UbTupleFloat3> &nodes,
                                                     vector<UbTupleInt2> &lines, vector<string> &datanames,

src/basics/writer/WbWriterVtkXmlBinary.h

@@ -91,6 +91,10 @@ public:
     // nodenumbering must start with 0!
     std::string writeLines(const std::string &filename, std::vector<UbTupleFloat3> &nodes,
                            std::vector<UbTupleInt2> &lines) override;
+    std::string writePolyLines(const std::string &filename, real* coordinatesX,
+                                                    real* coordinatesY, real*coordinatesZ, uint numberOfCoordinates) override;
+    std::string writePolyLines(const std::string & filename, std::vector<real>& coordinatesX,
+                                                    std::vector<real>& coordinatesY,  std::vector<real>& coordinatesZ) override;
     // std::string writeLinesWithNodeData(const std::string& filename,std::vector<UbTupleFloat3 >& nodes,
     // std::vector<UbTupleInt2 >& lines, std::vector< std::string >& datanames, std::vector< std::vector< double > >&
     // nodedata);

src/gpu/VirtualFluids_GPU/PreCollisionInteractor/ActuatorFarm.h

@@ -154,6 +154,7 @@ private:
     void rotateBlades(real angle, uint turbineID);
 
     void writeBladeCoords(uint t);
+    void writeBladeCoordsToVtkForDebug(const std::string& filename);
     void writeBladeForces(uint t);
     void writeBladeVelocities(uint t);
 

src/gpu/VirtualFluids_GPU/PreCollisionInteractor/ActuatorFarmInlines.h

@@ -36,13 +36,24 @@
 
 #include "basics/DataTypes.h"
 
-__host__ __device__ __inline__ uint calcNodeIndexInBladeArrays(uint bladeNode, uint numberOfNodesPerBlade, uint blade, uint numberOfBlades, uint turbine, uint numberOfTurbines)
+struct TurbineNodeIndex {
+    uint turbine;
+    uint blade;
+    uint bladeNode;
+};
+
+__host__ __device__ __inline__ uint calcNodeIndexInBladeArrays(uint bladeNode, uint numberOfNodesPerBlade, uint blade, uint numberOfBlades, uint turbine)
 {
     // see https://git.rz.tu-bs.de/irmb/VirtualFluids_dev/-/merge_requests/248 for visualization
     return bladeNode + numberOfNodesPerBlade * (blade + numberOfBlades * turbine);
 }
 
-__host__ __device__ __inline__ void calcTurbineBladeAndBladeNode(uint node, uint &bladeNode, uint numberOfNodesPerBlade, uint &blade, uint numberOfBlades, uint &turbine, uint numberOfTurbines)
+__host__ __device__ __inline__ uint calcNodeIndexInBladeArrays(const TurbineNodeIndex &turbineNodeIndex, uint numberOfNodesPerBlade, uint numberOfBlades)
+{
+    return calcNodeIndexInBladeArrays(turbineNodeIndex.bladeNode, numberOfNodesPerBlade, turbineNodeIndex.blade, numberOfBlades, turbineNodeIndex.turbine);
+}
+
+__host__ __device__ __inline__ void calcTurbineBladeAndBladeNode(uint node, uint &bladeNode, uint numberOfNodesPerBlade, uint &blade, uint numberOfBlades, uint &turbine)
 {
     // see https://git.rz.tu-bs.de/irmb/VirtualFluids_dev/-/merge_requests/248 for visualization
     turbine = node / (numberOfNodesPerBlade * numberOfBlades);
@@ -51,5 +62,13 @@ __host__ __device__ __inline__ void calcTurbineBladeAndBladeNode(uint node, uint
     uint y_off = numberOfNodesPerBlade * blade + x_off;
     bladeNode = node - y_off;
 }
+__host__ __device__ __inline__ TurbineNodeIndex calcTurbineBladeAndBladeNode(uint node, uint numberOfNodesPerBlade, uint numberOfBlades)
+{
+    uint turbine;
+    uint blade;
+    uint bladeNode;
+    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
+    return { /*.turbine = */ turbine, /*.blade = */ blade, /*.bladeNode = */ bladeNode }; // Designated initializers are a C++ 20 feature
+}
 
 #endif

src/gpu/VirtualFluids_GPU/PreCollisionInteractor/ActuatorFarmInlinesTest.cpp

@@ -6,48 +6,59 @@ TEST(ActuatorFarmInlinesTest, calcNodeIndexInBladeArrays)
 {
     const uint numberOfNodesPerBlade = 4;
     const uint numberOfBlades = 3;
-    const uint numberOfTurbines = 2;
 
     // first node on first blade
     uint bladeNode = 0;
     uint blade = 0;
     uint turbine = 0;
-    auto nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    auto nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
+    EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(0));
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays({turbine, blade, bladeNode}, numberOfNodesPerBlade, numberOfBlades);
     EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(0));
 
     // last node on first blade
     bladeNode = 3;
     blade = 0;
     turbine = 0;
-    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
+    EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(3));
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays({turbine, blade, bladeNode}, numberOfNodesPerBlade, numberOfBlades);
     EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(3));
 
     // first node on third blade
     bladeNode = 0;
     blade = 2;
     turbine = 0;
-    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
+    EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(8));
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays({turbine, blade, bladeNode}, numberOfNodesPerBlade, numberOfBlades);
     EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(8));
 
     // last node on third blade, also last node on first turbine
     bladeNode = 3;
     blade = 2;
     turbine = 0;
-    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
+    EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(11));
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays({turbine, blade, bladeNode}, numberOfNodesPerBlade, numberOfBlades);
     EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(11));
 
     // first node on second turbine
     bladeNode = 0;
     blade = 0;
     turbine = 1;
-    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
+    EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(12));
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays({turbine, blade, bladeNode}, numberOfNodesPerBlade, numberOfBlades);
     EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(12));
 
     // last node on second turbine
     bladeNode = 3;
     blade = 2;
     turbine = 1;
-    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays(bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
+    EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(23));
+    nodeIndexInBladeArrays = calcNodeIndexInBladeArrays({turbine, blade, bladeNode}, numberOfNodesPerBlade, numberOfBlades);
     EXPECT_THAT(nodeIndexInBladeArrays, testing::Eq(23));
 }
 
@@ -55,45 +66,70 @@ TEST(ActuatorFarmInlinesTest, calcTurbineBladeAndBladeNode)
 {
     const uint numberOfNodesPerBlade = 4;
     const uint numberOfBlades = 3;
-    const uint numberOfTurbines = 2;
 
     uint bladeNode;
     uint blade;
     uint turbine;
 
+    TurbineNodeIndex result;
+
     uint node = 0; // first node on first blade
-    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
     EXPECT_THAT(bladeNode, testing::Eq(0));
     EXPECT_THAT(blade, testing::Eq(0));
     EXPECT_THAT(turbine, testing::Eq(0));
+    result = calcTurbineBladeAndBladeNode(node, numberOfNodesPerBlade, numberOfBlades);
+    EXPECT_THAT(result.bladeNode, testing::Eq(0));
+    EXPECT_THAT(result.blade, testing::Eq(0));
+    EXPECT_THAT(result.turbine, testing::Eq(0));
 
     node = 3; // last node on first blade
-    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
     EXPECT_THAT(bladeNode, testing::Eq(3));
     EXPECT_THAT(blade, testing::Eq(0));
     EXPECT_THAT(turbine, testing::Eq(0));
+    result = calcTurbineBladeAndBladeNode(node, numberOfNodesPerBlade, numberOfBlades);
+    EXPECT_THAT(result.bladeNode, testing::Eq(3));
+    EXPECT_THAT(result.blade, testing::Eq(0));
+    EXPECT_THAT(result.turbine, testing::Eq(0));
 
     node = 8; // first node on third blade
-    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
     EXPECT_THAT(bladeNode, testing::Eq(0));
     EXPECT_THAT(blade, testing::Eq(2));
     EXPECT_THAT(turbine, testing::Eq(0));
+    result = calcTurbineBladeAndBladeNode(node, numberOfNodesPerBlade, numberOfBlades);
+    EXPECT_THAT(result.bladeNode, testing::Eq(0));
+    EXPECT_THAT(result.blade, testing::Eq(2));
+    EXPECT_THAT(result.turbine, testing::Eq(0));
 
     node = 11; // last node on third blade, also last node on first turbine
-    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
     EXPECT_THAT(bladeNode, testing::Eq(3));
     EXPECT_THAT(blade, testing::Eq(2));
     EXPECT_THAT(turbine, testing::Eq(0));
+    result = calcTurbineBladeAndBladeNode(node, numberOfNodesPerBlade, numberOfBlades);
+    EXPECT_THAT(result.bladeNode, testing::Eq(3));
+    EXPECT_THAT(result.blade, testing::Eq(2));
+    EXPECT_THAT(result.turbine, testing::Eq(0));
 
     node = 12; // first node on second turbine
-    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
     EXPECT_THAT(bladeNode, testing::Eq(0));
     EXPECT_THAT(blade, testing::Eq(0));
     EXPECT_THAT(turbine, testing::Eq(1));
+    result = calcTurbineBladeAndBladeNode(node, numberOfNodesPerBlade, numberOfBlades);
+    EXPECT_THAT(result.bladeNode, testing::Eq(0));
+    EXPECT_THAT(result.blade, testing::Eq(0));
+    EXPECT_THAT(result.turbine, testing::Eq(1));
 
     node = 23; // last node on second turbine
-    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine, numberOfTurbines);
+    calcTurbineBladeAndBladeNode(node, bladeNode, numberOfNodesPerBlade, blade, numberOfBlades, turbine);
     EXPECT_THAT(bladeNode, testing::Eq(3));
     EXPECT_THAT(blade, testing::Eq(2));
     EXPECT_THAT(turbine, testing::Eq(1));
+    result = calcTurbineBladeAndBladeNode(node, numberOfNodesPerBlade, numberOfBlades);
+    EXPECT_THAT(result.bladeNode, testing::Eq(3));
+    EXPECT_THAT(result.blade, testing::Eq(2));
+    EXPECT_THAT(result.turbine, testing::Eq(1));
 }