Replace Parallel_Reduce with ParaKmeshWorld in occupy, fix ParaWorld ODR

Migrate occupy.cpp and elecstate_tools.cpp from the legacy
Parallel_Reduce::reduce_double_allpool / reduce_max / reduce_min
to the new module_parallel ParaKmeshWorld API:

- Add reduce_across_pools / reduce_max_across_pools /
  reduce_min_across_pools to ParaKmeshWorld (Allreduce on the
  inter-pool communicator KP_WORLD, no-op when kpar==1).
- Add a reduce-only ParaKmeshWorld() default constructor and a
  no-arg make_kmesh_world() bridge overload for call sites like
  calEBand that have no k-point information to pass.
- occupy.h/cpp: replace npool parameter with const ParaKmeshWorld&,
  remove #include parallel_reduce.h, remove GlobalV::NPROC_IN_POOL.
- elecstate_tools.cpp: calEBand and calculate_weights now construct
  kmesh via the bridge; delete the old npool/bndpar local variable.

Fix a latent ODR violation in ParaWorld that caused a free() crash
in test_occupy: the MPI_Comm comm_ member only existed under
#ifdef __MPI, so the class layout differed between translation units
compiled with and without __MPI. Replace with a void* opaque handle
(memcpy round-trip, layout-identical in both builds).

Author: abacus_fixer

source/source_base/module_parallel/para_bridge.cpp

@@ -2,6 +2,7 @@
 #include "para_tag.h"
 
 #ifdef __MPI
+#include "source_base/global_variable.h"
 #include "source_base/parallel_comm.h"
 #endif
 
@@ -19,4 +20,40 @@ ParaWorld make_pw_world()
 #endif
 }
 
+// Reduce-only overload: no k-point distribution data.
+ParaKmeshWorld make_kmesh_world()
+{
+#ifdef __MPI
+    int mpi_initialized = 0;
+    MPI_Initialized(&mpi_initialized);
+    if (mpi_initialized && GlobalV::KPAR > 1 && KP_WORLD != MPI_COMM_NULL)
+    {
+        // Build from globals but skip distribute_kpoints (nkstot=0).
+        return ParaKmeshWorld(KP_WORLD, GlobalV::KPAR, GlobalV::MY_POOL,
+                             GlobalV::NPROC, 0, 1);
+    }
+#endif
+    return ParaKmeshWorld();
+}
+
+// Temporary bridge: construct a kmesh-domain ParaKmeshWorld from the old
+// globals. Delete this file once ParaCollection is wired into driver init.
+ParaKmeshWorld make_kmesh_world(int nkstot, int nspin)
+{
+#ifdef __MPI
+    // Fall back to a serial single-pool domain when MPI is not initialized
+    // (e.g. unit tests linked against the MPI-compiled base library) or
+    // when there is only one k-point pool, so that no MPI call is made on
+    // an unset communicator.
+    int mpi_initialized = 0;
+    MPI_Initialized(&mpi_initialized);
+    if (mpi_initialized && GlobalV::KPAR > 1 && KP_WORLD != MPI_COMM_NULL)
+    {
+        return ParaKmeshWorld(KP_WORLD, GlobalV::KPAR, GlobalV::MY_POOL,
+                             GlobalV::NPROC, nkstot, nspin);
+    }
+#endif
+    return ParaKmeshWorld(nkstot, nspin);
+}
+
 } // namespace Parallel

source/source_base/module_parallel/para_bridge.h

@@ -1,6 +1,7 @@
 #ifndef PARA_BRIDGE_H
 #define PARA_BRIDGE_H
 
+#include "para_kmesh_world.h"
 #include "para_world.h"
 
 namespace Parallel
@@ -16,6 +17,32 @@ namespace Parallel
  */
 ParaWorld make_pw_world();
 
