#include <spin_constrain.h>

Collaboration diagram for spinconstrain::SpinConstrain< FPTYPE >:

Public Member Functions
void	init_sc (double sc_thr_in, int nsc_in, int nsc_min_in, double alpha_trial_in, double sccut_in, double sc_drop_thr_in, const UnitCell &ucell, Parallel_Orbitals ParaV_in, int nspin_in, K_Vectors &kv_in, void p_hamilt_in, void psi_in, elecstate::ElecState pelec_in, ModulePW::PW_Basis_K *pw_wfc_in=nullptr)
	initialize spin-constrained DFT

void	cal_mi_lcao (const int &step, bool print=false)
	calculate the magnetization of each atom with real space projection method for LCAO base

void	cal_mi_pw ()

void	cal_mw_from_lambda (int i_step, const ModuleBase::Vector3< double > *delta_lambda=nullptr)

double	cal_escon ()
	calculate the energy of \sum_i \lambda_i * Mi if this->is_mag_converged is true, then this function will calculate the energy and return the real value if this->is_mag_converged is false, then this function will return 0.0

double	get_escon ()

void	run_lambda_loop (int outer_step, bool rerun=true)

void	update_psi_charge (const ModuleBase::Vector3< double > *delta_lambda, bool pw_solve=true)
	update the charge density for LCAO base with new lambda update the charge density and psi for PW base with new lambda

void	calculate_delta_hcc (std::complex< double > h_tmp, const std::complex< double > becp_k, const ModuleBase::Vector3< double > delta_lambda, const int nbands, const int nkb, const int nh_iat)

bool	check_rms_stop (int outer_step, int i_step, double rms_error, double duration, double total_duration)
	lambda loop helper functions

void	check_restriction (const std::vector< ModuleBase::Vector3< double > > &search, double &alpha_trial)
	apply restriction

bool	check_gradient_decay (std::vector< ModuleBase::Vector3< double > > new_spin, std::vector< ModuleBase::Vector3< double > > old_spin, std::vector< ModuleBase::Vector3< double > > new_delta_lambda, std::vector< ModuleBase::Vector3< double > > old_delta_lambda, bool print=false)
	check gradient decay

double	cal_alpha_opt (std::vector< ModuleBase::Vector3< double > > spin, std::vector< ModuleBase::Vector3< double > > spin_plus, const double alpha_trial)
	calculate alpha_opt

void	print_header ()
	print header info

void	print_termination ()
	print termination message

void	print_Mi (std::ofstream &ofs_running)
	print mi

void	print_Mag_Force (std::ofstream &ofs_running)
	print magnetic force, defined as \frac{\delta{L}}/{\delta{Mi}} = -lambda[iat])

	SpinConstrain (SpinConstrain const &)=delete
	Delete copy and move constructors and assign operators.

	SpinConstrain (SpinConstrain &&)=delete

void	set_atomCounts (const std::map< int, int > &atomCounts_in)
	set element index to atom index map

const std::map< int, int > &	get_atomCounts () const
	get element index to atom index map

void	set_orbitalCounts (const std::map< int, int > &orbitalCounts_in)
	set element index to orbital index map

const std::map< int, int > &	get_orbitalCounts () const
	get element index to orbital index map

void	set_lnchiCounts (const std::map< int, std::map< int, int > > &lnchiCounts_in)
	set lnchiCounts

const std::map< int, std::map< int, int > > &	get_lnchiCounts () const
	get lnchiCounts

void	set_sc_lambda ()
	set sc_lambda

void	set_sc_lambda (const ModuleBase::Vector3< double > *lambda_in, int nat_in)
	set sc_lambda from variable

void	set_target_mag ()
	set target_mag

void	set_target_mag (const ModuleBase::Vector3< double > *target_mag_in, int nat_in)
	set target_mag from variable

void	set_target_mag (const std::vector< ModuleBase::Vector3< double > > &target_mag_in)
	set target magnetic moment

void	set_constrain ()
	set constrain

void	set_constrain (const ModuleBase::Vector3< int > *constrain_in, int nat_in)
	set constrain from variable

const std::vector< ModuleBase::Vector3< double > > &	get_sc_lambda () const
	get sc_lambda

const std::vector< ModuleBase::Vector3< double > > &	get_target_mag () const
	get target_mag

const std::vector< ModuleBase::Vector3< int > > &	get_constrain () const
	get constrain

int	get_nat ()
	get nat

int	get_ntype ()
	get ntype

