refactor(klist): rename nkstot_full to nkstot_nospin and thread ofs_warning through klist API

Three intertwined changes that must ship together to keep the build green:

1. Rename `nkstot_full` -> `nkstot_nospin` (member, getter, setter) across
   all consumers (source_cell, source_lcao/module_ri, module_bse, module_lr,
   module_rdmft, source_pw/module_pwdft, source_io). The old name was
   ambiguous: EXX/RI/LR code already treats it as "physical k-point count
   WITHOUT spin multiplicity" (see e.g. ri_2d_comm.hpp:
   `ik_full + is_k * nkstot_full`), so the new name makes the convention
   explicit. Comments in reciprocal_grid.h now document both:
   - nkstot: INCLUDING spin multiplicity (after set_kup_and_kdw)
   - nkstot_nospin: physical k-points, WITHOUT spin multiplicity

2. Thread `std::ostream& ofs_warning` through K_Vectors::set,
   setup_line_kpoints, set_both_kvec, update_use_ibz, reduce_by_symmetry,
   handle_symmetry_mismatch, and read_mp_mesh so they no longer read
   `GlobalV::ofs_warning` directly. Internal ModuleBase::WARNING calls
   are replaced with `ofs_warning <<` to keep behavior consistent.
   The klist module itself no longer references GlobalV::ofs_warning;
   outer callers (esolver_fp, esolver_gets, esolver_lr_lcao_tddft,
   deepks_test_prep) pass `GlobalV::ofs_warning` at the boundary.

3. Thread `int my_rank` through update_use_ibz, reduce_by_symmetry,
   handle_symmetry_mismatch to remove `GlobalV::MY_RANK` reads inside
   the klist module.

Also included: dftu_base static-member cleanup (mark_occ_mat_initialized
-> this->occ_mat_initialized = true) which was already in the working
tree and is consistent with the project rule "no static members in
dftu_base.h".

Behavior is unchanged. Build passes with `cmake --build build_max_para_test
-j 30`. All 12 previously-failing 01_PW tests (003, 007, 028, 030, 034,
036, 037, 050, 055, 063, 078, 079, 097x2, 206, 815, scf_deltaspin2)
pass with identical etot; valgrind reports no ABACUS-side Invalid write.

Author: abacus_fixer

source/source_cell/klist.cpp

