refactor(nlist): move nprocs into InputNlist constructors

Replaces the ``set_nprocs(comm->nprocs)`` setter with a constructor
parameter on both ``InputNlist`` overloads (lightweight and comm-aware)
and the matching ``DP_NewNlist`` / ``DP_NewNlist_comm`` C entry points
plus the hpp wrappers.  ``nprocs`` is a conceptual sibling of ``world``
and ``nswap`` and lives more naturally in the initializer than as a
post-construction setter.  Default value 1 keeps direct C++ API
consumers source-compatible — they need not pass anything.

- ``InputNlist`` lightweight ctor: new trailing ``int nprocs_ = 1``.
- ``InputNlist`` comm-aware ctor: new trailing ``int nprocs_ = 1``.
- ``DP_NewNlist`` / ``DP_NewNlist_comm``: new trailing ``int nprocs``
  arg (no default — C API).
- ``deepmd::hpp::InputNlist`` ctors: new trailing ``int nprocs = 1``.
- ``DP_NlistSetNprocs`` / ``set_nprocs`` removed (single-use in-tree).
- ``pair_deepmd.cpp``, ``pair_deepspin.cpp``, ``fix_dplr.cpp`` now pass
  ``comm->nprocs`` directly in the constructor call.
- Update stale comments in ``DeepPotPTExpt.cc`` and ``DeepSpinPTExpt.cc``
  to reference the constructor parameter instead of the removed setter.

Author: Han Wang

source/api_c/include/c_api.h

@@ -27,10 +27,8 @@ typedef struct DP_Nlist DP_Nlist;
  * @param[in] Array stores the core region atom's neighbor index
  * @returns A pointer to the neighbor list.
  **/
-extern DP_Nlist* DP_NewNlist(int inum_,
-                             int* ilist_,
-                             int* numneigh_,
-                             int** firstneigh_);
+extern DP_Nlist* DP_NewNlist(
+    int inum_, int* ilist_, int* numneigh_, int** firstneigh_, int nprocs);
 /**
  * @brief Create a new neighbor list with communication capabilities.
  * @details This function extends DP_NewNlist by adding support for parallel
@@ -52,6 +50,9 @@ extern DP_Nlist* DP_NewNlist(int inum_,
  * each swap.
  * @param[in] world Pointer to the MPI communicator or similar communication
  * world used for the operation.
+ * @param[in] nprocs Number of MPI ranks (1 = single-rank).  Used by
+ * ``DeepPotPTExpt`` / ``DeepSpinPTExpt`` to choose between the regular
+ * and with-comm artifacts.  Defaults to 1 if not supplied.
  * @returns A pointer to the initialized neighbor list with communication
  * capabilities.
  */
@@ -66,7 +67,8 @@ extern DP_Nlist* DP_NewNlist_comm(int inum_,
                                   int** sendlist,
                                   int* sendproc,
                                   int* recvproc,
-                                  void* world);
+                                  void* world,
+                                  int nprocs);
 
 /**
  * @brief Set mask for a neighbor list.
@@ -88,16 +90,6 @@ extern void DP_NlistSetMask(DP_Nlist* nl, int mask);
  **/
 extern void DP_NlistSetMapping(DP_Nlist* nl, int* mapping);
 
