Merge pull request #739 from Xiangyu-Hu/xiangyu/real_ghost_particles

Two important changes: 1. I tried to use more discrete variables in base particles so that the class is more descriptive. 2. I do not use real_particles_bound_ anymore, since I propose to use total_particles_ together the already defined total_real_particles_ to determine usage of the particles.

src/shared/bodies/complex_bodies/unstructured_mesh.cpp

@@ -14,7 +14,7 @@ BaseInnerRelationInFVM::BaseInnerRelationInFVM(RealBody &real_body, ANSYSMesh &a
       Vol_(base_particles_.getVariableDataByName<Real>("VolumetricMeasure"))
 {
     subscribeToBody();
-    inner_configuration_.resize(base_particles_.RealParticlesBound(), Neighborhood());
+    inner_configuration_.resize(base_particles_.ParticlesBound(), Neighborhood());
 };
 //=============================================================================================//
 } // namespace SPH

src/shared/body_relations/base_body_relation.cpp

@@ -24,7 +24,7 @@ BaseInnerRelation::BaseInnerRelation(RealBody &real_body)
     : SPHRelation(real_body), real_body_(&real_body)
 {
     subscribeToBody();
-    inner_configuration_.resize(base_particles_.RealParticlesBound(), Neighborhood());
+    inner_configuration_.resize(base_particles_.ParticlesBound(), Neighborhood());
 }
 //=================================================================================================//
 void BaseInnerRelation::resetNeighborhoodCurrentSize()
@@ -51,7 +51,7 @@ BaseContactRelation::BaseContactRelation(SPHBody &sph_body, RealBodyVector conta
         const std::string name = contact_bodies_[k]->getName();
         contact_particles_.push_back(&contact_bodies_[k]->getBaseParticles());
         contact_adaptations_.push_back(contact_bodies_[k]->sph_adaptation_);
-        contact_configuration_[k].resize(base_particles_.RealParticlesBound(), Neighborhood());
+        contact_configuration_[k].resize(base_particles_.ParticlesBound(), Neighborhood());
     }
 }
 //=================================================================================================//

src/shared/io_system/io_base.cpp

@@ -25,25 +25,11 @@ bool BaseIO::isBodyIncluded(const SPHBodyVector &bodies, SPHBody *sph_body)
 //=============================================================================================//
 BodyStatesRecording::BodyStatesRecording(SPHSystem &sph_system)
     : BaseIO(sph_system), bodies_(sph_system.getRealBodies()),
-      state_recording_(sph_system_.StateRecording())
-{
-    for (size_t i = 0; i < bodies_.size(); ++i)
-    {
-        BaseParticles &particles = bodies_[i]->getBaseParticles();
-        dv_all_pos_.push_back(particles.getVariableByName<Vecd>("Position"));
-    }
-}
+      state_recording_(sph_system_.StateRecording()) {}
 //=============================================================================================//
 BodyStatesRecording::BodyStatesRecording(SPHBody &body)
     : BaseIO(body.getSPHSystem()), bodies_({&body}),
