Fix performance tests

Deltares · Jan 8, 2024 · c4117d3 · c4117d3
1 parent df419b7
commit c4117d3
Show file tree

Hide file tree

Showing 3 changed files with 44 additions and 21 deletions.
diff --git a/libs/MeshKernel/include/MeshKernel/Mesh.hpp b/libs/MeshKernel/include/MeshKernel/Mesh.hpp
@@ -170,7 +170,8 @@ namespace meshkernel
         /// @param[in] mergingDistance The distance below which two nodes will be merged
         void MergeNodesInPolygon(const Polygons& polygons, double mergingDistance);
 
-        /// @brief Connect two existing nodes, forming a new edge (connectdbn)
+        /// @brief Connect two existing nodes, checking if the nodes are already connected.
+        /// If the nodes are not connected a new edge is formed, otherwise UInt invalid value is returned. (connectdbn)
         /// @param[in] startNode The start node index
         /// @param[in] endNode The end node index
         /// @return The index of the new edge
@@ -181,6 +182,12 @@ namespace meshkernel
         /// @return The index of the new node
         UInt InsertNode(const Point& newPoint);
 
+        /// @brief Insert a new edge, assuming two nodes are not already connected
+        /// @param[in] startNode The start node index
+        /// @param[in] endNode The end node index
+        /// @return The index of the new edge
+        UInt InsertEdge(UInt startNode, UInt endNode);
+
         /// @brief Delete a node
         /// @param[in] node The index of the node to delete
         void DeleteNode(UInt node);
@@ -191,6 +198,12 @@ namespace meshkernel
         /// @return The edge index
         [[nodiscard]] UInt FindEdge(UInt firstNodeIndex, UInt secondNodeIndex) const;
 
+        /// @brief Find the edge using a linear search, without connectivity information (much slower than FindEdge)
+        /// @param[in] firstNodeIndex The index of the first node
+        /// @param[in] secondNodeIndex The index of the second node
+        /// @return The edge index
+        [[nodiscard]] UInt FindEdgeWithLinearSearch(UInt firstNodeIndex, UInt secondNodeIndex) const;
+
         /// @brief Move a node to a new location
         /// @param[in] newPoint The new location
         /// @param[in] nodeindex The index of the node to move

diff --git a/libs/MeshKernel/src/Mesh.cpp b/libs/MeshKernel/src/Mesh.cpp
@@ -370,6 +370,11 @@ meshkernel::UInt Mesh::ConnectNodes(UInt startNode, UInt endNode)
     if (edgeIndex != constants::missing::uintValue)
         return constants::missing::uintValue;
 
+    return InsertEdge(startNode, endNode);
+}
+
+meshkernel::UInt Mesh::InsertEdge(UInt startNode, UInt endNode)
+{
     // increment the edges container
     const auto newEdgeIndex = GetNumEdges();
     m_edges.resize(newEdgeIndex + 1);
@@ -493,31 +498,30 @@ meshkernel::UInt Mesh::FindEdge(UInt firstNodeIndex, UInt secondNodeIndex) const
         throw std::invalid_argument("Mesh::FindEdge: Invalid node index.");
     }
 
-    const auto nunEdgesFirstNode = m_nodesNumEdges[firstNodeIndex];
-
-    if (nunEdgesFirstNode > 0)
+    for (UInt n = 0; n < m_nodesNumEdges[firstNodeIndex]; n++)
     {
-        for (UInt n = 0; n < nunEdgesFirstNode; n++)
+        const auto edgeIndex = m_nodesEdges[firstNodeIndex][n];
+        const auto firstEdgeOtherNode = OtherNodeOfEdge(m_edges[edgeIndex], firstNodeIndex);
+        const auto edgeFound = firstEdgeOtherNode == secondNodeIndex;
+        if (edgeFound)
         {
-            const auto edgeIndex = m_nodesEdges[firstNodeIndex][n];
-            const auto firstEdgeOtherNode = OtherNodeOfEdge(m_edges[edgeIndex], firstNodeIndex);
-            if (firstEdgeOtherNode == secondNodeIndex)
-            {
-                return edgeIndex;
-            }
+            return edgeIndex;
         }
     }
-    else
+
+    return constants::missing::uintValue;
+}
+
+meshkernel::UInt Mesh::FindEdgeWithLinearSearch(UInt firstNodeIndex, UInt secondNodeIndex) const
+{
+    for (UInt edgeIndex = 0; edgeIndex < GetNumEdges(); edgeIndex++)
     {
-        for (UInt edgeIndex = 0; edgeIndex < GetNumEdges(); edgeIndex++)
+        const auto& [firstNode, secondNode] = m_edges[edgeIndex];
+        const auto edgeFound = firstNode == firstNodeIndex && secondNode == secondNodeIndex ||
+                               secondNode == firstNodeIndex && firstNode == secondNodeIndex;
+        if (edgeFound)
         {
-            const auto& [firstNode, secondNode] = m_edges[edgeIndex];
-            const auto edgeFound = firstNode == firstNodeIndex && secondNode == secondNodeIndex ||
-                                   secondNode == firstNodeIndex && firstNode == secondNodeIndex;
-            if (edgeFound)
-            {
-                return edgeIndex;
-            }
+            return edgeIndex;
         }
     }
 

diff --git a/libs/MeshKernel/src/Mesh2DGenerateGlobal.cpp b/libs/MeshKernel/src/Mesh2DGenerateGlobal.cpp
@@ -70,7 +70,13 @@ void Mesh2DGenerateGlobal::AddFace(Mesh& mesh,
         {
             nextNode = 0;
         }
-        mesh.ConnectNodes(nodeIndices[n], nodeIndices[nextNode]);
+        const auto& firstNodeIndex = nodeIndices[n];
+        const auto& secondNodeIndex = nodeIndices[nextNode];
+
+        if (mesh.FindEdgeWithLinearSearch(firstNodeIndex, secondNodeIndex) == constants::missing::uintValue)
+        {
+            mesh.ConnectNodes(firstNodeIndex, secondNodeIndex);
+        }
     }
 }