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 2b0d39992e..a2dc544ae7 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_.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_.Mi_[0][0]), - 3 * this->state_.Mi_.size()); + &(this->state_.get_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 e410e2c7fe..b3d73abd21 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.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 b004057514..f0737236ff 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.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) { // 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.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::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 4491e706e0..d692ecda7e 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.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.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.Mi_[0][0]), 3 * state.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.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 29e5ad373b..4af0fa9024 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.cpp b/source/source_lcao/module_deltaspin/deltaspin_state.cpp index b4890ce91b..ced10695c1 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 f4cd559ac9..54d7d0b7b3 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>& get_lambda() + { + return lambda_; + } /// get target_mag const std::vector>& get_target_mag() const; /// get constrain @@ -144,7 +149,12 @@ 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() + { + 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 a4cb57ca63..e90d617c59 100644 --- a/source/source_lcao/module_deltaspin/lambda_loop.cpp +++ b/source/source_lcao/module_deltaspin/lambda_loop.cpp @@ -122,10 +122,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); @@ -143,7 +143,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_.get_lambda()); // [direction_only mode] Project out parallel component of lambda // This keeps |lambda| -> 0, only constraining spin direction @@ -155,18 +155,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_lambda()[ia].x*dir.x + + this->state_.get_lambda()[ia].y*dir.y + + this->state_.get_lambda()[ia].z*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; } } // 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); @@ -174,7 +174,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_.get_lambda()); this->update_psi_charge(dnu_last_step.data(), true, true); #ifdef __MPI duration = (double)(MPI_Wtime() - iterstart); @@ -269,7 +269,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++) @@ -344,13 +344,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_.get_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); diff --git a/source/source_lcao/module_deltaspin/lambda_loop_diag.cpp b/source/source_lcao/module_deltaspin/lambda_loop_diag.cpp index 71bb63c3a9..090d15a899 100644 --- a/source/source_lcao/module_deltaspin/lambda_loop_diag.cpp +++ b/source/source_lcao/module_deltaspin/lambda_loop_diag.cpp @@ -85,7 +85,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; @@ -126,9 +126,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_.get_lambda()[ia][ic] = lambda_val_ry; } else { - this->state_.lambda_[ia][ic] = 0.0; + this->state_.get_lambda()[ia][ic] = 0.0; } } } @@ -141,25 +141,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; } @@ -170,34 +170,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_.get_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; @@ -213,7 +213,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_.get_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/lambda_loop_helper.cpp b/source/source_lcao/module_deltaspin/lambda_loop_helper.cpp index 0aa0afa3de..4cd00c6600 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 dfe501d4a9..df918c40da 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 7dba0c2b89..4bd86a72e6 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 @@ -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 diff --git a/source/source_lcao/module_deltaspin/test/test_deltaspin_state.cpp b/source/source_lcao/module_deltaspin/test/test_deltaspin_state.cpp index 56991a594d..4f80aaab97 100644 --- a/source/source_lcao/module_deltaspin/test/test_deltaspin_state.cpp +++ b/source/source_lcao/module_deltaspin/test/test_deltaspin_state.cpp @@ -20,8 +20,8 @@ TEST(ScStateCalEsconTest, CalEsconSingleAtom) { ScState state; state.set_atomCounts({{0, 1}}); - state.lambda_.push_back(Vector3(1.0, 1.0, 1.0)); - state.Mi_.push_back(Vector3(1.0, 1.0, 1.0)); + state.get_lambda().push_back(Vector3(1.0, 1.0, 1.0)); + state.get_mi().push_back(Vector3(1.0, 1.0, 1.0)); EXPECT_DOUBLE_EQ(state.cal_escon(), -3.0); EXPECT_DOUBLE_EQ(state.get_escon(), -3.0); @@ -31,10 +31,10 @@ TEST(ScStateCalEsconTest, CalEsconMultiAtom) { ScState state; state.set_atomCounts({{0, 2}}); - state.lambda_.push_back(Vector3(1.0, 0.0, 0.0)); - state.lambda_.push_back(Vector3(0.0, 1.0, 0.0)); - state.Mi_.push_back(Vector3(2.0, 0.0, 0.0)); - state.Mi_.push_back(Vector3(0.0, 3.0, 0.0)); + state.get_lambda().push_back(Vector3(1.0, 0.0, 0.0)); + state.get_lambda().push_back(Vector3(0.0, 1.0, 0.0)); + state.get_mi().push_back(Vector3(2.0, 0.0, 0.0)); + state.get_mi().push_back(Vector3(0.0, 3.0, 0.0)); EXPECT_DOUBLE_EQ(state.cal_escon(), -5.0); EXPECT_DOUBLE_EQ(state.get_escon(), -5.0);