DiracOperator Namespace Reference

Dirac Operators: General + derived. More...

Namespaces
namespace	Hyperfine
	Functions for F(r) [nuclear magnetisation distribution] and similar.
namespace	multipole
	Helper functions for the multipole operators.

Classes
class	AEk
	Axial electric multipole operator: \( A^E_K = T^{(+1)}_K(q)\gamma^5 \). More...
class	AEk_lowq
	Low qr form of Axial electric multipole operator: \( A^E_K = T^{(+1)}_K(q)\gamma^5\). More...
class	ALk
	Axial longitudinal multipole operator: \( A^L_K = T^{(-1)}_K(q)\gamma^5 \). More...
class	ALk_lowq
	Low qr form of Axial longitudinal multipole operator: \( A^L_K = T^{(-1)}_K(q)\gamma^5\). More...
class	AMk
	Axial magnetic multipole operator: \( A^M_K = T^{(0)}_K(q)\gamma^5 \). More...
class	AMk_lowq
	Low qr form of Axial magnetic multipole operator: \( A^M_K = T^{(0)}_K(q)\gamma^5\). More...
class	dr
	radial derivative operator More...
class	E1
	Electric dipole operator: -|e|r = -er. More...
class	E1v
	Electric dipole operator, v-form: \( \frac{ie}{\omega \alpha} \vec{\alpha}\). More...
class	Ek
	E^k (electric multipole) operator. More...
class	fieldshift
	Field shift operator, (e.g.) dV = V(r+dr) - V(r) More...
class	g0jL
	Matrix element of tensor operator: gamma^0 J_L(qr) C^L. More...
class	hfs
	Units: Assumes nuclear moment in units of powers of nuclear magnetons and/or barns - muN*b^(k-1)/2 for magnetic, and b^k/2 for electric. More...
class	ig0g5jL
	Matrix element of tensor operator: i gamma^0gamma^5 J_L(qr) C^L. nb: i makes ME real. More...
class	ig5jL
	Matrix element of tensor operator: i gamma^5 J_L(qr) C^L. nb: i makes ME real. More...
struct	IntM4x4
	4x4 Integer matrix (for Gamma/Pauli). Can be real or imag. Not mixed. More...
class	j
	j (total angular momentum) operator More...
class	jL
	Matrix element of tensor operator: J_L(qr)*C^L. More...
class	l
	l (orbital angular momentum) operator More...
class	M1
	Magnetic dipole operator: <a||M1||b> More...
class	M1nr
	Magnetic dipole operator, in non-relativistic form: M1 = L + 2S. More...
class	MLVP
	Magnetic loop vacuum polarisation (Uehling vertex) More...
class	NullOperator
	Speacial operator: 0. More...
class	Phi5k
	Temporal component of the axial vector multipole operator: \( \Theta_K = \Phi^5_K = t^K(q)\gamma^5 \). More...
class	Phi5k_lowq
	Low qr form of Temporal component of the axial vector multipole operator: \( \Theta_K = \Phi^5_K = t^K(q)\gamma^5\) . NOTE: If K=0, omega should be (ea-eb); for K=1 should be q = alpha*omega! More...
class	Phik
	Temporal component of the vector multipole operator: \( \Phi_K = t^K(q) \). More...
class	Phik_lowq
	Low qr form of Temporal component of the vector multipole operator: \( \Phi_K = t^K(q)\). More...
class	PNCnsi
	Nuclear-spin independent PNC operator (Qw) More...
class	RadialF
	General function of r, even scalar operator. More...
class	s
	s (spin) operator More...
class	S5k
	Pseudoscalar multipole operator: \( P_K = S^5_K = t^K(q)(i\gamma^0\gamma^5) \). More...
class	S5k_lowq
	Low qr form of Pseudoscalar multipole operator: \( P_K = S^5_K = t^K(q)(i\gamma^0\gamma^5)\) NOTE: If K=0, omega should be (ea-eb); for K=1 should be q = alpha*omega! More...
class	ScalarOperator
	Speacial case for scalar operator. More...
class	Sk
	Scalar multipole operator: \( S_K = t^K(q)\gamma^0 \). More...
class	Sk_lowq
	Low qr form of Scalar multipole operator: \( S_K = t^K(q)\gamma^0\). More...
