[Core] Remove push_back from ModelPart

applications/HDF5Application/custom_io/hdf5_connectivities_data.cpp

@@ -90,7 +90,10 @@ void ConnectivitiesData::CreateEntities(NodesContainerType& rNodes,
         }
         ElementType::Pointer p_elem =
             r_elem.Create(mIds[i], nodes, rProperties(mPropertiesIds[i]));
-        rElements.push_back(p_elem);
+        // here we can safely use the insert with the rElements.end() as the hint
+        // because, when reading, we can assume that it was written in the
+        // sorted order within HDF5.
+        rElements.insert(rElements.end(), p_elem);
     }
     KRATOS_CATCH("");
 }
@@ -119,7 +122,10 @@ void ConnectivitiesData::CreateEntities(NodesContainerType& rNodes,
         }
         Condition::Pointer p_cond =
             r_cond.Create(mIds[i], nodes, rProperties(mPropertiesIds[i]));
-        rConditions.push_back(p_cond);
+        // here we can safely use the insert with the rConditions.end() as the hint
+        // because, when reading, we can assume that it was written in the
+        // sorted order within HDF5.
+        rConditions.insert(rConditions.end(), p_cond);
     }
     KRATOS_CATCH("");
 }

applications/HDF5Application/custom_io/hdf5_points_data.cpp

@@ -36,7 +36,10 @@ void PointsData::CreateNodes(NodesContainerType& rNodes)
         const array_1d<double, 3>& r_coord = mCoords[i];
         NodeType::Pointer p_node = Kratos::make_intrusive<NodeType>(
             mIds[i], r_coord[0], r_coord[1], r_coord[2]);
-        rNodes.push_back(p_node);
+        // here we can safely use the insert with the rNodes.end() as the hint
+        // because, when reading, we can assume that it was written in the
+        // sorted order within HDF5.
+        rNodes.insert(rNodes.end(), p_node);
     }
     KRATOS_CATCH("");
 }

applications/MeshingApplication/custom_utilities/parmmg/pmmg_utilities.cpp

