all compiled

src/shared/common/base_data_package.h

@@ -52,7 +52,8 @@ template <typename ContainedDataType>
 using DataContainerUniquePtrKeeper = UniquePtrsKeeper<ContainedDataType>;
 
 template <template <typename> typename KeeperType, template <typename> typename ContainerType>
-using DataAssemble = std::tuple<KeeperType<ContainerType<int>>,
+using DataAssemble = std::tuple<KeeperType<ContainerType<size_t>>,
+                                KeeperType<ContainerType<int>>,
                                 KeeperType<ContainerType<Real>>,
                                 KeeperType<ContainerType<Vec2d>>,
                                 KeeperType<ContainerType<Mat2d>>,

src/shared/common/base_data_type.h

@@ -138,35 +138,40 @@ struct DataTypeIndex
     static constexpr int value = std::numeric_limits<int>::max();
 };
 template <>
-struct DataTypeIndex<int>
+struct DataTypeIndex<size_t>
 {
     static constexpr int value = 0;
 };
 template <>
-struct DataTypeIndex<Real>
+struct DataTypeIndex<int>
 {
     static constexpr int value = 1;
 };
 template <>
-struct DataTypeIndex<Vec2d>
+struct DataTypeIndex<Real>
 {
     static constexpr int value = 2;
 };
 template <>
-struct DataTypeIndex<Mat2d>
+struct DataTypeIndex<Vec2d>
 {
     static constexpr int value = 3;
 };
 template <>
-struct DataTypeIndex<Vec3d>
+struct DataTypeIndex<Mat2d>
 {
     static constexpr int value = 4;
 };
 template <>
-struct DataTypeIndex<Mat3d>
+struct DataTypeIndex<Vec3d>
 {
     static constexpr int value = 5;
 };
+template <>
+struct DataTypeIndex<Mat3d>
+{
+    static constexpr int value = 6;
+};
 
 /** Verbal boolean for positive and negative axis directions. */
 const int xAxis = 0;

src/shared/io_system/io_base.cpp

@@ -52,9 +52,14 @@ RestartIO::RestartIO(SPHSystem &sph_system)
     : BaseIO(sph_system), bodies_(sph_system.getRealBodies()),
       overall_file_path_(io_environment_.restart_folder_ + "/Restart_time_")
 {
-    std::transform(bodies_.begin(), bodies_.end(), std::back_inserter(file_names_),
-                   [&](SPHBody *body) -> std::string
-                   { return io_environment_.restart_folder_ + "/" + body->getName() + "_rst_"; });
+    for (size_t i = 0; i < bodies_.size(); ++i)
+    {
+        file_names_.push_back(io_environment_.restart_folder_ + "/" + bodies_[i]->getName() + "_rst_");
+
+        // basic variable for write to restart file
+        BaseParticles &particles = bodies_[i]->getBaseParticles();
+        particles.addVariableToRestart<size_t>("OriginalID");
+    }
 }
 //=============================================================================================//
 void RestartIO::writeToFile(size_t iteration_step)

src/shared/particles/base_particles.cpp

@@ -18,7 +18,7 @@ BaseParticles::BaseParticles(SPHBody &sph_body, BaseMaterial *base_material)
       base_material_(*base_material),
       restart_xml_parser_("xml_restart", "particles"),
       reload_xml_parser_("xml_particle_reload", "particles"),
-      copy_particle_data_(all_particle_data_),
+      copy_particle_data_(all_state_data_),
       write_restart_variable_to_xml_(variables_to_restart_, restart_xml_parser_),
       write_reload_variable_to_xml_(variables_to_reload_, reload_xml_parser_),
       read_restart_variable_from_xml_(variables_to_restart_, restart_xml_parser_)
@@ -38,13 +38,11 @@ void BaseParticles::initializeBasicParticleVariables()
     //----------------------------------------------------------------------
     //		unregistered variables and data
     //----------------------------------------------------------------------
-    original_id_ = addUnregisteredVariable("OriginalID",
-                                           [&](size_t i) -> size_t
-                                           { return i; });
-    sorted_id_ = addUnregisteredVariable("SortedID",
-                                         [&](size_t i) -> size_t
-                                         { return i; });
-    sequence_ = addUnregisteredVariable("Sequence");
+    original_id_ = registerSharedVariable<size_t>("OriginalID",
+                                                  [&](size_t i) -> size_t
+                                                  { return i; });
+    sorted_id_ = registerSharedVariableFrom<size_t>("SortedID", "OriginalID");
+    sequence_ = registerSharedVariable<size_t>("Sequence");
     particle_sorting_ = particle_sort_ptr_keeper_.createPtr<ParticleSorting>(*this);
 }
 //=================================================================================================//

src/shared/particles/base_particles.h

@@ -83,7 +83,6 @@ class BaseParticles
   private:
     DataContainerUniquePtrAssemble<DiscreteVariable> all_discrete_variable_ptrs_;
     DataContainerUniquePtrAssemble<SingleVariable> all_global_variable_ptrs_;
-    UniquePtrsKeeper<DiscreteVariable<size_t>> unregistered_variable_ptrs_;
     UniquePtrKeeper<ParticleSorting> particle_sort_ptr_keeper_;
 
   public:
