From 34456f5f7a81f2099d5f2064b42e43749f212347 Mon Sep 17 00:00:00 2001 From: hujieting <3114847804@qq.com> Date: Sat, 10 Oct 2026 11:25:00 +0800 Subject: [PATCH 1/3] refactor(deltaspin): encapsulate ScState::lambda_ and Mi_ as private with accessors --- .../module_deltaspin/cal_mw_from_lambda.cpp | 14 ++-- .../module_deltaspin/deltaspin_init.cpp | 2 +- .../module_deltaspin/deltaspin_lcao_mi.cpp | 28 ++++---- .../module_deltaspin/deltaspin_lcao_mi.h | 2 +- .../module_deltaspin/deltaspin_pw_mi.cpp | 14 ++-- .../module_deltaspin/deltaspin_pw_mi.h | 2 +- .../module_deltaspin/deltaspin_state.h | 14 +++- .../module_deltaspin/lambda_loop.cpp | 70 +++++++++---------- .../module_deltaspin/spin_constrain.h | 2 +- 9 files changed, 79 insertions(+), 69 deletions(-) diff --git a/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp b/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp index 2b0d39992e3..d5d655a96b2 100644 --- a/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp +++ b/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp @@ -175,7 +175,7 @@ void spinconstrain::SpinConstrain>::cal_mw_from_lambda( // FIRST CALL: save subspace data for reuse across lambda steps initial_hs = 1; this->pw_cache_.allocate_cpu(nbands, nk, size_becp); - this->pw_cache_.lambda_in_sub() = this->state_.lambda_; + this->pw_cache_.lambda_in_sub() = this->state_.get_sc_lambda(); } for (int ik = 0; ik < nk; ++ik) { @@ -199,7 +199,7 @@ void spinconstrain::SpinConstrain>::cal_mw_from_lambda( memcpy(h_tmp.data(), h_k, sizeof(std::complex) * nbands * nbands); memcpy(s_tmp.data(), s_k, sizeof(std::complex) * nbands * nbands); // Apply DeltaSpin correction (skip for initialization step i_step=-1) - if (i_step != -1) pw::calculate_delta_hcc(this->state_, this->pw_cache_, this->pelec, h_tmp.data(), becp_k, this->state_.lambda_.data(), nbands, nkb, nh_iat, ik, true); + if (i_step != -1) pw::calculate_delta_hcc(this->state_, this->pw_cache_, this->pelec, h_tmp.data(), becp_k, this->state_.get_sc_lambda().data(), nbands, nkb, nh_iat, ik, true); // Diagonalize in subspace, update becp (response wavefunctions) hsolver::DiagoIterAssist>::diag_responce(h_tmp.data(), @@ -237,7 +237,7 @@ void spinconstrain::SpinConstrain>::cal_mw_from_lambda( { initial_hs = 1; this->pw_cache_.allocate_gpu(nbands, nk, size_becp); - this->pw_cache_.lambda_in_sub() = this->state_.lambda_; + this->pw_cache_.lambda_in_sub() = this->state_.get_sc_lambda(); } std::complex* becp_pointer = nullptr; base_device::memory::resize_memory_op, base_device::DEVICE_GPU>()(becp_pointer, size_becp); @@ -261,7 +261,7 @@ void spinconstrain::SpinConstrain>::cal_mw_from_lambda( } base_device::memory::synchronize_memory_op, base_device::DEVICE_GPU, base_device::DEVICE_GPU>()(h_tmp, h_k, nbands * nbands); base_device::memory::synchronize_memory_op, base_device::DEVICE_GPU, base_device::DEVICE_GPU>()(s_tmp, s_k, nbands * nbands); - if (i_step != -1) pw::calculate_delta_hcc(this->state_, this->pw_cache_, this->pelec, h_tmp, becp_k, this->state_.lambda_.data(), nbands, nkb, nh_iat, ik, true); + if (i_step != -1) pw::calculate_delta_hcc(this->state_, this->pw_cache_, this->pelec, h_tmp, becp_k, this->state_.get_sc_lambda().data(), nbands, nkb, nh_iat, ik, true); hsolver::DiagoIterAssist, base_device::DEVICE_GPU>::diag_responce(h_tmp, s_tmp, @@ -294,13 +294,13 @@ void spinconstrain::SpinConstrain>::cal_mw_from_lambda( const std::complex* becp = &becp_tmp[ik * size_becp]; const int spin_sign = (this->state_.npol_ == 2) ? 1 : this->get_spin_sign(ik); accumulate_Mi_from_becp(becp, nkb, nbands, this->state_.npol_, spin_sign, - &this->pelec->wg(ik, 0), nh_iat, this->state_.Mi_); + &this->pelec->wg(ik, 0), nh_iat, this->state_.mutable_Mi()); } // MPI reduction: sum Mi across all k-pool ranks Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, - &(this->state_.Mi_[0][0]), - 3 * this->state_.Mi_.size()); + &(this->state_.mutable_Mi()[0][0]), + 3 * this->state_.get_Mi().size()); } } ModuleBase::timer::end("spinconstrain::SpinConstrain", "cal_mw_from_lambda"); diff --git a/source/source_lcao/module_deltaspin/deltaspin_init.cpp b/source/source_lcao/module_deltaspin/deltaspin_init.cpp index e410e2c7fee..7cb62f7eef0 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_init.cpp +++ b/source/source_lcao/module_deltaspin/deltaspin_init.cpp @@ -60,7 +60,7 @@ void init_sc_state(const ScInitParams& params, const UnitCell& ucell, ScState& s // Step 4: Load target magnetic moments and initial lambda from UnitCell // These are parsed from the STRU file's "sc_mag" and "lambda" keywords state.set_target_mag(unitcell::get_target_mag(ucell.atoms, ucell.ntype, ucell.nat)); - state.lambda_ = unitcell::get_lambda(ucell.atoms, ucell.ntype, ucell.nat); + state.mutable_lambda() = unitcell::get_lambda(ucell.atoms, ucell.ntype, ucell.nat); state.constrain_ = unitcell::get_constrain(ucell.atoms, ucell.ntype, ucell.nat); // Step 5: CRITICAL FIX for collinear spin (nspin=2) diff --git a/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp b/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp index b004057514e..03f747e61e8 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp +++ b/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp @@ -61,22 +61,22 @@ void cal_mi_lcao(ScState& state, dm->switch_dmr(0); // For nspin=2, only z-component is meaningful - for (int iat = 0; iat < state.Mi_.size(); iat++) + for (int iat = 0; iat < state.get_Mi().size(); iat++) { - state.Mi_[iat].x = 0.0; - state.Mi_[iat].y = 0.0; - state.Mi_[iat].z = moments[iat]; + state.mutable_Mi()[iat].x = 0.0; + state.mutable_Mi()[iat].y = 0.0; + state.mutable_Mi()[iat].z = moments[iat]; } } else if (state.nspin_ == 4) { // For nspin=4, moments array contains interleaved [Mx, My, Mz] per atom moments = static_cast, std::complex>>*>(p_operator)->cal_moment(dmr, state.get_constrain()); - for (int iat = 0; iat < state.Mi_.size(); iat++) + for (int iat = 0; iat < state.get_Mi().size(); iat++) { - state.Mi_[iat].x = moments[iat * 3]; - state.Mi_[iat].y = moments[iat * 3 + 1]; - state.Mi_[iat].z = moments[iat * 3 + 2]; + state.mutable_Mi()[iat].x = moments[iat * 3]; + state.mutable_Mi()[iat].y = moments[iat * 3 + 1]; + state.mutable_Mi()[iat].z = moments[iat * 3 + 2]; } } @@ -167,15 +167,15 @@ void calculate_mw_from_orbitals(const std::vector>; nullptr aborts diff --git a/source/source_lcao/module_deltaspin/deltaspin_pw_mi.cpp b/source/source_lcao/module_deltaspin/deltaspin_pw_mi.cpp index 4491e706e05..60bda69efcc 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_pw_mi.cpp +++ b/source/source_lcao/module_deltaspin/deltaspin_pw_mi.cpp @@ -83,7 +83,7 @@ void cal_mi_pw(ScState& state, int nkb = onsite_p->get_tot_nproj(); const int spin_sign = (npol == 2) ? 1 : spin_sign_at(state, pelec, ik); accumulate_Mi_from_becp(becp, nkb, nbands, npol, spin_sign, - &pelec->wg(ik, 0), &onsite_p->get_nh(0), state.Mi_); + &pelec->wg(ik, 0), &onsite_p->get_nh(0), state.mutable_Mi()); } } #if ((defined __CUDA) || (defined __ROCM)) @@ -105,12 +105,12 @@ void cal_mi_pw(ScState& state, int nkb = onsite_p->get_size_becp() / nbands / npol; const int spin_sign = (npol == 2) ? 1 : spin_sign_at(state, pelec, ik); accumulate_Mi_from_becp(becp, nkb, nbands, npol, spin_sign, - &pelec->wg(ik, 0), &onsite_p->get_nh(0), state.Mi_); + &pelec->wg(ik, 0), &onsite_p->get_nh(0), state.mutable_Mi()); } } #endif // MPI reduction: sum Mi across all k-pool ranks - Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, &(state.Mi_[0][0]), 3 * state.Mi_.size()); + Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, &(state.mutable_Mi()[0][0]), 3 * state.get_Mi().size()); ModuleBase::timer::end("spinconstrain::SpinConstrain", "cal_mi_pw"); } @@ -175,7 +175,7 @@ void calculate_delta_hcc(ScState& state, // The coefficient array uses {up-up, down-up, up-down, down-down}. // Then: ps_up = coeff0 * becp_up + coeff2 * becp_dn // ps_dn = coeff1 * becp_up + coeff3 * becp_dn - for (size_t iat = 0; iat < state.Mi_.size(); iat++) + for (size_t iat = 0; iat < state.get_Mi().size(); iat++) { const int nproj = nh_iat[iat]; const std::complex coefficients0(effective_lambda[iat][2], 0.0); @@ -206,7 +206,7 @@ void calculate_delta_hcc(ScState& state, // ps = lambda_z * spin_sign * becp // spin_sign = +1 for spin-up k-points, -1 for spin-down const int spin_sign = spin_sign_at(state, pelec, ik); - for (size_t iat = 0; iat < state.Mi_.size(); iat++) + for (size_t iat = 0; iat < state.get_Mi().size(); iat++) { const int nproj = nh_iat[iat]; double coefficients0 = effective_lambda[iat][2] * spin_sign; @@ -320,7 +320,7 @@ void update_psi_charge_pw_cpu(ScState& state, const ModuleBase::Vector3* lambda_for_hcc = delta_lambda; if (full_update) { - lambda_for_hcc = state.lambda_.data(); + lambda_for_hcc = state.get_sc_lambda().data(); } // ============================================================= @@ -439,7 +439,7 @@ void update_psi_charge_pw_gpu(ScState& state, const ModuleBase::Vector3* lambda_for_hcc = delta_lambda; if (full_update) { - lambda_for_hcc = state.lambda_.data(); + lambda_for_hcc = state.get_sc_lambda().data(); } // STAGE 1: Subspace diagonalization for each k-point (GPU) diff --git a/source/source_lcao/module_deltaspin/deltaspin_pw_mi.h b/source/source_lcao/module_deltaspin/deltaspin_pw_mi.h index 29e5ad373b9..4af0fa90249 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_pw_mi.h +++ b/source/source_lcao/module_deltaspin/deltaspin_pw_mi.h @@ -62,7 +62,7 @@ class SubspaceCache; * via OnsiteProjector::overlap_proj_psi, then decompose becp into magnetic moments. * Finally Mi is summed across all MPI k-pool ranks. * - * @param state Constraint state; state.Mi_ is filled in place. + * @param state Constraint state; its magnetic moments are filled in place. * @param psi PW wavefunctions (psi::Psi>*, passed as void* * to keep this header free of the Device template parameter). * @param pelec Electronic state (provides wg weights and k-list spin signs). diff --git a/source/source_lcao/module_deltaspin/deltaspin_state.h b/source/source_lcao/module_deltaspin/deltaspin_state.h index f4cd559ac9c..fbd4256fa38 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_state.h +++ b/source/source_lcao/module_deltaspin/deltaspin_state.h @@ -90,6 +90,11 @@ class ScState void set_constrain(const ModuleBase::Vector3* constrain_in, int nat_in); /// get sc_lambda const std::vector>& get_sc_lambda() const; + /// get mutable sc_lambda + std::vector>& mutable_lambda() + { + return lambda_; + } /// get target_mag const std::vector>& get_target_mag() const; /// get constrain @@ -145,6 +150,11 @@ class ScState double get_sc_drop_thr() const; /// get computed magnetic moments Mi per atom const std::vector>& get_Mi() const; + /// get mutable computed magnetic moments Mi per atom + std::vector>& mutable_Mi() + { + return Mi_; + } /// get human-readable atom labels ("Fe_0", "Fe_1", ...) for table printing const std::vector& get_atomLabels() const; /// Total number of orbitals across all constrained atoms @@ -171,9 +181,7 @@ class ScState * later refactoring step. * ============================================================= */ - std::vector> lambda_; ///< Lagrange multipliers (Ry/uB) per atom, 3 components std::vector> target_mag_; ///< Target magnetic moments (uB) per atom - std::vector> Mi_; ///< Current computed magnetic moments (uB) per atom std::vector> constrain_; ///< Per-atom/component constraint flags: 0=free, 1=constrained std::vector atomLabels_; ///< Human-readable labels: "Fe_0", "Fe_1", etc. int nspin_ = 0; ///< Spin type: 2=collinear, 4=non-collinear @@ -191,6 +199,8 @@ class ScState double tpiba = 0.0; ///< 2*pi/a lattice constant scaling factor, saved from UnitCell private: + std::vector> lambda_; ///< Lagrange multipliers (Ry/uB) per atom, 3 components + std::vector> Mi_; ///< Current computed magnetic moments (uB) per atom std::map> ScData; ///< Raw constraint data indexed by element type (itype) std::map ScDecayGrad; ///< Gradient decay thresholds (uB^2/eV) per element type std::vector decay_grad_; ///< Gradient decay thresholds converted to uB^2/Ry, per element type diff --git a/source/source_lcao/module_deltaspin/lambda_loop.cpp b/source/source_lcao/module_deltaspin/lambda_loop.cpp index 8534ef44341..f142e88a310 100644 --- a/source/source_lcao/module_deltaspin/lambda_loop.cpp +++ b/source/source_lcao/module_deltaspin/lambda_loop.cpp @@ -124,10 +124,10 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out // Compute initial magnetic moments and save starting state // ============================================================= this->cal_mw_from_lambda(i_step); - spin = this->state_.Mi_; + spin = this->state_.get_Mi(); // Save initial lambda: for unconstrained components (constrain==0), set to 0 - where_fill_scalar_else_2d(this->state_.constrain_, 0, zero, this->state_.lambda_, initial_lambda); + where_fill_scalar_else_2d(this->state_.constrain_, 0, zero, this->state_.get_sc_lambda(), initial_lambda); print_2d(" initial lambda (eV/uB): ", initial_lambda, this->state_.nspin_, ModuleBase::Ry_to_eV, ofs_running); print_2d(" initial spin (uB): ", spin, this->state_.nspin_, 1.0, ofs_running); @@ -145,7 +145,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out where_fill_scalar_2d(this->state_.constrain_, 0, zero, delta_lambda); // lambda = initial_lambda + delta_lambda - add_scalar_multiply_2d(initial_lambda, delta_lambda, one, this->state_.lambda_); + add_scalar_multiply_2d(initial_lambda, delta_lambda, one, this->state_.mutable_lambda()); // [direction_only mode] Project out parallel component of lambda // This keeps |lambda| -> 0, only constraining spin direction @@ -157,18 +157,18 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out if (norm > 1e-8) { const ModuleBase::Vector3 dir = target / norm; - double parallel = this->state_.lambda_[ia].x*dir.x + - this->state_.lambda_[ia].y*dir.y + - this->state_.lambda_[ia].z*dir.z; - this->state_.lambda_[ia].x -= parallel * dir.x; - this->state_.lambda_[ia].y -= parallel * dir.y; - this->state_.lambda_[ia].z -= parallel * dir.z; + double parallel = this->state_.get_sc_lambda()[ia].x*dir.x + + this->state_.get_sc_lambda()[ia].y*dir.y + + this->state_.get_sc_lambda()[ia].z*dir.z; + this->state_.mutable_lambda()[ia].x -= parallel * dir.x; + this->state_.mutable_lambda()[ia].y -= parallel * dir.y; + this->state_.mutable_lambda()[ia].z -= parallel * dir.z; } } // Apply lambda and compute new magnetic moments this->cal_mw_from_lambda(i_step, delta_lambda.data()); - new_spin = this->state_.Mi_; + new_spin = this->state_.get_Mi(); // Check if gradient dM/dlambda has decayed below threshold bool GradLessThanBound = check_gradient_decay(*this, new_spin, spin, delta_lambda, dnu_last_step, false, ofs_running); @@ -176,7 +176,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out { // Gradient has decayed: further optimization yields diminishing returns // Apply the last successful step and exit - add_scalar_multiply_2d(initial_lambda, dnu_last_step, one, this->state_.lambda_); + add_scalar_multiply_2d(initial_lambda, dnu_last_step, one, this->state_.mutable_lambda()); this->update_psi_charge(dnu_last_step.data(), true, true); #ifdef __MPI duration = (double)(MPI_Wtime() - iterstart); @@ -271,7 +271,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out if(PARAM.inp.basis_type == "pw") { pw::cal_mi_pw(this->state_, this->psi, this->pelec); - subtract_2d(this->state_.Mi_, this->state_.target_mag_, delta_spin); + subtract_2d(this->state_.get_Mi(), this->state_.target_mag_, delta_spin); where_fill_scalar_2d(this->state_.constrain_, 0, zero, delta_spin); search = delta_spin; for (int ia = 0; ia < nat; ia++) @@ -346,13 +346,13 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out // Mask unconstrained components where_fill_scalar_else_2d(this->state_.constrain_, 0, zero, delta_lambda, delta_lambda); // Update lambda - add_scalar_multiply_2d(initial_lambda, delta_lambda, one, this->state_.lambda_); + add_scalar_multiply_2d(initial_lambda, delta_lambda, one, this->state_.mutable_lambda()); // ============================================================= // TRIAL STEP: compute Mi at trial position // ============================================================= this->cal_mw_from_lambda(i_step, delta_lambda.data()); - spin_plus = this->state_.Mi_; + spin_plus = this->state_.get_Mi(); // Find optimal step size via linear interpolation alpha_opt = cal_alpha_opt(*this, spin, spin_plus, alpha_trial); @@ -482,7 +482,7 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( // Save initial lambda to restore after scan std::vector> initial_lambda(nat, 0.0); - where_fill_scalar_else_2d(this->state_.constrain_, 0, 0.0, this->state_.lambda_, initial_lambda); + where_fill_scalar_else_2d(this->state_.constrain_, 0, 0.0, this->state_.get_sc_lambda(), initial_lambda); // Open output file std::ofstream ofs_scan; @@ -523,9 +523,9 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( for (int ia = 0; ia < nat; ia++) { for (int ic = 0; ic < 3; ic++) { if (this->state_.constrain_[ia][ic] != 0) { - this->state_.lambda_[ia][ic] = lambda_val_ry; + this->state_.mutable_lambda()[ia][ic] = lambda_val_ry; } else { - this->state_.lambda_[ia][ic] = 0.0; + this->state_.mutable_lambda()[ia][ic] = 0.0; } } } @@ -538,25 +538,25 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( // Save step 0 Mi for consistency verification if (istep == 0) { - mi_step0 = this->state_.Mi_; + mi_step0 = this->state_.get_Mi(); } // Write results ofs_scan << std::scientific << std::setprecision(6); ofs_scan << istep << " " << lambda_val_ev; for (int ia = 0; ia < nat; ia++) { - ofs_scan << " " << this->state_.Mi_[ia].x - << " " << this->state_.Mi_[ia].y - << " " << this->state_.Mi_[ia].z; + ofs_scan << " " << this->state_.get_Mi()[ia].x + << " " << this->state_.get_Mi()[ia].y + << " " << this->state_.get_Mi()[ia].z; } ofs_scan << std::endl; ofs_running << " [DS-DIAG] lambda = " << lambda_val_ev << " eV/uB" << std::endl; for (int ia = 0; ia < nat; ia++) { ofs_running << " [DS-DIAG] Atom " << ia << " Mi = (" - << this->state_.Mi_[ia].x << ", " - << this->state_.Mi_[ia].y << ", " - << this->state_.Mi_[ia].z << ") uB" << std::endl; + << this->state_.get_Mi()[ia].x << ", " + << this->state_.get_Mi()[ia].y << ", " + << this->state_.get_Mi()[ia].z << ") uB" << std::endl; } ofs_running << std::endl; } @@ -567,34 +567,34 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( // after multiple lambda updates in the scan loop // ============================================================= ofs_running << " [DS-DIAG] === Consistency check: restoring initial lambda ===" << std::endl; - this->state_.lambda_ = initial_lambda; + this->state_.mutable_lambda() = initial_lambda; this->cal_mw_from_lambda(nsteps); // Write consistency check result ofs_scan << std::scientific << std::setprecision(6); ofs_scan << "init_recheck " << lambda_start; for (int ia = 0; ia < nat; ia++) { - ofs_scan << " " << this->state_.Mi_[ia].x - << " " << this->state_.Mi_[ia].y - << " " << this->state_.Mi_[ia].z; + ofs_scan << " " << this->state_.get_Mi()[ia].x + << " " << this->state_.get_Mi()[ia].y + << " " << this->state_.get_Mi()[ia].z; } ofs_scan << std::endl; ofs_running << " [DS-DIAG] lambda = " << lambda_start << " eV/uB (restored)" << std::endl; for (int ia = 0; ia < nat; ia++) { ofs_running << " [DS-DIAG] Atom " << ia << " Mi = (" - << this->state_.Mi_[ia].x << ", " - << this->state_.Mi_[ia].y << ", " - << this->state_.Mi_[ia].z << ") uB" << std::endl; + << this->state_.get_Mi()[ia].x << ", " + << this->state_.get_Mi()[ia].y << ", " + << this->state_.get_Mi()[ia].z << ") uB" << std::endl; } // Compare restored Mi with step 0 Mi to check consistency ofs_scan << "# [consistency] step 0 vs init_recheck Mi difference:" << std::endl; double max_mi_diff = 0.0; for (int ia = 0; ia < nat; ia++) { - double dx = std::abs(this->state_.Mi_[ia].x - mi_step0[ia].x); - double dy = std::abs(this->state_.Mi_[ia].y - mi_step0[ia].y); - double dz = std::abs(this->state_.Mi_[ia].z - mi_step0[ia].z); + double dx = std::abs(this->state_.get_Mi()[ia].x - mi_step0[ia].x); + double dy = std::abs(this->state_.get_Mi()[ia].y - mi_step0[ia].y); + double dz = std::abs(this->state_.get_Mi()[ia].z - mi_step0[ia].z); double diff = std::max({dx, dy, dz}); if (diff > max_mi_diff) max_mi_diff = diff; ofs_scan << "# Atom " << ia << " dM = (" << dx << ", " << dy << ", " << dz << ") uB" << std::endl; @@ -610,7 +610,7 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( ofs_scan.close(); // Restore original lambda values (already restored above, but explicit for clarity) - this->state_.lambda_ = initial_lambda; + this->state_.mutable_lambda() = initial_lambda; ofs_running << std::string(80, '=') << std::endl; ofs_running << " [DS-DIAG] === LINEAR LAMBDA SCAN COMPLETE ===" << std::endl; diff --git a/source/source_lcao/module_deltaspin/spin_constrain.h b/source/source_lcao/module_deltaspin/spin_constrain.h index 7dba0c2b89d..767f9ba10c6 100644 --- a/source/source_lcao/module_deltaspin/spin_constrain.h +++ b/source/source_lcao/module_deltaspin/spin_constrain.h @@ -165,7 +165,7 @@ class SpinConstrain * @details Uses the DeltaSpin operator to compute magnetic moments from the density * matrix. For nspin=2, extracts only the z-component. For nspin=4, extracts * all three components from the interleaved 4-component spinor density matrix. - * The moments are stored in state_.Mi_ (indexed by global atom index iat). + * The moments are stored in ScState (indexed by global atom index iat). * * @param step Current SCF iteration number (for logging) * @param print Whether to print moments to ofs_running From 519c7558036228a1adbdc6de6e66a4ed34e1ddd3 Mon Sep 17 00:00:00 2001 From: hujieting <3114647804@qq.com> Date: Sat, 10 Oct 2026 15:19:45 +0800 Subject: [PATCH 2/3] refactor(deltaspin): rename mutable accessors per review --- .../module_deltaspin/cal_mw_from_lambda.cpp | 4 ++-- .../module_deltaspin/deltaspin_init.cpp | 2 +- .../module_deltaspin/deltaspin_lcao_mi.cpp | 24 +++++++++---------- .../module_deltaspin/deltaspin_pw_mi.cpp | 6 ++--- .../module_deltaspin/deltaspin_state.h | 4 ++-- .../module_deltaspin/lambda_loop.cpp | 20 ++++++++-------- 6 files changed, 30 insertions(+), 30 deletions(-) diff --git a/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp b/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp index d5d655a96b2..266434a99d4 100644 --- a/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp +++ b/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp @@ -294,12 +294,12 @@ void spinconstrain::SpinConstrain>::cal_mw_from_lambda( const std::complex* becp = &becp_tmp[ik * size_becp]; const int spin_sign = (this->state_.npol_ == 2) ? 1 : this->get_spin_sign(ik); accumulate_Mi_from_becp(becp, nkb, nbands, this->state_.npol_, spin_sign, - &this->pelec->wg(ik, 0), nh_iat, this->state_.mutable_Mi()); + &this->pelec->wg(ik, 0), nh_iat, this->state_.get_mi()); } // MPI reduction: sum Mi across all k-pool ranks Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, - &(this->state_.mutable_Mi()[0][0]), + &(this->state_.get_mi()[0][0]), 3 * this->state_.get_Mi().size()); } } diff --git a/source/source_lcao/module_deltaspin/deltaspin_init.cpp b/source/source_lcao/module_deltaspin/deltaspin_init.cpp index 7cb62f7eef0..b3d73abd21c 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_init.cpp +++ b/source/source_lcao/module_deltaspin/deltaspin_init.cpp @@ -60,7 +60,7 @@ void init_sc_state(const ScInitParams& params, const UnitCell& ucell, ScState& s // Step 4: Load target magnetic moments and initial lambda from UnitCell // These are parsed from the STRU file's "sc_mag" and "lambda" keywords state.set_target_mag(unitcell::get_target_mag(ucell.atoms, ucell.ntype, ucell.nat)); - state.mutable_lambda() = unitcell::get_lambda(ucell.atoms, ucell.ntype, ucell.nat); + state.get_lambda() = unitcell::get_lambda(ucell.atoms, ucell.ntype, ucell.nat); state.constrain_ = unitcell::get_constrain(ucell.atoms, ucell.ntype, ucell.nat); // Step 5: CRITICAL FIX for collinear spin (nspin=2) diff --git a/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp b/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp index 03f747e61e8..78ba7c7c045 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp +++ b/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp @@ -63,9 +63,9 @@ void cal_mi_lcao(ScState& state, // For nspin=2, only z-component is meaningful for (int iat = 0; iat < state.get_Mi().size(); iat++) { - state.mutable_Mi()[iat].x = 0.0; - state.mutable_Mi()[iat].y = 0.0; - state.mutable_Mi()[iat].z = moments[iat]; + state.get_mi()[iat].x = 0.0; + state.get_mi()[iat].y = 0.0; + state.get_mi()[iat].z = moments[iat]; } } else if (state.nspin_ == 4) @@ -74,9 +74,9 @@ void cal_mi_lcao(ScState& state, moments = static_cast, std::complex>>*>(p_operator)->cal_moment(dmr, state.get_constrain()); for (int iat = 0; iat < state.get_Mi().size(); iat++) { - state.mutable_Mi()[iat].x = moments[iat * 3]; - state.mutable_Mi()[iat].y = moments[iat * 3 + 1]; - state.mutable_Mi()[iat].z = moments[iat * 3 + 2]; + state.get_mi()[iat].x = moments[iat * 3]; + state.get_mi()[iat].y = moments[iat * 3 + 1]; + state.get_mi()[iat].z = moments[iat * 3 + 2]; } } @@ -167,15 +167,15 @@ void calculate_mw_from_orbitals(const std::vectorget_tot_nproj(); const int spin_sign = (npol == 2) ? 1 : spin_sign_at(state, pelec, ik); accumulate_Mi_from_becp(becp, nkb, nbands, npol, spin_sign, - &pelec->wg(ik, 0), &onsite_p->get_nh(0), state.mutable_Mi()); + &pelec->wg(ik, 0), &onsite_p->get_nh(0), state.get_mi()); } } #if ((defined __CUDA) || (defined __ROCM)) @@ -105,12 +105,12 @@ void cal_mi_pw(ScState& state, int nkb = onsite_p->get_size_becp() / nbands / npol; const int spin_sign = (npol == 2) ? 1 : spin_sign_at(state, pelec, ik); accumulate_Mi_from_becp(becp, nkb, nbands, npol, spin_sign, - &pelec->wg(ik, 0), &onsite_p->get_nh(0), state.mutable_Mi()); + &pelec->wg(ik, 0), &onsite_p->get_nh(0), state.get_mi()); } } #endif // MPI reduction: sum Mi across all k-pool ranks - Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, &(state.mutable_Mi()[0][0]), 3 * state.get_Mi().size()); + Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, &(state.get_mi()[0][0]), 3 * state.get_Mi().size()); ModuleBase::timer::end("spinconstrain::SpinConstrain", "cal_mi_pw"); } diff --git a/source/source_lcao/module_deltaspin/deltaspin_state.h b/source/source_lcao/module_deltaspin/deltaspin_state.h index fbd4256fa38..9c38d4443b4 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_state.h +++ b/source/source_lcao/module_deltaspin/deltaspin_state.h @@ -91,7 +91,7 @@ class ScState /// get sc_lambda const std::vector>& get_sc_lambda() const; /// get mutable sc_lambda - std::vector>& mutable_lambda() + std::vector>& get_lambda() { return lambda_; } @@ -151,7 +151,7 @@ class ScState /// get computed magnetic moments Mi per atom const std::vector>& get_Mi() const; /// get mutable computed magnetic moments Mi per atom - std::vector>& mutable_Mi() + std::vector>& get_mi() { return Mi_; } diff --git a/source/source_lcao/module_deltaspin/lambda_loop.cpp b/source/source_lcao/module_deltaspin/lambda_loop.cpp index f142e88a310..2f97fd62038 100644 --- a/source/source_lcao/module_deltaspin/lambda_loop.cpp +++ b/source/source_lcao/module_deltaspin/lambda_loop.cpp @@ -145,7 +145,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out where_fill_scalar_2d(this->state_.constrain_, 0, zero, delta_lambda); // lambda = initial_lambda + delta_lambda - add_scalar_multiply_2d(initial_lambda, delta_lambda, one, this->state_.mutable_lambda()); + add_scalar_multiply_2d(initial_lambda, delta_lambda, one, this->state_.get_lambda()); // [direction_only mode] Project out parallel component of lambda // This keeps |lambda| -> 0, only constraining spin direction @@ -160,9 +160,9 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out double parallel = this->state_.get_sc_lambda()[ia].x*dir.x + this->state_.get_sc_lambda()[ia].y*dir.y + this->state_.get_sc_lambda()[ia].z*dir.z; - this->state_.mutable_lambda()[ia].x -= parallel * dir.x; - this->state_.mutable_lambda()[ia].y -= parallel * dir.y; - this->state_.mutable_lambda()[ia].z -= parallel * dir.z; + this->state_.get_lambda()[ia].x -= parallel * dir.x; + this->state_.get_lambda()[ia].y -= parallel * dir.y; + this->state_.get_lambda()[ia].z -= parallel * dir.z; } } @@ -176,7 +176,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out { // Gradient has decayed: further optimization yields diminishing returns // Apply the last successful step and exit - add_scalar_multiply_2d(initial_lambda, dnu_last_step, one, this->state_.mutable_lambda()); + add_scalar_multiply_2d(initial_lambda, dnu_last_step, one, this->state_.get_lambda()); this->update_psi_charge(dnu_last_step.data(), true, true); #ifdef __MPI duration = (double)(MPI_Wtime() - iterstart); @@ -346,7 +346,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out // Mask unconstrained components where_fill_scalar_else_2d(this->state_.constrain_, 0, zero, delta_lambda, delta_lambda); // Update lambda - add_scalar_multiply_2d(initial_lambda, delta_lambda, one, this->state_.mutable_lambda()); + add_scalar_multiply_2d(initial_lambda, delta_lambda, one, this->state_.get_lambda()); // ============================================================= // TRIAL STEP: compute Mi at trial position @@ -523,9 +523,9 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( for (int ia = 0; ia < nat; ia++) { for (int ic = 0; ic < 3; ic++) { if (this->state_.constrain_[ia][ic] != 0) { - this->state_.mutable_lambda()[ia][ic] = lambda_val_ry; + this->state_.get_lambda()[ia][ic] = lambda_val_ry; } else { - this->state_.mutable_lambda()[ia][ic] = 0.0; + this->state_.get_lambda()[ia][ic] = 0.0; } } } @@ -567,7 +567,7 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( // after multiple lambda updates in the scan loop // ============================================================= ofs_running << " [DS-DIAG] === Consistency check: restoring initial lambda ===" << std::endl; - this->state_.mutable_lambda() = initial_lambda; + this->state_.get_lambda() = initial_lambda; this->cal_mw_from_lambda(nsteps); // Write consistency check result @@ -610,7 +610,7 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( ofs_scan.close(); // Restore original lambda values (already restored above, but explicit for clarity) - this->state_.mutable_lambda() = initial_lambda; + this->state_.get_lambda() = initial_lambda; ofs_running << std::string(80, '=') << std::endl; ofs_running << " [DS-DIAG] === LINEAR LAMBDA SCAN COMPLETE ===" << std::endl; From 276087e17f554003fdc9d8ebadba8ddf87481e58 Mon Sep 17 00:00:00 2001 From: hujieting <3114647804@qq.com> Date: Sat, 10 Oct 2026 15:35:22 +0800 Subject: [PATCH 3/3] refactor(deltaspin): unify ScState accessor naming --- .../module_deltaspin/cal_mw_from_lambda.cpp | 2 +- .../module_deltaspin/deltaspin_lcao_mi.cpp | 4 +- .../module_deltaspin/deltaspin_pw_mi.cpp | 6 +-- .../module_deltaspin/deltaspin_state.cpp | 2 +- .../module_deltaspin/deltaspin_state.h | 2 +- .../module_deltaspin/lambda_loop.cpp | 40 +++++++++---------- .../module_deltaspin/lambda_loop_helper.cpp | 4 +- .../module_deltaspin/lambda_loop_helper.h | 2 +- .../module_deltaspin/spin_constrain.h | 2 +- 9 files changed, 32 insertions(+), 32 deletions(-) diff --git a/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp b/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp index 266434a99d4..a2dc544ae7d 100644 --- a/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp +++ b/source/source_lcao/module_deltaspin/cal_mw_from_lambda.cpp @@ -300,7 +300,7 @@ void spinconstrain::SpinConstrain>::cal_mw_from_lambda( Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, &(this->state_.get_mi()[0][0]), - 3 * this->state_.get_Mi().size()); + 3 * this->state_.get_mi().size()); } } ModuleBase::timer::end("spinconstrain::SpinConstrain", "cal_mw_from_lambda"); diff --git a/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp b/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp index 78ba7c7c045..f0737236ff7 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp +++ b/source/source_lcao/module_deltaspin/deltaspin_lcao_mi.cpp @@ -61,7 +61,7 @@ void cal_mi_lcao(ScState& state, dm->switch_dmr(0); // For nspin=2, only z-component is meaningful - for (int iat = 0; iat < state.get_Mi().size(); iat++) + for (int iat = 0; iat < state.get_mi().size(); iat++) { state.get_mi()[iat].x = 0.0; state.get_mi()[iat].y = 0.0; @@ -72,7 +72,7 @@ void cal_mi_lcao(ScState& state, { // For nspin=4, moments array contains interleaved [Mx, My, Mz] per atom moments = static_cast, std::complex>>*>(p_operator)->cal_moment(dmr, state.get_constrain()); - for (int iat = 0; iat < state.get_Mi().size(); iat++) + for (int iat = 0; iat < state.get_mi().size(); iat++) { state.get_mi()[iat].x = moments[iat * 3]; state.get_mi()[iat].y = moments[iat * 3 + 1]; diff --git a/source/source_lcao/module_deltaspin/deltaspin_pw_mi.cpp b/source/source_lcao/module_deltaspin/deltaspin_pw_mi.cpp index 6b5682b0ae8..d692ecda7eb 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_pw_mi.cpp +++ b/source/source_lcao/module_deltaspin/deltaspin_pw_mi.cpp @@ -110,7 +110,7 @@ void cal_mi_pw(ScState& state, } #endif // MPI reduction: sum Mi across all k-pool ranks - Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, &(state.get_mi()[0][0]), 3 * state.get_Mi().size()); + Parallel_Reduce::reduce_double_allpool(PARAM.inp.kpar, GlobalV::NPROC_IN_POOL, &(state.get_mi()[0][0]), 3 * state.get_mi().size()); ModuleBase::timer::end("spinconstrain::SpinConstrain", "cal_mi_pw"); } @@ -175,7 +175,7 @@ void calculate_delta_hcc(ScState& state, // The coefficient array uses {up-up, down-up, up-down, down-down}. // Then: ps_up = coeff0 * becp_up + coeff2 * becp_dn // ps_dn = coeff1 * becp_up + coeff3 * becp_dn - for (size_t iat = 0; iat < state.get_Mi().size(); iat++) + for (size_t iat = 0; iat < state.get_mi().size(); iat++) { const int nproj = nh_iat[iat]; const std::complex coefficients0(effective_lambda[iat][2], 0.0); @@ -206,7 +206,7 @@ void calculate_delta_hcc(ScState& state, // ps = lambda_z * spin_sign * becp // spin_sign = +1 for spin-up k-points, -1 for spin-down const int spin_sign = spin_sign_at(state, pelec, ik); - for (size_t iat = 0; iat < state.get_Mi().size(); iat++) + for (size_t iat = 0; iat < state.get_mi().size(); iat++) { const int nproj = nh_iat[iat]; double coefficients0 = effective_lambda[iat][2] * spin_sign; diff --git a/source/source_lcao/module_deltaspin/deltaspin_state.cpp b/source/source_lcao/module_deltaspin/deltaspin_state.cpp index b4890ce91b9..ced10695c19 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_state.cpp +++ b/source/source_lcao/module_deltaspin/deltaspin_state.cpp @@ -530,7 +530,7 @@ double ScState::get_current_sc_thr() const } /// get computed magnetic moments Mi per atom -const std::vector>& ScState::get_Mi() const +const std::vector>& ScState::get_mi() const { return this->Mi_; } diff --git a/source/source_lcao/module_deltaspin/deltaspin_state.h b/source/source_lcao/module_deltaspin/deltaspin_state.h index 9c38d4443b4..54d7d0b7b38 100644 --- a/source/source_lcao/module_deltaspin/deltaspin_state.h +++ b/source/source_lcao/module_deltaspin/deltaspin_state.h @@ -149,7 +149,7 @@ class ScState /// get sc_drop_thr double get_sc_drop_thr() const; /// get computed magnetic moments Mi per atom - const std::vector>& get_Mi() const; + const std::vector>& get_mi() const; /// get mutable computed magnetic moments Mi per atom std::vector>& get_mi() { diff --git a/source/source_lcao/module_deltaspin/lambda_loop.cpp b/source/source_lcao/module_deltaspin/lambda_loop.cpp index 2f97fd62038..53615dd544c 100644 --- a/source/source_lcao/module_deltaspin/lambda_loop.cpp +++ b/source/source_lcao/module_deltaspin/lambda_loop.cpp @@ -124,7 +124,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out // Compute initial magnetic moments and save starting state // ============================================================= this->cal_mw_from_lambda(i_step); - spin = this->state_.get_Mi(); + spin = this->state_.get_mi(); // Save initial lambda: for unconstrained components (constrain==0), set to 0 where_fill_scalar_else_2d(this->state_.constrain_, 0, zero, this->state_.get_sc_lambda(), initial_lambda); @@ -168,7 +168,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out // Apply lambda and compute new magnetic moments this->cal_mw_from_lambda(i_step, delta_lambda.data()); - new_spin = this->state_.get_Mi(); + new_spin = this->state_.get_mi(); // Check if gradient dM/dlambda has decayed below threshold bool GradLessThanBound = check_gradient_decay(*this, new_spin, spin, delta_lambda, dnu_last_step, false, ofs_running); @@ -271,7 +271,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out if(PARAM.inp.basis_type == "pw") { pw::cal_mi_pw(this->state_, this->psi, this->pelec); - subtract_2d(this->state_.get_Mi(), this->state_.target_mag_, delta_spin); + subtract_2d(this->state_.get_mi(), this->state_.target_mag_, delta_spin); where_fill_scalar_2d(this->state_.constrain_, 0, zero, delta_spin); search = delta_spin; for (int ia = 0; ia < nat; ia++) @@ -352,7 +352,7 @@ void spinconstrain::SpinConstrain>::run_lambda_loop(int out // TRIAL STEP: compute Mi at trial position // ============================================================= this->cal_mw_from_lambda(i_step, delta_lambda.data()); - spin_plus = this->state_.get_Mi(); + spin_plus = this->state_.get_mi(); // Find optimal step size via linear interpolation alpha_opt = cal_alpha_opt(*this, spin, spin_plus, alpha_trial); @@ -538,25 +538,25 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( // Save step 0 Mi for consistency verification if (istep == 0) { - mi_step0 = this->state_.get_Mi(); + mi_step0 = this->state_.get_mi(); } // Write results ofs_scan << std::scientific << std::setprecision(6); ofs_scan << istep << " " << lambda_val_ev; for (int ia = 0; ia < nat; ia++) { - ofs_scan << " " << this->state_.get_Mi()[ia].x - << " " << this->state_.get_Mi()[ia].y - << " " << this->state_.get_Mi()[ia].z; + ofs_scan << " " << this->state_.get_mi()[ia].x + << " " << this->state_.get_mi()[ia].y + << " " << this->state_.get_mi()[ia].z; } ofs_scan << std::endl; ofs_running << " [DS-DIAG] lambda = " << lambda_val_ev << " eV/uB" << std::endl; for (int ia = 0; ia < nat; ia++) { ofs_running << " [DS-DIAG] Atom " << ia << " Mi = (" - << this->state_.get_Mi()[ia].x << ", " - << this->state_.get_Mi()[ia].y << ", " - << this->state_.get_Mi()[ia].z << ") uB" << std::endl; + << this->state_.get_mi()[ia].x << ", " + << this->state_.get_mi()[ia].y << ", " + << this->state_.get_mi()[ia].z << ") uB" << std::endl; } ofs_running << std::endl; } @@ -574,27 +574,27 @@ void spinconstrain::SpinConstrain>::run_lambda_linear_scan( ofs_scan << std::scientific << std::setprecision(6); ofs_scan << "init_recheck " << lambda_start; for (int ia = 0; ia < nat; ia++) { - ofs_scan << " " << this->state_.get_Mi()[ia].x - << " " << this->state_.get_Mi()[ia].y - << " " << this->state_.get_Mi()[ia].z; + ofs_scan << " " << this->state_.get_mi()[ia].x + << " " << this->state_.get_mi()[ia].y + << " " << this->state_.get_mi()[ia].z; } ofs_scan << std::endl; ofs_running << " [DS-DIAG] lambda = " << lambda_start << " eV/uB (restored)" << std::endl; for (int ia = 0; ia < nat; ia++) { ofs_running << " [DS-DIAG] Atom " << ia << " Mi = (" - << this->state_.get_Mi()[ia].x << ", " - << this->state_.get_Mi()[ia].y << ", " - << this->state_.get_Mi()[ia].z << ") uB" << std::endl; + << this->state_.get_mi()[ia].x << ", " + << this->state_.get_mi()[ia].y << ", " + << this->state_.get_mi()[ia].z << ") uB" << std::endl; } // Compare restored Mi with step 0 Mi to check consistency ofs_scan << "# [consistency] step 0 vs init_recheck Mi difference:" << std::endl; double max_mi_diff = 0.0; for (int ia = 0; ia < nat; ia++) { - double dx = std::abs(this->state_.get_Mi()[ia].x - mi_step0[ia].x); - double dy = std::abs(this->state_.get_Mi()[ia].y - mi_step0[ia].y); - double dz = std::abs(this->state_.get_Mi()[ia].z - mi_step0[ia].z); + double dx = std::abs(this->state_.get_mi()[ia].x - mi_step0[ia].x); + double dy = std::abs(this->state_.get_mi()[ia].y - mi_step0[ia].y); + double dz = std::abs(this->state_.get_mi()[ia].z - mi_step0[ia].z); double diff = std::max({dx, dy, dz}); if (diff > max_mi_diff) max_mi_diff = diff; ofs_scan << "# Atom " << ia << " dM = (" << dx << ", " << dy << ", " << dz << ") uB" << std::endl; diff --git a/source/source_lcao/module_deltaspin/lambda_loop_helper.cpp b/source/source_lcao/module_deltaspin/lambda_loop_helper.cpp index 0aa0afa3de4..4cd00c66006 100644 --- a/source/source_lcao/module_deltaspin/lambda_loop_helper.cpp +++ b/source/source_lcao/module_deltaspin/lambda_loop_helper.cpp @@ -40,7 +40,7 @@ namespace spinconstrain template void print_termination(const SpinConstrain& sc, std::ostream& ofs_running) { - print_2d(" after-optimization spin (uB): (print in the inner loop): ", sc.get_Mi(), sc.get_nspin(), 1.0, ofs_running); + print_2d(" after-optimization spin (uB): (print in the inner loop): ", sc.get_mi(), sc.get_nspin(), 1.0, ofs_running); print_2d(" after-optimization lambda (eV/uB): (print in the inner loop): ", sc.get_sc_lambda(), sc.get_nspin(), @@ -351,7 +351,7 @@ void print_Mi(const SpinConstrain& sc, std::ostream& ofs_running) sc.check_atomCounts(); const int nat = sc.get_nat(); const int nspin = sc.get_nspin(); - const auto& Mi = sc.get_Mi(); + const auto& Mi = sc.get_mi(); const auto& atomLabel = sc.get_atomLabels(); std::vector atom_labels_iat(nat); for (const auto& it : sc.get_atomCounts()) diff --git a/source/source_lcao/module_deltaspin/lambda_loop_helper.h b/source/source_lcao/module_deltaspin/lambda_loop_helper.h index dfe501d4a99..df918c40da1 100644 --- a/source/source_lcao/module_deltaspin/lambda_loop_helper.h +++ b/source/source_lcao/module_deltaspin/lambda_loop_helper.h @@ -16,7 +16,7 @@ * They have been lifted to free functions in the spinconstrain namespace to * shrink the SpinConstrain god class. Each helper takes the SpinConstrain * instance as its first parameter and accesses internal state through the - * public getters (get_Mi, get_sc_lambda, get_constrain, ...). + * public getters (get_mi, get_sc_lambda, get_constrain, ...). * * @par Template parameter TK * - std::complex: full implementation (nspin=2 and nspin=4) diff --git a/source/source_lcao/module_deltaspin/spin_constrain.h b/source/source_lcao/module_deltaspin/spin_constrain.h index 767f9ba10c6..4bd86a72e6f 100644 --- a/source/source_lcao/module_deltaspin/spin_constrain.h +++ b/source/source_lcao/module_deltaspin/spin_constrain.h @@ -401,7 +401,7 @@ class SpinConstrain /// get sc_drop_thr double get_sc_drop_thr() const { return state_.get_sc_drop_thr(); } /// get computed magnetic moments Mi per atom - const std::vector>& get_Mi() const { return state_.get_Mi(); } + const std::vector>& get_mi() const { return state_.get_mi(); } /// get human-readable atom labels ("Fe_0", "Fe_1", ...) for table printing const std::vector& get_atomLabels() const { return state_.get_atomLabels(); } /// @brief set orbital parallel info