deltaspin: remove GlobalV::ofs_running dependency from module_deltaspin

Pass ofs_running explicitly through function parameters instead of
referencing the GlobalV::ofs_running global variable directly inside
the deltaspin module. This follows ABACUS rule #1 (do not increase
cross-layer control through GlobalV) and matches the existing design
pattern used by print_Mi / print_Mag_Force.

Changes:
- spin_constrain.h: add std::ostream& ofs_running parameter to 7
  functions (run_lambda_loop, run_lambda_linear_scan, print_header,
  print_termination, check_rms_stop, check_restriction,
  check_gradient_decay). Added <fstream> include. Removed default
  value for 'rerun' and 'print' parameters to keep call sites
  explicit (rule deepmodeling#5).
- lambda_loop_helper.cpp: replace all GlobalV::ofs_running with the
  ofs_running parameter; remove #include source_base/global_variable.h.
- lambda_loop.cpp: replace all GlobalV::ofs_running with the
  ofs_running parameter; remove #include source_base/global_variable.h
  (kept #include source_io/module_parameter/parameter.h since PARAM is
  still used).
- basic_funcs.cpp: remove unused #include source_base/global_variable.h.
- template_helpers.cpp: update TK=double stub signatures to match.
- deltaspin_lcao.h/cpp: add ofs_running parameter to
  run_deltaspin_lambda_loop_lcao; add <iosfwd> include.
- deltaspin_pw.h/cpp: add ofs_running parameter to
  run_deltaspin_lambda_loop; add <iosfwd> include.
- esolver_ks_pw.cpp / esolver_ks_lcao.cpp: pass GlobalV::ofs_running
  at the call site (the esolver layer owns the dependency).
- template_helpers_test.cpp: pass std::cout at test call sites.

Result: module_deltaspin no longer references GlobalV::ofs_running.
The only remaining GlobalV:: usages in the module are historical MPI
constants (NPROC_IN_POOL, RANK_IN_POOL) in cal_mw*.cpp, untouched by
this change.

Author: abacus_fixer

source/source_esolver/esolver_ks_lcao.cpp

@@ -430,19 +430,19 @@ void ESolver_KS_LCAO<TK, TR>::hamilt2rho_single(UnitCell& ucell, int istep, int
         spinconstrain::SpinConstrain<TK>& sc = spinconstrain::SpinConstrain<TK>::getScInstance();
         if (this->inp_->sc_lambda_strategy == "linear_scan")
         {
-            sc.run_lambda_linear_scan(iter - 1);
+            sc.run_lambda_linear_scan(iter - 1, GlobalV::ofs_running);
             skip_solve = true;
         }
         else if (!sc.mag_converged() && this->drho > 0 && this->drho < this->inp_->sc_scf_thr)
         {
-            sc.run_lambda_loop(iter - 1);
+            sc.run_lambda_loop(iter - 1, true, GlobalV::ofs_running);
             this->ds_rms_ = sc.get_last_rms_error();
             sc.set_mag_converged(true);
             skip_solve = true;
         }
         else if (sc.mag_converged())
         {
-            sc.run_lambda_loop(iter - 1);
+            sc.run_lambda_loop(iter - 1, true, GlobalV::ofs_running);
             this->ds_rms_ = sc.get_last_rms_error();
             skip_solve = true;
         }

source/source_esolver/esolver_ks_pw.cpp

@@ -228,7 +228,7 @@ void ESolver_KS_PW<T, Device>::hamilt2rho_single(UnitCell& ucell, const int iste
     bool skip_charge = this->inp_->calculation == "nscf" ? true : false;
 
     // run the inner lambda loop to contrain atomic moments with the DeltaSpin method
-    bool skip_solve = pw::run_deltaspin_lambda_loop(iter - 1, this->drho, *this->inp_);
+    bool skip_solve = pw::run_deltaspin_lambda_loop(iter - 1, this->drho, *this->inp_, GlobalV::ofs_running);
     if (skip_solve)
     {
         // Fetch the most recent DeltaSpin RMS for display in the SCF iteration table.

source/source_lcao/module_deltaspin/basic_funcs.cpp

@@ -3,7 +3,6 @@
 #include <iostream>
 #include "source_base/constants.h"
 #include "source_base/formatter.h"
-#include "source_base/global_variable.h"
 
 double maxval_abs_2d(const std::vector<ModuleBase::Vector3<double>>& array)
 {

source/source_lcao/module_deltaspin/deltaspin_lcao.cpp

@@ -125,7 +125,8 @@ void cal_mi_lcao_wrapper(const int iter, const Input_para& inp)
 template <typename TK>
 bool run_deltaspin_lambda_loop_lcao(const int iter,
                                      const double drho,
-                                     const Input_para& inp)
+                                     const Input_para& inp,
+                                     std::ostream& ofs_running)
 {
     bool skip_solve = false;
 
@@ -136,14 +137,14 @@ bool run_deltaspin_lambda_loop_lcao(const int iter,
         if (!sc.mag_converged() && drho > 0 && drho < inp.sc_scf_thr)
         {
             /// Charge density is stable enough: optimize lambda for the first time
-            sc.run_lambda_loop(iter);
+            sc.run_lambda_loop(iter, true, ofs_running);
             sc.set_mag_converged(true);
             skip_solve = true;
         }
         else if (sc.mag_converged())
         {
             /// Already converged: refine lambda for the current charge density
-            sc.run_lambda_loop(iter);
+            sc.run_lambda_loop(iter, true, ofs_running);
             skip_solve = true;
         }
     }
@@ -174,9 +175,11 @@ template void cal_mi_lcao_wrapper<std::complex<double>>(const int iter, const In
 
 template bool run_deltaspin_lambda_loop_lcao<double>(const int iter,
                                                       const double drho,
-                                                      const Input_para& inp);
+                                                      const Input_para& inp,
+                                                      std::ostream& ofs_running);
 template bool run_deltaspin_lambda_loop_lcao<std::complex<double>>(const int iter,
                                                                       const double drho,
-                                                                      const Input_para& inp);
+                                                                      const Input_para& inp,
+                                                                      std::ostream& ofs_running);
 
 } // namespace ModuleESolver

source/source_lcao/module_deltaspin/deltaspin_lcao.h

@@ -1,6 +1,8 @@
 #ifndef DELTASPIN_LCAO_H
 #define DELTASPIN_LCAO_H
 
+#include <iosfwd>
+
 #include "source_cell/unitcell.h"
 #include "source_cell/klist.h"
 #include "source_io/module_parameter/input_parameter.h"
@@ -60,7 +62,8 @@ void cal_mi_lcao_wrapper(const int iter, const Input_para& inp);
 template <typename TK>
 bool run_deltaspin_lambda_loop_lcao(const int iter,
                                      const double drho,
-                                     const Input_para& inp);
+                                     const Input_para& inp,
+                                     std::ostream& ofs_running);
 
 } // namespace ModuleESolver
 

source/source_lcao/module_deltaspin/lambda_loop.cpp

@@ -8,7 +8,6 @@
 
 #include "basic_funcs.h"
 #include "source_base/constants.h"
-#include "source_base/global_variable.h"
 #include "source_io/module_parameter/parameter.h"
 
 /**
@@ -72,7 +71,7 @@
  *   - decay_grad thresholds are not too aggressive
  */
 template <>
-void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int outer_step, bool rerun)
+void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int outer_step, bool rerun, std::ostream& ofs_running)
 {
     int nat = this->get_nat();
     int ntype = this->get_ntype();
@@ -107,7 +106,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
 
     double inner_loop_duration = 0.0;
 
-    this->print_header();
+    this->print_header(ofs_running);
 
     // =============================================================
     // MAIN OPTIMIZATION LOOP
@@ -129,9 +128,9 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
             // Save initial lambda: for unconstrained components (constrain==0), set to 0
             where_fill_scalar_else_2d(this->constrain_, 0, zero, this->lambda_, initial_lambda);
 
-            print_2d(" initial lambda (eV/uB): ", initial_lambda, this->nspin_, ModuleBase::Ry_to_eV, GlobalV::ofs_running);
-            print_2d(" initial spin (uB): ", spin, this->nspin_, 1.0, GlobalV::ofs_running);
-            print_2d(" target spin (uB): ", this->target_mag_, this->nspin_, 1.0, GlobalV::ofs_running);
+            print_2d(" initial lambda (eV/uB): ", initial_lambda, this->nspin_, ModuleBase::Ry_to_eV, ofs_running);
+            print_2d(" initial spin (uB): ", spin, this->nspin_, 1.0, ofs_running);
+            print_2d(" target spin (uB): ", this->target_mag_, this->nspin_, 1.0, ofs_running);
             i_step++;
         }
         else
