CPACS-Creator: Add error handling when a section should be added in (or next to) a segment containing guide curves

bindings/python_internal/configuration.i

@@ -40,7 +40,9 @@
 #include "CCPACSExternalObject.h"
 #include "CTiglShapeCache.h"
 #include "CTiglError.h"
+#include "CCPACSWalls.h"
 #include "CCPACSWallPosition.h"
+#include "CCPACSFuselageWallSegment.h"
 #include "CCPACSWingSegment.h"
 #include "CCPACSFuselageSegment.h"
 #include "CTiglWingConnection.h"
@@ -87,6 +89,7 @@
 #include "generated/CPACSBoundingElementUIDs.h"
 #include "generated/CPACSStructuralWallElement.h"
 #include "generated/CPACSStructuralWallElements.h"
+#include "generated/CPACSWalls.h"
 #include "generated/CPACSWallPositionUIDs.h"
 #include "generated/CPACSWallPosition.h"
 #include "generated/CPACSWallPositions.h"
@@ -180,7 +183,6 @@
 %include "generated/CPACSLateralCap_placement.h"
 %boost_optional(tigl::generated::CPACSLateralCap)
 %include "generated/CPACSLateralCap.h"
-
 %boost_optional(tigl::generated::CPACSBoundingElementUIDs)
 %include "generated/CPACSBoundingElementUIDs.h"
 %include "generated/CPACSStructuralWallElement.h"
@@ -190,8 +192,14 @@
 %include "generated/CPACSWallPositions.h"
 %include "generated/CPACSWallSegment.h"
 %include "generated/CPACSWallSegments.h"
+%boost_optional(tigl::CCPACSWalls)
 %boost_optional(tigl::generated::CPACSWalls)
+%boost_optional(tigl::CCPACSWallPosition)
+%boost_optional(tigl::CCPACSFuselageWallSegment)
 %include "generated/CPACSWalls.h"
+%include "CCPACSWalls.h"
+%include "CCPACSWallPosition.h"
+%include "CCPACSFuselageWallSegment.h"
 
 // ----------------- Engines ---------------------------//
 %boost_optional(tigl::CCPACSEngines)