+/**
+ * @brief Temporary bridge: construct a kmesh-domain ParaKmeshWorld from
+ * the old globals KP_WORLD / GlobalV::KPAR (MPI) or as a serial domain
+ * (non-MPI).
+ *
+ * Falls back to a serial single-pool domain when MPI is not initialized
+ * (e.g. unit tests linked against the MPI-compiled base library) or when
+ * there is only one k-point pool, so that no MPI call is made on an
+ * unset communicator.
+ *
+ * @param[in] nkstot  total number of k-points (without spin)
+ * @param[in] nspin   number of spin components
+ */
+ParaKmeshWorld make_kmesh_world(int nkstot, int nspin);
+
+/**
+ * @brief Reduce-only overload: construct a kmesh domain for call sites
+ * that only need cross-pool reduction (reduce_across_pools etc.) and
+ * have no k-point information to pass.
+ *
+ * The k-point distribution data (nks_pool_, whichpool_, ...) is left
+ * empty; calling pool_collection / gather_kvec on the returned object
+ * is invalid. Use the (nkstot, nspin) overload when those are needed.
+ */
+ParaKmeshWorld make_kmesh_world();
+
 } // namespace Parallel
 
 #endif // PARA_BRIDGE_H

source/source_base/module_parallel/para_kmesh_world.cpp

@@ -15,6 +15,14 @@ ParaKmeshWorld::ParaKmeshWorld(int nkstot, int nspin)
     startk_global_ = 0;
 }
 
+ParaKmeshWorld::ParaKmeshWorld()
+    : ParaWorld("kmesh"), kpar_(1), my_pool_(0), rank_in_pool_(0),
+      nproc_(1), nspin_(1), nkstot_(0), nks_local_(0), startk_global_(0)
+{
+    // Intentionally empty: no k-point distribution data.
+    // Only kpar_ / comm() are valid for reduce_across_pools.
+}
+
 #ifdef __MPI
 ParaKmeshWorld::ParaKmeshWorld(const MPI_Comm& comm, int kpar, int my_pool, int nproc, int nkstot, int nspin)
     : ParaWorld("kmesh", comm), kpar_(kpar), my_pool_(my_pool),
@@ -93,6 +101,39 @@ int ParaKmeshWorld::max_nks_pool() const
     return *std::max_element(nks_pool_.begin(), nks_pool_.end());
 }
 
