ok

Uses TDHF to include core-polarisation (RPA) corrections to matrix elements of an external field operator.

Solves the TDHF equations for each core orbital \( \phi_a \),

\[ (h_{\rm HF} - \en_a \mp \omega)\varphi^a_\pm = -(t_\pm + \delta V_\pm - \delta\en^a_\pm)\phi_a, \]

self-consistently to determine \( \delta V_\pm \). See the ExternalField namespace documentation for full physics description.

Each core orbital acquires both a forward ( \( \varphi^a_+ \), stored as X) and backward ( \( \varphi^a_- \), stored as Y) correction. Both contribute to \( \delta V_\pm \):

\[ \delta V_\pm \phi_i = \sum_a^{\rm core} \left[ \matel{\phi_a}{Q}{\varphi^a_+}\phi_i - \matel{\phi_a}{Q}{\phi_i}\varphi^a_+ + \matel{\varphi^a_-}{Q}{\phi_a}\phi_i - \matel{\varphi^a_-}{Q}{\phi_i}\phi_a \right]. \]

It is via \( \delta V_\pm \) that the \( e^{\pm i\omega t} \) terms are mixed.

Construction: Requires a pointer to an operator (h) and a const HF::HartreeFock object.

Usage: solve_core (omega) solves the TDHF equations for a given frequency. dV (Fa, Fb) then returns the RPA correction to the reduced matrix element \( \redmatel{a}{\delta V}{b} \).

Warning: Does not currently work for frequency-dependent operators unless they depend only on the magnitude \( |\omega| \). The method assumes \( t_- = t_+^\dag \), whereas the correct relation is \( t_-(\omega) = t_+^\dag(-\omega) \). This will be fixed in a future update.

#include <TDHF.hpp>

Inheritance diagram for ExternalField::TDHF:

Public Member Functions
	TDHF (const DiracOperator::TensorOperator const h, const HF::HartreeFock const hf)
	Constructs TDHF for operator h.

virtual void	solve_core (double omega, int max_its=100, bool print=true) override
	Solves TDHF equations self-consistently for core electrons at frequency omega.

virtual Method	method () const override
	Returns RPA method.

virtual void	clear () override final
	Clears the internal state back to pre solve_core()

double	dV (const DiracSpinor &Fa, const DiracSpinor &Fb, bool conj) const
	Returns reduced matrix element \(\redmatel{a}{\delta V}{b}\), or the conjugate \(\redmatel{a}{\delta V^\dagger}{b}\) if conj=true.

virtual double	dV (const DiracSpinor &Fa, const DiracSpinor &Fb) const override final
	Returns reduced matrix element <n\|\|dV_pm\|\|m> (see namespace doc for dV_pm)

DiracSpinor	dV_rhs (int kappa_n, const DiracSpinor &Fm, bool conj=false) const override
	Returns [dV_pm * phi_m]_kappa: RHS of TDHF eq., projected onto kappa (see namespace doc)

const std::vector< DiracSpinor > &	get_dPsis (const DiracSpinor &Fc, dPsiType XorY) const
	Returns const ref to dPsi orbitals for given core orbital Fc.

const DiracSpinor &	get_dPsi_x (const DiracSpinor &Fc, dPsiType XorY, const int kappa_x) const
	Returns const ref to dPsi orbital of given kappa.

DiracSpinor	solve_dPsi (const DiracSpinor &Fv, const double omega, dPsiType XorY, const int kappa_beta, const MBPT::CorrelationPotential *const Sigma=nullptr, StateType st=StateType::ket, bool incl_dV=true) const
	Forms \(\varphi^v_\pm\) for valence state Fv (including core pol.): single kappa channel.

std::vector< DiracSpinor >	solve_dPsis (const DiracSpinor &Fv, const double omega, dPsiType XorY, const MBPT::CorrelationPotential *const Sigma=nullptr, StateType st=StateType::ket, bool incl_dV=true) const
	Forms \(\varphi^v_\pm\) for all kappa channels; see solve_dPsi.