-/**
- * @brief Set the number of MPI ranks for a neighbor list.
- *
- * @param nl Neighbor list.
- * @param nprocs Number of MPI ranks (1 = single-rank).
- * @since API version 26
- *
- **/
-extern void DP_NlistSetNprocs(DP_Nlist* nl, int nprocs);
-
 /**
  * @brief Delete a neighbor list.
  *

source/api_c/include/deepmd.hpp

@@ -809,15 +809,16 @@ struct InputNlist {
         ilist(nullptr),
         numneigh(nullptr),
         firstneigh(nullptr),
-        nl(DP_NewNlist(0, nullptr, nullptr, nullptr)) {
+        nl(DP_NewNlist(0, nullptr, nullptr, nullptr, 1)) {
     DP_CHECK_OK(DP_NlistCheckOK, nl);
   };
-  InputNlist(int inum_, int* ilist_, int* numneigh_, int** firstneigh_)
+  InputNlist(
+      int inum_, int* ilist_, int* numneigh_, int** firstneigh_, int nprocs = 1)
       : inum(inum_),
         ilist(ilist_),
         numneigh(numneigh_),
         firstneigh(firstneigh_),
-        nl(DP_NewNlist(inum_, ilist_, numneigh_, firstneigh_)) {
+        nl(DP_NewNlist(inum_, ilist_, numneigh_, firstneigh_, nprocs)) {
     DP_CHECK_OK(DP_NlistCheckOK, nl);
   };
   InputNlist(int inum_,
@@ -831,7 +832,8 @@ struct InputNlist {
              int** sendlist,
              int* sendproc,
              int* recvproc,
-             void* world)
+             void* world,
+             int nprocs = 1)
       : inum(inum_),
         ilist(ilist_),
         numneigh(numneigh_),
@@ -847,7 +849,8 @@ struct InputNlist {
                             sendlist,
                             sendproc,
                             recvproc,
-                            world)) {};
+                            world,
+                            nprocs)) {};
   ~InputNlist() { DP_DeleteNlist(nl); };
   /// @brief C API neighbor list.
   DP_Nlist* nl;
@@ -868,11 +871,6 @@ struct InputNlist {
    * @param mapping mapping from all atoms to real atoms, in size nall.
    */
   void set_mapping(int* mapping) { DP_NlistSetMapping(nl, mapping); };