void	check_atomCounts ()
	check atomCounts

int	get_iat (int itype, int atom_index)
	get iat

void	set_nspin (int nspin)
	set nspin

int	get_nspin ()
	get nspin

void	zero_Mi ()
	zero atomic magnetic moment

double	get_decay_grad (int itype)
	get decay_grad

void	set_decay_grad ()
	set decay_grad

const std::vector< double > &	get_decay_grad ()
	get decay_grad

void	set_decay_grad (const double *decay_grad_in, int ntype_in)
	set decay_grad from variable

void	set_sc_drop_thr (double sc_drop_thr_in)
	set decay grad switch

void	set_input_parameters (double sc_thr_in, int nsc_in, int nsc_min_in, double alpha_trial_in, double sccut_in, double sc_drop_thr_in)
	set input parameters

double	get_sc_thr ()
	get sc_thr

int	get_nsc ()
	get nsc

int	get_nsc_min ()
	get nsc_min

double	get_alpha_trial ()
	get alpha_trial

double	get_sccut ()
	get sccut

double	get_sc_drop_thr ()
	get sc_drop_thr

void	set_ParaV (Parallel_Orbitals *ParaV_in)
	set orbital parallel info

void	set_solver_parameters (K_Vectors &kv_in, void p_hamilt_in, void psi_in, elecstate::ElecState *pelec_in)
	set parameters for solver

void	set_operator (hamilt::Operator< FPTYPE > *op_in)
	save operator for spin-constrained DFT

void	set_mag_converged (bool is_Mi_converged_in)
	set is_Mi_converged

bool	mag_converged () const
	get is_Mi_converged

void	cal_mi_pw ()

void	set_operator (hamilt::Operator< std::complex< double > > *op_in)

void	set_operator (hamilt::Operator< double > *op_in)

void	calculate_delta_hcc (std::complex< double > h_tmp, const std::complex< double > becp_k, const ModuleBase::Vector3< double > delta_lambda, const int nbands, const int nkb, const int nh_iat)

void	cal_mw_from_lambda (int i_step, const ModuleBase::Vector3< double > *delta_lambda)

void	update_psi_charge (const ModuleBase::Vector3< double > *delta_lambda, bool pw_solve)

void	run_lambda_loop (int outer_step, bool rerun)

void	print_termination ()

bool	check_rms_stop (int outer_step, int i_step, double rms_error, double duration, double total_duration)

void	print_header ()
	print header

void	check_restriction (const std::vector< ModuleBase::Vector3< double > > &search, double &alpha_trial)
	check restriction

double	cal_alpha_opt (std::vector< ModuleBase::Vector3< double > > spin, std::vector< ModuleBase::Vector3< double > > spin_plus, const double alpha_trial)
	calculate alpha_opt

bool	check_gradient_decay (std::vector< ModuleBase::Vector3< double > > new_spin, std::vector< ModuleBase::Vector3< double > > spin, std::vector< ModuleBase::Vector3< double > > delta_lambda, std::vector< ModuleBase::Vector3< double > > dnu_last_step, bool print)
	check gradient decay

void	cal_mw_from_lambda (int i_step, const ModuleBase::Vector3< double > *delta_lambda)

void	cal_mi_lcao (const int &step, bool print)

void	run_lambda_loop (int outer_step, bool rerun)

bool	check_rms_stop (int outer_step, int i_step, double rms_error, double duration, double total_duration)

void	check_restriction (const std::vector< ModuleBase::Vector3< double > > &search, double &alpha_trial)

double	cal_alpha_opt (std::vector< ModuleBase::Vector3< double > > spin, std::vector< ModuleBase::Vector3< double > > spin_plus, const double alpha_trial)
	calculate alpha_opt

void	print_termination ()

void	print_header ()

bool	check_gradient_decay (std::vector< ModuleBase::Vector3< double > > new_spin, std::vector< ModuleBase::Vector3< double > > old_spin, std::vector< ModuleBase::Vector3< double > > new_delta_lambda, std::vector< ModuleBase::Vector3< double > > old_delta_lambda, bool print)

Static Public Member Functions
static SpinConstrain &	getScInstance ()
	Public method to access the Singleton instance.

Public Attributes
bool	higher_mag_prec = false
	use rerun to get higher precision in lambda_loop for PW base

Parallel_Orbitals *	ParaV = nullptr

void *	p_hamilt = nullptr

void *	psi = nullptr

elecstate::ElecState *	pelec = nullptr