@@ -538,6 +546,7 @@ class CCPACSWingRibsPositioning;
 %factory(tigl::ITiglGeometricComponent& tigl::CTiglUIDManager::GetGeometricComponent,
          tigl::CCPACSFuselage,
          tigl::CCPACSFuselageSegment,
+         tigl::CCPACSFuselageWallSegment,
          tigl::CCPACSWing,
          tigl::CCPACSWingSegment,
          tigl::CCPACSWingComponentSegment,

src/fuselage/CCPACSFuselage.cpp

@@ -491,7 +491,7 @@
 {
     CTiglPoint center;
     if (! fuselageHelper->HasShape()) {  // fuselage has no element case
         return center;
     }
     std::string noiseUID                  = fuselageHelper->GetNoseUID();
     CTiglFuselageSectionElement* cElement = fuselageHelper->GetCTiglElementOfFuselage(noiseUID);
@@ -521,7 +521,7 @@
 {
     double length = 0;
     if (!fuselageHelper->HasShape()) { // fuselage has no element case
         return length;
     }
     CTiglFuselageSectionElement* nose = fuselageHelper->GetCTiglElementOfFuselage(fuselageHelper->GetNoseUID());
     CTiglFuselageSectionElement* tail = fuselageHelper->GetCTiglElementOfFuselage(fuselageHelper->GetTailUID());
@@ -545,8 +545,8 @@
     //              2) Compute the new center point for each element using the previous transformation
 
     if (!fuselageHelper->HasShape()) {
         LOG(WARNING) << "PACSFuselage::SetLength: Impossible to set the length because this fuselage has no segments.";
         return;
     }
 
     std::vector<std::string> elementUIDS = fuselageHelper->GetElementUIDsInOrder();
@@ -586,7 +586,7 @@
     double oldLength = GetLength();
     if (oldLength == 0) {
         // todo cover the case where length is 0
         throw CTiglError("CCPACSFuselage::SetLengthBetween: the old length is 0, impossible to scale the length");
     }
     double xScale = newLength / oldLength;
     CTiglTransformation scaleM;
@@ -653,8 +653,8 @@
 
     double currentHeight = GetMaximalHeight();
     if (currentHeight < 0.00000000001 ){
         LOG(WARNING) << "CCPACSFuselage::SetMaxHeight: The current height is near 0, we do not support for the moment setting the height if the current height is zero, sorry.";
         return;
     }
     double scalingZ = newHeight / currentHeight;
     CTiglTransformation S;
@@ -721,8 +721,8 @@
 
     double currentWidth = GetMaximalWidth();
     if (currentWidth < 0.00000000001 ){
         LOG(WARNING) << "CCPACSFuselage::SetMaxHeight: The current height is near 0, we do not support for the moment setting the height if the current height is zero, sorry.";
         return;
     }
     double scalingY = newWidth / currentWidth;
     CTiglTransformation S;
@@ -748,6 +748,11 @@
 
 void CCPACSFuselage::CreateNewConnectedElementBetween(std::string startElementUID, std::string endElementUID)
 {
+    if(GetSegments().GetSegmentFromTo(startElementUID, endElementUID).GetGuideCurves())
+    {
+        throw tigl::CTiglError("Adding sections in fuselage segments containing guide curves is currently not supported.\n"
+                               "In general, guide curves should only be added when all sections are already defined, since the guide curves depend on them.", TIGL_UID_ERROR);
+    }
 
     std::string segmentToSplit = GetSegments().GetSegmentFromTo(startElementUID, endElementUID).GetUID();
     CTiglFuselageSectionElement* startElement = fuselageHelper->GetCTiglElementOfFuselage(startElementUID);
@@ -757,7 +762,7 @@
     CTiglPoint center = ( startElement->GetCenter() + endElement->GetCenter() ) * 0.5;
     CTiglPoint normal = ( startElement->GetNormal() + endElement->GetNormal() );
     if ( isNear( normal.norm2(), 0) ){
         normal = startElement->GetNormal();
     }
     normal.normalize();
     double angleN = ( startElement->GetRotationAroundNormal() + endElement->GetRotationAroundNormal() ) * 0.5;
@@ -795,8 +800,23 @@
         // in this case we simply need to find the previous element and call the appropriate function
         std::vector<std::string>  elementsBefore = ListFunctions::GetElementsInBetween(fuselageHelper->GetElementUIDsInOrder(), fuselageHelper->GetNoseUID(),startElementUID);
         if ( elementsBefore.size() < 2) {
             throw  CTiglError("Impossible to add a element after if there is no previous element");
         }
+
+        // Iterate over segments to find the one ending in startElementUID
+        // If the corresponding segment contains guide curves -> Throw error, since adding elements after gc-segments is not supported
+        for (int i=1; i <= GetSegmentCount(); i++)
+        {
+            if (GetSegment(i).GetEndSectionElementUID() == startElementUID)
+            {
+                if(GetSegment(i).GetGuideCurves())
+                {
+                    throw tigl::CTiglError("Adding sections after fuselage segments containing guide curves is currently not supported.\n"
+                                           "In general, guide curves should only be added when all sections are already defined, since the guide curves depend on them.", TIGL_UID_ERROR);
+                }
+            }
+        }
+
         std::string  previousElementUID = elementsBefore[elementsBefore.size()-2];
 
         CTiglFuselageSectionElement* previousElement = fuselageHelper->GetCTiglElementOfFuselage(previousElementUID);
@@ -846,8 +866,23 @@
     else {
         std::vector<std::string> elementsAfter  =  ListFunctions::GetElementsAfter(fuselageHelper->GetElementUIDsInOrder(), startElementUID);
         if (elementsAfter.size() < 1 ) {
             throw  CTiglError("Impossible to add a element before if there is no previous element");
         }
+
+        // Iterate over segments to find the one starting in startElementUID
+        // If the corresponding segment contains guide curves -> Throw error, since adding elements after gc-segments is not supported
+        for (int i=1; i <= GetSegmentCount(); i++)
+        {
+            if (GetSegment(i).GetStartSectionElementUID() == startElementUID)
+            {
+                if(GetSegment(i).GetGuideCurves())
+                {
+                    throw tigl::CTiglError("Adding sections before fuselage segments containing guide curves is currently not supported.\n"
+                                           "In general, guide curves should only be added when all sections are already defined, since the guide curves depend on them.", TIGL_UID_ERROR);
+                }
+            }
+        }
+
         std::string  previousElementUID = elementsAfter[0];
 
         CTiglFuselageSectionElement* previousElement = fuselageHelper->GetCTiglElementOfFuselage(previousElementUID);
@@ -890,9 +925,9 @@
             try { // we use a try-catch to not rise two time a exception if the reordering occurs during the first cpacs parsing
                 m_segments.ReorderSegments();
             }
             catch (  const CTiglError& err) {
                 LOG(ERROR) << err.what();
             }
         }
 
     }
@@ -908,7 +943,7 @@
 {
     std::vector<std::string> orderedUIDs = GetOrderedConnectedElement();
     if (!ListFunctions::Contains(orderedUIDs, elementUID)) {
         throw CTiglError("Invalid uid, the given element is not a connected element ");
     }
     // section to delete
     CCPACSFuselageSection& sec = GetSections().GetSection(fuselageHelper->GetCTiglElementOfFuselage(elementUID)->GetSectionUID());
@@ -937,7 +972,7 @@
        seg1.SetToElementUID(next);
        GetSections().RemoveSection(sec);
     } else {
        throw CTiglError("Unexpected case: fuselage structure seems unusual.");
     }
     Invalidate();
 }

src/structural_elements/CCPACSFuselageWallSegment.h

@@ -36,22 +36,22 @@
 public:
     TIGL_EXPORT CCPACSFuselageWallSegment(CCPACSWallSegments* parent, CTiglUIDManager* uidMgr);
 
-    std::string GetDefaultedUID() const override
+    TIGL_EXPORT std::string GetDefaultedUID() const override
     {
         return GetUID().value_or("UnknownWallSegment");
     }
 
-    TiglGeometricComponentIntent GetComponentIntent() const override
+    TIGL_EXPORT TiglGeometricComponentIntent GetComponentIntent() const override
     {
         return TIGL_INTENT_INNER_STRUCTURE | TIGL_INTENT_PHYSICAL;
     }
 
-    TiglGeometricComponentType   GetComponentType() const override
+    TIGL_EXPORT TiglGeometricComponentType   GetComponentType() const override
     {
         return TIGL_COMPONENT_FUSELAGE_WALL;
     }
 
-    TopoDS_Compound GetCutPlanes() const;
+    TIGL_EXPORT TopoDS_Compound GetCutPlanes() const;
 
     TIGL_EXPORT void SetPhi(const double& value) override;
     TIGL_EXPORT void SetDoubleSidedExtrusion(const boost::optional<bool>& value) override;

src/structural_elements/CCPACSWalls.h

@@ -32,12 +32,12 @@ namespace tigl
 class CCPACSWalls : public generated::CPACSWalls
 {
 public:
-    CCPACSWalls(CCPACSFuselageStructure* parent, CTiglUIDManager* uidMgr);
+    TIGL_EXPORT CCPACSWalls(CCPACSFuselageStructure* parent, CTiglUIDManager* uidMgr);
 
-    const CCPACSFuselageWallSegment& GetWallSegment(const std::string& uid) const;
-    const CCPACSWallPosition& GetWallPosition(const std::string& uid) const;
+    TIGL_EXPORT const CCPACSFuselageWallSegment& GetWallSegment(const std::string& uid) const;
+    TIGL_EXPORT const CCPACSWallPosition& GetWallPosition(const std::string& uid) const;
 
-    void Invalidate(const boost::optional<std::string>& source = boost::none) const;
+    TIGL_EXPORT void Invalidate(const boost::optional<std::string>& source = boost::none) const;
 };
 
 } // namespace tigl

src/wing/CCPACSWing.cpp

@@ -108,7 +108,7 @@
             configuration->GetDucts()->RegisterInvalidationCallback([&](){ this->Invalidate(); });
         }
     }
     else if (parent->IsParent<CCPACSRotorcraftModel>()) {
         configuration = &parent->GetParent<CCPACSRotorcraftModel>()->GetConfiguration();
     }
     else {
@@ -638,8 +638,8 @@
 double CCPACSWing::GetWingspan() const
 {
     if (!wingHelper->HasShape()) {
         LOG(WARNING) << "The wing seems empty.";
         return 0;
     }
 
     // prepare mirror transformation
@@ -649,10 +649,10 @@
         gp_Ax2 mirrorPlane;
         if (sym == TIGL_X_Z_PLANE) {
             mirrorPlane = gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(0., 1., 0.));
         } else if (sym == TIGL_X_Y_PLANE) {
             mirrorPlane = gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(0., 0., 1.));
         } else if (sym == TIGL_Y_Z_PLANE) {
             mirrorPlane = gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(1., 0., 0.));
         }
         mirrorTransform.SetMirror(mirrorPlane);
     }