-  /**
-   * @brief Set the number of MPI ranks for this neighbor list.
-   * @param nprocs Number of MPI ranks (1 = single-rank).
-   */
-  void set_nprocs(int nprocs) { DP_NlistSetNprocs(nl, nprocs); };
 };
 
 /**
@@ -900,7 +898,7 @@ void inline convert_nlist(InputNlist& to_nlist,
   // delete the original nl
   DP_DeleteNlist(to_nlist.nl);
   to_nlist.nl = DP_NewNlist(to_nlist.inum, to_nlist.ilist, to_nlist.numneigh,
-                            to_nlist.firstneigh);
+                            to_nlist.firstneigh, 1);
 }
 /**
  * @brief Deep Potential Base Model.

source/api_c/src/c_api.cc

@@ -16,12 +16,10 @@ extern "C" {
 DP_Nlist::DP_Nlist() {}
 DP_Nlist::DP_Nlist(deepmd::InputNlist& nl) : nl(nl) {}
 
-DP_Nlist* DP_NewNlist(int inum_,
-                      int* ilist_,
-                      int* numneigh_,
-                      int** firstneigh_) {
-  DP_NEW_OK(DP_Nlist,
-            deepmd::InputNlist nl(inum_, ilist_, numneigh_, firstneigh_);
+DP_Nlist* DP_NewNlist(
+    int inum_, int* ilist_, int* numneigh_, int** firstneigh_, int nprocs) {
+  DP_NEW_OK(DP_Nlist, deepmd::InputNlist nl(inum_, ilist_, numneigh_,
+                                            firstneigh_, nprocs);
             DP_Nlist* new_nl = new DP_Nlist(nl); return new_nl;)
 }
 DP_Nlist* DP_NewNlist_comm(int inum_,
@@ -35,18 +33,18 @@ DP_Nlist* DP_NewNlist_comm(int inum_,
                            int** sendlist,
                            int* sendproc,
                            int* recvproc,
-                           void* world) {
+                           void* world,
+                           int nprocs) {
   deepmd::InputNlist nl(inum_, ilist_, numneigh_, firstneigh_, nswap, sendnum,
-                        recvnum, firstrecv, sendlist, sendproc, recvproc,
-                        world);
+                        recvnum, firstrecv, sendlist, sendproc, recvproc, world,
+                        nprocs);
   DP_Nlist* new_nl = new DP_Nlist(nl);
   return new_nl;
 }
 void DP_NlistSetMask(DP_Nlist* nl, int mask) { nl->nl.set_mask(mask); }
 void DP_NlistSetMapping(DP_Nlist* nl, int* mapping) {
   nl->nl.set_mapping(mapping);
 }
-void DP_NlistSetNprocs(DP_Nlist* nl, int nprocs) { nl->nl.set_nprocs(nprocs); }
 void DP_DeleteNlist(DP_Nlist* nl) { delete nl; }
 
 // DP Base Model

source/api_cc/src/DeepPotPTExpt.cc

@@ -367,10 +367,11 @@ void DeepPotPTExpt::compute(ENERGYVTYPE& ener,
 
   // Dispatch decision: use the with-comm artifact when LAMMPS is running
   // multi-rank.  ``lmp_list.nprocs > 1`` is the direct predicate;
-  // ``pair_deepmd.cpp`` populates it via ``set_nprocs(comm->nprocs)``.
-  // Earlier drafts used ``nswap > 0`` as a proxy, but that breaks for
-  // ``atom_style spin`` (which emits nswap > 0 even in single-rank to
-  // propagate PBC ghost spins).  ``nprocs`` is unambiguous.
+  // LAMMPS pair styles populate it by passing ``comm->nprocs`` to the
+  // ``InputNlist`` constructor.  Earlier drafts used ``nswap > 0`` as a
+  // proxy, but that breaks for ``atom_style spin`` (which emits
+  // nswap > 0 even in single-rank to propagate PBC ghost spins).
+  // ``nprocs`` is unambiguous.
   //
   // The regular artifact uses ``mapping`` to gather ghost-atom features
   // from local-atom embeddings (``index_select(node_ebd[1, nloc, dim],

source/api_cc/src/DeepSpinPTExpt.cc

@@ -381,10 +381,11 @@ void DeepSpinPTExpt::compute(ENERGYVTYPE& ener,
   // ghost→local mapping); multi-rank without a with-comm artifact cannot
   // drive border_op (no inter-rank exchange tensor).  Both unsupported
   // combinations fail-fast for every caller.
-  // ``nprocs > 1`` is the direct multi-rank predicate (set by
-  // pair_deepspin via ``lmp_list.set_nprocs(comm->nprocs)``).  Earlier
-  // drafts used ``nswap > 0`` as a proxy, but atom_style spin emits
-  // nswap > 0 even in single-rank, so the proxy is unsound.
+  // ``nprocs > 1`` is the direct multi-rank predicate (LAMMPS pair
+  // styles set it by passing ``comm->nprocs`` to the ``InputNlist``
+  // constructor).  Earlier drafts used ``nswap > 0`` as a proxy, but
+  // atom_style spin emits nswap > 0 even in single-rank, so the proxy
+  // is unsound.
   bool multi_rank = (lmp_list.nprocs > 1);
   bool atom_map_present = (lmp_list.mapping != nullptr);
   bool use_with_comm = has_comm_artifact_ && multi_rank;

source/lib/include/neighbor_list.h

@@ -46,9 +46,11 @@ struct InputNlist {
   int mask = 0xFFFFFFFF;
   /// mapping from all atoms to real atoms, in the size of nall
   int* mapping = nullptr;
-  /// number of MPI ranks (1 = single-rank).  Populated by LAMMPS pair
-  /// styles from ``comm->nprocs``; defaults to 1 for direct C++
-  /// callers that don't set it.  Use this — NOT ``nswap > 0`` — as the
+  /// number of MPI ranks (1 = single-rank).  Passed by LAMMPS pair
+  /// styles as the trailing ``nprocs_`` argument of the comm-aware
+  /// constructor (sourced from ``comm->nprocs``); defaults to 1 for
+  /// direct C++ callers and for the lightweight constructors that
+  /// don't carry comm metadata.  Use this — NOT ``nswap > 0`` — as the
   /// "is multi-rank?" predicate: ``atom_style spin`` and some other
   /// LAMMPS configurations populate ``nswap`` even in single-rank.
   int nprocs = 1;
@@ -65,7 +67,11 @@ struct InputNlist {
         sendproc(nullptr),
         recvproc(nullptr),
         world(0) {};
-  InputNlist(int inum_, int* ilist_, int* numneigh_, int** firstneigh_)
+  InputNlist(int inum_,
+             int* ilist_,
+             int* numneigh_,
+             int** firstneigh_,
+             int nprocs_ = 1)
       : inum(inum_),
         ilist(ilist_),
         numneigh(numneigh_),
@@ -77,7 +83,8 @@ struct InputNlist {
         sendlist(nullptr),
         sendproc(nullptr),
         recvproc(nullptr),
-        world(0) {};
+        world(0),
+        nprocs(nprocs_) {};
   InputNlist(int inum_,
              int* ilist_,
              int* numneigh_,
@@ -89,7 +96,8 @@ struct InputNlist {
              int** sendlist,
              int* sendproc,
              int* recvproc,
-             void* world)
+             void* world,
+             int nprocs_ = 1)
       : inum(inum_),
         ilist(ilist_),
         numneigh(numneigh_),
@@ -101,7 +109,8 @@ struct InputNlist {
         sendlist(sendlist),
         sendproc(sendproc),
         recvproc(recvproc),
-        world(world) {};
+        world(world),
+        nprocs(nprocs_) {};
   ~InputNlist() {};
   /**
    * @brief Set mask for this neighbor list.
@@ -111,15 +120,6 @@ struct InputNlist {
    * @brief Set mapping for this neighbor list.
    */
   void set_mapping(int* mapping_) { mapping = mapping_; };