@@ -171,7 +170,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
             new_spin = this->Mi_;
 
             // Check if gradient dM/dlambda has decayed below threshold
-            bool GradLessThanBound = this->check_gradient_decay(new_spin, spin, delta_lambda, dnu_last_step);
+            bool GradLessThanBound = this->check_gradient_decay(new_spin, spin, delta_lambda, dnu_last_step, false, ofs_running);
             if (i_step >= this->nsc_min_ && GradLessThanBound)
             {
                 // Gradient has decayed: further optimization yields diminishing returns
@@ -186,8 +185,8 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
                     - iterstart)).count() / static_cast<double>(1e6);
 #endif
                 inner_loop_duration += duration;
-                GlobalV::ofs_running << " Total TIME(s) = " << inner_loop_duration << std::endl;
-                this->print_termination();
+                ofs_running << " Total TIME(s) = " << inner_loop_duration << std::endl;
+                this->print_termination(ofs_running);
                 break;
             }
             spin = new_spin;
@@ -260,7 +259,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
                 - iterstart)).count() / static_cast<double>(1e6);
 #endif
         inner_loop_duration += duration;
-        if (this->check_rms_stop(outer_step, i_step, rms_error, duration, inner_loop_duration))
+        if (this->check_rms_stop(outer_step, i_step, rms_error, duration, inner_loop_duration, ofs_running))
         {
             // Save RMS for ESolver to display in the SCF iteration table.
             this->last_rms_error_ = rms_error;
@@ -283,15 +282,15 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
                 }
                 mean_error = sum_2d(temp_1) / nat;
                 rms_error = std::sqrt(mean_error);