@@ -682,11 +682,11 @@
     case TIGL_Y_AXIS:
         return ymax - ymin;
         break;
     case TIGL_X_AXIS:
         return xmax - xmin;
         break;
     default:
         return ymax - ymin;
     }
 }
 
@@ -715,10 +715,10 @@
         return zmax - zmin;
     case TIGL_Y_AXIS:
         return ymax - ymin;
     case TIGL_X_AXIS:
         return xmax - xmin;
     default:
         return ymax - ymin;
     }
 }
 
@@ -1193,7 +1193,7 @@
 {
     // check inputs
     if (newDihedral > 89 || newDihedral < -89 || chordPercentage < 0 || chordPercentage > 1) {
         throw CTiglError("Invalid input! required angle [-89,89], chordPrecentage [0,1] ");
     }
     // The idea is:
     // 1) Compute the new chord point of the tip such that the wing has the wanted origin
@@ -1309,9 +1309,9 @@
     case TIGL_Y_AXIS:
         projection.AddProjectionOnXZPlane();
         break;
     case TIGL_X_AXIS:
         projection.AddProjectionOnYZPlane();
         break;
     }
 
     double vInc, wInc;
@@ -1332,7 +1332,7 @@
 
     double det = pow(v, 2) - (4 * -2*newArea * w);
     if ( det < 0) {
         throw CTiglError("Impossible to find a valid scale factor to set the area.");
     }
 
     // we use muller's method to support the case when w = 0
