Merge pull request #557 from Xiangyu-Hu/refactory/revise_list_data

Xiangyu-Hu · web-flow · commit c33682b5f1b7 · 2024-04-07T23:29:27.000+02:00
reverse the list data by using pair as before.
diff --git a/src/for_2D_build/meshes/cell_linked_list_supplementary.cpp b/src/for_2D_build/meshes/cell_linked_list_supplementary.cpp
@@ -37,7 +37,6 @@ void CellLinkedList::clearCellLists()
 void CellLinkedList::UpdateCellListData(BaseParticles &base_particles)
 {
     StdLargeVec<Vecd> &pos = base_particles.pos_;
-    StdLargeVec<Real> &Vol = base_particles.Vol_;
     mesh_parallel_for(
         MeshRange(Array2i::Zero(), all_cells_),
         [&](int i, int j)
@@ -47,7 +46,7 @@ void CellLinkedList::UpdateCellListData(BaseParticles &base_particles)
             for (size_t s = 0; s != cell_list.size(); ++s)
             {
                 size_t index = cell_list[s];
-                cell_data_lists_[i][j].emplace_back(std::make_tuple(index, pos[index], Vol[index]));
+                cell_data_lists_[i][j].emplace_back(std::make_pair(index, pos[index]));
             }
         });
 }
@@ -75,18 +74,17 @@ void CellLinkedList ::insertParticleIndex(size_t particle_index, const Vecd &par
     cell_index_lists_[cellpos[0]][cellpos[1]].emplace_back(particle_index);
 }
 //=================================================================================================//
-void CellLinkedList ::InsertListDataEntry(
-    size_t particle_index, const Vecd &particle_position, Real volumetric)
+void CellLinkedList ::InsertListDataEntry(size_t particle_index, const Vecd &particle_position)
 {
     Array2i cellpos = CellIndexFromPosition(particle_position);
-    cell_data_lists_[cellpos[0]][cellpos[1]].emplace_back(
-        std::make_tuple(particle_index, particle_position, volumetric));
+    cell_data_lists_[cellpos[0]][cellpos[1]]
+        .emplace_back(std::make_pair(particle_index, particle_position));
 }
 //=================================================================================================//
 ListData CellLinkedList::findNearestListDataEntry(const Vecd &position)
 {
     Real min_distance_sqr = MaxReal;
-    ListData nearest_entry(MaxSize_t, MaxReal * Vecd::Ones(), MaxReal);
+    ListData nearest_entry(MaxSize_t, MaxReal * Vecd::Ones());
 
     Array2i cell = CellIndexFromPosition(position);
     mesh_for_each(
diff --git a/src/for_3D_build/meshes/cell_linked_list_supplementary.cpp b/src/for_3D_build/meshes/cell_linked_list_supplementary.cpp
@@ -35,7 +35,6 @@ void CellLinkedList::clearCellLists()
 void CellLinkedList::UpdateCellListData(BaseParticles &base_particles)
 {
     StdLargeVec<Vecd> &pos = base_particles.pos_;
-    StdLargeVec<Real> &Vol = base_particles.Vol_;
     mesh_parallel_for(
         MeshRange(Array3i::Zero(), all_cells_),
         [&](int i, int j, int k)
@@ -45,7 +44,7 @@ void CellLinkedList::UpdateCellListData(BaseParticles &base_particles)
             for (size_t s = 0; s != cell_list.size(); ++s)
             {
                 size_t index = cell_list[s];
-                cell_data_lists_[i][j][k].emplace_back(std::make_tuple(index, pos[index], Vol[index]));
+                cell_data_lists_[i][j][k].emplace_back(std::make_pair(index, pos[index]));
             }
         });
 }
@@ -72,18 +71,17 @@ void CellLinkedList ::insertParticleIndex(size_t particle_index, const Vecd &par
     cell_index_lists_[cell_pos[0]][cell_pos[1]][cell_pos[2]].emplace_back(particle_index);
 }
 //=================================================================================================//
-void CellLinkedList ::InsertListDataEntry(size_t particle_index,
-                                          const Vecd &particle_position, Real volumetric)
+void CellLinkedList ::InsertListDataEntry(size_t particle_index, const Vecd &particle_position)
 {
     Array3i cell_pos = CellIndexFromPosition(particle_position);
     cell_data_lists_[cell_pos[0]][cell_pos[1]][cell_pos[2]].emplace_back(
-        std::make_tuple(particle_index, particle_position, volumetric));
+        std::make_pair(particle_index, particle_position));
 }
 //=================================================================================================//
 ListData CellLinkedList::findNearestListDataEntry(const Vecd &position)
 {
     Real min_distance_sqr = MaxReal;
-    ListData nearest_entry = std::make_tuple(MaxSize_t, MaxReal * Vecd::Ones(), MaxReal);
+    ListData nearest_entry = std::make_pair(MaxSize_t, MaxReal * Vecd::Ones());
 
     Array3i cell = CellIndexFromPosition(position);
     mesh_for_each(
diff --git a/src/for_3D_build/particle_generator/particle_generator_network.cpp b/src/for_3D_build/particle_generator/particle_generator_network.cpp
@@ -23,7 +23,7 @@ ParticleGenerator<Network>::
     Vecd end_direction = displacement / (displacement.norm() + TinyReal);
     /** Add initial particle to the first branch of the tree. */
     growAParticleOnBranch(tree_->root_, starting_pnt_, end_direction);
-    cell_linked_list_.InsertListDataEntry(0, pos_[0], segment_length_);
+    cell_linked_list_.InsertListDataEntry(0, pos_[0]);
 }
 //=================================================================================================//
 void ParticleGenerator<Network>::
@@ -157,7 +157,7 @@ bool ParticleGenerator<Network>::
 
         for (const size_t &particle_idx : new_branch->inner_particles_)
         {
-            cell_linked_list_.InsertListDataEntry(particle_idx, pos_[particle_idx], segment_length_);
+            cell_linked_list_.InsertListDataEntry(particle_idx, pos_[particle_idx]);
         }
     }
 