-                GlobalV::ofs_running<<" Current RMS: "<<rms_error<<std::endl;
+                ofs_running<<" Current RMS: "<<rms_error<<std::endl;
 
                 // If RMS is still large after full update, recursively rerun
                 // with higher precision (full PW solver instead of subspace only)
                 if(rms_error > this->current_sc_thr_ * 10 && rerun == true && this->higher_mag_prec == true)
                 {
                     std::cout<<" DeltaSpin: RMS error too large ("<<rms_error<<"), rerun inner loop with full PW solver"<<std::endl;
                     std::cout<<std::endl;
-                    this->run_lambda_loop(outer_step, false);
+                    this->run_lambda_loop(outer_step, false, ofs_running);
                 }
             }
             break;
@@ -317,7 +316,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
         }
 
         // Cap step size to prevent overshooting
-        this->check_restriction(search, alpha_trial);
+        this->check_restriction(search, alpha_trial, ofs_running);
 
         // =============================================================
         // CUMULATIVE STEP UPDATE
@@ -356,7 +355,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
 
         // Find optimal step size via linear interpolation
         alpha_opt = this->cal_alpha_opt(spin, spin_plus, alpha_trial);
-        this->check_restriction(search, alpha_opt);
+        this->check_restriction(search, alpha_opt, ofs_running);
 
         // Correct dnu: dnu += (alpha_opt - alpha_trial) * search
         alpha_plus = alpha_opt - alpha_trial;