+void ParaKmeshWorld::reduce_across_pools(double& value) const
+{
+    if (kpar_ == 1)
+    {
+        return;
+    }
+#ifdef __MPI
+    MPI_Allreduce(MPI_IN_PLACE, &value, 1, MPI_DOUBLE, MPI_SUM, comm());
+#endif
+}
+
+void ParaKmeshWorld::reduce_max_across_pools(double& value) const
+{
+    if (kpar_ == 1)
+    {
+        return;
+    }
+#ifdef __MPI
+    MPI_Allreduce(MPI_IN_PLACE, &value, 1, MPI_DOUBLE, MPI_MAX, comm());
+#endif
+}
+
+void ParaKmeshWorld::reduce_min_across_pools(double& value) const
+{
+    if (kpar_ == 1)
+    {
+        return;
+    }
+#ifdef __MPI
+    MPI_Allreduce(MPI_IN_PLACE, &value, 1, MPI_DOUBLE, MPI_MIN, comm());
+#endif
+}
+
 void ParaKmeshWorld::pool_collection(double& value, const double* wk, int ik) const
 {
 #ifdef __MPI

source/source_base/module_parallel/para_kmesh_world.h

@@ -30,6 +30,17 @@ class ParaKmeshWorld : public ParaWorld
      */
     ParaKmeshWorld(int nkstot, int nspin);
 
+    /**
+     * @brief Construct a reduce-only k-mesh domain with no k-point
+     * distribution data.
+     *
+     * kpar_/comm are set from the bridge globals so that
+     * reduce_across_pools / reduce_max/min_across_pools work correctly.
+     * The distribution arrays (nks_pool_, whichpool_, ...) are left
+     * empty; calling pool_collection / gather_kvec is invalid.
+     */
+    ParaKmeshWorld();
+
 #ifdef __MPI
     /**
      * @brief Construct a k-mesh domain on an existing communicator.
@@ -83,6 +94,36 @@ class ParaKmeshWorld : public ParaWorld
     /// Maximum number of k-points across all pools.
     int max_nks_pool() const;
 
+    // ===== Cross-pool reductions =====
+
+    /**
+     * @brief Sum a scalar across all k-point pools.
+     *
+     * Replaces Parallel_Reduce::reduce_double_allpool. Uses the inter-pool
+     * communicator (comm()) so that same-rank processes across pools
+     * participate. Since all processes in a pool share the same value,
+     * no normalization by pool size is needed. No-op when kpar()==1.
+     *
+     * @param[in,out] value  local partial sum, overwritten with global total
+     */
+    void reduce_across_pools(double& value) const;
+
+    /**
+     * @brief Global max across all k-point pools.
+     *
+     * @param[in,out] value  local value, overwritten with global max
+     */
+    void reduce_max_across_pools(double& value) const;
+
+    /**
+     * @brief Global min across all k-point pools.
+     *
+     * @param[in,out] value  local value, overwritten with global min
+     */
+    void reduce_min_across_pools(double& value) const;
+
+    // ===== Cross-domain operations =====
+
     /**
      * @brief Collect a scalar value from the pool that owns k-point ik.
      *

source/source_base/module_parallel/para_world.cpp

@@ -3,22 +3,23 @@
 namespace Parallel
 {
 
-ParaWorld::ParaWorld(const std::string& tag) : tag_(tag), rank_(0), size_(1)
+ParaWorld::ParaWorld(const std::string& tag) : tag_(tag), rank_(0), size_(1), comm_(nullptr)
 {
 #ifdef __MPI
     if (!tag.empty())
     {
-        comm_ = MPI_COMM_SELF;
+        comm_ = handle_from_comm(MPI_COMM_SELF);
     }
     else
     {
-        comm_ = MPI_COMM_NULL;
+        comm_ = handle_from_comm(MPI_COMM_NULL);
     }
 #endif
 }
 
 #ifdef __MPI
-ParaWorld::ParaWorld(const std::string& tag, const MPI_Comm& comm) : tag_(tag), comm_(comm)
+ParaWorld::ParaWorld(const std::string& tag, const MPI_Comm& comm)
+    : tag_(tag), comm_(handle_from_comm(comm))
 {
     if (comm == MPI_COMM_NULL)
     {
@@ -34,7 +35,7 @@ ParaWorld::ParaWorld(const std::string& tag, const MPI_Comm& comm) : tag_(tag),
 bool ParaWorld::valid() const
 {
 #ifdef __MPI
-    return comm_ != MPI_COMM_NULL;
+    return comm() != MPI_COMM_NULL;
 #else
     return !tag_.empty();
 #endif

source/source_base/module_parallel/para_world.h

@@ -1,6 +1,7 @@
 #ifndef PARA_WORLD_H
 #define PARA_WORLD_H
 
+#include <cstring>
 #include <memory>
 #include <string>
 
@@ -20,9 +21,13 @@ namespace Parallel
  * GlobalV::RANK_IN_POOL / POOL_WORLD by an object that functions
  * receive explicitly.
  *
- * In serial builds (no __MPI) the communicator member does not
- * exist; rank() always returns 0 and size() always returns 1, so
- * call sites compile unchanged in both serial and MPI builds.
+ * The communicator is stored as an opaque handle so that the class
+ * layout is identical in serial and MPI builds. Binaries that mix
+ * translation units compiled with different __MPI settings (e.g. unit
+ * tests linked against the MPI-compiled base library) would otherwise
+ * be an ODR violation with undefined behavior. In serial builds rank()
+ * always returns 0 and size() always returns 1, so call sites compile
+ * unchanged in both serial and MPI builds.
  */
 class ParaWorld
 {
@@ -59,7 +64,11 @@ class ParaWorld
     /// Underlying MPI communicator (MPI builds only).
     MPI_Comm comm() const
     {
-        return comm_;
+        MPI_Comm comm = MPI_COMM_NULL;
+        static_assert(sizeof(MPI_Comm) <= sizeof(comm_),
+                      "MPI_Comm does not fit into the opaque handle");
+        std::memcpy(&comm, &comm_, sizeof(MPI_Comm));
+        return comm;
     }
 #endif
 
@@ -127,12 +136,23 @@ class ParaWorld
 #endif
 
 private:
+#ifdef __MPI
+    /// Wrap an MPI communicator into the opaque handle storage.
+    static void* handle_from_comm(const MPI_Comm& comm)
+    {
+        void* handle = nullptr;
+        std::memcpy(&handle, &comm, sizeof(MPI_Comm));
+        return handle;
+    }
+#endif
+
     std::string tag_;   ///< domain tag
     int rank_;          ///< rank inside domain
     int size_;          ///< number of processes in domain
-#ifdef __MPI
-    MPI_Comm comm_;     ///< wrapped communicator (never owned/freed here)
-#endif
+    // Opaque communicator handle, present in both serial and MPI builds
+    // so that the class layout never depends on the __MPI macro (see the
+    // class comment). Never owned/freed here.
+    void* comm_;
 };
 
 } // namespace Parallel