@@ -175,9 +174,6 @@ class BaseParticles
     ParticleVariables sortable_variables_;
     ParticleSorting *particle_sorting_;
 
-    template <typename... Args>
-    StdLargeVec<size_t> *addUnregisteredVariable(const std::string &name, Args &&...args);
-
   public:
     template <typename DataType>
     void addVariableToSort(const std::string &name);
@@ -222,7 +218,7 @@ class BaseParticles
     BaseMaterial &base_material_;
     XmlParser restart_xml_parser_;
     XmlParser reload_xml_parser_;
-    ParticleData all_particle_data_;
+    ParticleData all_state_data_; /**< all discrete variable data except those on particle IDs  */
     ParticleVariables all_discrete_variables_;
     SingleVariables all_single_variables_;
     ParticleVariables variables_to_write_;

src/shared/particles/base_particles.hpp

@@ -46,16 +46,6 @@ StdLargeVec<DataType> *BaseParticles::
     return &contained_data;
 }
 //=================================================================================================//
-template <typename... Args>
-StdLargeVec<size_t> *BaseParticles::addUnregisteredVariable(const std::string &name, Args &&...args)
-{
-
-    DiscreteVariable<size_t> *variable =
-        unregistered_variable_ptrs_.createPtr<DiscreteVariable<size_t>>(name);
-    initializeVariable(variable, std::forward<Args>(args)...);
-    return variable->DataField();
-}
-//=================================================================================================//
 template <typename DataType>
 DataType *BaseParticles::
     registerSingleVariable(const std::string &name, DataType initial_value)
@@ -107,7 +97,10 @@ StdLargeVec<DataType> *BaseParticles::registerSharedVariable(const std::string &
     {
         initializeVariable(variable, std::forward<Args>(args)...);
         constexpr int type_index = DataTypeIndex<DataType>::value;
-        std::get<type_index>(all_particle_data_).push_back(variable->DataField());
+        if (type_index != DataTypeIndex<size_t>::value) // particle IDs excluded
+        {
+            std::get<type_index>(all_state_data_).push_back(variable->DataField());
+        }
     }
 
     return variable->DataField();
@@ -211,13 +204,16 @@ DiscreteVariable<DataType> *BaseParticles::
 template <typename DataType>
 void BaseParticles::addVariableToSort(const std::string &name)
 {
-    DiscreteVariable<DataType> *new_sortable =
-        addVariableToList<DataType>(sortable_variables_, name);
-    if (new_sortable != nullptr)
+    constexpr int type_index = DataTypeIndex<DataType>::value;
+    if (type_index != DataTypeIndex<size_t>::value) // particle IDs excluded
     {
-        constexpr int type_index = DataTypeIndex<DataType>::value;
-        StdLargeVec<DataType> *variable_data = new_sortable->DataField();
-        std::get<type_index>(sortable_data_).push_back(variable_data);
+        DiscreteVariable<DataType> *new_sortable =
+            addVariableToList<DataType>(sortable_variables_, name);
+        if (new_sortable != nullptr)
+        {
+            StdLargeVec<DataType> *variable_data = new_sortable->DataField();
+            std::get<type_index>(sortable_data_).push_back(variable_data);
+        }
     }
 }
 //=================================================================================================//

src/shared/particles/particle_sorting.cpp

@@ -10,7 +10,6 @@ namespace SPH
 //=================================================================================================//
 SwapSortableParticleData::SwapSortableParticleData(BaseParticles &base_particles)
     : sequence_(base_particles.ParticleSequences()),
-      original_id_(base_particles.ParticleOriginalIds()),
       sortable_data_(base_particles.SortableParticleData()),
       swap_particle_data_value_(sortable_data_) {}
 //=================================================================================================//
@@ -20,7 +19,6 @@ void SwapSortableParticleData::operator()(size_t *a, size_t *b)
 
     size_t index_a = a - sequence_.data();
     size_t index_b = b - sequence_.data();
-    std::swap(original_id_[index_a], original_id_[index_b]);
     swap_particle_data_value_(index_a, index_b);
 }
 //=================================================================================================//
@@ -31,7 +29,10 @@ ParticleSorting::ParticleSorting(BaseParticles &base_particles)
       sequence_(base_particles.ParticleSequences()),
       swap_sortable_particle_data_(base_particles), compare_(),
       quick_sort_particle_range_(sequence_.data(), 0, compare_, swap_sortable_particle_data_),
-      quick_sort_particle_body_() {}
+      quick_sort_particle_body_()
+{
+    base_particles.addVariableToSort<size_t>("OriginalID");
+}
 //=================================================================================================//
 void ParticleSorting::sortingParticleData(size_t *begin, size_t size)
 {

src/shared/particles/particle_sorting.h

@@ -231,7 +231,6 @@ class SwapSortableParticleData
 {
   protected:
     StdLargeVec<size_t> &sequence_;
-    StdLargeVec<size_t> &original_id_;
     ParticleData &sortable_data_;
     OperationOnDataAssemble<ParticleData, SwapParticleDataValue> swap_particle_data_value_;