ExternalField::DiagramRPA

ok

RPA correction to matrix elements, using Diagram technique.

The basic equation is:

\[ \langle{w}|{\delta V_{\pm}}|{v}\rangle = \sum_{na}\frac{t_{na}\,\widetilde g_{wavn}}{\varepsilon_a - \varepsilon_n \pm \omega} + \sum_{na}\frac{t_{an}\,\widetilde g_{wnva}}{\varepsilon_a - \varepsilon_n \mp \omega}, \]

These should be solved self-consistently for all core-excited matrix elements. Should be solved independently for each frequency, including negative frequencies. To maintain Hermicity:

\[ [\delta V_{\pm}(\omega)]^\dag = \delta V_{\mp}(-\omega). \]

The reduced matrix elements are:

\[ \langle{w}\|{\delta V_{\pm}}\|{v}\rangle = \sum_{na}\frac{(-1)^{k+w-n}}{[k]}\Bigg( \frac{T_{na}\,W^k_{wavn}}{\varepsilon_a - \varepsilon_n \pm \omega} + \frac{(-1)^{a-n}T_{an}\,W^k_{wnva}}{\varepsilon_a - \varepsilon_n \mp \omega} \Bigg). \]

Note

Stores a pointer to the external field operator. That operator must remain alive for life of DiagramRPA object. Also, for frequency-dependent operators, updating the frequency of the operator externally will affect the results from this class (as it should). The DiagramRPA::solve_core() function should be re called if the external operator is updated.

Stores required W^k integrals (only those which are required). Writes them to disk by default. This can use significant memory, particularly for large basis. At the moment, always uses full basis – this may optionally change in the future.

Calling DiagramRPA::dV() without calling DiagramRPA::solve_core() will return 0. This is different from previous behaviour, where it returned dV^1, but in line with others. Call with max_its = 0 will also return 0. Call with max_its = 1 will return lowest-order dV correction.

#include <DiagramRPA.hpp>

Inheritance diagram for ExternalField::DiagramRPA:

Public Member Functions
	DiagramRPA (const DiracOperator::TensorOperator *const h, const std::vector< DiracSpinor > &basis, const HF::HartreeFock *in_hf, const std::string &atom="", bool print=true)
	Constructs DiagramRPA from a basis and a Hartree-Fock object.
	DiagramRPA (const DiracOperator::TensorOperator *const h, const DiagramRPA *const drpa)
	Constructs DiagramRPA by reusing W matrices from an existing instance.
void	solve_core (double omega, int max_its=200, bool print=true) override final
	Iterates the RPA equations to convergence for the core electrons.
Method	method () const final
	Returns the RPA method identifier (diagram)
double	dV (const DiracSpinor &Fa, const DiracSpinor &Fb) const override final
	Returns the RPA correction to a reduced matrix element.
double	dV (const DiracSpinor &Fa, const DiracSpinor &Fb, bool conj) const
DiracSpinor	dV_rhs (int kappa, const DiracSpinor &Fm, bool conj=false) const final
	Calculates reduced right-hand-side, projected onto kappa: [dV|phi_m]_kappa.
void	clear () final
	Resets the RPA matrix elements to their unperturbed (zeroth-order) values.
void	update_t0s (const DiracOperator::TensorOperator *const h=nullptr)
	Updates the zeroth-order matrix elements and resets the RPA solution.
DiagramRPA &	operator= (const DiagramRPA &)=delete
	DiagramRPA (const DiagramRPA &)=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
int	parity () const
bool	imagQ () const
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

Additional Inherited Members
Protected Member Functions inherited from ExternalField::CorePolarisation
	CorePolarisation (const DiracOperator::TensorOperator *const h)
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}

Constructor & Destructor Documentation

DiagramRPA() [1/2]

ExternalField::DiagramRPA::DiagramRPA	(	const DiracOperator::TensorOperator *const	h,
		const std::vector< DiracSpinor > &	basis,
		const HF::HartreeFock *	in_hf,
		const std::string &	atom = "",
		bool	print = true
	)

Constructs DiagramRPA from a basis and a Hartree-Fock object.