@@ -1407,6 +1407,11 @@
 
 void CCPACSWing::CreateNewConnectedElementBetween(std::string startElementUID, std::string endElementUID)
 {
+        if(GetSegments().GetSegmentFromTo(startElementUID, endElementUID).GetGuideCurves())
+        {
+            throw tigl::CTiglError("Adding sections in wing segments containing guide curves is currently not supported.\n"
+                                   "In general, guide curves should only be added when all sections are already defined, since the guide curves depend on them.", TIGL_UID_ERROR);
+        }
 
         std::string segmentToSplit = GetSegments().GetSegmentFromTo(startElementUID, endElementUID).GetUID();
         CTiglWingSectionElement *startElement = wingHelper->GetCTiglElementOfWing(startElementUID);
@@ -1416,7 +1421,7 @@
         CTiglPoint center = (startElement->GetCenter() + endElement->GetCenter()) * 0.5;
         CTiglPoint normal = (startElement->GetNormal() + endElement->GetNormal());
         if (isNear(normal.norm2(), 0)) {
             normal = startElement->GetNormal();
         }
         normal.normalize();
         double angleN = (startElement->GetRotationAroundNormal() + endElement->GetRotationAroundNormal()) * 0.5;
@@ -1452,8 +1457,23 @@
         else {
             std::vector<std::string>  elementsBefore = ListFunctions::GetElementsInBetween(wingHelper->GetElementUIDsInOrder(), wingHelper->GetRootUID(),startElementUID);
             if ( elementsBefore.size() < 2) {
                 throw  CTiglError("Impossible to add a element after if there is no previous element");
             }
+
+            // Iterate over segments to find the one ending in startElementUID
+            // If the corresponding segment contains guide curves -> Throw error, since adding elements after gc-segments is not supported
+            for (int i=1; i <= GetSegmentCount(); i++)
+            {
+                if (GetSegment(i).GetOuterSectionElementUID() == startElementUID)
+                {
+                    if(GetSegment(i).GetGuideCurves())
+                    {
+                        throw tigl::CTiglError("Adding sections after wing segments containing guide curves is currently not supported.\n"
+                                               "In general, guide curves should only be added when all sections are already defined, since the guide curves depend on them.", TIGL_UID_ERROR);
+                    }
+                }
+            }
+
             std::string  previousElementUID = elementsBefore[elementsBefore.size()-2];
 
             CTiglWingSectionElement* previousElement = wingHelper->GetCTiglElementOfWing(previousElementUID);
@@ -1499,58 +1519,73 @@
 {
         std::vector<std::string> elementsBefore = ListFunctions::GetElementsInBetween(wingHelper->GetElementUIDsInOrder(), wingHelper->GetRootUID(),startElementUID);
         if ( elementsBefore.size() > 1 ) {
             this->CreateNewConnectedElementBetween(elementsBefore[elementsBefore.size()-2], startElementUID);
         }
         else {
             std::vector<std::string> elementsAfter  =  ListFunctions::GetElementsAfter(wingHelper->GetElementUIDsInOrder(), startElementUID);
             if (elementsAfter.size() < 1 ) {
                 throw  CTiglError("Impossible to add a element before if there is no previous element");
             }
+
+            // Iterate over segments to find the one starting in startElementUID
+            // If the corresponding segment contains guide curves -> Throw error, since adding elements after gc-segments is not supported
+            for (int i=1; i <= GetSegmentCount(); i++)
+            {
+                if (GetSegment(i).GetInnerSectionElementUID() == startElementUID)
+                {
+                    if(GetSegment(i).GetGuideCurves())
+                    {
+                        throw tigl::CTiglError("Adding sections before wing segments containing guide curves is currently not supported.\n"
+                                               "In general, guide curves should only be added when all sections are already defined, since the guide curves depend on them.", TIGL_UID_ERROR);
+                    }
+                }
+            }
+
             std::string  previousElementUID = elementsAfter[0];
 
             CTiglWingSectionElement* previousElement = wingHelper->GetCTiglElementOfWing(previousElementUID);
             CTiglWingSectionElement* startElement = wingHelper->GetCTiglElementOfWing(startElementUID);
 
             // Compute the parameters for the new section base on the start element and the previous element.
             // We try to create a continuous fuselage
             CTiglPoint normal  =  startElement->GetNormal() + (startElement->GetNormal() - previousElement->GetNormal() ) ;
             CTiglPoint center = startElement->GetCenter() + (startElement->GetCenter() - previousElement->GetCenter() );
             double angleN = startElement->GetRotationAroundNormal() + (startElement->GetRotationAroundNormal() -previousElement->GetRotationAroundNormal());
             double area = startElement->GetArea();
             if (previousElement->GetArea() > 0) {
                 double scaleF = startElement->GetArea() / previousElement->GetArea();
                 area = scaleF * area;
             }
             std::string profileUID = startElement->GetProfileUID();
             std::string sectionUID = startElement->GetSectionUID() + "Before";
 
 
             CCPACSWingSection& newSection = GetSections().CreateSection(sectionUID, profileUID);
             CTiglWingSectionElement* newElement = newSection.GetSectionElement(1).GetCTiglSectionElement();
 
             newElement->SetNormal(normal);
             newElement->SetRotationAroundNormal(angleN);
             newElement->SetCenter(center);
             newElement->SetArea(area);
 
             // Connect the element with the segment
             CCPACSWingSegment&  newSegment = GetSegments().AddSegment();
             std::string newSegmentUID = GetUIDManager().MakeUIDUnique("SegGenerated");
 
             newSegment.SetUID(newSegmentUID);
             newSegment.SetName(newSegmentUID);
             newSegment.SetFromElementUID(newElement->GetSectionElementUID());
             newSegment.SetToElementUID(startElementUID);
 
             GetSegments().Invalidate();
             // to reorder the segment if needed.
             if ( m_segments.NeedReordering() ){
                 try { // we use a try-catch to not rise two time a exception if the reordering occurs during the first cpacs parsing
                     m_segments.ReorderSegments();
                 }
                 catch (  const CTiglError& err) {
                     LOG(ERROR) << err.what();
                 }
             }
         }
 }
@@ -1569,7 +1604,7 @@
     std::vector<std::string> orderedUIDs = wingHelper->GetElementUIDsInOrder();
 
     if (!ListFunctions::Contains(orderedUIDs, elementUID)) {
         throw CTiglError("Invalid uid, the given element is not a connected element ");
     }
     // section to delete
     CCPACSWingSection& sec = GetSections().GetSection(wingHelper->GetCTiglElementOfWing(elementUID)->GetSectionUID());
@@ -1598,7 +1633,7 @@
         seg1.SetToElementUID(next);
         GetSections().RemoveSection(sec);
     } else {
         throw CTiglError("Unexpected case: wing structure seems unusual.");
     }
     Invalidate();
 

tests/unittests/creatorFuselage.cpp

@@ -330,6 +330,16 @@ TEST_F(creatorFuselage, setRotation_MultipleFuselagesModel)
 }
 
 