diff --git a/src/shared/bodies/complex_bodies/tree_body.cpp b/src/shared/bodies/complex_bodies/tree_body.cpp
@@ -21,12 +21,11 @@ void TreeBody::buildParticleConfiguration(ParticleConfiguration &particle_config
     neighboring_ids.push_back(branches_[1]->inner_particles_[1]);
     /** Build configuration. */
     const StdLargeVec<Vecd> &pos = base_particles_->pos_;
-    const StdLargeVec<Real> &Vol = base_particles_->Vol_;
     NeighborBuilderInner neighbor_relation_inner(*this);
     for (size_t n = 0; n != neighboring_ids.size(); ++n)
     {
         size_t index_j = neighboring_ids[n];
-        ListData list_data_j = std::make_tuple(index_j, pos[index_j], Vol[index_j]);
+        ListData list_data_j = std::make_pair(index_j, pos[index_j]);
         Neighborhood &neighborhood = particle_configuration[particle_id];
         neighbor_relation_inner(neighborhood, pos[particle_id], particle_id, list_data_j);
     }
@@ -93,7 +92,7 @@ void TreeBody::buildParticleConfiguration(ParticleConfiguration &particle_config
         for (size_t n = 0; n != neighboring_ids.size(); ++n)
         {
             size_t index_j = neighboring_ids[n];
-            ListData list_data_j = std::make_tuple(index_j, pos[index_j], Vol[index_j]);
+            ListData list_data_j = std::make_pair(index_j, pos[index_j]);
             Neighborhood &neighborhood = particle_configuration[particle_id];
             neighbor_relation_inner(neighborhood, pos[particle_id], particle_id, list_data_j);
         }
@@ -165,7 +164,7 @@ void TreeBody::buildParticleConfiguration(ParticleConfiguration &particle_config
                 for (size_t n = 0; n != neighboring_ids.size(); ++n)
                 {
                     size_t index_j = neighboring_ids[n];
-                    ListData list_data_j = std::make_tuple(index_j, pos[index_j], Vol[index_j]);
+                    ListData list_data_j = std::make_pair(index_j, pos[index_j]);
                     Neighborhood &neighborhood = particle_configuration[particle_id];
                     neighbor_relation_inner(neighborhood, pos[particle_id], particle_id, list_data_j);
                 }
@@ -203,7 +202,7 @@ void TreeBody::buildParticleConfiguration(ParticleConfiguration &particle_config
                 for (size_t n = 0; n != neighboring_ids.size(); ++n)
                 {
                     size_t index_j = neighboring_ids[n];
-                    ListData list_data_j = std::make_tuple(index_j, pos[index_j], Vol[index_j]);
+                    ListData list_data_j = std::make_pair(index_j, pos[index_j]);
                     Neighborhood &neighborhood = particle_configuration[particle_id];
                     neighbor_relation_inner(neighborhood, pos[particle_id], particle_id, list_data_j);
                 }
diff --git a/src/shared/common/sph_data_containers.h b/src/shared/common/sph_data_containers.h
@@ -58,7 +58,7 @@ using ConcurrentIndexVector = ConcurrentVec<size_t>;
 using ParticlesBound = std::pair<size_t, size_t>;
 
 /** List data pair: first for indexes, second for particle position. */
-using ListData = std::tuple<size_t, Vecd, Real>;
+using ListData = std::pair<size_t, Vecd>;
 using ListDataVector = StdLargeVec<ListData>;
 using DataListsInCells = StdLargeVec<ListDataVector *>;
 using ConcurrentCellLists = ConcurrentVec<ConcurrentIndexVector *>;
diff --git a/src/shared/meshes/cell_linked_list.cpp b/src/shared/meshes/cell_linked_list.cpp
@@ -100,18 +100,16 @@ size_t MultilevelCellLinkedList::getMeshLevel(Real particle_cutoff_radius)
     return 999; // means an error in level searching
 };
 //=================================================================================================//
-void MultilevelCellLinkedList::
-    insertParticleIndex(size_t particle_index, const Vecd &particle_position)
+void MultilevelCellLinkedList::insertParticleIndex(size_t particle_index, const Vecd &particle_position)
 {
     size_t level = getMeshLevel(kernel_.CutOffRadius(h_ratio_[particle_index]));
     mesh_levels_[level]->insertParticleIndex(particle_index, particle_position);
 }
 //=================================================================================================//
-void MultilevelCellLinkedList::
-    InsertListDataEntry(size_t particle_index, const Vecd &particle_position, Real volumetric)
+void MultilevelCellLinkedList::InsertListDataEntry(size_t particle_index, const Vecd &particle_position)
 {
     size_t level = getMeshLevel(kernel_.CutOffRadius(h_ratio_[particle_index]));
-    mesh_levels_[level]->InsertListDataEntry(particle_index, particle_position, volumetric);
+    mesh_levels_[level]->InsertListDataEntry(particle_index, particle_position);
 }
 //=================================================================================================//
 void MultilevelCellLinkedList::UpdateCellLists(BaseParticles &base_particles)
diff --git a/src/shared/meshes/cell_linked_list.h b/src/shared/meshes/cell_linked_list.h
@@ -69,7 +69,7 @@ class BaseCellLinkedList : public BaseMeshField
     /** Insert a cell-linked_list entry to the concurrent index list. */
     virtual void insertParticleIndex(size_t particle_index, const Vecd &particle_position) = 0;
     /** Insert a cell-linked_list entry of the index and particle position pair. */
-    virtual void InsertListDataEntry(size_t particle_index, const Vecd &particle_position, Real volumetric) = 0;
+    virtual void InsertListDataEntry(size_t particle_index, const Vecd &particle_position) = 0;
     /** find the nearest list data entry */
     virtual ListData findNearestListDataEntry(const Vecd &position) = 0;
     /** computing the sequence which indicate the order of sorted particle data */
@@ -117,7 +117,7 @@ class CellLinkedList : public BaseCellLinkedList, public Mesh
     void UpdateCellListData(BaseParticles &base_particles);
     virtual void UpdateCellLists(BaseParticles &base_particles) override;
     void insertParticleIndex(size_t particle_index, const Vecd &particle_position) override;
-    void InsertListDataEntry(size_t particle_index, const Vecd &particle_position, Real volumetric) override;
+    void InsertListDataEntry(size_t particle_index, const Vecd &particle_position) override;
     virtual ListData findNearestListDataEntry(const Vecd &position) override;
     virtual StdLargeVec<size_t> &computingSequence(BaseParticles &base_particles) override;
     virtual void tagBodyPartByCell(ConcurrentCellLists &cell_lists, std::function<bool(Vecd, Real)> &check_included) override;
@@ -152,8 +152,8 @@ class MultilevelCellLinkedList : public MultilevelMesh<BaseCellLinkedList, CellL
 
     virtual void UpdateCellLists(BaseParticles &base_particles) override;
     void insertParticleIndex(size_t particle_index, const Vecd &particle_position) override;
-    void InsertListDataEntry(size_t particle_index, const Vecd &particle_position, Real volumetric) override;
-    virtual ListData findNearestListDataEntry(const Vecd &position) override { return ListData(0, Vecd::Zero(), 0); };
+    void InsertListDataEntry(size_t particle_index, const Vecd &particle_position) override;
+    virtual ListData findNearestListDataEntry(const Vecd &position) override { return ListData(0, Vecd::Zero()); }; // mocking, not implemented
     virtual StdLargeVec<size_t> &computingSequence(BaseParticles &base_particles) override;
     virtual void tagBodyPartByCell(ConcurrentCellLists &cell_lists, std::function<bool(Vecd, Real)> &check_included) override;
     virtual void tagBoundingCells(StdVec<CellLists> &cell_data_lists, const BoundingBox &bounding_bounds, int axis) override{};
diff --git a/src/shared/particle_dynamics/general_dynamics/domian_bouding/domain_bounding.cpp b/src/shared/particle_dynamics/general_dynamics/domian_bouding/domain_bounding.cpp
@@ -27,8 +27,7 @@ void PeriodicConditionUsingCellLinkedList::
             Vecd translated_position = particle_position - periodic_translation_;
             /** insert ghost particle to cell linked list */
             mutex_cell_list_entry_.lock();
-            cell_linked_list_.InsertListDataEntry(std::get<0>(cell_list_data[num]),
-                                                  translated_position, std::get<2>(cell_list_data[num]));
+            cell_linked_list_.InsertListDataEntry(cell_list_data[num].first, translated_position);
             mutex_cell_list_entry_.unlock();
         }
     }
@@ -46,8 +45,7 @@ void PeriodicConditionUsingCellLinkedList::
             Vecd translated_position = particle_position + periodic_translation_;
             /** insert ghost particle to cell linked list */
             mutex_cell_list_entry_.lock();
-            cell_linked_list_.InsertListDataEntry(std::get<0>(cell_list_data[num]),
-                                                  translated_position, std::get<2>(cell_list_data[num]));
+            cell_linked_list_.InsertListDataEntry(cell_list_data[num].first, translated_position);
             mutex_cell_list_entry_.unlock();
         }
     }