class	TensorOperator
	General operator (virtual base class); operators derive from this. More...
class	VEk
	Vector electric multipole (V-form) operator: \( V^E_K = T^{(+1)}_K(q) \). More...
class	VEk_Len
	Vector electric multipole (transition) operator, Length-form: ( \( T^{(+1),{\rm Len}}_K \) ). More...
class	VEk_lowq
	Low qr form of Vector electric. Only for K=1 (zero otherwise) More...
class	VertexQED
	Effective VertexQED operator. More...
class	VLk
	Vector longitudinal multipole operator (V-form): \( V^L_K = T^{(-1)}_K(q) \). More...
class	VLk_lowq
	Low qr form of Vector longitudanal. More...
class	VMk
	Vector magnetic multipole operator: \( V^M_K = T^{(0)}_K(q) \). More...
class	VMk_lowq
	Low qr form of Vector magnetic. Only for K=1 (zero otherwise) More...
class	Vrad
	Flambaum-ginges radiative potential operator. More...

Enumerations
enum class	Parity { even , odd , blank }
enum class	Realness { real , imaginary , blank }

Functions
std::unique_ptr< DiracOperator::TensorOperator >	generate (std::string_view operator_name, const IO::InputBlock &input, const Wavefunction &wf)
	Returns a unique_ptr (polymorphic) to the requested operator, with given properties.
void	list_operators ()
	List available operators.