-  /**
-   * @brief Set the MPI rank count for this neighbor list.
-   *
-   * Used by ``DeepPotPTExpt`` / ``DeepSpinPTExpt`` to decide whether
-   * the regular or with-comm artifact should run.  Pair styles must
-   * call this with ``comm->nprocs``; without it the C++ side will
-   * treat the call as single-rank.
-   */
-  void set_nprocs(int nprocs_) { nprocs = nprocs_; };
 };
 
 /**

source/lmp/fix_dplr.cpp

@@ -505,9 +505,8 @@ void FixDPLR::pre_force(int vflag) {
   // get lammps nlist
   NeighList* list = pair_deepmd->list;
   deepmd_compat::InputNlist lmp_list(list->inum, list->ilist, list->numneigh,
-                                     list->firstneigh);
+                                     list->firstneigh, comm->nprocs);
   lmp_list.set_mask(NEIGHMASK);
-  lmp_list.set_nprocs(comm->nprocs);
   if (comm->nprocs == 1 && atom->map_style != Atom::MAP_NONE) {
     lmp_list.set_mapping(mapping_vec.data());
   }

source/lmp/pair_deepmd.cpp

@@ -237,9 +237,8 @@ void PairDeepMD::compute(int eflag, int vflag) {
         list->inum, list->ilist, list->numneigh, list->firstneigh,
         commdata_->nswap, commdata_->sendnum, commdata_->recvnum,
         commdata_->firstrecv, commdata_->sendlist, commdata_->sendproc,
-        commdata_->recvproc, &world);
+        commdata_->recvproc, &world, comm->nprocs);
     lmp_list.set_mask(NEIGHMASK);
-    lmp_list.set_nprocs(comm->nprocs);
     if (comm->nprocs == 1 && atom->map_style != Atom::MAP_NONE) {
       lmp_list.set_mapping(mapping_vec.data());
     }

source/lmp/pair_deepspin.cpp

@@ -251,9 +251,8 @@ void PairDeepSpin::compute(int eflag, int vflag) {
         list->inum, list->ilist, list->numneigh, list->firstneigh,
         commdata_->nswap, commdata_->sendnum, commdata_->recvnum,
         commdata_->firstrecv, commdata_->sendlist, commdata_->sendproc,
-        commdata_->recvproc, &world);
+        commdata_->recvproc, &world, comm->nprocs);
     lmp_list.set_mask(NEIGHMASK);
-    lmp_list.set_nprocs(comm->nprocs);
     if (comm->nprocs == 1 && atom->map_style != Atom::MAP_NONE) {
       lmp_list.set_mapping(mapping_vec.data());
     }