refactor(klist): extract EXX k-star broadcast into KListIO::bcast_kstars

Move the rank-0 -> all kstars broadcast loop out of K_Vectors::mpi_k
into a this-free KListIO helper. The wrappers compile to no-ops in
serial builds, so the helper is guarded only by __EXX at the call site
like the original block.

Author: abacus_fixer

source/source_cell/klist.cpp

@@ -784,34 +784,10 @@ void K_Vectors::mpi_k(std::ofstream& ofs_running, const int my_rank, const int m
                          this->kvec_c_full);
 
 #ifdef __EXX
+    // bcast kstars (rank 0 holds the filled maps; other ranks rebuild them)
     if (ModuleSymmetry::Symmetry::symm_flag == 1)
-    { // bcast kstars
-        this->kstars.resize(this->nkstot);
-        for (int ikibz = 0; ikibz < this->nkstot; ++ikibz)
-        {
-            int starsize = this->kstars[ikibz].size();
-            Parallel_Common::bcast_int(starsize);
-            auto ks = this->kstars[ikibz].begin();
-            for (int ik = 0; ik < starsize; ++ik)
-            {
-                int isym = 0;
-                ModuleBase::Vector3<double> ks_vec(0, 0, 0);
-                if (my_rank == 0)
-                {
-                    isym = ks->first;
-                    ks_vec = ks->second;
-                    ++ks;
-                }
-                Parallel_Common::bcast_int(isym);
-                Parallel_Common::bcast_double(ks_vec.x);
-                Parallel_Common::bcast_double(ks_vec.y);
-                Parallel_Common::bcast_double(ks_vec.z);
-                if (my_rank != 0)
-                {
-                    this->kstars[ikibz].insert(std::make_pair(isym, ks_vec));
-                }
-            }
-        }
+    {
+        KListIO::bcast_kstars(this->kstars, this->nkstot, my_rank);
     }
 #endif
 } // END SUBROUTINE mpi_k

source/source_cell/klist_io.cpp

@@ -8,6 +8,7 @@
 
 #include "source_base/formatter.h"
 #include "source_base/global_function.h"
+#include "source_base/parallel_common.h"
 #include "source_cell/reciprocal_grid.h"
 
 #include <sstream>
@@ -269,4 +270,36 @@ void unpack_kpts(const std::vector<int>& isk_aux,
     }
 }
 
+void bcast_kstars(std::vector<std::map<int, ModuleBase::Vector3<double>>>& kstars,
+                  const int nkstot,
+                  const int my_rank)
+{
+    kstars.resize(nkstot);
+    for (int ikibz = 0; ikibz < nkstot; ++ikibz)
+    {
+        int starsize = kstars[ikibz].size();
+        Parallel_Common::bcast_int(starsize);
+        auto ks = kstars[ikibz].begin();
+        for (int ik = 0; ik < starsize; ++ik)
+        {
+            int isym = 0;
+            ModuleBase::Vector3<double> ks_vec(0, 0, 0);
+            if (my_rank == 0)
+            {
+                isym = ks->first;
+                ks_vec = ks->second;
+                ++ks;
+            }
+            Parallel_Common::bcast_int(isym);
+            Parallel_Common::bcast_double(ks_vec.x);
+            Parallel_Common::bcast_double(ks_vec.y);
+            Parallel_Common::bcast_double(ks_vec.z);
+            if (my_rank != 0)
+            {
+                kstars[ikibz].insert(std::make_pair(isym, ks_vec));
+            }
+        }
+    }
+}
+
 } // namespace KListIO

source/source_cell/klist_io.h

@@ -79,6 +79,15 @@ void pack_kpts(const std::vector<int>& isk,
                std::vector<double>& kvec_d_aux,
                std::vector<double>& kvec_c_full_aux);
 
+/// Broadcast the EXX k-stars (one (symmetry-index, k-vector) map per IBZ
+/// k-point) from `my_rank == 0` to every process. Rank 0 holds the filled
+/// maps; other ranks resize and rebuild them from the broadcast. MPI
+/// wrappers are compiled as no-ops without __MPI, so the call is safe in
+/// serial builds (it simply leaves the rank-0 maps untouched).
+void bcast_kstars(std::vector<std::map<int, ModuleBase::Vector3<double>>>& kstars,
+                  int nkstot,
+                  int my_rank);
+
 /// Scatter the broadcast buffers into this pool's k-point slice, starting at
 /// global index `startk`. this-free; mirrors pack_kpts after the broadcast.
 void unpack_kpts(const std::vector<int>& isk_aux,