Splits basis into core (hole) and excited states, then computes the Coulomb W-matrix integrals required by the diagram RPA equations. If atom is non-empty the W matrices are read from a binary cache file (named from the atom label, operator rank, parity, and basis string) to avoid recalculation; if no matching file exists the matrices are computed and the file is written for future use. The Breit interaction is included automatically when present in in_hf.

Parameters

h	Pointer to the external-field tensor operator; must not be null
basis	Complete single-particle basis (holes and excited states)
in_hf	Pointer to the Hartree-Fock object; must not be null
atom	Atom label used to form the W-matrix cache filename; pass an empty string to disable file I/O
print	If true, prints progress information to stdout

DiagramRPA() [2/2]

ExternalField::DiagramRPA::DiagramRPA	(	const DiracOperator::TensorOperator *const	h,
		const DiagramRPA *const	drpa
	)

Constructs DiagramRPA by reusing W matrices from an existing instance.

Member Function Documentation

solve_core()

void ExternalField::DiagramRPA::solve_core ( double  omega, int  max_its = 200, bool  print = true  )

finaloverridevirtual

Iterates the RPA equations to convergence for the core electrons.

Performs a self-consistent iterative solution of the diagram-method RPA equations at external-field frequency omega. The zeroth-order matrix elements \( t^{(0)}_{am} \) are calculated (so long as max_its>0). Each iteration updates the RPA matrix elements \( t_{am} \) and \( t_{ma} \) using the precomputed Coulomb W-matrix integrals until the maximum relative change falls below eps_target(), or max_its iterations have been performed.

Parameters

omega	External-field frequency in atomic units
max_its	Maximum number of iterations (default 200)
print	If true, prints per-iteration progress to stdout

Note

Calling DiagramRPA::dV() without calling DiagramRPA::solve_core() will return 0. Call with max_its = 0 will mean that dV() also returns 0. Call with max_its = 1 will mean that dV() returns the lowest-order dV correction.

Implements ExternalField::CorePolarisation.

method()

Method ExternalField::DiagramRPA::method ( ) const

inlinefinalvirtual

Returns the RPA method identifier (diagram)

Implements ExternalField::CorePolarisation.

dV()

double ExternalField::DiagramRPA::dV ( const DiracSpinor &  Fa, const DiracSpinor &  Fb  ) const

finaloverridevirtual

Returns the RPA correction to a reduced matrix element.

Computes the many-body RPA correction to the reduced matrix element

\[ \langle a \| \delta V \| b \rangle \]

using the converged RPA matrix elements \( t_{am} \) from the most recent solve_core() call. Should be called after solve_core() has converged.

Parameters

Fa	Bra state
Fb	Ket state

Returns

Reduced matrix element of the RPA correction

Note

Not Hermitian - solve_core() must be called with negaitve omega

Implements ExternalField::CorePolarisation.

dV_rhs()

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

finalvirtual

Calculates reduced right-hand-side, projected onto kappa: [dV|phi_m]_kappa.

Reimplemented from ExternalField::CorePolarisation.

clear()

void ExternalField::DiagramRPA::clear ( )

finalvirtual

Resets the RPA matrix elements to their unperturbed (zeroth-order) values.

Clears the \( t_{am} \) and \( t_{ma} \) matrices (which encode the hole-excited RPA corrections) back to the state prior to any solve_core() call. Use this to discard a failed or poorly converged solution before restarting, for example with a different frequency or damping parameter.

Implements ExternalField::CorePolarisation.

update_t0s()

void ExternalField::DiagramRPA::update_t0s

(

const DiracOperator::TensorOperator *const

h = nullptr

)

Updates the zeroth-order matrix elements and resets the RPA solution.

Recomputes the lowest-order (no-RPA) matrix elements \( t^{(0)}_{am} \) for operator h . Does not update the rpa T_am values. If h is null the currently stored operator is used unchanged.

Parameters

h	Optional replacement tensor operator; pass nullptr to keep the current operator

---

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

• ExternalField/DiagramRPA.hpp
• ExternalField/DiagramRPA.cpp