Merge branch 'develop' into perf/buffer-csr-output

Author: mohanchen

source/source_cell/mdcell.cpp

@@ -82,8 +82,9 @@ void MDCell::sync_backing_unitcell_owned_atoms_()
     }
 }
 
-#ifdef __MPI
-void MDCell::initialize_from_ucell_(UnitCell& ucell, MPI_Comm comm, double cutoff, double skin)
+void MDCell::initialize_from_unitcell(UnitCell& ucell,
+                                      double skin,
+                                      const ModuleBase::CommunicationDomain& comm_domain)
 {
     backing_unitcell_ = &ucell;
     nat_ = ucell.nat;
@@ -100,55 +101,21 @@ void MDCell::initialize_from_ucell_(UnitCell& ucell, MPI_Comm comm, double cutof
         type_masses_[static_cast<std::size_t>(it)] = ucell.atoms[it].mass;
         type_atom_counts_[static_cast<std::size_t>(it)] = ucell.atoms[it].na;
     }
-    comm_ = comm;
-    cutoff_ = cutoff;
+    cutoff_ = 0.0;
     skin_ = skin;
-
+    neighbor_search_.reset();
+    neighbor_layout_valid_ = false;
     owned_atoms_.clear();
     ghost_atoms_.clear();
-    MPI_Comm_rank(comm_, &rank_);
-    MPI_Comm_size(comm_, &size_);
 
-    decomp_.init(comm_, latvec_, lat0_, cutoff_, skin_);
-    decomp_.split_owned_atoms_from_ucell(ucell, owned_atoms_);
-    clear_forces_(owned_atoms_);
-    exchange_ghost_atoms();
-}
-
-void MDCell::initialize_from_owned_atoms_(MPI_Comm comm, double cutoff, double skin)
-{
-    comm_ = comm;
-    cutoff_ = cutoff;
-    skin_ = skin;
+#ifdef __MPI
+    comm_ = comm_domain.communicator();
     MPI_Comm_rank(comm_, &rank_);
     MPI_Comm_size(comm_, &size_);
-    decomp_.init(comm_, latvec_, lat0_, cutoff_, skin_);
-    clear_forces_(owned_atoms_);
-    exchange_ghost_atoms();
-}
+    decomp_.init(comm_, latvec_, lat0_, 0.0, 0.0);
+    decomp_.split_owned_atoms_from_ucell(ucell, owned_atoms_);
 #else
-void MDCell::initialize_from_ucell_(UnitCell& ucell, double cutoff, double skin)
-{
-    backing_unitcell_ = &ucell;
-    nat_ = ucell.nat;
-    lat0_ = ucell.lat0;
-    omega_ = ucell.omega;
-    latvec_ = ucell.latvec;
-    gt_ = ucell.GT;
-    type_labels_.resize(static_cast<std::size_t>(ucell.ntype));
-    type_masses_.resize(static_cast<std::size_t>(ucell.ntype));
-    type_atom_counts_.resize(static_cast<std::size_t>(ucell.ntype));
-    for (int it = 0; it < ucell.ntype; ++it)
-    {
-        type_labels_[static_cast<std::size_t>(it)] = ucell.atoms[it].label;
-        type_masses_[static_cast<std::size_t>(it)] = ucell.atoms[it].mass;
-        type_atom_counts_[static_cast<std::size_t>(it)] = ucell.atoms[it].na;
-    }
-    cutoff_ = cutoff;
-    skin_ = skin;
-    owned_atoms_.clear();
-    ghost_atoms_.clear();
-
+    static_cast<void>(comm_domain);
     for (int it = 0; it < ucell.ntype; ++it)
     {
         for (int ia = 0; ia < ucell.atoms[it].na; ++ia)
@@ -164,30 +131,9 @@ void MDCell::initialize_from_ucell_(UnitCell& ucell, double cutoff, double skin)
                                              0));
         }
     }
-    exchange_ghost_atoms();
-}
-
-void MDCell::initialize_from_owned_atoms_(double cutoff, double skin)
-{
-    cutoff_ = cutoff;
-    skin_ = skin;
-    clear_forces_(owned_atoms_);
-    exchange_ghost_atoms();
-}
 #endif
 