TDHF &	operator= (const TDHF &)=delete

	TDHF (const TDHF &)=default

Public Member Functions inherited from ExternalField::CorePolarisation
double	last_eps () const
	Returns eps (convergance) of last solve_core run.

double	last_its () const
	Returns its (# of iterations) of last solve_core run.

double	last_omega () const
	Returns omega (frequency) of last solve_core run.

int	rank () const
	Rank of the operator.

int	parity () const
	Parity of the operator.

bool	imagQ () const
	Returns true if the operator is imaginary.

double &	eps_target ()
	Convergance target.

double	eps_target () const
	Convergance target.

double	eta () const
	Damping factor; 0 means no damping. Must have 0 <= eta < 1.

void	set_eta (double eta)
	Set/update damping factor; 0 means no damping. Must have 0 <= eta < 1.

CorePolarisation &	operator= (const CorePolarisation &)=delete

	CorePolarisation (const CorePolarisation &)=default

Protected Attributes
std::vector< std::vector< DiracSpinor > >	m_X {}

std::vector< std::vector< DiracSpinor > >	m_Y {}

std::vector< std::vector< DiracSpinor > >	m_hFcore {}

const HF::HartreeFock *const	p_hf

const std::vector< DiracSpinor >	m_core

const double	m_alpha

const HF::Breit *const	p_VBr

Protected Attributes inherited from ExternalField::CorePolarisation
const DiracOperator::TensorOperator *	m_h

double	m_core_eps {1.0}

int	m_core_its {0}

double	m_core_omega {0.0}

int	m_rank

int	m_pi

bool	m_imag

double	m_eta {0.4}

double	m_eps {1.0e-10}

Additional Inherited Members
Protected Member Functions inherited from ExternalField::CorePolarisation
	CorePolarisation (const DiracOperator::TensorOperator *const h)

Constructor & Destructor Documentation

◆ TDHF()

ExternalField::TDHF::TDHF	(	const DiracOperator::TensorOperator *const	h,
		const HF::HartreeFock *const	hf
	)

Constructs TDHF for operator h.

Parameters

h	External field operator.
hf	HF::HartreeFock object defining the core.

Member Function Documentation

◆ solve_core()

void ExternalField::TDHF::solve_core	(	double	omega,
		int	max_its = `100`,
		bool	print = `true`
	)

overridevirtual

Solves TDHF equations self-consistently for core electrons at frequency omega.

Iterates the TDHF equations until \( \delta V_\pm \) converges to within eps_target(), or max_its iterations have been performed. Can be re-run at a different frequency without restarting from scratch.

Parameters

omega	External-field frequency \( \omega \) in atomic units.
max_its	Maximum number of iterations. Set to 1 to get the first-order correction (no damping on first iteration).
print	If true, write convergence progress to screen.

Note: Frequency should be positive; negative is allowed but use with care. Unlike DiagramRPA, TDHF solves for both \( \varphi^a_+ \) and \( \varphi^a_- \) simultaneously (see class docs), so a single call covers both contributions to \( \delta V_\pm \).

Note: Does not update the frequency of the operator itself; for frequency-dependent operators, update the operator frequency externally before calling.

Implements ExternalField::CorePolarisation.

Reimplemented in ExternalField::TDHFbasis.

◆ method()

virtual Method ExternalField::TDHF::method ( ) const

inlineoverridevirtual

Returns RPA method.

Implements ExternalField::CorePolarisation.

Reimplemented in ExternalField::TDHFbasis.

◆ clear()

void ExternalField::TDHF::clear ( )

finaloverridevirtual

Clears the internal state back to pre solve_core()

Implements ExternalField::CorePolarisation.

◆ dV() [1/2]

double ExternalField::TDHF::dV	(	const DiracSpinor &	Fa,
		const DiracSpinor &	Fb,
		bool	conj
	)		const

Returns reduced matrix element \(\redmatel{a}{\delta V}{b}\), or the conjugate \(\redmatel{a}{\delta V^\dagger}{b}\) if conj=true.

◆ dV() [2/2]

double ExternalField::TDHF::dV	(	const DiracSpinor &	Fn,
		const DiracSpinor &	Fm
	)		const

finaloverridevirtual

Returns reduced matrix element <n||dV_pm||m> (see namespace doc for dV_pm)

Implements ExternalField::CorePolarisation.

◆ dV_rhs()

DiracSpinor ExternalField::TDHF::dV_rhs	(	int	kappa,
		const DiracSpinor &	Fm,
		bool	conj = `false`
	)		const

overridevirtual

Returns [dV_pm * phi_m]_kappa: RHS of TDHF eq., projected onto kappa (see namespace doc)

Reimplemented from ExternalField::CorePolarisation.

◆ get_dPsis()

const std::vector< DiracSpinor > & ExternalField::TDHF::get_dPsis	(	const DiracSpinor &	Fc,
		dPsiType	XorY
	)		const

Returns const ref to dPsi orbitals for given core orbital Fc.

◆ get_dPsi_x()

const DiracSpinor & ExternalField::TDHF::get_dPsi_x	(	const DiracSpinor &	Fc,
		dPsiType	XorY,
		const int	kappa_x
	)		const

Returns const ref to dPsi orbital of given kappa.

◆ solve_dPsi()

DiracSpinor ExternalField::TDHF::solve_dPsi	(	const DiracSpinor &	Fv,
		const double	omega,
		dPsiType	XorY,
		const int	kappa_beta,
		const MBPT::CorrelationPotential *const	Sigma = `nullptr`,
		StateType	st = `StateType::ket`,
		bool	incl_dV = `true`
	)		const

Forms \(\varphi^v_\pm\) for valence state Fv (including core pol.): single kappa channel.

Solves

\[ (h_{\rm HF} + \Sigma - \en_v - \omega)\varphi^v_+ = -(t + \delta V - \delta\en^v)\phi_v \]

or

\[ (h_{\rm HF} + \Sigma - \en_v + \omega)\varphi^v_- = -(t^\dagger + \delta V^\dagger - \delta\en^v)\phi_v \]

Returns \( \chi_\beta \) for given kappa_beta, where

\[ X_{j,m} = (-1)^{j_\beta-m}tjs(j,k,j;-m,0,m)\chi_j \]

Parameters

Fv	Valence state \(\phi_v\).
omega	Perturbation frequency \(\omega\).
XorY	Selects X or Y solution; see dPsiType.
kappa_beta	Kappa quantum number of the target channel.
Sigma	Optional correlation potential; see MBPT::CorrelationPotential.
st	Bra or ket convention; see StateType.
incl_dV	Include the induced potential \(\delta V\) if true.

XXX Think this ^ shouldn't be here. Haven't checked though!

◆ solve_dPsis()

std::vector< DiracSpinor > ExternalField::TDHF::solve_dPsis	(	const DiracSpinor &	Fv,
		const double	omega,
		dPsiType	XorY,
		const MBPT::CorrelationPotential *const	Sigma = `nullptr`,
		StateType	st = `StateType::ket`,
		bool	incl_dV = `true`
	)		const

Forms \(\varphi^v_\pm\) for all kappa channels; see solve_dPsi.

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

ExternalField/TDHF.hpp
ExternalField/TDHF.cpp

ok

Public Member Functions

Protected Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ TDHF()

Member Function Documentation

◆ solve_core()

◆ method()

◆ clear()

◆ dV() [1/2]

◆ dV() [2/2]

◆ dV_rhs()

◆ get_dPsis()

◆ get_dPsi_x()

◆ solve_dPsi()

◆ solve_dPsis()