@@ -1184,9 +1184,9 @@ void ParMmgUtilities<TPMMGLibrary>::WriteMeshDataToModelPart(
     std::unordered_map<IndexType, IndexVectorType> color_nodes, first_color_cond, second_color_cond, first_color_elem, second_color_elem;
 
     // The tempotal store of
-    ConditionsArrayType created_conditions_vector;
-    ElementsArrayType created_elements_vector;
-    NodesArrayType created_nodes_vector;
+    std::vector<Condition::Pointer> created_conditions_vector;
+    std::vector<Element::Pointer> created_elements_vector;
+    std::vector<Node::Pointer> created_nodes_vector;
 
     // Auxiliar values
     int ref, is_required;

kratos/benchmarks/model_part_benchmark.cpp

@@ -0,0 +1,274 @@
+//    |  /           |
+//    ' /   __| _` | __|  _ \   __|
+//    . \  |   (   | |   (   |\__ `
+//   _|\_\_|  \__,_|\__|\___/ ____/
+//                   Multi-Physics
+//
+//  License:         BSD License
+//                   Kratos default license: kratos/license.txt
+//
+//  Main authors:    Suneth Warnakulasuriya
+//
+
+// System includes
+#include <vector>
+
+// External includes
+#include <benchmark/benchmark.h>
+
+// Project includes
+#include "containers/model.h"
+#include "containers/pointer_vector_set.h"
+#include "includes/indexed_object.h"
+#include "includes/key_hash.h"
+#include "includes/model_part.h"
+#include "includes/smart_pointers.h"
+#include "utilities/assign_unique_model_part_collection_tag_utility.h"
+
+namespace Kratos {
+
+static void BM_ModelPartCreateNewNode(benchmark::State& state) {
+    for (auto _ : state) {
+        const IndexType input_size = state.range(0);
+
+        state.PauseTiming();
+
+        auto model = Model();
+        auto& r_model_part = model.CreateModelPart("test");
+
+        state.ResumeTiming();
+
+        for (IndexType i = 0; i < input_size; ++i) {
+            r_model_part.CreateNewNode(i + 1, 0.0, 0.0, 0.0);
+        }
+    }
+}
+
+
+static void BM_ModelPartAddNodesToRootFromRange1(benchmark::State& state) {
+    for (auto _ : state) {
+        const IndexType input_size = state.range(0);
+        const bool fill_existing = state.range(1) == 1;
+
+        state.PauseTiming();
+
+        auto model = Model();
+        auto& r_model_part = model.CreateModelPart("test");
+
+        std::vector<ModelPart::NodeType::Pointer> nodes_to_be_added, existing_nodes;
+        if (!fill_existing) {
+            nodes_to_be_added.reserve(input_size);
+        } else {
+            nodes_to_be_added.reserve(input_size / 2 + 1);
+            existing_nodes.reserve(input_size / 2 + 1);
+        }
+
+        // doing it in reverse to make sure a proper sort is done always
+        for (IndexType i = input_size; i > 0; --i) {
+            auto p_node = Kratos::make_intrusive<NodeType>(i, 0.0, 0.0, 0.0);
+            if (!fill_existing || i % 2 == 0) {
+                nodes_to_be_added.push_back(p_node);
+            } else {
+                existing_nodes.push_back(p_node);
+            }
+        }
+        r_model_part.AddNodes(existing_nodes.begin(), existing_nodes.end());
+        state.ResumeTiming();
+
+        // benchmarking to add nodes for already existing model part with nodes
+        r_model_part.AddNodes(nodes_to_be_added.begin(), nodes_to_be_added.end());
+    }
+}
+
+static void BM_ModelPartAddNodesToRootFromRange2(benchmark::State& state) {
+    for (auto _ : state) {
+        const IndexType input_size = state.range(0);
+        const bool fill_existing = state.range(1) == 1;
+
+        state.PauseTiming();
+
+        auto model = Model();
+        auto& r_model_part = model.CreateModelPart("test");
+
+        PointerVectorSet<ModelPart::NodeType, IndexedObject> nodes_to_be_added, existing_nodes;
+        if (!fill_existing) {
+            nodes_to_be_added.reserve(input_size);
+        } else {
+            nodes_to_be_added.reserve(input_size / 2 + 1);
+            existing_nodes.reserve(input_size / 2 + 1);
+        }
+
+        // doing it in reverse to make sure a proper sort is done always
+        for (IndexType i = 0; i < input_size; ++i) {
+            auto p_node = Kratos::make_intrusive<NodeType>(i + 1, 0.0, 0.0, 0.0);
+            if (!fill_existing || i % 2 == 0) {
+                nodes_to_be_added.insert(nodes_to_be_added.end(), p_node);
+            } else {
+                existing_nodes.insert(existing_nodes.end(), p_node);
+            }
+        }
+        r_model_part.AddNodes(existing_nodes.begin(), existing_nodes.end());
+        state.ResumeTiming();
+
+        // benchmarking to add nodes for already existing model part with nodes
+        r_model_part.AddNodes(nodes_to_be_added.begin(), nodes_to_be_added.end());
+    }
+}
+
+static void BM_ModelPartAddNodesToSubSubFromRange1(benchmark::State& state) {
+    for (auto _ : state) {
+        const IndexType input_size = state.range(0);
+        const bool fill_existing = state.range(1) == 1;
+
+        state.PauseTiming();
+
+        auto model = Model();
+        auto& r_sub_sub_model_part = model.CreateModelPart("test").CreateSubModelPart("sub_test").CreateSubModelPart("sub_sub_test");
+
+        std::vector<ModelPart::NodeType::Pointer> nodes_to_be_added, existing_nodes;
+        if (!fill_existing) {
+            nodes_to_be_added.reserve(input_size);
+        } else {
+            nodes_to_be_added.reserve(input_size / 2 + 1);
+            existing_nodes.reserve(input_size / 2 + 1);
+        }
+
+        // doing it in reverse to make sure a proper sort is done always
+        for (IndexType i = 0; i < input_size; ++i) {
+            auto p_node = Kratos::make_intrusive<NodeType>(i + 1, 0.0, 0.0, 0.0);
+            if (!fill_existing || i % 2 == 0) {
+                nodes_to_be_added.insert(nodes_to_be_added.end(), p_node);
+            } else {
+                existing_nodes.insert(existing_nodes.end(), p_node);
+            }
+        }
+        r_sub_sub_model_part.AddNodes(existing_nodes.begin(), existing_nodes.end());
+        state.ResumeTiming();
+
+        r_sub_sub_model_part.AddNodes(nodes_to_be_added.begin(), nodes_to_be_added.end());
+    }
+}
+
+static void BM_ModelPartAddNodesToSubSubFromRange2(benchmark::State& state) {
+    for (auto _ : state) {
+        const IndexType input_size = state.range(0);
+        const bool fill_existing = state.range(1) == 1;
+
+        state.PauseTiming();
+
+        auto model = Model();
+        auto& r_sub_sub_model_part = model.CreateModelPart("test").CreateSubModelPart("sub_test").CreateSubModelPart("sub_sub_test");
+
+        std::vector<ModelPart::NodeType::Pointer> nodes_to_be_added, existing_nodes;
+        if (!fill_existing) {
+            nodes_to_be_added.reserve(input_size);
+        } else {
+            nodes_to_be_added.reserve(input_size / 2 + 1);
+            existing_nodes.reserve(input_size / 2 + 1);
+        }
+
+        // doing it in reverse to make sure a proper sort is done always
+        for (IndexType i = 0; i < input_size; ++i) {
+            auto p_node = Kratos::make_intrusive<NodeType>(i + 1, 0.0, 0.0, 0.0);
+            if (!fill_existing || i % 2 == 0) {
+                nodes_to_be_added.insert(nodes_to_be_added.end(), p_node);
+            } else {
+                existing_nodes.insert(existing_nodes.end(), p_node);
+            }
+        }
+        r_sub_sub_model_part.GetRootModelPart().AddNodes(nodes_to_be_added.begin(), nodes_to_be_added.end());
+        r_sub_sub_model_part.GetRootModelPart().AddNodes(existing_nodes.begin(), existing_nodes.end());
+        state.ResumeTiming();
+
+        r_sub_sub_model_part.AddNodes(nodes_to_be_added.begin(), nodes_to_be_added.end());
+    }
+}
+
+static void BM_ModelPartAddNodesToSubSubFromRange3(benchmark::State& state) {
+    for (auto _ : state) {
+        const IndexType input_size = state.range(0);
+        const bool fill_existing = state.range(1) == 1;
+
+        state.PauseTiming();
+
+        auto model = Model();
+        auto& r_sub_sub_model_part = model.CreateModelPart("test").CreateSubModelPart("sub_test").CreateSubModelPart("sub_sub_test");
+
+        std::vector<ModelPart::NodeType::Pointer> nodes_to_be_added, existing_nodes;
+        if (!fill_existing) {
+            nodes_to_be_added.reserve(input_size);
+        } else {
+            nodes_to_be_added.reserve(input_size / 2 + 1);
+            existing_nodes.reserve(input_size / 2 + 1);
+        }
+
+        // doing it in reverse to make sure a proper sort is done always
+        for (IndexType i = 0; i < input_size; ++i) {
+            auto p_node = Kratos::make_intrusive<NodeType>(i + 1, 0.0, 0.0, 0.0);
+            if (!fill_existing || i % 2 == 0) {
+                nodes_to_be_added.insert(nodes_to_be_added.end(), p_node);
+            } else {
+                existing_nodes.insert(existing_nodes.end(), p_node);
+            }
+        }
+        r_sub_sub_model_part.GetRootModelPart().AddNodes(nodes_to_be_added.begin(), nodes_to_be_added.end());
+        r_sub_sub_model_part.GetRootModelPart().AddNodes(existing_nodes.begin(), existing_nodes.end());
+        state.ResumeTiming();
+
+        r_sub_sub_model_part.AddNodes(r_sub_sub_model_part.GetRootModelPart().NodesBegin(), r_sub_sub_model_part.GetRootModelPart().NodesEnd());
+    }
+}
+
+static void BM_ModelPartAddNodesToSubSubFromId1(benchmark::State& state) {
+    for (auto _ : state) {
+        const IndexType input_size = state.range(0);
+        const bool fill_existing = state.range(1) == 1;
+
+        state.PauseTiming();
+
+        auto model = Model();
+        auto& r_root_model_part = model.CreateModelPart("test");
+        auto& r_sub_sub_model_part = r_root_model_part.CreateSubModelPart("sub_test").CreateSubModelPart("sub_sub_test");
+
+        PointerVectorSet<ModelPart::NodeType, IndexedObject> nodes;
+        std::vector<IndexType> node_ids_to_add, existing_node_ids;
+        if (!fill_existing) {
+            node_ids_to_add.reserve(input_size);
+        } else {
+            node_ids_to_add.reserve(input_size / 2 + 1);
+            existing_node_ids.reserve(input_size / 2 + 1);
+        }
+
+        for (IndexType i = 0; i < input_size; ++i) {
+            nodes.insert(nodes.end(), Kratos::make_intrusive<NodeType>(i + 1, 0.0, 0.0, 0.0));
+        }
+
+        // doing it in reverse to make sure a proper sort is done always
+        for (IndexType i = input_size; i > 0; --i) {
+            if (!fill_existing || i % 2 == 0) {
+                node_ids_to_add.push_back(i);
+            } else {
+                existing_node_ids.push_back(i);
+            }
+        }
+        r_root_model_part.AddNodes(nodes.begin(), nodes.end());
+        r_sub_sub_model_part.AddNodes(existing_node_ids);
+        state.ResumeTiming();
+
+        r_sub_sub_model_part.AddNodes(node_ids_to_add);
+    }
+}
+
+
+// Register the function as a benchmark
+BENCHMARK(BM_ModelPartCreateNewNode) -> RangeMultiplier(10) -> Range(1e2, 1e+6);
+BENCHMARK(BM_ModelPartAddNodesToRootFromRange1) -> ArgsProduct({{100, 1000, 10000, 100000, 1000000}, {0, 1}});
+BENCHMARK(BM_ModelPartAddNodesToRootFromRange2) -> ArgsProduct({{100, 1000, 10000, 100000, 1000000}, {0, 1}});
+BENCHMARK(BM_ModelPartAddNodesToSubSubFromRange1) -> ArgsProduct({{100, 1000, 10000, 100000, 1000000}, {0, 1}});
+BENCHMARK(BM_ModelPartAddNodesToSubSubFromRange2) -> ArgsProduct({{100, 1000, 10000, 100000, 1000000}, {0, 1}});
+BENCHMARK(BM_ModelPartAddNodesToSubSubFromRange3) -> ArgsProduct({{100, 1000, 10000, 100000, 1000000}, {0, 1}});
+BENCHMARK(BM_ModelPartAddNodesToSubSubFromId1) -> ArgsProduct({{100, 1000, 10000, 100000, 1000000}, {0, 1}});
+
+}  // namespace Kratos
+
+BENCHMARK_MAIN();

kratos/containers/pointer_vector_set.h

@@ -20,6 +20,7 @@
 #include <sstream>
 #include <cstddef>
 #include <utility>
+#include <type_traits>
 
 // External includes
 #include <boost/iterator/indirect_iterator.hpp>
@@ -647,10 +648,23 @@ class PointerVectorSet final
     template <class InputIterator>
     void insert(InputIterator first, InputIterator last)
     {
-        // first sorts the input iterators and make the input unique.
-        std::sort(first, last, CompareKey());
-        auto new_last = std::unique(first, last, EqualKeyTo());
-        SortedInsert(first, new_last);
+        if constexpr(std::is_assignable_v<decltype(*std::declval<InputIterator>()), decltype(*std::declval<InputIterator>())>) {
+            // first sorts the input iterators and make the input unique if the iterators are assignable
+            std::sort(first, last, CompareKey());
+            auto new_last = std::unique(first, last, EqualKeyTo());
+            SortedInsert(first, new_last);
+        } else {
+            // the iterators are not assignable, hence they may be coming from a const vector, So, we need to make a copy
+            // to do the sort and unique.
+            std::vector<TPointerType> temp;
+            temp.reserve(std::distance(first, last));
+            for (auto it = first; it != last; ++it) {
+                temp.push_back(GetPointer(it));
+            }
+            std::sort(temp.begin(), temp.end(), CompareKey());
+            auto new_last = std::unique(temp.begin(), temp.end(), EqualKeyTo());
+            SortedInsert(temp.begin(), new_last);
+        }
     }
 
     /**
@@ -667,6 +681,20 @@ class PointerVectorSet final
         SortedInsert(first, last);
     }
 
+    /**
+     * @brief Insert elements from another PointerVectorSet range.
+     * @details This function inserts element pointers from another PointerVectorSet range specified by first and last into the current set.
+     * Since, PointerVectorSet is assumed to be sorted and unique, the incoming PointerVectorSet is not
+     * sorted and made unique again. This will not insert any elements in the incoming set, if there exists an element with a key
+     * which is equal to an element's key in the input range.
+     * @param first Other PointerVectorSet starting iterator
+     * @param last Other PointerVectorSet ending iterator
+     */
+    void insert(PointerVectorSet::iterator first, PointerVectorSet::iterator last)
+    {
+        SortedInsert(first, last);
+    }
+
     void insert(const PointerVectorSet& rOther)
     {
         insert(rOther.begin(), rOther.end());
@@ -1199,7 +1227,10 @@ class PointerVectorSet final
         // which is harder to guess, and cryptic. Hence, using the decltype.
         using iterator_value_type = std::decay_t<decltype(*Iterator)>;
 
-        if constexpr(std::is_same_v<iterator_value_type, std::remove_cv_t<TPointerType>>) {
+        if constexpr(std::is_same_v<TIteratorType, iterator> || std::is_same_v<TIteratorType, reverse_iterator>) {
+            // if the TIteratorType is of boost::indirect_iterator type, then we can get the pointer by dereferencing.
+            return *(Iterator.base());
+        } else if constexpr(std::is_same_v<iterator_value_type, std::remove_cv_t<TPointerType>>) {
             // this supports any type of pointers
             return *Iterator;
         } else if constexpr(std::is_same_v<iterator_value_type, std::remove_cv_t<value_type>> && std::is_same_v<TPointerType, Kratos::intrusive_ptr<std::decay_t<decltype(*Iterator)>>>) {