-
-void MDCell::initialize_from_unitcell(UnitCell& ucell,
-                                      double cutoff,
-                                      double skin,
-                                      const ModuleBase::CommunicationDomain& comm_domain)
-{
-#ifdef __MPI
-    initialize_from_ucell_(ucell, comm_domain.communicator(), cutoff, skin);
-#else
-    static_cast<void>(comm_domain);
-    initialize_from_ucell_(ucell, cutoff, skin);
-#endif
+    clear_forces_(owned_atoms_);
 }
 
 void MDCell::initialize_from_owned_atoms(const ModuleBase::Matrix3& latvec,
@@ -199,7 +145,6 @@ void MDCell::initialize_from_owned_atoms(const ModuleBase::Matrix3& latvec,
                                          const std::vector<std::string>& type_labels,
                                          const std::vector<double>& type_masses,
                                          const std::vector<std::int64_t>& type_atom_counts,
-                                         double cutoff,
                                          double skin,
                                          const ModuleBase::CommunicationDomain& comm_domain)
 {
@@ -212,12 +157,42 @@ void MDCell::initialize_from_owned_atoms(const ModuleBase::Matrix3& latvec,
     type_labels_ = type_labels;
     type_masses_ = type_masses;
     type_atom_counts_ = type_atom_counts;
+    backing_unitcell_ = nullptr;
+    cutoff_ = 0.0;
+    skin_ = skin;
+    neighbor_search_.reset();
+    neighbor_layout_valid_ = false;
+    ghost_atoms_.clear();
 #ifdef __MPI
-    initialize_from_owned_atoms_(comm_domain.communicator(), cutoff, skin);
+    comm_ = comm_domain.communicator();
+    MPI_Comm_rank(comm_, &rank_);
+    MPI_Comm_size(comm_, &size_);
 #else
     static_cast<void>(comm_domain);
-    initialize_from_owned_atoms_(cutoff, skin);
 #endif
+    clear_forces_(owned_atoms_);
+}
+
+void MDCell::initialize_neighbors(double cutoff)
+{
+    if (cutoff <= 0.0)
+    {
+        throw std::runtime_error("MDCell neighbor cutoff must be positive.");
+    }
+
+    cutoff_ = cutoff;
+    neighbor_search_.reset();
+    neighbor_layout_valid_ = false;
+
+#ifdef __MPI
+    if (comm_ == MPI_COMM_NULL)
+    {
+        throw std::runtime_error("MDCell communication domain is not initialized.");
+    }
+    decomp_.init(comm_, latvec_, lat0_, cutoff_, skin_);
+#endif
+
+    migrate_owned_atoms();
 }
 
 #ifdef __MPI
@@ -341,6 +316,11 @@ void MDCell::migrate_owned_atoms()
 
 void MDCell::prepare_neighbors()
 {
+    if (cutoff_ <= 0.0)
+    {
+        throw std::runtime_error("MDCell neighbors must be initialized before use.");
+    }
+
     bool rebuild = !neighbor_layout_valid_ || neighbor_reference_frac_.size() != owned_atoms_.size();
     double local_max_displacement = 0.0;
     if (!rebuild)

source/source_cell/mdcell.h

@@ -32,7 +32,6 @@ class MDCell : public BaseCell
     MDCell& operator=(MDCell&&);
 
     void initialize_from_unitcell(UnitCell& ucell,
-                                  double cutoff,
                                   double skin,
                                   const ModuleBase::CommunicationDomain& comm_domain);
     void initialize_from_owned_atoms(const ModuleBase::Matrix3& latvec,
@@ -44,10 +43,11 @@ class MDCell : public BaseCell
                                      const std::vector<std::string>& type_labels,
                                      const std::vector<double>& type_masses,
                                      const std::vector<std::int64_t>& type_atom_counts,
-                                     double cutoff,
                                      double skin,
                                      const ModuleBase::CommunicationDomain& comm_domain);
 
+    void initialize_neighbors(double cutoff);
+
 #ifdef __MPI
     int mpi_rank() const;
     int mpi_size() const;
@@ -74,7 +74,7 @@ class MDCell : public BaseCell
     std::vector<LocalAtom>& mutable_owned_atoms();
     std::vector<LocalAtom>& mutable_ghost_atoms();
 
-    int nlocal() const { return static_cast<int>(owned_atoms_.size()); }
+    int nowned_atoms() const { return static_cast<int>(owned_atoms_.size()); }
     int nghost() const { return static_cast<int>(ghost_atoms_.size()); }
     double cutoff() const;
     bool has_backing_unitcell() const;
@@ -90,14 +90,6 @@ class MDCell : public BaseCell
     const ModuleBase::Matrix3& get_latvec() const override;
     const ModuleBase::Matrix3& get_GT() const override;
 
-#ifdef __MPI
-    void initialize_from_ucell_(UnitCell& ucell, MPI_Comm comm, double cutoff, double skin);
-    void initialize_from_owned_atoms_(MPI_Comm comm, double cutoff, double skin);
-#else
-    void initialize_from_ucell_(UnitCell& ucell, double cutoff, double skin);
-    void initialize_from_owned_atoms_(double cutoff, double skin);
-#endif
-
     void sync_backing_unitcell_geometry_();
     void sync_backing_unitcell_owned_atoms_();
     void clear_forces_(std::vector<LocalAtom>& atoms);

source/source_cell/mdcell_reader.cpp

@@ -187,15 +187,13 @@ std::vector<LocalAtom> read_owned_atoms(std::ifstream& ifs,
                                          const ModuleBase::Matrix3& primitive_latvec,
                                          const ModuleBase::Matrix3& primitive_gt,
                                          const std::vector<int>& cell_replica,
-                                         double cutoff,
-                                         double skin,
                                          std::int64_t& nat,
                                          const ModuleBase::CommunicationDomain& comm_domain)
 {
     int rank = 0;
 #ifdef __MPI
     DomainDecomposition decomposition;
-    decomposition.init(comm_domain.communicator(), metadata.latvec, metadata.lat0, cutoff, skin);
+    decomposition.init(comm_domain.communicator(), metadata.latvec, metadata.lat0, 0.0, 0.0);
     rank = comm_domain.rank();
 #endif
 
@@ -324,16 +322,10 @@ std::vector<LocalAtom> read_owned_atoms(std::ifstream& ifs,
 } // namespace
 
 MDCell MDCellReader::read_stru(const std::string& stru_file,
-                                          const std::vector<int>& cell_replica,
-                                          double cutoff,
-                                          double skin,
-                                          const ModuleBase::CommunicationDomain& comm_domain)
+                               const std::vector<int>& cell_replica,
+                               double skin,
+                               const ModuleBase::CommunicationDomain& comm_domain)
 {
-    if (cutoff <= 0.0)
-    {
-        throw std::runtime_error("MDCell requires a positive cutoff.");
-    }
-
     std::ifstream ifs(stru_file.c_str(), std::ios::in);
     if (!ifs)
     {
@@ -354,7 +346,7 @@ MDCell MDCellReader::read_stru(const std::string& stru_file,
     metadata.omega = std::abs(metadata.latvec.Det()) * metadata.lat0 * metadata.lat0 * metadata.lat0;
     std::int64_t nat = 0;
     const std::vector<LocalAtom> owned_atoms = read_owned_atoms(ifs, metadata, primitive_latvec, primitive_gt,
-                                                                  cell_replica, cutoff, skin, nat, comm_domain);
+                                                                  cell_replica, nat, comm_domain);
     MDCell mdcell;
     mdcell.initialize_from_owned_atoms(metadata.latvec,
                                        metadata.gt,
@@ -365,7 +357,6 @@ MDCell MDCellReader::read_stru(const std::string& stru_file,
                                        metadata.labels,
                                        metadata.masses,
                                        metadata.type_atom_counts,
-                                       cutoff,
                                        skin,
                                        comm_domain);
     mdcell.mutable_stru_meta() = metadata.stru_meta;

source/source_cell/mdcell_reader.h

@@ -15,7 +15,6 @@ class MDCellReader
 public:
     static MDCell read_stru(const std::string& stru_file,
                             const std::vector<int>& cell_replica,
-                            double cutoff,
                             double skin,
                             const ModuleBase::CommunicationDomain& comm_domain);
 };

source/source_cell/module_neighlist/bin_manager.cpp

@@ -182,16 +182,16 @@ void BinManager::build_atom_neighbors(
     const std::vector<NeighborAtom>& binned_atoms
 )
 {
-    assert(atoms.size() == static_cast<size_t>(neighbor_list.get_nlocal()));
+    assert(atoms.size() == static_cast<size_t>(neighbor_list.get_ncentral_atoms()));
 
     double sradius2 = sradius_ * sradius_;
 
     neighbor_list.reset();
 
     std::vector<int> neigh_tmp;
 
-    const int nlocal = neighbor_list.get_nlocal();
-    for (int i = 0; i < nlocal; i++)
+    const int ncentral_atoms = neighbor_list.get_ncentral_atoms();
+    for (int i = 0; i < ncentral_atoms; i++)
     {
         neigh_tmp.clear();
         const NeighborAtom& atom = atoms[i];

source/source_cell/module_neighlist/neighbor_list.h

@@ -12,20 +12,20 @@ class NeighborList
     NeighborList() = default;
     ~NeighborList() = default;
 
-    void initialize(std::size_t nlocal, std::size_t pgsize)
+    void initialize(std::size_t ncentral_atoms, std::size_t pgsize)
     {
-        nlocal_ = ModuleNeighList::checked_int_size(nlocal, "NeighborList local atom count");
+        ncentral_atoms_ = ModuleNeighList::checked_int_size(ncentral_atoms, "NeighborList central atom count");
         allocator_.initialize(ModuleNeighList::checked_int_size(pgsize, "NeighborList page size"));
-        numneigh_.assign(nlocal, 0);
-        firstneigh_.assign(nlocal, nullptr);
+        numneigh_.assign(ncentral_atoms, 0);
+        firstneigh_.assign(ncentral_atoms, nullptr);
     }
 
     void reset()
     {
         allocator_.reset();
     }
 
-    int get_nlocal() const { return nlocal_; }
+    int get_ncentral_atoms() const { return ncentral_atoms_; }
     int get_numneigh(int i) const { return numneigh_[i]; }
     int* get_firstneigh(int i) { return firstneigh_[i]; }
     const int* get_firstneigh(int i) const { return firstneigh_[i]; }
@@ -43,7 +43,7 @@ class NeighborList
     }
 
 private:
-    int nlocal_ = 0;
+    int ncentral_atoms_ = 0;
     std::vector<int> numneigh_;
     std::vector<int*> firstneigh_;
     PageAllocator allocator_;

source/source_cell/module_neighlist/neighbor_search.cpp

@@ -202,7 +202,7 @@ void NeighborSearch::filter_candidate_neighbors_(double cutoff, double lat0)
     const double cutoff2 = cutoff * cutoff;
     neighbor_list_.reset();
     std::vector<int> active;
-    for (int i = 0; i < candidate_neighbor_list_.get_nlocal(); ++i)
+    for (int i = 0; i < candidate_neighbor_list_.get_ncentral_atoms(); ++i)
     {
         active.clear();
         const NeighborAtom& center = all_atoms_[static_cast<std::size_t>(i)];

source/source_cell/module_neighlist/test/bin_manager_test.cpp

@@ -82,7 +82,7 @@ TEST(BinManagerUnit, EmptyAtomsBuildNeighbors)
     nl.initialize(0, 16);
 
     bm.build_atom_neighbors(nl, atoms, atoms);
-    EXPECT_EQ(nl.get_nlocal(), 0);
+    EXPECT_EQ(nl.get_ncentral_atoms(), 0);
 }
 
 TEST(BinManagerUnit, BoundaryAndExactRadius)
@@ -166,7 +166,7 @@ TEST(BinManagerUnit, GhostAtomsAreCounted)
 
     bm.build_atom_neighbors(nl, inside, all_atoms);
 
-    EXPECT_EQ(nl.get_nlocal(), 1);
+    EXPECT_EQ(nl.get_ncentral_atoms(), 1);
     EXPECT_EQ(nl.get_numneigh(0), 1);
     bool found = false;
     if (nl.get_numneigh(0) > 0 && nl.get_firstneigh(0) != nullptr) {