@@ -423,7 +422,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_loop(int out
  *   step, lambda_eV_uB, Mi_x_0, Mi_y_0, Mi_z_0, Mi_x_1, ...
  */
 template <>
-void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(int outer_step)
+void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(int outer_step, std::ostream& ofs_running)
 {
     int nat = this->get_nat();
     int ntype = this->get_ntype();
@@ -433,7 +432,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
     int nsteps = PARAM.inp.sc_scan_steps;
 
     if (nsteps <= 0) {
-        GlobalV::ofs_running << " [DS-DIAG] linear_scan: sc_scan_steps <= 0, skipping" << std::endl;
+        ofs_running << " [DS-DIAG] linear_scan: sc_scan_steps <= 0, skipping" << std::endl;
         return;
     }
 
@@ -442,15 +441,15 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
     double lambda_end_ry = lambda_end / ModuleBase::Ry_to_eV;
     double lambda_step = (lambda_end_ry - lambda_start_ry) / (nsteps - 1);
 
-    GlobalV::ofs_running << "\n" << std::string(80, '=') << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] === LINEAR LAMBDA SCAN START ===" << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] Scan range: " << lambda_start << " -> " << lambda_end << " eV/uB" << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] Number of steps: " << nsteps << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] Lambda step size: " << lambda_step * ModuleBase::Ry_to_eV << " eV/uB" << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] nat = " << nat << ", ntype = " << ntype << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] nspin_ = " << this->nspin_ << ", npol_ = " << this->npol_ << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] p_operator = " << (this->p_operator ? "valid" : "NULL") << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] constrain_ size = " << this->constrain_.size() << std::endl;
+    ofs_running << "\n" << std::string(80, '=') << std::endl;
+    ofs_running << " [DS-DIAG] === LINEAR LAMBDA SCAN START ===" << std::endl;
+    ofs_running << " [DS-DIAG] Scan range: " << lambda_start << " -> " << lambda_end << " eV/uB" << std::endl;
+    ofs_running << " [DS-DIAG] Number of steps: " << nsteps << std::endl;
+    ofs_running << " [DS-DIAG] Lambda step size: " << lambda_step * ModuleBase::Ry_to_eV << " eV/uB" << std::endl;
+    ofs_running << " [DS-DIAG] nat = " << nat << ", ntype = " << ntype << std::endl;
+    ofs_running << " [DS-DIAG] nspin_ = " << this->nspin_ << ", npol_ = " << this->npol_ << std::endl;
+    ofs_running << " [DS-DIAG] p_operator = " << (this->p_operator ? "valid" : "NULL") << std::endl;
+    ofs_running << " [DS-DIAG] constrain_ size = " << this->constrain_.size() << std::endl;
 
     // Check if any constraints are defined; if not, set all atoms as constrained
     bool has_constraints = false;
@@ -462,7 +461,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
     }
 
     if (!has_constraints) {
-        GlobalV::ofs_running << " [DS-DIAG] No constraints found in STRU, setting all atoms as constrained" << std::endl;
+        ofs_running << " [DS-DIAG] No constraints found in STRU, setting all atoms as constrained" << std::endl;
         for (int ia = 0; ia < nat; ia++) {
             if (this->nspin_ == 4) {
                 this->constrain_[ia] = ModuleBase::Vector3<int>(1, 1, 1);
@@ -474,11 +473,11 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
     }
 
     for (int ia = 0; ia < nat; ia++) {
-        GlobalV::ofs_running << " [DS-DIAG]   Atom " << ia << " constrain = ("
+        ofs_running << " [DS-DIAG]   Atom " << ia << " constrain = ("
                              << this->constrain_[ia].x << ", " << this->constrain_[ia].y << ", " << this->constrain_[ia].z << ")"
                              << " target_mag = (" << this->target_mag_[ia].x << ", " << this->target_mag_[ia].y << ", " << this->target_mag_[ia].z << ")" << std::endl;
     }
-    GlobalV::ofs_running << std::string(80, '=') << "\n" << std::endl;
+    ofs_running << std::string(80, '=') << "\n" << std::endl;
 
     // Save initial lambda to restore after scan
     std::vector<ModuleBase::Vector3<double>> initial_lambda(nat, 0.0);
@@ -530,7 +529,7 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
             }
         }
 
-        GlobalV::ofs_running << " [DS-DIAG] === Scan step " << istep << "/" << nsteps
+        ofs_running << " [DS-DIAG] === Scan step " << istep << "/" << nsteps
                              << " lambda = " << lambda_val_ev << " eV/uB ===" << std::endl;
 
         // Compute magnetic moments at current lambda
@@ -551,22 +550,22 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
         }
         ofs_scan << std::endl;
 