-      state_recording_(sph_system_.StateRecording())
-{
-    for (size_t i = 0; i < bodies_.size(); ++i)
-    {
-        BaseParticles &particles = bodies_[i]->getBaseParticles();
-        dv_all_pos_.push_back(particles.getVariableByName<Vecd>("Position"));
-    }
-}
+      state_recording_(sph_system_.StateRecording()) {}
 //=============================================================================================//
 void BodyStatesRecording::writeToFile()
 {

src/shared/io_system/io_base.h

@@ -112,8 +112,8 @@ class BodyStatesRecording : public BaseIO
             {
                 if (bodies_[i]->checkNewlyUpdated())
                 {
-                    dv_all_pos_[i]->prepareForOutput(ex_policy);
                     BaseParticles &base_particles = bodies_[i]->getBaseParticles();
+                    base_particles.dvParticlePosition()->prepareForOutput(ex_policy);
                     prepare_variable_to_write_(base_particles.VariablesToWrite(), ex_policy);
                 }
             }
@@ -166,7 +166,6 @@ class BodyStatesRecording : public BaseIO
     StdVec<BaseDynamics<void> *> derived_variables_;
     OperationOnDataAssemble<ParticleVariables, prepareVariablesToWrite> prepare_variable_to_write_;
     bool state_recording_;
-    StdVec<DiscreteVariable<Vecd> *> dv_all_pos_;
     virtual void writeWithFileName(const std::string &sequence) = 0;
 
   private:

src/shared/particle_dynamics/base_local_dynamics.h

@@ -147,6 +147,9 @@ class Average : public ReduceSumType
  * @brief Class template argument deduction (CTAD) for constructing interaction dynamics.
  * @details Note that the form "XXX" is not std::string type, so we need to use
  * std::string("XXX") to convert it to std::string type.
+ * Only the DynamicsIdentifier parameter is reference,
+ * the other parameters should not use it, use pointer
+ * instead.
  */
 template <typename DynamicsIdentifier, typename... OtherArgs>
 struct DynamicsArgs

src/shared/particles/base_particles.cpp

@@ -10,9 +10,9 @@ namespace SPH
 {
 //=================================================================================================//
 BaseParticles::BaseParticles(SPHBody &sph_body, BaseMaterial *base_material)
-    : sv_total_real_particles_(nullptr), real_particles_bound_(0), particles_bound_(0),
-      original_id_(nullptr), sorted_id_(nullptr),
-      pos_(nullptr), Vol_(nullptr), rho_(nullptr), mass_(nullptr),
+    : sv_total_real_particles_(nullptr),
+      particles_bound_(0), original_id_(nullptr), sorted_id_(nullptr),
+      dv_pos_(nullptr), Vol_(nullptr), rho_(nullptr), mass_(nullptr),
       sph_body_(sph_body), body_name_(sph_body.getName()),
       base_material_(*base_material),
       restart_xml_parser_("xml_restart", "particles"),
@@ -50,35 +50,32 @@ void BaseParticles::initializeBasicParticleVariables()
 //=================================================================================================//
 void BaseParticles::registerPositionAndVolumetricMeasure(StdLargeVec<Vecd> &pos, StdLargeVec<Real> &Vol)
 {
-    pos_ = registerStateVariableFrom<Vecd>("Position", pos);
+    dv_pos_ = registerStateVariableOnlyFrom<Vecd>("Position", pos);
     Vol_ = registerStateVariableFrom<Real>("VolumetricMeasure", Vol);
     addVariableToReload<Vecd>("Position");
     addVariableToReload<Real>("VolumetricMeasure");
 }
 //=================================================================================================//
 void BaseParticles::registerPositionAndVolumetricMeasureFromReload()
 {
-    pos_ = registerStateVariableFromReload<Vecd>("Position");
+    dv_pos_ = registerStateVariableOnlyFromReload<Vecd>("Position");
     Vol_ = registerStateVariableFromReload<Real>("VolumetricMeasure");
 }
 //=================================================================================================//
 void BaseParticles::initializeAllParticlesBounds(size_t number_of_particles)
 {
-    UnsignedInt *total_real_particles = sv_total_real_particles_->Data();
-    *total_real_particles = number_of_particles;
-    real_particles_bound_ = number_of_particles;
-    particles_bound_ = real_particles_bound_;
+    sv_total_real_particles_->setValue(number_of_particles);
+    particles_bound_ = number_of_particles;
 }
 //=================================================================================================//
 void BaseParticles::initializeAllParticlesBoundsFromReloadXml()
 {
     initializeAllParticlesBounds(reload_xml_parser_.Size(reload_xml_parser_.first_element_));
 }
 //=================================================================================================//
-void BaseParticles::increaseAllParticlesBounds(size_t buffer_size)
+void BaseParticles::increaseParticlesBounds(size_t extra_size)
 {
-    real_particles_bound_ += buffer_size;
-    particles_bound_ += buffer_size;
+    particles_bound_ += extra_size;
 }
 //=================================================================================================//
 void BaseParticles::copyFromAnotherParticle(size_t index, size_t another_index)

src/shared/particles/base_particles.h

@@ -96,13 +96,10 @@ class BaseParticles
     //----------------------------------------------------------------------
     // Global information for defining particle groups
     // total_real_particles_ gives the run-time total number of real particles.
-    // real_particles_bound_ gives the maximum possible number of real particles
-    // which is allowed in the computation.
     // particles_bound_ gives the total number of particles in all groups.
     //----------------------------------------------------------------------
   protected:
     SingularVariable<UnsignedInt> *sv_total_real_particles_;
-    UnsignedInt real_particles_bound_;
     UnsignedInt particles_bound_;
 
   public:
@@ -115,11 +112,10 @@ class BaseParticles
     UnsignedInt TotalRealParticles() { return *sv_total_real_particles_->Data(); };
     void incrementTotalRealParticles(UnsignedInt increment = 1) { *sv_total_real_particles_->Data() += increment; };
     void decrementTotalRealParticles(UnsignedInt decrement = 1) { *sv_total_real_particles_->Data() -= decrement; };
-    UnsignedInt RealParticlesBound() { return real_particles_bound_; };
     UnsignedInt ParticlesBound() { return particles_bound_; };
     void initializeAllParticlesBounds(size_t total_real_particles);
     void initializeAllParticlesBoundsFromReloadXml();
-    void increaseAllParticlesBounds(size_t buffer_size);
+    void increaseParticlesBounds(size_t extra_size);
     void copyFromAnotherParticle(size_t index, size_t another_index);
     size_t allocateGhostParticles(size_t ghost_size);
     void updateGhostParticle(size_t ghost_index, size_t index);
@@ -167,6 +163,10 @@ class BaseParticles
     DiscreteVariable<DataType> *registerStateVariableOnly(const std::string &name, Args &&...args);
     template <typename DataType>
     DiscreteVariable<DataType> *registerStateVariableOnlyFrom(const std::string &new_name, const std::string &old_name);
+    template <typename DataType>
+    DiscreteVariable<DataType> *registerStateVariableOnlyFrom(const std::string &name, const StdLargeVec<DataType> &geometric_data);
+    template <typename DataType>
+    DiscreteVariable<DataType> *registerStateVariableOnlyFromReload(const std::string &name);
 
     template <typename DataType>
     SingularVariable<DataType> *addUniqueSingularVariableOnly(const std::string &name, DataType initial_value = ZeroData<DataType>::value);
@@ -181,13 +181,9 @@ class BaseParticles
     DiscreteVariable<DataType> *addVariableToList(ParticleVariables &variable_set, const std::string &name);
     template <typename DataType>
     DiscreteVariable<DataType> *addVariableToList(ParticleVariables &variable_set, DiscreteVariable<DataType> *variable);
-    template <typename DataType>
-    void *addVariableToList(ParticleVariables &variable_set, DiscreteVariableArray<DataType> *variable);
 
-    template <typename DataType>
-    void addVariableToWrite(const std::string &name);
-    template <typename DataType>
-    void addVariableToWrite(DiscreteVariable<DataType> *variable);
+    template <typename DataType, typename... Args>
+    void addVariableToWrite(Args &&...args);
     template <typename DataType>
     void addVariableToWrite(DiscreteVariableArray<DataType> *variable_array);
     template <typename DataType>
@@ -208,8 +204,10 @@ class BaseParticles
     ParticleVariables variables_to_sort_;
 
   public:
+    template <typename DataType, typename... Args>
+    void addVariableToSort(Args &&...args);
     template <typename DataType>
-    void addVariableToSort(const std::string &name);
+    void addVariableToSort(DiscreteVariableArray<DataType> *variable_array);
     UnsignedInt *ParticleOriginalIds() { return original_id_; };
     UnsignedInt *ParticleSortedIds() { return sorted_id_; };
     ParticleData &SortableParticleData() { return sortable_data_; };
@@ -231,16 +229,17 @@ class BaseParticles
     //----------------------------------------------------------------------
     void registerPositionAndVolumetricMeasure(StdLargeVec<Vecd> &pos, StdLargeVec<Real> &Vol);
     void registerPositionAndVolumetricMeasureFromReload();
-    Vecd *ParticlePositions() { return pos_; }
+    DiscreteVariable<Vecd> *dvParticlePosition() { return dv_pos_; }
+    Vecd *ParticlePositions() { return dv_pos_->Data(); }
     Real *VolumetricMeasures() { return Vol_; }
     virtual Real ParticleVolume(size_t index) { return Vol_[index]; }
     virtual Real ParticleSpacing(size_t index) { return std::pow(Vol_[index], 1.0 / Real(Dimensions)); }
 
   protected:
-    Vecd *pos_;  /**< Position */
-    Real *Vol_;  /**< Volumetric measure, also area and length of surface and linear particle */
-    Real *rho_;  /**< Density as a fundamental property of phyiscal matter */
-    Real *mass_; /**< Mass as another fundamental property of physical matter */
+    DiscreteVariable<Vecd> *dv_pos_; /**< Discrete variable position */
+    Real *Vol_;                      /**< Volumetric measure, also area and length of surface and linear particle */
+    Real *rho_;                      /**< Density as a fundamental property of phyiscal matter */
+    Real *mass_;                     /**< Mass as another fundamental property of physical matter */
 
     SPHBody &sph_body_;
     std::string body_name_;

src/shared/particles/base_particles.hpp

@@ -120,7 +120,14 @@ DiscreteVariable<DataType> *BaseParticles::
     static_assert(DataTypeIndex<DataType>::value != DataTypeIndex<UnsignedInt>::value,
                   "\n Error: the data type UnsignedInt is not particle state variable!\n");
 
-    return registerDiscreteVariableOnly<DataType>(name, particles_bound_, std::forward<Args>(args)...);
+    DiscreteVariable<DataType> *variable =
+        registerDiscreteVariableOnly<DataType>(name, particles_bound_, std::forward<Args>(args)...);
+
+    DataType *data_field = variable->Data();
+    constexpr int type_index = DataTypeIndex<DataType>::value;
+    std::get<type_index>(all_state_data_).push_back(data_field);
+
+    return variable;
 }
 //=================================================================================================//
 template <class DataType, typename... Args>
@@ -164,6 +171,34 @@ DataType *BaseParticles::registerStateVariableFrom(
 }
 //=================================================================================================//
 template <typename DataType>
+DataType *BaseParticles::registerStateVariableFrom(
+    const std::string &name, const StdLargeVec<DataType> &geometric_data)
+{
+    DataType *data_field = registerStateVariable<DataType>(name);
+
+    for (size_t i = 0; i != geometric_data.size(); ++i)
+    {
+        data_field[i] = geometric_data[i];
+    }
+    return data_field;
+}
+//=================================================================================================//
+template <typename DataType>
+DataType *BaseParticles::registerStateVariableFromReload(const std::string &name)
+{
+    DataType *data_field = registerStateVariable<DataType>(name);
+
+    size_t index = 0;
+    for (auto child = reload_xml_parser_.first_element_->FirstChildElement(); child; child = child->NextSiblingElement())
+    {
+        reload_xml_parser_.queryAttributeValue(child, name, data_field[index]);
+        index++;
+    }
+
+    return data_field;
+}
+//=================================================================================================//
+template <typename DataType>
 DiscreteVariable<DataType> *BaseParticles::registerStateVariableOnlyFrom(
     const std::string &new_name, const std::string &old_name)
 {
@@ -182,22 +217,23 @@ DiscreteVariable<DataType> *BaseParticles::registerStateVariableOnlyFrom(
 }
 //=================================================================================================//
 template <typename DataType>
-DataType *BaseParticles::registerStateVariableFrom(
+DiscreteVariable<DataType> *BaseParticles::registerStateVariableOnlyFrom(
     const std::string &name, const StdLargeVec<DataType> &geometric_data)
 {
-    DataType *data_field = registerStateVariable<DataType>(name);
-
+    DiscreteVariable<DataType> *variable = registerStateVariableOnly<DataType>(name);
+    DataType *data_field = variable->Data();
     for (size_t i = 0; i != geometric_data.size(); ++i)
     {
         data_field[i] = geometric_data[i];
     }
-    return data_field;
+    return variable;
 }
 //=================================================================================================//
 template <typename DataType>
-DataType *BaseParticles::registerStateVariableFromReload(const std::string &name)
+DiscreteVariable<DataType> *BaseParticles::registerStateVariableOnlyFromReload(const std::string &name)
 {
-    DataType *data_field = registerStateVariable<DataType>(name);
+    DiscreteVariable<DataType> *new_variable = registerStateVariableOnly<DataType>(name);
+    DataType *data_field = new_variable->Data();
 
     size_t index = 0;
     for (auto child = reload_xml_parser_.first_element_->FirstChildElement(); child; child = child->NextSiblingElement())
@@ -206,7 +242,7 @@ DataType *BaseParticles::registerStateVariableFromReload(const std::string &name
         index++;
     }
 
-    return data_field;
+    return new_variable;
 }
 //=================================================================================================//
 template <typename DataType>
@@ -293,7 +329,7 @@ template <typename DataType>
 DiscreteVariable<DataType> *BaseParticles::
     addVariableToList(ParticleVariables &variable_set, DiscreteVariable<DataType> *variable)
 {
-    if (variable->getDataSize() < real_particles_bound_)
+    if (variable->getDataSize() < particles_bound_)
     {
         std::cout << "\n Error: The variable '" << variable->Name() << "' can not be treated as a particle variable," << std::endl;
         std::cout << "\n because the data size " << variable->getDataSize() << " is too less!" << std::endl;
@@ -312,10 +348,11 @@ DiscreteVariable<DataType> *BaseParticles::
     return nullptr; // no variable added as sortable variable
 }
 //=================================================================================================//
-template <typename DataType>
-void BaseParticles::addVariableToSort(const std::string &name)
+template <typename DataType, typename... Args>
+void BaseParticles::addVariableToSort(Args &&...args)
 {
-    DiscreteVariable<DataType> *new_sortable = addVariableToList<DataType>(variables_to_sort_, name);
+    DiscreteVariable<DataType> *new_sortable =
+        addVariableToList<DataType>(variables_to_sort_, std::forward<Args>(args)...);
     if (new_sortable != nullptr)
     {
         constexpr int type_index = DataTypeIndex<DataType>::value;
@@ -325,15 +362,19 @@ void BaseParticles::addVariableToSort(const std::string &name)
 }
 //=================================================================================================//
 template <typename DataType>
-void BaseParticles::addVariableToWrite(const std::string &name)
+void BaseParticles::addVariableToSort(DiscreteVariableArray<DataType> *variable_array)
 {
-    addVariableToList<DataType>(variables_to_write_, name);
+    StdVec<DiscreteVariable<DataType> *> variables = variable_array->getVariables();
+    for (size_t i = 0; i != variables.size(); ++i)
+    {
+        addVariableToSort<DataType>(variables[i]);
+    }
 }
 //=================================================================================================//
-template <typename DataType>
-void BaseParticles::addVariableToWrite(DiscreteVariable<DataType> *variable)
+template <typename DataType, typename... Args>
+void BaseParticles::addVariableToWrite(Args &&...args)
 {
-    addVariableToList<DataType>(variables_to_write_, variable);
+    addVariableToList<DataType>(variables_to_write_, std::forward<Args>(args)...);
 }
 //=================================================================================================//
 template <typename DataType>

src/shared/particles/particle_operation.cpp

@@ -8,6 +8,6 @@ SpawnRealParticle::SpawnRealParticle(BaseParticles *particles)
       copyable_states_(),
       dv_original_id_(particles->getVariableByName<UnsignedInt>("OriginalID")),
       sv_total_real_particles_(particles->svTotalRealParticles()),
-      real_particles_bound_(particles->RealParticlesBound()) {}
+      particles_bound_(particles->ParticlesBound()) {}
 //=================================================================================================//
 } // namespace SPH