Refactored Malo's code to avoid DRY

I also added unit tests for the TiglWingHelperFunctions. Addresses #827
DLR-SC · Nov 12, 2021 · b3c5ab4 · b3c5ab4
1 parent 7b01138
commit b3c5ab4
Show file tree

Hide file tree

Showing 4 changed files with 112 additions and 37 deletions.
diff --git a/src/wing/CCPACSWing.cpp b/src/wing/CCPACSWing.cpp
@@ -539,8 +539,8 @@ double CCPACSWing::GetReferenceArea(TiglSymmetryAxis symPlane) const
 
 double CCPACSWing::GetReferenceArea() const
 {
-    TiglAxis spanDir = winghelper::GetMajorDirection(*this);
-    TiglAxis deepDir = winghelper::GetDeepDirection(*this);
+    TiglAxis spanDir = winghelper::GetWingSpanAxis(*this);
+    TiglAxis deepDir = winghelper::GetWingDepthAxis(*this);
 
     if (spanDir == TIGL_Y_AXIS && deepDir == TIGL_X_AXIS) {
         return GetReferenceArea(TIGL_X_Y_PLANE);

diff --git a/src/wing/TiglWingHelperFunctions.cpp b/src/wing/TiglWingHelperFunctions.cpp
@@ -23,6 +23,35 @@
 #include "tigl.h"
 #include "CCPACSWingSegment.h"
 
+namespace
+{
+    struct CumulatedLength
+    {
+        gp_XYZ depth{0., 0., 0.};
+        gp_XYZ span{0., 0., 0.};
+    };
+
+
+    // Helper function to compute accumulated depth and span of the wing
+    CumulatedLength GetCumulatedLength(const tigl::CCPACSWing& wing)
+    {
+        CumulatedLength length;
+        for (int i = 1; i <= wing.GetSegmentCount(); ++i) {
+            const auto& segment = wing.GetSegment(i);
+            gp_XYZ dirSpan  = segment.GetChordPoint(1, 0).XYZ() - segment.GetChordPoint(0, 0).XYZ();
+            gp_XYZ dirDepth = segment.GetChordPoint(0, 1).XYZ() - segment.GetChordPoint(0, 0).XYZ();
+            length.span  += gp_XYZ(fabs(dirSpan.X()), fabs(dirSpan.Y()), fabs(dirSpan.Z()));
+            length.depth += gp_XYZ(fabs(dirDepth.X()), fabs(dirDepth.Y()), fabs(dirDepth.Z()));
+
+        }
+        const auto& outerSegment = wing.GetSegment(wing.GetSegmentCount());
+        gp_XYZ dirDepth = outerSegment.GetChordPoint(1, 1).XYZ() - outerSegment.GetChordPoint(1, 0).XYZ();
+        length.depth    += gp_XYZ(fabs(dirDepth.X()), fabs(dirDepth.Y()), fabs(dirDepth.Z()));
+
+        return length;
+    }
+}
+
 namespace tigl
 {
 
@@ -35,27 +64,17 @@ bool HasShape(const tigl::CCPACSWing& wing)
 
 }
 
-TiglAxis GetDeepDirection(const tigl::CCPACSWing& wing)
+TiglAxis GetWingDepthAxis(const tigl::CCPACSWing& wing)
 {
     if (!HasShape(wing)) {
         LOG(WARNING) << "CTiglWingHelper::GetDeepDirection: This wing has no shape -> impossible to determine the "
                         "direction properly. The default direction will be returned";
         return TIGL_X_AXIS;
     }
 
-    gp_XYZ cumulatedDepthDirection(0, 0, 0);
-    for (int i = 1; i <= wing.GetSegmentCount(); ++i) {
-        const CCPACSWingSegment& segment = wing.GetSegment(i);
-        gp_XYZ dirDepth                  = segment.GetChordPoint(0, 1).XYZ() - segment.GetChordPoint(0, 0).XYZ();
-        dirDepth                         = gp_XYZ(fabs(dirDepth.X()), fabs(dirDepth.Y()), fabs(dirDepth.Z()));
-        cumulatedDepthDirection += dirDepth;
-    }
-    const CCPACSWingSegment& outerSegment = wing.GetSegment(wing.GetSegmentCount());
-    gp_XYZ dirDepth = outerSegment.GetChordPoint(1, 1).XYZ() - outerSegment.GetChordPoint(1, 0).XYZ();
-    dirDepth        = gp_XYZ(fabs(dirDepth.X()), fabs(dirDepth.Y()), fabs(dirDepth.Z()));
-    cumulatedDepthDirection += dirDepth;
+    gp_XYZ cumulatedDepthDirection = GetCumulatedLength(wing).depth;
 
-    switch (GetMajorDirection(wing)) {
+    switch (GetWingSpanAxis(wing)) {
     case TIGL_Y_AXIS:
         return cumulatedDepthDirection.X() >= cumulatedDepthDirection.Z() ? TiglAxis::TIGL_X_AXIS
                                                                           : TiglAxis::TIGL_Z_AXIS;
@@ -70,7 +89,7 @@ TiglAxis GetDeepDirection(const tigl::CCPACSWing& wing)
     }
 }
 
-TiglAxis GetMajorDirection(const CCPACSWing& wing)
+TiglAxis GetWingSpanAxis(const CCPACSWing& wing)
 {
     if (!HasShape(wing)) {
         LOG(WARNING) << "CTiglWingHelper::GetMajorDirection: This wing has no shape -> impossible to determine the "
@@ -88,21 +107,9 @@ TiglAxis GetMajorDirection(const CCPACSWing& wing)
     default:
         // heuristic to find the best major axis
         // first find the deep axis , then chose the major axis between the two left axis
-        gp_XYZ cumulatedSpanDirection(0, 0, 0);
-        gp_XYZ cumulatedDepthDirection(0, 0, 0);
-        for (int i = 1; i <= wing.GetSegmentCount(); ++i) {
-            const CCPACSWingSegment& segment = wing.GetSegment(i);
-            gp_XYZ dirSpan                   = segment.GetChordPoint(1, 0).XYZ() - segment.GetChordPoint(0, 0).XYZ();
-            gp_XYZ dirDepth                  = segment.GetChordPoint(0, 1).XYZ() - segment.GetChordPoint(0, 0).XYZ();
-            dirSpan  = gp_XYZ(fabs(dirSpan.X()), fabs(dirSpan.Y()), fabs(dirSpan.Z())); // why we use abs value?
-            dirDepth = gp_XYZ(fabs(dirDepth.X()), fabs(dirDepth.Y()), fabs(dirDepth.Z()));
-            cumulatedSpanDirection += dirSpan;
-            cumulatedDepthDirection += dirDepth;
-        }
-        const CCPACSWingSegment& outerSegment = wing.GetSegment(wing.GetSegmentCount());
-        gp_XYZ dirDepth = outerSegment.GetChordPoint(1, 1).XYZ() - outerSegment.GetChordPoint(1, 0).XYZ();
-        dirDepth        = gp_XYZ(fabs(dirDepth.X()), fabs(dirDepth.Y()), fabs(dirDepth.Z()));
-        cumulatedDepthDirection += dirDepth;
+        auto length = GetCumulatedLength(wing);
+        gp_XYZ cumulatedSpanDirection = length.span;
+        gp_XYZ cumulatedDepthDirection = length.depth;
 
         int depthIndex = 0;
         if (cumulatedDepthDirection.X() >= cumulatedDepthDirection.Y() &&

diff --git a/src/wing/TiglWingHelperFunctions.h b/src/wing/TiglWingHelperFunctions.h
@@ -29,13 +29,30 @@ namespace tigl
 namespace winghelper
 {
 
- // Returns the deep direction of the wing
-TiglAxis GetDeepDirection(const tigl::CCPACSWing& wing);
+/**
+ * Returns the depth direction of the wing
+ *
+ * Note: this is a heuristic that is determined by the wing shape
+ * and its position in 3D space.
+ *
+ * TODO: In future we need do define on the cpacs basis the projection
+ * plane of the wing
+ */
+TiglAxis GetWingDepthAxis(const tigl::CCPACSWing& wing);
 
-// Returns the major direction of the wing (correspond to the span direction)
-// @Details: If a symmetry plan is set, the major direction is normal to the symmetry plan,
-// otherwise, an heuristic is used to find out the best span axis candidate.
-TiglAxis GetMajorDirection(const tigl::CCPACSWing& wing);
+/**
+ * Returns the major direction of the wing (correspond to the span direction)
+ *
+ * @Details: If a symmetry plan is set, the major direction is normal to the symmetry plan,
+ * otherwise, an heuristic is used to find out the best span axis candidate.
+ *
+ * Note: this is a heuristic that is determined by the wing shape
+ * and its position in 3D space.
+ *
+ * TODO: In future we need do define on the cpacs basis the projection
+ * plane of the wing
+ */
+TiglAxis GetWingSpanAxis(const tigl::CCPACSWing& wing);
 
 } // namespace winghelper
 

diff --git a/tests/unittests/tiglWing.cpp b/tests/unittests/tiglWing.cpp
@@ -23,6 +23,7 @@
 #include "tigl.h"
 #include <string.h>
 #include <CCPACSConfigurationManager.h>
+#include <TiglWingHelperFunctions.h>
 
 /******************************************************************************/
 
@@ -342,6 +343,56 @@ TEST_F(TiglWing, tiglGetAspectRatio)
 
 }
 
+TEST_F(TiglWing, spanDirection)
+{
+    tigl::CCPACSConfigurationManager& manager = tigl::CCPACSConfigurationManager::GetInstance();
+    tigl::CCPACSConfiguration& config = manager.GetConfiguration(tiglHandle);
+
+    auto& wing = config.GetWing(1);
+    auto& vtp = config.GetWing(3);
+
+    auto axis = tigl::winghelper::GetWingSpanAxis(wing);
+    EXPECT_EQ(TIGL_Y_AXIS, axis);
+
+
+    axis = tigl::winghelper::GetWingSpanAxis(vtp);
+    EXPECT_EQ(TIGL_Z_AXIS, axis);
+
+    wing.SetSymmetryAxis(TIGL_NO_SYMMETRY);
+    vtp.SetSymmetryAxis(TIGL_X_Y_PLANE);
+
+    axis = tigl::winghelper::GetWingSpanAxis(wing);
+    EXPECT_EQ(TIGL_Y_AXIS, axis);
+
+    axis = tigl::winghelper::GetWingSpanAxis(vtp);
+    EXPECT_EQ(TIGL_Z_AXIS, axis);
+}
+
+TEST_F(TiglWing, depthDirection)
+{
+    tigl::CCPACSConfigurationManager& manager = tigl::CCPACSConfigurationManager::GetInstance();
+    tigl::CCPACSConfiguration& config = manager.GetConfiguration(tiglHandle);
+
+    auto& wing = config.GetWing(1);
+    auto& vtp = config.GetWing(3);
+
+    auto axis = tigl::winghelper::GetWingDepthAxis(wing);
+    EXPECT_EQ(TIGL_X_AXIS, axis);
+
+
+    axis = tigl::winghelper::GetWingDepthAxis(vtp);
+    EXPECT_EQ(TIGL_X_AXIS, axis);
+
+    wing.SetSymmetryAxis(TIGL_NO_SYMMETRY);
+    vtp.SetSymmetryAxis(TIGL_X_Y_PLANE);
+
+    axis = tigl::winghelper::GetWingDepthAxis(wing);
+    EXPECT_EQ(TIGL_X_AXIS, axis);
+
+    axis = tigl::winghelper::GetWingDepthAxis(vtp);
+    EXPECT_EQ(TIGL_X_AXIS, axis);
+}
+
 TEST_F(WingSimple, wingGetMAC_success)
 {
     double  c_1, x_1, y_1, z_1;