std::unique_ptr< DiracOperator::TensorOperator >	generate_sigma_r (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_E1 (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_E1v (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_E2 (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_ialpha (const IO::InputBlock &input, const Wavefunction &)
std::unique_ptr< DiracOperator::TensorOperator >	generate_Ek (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	MultipoleOperator (const Grid &grid, int k, double omega, char type, char comp, bool low_q, const SphericalBessel::JL_table *jl=nullptr)
	Factory for relativistic multipole operators.
std::unique_ptr< DiracOperator::TensorOperator >	generate_Multipole (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_fieldshift (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_hfs (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_l (const IO::InputBlock &input, const Wavefunction &)
std::unique_ptr< DiracOperator::TensorOperator >	generate_s (const IO::InputBlock &input, const Wavefunction &)
std::unique_ptr< DiracOperator::TensorOperator >	generate_M1 (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_M1nr (const IO::InputBlock &input, const Wavefunction &)
std::unique_ptr< DiracOperator::TensorOperator >	generate_p (const IO::InputBlock &input, const Wavefunction &)
std::unique_ptr< DiracOperator::TensorOperator >	generate_pnc (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_Vrad (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_MLVP (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_r (const IO::InputBlock &input, const Wavefunction &wf)
std::unique_ptr< DiracOperator::TensorOperator >	generate_dr (const IO::InputBlock &input, const Wavefunction &)
double	Pab (double pm, const std::vector< double > &t, const DiracSpinor &Fa, const DiracSpinor &Fb)
	Pab function: Int[ (fa*gb + pm*ga*fb) * t(r) , dr]. pm = +/-1 (usually)
double	Rab (double pm, const std::vector< double > &t, const DiracSpinor &Fa, const DiracSpinor &Fb)
	Rab function: Int[ (fa*fb + pm*ga*gb) * t(r) , dr]. pm = +/-1 (usually)
void	Pab_rhs (double pm, const std::vector< double > &t, DiracSpinor *dF, const DiracSpinor &Fb, double A=1.0)
	Pab_rhs function: dF_ab += A * t(r) * (g, pm*f) , pm=+/-1 (usually). NOTE: uses +=, so can combine. Ensure empty to begin.
void	Rab_rhs (double pm, const std::vector< double > &t, DiracSpinor *dF, const DiracSpinor &Fb, double A=1.0)
	Rab_rhs function: dF_ab += A * t(r) * (f, pm*g) , pm=+/-1 (usually). NOTE: uses +=, so can combine. Ensure empty to begin.
double	Vab (const std::vector< double > &t, const DiracSpinor &Fa, const DiracSpinor &Fb)
	Vab function: Int[ (fa*gb ) * t(r) , dr].
double	Wab (const std::vector< double > &t, const DiracSpinor &Fa, const DiracSpinor &Fb)
	Wab function: Int[ (ga*fb ) * t(r) , dr].
double	Gab (const std::vector< double > &t, const DiracSpinor &Fa, const DiracSpinor &Fb)
	Gab function: Int[ (ga*gb ) * t(r) , dr].
void	Gab_rhs (const std::vector< double > &t, DiracSpinor *dF, const DiracSpinor &Fb, double a)
double	Gab (const DiracSpinor &Fa, const DiracSpinor &Fb)
	Gab = Int[ ga*gb , dr] - (just relativistic correction part of integral)
void	Gab_rhs (DiracSpinor *dF, const DiracSpinor &Fb, double a)
	Gab_rhs(r) += a*g_b(r). Note: uses += so may be sumulative.
double	Pab (double pm, const DiracSpinor &Fa, const DiracSpinor &Fb)
	Pab[1] function: Int[ (fa*gb + pm*ga*fb) , dr]. pm = +/-1 (usually)
double	Rab (double pm, const DiracSpinor &Fa, const DiracSpinor &Fb)
	Rab[1] function: Int[ (fa*fb + pm*ga*gb) , dr] = Int[ (pm-1)*ga*gb) , dr]. NOTE: assumes NOT diagonal, using orthogonality condition.
void	Pab_rhs (double pm, DiracSpinor *dF, const DiracSpinor &Fb, double A=1.0)
	Pab_rhs[1] function: dF_ab += A * (g, pm*f) , pm=+/-1 (usually).
void	Rab_rhs (double pm, DiracSpinor *dF, const DiracSpinor &Fb, double A=1.0)
	Rab_rhs[1] function: dF_ab += A * (f, pm*g) = dF_ab += A * (0, (pm-1)*g). NOTE: assumes NOT diagonal, using orthogonality condition.

Variables
brief i	vec

Detailed Description

Dirac Operators: General + derived.

Function Documentation

generate()

std::unique_ptr< DiracOperator::TensorOperator > DiracOperator::generate	(	std::string_view	operator_name,
		const IO::InputBlock &	input,
		const Wavefunction &	wf
	)

Returns a unique_ptr (polymorphic) to the requested operator, with given properties.

list_operators()

void DiracOperator::list_operators

(

)

List available operators.

MultipoleOperator()

std::unique_ptr< DiracOperator::TensorOperator > DiracOperator::MultipoleOperator	(	const Grid &	grid,
		int	k,
		double	omega,
		char	type,
		char	comp,
		bool	low_q,
		const SphericalBessel::JL_table *	jl = nullptr
	)

Factory for relativistic multipole operators.

Constructs and returns a specific multipole operator derived from DiracOperator::TensorOperator, based on the requested Lorentz structure, multipole component, and momentum-transfer regime.

The operator corresponds to a spherical multipole of rank k with frequency/energy transfer omega. The type and component determine the Lorentz structure and spatial character of the interaction.

Parameters

grid	Radial grid on which the operator acts.
k	Multipole rank (total angular momentum of the operator).
omega	Energy (frequency) transfer.
type	Interaction type: 'V' : Vector 'A' : Axial-vector 'S' : Scalar 'P' : Pseudoscalar
comp	Multipole component (for V/A types): 'E' : Electric 'M' : Magnetic 'L' : Longitudinal 'T' : Temporal [caution - NOT transverse!] (Ignored for scalar and pseudoscalar operators.)
low_q	If true, construct the low-momentum (long-wavelength) approximation of the operator.
jl	Optional pointer to a precomputed spherical Bessel table. If provided, radial Bessel functions are taken from this table to avoid recomputation. If nullptr, they are generated internally as needed.

Returns

A std::unique_ptr to the requested TensorOperator.

Note

Length-form electric operators (if implemented separately) are only valid for vector-electric ('V','E') combinations.

Warning

Invalid combinations of type and comp may result in a nullptr being returned.

Pab() [1/2]

double DiracOperator::Pab	(	double	pm,
		const std::vector< double > &	t,
		const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)

Pab function: Int[ (fa*gb + pm*ga*fb) * t(r) , dr]. pm = +/-1 (usually)

Note: does not know selection rules, so only evaluate if non-zero

Rab() [1/2]

double DiracOperator::Rab	(	double	pm,
		const std::vector< double > &	t,
		const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)

Rab function: Int[ (fa*fb + pm*ga*gb) * t(r) , dr]. pm = +/-1 (usually)

Note: does not know selection rules, so only evaluate if non-zero

Pab_rhs() [1/2]

void DiracOperator::Pab_rhs	(	double	pm,
		const std::vector< double > &	t,
		DiracSpinor *	dF,
		const DiracSpinor &	Fb,
		double	A = 1.0
	)

Pab_rhs function: dF_ab += A * t(r) * (g, pm*f) , pm=+/-1 (usually). NOTE: uses +=, so can combine. Ensure empty to begin.

Note: does not know selection rules, so only evaluate if non-zero. Should have Fa*Pab_rhs = A * Pab.

Rab_rhs() [1/2]

void DiracOperator::Rab_rhs	(	double	pm,
		const std::vector< double > &	t,
		DiracSpinor *	dF,
		const DiracSpinor &	Fb,
		double	A = 1.0
	)

Rab_rhs function: dF_ab += A * t(r) * (f, pm*g) , pm=+/-1 (usually). NOTE: uses +=, so can combine. Ensure empty to begin.

Note: does not know selection rules, so only evaluate if non-zero. Should have Fa*Rab_rhs = A * Rab.

Vab()

double DiracOperator::Vab	(	const std::vector< double > &	t,
		const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)

Vab function: Int[ (fa*gb ) * t(r) , dr].

Wab()

double DiracOperator::Wab	(	const std::vector< double > &	t,
		const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)

Wab function: Int[ (ga*fb ) * t(r) , dr].

Gab() [1/2]

double DiracOperator::Gab	(	const std::vector< double > &	t,
		const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)

Gab function: Int[ (ga*gb ) * t(r) , dr].

Gab() [2/2]

double DiracOperator::Gab	(	const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)

Gab = Int[ ga*gb , dr] - (just relativistic correction part of integral)

Gab_rhs()

void DiracOperator::Gab_rhs	(	DiracSpinor *	dF,
		const DiracSpinor &	Fb,
		double	a
	)

Gab_rhs(r) += a*g_b(r). Note: uses += so may be sumulative.

Pab() [2/2]

double DiracOperator::Pab	(	double	pm,
		const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)

Pab[1] function: Int[ (fa*gb + pm*ga*fb) , dr]. pm = +/-1 (usually)

Rab() [2/2]

double DiracOperator::Rab	(	double	pm,
		const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)

Rab[1] function: Int[ (fa*fb + pm*ga*gb) , dr] = Int[ (pm-1)*ga*gb) , dr]. NOTE: assumes NOT diagonal, using orthogonality condition.

Pab_rhs() [2/2]

void DiracOperator::Pab_rhs	(	double	pm,
		DiracSpinor *	dF,
		const DiracSpinor &	Fb,
		double	a
	)

Pab_rhs[1] function: dF_ab += A * (g, pm*f) , pm=+/-1 (usually).

Rab_rhs() [2/2]

void DiracOperator::Rab_rhs	(	double	pm,
		DiracSpinor *	dF,
		const DiracSpinor &	Fb,
		double	a
	)

Rab_rhs[1] function: dF_ab += A * (f, pm*g) = dF_ab += A * (0, (pm-1)*g). NOTE: assumes NOT diagonal, using orthogonality condition.

Variable Documentation

vec

brief i DiracOperator::vec

Initial value:

{\alpha} matrix element: propto Electric dipole operator.
    i factored so that ME is real
class ialpha final : public TensorOperator {
public:
  ialpha() : TensorOperator(1, Parity::odd, 1.0, {}, 0, Realness::real, true) {}
 
  std::string name() const override final { return "i*alpha"; }
  std::string units() const override final { return "au"; }
 
  double angularF(const int ka, const int kb) const override final {
    return Angular::Ck_kk(1, ka, kb);
  }
 
  double angularCff(int, int) const override final { return 0; }
  double angularCgg(int, int) const override final { return 0; }
  double angularCfg(int ka, int kb) const override final { return ka - kb - 1; }
  double angularCgf(int ka, int kb) const override final { return ka - kb + 1; }
}