ModulePW::PW_Basis_K *	pw_wfc_ = nullptr

double	tpiba = 0.0

const double	meV_to_Ry = 7.349864435130999e-05
	save ucell.tpiba

K_Vectors	kv_

Private Member Functions
	SpinConstrain ()

	~SpinConstrain ()

SpinConstrain &	operator= (SpinConstrain const &)=delete

SpinConstrain &	operator= (SpinConstrain &&)=delete

Private Attributes
std::map< int, std::vector< ScAtomData > >	ScData

std::map< int, double >	ScDecayGrad

std::vector< double >	decay_grad_

std::map< int, int >	atomCounts

std::map< int, int >	orbitalCounts

std::map< int, std::map< int, int > >	lnchiCounts

std::vector< ModuleBase::Vector3< double > >	lambda_

std::vector< ModuleBase::Vector3< double > >	target_mag_

std::vector< ModuleBase::Vector3< double > >	Mi_

std::vector< std::string >	atomLabels_

double	escon_ = 0.0

int	nspin_ = 0

int	npol_ = 1

int	nsc_

int	nsc_min_

double	sc_drop_thr_ = 1e-3

double	sc_thr_

double	current_sc_thr_

std::vector< ModuleBase::Vector3< int > >	constrain_

bool	debug = false

double	alpha_trial_

double	restrict_current_

hamilt::Operator< FPTYPE > *	p_operator = nullptr
	operator for spin-constrained DFT, used for calculating current atomic magnetic moment

bool	is_Mi_converged = false
	if atomic magnetic moment is converged

FPTYPE *	sub_h_save

FPTYPE *	sub_s_save

FPTYPE *	becp_save

Constructor & Destructor Documentation

◆ SpinConstrain() [1/3]

template<typename FPTYPE >

spinconstrain::SpinConstrain< FPTYPE >::SpinConstrain ( SpinConstrain< FPTYPE > const & )

delete

Delete copy and move constructors and assign operators.

◆ SpinConstrain() [2/3]

template<typename FPTYPE >

spinconstrain::SpinConstrain< FPTYPE >::SpinConstrain ( SpinConstrain< FPTYPE > && )

delete

◆ SpinConstrain() [3/3]

template<typename FPTYPE >

spinconstrain::SpinConstrain< FPTYPE >::SpinConstrain ( )

inlineprivate

◆ ~SpinConstrain()

template<typename FPTYPE >

spinconstrain::SpinConstrain< FPTYPE >::~SpinConstrain ( )

inlineprivate

Member Function Documentation

◆ cal_alpha_opt() [1/3]

double spinconstrain::SpinConstrain< std::complex< double > >::cal_alpha_opt	(	std::vector< ModuleBase::Vector3< double > >	spin,
		std::vector< ModuleBase::Vector3< double > >	spin_plus,
		const double	alpha_trial
	)

calculate alpha_opt

Here is the call graph for this function:

◆ cal_alpha_opt() [2/3]

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::cal_alpha_opt	(	std::vector< ModuleBase::Vector3< double > >	spin,
		std::vector< ModuleBase::Vector3< double > >	spin_plus,
		const double	alpha_trial
	)

calculate alpha_opt

◆ cal_alpha_opt() [3/3]

double spinconstrain::SpinConstrain< double >::cal_alpha_opt	(	std::vector< ModuleBase::Vector3< double > >	spin,
		std::vector< ModuleBase::Vector3< double > >	spin_plus,
		const double	alpha_trial
	)

calculate alpha_opt

◆ cal_escon()

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::cal_escon ( )

calculate the energy of \sum_i \lambda_i * Mi if this->is_mag_converged is true, then this function will calculate the energy and return the real value if this->is_mag_converged is false, then this function will return 0.0

Here is the caller graph for this function:

◆ cal_mi_lcao() [1/2]

void spinconstrain::SpinConstrain< double >::cal_mi_lcao	(	const int &	step,
		bool	print
	)