@@ -18,6 +18,7 @@ void K_Vectors::set(const UnitCell& ucell,
                     const ModuleBase::Matrix3& reciprocal_vec,
                     const ModuleBase::Matrix3& latvec,
                     std::ofstream& ofs,
+                    std::ofstream& ofs_warning,
                     const bool use_ibz,
                     const std::string& global_out_dir,
                     const bool gamma_only_local,
@@ -65,7 +66,7 @@ void K_Vectors::set(const UnitCell& ucell,
                                                kmesh_type_,
                                                koffset,
                                                ofs,
-                                               GlobalV::ofs_warning,
+                                               ofs_warning,
                                                my_rank);
 #ifdef __MPI
     Parallel_Common::bcast_bool(read_succesfully);
@@ -82,7 +83,7 @@ void K_Vectors::set(const UnitCell& ucell,
     // complement the Cartesian coordinates of the full k-point list
     KListIO::fill_full_kvec(this->kc_done,
                             this->kd_done,
-                            this->nkstot_full,
+                            this->nkstot_nospin,
                             reciprocal_vec,
                             this->kvec_c,
                             this->kvec_d,
@@ -95,21 +96,21 @@ void K_Vectors::set(const UnitCell& ucell,
     {
         bool match = true;
         // calculate kpoints in IBZ and reduce kpoints according to symmetry
-        this->reduce_by_symmetry(ucell, symm, ModuleSymmetry::Symmetry::symm_flag, skpt1, match);
+        this->reduce_by_symmetry(ucell, symm, ModuleSymmetry::Symmetry::symm_flag, skpt1, match, my_rank, ofs);
 #ifdef __MPI
         Parallel_Common::bcast_bool(match);
 #endif
         if (!match)
         {
-            this->handle_symmetry_mismatch(ucell, symm, skpt1, match);
+            this->handle_symmetry_mismatch(ucell, symm, skpt1, match, my_rank, ofs);
         }
     }
 
     // (3)
     // Improve k point information
 
     // Complement the coordinates of k point
-    this->set_both_kvec(reciprocal_vec, latvec, skpt2, ofs);
+    this->set_both_kvec(reciprocal_vec, latvec, skpt2, ofs, ofs_warning);
 
     if (my_rank == 0)
     {
@@ -143,8 +144,8 @@ void K_Vectors::set(const UnitCell& ucell,
     this->set_kup_and_kdw(ofs);
 
     // initialize ibz_index
-    this->ibz_index.resize(this->nkstot_full);
-    for (int ik = 0; ik < this->nkstot_full; ik++)
+    this->ibz_index.resize(this->nkstot_nospin);
+    for (int ik = 0; ik < this->nkstot_nospin; ik++)
     {
         this->ibz_index[ik] = ik;
     }
@@ -167,7 +168,9 @@ void K_Vectors::set(const UnitCell& ucell,
 void K_Vectors::handle_symmetry_mismatch(const UnitCell& ucell,
                                          const ModuleSymmetry::Symmetry& symm,
                                          std::string& skpt,
-                                         bool& match)
+                                         bool& match,
+                                         const int my_rank,
+                                         std::ofstream& ofs)
 {
     std::cout << "Optimized lattice type of reciprocal lattice cannot match the optimized real lattice. "
               << std::endl;
@@ -178,7 +181,7 @@ void K_Vectors::handle_symmetry_mismatch(const UnitCell& ucell,
         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);
+        this->reduce_by_symmetry(ucell, symm, ModuleSymmetry::Symmetry::symm_flag, skpt, match, my_rank, ofs);
     }
     else
     {
@@ -285,7 +288,7 @@ bool K_Vectors::parse_kfile(const std::string& fn, std::ofstream& ofs_running, s
         return false;
     }
 
-    this->nkstot_full = this->nks = this->nkstot;
+    this->nkstot_nospin = this->nks = this->nkstot;
 
     ModuleBase::GlobalFunc::OUT(ofs_running, "nkstot", nkstot);
     return true;
@@ -322,7 +325,8 @@ bool K_Vectors::read_mp_mesh(std::ifstream& ifk,
     this->koffset[2] = 0;
     if (!(ifk >> this->koffset[0] >> this->koffset[1] >> this->koffset[2]))
     {
-        ModuleBase::WARNING("K_Vectors::read_kpoints", "Missing k-point offsets in the k-points file.");
+        ofs_warning << " K_Vectors::read_kpoints  warning : "
+                    << "Missing k-point offsets in the k-points file." << std::endl;
     }
 
     this->Monkhorst_Pack(nmp, this->koffset, k_type);
@@ -347,11 +351,11 @@ bool K_Vectors::read_listed_kpoints(std::ifstream& ifk, const std::string& kword
     }
     if (kword == "Line_Cartesian")
     {
-        return this->setup_line_kpoints(ifk, this->kvec_c, true);
+        return this->setup_line_kpoints(ifk, this->kvec_c, true, ofs_warning);
     }
     if (kword == "Line_Direct" || kword == "L" || kword == "Line")
     {
-        return this->setup_line_kpoints(ifk, this->kvec_d, false);
+        return this->setup_line_kpoints(ifk, this->kvec_d, false, ofs_warning);
     }
 
     ofs_warning << " Error : neither Cartesian nor Direct kpoint." << std::endl;
@@ -360,12 +364,14 @@ bool K_Vectors::read_listed_kpoints(std::ifstream& ifk, const std::string& kword
 
 bool K_Vectors::setup_line_kpoints(std::ifstream& ifk,
                                    std::vector<ModuleBase::Vector3<double>>& kvec,
-                                   const bool cartesian)
+                                   const bool cartesian,
+                                   std::ofstream& ofs_warning)
 {
     if (ModuleSymmetry::Symmetry::symm_flag == 1)
     {
-        ModuleBase::WARNING("K_Vectors::read_kpoints",
-                            "Line mode of k-points is open, please set symmetry to 0 or -1.");
+        ofs_warning << " K_Vectors::read_kpoints  warning : "
+                    << "Line mode of k-points is open, please set symmetry to 0 or -1."
+                    << std::endl;
         return false;
     }
 
@@ -403,9 +409,10 @@ void K_Vectors::interpolate_k_between(std::ifstream& ifk, std::vector<ModuleBase
 void K_Vectors::update_use_ibz(const int& nkstot_ibz,
                                const std::vector<ModuleBase::Vector3<double>>& kvec_d_ibz,
                                const std::vector<double>& wk_ibz,
-                               std::ofstream& ofs_running)
+                               std::ofstream& ofs_running,
+                               const int my_rank)
 {
-    if (GlobalV::MY_RANK != 0) {
+    if (my_rank != 0) {
         return;
     }
     ModuleBase::TITLE("K_Vectors", "update_use_ibz");
@@ -461,9 +468,11 @@ void K_Vectors::reduce_by_symmetry(const UnitCell& ucell,
                                    const ModuleSymmetry::Symmetry& symm,
                                    bool use_symm,
                                    std::string& skpt,
-                                   bool& match)
+                                   bool& match,
+                                   const int my_rank,
+                                   std::ofstream& ofs_running)
 {
-    if (GlobalV::MY_RANK != 0)
+    if (my_rank != 0)
     {
         return;
     }
@@ -532,14 +541,14 @@ void K_Vectors::reduce_by_symmetry(const UnitCell& ucell,
 
     // output in kpoints file
     skpt = KListIO::ibz_kpt_table(this->nkstot, this->kvec_d, this->ibz_index, kvec_d_ibz);
-    ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Number of irreducible k-points", nkstot_ibz);
+    ModuleBase::GlobalFunc::OUT(ofs_running, "Number of irreducible k-points", nkstot_ibz);
 
-    GlobalV::ofs_running << KListIO::ibz_wk_table(nkstot_ibz, kvec_d_ibz, wk_ibz, ibz2bz) << std::endl;
+    ofs_running << KListIO::ibz_wk_table(nkstot_ibz, kvec_d_ibz, wk_ibz, ibz2bz) << std::endl;
 
     // resize the kpoint container according to nkstot_ibz
     if (use_symm || this->get_is_mp())
     {
-        this->update_use_ibz(nkstot_ibz, kvec_d_ibz, wk_ibz, GlobalV::ofs_running);
+        this->update_use_ibz(nkstot_ibz, kvec_d_ibz, wk_ibz, ofs_running, my_rank);
     }
 
     return;
@@ -588,7 +597,7 @@ void K_Vectors::mpi_k(std::ofstream& ofs_running, const int my_rank, const int m
 
     Parallel_Common::bcast_int(this->nkstot);
 
-    Parallel_Common::bcast_int(this->nkstot_full);
+    Parallel_Common::bcast_int(this->nkstot_nospin);
 
     Parallel_Common::bcast_int(this->nmp, 3);
 
@@ -618,7 +627,7 @@ void K_Vectors::mpi_k(std::ofstream& ofs_running, const int my_rank, const int m
     std::vector<double> wk_aux(this->nkstot);
     std::vector<double> kvec_c_aux(this->nkstot * 3);
     std::vector<double> kvec_d_aux(this->nkstot * 3);
-    std::vector<double> kvec_c_full_aux(this->nkstot_full * 3);
+    std::vector<double> kvec_c_full_aux(this->nkstot_nospin * 3);
 
     // collect and process in rank 0
     if (my_rank == 0)
@@ -642,7 +651,7 @@ void K_Vectors::mpi_k(std::ofstream& ofs_running, const int my_rank, const int m
     Parallel_Common::bcast_double(wk_aux.data(), this->nkstot);
     Parallel_Common::bcast_double(kvec_c_aux.data(), this->nkstot * 3);
     Parallel_Common::bcast_double(kvec_d_aux.data(), this->nkstot * 3);
-    Parallel_Common::bcast_double(kvec_c_full_aux.data(), this->nkstot_full * 3);
+    Parallel_Common::bcast_double(kvec_c_full_aux.data(), this->nkstot_nospin * 3);
 
     // process k point data in each processor
     this->renew(this->nks * this->spin_mult);

source/source_cell/klist.h

@@ -60,6 +60,7 @@ class K_Vectors : public ModuleCell::ReciprocalGrid
         const ModuleBase::Matrix3& reciprocal_vec,
         const ModuleBase::Matrix3& latvec,
         std::ofstream& ofs,
+        std::ofstream& ofs_warning,
         const bool use_ibz,
         const std::string& global_out_dir,
         const bool gamma_only_local,
@@ -77,9 +78,9 @@ class K_Vectors : public ModuleCell::ReciprocalGrid
         return this->nkstot;
     }
 
-    int get_nkstot_full() const
+    int get_nkstot_nospin() const
     {
-        return this->nkstot_full;
+        return this->nkstot_nospin;
     }
 
     double get_koffset(const int i) const
@@ -114,9 +115,9 @@ class K_Vectors : public ModuleCell::ReciprocalGrid
         this->nkstot = value;
     }
 
-    void set_nkstot_full(int value)
+    void set_nkstot_nospin(int value)
     {
-        this->nkstot_full = value;
+        this->nkstot_nospin = value;
     }
 
     bool get_is_mp() const
@@ -147,7 +148,8 @@ class K_Vectors : public ModuleCell::ReciprocalGrid
     void update_use_ibz(const int& nkstot_ibz,
                         const std::vector<ModuleBase::Vector3<double>>& kvec_d_ibz,
                         const std::vector<double>& wk_ibz,
-                        std::ofstream& ofs_running);
+                        std::ofstream& ofs_running,
+                        const int my_rank);
 
     /**
      * @brief Updates the k-points after a volume change.
@@ -206,7 +208,9 @@ class K_Vectors : public ModuleCell::ReciprocalGrid
                             const ModuleSymmetry::Symmetry& symm,
                             bool use_symm,
                             std::string& skpt,
-                            bool& match) override;
+                            bool& match,
+                            const int my_rank,
+                            std::ofstream& ofs_running) override;
 
     /// @brief step 1 : generate kpoints
 
@@ -296,10 +300,12 @@ class K_Vectors : public ModuleCell::ReciprocalGrid
      * @param ifk stream to read the special points from
      * @param kvec target coordinate container (kvec_c or kvec_d)
      * @param cartesian true for Line_Cartesian, false for Line_Direct
+     * @param ofs_warning warning-log stream for error messages
      */
     bool setup_line_kpoints(std::ifstream& ifk,
                             std::vector<ModuleBase::Vector3<double>>& kvec,
-                            const bool cartesian);
+                            const bool cartesian,
+                            std::ofstream& ofs_warning);
 
     /**
      * @brief Handle a reciprocal/real lattice Bravais-type mismatch after
@@ -317,7 +323,9 @@ class K_Vectors : public ModuleCell::ReciprocalGrid
     void handle_symmetry_mismatch(const UnitCell& ucell,
                                   const ModuleSymmetry::Symmetry& symm,
                                   std::string& skpt,
-                                  bool& match);
+                                  bool& match,
+                                  const int my_rank,
+                                  std::ofstream& ofs);
 
     /**
      * @brief Adds k-points linearly between special points.

source/source_cell/klist_io.cpp

@@ -344,22 +344,22 @@ 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 int nkstot_nospin,
                     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)
+        for (int ik = 0; ik < nkstot_nospin; ++ik)
         {
             kvec_c_full[ik] = kvec_d[ik] * reciprocal_vec;
         }
     }
     else if (kc_done && !kd_done)
     {
-        for (int ik = 0; ik < nkstot_full; ++ik)
+        for (int ik = 0; ik < nkstot_nospin; ++ik)
         {
             kvec_c_full[ik] = kvec_c[ik];
         }

source/source_cell/klist_io.h

@@ -127,7 +127,7 @@ void unpack_kpts(const std::vector<int>& isk_aux,
 /// K_Vectors::set() before IBZ reduction.
 void fill_full_kvec(bool kc_done,
                     bool kd_done,
-                    int nkstot_full,
+                    int nkstot_nospin,
                     const ModuleBase::Matrix3& reciprocal_vec,
                     const std::vector<ModuleBase::Vector3<double>>& kvec_c,
                     const std::vector<ModuleBase::Vector3<double>>& kvec_d,

source/source_cell/qlist.cpp

@@ -36,19 +36,19 @@ void QList::generate_mesh(UnitCell& ucell, ModuleSymmetry::Symmetry& symm,
     const double offset[3] = {0.0, 0.0, 0.0};
     this->Monkhorst_Pack(this->nmp, offset, 0);
 
-    this->nkstot_full = this->nkstot;
+    this->nkstot_nospin = this->nkstot;
     this->nks = this->nkstot;
 
     // Star reduction: always use symmetry, always include the -q partner.
     bool match = true;
     std::string skpt;
-    this->reduce_by_symmetry(ucell, symm, true, skpt, match);
+    this->reduce_by_symmetry(ucell, symm, true, skpt, match, GlobalV::MY_RANK, GlobalV::ofs_running);
     if (!match)
     {
         ModuleBase::WARNING("QList::generate_mesh",
                             "Reciprocal lattice is incompatible with the real-space lattice. "
                             "Falling back to the unreduced q-point mesh.");
-        this->nkstot = this->nks = this->nkstot_full;
+        this->nkstot = this->nks = this->nkstot_nospin;
     }
 
     // weights sum to 1 (average over the full Brillouin zone)
@@ -189,7 +189,7 @@ void QList::read_from_file(const std::string& filename, UnitCell& ucell) {
         }
     }
 
-    this->nkstot_full = this->nks = this->nkstot;
+    this->nkstot_nospin = this->nks = this->nkstot;
 
     // complement the coordinates: fill the missing representation
     if (!this->kc_done && this->kd_done)
@@ -329,8 +329,12 @@ void QList::reduce_by_symmetry(const UnitCell& ucell,
                                const ModuleSymmetry::Symmetry& symm,
                                bool use_symm,
                                std::string& skpt,
-                               bool& match) {
+                               bool& match,
+                               const int my_rank,
+                               std::ofstream& ofs_running) {
     (void)skpt;
+    (void)my_rank;
+    (void)ofs_running;
     // q-points are spin-free: build the point-group operations and always
     // double them by the time-reversal operation -q (no magnetic group).
     std::vector<ModuleBase::Matrix3> kgmatrix(48 * 2);

source/source_cell/qlist.h

@@ -135,7 +135,9 @@ class QList : public ModuleCell::ReciprocalGrid {
                             const ModuleSymmetry::Symmetry& symm,
                             bool use_symm,
                             std::string& skpt,
-                            bool& match) override;
+                            bool& match,
+                            const int my_rank,
+                            std::ofstream& ofs_running) override;
 
 private:
     std::vector<int> nirr_; ///< number of irreps for each q-point