Add m_nodes.reserve() and BuildTree

Author: attcs

octree.h

@@ -3105,86 +3105,59 @@ namespace OrthoTree
         this->template Create<false>(*this, points, maxDepthNoIn, std::move(boxSpaceOptional), maxElementNoInNode);
     }
 
-  public: // Create
-    // Create
-    template<bool IS_PARALLEL_EXEC = false>
-    static void Create(
-      OrthoTreePoint& tree,
-      TContainer const& points,
-      std::optional<depth_t> maxDepthNoIn = std::nullopt,
-      std::optional<TBox> boxSpaceOptional = std::nullopt,
-      std::size_t maxElementNoInNode = DEFAULT_MAX_ELEMENT) noexcept
+  private:
+    struct Location
     {
-      auto const boxSpace = boxSpaceOptional.has_value() ? IGM::GetBoxAD(*boxSpaceOptional) : IGM::GetBoxOfPointsAD(points);
-      auto const pointNo = points.size();
-
-      auto const maxDepthNo = (!maxDepthNoIn || maxDepthNoIn == depth_t{}) ? Base::EstimateMaxDepth(pointNo, maxElementNoInNode) : *maxDepthNoIn;
-      tree.InitBase(boxSpace, maxDepthNo, maxElementNoInNode);
-      if (points.empty())
-        return;
-
-      // Calculate and sort the Morton location ids
-
-      struct Location
-      {
-        TEntityID EntityID;
-        MortonLocationID LocationID;
-      };
-      auto locations = std::vector<Location>(pointNo);
-      EXEC_POL_DEF(ept); // GCC 11.3
-      std::transform(EXEC_POL_ADD(ept) points.begin(), points.end(), locations.begin(), [&](auto const& point) {
-        return Location{ detail::getKeyPart(points, point), tree.GetLocationID(detail::getValuePart(point)) };
-      });
+      TEntityID EntityID;
+      MortonLocationID LocationID;
+    };
 
+    // Build the tree in depth-first order
+    template<bool IS_PARALLEL_EXEC = false>
+    inline constexpr void BuildTree(std::vector<Location>& locations) noexcept
+    {
       if constexpr (IS_PARALLEL_EXEC)
       {
         EXEC_POL_DEF(eps); // GCC 11.3
         std::sort(EXEC_POL_ADD(eps) locations.begin(), locations.end(), [&](auto const& l, auto const& r) { return l.LocationID < r.LocationID; });
       }
 
-      // Build the tree in depth-first order
-
       struct NodeStackData
       {
         std::pair<MortonNodeID, Node> NodeInstance;
         typename std::vector<Location>::iterator EndLocationIt;
       };
       std::array<NodeStackData, SI::MAX_THEORETICAL_DEPTH> nodeStack;
-      nodeStack[0] = NodeStackData{ *tree.m_nodes.find(SI::GetRootKey()), locations.end() };
-      tree.m_nodes.clear(); // Root will be inserted again via the nodeStack, unspecified behavior
+      nodeStack[0] = NodeStackData{ *this->m_nodes.find(SI::GetRootKey()), locations.end() };
+      this->m_nodes.clear(); // Root will be inserted again via the nodeStack, unspecified behavior
 
       auto beginLocationIt = locations.begin();
       auto constexpr exitDepthID = depth_t(-1);
       for (depth_t depthID = 0; depthID != exitDepthID;)
       {
         auto& [node, endLocationIt] = nodeStack[depthID];
         std::size_t const elementNo = std::distance(beginLocationIt, endLocationIt);
-        if (elementNo == 0)
-        {
-          tree.m_nodes.emplace(std::move(node));
-          --depthID;
-          continue;
-        }
-
-        if ((elementNo < tree.m_maxElementNo && !node.second.IsAnyChildExist()) || depthID == maxDepthNo)
+        if ((0 < elementNo && elementNo < this->m_maxElementNo && !node.second.IsAnyChildExist()) || depthID == this->m_maxDepthNo)
         {
           auto& entityIDs = node.second.GetEntities();
           entityIDs.resize(elementNo);
-
           LOOPIVDEP
           for (std::size_t i = 0; i < elementNo; ++i)
           {
             entityIDs[i] = beginLocationIt->EntityID;
             ++beginLocationIt;
           }
+        }
 
-          tree.m_nodes.emplace(std::move(node));
+        if (beginLocationIt == endLocationIt)
+        {
+          this->m_nodes.emplace(std::move(node));
           --depthID;
           continue;
         }
 
         ++depthID;
-        auto const examinedLevel = tree.GetDepthMax() - depthID;
+        auto const examinedLevel = this->GetDepthMax() - depthID;
         auto const keyGenerator = typename SI::ChildKeyGenerator(node.first);
         auto const childChecker = typename SI::ChildCheckerFixedDepth(examinedLevel, beginLocationIt->LocationID);
         auto childKey = keyGenerator.GetChildNodeKey(childChecker.GetChildID(examinedLevel));
@@ -3202,10 +3175,40 @@ namespace OrthoTree
         }
 
         nodeStack[depthID].NodeInstance.first = std::move(childKey);
-        nodeStack[depthID].NodeInstance.second = tree.CreateChild(node.second, childKey);
+        nodeStack[depthID].NodeInstance.second = this->CreateChild(node.second, childKey);
       }
     }
 
+  public: // Create
+    // Create
+    template<bool IS_PARALLEL_EXEC = false>
+    static void Create(
+      OrthoTreePoint& tree,
+      TContainer const& points,
+      std::optional<depth_t> maxDepthNoIn = std::nullopt,
+      std::optional<TBox> boxSpaceOptional = std::nullopt,
+      std::size_t maxElementNoInNode = DEFAULT_MAX_ELEMENT) noexcept
+    {
+      auto const boxSpace = boxSpaceOptional.has_value() ? IGM::GetBoxAD(*boxSpaceOptional) : IGM::GetBoxOfPointsAD(points);
+      auto const pointNo = points.size();
+
+      auto const maxDepthNo = (!maxDepthNoIn || maxDepthNoIn == depth_t{}) ? Base::EstimateMaxDepth(pointNo, maxElementNoInNode) : *maxDepthNoIn;
+      tree.InitBase(boxSpace, maxDepthNo, maxElementNoInNode);
+      if (points.empty())
+        return;
+
+      detail::reserve(tree.m_nodes, Base::EstimateNodeNumber(pointNo, maxDepthNo, maxElementNoInNode));
+
+      // Calculate and sort the Morton location ids
+      auto locations = std::vector<Location>(pointNo);
+      EXEC_POL_DEF(ept); // GCC 11.3
+      std::transform(EXEC_POL_ADD(ept) points.begin(), points.end(), locations.begin(), [&](auto const& point) {
+        return Location{ detail::getKeyPart(points, point), tree.GetLocationID(detail::getValuePart(point)) };
+      });
+
+      tree.template BuildTree<IS_PARALLEL_EXEC>(locations);
+    }
+
   public: // Edit functions
     // Insert entity into the tree with node rebalancing
     bool InsertWithRebalancing(TEntityID newEntityID, TVector const& newPoint, TContainer const& points) noexcept