◆ cal_mi_lcao() [2/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::cal_mi_lcao	(	const int &	step,
		bool	print = `false`
	)

calculate the magnetization of each atom with real space projection method for LCAO base

Parameters

step	: the step number of the SCF calculation
print	: print the magnetization of each atom if true

Here is the caller graph for this function:

◆ cal_mi_pw() [1/2]

void spinconstrain::SpinConstrain< std::complex< double > >::cal_mi_pw ( )

Here is the call graph for this function:

◆ cal_mi_pw() [2/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::cal_mi_pw ( )

Here is the caller graph for this function:

◆ cal_mw_from_lambda() [1/3]

void spinconstrain::SpinConstrain< std::complex< double > >::cal_mw_from_lambda	(	int	i_step,
		const ModuleBase::Vector3< double > *	delta_lambda
	)

update H(k) for each k point

Here is the call graph for this function:

◆ cal_mw_from_lambda() [2/3]

void spinconstrain::SpinConstrain< double >::cal_mw_from_lambda	(	int	i_step,
		const ModuleBase::Vector3< double > *	delta_lambda
	)

◆ cal_mw_from_lambda() [3/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::cal_mw_from_lambda	(	int	i_step,
		const ModuleBase::Vector3< double > *	delta_lambda = `nullptr`
	)

◆ calculate_delta_hcc() [1/2]

void spinconstrain::SpinConstrain< std::complex< double > >::calculate_delta_hcc	(	std::complex< double > *	h_tmp,
		const std::complex< double > *	becp_k,
		const ModuleBase::Vector3< double > *	delta_lambda,
		const int	nbands,
		const int	nkb,
		const int *	nh_iat
	)

Here is the call graph for this function:

◆ calculate_delta_hcc() [2/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::calculate_delta_hcc	(	std::complex< double > *	h_tmp,
		const std::complex< double > *	becp_k,
		const ModuleBase::Vector3< double > *	delta_lambda,
		const int	nbands,
		const int	nkb,
		const int *	nh_iat
	)

◆ check_atomCounts()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::check_atomCounts ( )

check atomCounts

◆ check_gradient_decay() [1/3]

bool spinconstrain::SpinConstrain< double >::check_gradient_decay	(	std::vector< ModuleBase::Vector3< double > >	new_spin,
		std::vector< ModuleBase::Vector3< double > >	old_spin,
		std::vector< ModuleBase::Vector3< double > >	new_delta_lambda,
		std::vector< ModuleBase::Vector3< double > >	old_delta_lambda,
		bool	print
	)

◆ check_gradient_decay() [2/3]

template<typename FPTYPE >

bool spinconstrain::SpinConstrain< FPTYPE >::check_gradient_decay	(	std::vector< ModuleBase::Vector3< double > >	new_spin,
		std::vector< ModuleBase::Vector3< double > >	old_spin,
		std::vector< ModuleBase::Vector3< double > >	new_delta_lambda,
		std::vector< ModuleBase::Vector3< double > >	old_delta_lambda,
		bool	print = `false`
	)

check gradient decay

◆ check_gradient_decay() [3/3]

bool spinconstrain::SpinConstrain< std::complex< double > >::check_gradient_decay	(	std::vector< ModuleBase::Vector3< double > >	new_spin,
		std::vector< ModuleBase::Vector3< double > >	spin,
		std::vector< ModuleBase::Vector3< double > >	delta_lambda,
		std::vector< ModuleBase::Vector3< double > >	dnu_last_step,
		bool	print
	)

check gradient decay

Here is the call graph for this function:

◆ check_restriction() [1/3]

void spinconstrain::SpinConstrain< std::complex< double > >::check_restriction	(	const std::vector< ModuleBase::Vector3< double > > &	search,
		double &	alpha_trial
	)

check restriction

Here is the call graph for this function:

◆ check_restriction() [2/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::check_restriction	(	const std::vector< ModuleBase::Vector3< double > > &	search,
		double &	alpha_trial
	)

apply restriction

◆ check_restriction() [3/3]

void spinconstrain::SpinConstrain< double >::check_restriction	(	const std::vector< ModuleBase::Vector3< double > > &	search,
		double &	alpha_trial
	)

◆ check_rms_stop() [1/3]

bool spinconstrain::SpinConstrain< std::complex< double > >::check_rms_stop	(	int	outer_step,
		int	i_step,
		double	rms_error,
		double	duration,
		double	total_duration
	)

◆ check_rms_stop() [2/3]

template<typename FPTYPE >

bool spinconstrain::SpinConstrain< FPTYPE >::check_rms_stop	(	int	outer_step,
		int	i_step,
		double	rms_error,
		double	duration,
		double	total_duration
	)

lambda loop helper functions

◆ check_rms_stop() [3/3]

bool spinconstrain::SpinConstrain< double >::check_rms_stop	(	int	outer_step,
		int	i_step,
		double	rms_error,
		double	duration,
		double	total_duration
	)

◆ get_alpha_trial()

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::get_alpha_trial ( )

get alpha_trial

◆ get_atomCounts()

template<typename FPTYPE >

const std::map< int, int > & spinconstrain::SpinConstrain< FPTYPE >::get_atomCounts ( ) const

get element index to atom index map

◆ get_constrain()

template<typename FPTYPE >

const std::vector< ModuleBase::Vector3< int > > & spinconstrain::SpinConstrain< FPTYPE >::get_constrain ( ) const

get constrain

get_constrain

Here is the caller graph for this function:

◆ get_decay_grad() [1/2]

template<typename FPTYPE >

const std::vector< double > & spinconstrain::SpinConstrain< FPTYPE >::get_decay_grad ( )

get decay_grad

◆ get_decay_grad() [2/2]

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::get_decay_grad ( int itype )

get decay_grad

get grad_decay this function can only be called by the root process because only root process reads the ScDecayGrad from json file

◆ get_escon()

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::get_escon ( )

◆ get_iat()

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::get_iat	(	int	itype,
		int	atom_index
	)

get iat

◆ get_lnchiCounts()

template<typename FPTYPE >

const std::map< int, std::map< int, int > > & spinconstrain::SpinConstrain< FPTYPE >::get_lnchiCounts ( ) const

get lnchiCounts

◆ get_nat()

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::get_nat ( )

get nat

◆ get_nsc()

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::get_nsc ( )

get nsc

◆ get_nsc_min()

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::get_nsc_min ( )

get nsc_min

◆ get_nspin()

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::get_nspin ( )

get nspin

◆ get_ntype()

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::get_ntype ( )

get ntype

◆ get_orbitalCounts()

template<typename FPTYPE >

const std::map< int, int > & spinconstrain::SpinConstrain< FPTYPE >::get_orbitalCounts ( ) const

get element index to orbital index map

◆ get_sc_drop_thr()

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::get_sc_drop_thr ( )

get sc_drop_thr

◆ get_sc_lambda()

template<typename FPTYPE >

const std::vector< ModuleBase::Vector3< double > > & spinconstrain::SpinConstrain< FPTYPE >::get_sc_lambda ( ) const

get sc_lambda

Here is the caller graph for this function:

◆ get_sc_thr()

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::get_sc_thr ( )

get sc_thr

◆ get_sccut()

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::get_sccut ( )

get sccut

◆ get_target_mag()

template<typename FPTYPE >

const std::vector< ModuleBase::Vector3< double > > & spinconstrain::SpinConstrain< FPTYPE >::get_target_mag ( ) const

get target_mag

◆ getScInstance()

template<typename FPTYPE >

SpinConstrain< FPTYPE > & spinconstrain::SpinConstrain< FPTYPE >::getScInstance ( )

static

Public method to access the Singleton instance.

pubic methods for setting and getting spin-constrained DFT parameters

Here is the caller graph for this function:

◆ init_sc()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::init_sc	(	double	sc_thr_in,
		int	nsc_in,
		int	nsc_min_in,
		double	alpha_trial_in,
		double	sccut_in,
		double	sc_drop_thr_in,
		const UnitCell &	ucell,
		Parallel_Orbitals *	ParaV_in,
		int	nspin_in,
		K_Vectors &	kv_in,
		void *	p_hamilt_in,
		void *	psi_in,
		elecstate::ElecState *	pelec_in,
		ModulePW::PW_Basis_K *	pw_wfc_in = `nullptr`
	)

initialize spin-constrained DFT

pubic interface for spin-constrained DFT

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mag_converged()

template<typename FPTYPE >

bool spinconstrain::SpinConstrain< FPTYPE >::mag_converged ( ) const

inline

get is_Mi_converged

Here is the caller graph for this function:

◆ operator=() [1/2]

template<typename FPTYPE >

SpinConstrain & spinconstrain::SpinConstrain< FPTYPE >::operator= ( SpinConstrain< FPTYPE > && )

privatedelete

◆ operator=() [2/2]

template<typename FPTYPE >

SpinConstrain & spinconstrain::SpinConstrain< FPTYPE >::operator= ( SpinConstrain< FPTYPE > const & )

privatedelete

◆ print_header() [1/3]

void spinconstrain::SpinConstrain< std::complex< double > >::print_header ( )

print header

◆ print_header() [2/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::print_header ( )

print header info

◆ print_header() [3/3]

void spinconstrain::SpinConstrain< double >::print_header ( )

◆ print_Mag_Force()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::print_Mag_Force ( std::ofstream & ofs_running )

print magnetic force, defined as \frac{\delta{L}}/{\delta{Mi}} = -lambda[iat])

print magnetic force (defined as \frac{\delta{L}}/{\delta{Mi}} = -lambda[iat])

Here is the caller graph for this function:

◆ print_Mi()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::print_Mi ( std::ofstream & ofs_running )

print mi

print Mi

Here is the caller graph for this function:

◆ print_termination() [1/3]

void spinconstrain::SpinConstrain< std::complex< double > >::print_termination ( )

Here is the call graph for this function:

◆ print_termination() [2/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::print_termination ( )

print termination message

◆ print_termination() [3/3]

void spinconstrain::SpinConstrain< double >::print_termination ( )

◆ run_lambda_loop() [1/3]

void spinconstrain::SpinConstrain< std::complex< double > >::run_lambda_loop	(	int	outer_step,
		bool	rerun
	)

check if restriction is needed

Here is the call graph for this function:

◆ run_lambda_loop() [2/3]

void spinconstrain::SpinConstrain< double >::run_lambda_loop	(	int	outer_step,
		bool	rerun
	)

◆ run_lambda_loop() [3/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::run_lambda_loop	(	int	outer_step,
		bool	rerun = `true`
	)

Here is the caller graph for this function:

◆ set_atomCounts()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_atomCounts ( const std::map< int, int > & atomCounts_in )

set element index to atom index map

◆ set_constrain() [1/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_constrain ( )

set constrain

◆ set_constrain() [2/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_constrain	(	const ModuleBase::Vector3< int > *	constrain_in,
		int	nat_in
	)

set constrain from variable

Here is the call graph for this function:

◆ set_decay_grad() [1/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_decay_grad ( )

set decay_grad

set grad_decy

◆ set_decay_grad() [2/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_decay_grad	(	const double *	decay_grad_in,
		int	ntype_in
	)

set decay_grad from variable

set grad_decy from variable

Here is the call graph for this function:

◆ set_input_parameters()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_input_parameters	(	double	sc_thr_in,
		int	nsc_in,
		int	nsc_min_in,
		double	alpha_trial_in,
		double	sccut_in,
		double	sc_drop_thr_in
	)

set input parameters

◆ set_lnchiCounts()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_lnchiCounts ( const std::map< int, std::map< int, int > > & lnchiCounts_in )

set lnchiCounts

◆ set_mag_converged()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_mag_converged ( bool is_Mi_converged_in )

inline

set is_Mi_converged

Here is the caller graph for this function:

◆ set_nspin()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_nspin ( int nspin )

set nspin

◆ set_operator() [1/3]

void spinconstrain::SpinConstrain< double >::set_operator ( hamilt::Operator< double > * op_in )

◆ set_operator() [2/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_operator ( hamilt::Operator< FPTYPE > * op_in )

save operator for spin-constrained DFT

Parameters

op_in the base pointer of operator, actual type should be DeltaSpin<OperatorLCAO<TK, TR>>*

Here is the caller graph for this function:

◆ set_operator() [3/3]

void spinconstrain::SpinConstrain< std::complex< double > >::set_operator ( hamilt::Operator< std::complex< double > > * op_in )

◆ set_orbitalCounts()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_orbitalCounts ( const std::map< int, int > & orbitalCounts_in )

set element index to orbital index map

◆ set_ParaV()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_ParaV ( Parallel_Orbitals * ParaV_in )

set orbital parallel info

set ParaV

Here is the call graph for this function:

◆ set_sc_drop_thr()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_sc_drop_thr ( double sc_drop_thr_in )

set decay grad switch

set sc_drop_thr

◆ set_sc_lambda() [1/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_sc_lambda ( )

set sc_lambda

◆ set_sc_lambda() [2/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_sc_lambda	(	const ModuleBase::Vector3< double > *	lambda_in,
		int	nat_in
	)

set sc_lambda from variable

Here is the call graph for this function:

◆ set_solver_parameters()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_solver_parameters	(	K_Vectors &	kv_in,
		void *	p_hamilt_in,
		void *	psi_in,
		elecstate::ElecState *	pelec_in
	)

set parameters for solver

◆ set_target_mag() [1/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_target_mag ( )

set target_mag

◆ set_target_mag() [2/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_target_mag	(	const ModuleBase::Vector3< double > *	target_mag_in,
		int	nat_in
	)

set target_mag from variable

Here is the call graph for this function:

◆ set_target_mag() [3/3]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::set_target_mag ( const std::vector< ModuleBase::Vector3< double > > & target_mag_in )

set target magnetic moment

this is wired because the UnitCell class set in x direction

Here is the call graph for this function:

◆ update_psi_charge() [1/2]

void spinconstrain::SpinConstrain< std::complex< double > >::update_psi_charge	(	const ModuleBase::Vector3< double > *	delta_lambda,
		bool	pw_solve
	)

Here is the call graph for this function:

◆ update_psi_charge() [2/2]

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::update_psi_charge	(	const ModuleBase::Vector3< double > *	delta_lambda,
		bool	pw_solve = `true`
	)

update the charge density for LCAO base with new lambda update the charge density and psi for PW base with new lambda

◆ zero_Mi()

template<typename FPTYPE >

void spinconstrain::SpinConstrain< FPTYPE >::zero_Mi ( )

zero atomic magnetic moment

Member Data Documentation

◆ alpha_trial_

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::alpha_trial_

private

◆ atomCounts

template<typename FPTYPE >

std::map<int, int> spinconstrain::SpinConstrain< FPTYPE >::atomCounts

private

◆ atomLabels_

template<typename FPTYPE >

std::vector<std::string> spinconstrain::SpinConstrain< FPTYPE >::atomLabels_

private

◆ becp_save

template<typename FPTYPE >

FPTYPE* spinconstrain::SpinConstrain< FPTYPE >::becp_save

private

◆ constrain_

template<typename FPTYPE >

std::vector<ModuleBase::Vector3<int> > spinconstrain::SpinConstrain< FPTYPE >::constrain_

private

◆ current_sc_thr_

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::current_sc_thr_

private

◆ debug

template<typename FPTYPE >

bool spinconstrain::SpinConstrain< FPTYPE >::debug = false

private

◆ decay_grad_

template<typename FPTYPE >

std::vector<double> spinconstrain::SpinConstrain< FPTYPE >::decay_grad_

private

◆ escon_

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::escon_ = 0.0

private

◆ higher_mag_prec

template<typename FPTYPE >

bool spinconstrain::SpinConstrain< FPTYPE >::higher_mag_prec = false

use rerun to get higher precision in lambda_loop for PW base

◆ is_Mi_converged

template<typename FPTYPE >

bool spinconstrain::SpinConstrain< FPTYPE >::is_Mi_converged = false

private

if atomic magnetic moment is converged

◆ kv_

template<typename FPTYPE >

K_Vectors spinconstrain::SpinConstrain< FPTYPE >::kv_

◆ lambda_

template<typename FPTYPE >

std::vector<ModuleBase::Vector3<double> > spinconstrain::SpinConstrain< FPTYPE >::lambda_

private

◆ lnchiCounts

template<typename FPTYPE >

std::map<int, std::map<int, int> > spinconstrain::SpinConstrain< FPTYPE >::lnchiCounts

private

◆ meV_to_Ry

template<typename FPTYPE >

const double spinconstrain::SpinConstrain< FPTYPE >::meV_to_Ry = 7.349864435130999e-05

save ucell.tpiba

◆ Mi_

template<typename FPTYPE >

std::vector<ModuleBase::Vector3<double> > spinconstrain::SpinConstrain< FPTYPE >::Mi_

private

◆ npol_

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::npol_ = 1

private

◆ nsc_

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::nsc_

private

input parameters for lambda-loop

◆ nsc_min_

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::nsc_min_

private

◆ nspin_

template<typename FPTYPE >

int spinconstrain::SpinConstrain< FPTYPE >::nspin_ = 0

private

◆ orbitalCounts

template<typename FPTYPE >

std::map<int, int> spinconstrain::SpinConstrain< FPTYPE >::orbitalCounts

private

◆ p_hamilt

template<typename FPTYPE >

void* spinconstrain::SpinConstrain< FPTYPE >::p_hamilt = nullptr

◆ p_operator

template<typename FPTYPE >

hamilt::Operator<FPTYPE>* spinconstrain::SpinConstrain< FPTYPE >::p_operator = nullptr

private

operator for spin-constrained DFT, used for calculating current atomic magnetic moment

◆ ParaV

template<typename FPTYPE >

Parallel_Orbitals* spinconstrain::SpinConstrain< FPTYPE >::ParaV = nullptr

important outter class pointers used in spin-constrained DFT

◆ pelec

template<typename FPTYPE >

elecstate::ElecState* spinconstrain::SpinConstrain< FPTYPE >::pelec = nullptr

◆ psi

template<typename FPTYPE >

void* spinconstrain::SpinConstrain< FPTYPE >::psi = nullptr

◆ pw_wfc_

template<typename FPTYPE >

ModulePW::PW_Basis_K* spinconstrain::SpinConstrain< FPTYPE >::pw_wfc_ = nullptr

◆ restrict_current_

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::restrict_current_

private

◆ sc_drop_thr_

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::sc_drop_thr_ = 1e-3

private

◆ sc_thr_

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::sc_thr_

private

◆ ScData

template<typename FPTYPE >

std::map<int, std::vector<ScAtomData> > spinconstrain::SpinConstrain< FPTYPE >::ScData

private

◆ ScDecayGrad

template<typename FPTYPE >

std::map<int, double> spinconstrain::SpinConstrain< FPTYPE >::ScDecayGrad

private

◆ sub_h_save

template<typename FPTYPE >

FPTYPE* spinconstrain::SpinConstrain< FPTYPE >::sub_h_save

private

◆ sub_s_save

template<typename FPTYPE >

FPTYPE* spinconstrain::SpinConstrain< FPTYPE >::sub_s_save

private

◆ target_mag_

template<typename FPTYPE >

std::vector<ModuleBase::Vector3<double> > spinconstrain::SpinConstrain< FPTYPE >::target_mag_

private

◆ tpiba

template<typename FPTYPE >

double spinconstrain::SpinConstrain< FPTYPE >::tpiba = 0.0

The documentation for this class was generated from the following files:

/home/runner/work/abacus-develop/abacus-develop/source/source_lcao/module_deltaspin/spin_constrain.h
/home/runner/work/abacus-develop/abacus-develop/source/source_lcao/module_deltaspin/init_sc.cpp
/home/runner/work/abacus-develop/abacus-develop/source/source_lcao/module_deltaspin/spin_constrain.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ SpinConstrain() [1/3]

◆ SpinConstrain() [2/3]

◆ SpinConstrain() [3/3]

◆ ~SpinConstrain()

Member Function Documentation

◆ cal_alpha_opt() [1/3]

◆ cal_alpha_opt() [2/3]

◆ cal_alpha_opt() [3/3]

◆ cal_escon()

◆ cal_mi_lcao() [1/2]

◆ cal_mi_lcao() [2/2]

◆ cal_mi_pw() [1/2]

◆ cal_mi_pw() [2/2]

◆ cal_mw_from_lambda() [1/3]

◆ cal_mw_from_lambda() [2/3]

◆ cal_mw_from_lambda() [3/3]

◆ calculate_delta_hcc() [1/2]

◆ calculate_delta_hcc() [2/2]

◆ check_atomCounts()

◆ check_gradient_decay() [1/3]

◆ check_gradient_decay() [2/3]

◆ check_gradient_decay() [3/3]

◆ check_restriction() [1/3]

◆ check_restriction() [2/3]

◆ check_restriction() [3/3]

◆ check_rms_stop() [1/3]

◆ check_rms_stop() [2/3]

◆ check_rms_stop() [3/3]

◆ get_alpha_trial()

◆ get_atomCounts()

◆ get_constrain()

◆ get_decay_grad() [1/2]

◆ get_decay_grad() [2/2]

◆ get_escon()

◆ get_iat()

◆ get_lnchiCounts()

◆ get_nat()

◆ get_nsc()

◆ get_nsc_min()

◆ get_nspin()

◆ get_ntype()

◆ get_orbitalCounts()

◆ get_sc_drop_thr()

◆ get_sc_lambda()

◆ get_sc_thr()

◆ get_sccut()

◆ get_target_mag()

◆ getScInstance()

◆ init_sc()

◆ mag_converged()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ print_header() [1/3]

◆ print_header() [2/3]

◆ print_header() [3/3]

◆ print_Mag_Force()

◆ print_Mi()

◆ print_termination() [1/3]

◆ print_termination() [2/3]

◆ print_termination() [3/3]

◆ run_lambda_loop() [1/3]

◆ run_lambda_loop() [2/3]

◆ run_lambda_loop() [3/3]

◆ set_atomCounts()

◆ set_constrain() [1/2]

◆ set_constrain() [2/2]

◆ set_decay_grad() [1/2]

◆ set_decay_grad() [2/2]

◆ set_input_parameters()

◆ set_lnchiCounts()

◆ set_mag_converged()

◆ set_nspin()

◆ set_operator() [1/3]

◆ set_operator() [2/3]