refactor(klist): extract EXX k-stars build into KListIO::build_kstars

Move the this-free triple loop that groups k points into EXX k-stars out
of K_Vectors::reduce_by_symmetry into KListIO::build_kstars. The symmetry
comparison is passed in as a std::function so klist_io.cpp does not depend
on the Symmetry header; k restriction uses ModuleCell::restrict_kpt.

Behavior is unchanged for symm_flag==1 (the only path that reaches this
code). klist.cpp drops ~20 lines; the loop is now isolated and testable.

Verified: cmake --build build_max_para_test -j30 (exit 0, __EXX on) and
ctest -R "MODULE_CELL_(klist|reciprocal_grid|qlist)" -> 5/5.

Author: abacus_fixer

source/source_cell/klist.cpp

@@ -622,35 +622,15 @@ void K_Vectors::reduce_by_symmetry(const UnitCell& ucell,
 
 #ifdef __EXX
     // setup kstars according to the final (max-norm) kvec_d_ibz
-    this->kstars.resize(nkstot_ibz);
     if (ModuleSymmetry::Symmetry::symm_flag == 1)
     {
-        ModuleBase::Vector3<double> kvec_rot;
-        for (int i = 0; i < this->nkstot; ++i)
-        {
-            int exist_number = -1;
-            int isym = 0;
-            for (int j = 0; j < nrotkm; ++j)
-            {
-                kvec_rot = this->kvec_d[i] * kgmatrix[j];
-                ModuleCell::restrict_kpt(kvec_rot, symm.epsilon);
-                for (int k = 0; k < nkstot_ibz; ++k)
-                {
-                    if (symm.equal(kvec_rot.x, kvec_d_ibz[k].x) && symm.equal(kvec_rot.y, kvec_d_ibz[k].y)
-                        && symm.equal(kvec_rot.z, kvec_d_ibz[k].z))
-                    {
-                        isym = j;
-                        exist_number = k;
-                        break;
-                    }
-                }
-                if (exist_number != -1)
-                {
-                    break;
-                }
-            }
-            this->kstars[exist_number].insert(std::make_pair(isym, this->kvec_d[i]));
-        }
+        KListIO::build_kstars(this->kvec_d,
+                              kgmatrix,
+                              nrotkm,
+                              kvec_d_ibz,
+                              symm.epsilon,
+                              [&symm](double a, double b) { return symm.equal(a, b); },
+                              this->kstars);
     }
 #endif
 

source/source_cell/klist_io.cpp

@@ -8,6 +8,7 @@
 
 #include "source_base/formatter.h"
 #include "source_base/global_function.h"
+#include "source_cell/reciprocal_grid.h"
 
 #include <sstream>
 
@@ -137,4 +138,44 @@ LineK interp_line(std::ifstream& ifk, const int nks_special)
     return out;
 }
 
+void build_kstars(const std::vector<ModuleBase::Vector3<double>>& kvec_d,
+                  const std::vector<ModuleBase::Matrix3>& kgmatrix,
+                  const int nrotkm,
+                  const std::vector<ModuleBase::Vector3<double>>& kvec_d_ibz,
+                  const double epsilon,
+                  const std::function<bool(double, double)>& equal,
+                  std::vector<std::map<int, ModuleBase::Vector3<double>>>& kstars)
+{
+    const int nkstot = static_cast<int>(kvec_d.size());
+    const int nkstot_ibz = static_cast<int>(kvec_d_ibz.size());
+    kstars.resize(nkstot_ibz);
+
+    ModuleBase::Vector3<double> kvec_rot;
+    for (int i = 0; i < nkstot; ++i)
+    {
+        int exist_number = -1;
+        int isym = 0;
+        for (int j = 0; j < nrotkm; ++j)
+        {
+            kvec_rot = kvec_d[i] * kgmatrix[j];
+            ModuleCell::restrict_kpt(kvec_rot, epsilon);
+            for (int k = 0; k < nkstot_ibz; ++k)
+            {
+                if (equal(kvec_rot.x, kvec_d_ibz[k].x) && equal(kvec_rot.y, kvec_d_ibz[k].y)
+                    && equal(kvec_rot.z, kvec_d_ibz[k].z))
+                {
+                    isym = j;
+                    exist_number = k;
+                    break;
+                }
+            }
+            if (exist_number != -1)
+            {
+                break;
+            }
+        }
+        kstars[exist_number].insert(std::make_pair(isym, kvec_d[i]));
+    }
+}
+
 } // namespace KListIO

source/source_cell/klist_io.h

@@ -1,9 +1,12 @@
 #ifndef KLIST_IO_H
 #define KLIST_IO_H
 
+#include "source_base/matrix3.h"
 #include "source_base/vector3.h"
 
 #include <fstream>
+#include <functional>
+#include <map>
 #include <string>
 #include <vector>
 
@@ -35,6 +38,19 @@ struct LineK
 /// then linearly interpolate the line-mode k points. Pure function of the
 /// stream and `nks_special`; dies via WARNING_QUIT on malformed input.
 LineK interp_line(std::ifstream& ifk, int nks_special);
+
+/// Build the EXX k-stars: for every k point, find the symmetry operation
+/// (index into `kgmatrix`) that rotates it onto an irreducible k point, and
+/// group k points by that IBZ representative. `equal` compares two doubles
+/// with the symmetry precision; `epsilon` is the k-restriction tolerance.
+/// this-free so the heavy triple loop is isolated and testable.
+void build_kstars(const std::vector<ModuleBase::Vector3<double>>& kvec_d,
+                  const std::vector<ModuleBase::Matrix3>& kgmatrix,
+                  int nrotkm,
+                  const std::vector<ModuleBase::Vector3<double>>& kvec_d_ibz,
+                  double epsilon,
+                  const std::function<bool(double, double)>& equal,
+                  std::vector<std::map<int, ModuleBase::Vector3<double>>>& kstars);
 } // namespace KListIO
 
 #endif // KLIST_IO_H