diff --git a/src/shared/particle_dynamics/general_dynamics/domian_bouding/ghost_bounding.cpp b/src/shared/particle_dynamics/general_dynamics/domian_bouding/ghost_bounding.cpp
@@ -74,8 +74,7 @@ void PeriodicConditionUsingGhostParticles::CreatPeriodicGhostParticles::checkLow
         base_particles_.updateGhostParticle(lower_ghost_bound_.second, index_i);
         pos_[lower_ghost_bound_.second] = particle_position + periodic_translation_;
         /** insert ghost particle to cell linked list */
-        cell_linked_list_.InsertListDataEntry(lower_ghost_bound_.second,
-                                              pos_[lower_ghost_bound_.second], Vol_[index_i]);
+        cell_linked_list_.InsertListDataEntry(lower_ghost_bound_.second, pos_[lower_ghost_bound_.second]);
         lower_ghost_bound_.second++;
         ghost_boundary_.checkWithinGhostSize(lower_ghost_bound_);
         mutex_create_ghost_particle_.unlock();
@@ -92,8 +91,7 @@ void PeriodicConditionUsingGhostParticles::CreatPeriodicGhostParticles::checkUpp
         base_particles_.updateGhostParticle(upper_ghost_bound_.second, index_i);
         pos_[upper_ghost_bound_.second] = particle_position - periodic_translation_;
         /** insert ghost particle to cell linked list */