-        GlobalV::ofs_running << " [DS-DIAG]   lambda = " << lambda_val_ev << " eV/uB" << std::endl;
+        ofs_running << " [DS-DIAG]   lambda = " << lambda_val_ev << " eV/uB" << std::endl;
         for (int ia = 0; ia < nat; ia++) {
-            GlobalV::ofs_running << " [DS-DIAG]   Atom " << ia << " Mi = ("
+            ofs_running << " [DS-DIAG]   Atom " << ia << " Mi = ("
                                  << this->Mi_[ia].x << ", "
                                  << this->Mi_[ia].y << ", "
                                  << this->Mi_[ia].z << ") uB" << std::endl;
         }
-        GlobalV::ofs_running << std::endl;
+        ofs_running << std::endl;
     }
 
     // =============================================================
     // CONSISTENCY CHECK: restore initial lambda and recompute Mi
     // to verify that the lambda->Mi mapping is numerically stable
     // after multiple lambda updates in the scan loop
     // =============================================================
-    GlobalV::ofs_running << " [DS-DIAG] === Consistency check: restoring initial lambda ===" << std::endl;
+    ofs_running << " [DS-DIAG] === Consistency check: restoring initial lambda ===" << std::endl;
     this->lambda_ = initial_lambda;
     this->cal_mw_from_lambda(nsteps);
 
@@ -580,9 +579,9 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
     }
     ofs_scan << std::endl;
 
-    GlobalV::ofs_running << " [DS-DIAG]   lambda = " << lambda_start << " eV/uB (restored)" << std::endl;
+    ofs_running << " [DS-DIAG]   lambda = " << lambda_start << " eV/uB (restored)" << std::endl;
     for (int ia = 0; ia < nat; ia++) {
-        GlobalV::ofs_running << " [DS-DIAG]   Atom " << ia << " Mi = ("
+        ofs_running << " [DS-DIAG]   Atom " << ia << " Mi = ("
                              << this->Mi_[ia].x << ", "
                              << this->Mi_[ia].y << ", "
                              << this->Mi_[ia].z << ") uB" << std::endl;
@@ -599,11 +598,11 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
         if (diff > max_mi_diff) max_mi_diff = diff;
         ofs_scan << "#   Atom " << ia << " dM = (" << dx << ", " << dy << ", " << dz << ") uB" << std::endl;
     }
-    GlobalV::ofs_running << " [DS-DIAG] Max Mi difference between step 0 and init_recheck: " << max_mi_diff << " uB" << std::endl;
+    ofs_running << " [DS-DIAG] Max Mi difference between step 0 and init_recheck: " << max_mi_diff << " uB" << std::endl;
     if (max_mi_diff > 1e-8) {
-        GlobalV::ofs_running << " [DS-DIAG] WARNING: Mi mapping may be inconsistent after multiple lambda updates!" << std::endl;
+        ofs_running << " [DS-DIAG] WARNING: Mi mapping may be inconsistent after multiple lambda updates!" << std::endl;
     } else {
-        GlobalV::ofs_running << " [DS-DIAG] OK: Mi mapping is consistent." << std::endl;
+        ofs_running << " [DS-DIAG] OK: Mi mapping is consistent." << std::endl;
     }
     ofs_scan << "#   Max Mi difference: " << max_mi_diff << " uB" << std::endl;
 
@@ -612,10 +611,10 @@ void spinconstrain::SpinConstrain<std::complex<double>>::run_lambda_linear_scan(
     // Restore original lambda values (already restored above, but explicit for clarity)
     this->lambda_ = initial_lambda;
 
-    GlobalV::ofs_running << std::string(80, '=') << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] === LINEAR LAMBDA SCAN COMPLETE ===" << std::endl;
-    GlobalV::ofs_running << " [DS-DIAG] Results written to: lambda_scan_results.dat" << std::endl;
-    GlobalV::ofs_running << std::string(80, '=') << "\n" << std::endl;
+    ofs_running << std::string(80, '=') << std::endl;
+    ofs_running << " [DS-DIAG] === LINEAR LAMBDA SCAN COMPLETE ===" << std::endl;
+    ofs_running << " [DS-DIAG] Results written to: lambda_scan_results.dat" << std::endl;
+    ofs_running << std::string(80, '=') << "\n" << std::endl;
 
     return;
 }