refactor(cell): extract k-vec completion and symmetry-mismatch handling from K_Vectors::set

Move the full k-point Cartesian-coordinate completion (kc/kd branches)
into KListIO::fill_full_kvec and the reciprocal/real lattice mismatch
handling (symmetry_autoclose retry vs WARNING_QUIT) into a private
K_Vectors::handle_symmetry_mismatch member. This drops the set()
cyclomatic complexity penalty; klist.cpp score rises 45 -> 50.

Author: abacus_fixer

source/source_cell/klist.cpp

@@ -108,16 +108,14 @@ void K_Vectors::set(const UnitCell& ucell,
     std::string skpt1;
     std::string skpt2;
 
-    if (!this->kc_done && this->kd_done)
-    {
-        for (size_t ik = 0; ik != this->nkstot_full; ++ik)
-            this->kvec_c_full[ik] = this->kvec_d[ik] * reciprocal_vec;
-    }
-    else if (this->kc_done && !this->kd_done)
-    {
-        for (size_t ik = 0; ik != this->nkstot_full; ++ik)
-            this->kvec_c_full[ik] = this->kvec_c[ik];
-    }
+    // complement the Cartesian coordinates of the full k-point list
+    KListIO::fill_full_kvec(this->kc_done,
+                            this->kd_done,
+                            this->nkstot_full,
+                            reciprocal_vec,
+                            this->kvec_c,
+                            this->kvec_d,
+                            this->kvec_c_full);
 
 
     // (2)
@@ -132,24 +130,7 @@ void K_Vectors::set(const UnitCell& ucell,
 #endif
         if (!match)
         {
-            std::cout << "Optimized lattice type of reciprocal lattice cannot match the optimized real lattice. "
-                      << std::endl;
-            std::cout << "It is often because the inaccuracy of lattice parameters in STRU." << std::endl;
-            if (ModuleSymmetry::Symmetry::symm_autoclose)
-            {
-                ModuleBase::WARNING("K_Vectors::ibz_kpoint", "Automatically set symmetry to 0 and continue ...");
-                std::cout << "Automatically set symmetry to 0 and continue ..." << std::endl;
-                ModuleSymmetry::Symmetry::symm_flag = 0;
-                match = true;
-                this->reduce_by_symmetry(ucell, symm, ModuleSymmetry::Symmetry::symm_flag, skpt1, match);
-            } else {
-                ModuleBase::WARNING_QUIT("K_Vectors::ibz_kpoint",
-                                         "Possible solutions: \n \
-1. Refine the lattice parameters in STRU;\n \
-2. Use a different`symmetry_prec`.  \n \
-3. Close symemtry: set `symmetry` to 0 in INPUT. \n \
-4. Set `symmetry_autoclose` to 1 in INPUT to automatically close symmetry when this error occurs.");
-            }
+            this->handle_symmetry_mismatch(ucell, symm, skpt1, match);
         }
     }
 
@@ -207,6 +188,33 @@ void K_Vectors::set(const UnitCell& ucell,
     return;
 }
 
+void K_Vectors::handle_symmetry_mismatch(const UnitCell& ucell,
+                                         const ModuleSymmetry::Symmetry& symm,
+                                         std::string& skpt,
+                                         bool& match)
+{
+    std::cout << "Optimized lattice type of reciprocal lattice cannot match the optimized real lattice. "
+              << std::endl;
+    std::cout << "It is often because the inaccuracy of lattice parameters in STRU." << std::endl;
+    if (ModuleSymmetry::Symmetry::symm_autoclose)
+    {
+        ModuleBase::WARNING("K_Vectors::ibz_kpoint", "Automatically set symmetry to 0 and continue ...");
+        std::cout << "Automatically set symmetry to 0 and continue ..." << std::endl;
+        ModuleSymmetry::Symmetry::symm_flag = 0;
+        match = true;
+        this->reduce_by_symmetry(ucell, symm, ModuleSymmetry::Symmetry::symm_flag, skpt, match);
+    }
+    else
+    {
+        ModuleBase::WARNING_QUIT("K_Vectors::ibz_kpoint",
+                                 "Possible solutions: \n \
+1. Refine the lattice parameters in STRU;\n \
+2. Use a different`symmetry_prec`.  \n \
+3. Close symemtry: set `symmetry` to 0 in INPUT. \n \
+4. Set `symmetry_autoclose` to 1 in INPUT to automatically close symmetry when this error occurs.");
+    }
+}
+
 // 1.reset the size of the K-point container according to spin_mult and nkstot
 // 2.reserve space for spin_mult>2 (symmetry)
 void K_Vectors::renew(const int& kpoint_number)

source/source_cell/klist.h

@@ -323,6 +323,24 @@ class K_Vectors : public ModuleCell::ReciprocalGrid
                             std::vector<ModuleBase::Vector3<double>>& kvec,
                             const bool cartesian);
 