-        cell_linked_list_.InsertListDataEntry(upper_ghost_bound_.second,
-                                              pos_[upper_ghost_bound_.second], Vol_[index_i]);
+        cell_linked_list_.InsertListDataEntry(upper_ghost_bound_.second, pos_[upper_ghost_bound_.second]);
         upper_ghost_bound_.second++;
         ghost_boundary_.checkWithinGhostSize(upper_ghost_bound_);
         mutex_create_ghost_particle_.unlock();
diff --git a/src/shared/particle_neighborhood/neighborhood.cpp b/src/shared/particle_neighborhood/neighborhood.cpp
diff --git a/src/shared/particle_neighborhood/neighborhood.h b/src/shared/particle_neighborhood/neighborhood.h

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,6 @@ void CellLinkedList::clearCellLists()`
`37`	`37`	`void CellLinkedList::UpdateCellListData(BaseParticles &base_particles)`
`38`	`38`	`{`
`39`	`39`	`StdLargeVec<Vecd> &pos = base_particles.pos_;`
`40`		`- StdLargeVec<Real> &Vol = base_particles.Vol_;`
`41`	`40`	`mesh_parallel_for(`
`42`	`41`	`MeshRange(Array2i::Zero(), all_cells_),`
`43`	`42`	`[&](int i, int j)`
`@@ -47,7 +46,7 @@ void CellLinkedList::UpdateCellListData(BaseParticles &base_particles)`
`47`	`46`	`for (size_t s = 0; s != cell_list.size(); ++s)`
`48`	`47`	`{`
`49`	`48`	`size_t index = cell_list[s];`
`50`		`- cell_data_lists_[i][j].emplace_back(std::make_tuple(index, pos[index], Vol[index]));`
	`49`	`+ cell_data_lists_[i][j].emplace_back(std::make_pair(index, pos[index]));`
`51`	`50`	`}`
`52`	`51`	`});`
`53`	`52`	`}`
`@@ -75,18 +74,17 @@ void CellLinkedList ::insertParticleIndex(size_t particle_index, const Vecd &par`
`75`	`74`	`cell_index_lists_[cellpos[0]][cellpos[1]].emplace_back(particle_index);`
`76`	`75`	`}`
`77`	`76`	`//=================================================================================================//`
`78`		`-void CellLinkedList ::InsertListDataEntry(`
`79`		`- size_t particle_index, const Vecd &particle_position, Real volumetric)`
	`77`	`+void CellLinkedList ::InsertListDataEntry(size_t particle_index, const Vecd &particle_position)`