+TEST_F(creatorFuselage, createSection_FuselageSegmentGuideCurves)
+{
+
+    setVariables("TestData/simple_test_guide_curves.xml", "Fuselage");
+
+    EXPECT_THROW(fuselage->CreateNewConnectedElementBefore("GuideCurveModel_Fuselage_Sec1_El1"), tigl::CTiglError);
+    EXPECT_THROW(fuselage->CreateNewConnectedElementBetween("GuideCurveModel_Fuselage_Sec1_El1", "GuideCurveModel_Fuselage_Sec2_El1"), tigl::CTiglError);
+    EXPECT_THROW(fuselage->CreateNewConnectedElementAfter("GuideCurveModel_Fuselage_Sec3_El1"), tigl::CTiglError);
+}
+
 
 TEST_F(creatorFuselage, createSection_MultipleFuselageModel)
 {

tests/unittests/creatorWing.cpp

@@ -998,6 +998,17 @@ TEST_F(creatorWing, MultipleWings_SetARKeepArea) {
 }
 
 
+TEST_F(creatorWing, createSection_WingSegmentGuideCurves)
+{
+
+    setVariables("TestData/simple_test_guide_curves.xml", "Wing");
+
+    EXPECT_THROW(wing->CreateNewConnectedElementBefore("GuideCurveModel_Wing_Sec1_El1"), tigl::CTiglError);
+    EXPECT_THROW(wing->CreateNewConnectedElementBetween("GuideCurveModel_Wing_Sec1_El1", "GuideCurveModel_Wing_Sec2_El1"), tigl::CTiglError);
+    EXPECT_THROW(wing->CreateNewConnectedElementAfter("GuideCurveModel_Wing_Sec4_El1"), tigl::CTiglError);
+}
+
+
 TEST_F(creatorWing, MultipleWings_CreateSections)
 {
     setVariables("TestData/multiple_wings.xml", "Wing");