+    /**
+     * @brief Handle a reciprocal/real lattice Bravais-type mismatch after
+     *        IBZ reduction.
+     *
+     * When symmetry_autoclose is enabled, symmetry is switched off and the
+     * IBZ reduction is retried; otherwise the run aborts with a WARNING_QUIT
+     * listing the possible remedies.
+     *
+     * @param ucell unit cell used for the retried IBZ reduction
+     * @param symm symmetry operations used for the retried reduction
+     * @param skpt k-point option string forwarded to reduce_by_symmetry
+     * @param match set to true when the autoclose retry succeeds
+     */
+    void handle_symmetry_mismatch(const UnitCell& ucell,
+                                  const ModuleSymmetry::Symmetry& symm,
+                                  std::string& skpt,
+                                  bool& match);
+
     /**
      * @brief Adds k-points linearly between special points.
      *

source/source_cell/klist_io.cpp

@@ -343,4 +343,28 @@ void bcast_kstars(std::vector<std::map<int, ModuleBase::Vector3<double>>>& kstar
     }
 }
 
+void fill_full_kvec(const bool kc_done,
+                    const bool kd_done,
+                    const int nkstot_full,
+                    const ModuleBase::Matrix3& reciprocal_vec,
+                    const std::vector<ModuleBase::Vector3<double>>& kvec_c,
+                    const std::vector<ModuleBase::Vector3<double>>& kvec_d,
+                    std::vector<ModuleBase::Vector3<double>>& kvec_c_full)
+{
+    if (!kc_done && kd_done)
+    {
+        for (int ik = 0; ik < nkstot_full; ++ik)
+        {
+            kvec_c_full[ik] = kvec_d[ik] * reciprocal_vec;
+        }
+    }
+    else if (kc_done && !kd_done)
+    {
+        for (int ik = 0; ik < nkstot_full; ++ik)
+        {
+            kvec_c_full[ik] = kvec_c[ik];
+        }
+    }
+}
+
 } // namespace KListIO

source/source_cell/klist_io.h

@@ -117,6 +117,19 @@ void unpack_kpts(const std::vector<int>& isk_aux,
                  std::vector<ModuleBase::Vector3<double>>& kvec_c,
                  std::vector<ModuleBase::Vector3<double>>& kvec_d,
                  std::vector<ModuleBase::Vector3<double>>& kvec_c_full);
+
+/// Fill the full-list Cartesian k vectors when only one coordinate set is
+/// available: direct coordinates are converted via `reciprocal_vec` when
+/// Cartesian points are missing, otherwise the Cartesian points are copied.
+/// No-op when both coordinate sets are done. this-free helper called from
+/// K_Vectors::set() before IBZ reduction.
+void fill_full_kvec(bool kc_done,
+                    bool kd_done,
+                    int nkstot_full,
+                    const ModuleBase::Matrix3& reciprocal_vec,
+                    const std::vector<ModuleBase::Vector3<double>>& kvec_c,
+                    const std::vector<ModuleBase::Vector3<double>>& kvec_d,
+                    std::vector<ModuleBase::Vector3<double>>& kvec_c_full);
 } // namespace KListIO
 
 #endif // KLIST_IO_H