`80`	`78`	`{`
`81`	`79`	`Array2i cellpos = CellIndexFromPosition(particle_position);`
`82`		`- cell_data_lists_[cellpos[0]][cellpos[1]].emplace_back(`
`83`		`- std::make_tuple(particle_index, particle_position, volumetric));`
	`80`	`+ cell_data_lists_[cellpos[0]][cellpos[1]]`
	`81`	`+ .emplace_back(std::make_pair(particle_index, particle_position));`
`84`	`82`	`}`
`85`	`83`	`//=================================================================================================//`
`86`	`84`	`ListData CellLinkedList::findNearestListDataEntry(const Vecd &position)`
`87`	`85`	`{`
`88`	`86`	`Real min_distance_sqr = MaxReal;`
`89`		`- ListData nearest_entry(MaxSize_t, MaxReal * Vecd::Ones(), MaxReal);`
	`87`	`+ ListData nearest_entry(MaxSize_t, MaxReal * Vecd::Ones());`
`90`	`88`
`91`	`89`	`Array2i cell = CellIndexFromPosition(position);`
`92`	`90`	`mesh_for_each(`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,6 @@ void CellLinkedList::clearCellLists()`
`35`	`35`	`void CellLinkedList::UpdateCellListData(BaseParticles &base_particles)`
`36`	`36`	`{`
`37`	`37`	`StdLargeVec<Vecd> &pos = base_particles.pos_;`
`38`		`- StdLargeVec<Real> &Vol = base_particles.Vol_;`
`39`	`38`	`mesh_parallel_for(`
`40`	`39`	`MeshRange(Array3i::Zero(), all_cells_),`
`41`	`40`	`[&](int i, int j, int k)`
`@@ -45,7 +44,7 @@ void CellLinkedList::UpdateCellListData(BaseParticles &base_particles)`
`45`	`44`	`for (size_t s = 0; s != cell_list.size(); ++s)`
`46`	`45`	`{`
`47`	`46`	`size_t index = cell_list[s];`
`48`		`- cell_data_lists_[i][j][k].emplace_back(std::make_tuple(index, pos[index], Vol[index]));`
	`47`	`+ cell_data_lists_[i][j][k].emplace_back(std::make_pair(index, pos[index]));`
`49`	`48`	`}`
`50`	`49`	`});`
`51`	`50`	`}`
`@@ -72,18 +71,17 @@ void CellLinkedList ::insertParticleIndex(size_t particle_index, const Vecd &par`
`72`	`71`	`cell_index_lists_[cell_pos[0]][cell_pos[1]][cell_pos[2]].emplace_back(particle_index);`
`73`	`72`	`}`
`74`	`73`	`//=================================================================================================//`
`75`		`-void CellLinkedList ::InsertListDataEntry(size_t particle_index,`
`76`		`- const Vecd &particle_position, Real volumetric)`
	`74`	`+void CellLinkedList ::InsertListDataEntry(size_t particle_index, const Vecd &particle_position)`
`77`	`75`	`{`
`78`	`76`	`Array3i cell_pos = CellIndexFromPosition(particle_position);`
`79`	`77`	`cell_data_lists_[cell_pos[0]][cell_pos[1]][cell_pos[2]].emplace_back(`
`80`		`- std::make_tuple(particle_index, particle_position, volumetric));`
	`78`	`+ std::make_pair(particle_index, particle_position));`
`81`	`79`	`}`
`82`	`80`	`//=================================================================================================//`
`83`	`81`	`ListData CellLinkedList::findNearestListDataEntry(const Vecd &position)`
`84`	`82`	`{`
`85`	`83`	`Real min_distance_sqr = MaxReal;`
`86`		`- ListData nearest_entry = std::make_tuple(MaxSize_t, MaxReal * Vecd::Ones(), MaxReal);`
	`84`	`+ ListData nearest_entry = std::make_pair(MaxSize_t, MaxReal * Vecd::Ones());`
`87`	`85`
`88`	`86`	`Array3i cell = CellIndexFromPosition(position);`
`89`	`87`	`mesh_for_each(`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ ParticleGenerator<Network>::`
`23`	`23`	`Vecd end_direction = displacement / (displacement.norm() + TinyReal);`
`24`	`24`	`/** Add initial particle to the first branch of the tree. */`
`25`	`25`	`growAParticleOnBranch(tree_->root_, starting_pnt_, end_direction);`
`26`		`- cell_linked_list_.InsertListDataEntry(0, pos_[0], segment_length_);`
	`26`	`+ cell_linked_list_.InsertListDataEntry(0, pos_[0]);`
`27`	`27`	`}`
`28`	`28`	`//=================================================================================================//`
`29`	`29`	`void ParticleGenerator<Network>::`
`@@ -157,7 +157,7 @@ bool ParticleGenerator<Network>::`
`157`	`157`
`158`	`158`	`for (const size_t &particle_idx : new_branch->inner_particles_)`
`159`	`159`	`{`
`160`		`- cell_linked_list_.InsertListDataEntry(particle_idx, pos_[particle_idx], segment_length_);`
	`160`	`+ cell_linked_list_.InsertListDataEntry(particle_idx, pos_[particle_idx]);`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,11 @@ void TreeBody::buildParticleConfiguration(ParticleConfiguration &particle_config`
`21`	`21`	`neighboring_ids.push_back(branches_[1]->inner_particles_[1]);`
`22`	`22`	`/** Build configuration. */`
`23`	`23`	`const StdLargeVec<Vecd> &pos = base_particles_->pos_;`
`24`		`- const StdLargeVec<Real> &Vol = base_particles_->Vol_;`
`25`	`24`	`NeighborBuilderInner neighbor_relation_inner(*this);`
`26`	`25`	`for (size_t n = 0; n != neighboring_ids.size(); ++n)`
`27`	`26`	`{`
`28`	`27`	`size_t index_j = neighboring_ids[n];`
`29`		`- ListData list_data_j = std::make_tuple(index_j, pos[index_j], Vol[index_j]);`
	`28`	`+ ListData list_data_j = std::make_pair(index_j, pos[index_j]);`
`30`	`29`	`Neighborhood &neighborhood = particle_configuration[particle_id];`
`31`	`30`	`neighbor_relation_inner(neighborhood, pos[particle_id], particle_id, list_data_j);`
`32`	`31`	`}`
`@@ -93,7 +92,7 @@ void TreeBody::buildParticleConfiguration(ParticleConfiguration &particle_config`
`93`	`92`	`for (size_t n = 0; n != neighboring_ids.size(); ++n)`
`94`	`93`	`{`
`95`	`94`	`size_t index_j = neighboring_ids[n];`
`96`		`- ListData list_data_j = std::make_tuple(index_j, pos[index_j], Vol[index_j]);`
	`95`	`+ ListData list_data_j = std::make_pair(index_j, pos[index_j]);`
`97`	`96`	`Neighborhood &neighborhood = particle_configuration[particle_id];`
`98`	`97`	`neighbor_relation_inner(neighborhood, pos[particle_id], particle_id, list_data_j);`
`99`	`98`	`}`
`@@ -165,7 +164,7 @@ void TreeBody::buildParticleConfiguration(ParticleConfiguration &particle_config`
`165`	`164`	`for (size_t n = 0; n != neighboring_ids.size(); ++n)`
`166`	`165`	`{`
`167`	`166`	`size_t index_j = neighboring_ids[n];`
`168`		`- ListData list_data_j = std::make_tuple(index_j, pos[index_j], Vol[index_j]);`
	`167`	`+ ListData list_data_j = std::make_pair(index_j, pos[index_j]);`
`169`	`168`	`Neighborhood &neighborhood = particle_configuration[particle_id];`
`170`	`169`	`neighbor_relation_inner(neighborhood, pos[particle_id], particle_id, list_data_j);`
`171`	`170`	`}`
`@@ -203,7 +202,7 @@ void TreeBody::buildParticleConfiguration(ParticleConfiguration &particle_config`
`203`	`202`	`for (size_t n = 0; n != neighboring_ids.size(); ++n)`
`204`	`203`	`{`
`205`	`204`	`size_t index_j = neighboring_ids[n];`
`206`		`- ListData list_data_j = std::make_tuple(index_j, pos[index_j], Vol[index_j]);`
	`205`	`+ ListData list_data_j = std::make_pair(index_j, pos[index_j]);`
`207`	`206`	`Neighborhood &neighborhood = particle_configuration[particle_id];`
`208`	`207`	`neighbor_relation_inner(neighborhood, pos[particle_id], particle_id, list_data_j);`
`209`	`208`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,18 +100,16 @@ size_t MultilevelCellLinkedList::getMeshLevel(Real particle_cutoff_radius)`
`100`	`100`	`return 999; // means an error in level searching`
`101`	`101`	`};`
`102`	`102`	`//=================================================================================================//`
`103`		`-void MultilevelCellLinkedList::`
`104`		`- insertParticleIndex(size_t particle_index, const Vecd &particle_position)`
	`103`	`+void MultilevelCellLinkedList::insertParticleIndex(size_t particle_index, const Vecd &particle_position)`
`105`	`104`	`{`
`106`	`105`	`size_t level = getMeshLevel(kernel_.CutOffRadius(h_ratio_[particle_index]));`
`107`	`106`	`mesh_levels_[level]->insertParticleIndex(particle_index, particle_position);`
`108`	`107`	`}`
`109`	`108`	`//=================================================================================================//`
`110`		`-void MultilevelCellLinkedList::`
`111`		`- InsertListDataEntry(size_t particle_index, const Vecd &particle_position, Real volumetric)`
	`109`	`+void MultilevelCellLinkedList::InsertListDataEntry(size_t particle_index, const Vecd &particle_position)`
`112`	`110`	`{`
`113`	`111`	`size_t level = getMeshLevel(kernel_.CutOffRadius(h_ratio_[particle_index]));`
`114`		`- mesh_levels_[level]->InsertListDataEntry(particle_index, particle_position, volumetric);`
	`112`	`+ mesh_levels_[level]->InsertListDataEntry(particle_index, particle_position);`
`115`	`113`	`}`
`116`	`114`	`//=================================================================================================//`
`117`	`115`	`void MultilevelCellLinkedList::UpdateCellLists(BaseParticles &base_particles)`
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,7 @@ void PeriodicConditionUsingCellLinkedList::`
`27`	`27`	`Vecd translated_position = particle_position - periodic_translation_;`
`28`	`28`	`/** insert ghost particle to cell linked list */`
`29`	`29`	`mutex_cell_list_entry_.lock();`
`30`		`- cell_linked_list_.InsertListDataEntry(std::get<0>(cell_list_data[num]),`
`31`		`- translated_position, std::get<2>(cell_list_data[num]));`
	`30`	`+ cell_linked_list_.InsertListDataEntry(cell_list_data[num].first, translated_position);`
`32`	`31`	`mutex_cell_list_entry_.unlock();`
`33`	`32`	`}`
`34`	`33`	`}`
`@@ -46,8 +45,7 @@ void PeriodicConditionUsingCellLinkedList::`
`46`	`45`	`Vecd translated_position = particle_position + periodic_translation_;`
`47`	`46`	`/** insert ghost particle to cell linked list */`
`48`	`47`	`mutex_cell_list_entry_.lock();`
`49`		`- cell_linked_list_.InsertListDataEntry(std::get<0>(cell_list_data[num]),`
`50`		`- translated_position, std::get<2>(cell_list_data[num]));`
	`48`	`+ cell_linked_list_.InsertListDataEntry(cell_list_data[num].first, translated_position);`
`51`	`49`	`mutex_cell_list_entry_.unlock();`
`52`	`50`	`}`
`53`	`51`	`}`