Matrix element of tensor operator: J_L(qr)*C^L. More...

#include <jL.hpp>

Inheritance diagram for DiracOperator::jL:

Public Member Functions
	jL (const Grid &r_grid, const Grid &q_grid, std::size_t max_l, bool subtract_one=false)
	Contruction takes radial grid, a q grid, and a maximum L. Fills lookup table.

	jL (const jL &other)
	Constructing from existing operator: copies JL table - faster. Can copy from a jL of different type (g0,g5 etc)

jL &	operator= (const jL &)=delete

std::size_t	L () const
	Current value of L (should = rank)

std::size_t	max_L () const
	Maximum L value in table.

const auto &	q_grid () const

const auto &	r_grid () const

virtual void	set_L_q (std::size_t L, double q)
	Sets the current L and q values for use. Note: NOT thread safe!

DiracSpinor	radial_rhs (const int kappa_a, const DiracSpinor &Fb) const override
	radial_int = Fa * radial_rhs(a, Fb) (a needed for angular factor)

virtual double	radialIntegral (const DiracSpinor &Fa, const DiracSpinor &Fb) const override final
	Radial part of integral R_ab = (Fa\|t\|Fb).

double	rme (const DiracSpinor &a, const DiracSpinor &b, std::size_t L, double q) const
	Directly calculate reduced matrix element without needing to call set_L_q - this is thread safe.

bool	is_zero (const DiracSpinor &a, const DiracSpinor &b, std::size_t L) const
	Checks if specific ME is zero (when not useing set_L_q)

virtual double	angularF (const int ka, const int kb) const override
	angularF: links radiation integral to RME. RME = <a\|\|h\|\|b> = angularF(a,b) * radial_int(a,b)

virtual double	angularCff (int, int) const override
	Angular factor for f_a*f_b part of radial integral.

virtual double	angularCgg (int, int) const override
	Angular factor for g_a*g_b part of radial integral.

virtual double	angularCfg (int, int) const override
	Angular factor for f_a*g_b part of radial integral.

virtual double	angularCgf (int, int) const override
	Angular factor for g_a*f_b part of radial integral.

virtual std::string	name () const override
	Returns "name" of operator (e.g., 'E1')

std::string	units () const override final
	Returns units of operator (usually au, may be MHz, etc.)

Public Member Functions inherited from DiracOperator::TensorOperator
bool	freqDependantQ () const

bool	isZero (const int ka, int kb) const
	If matrix element <a\|h\|b> is zero, returns true.

bool	isZero (const DiracSpinor &Fa, const DiracSpinor &Fb) const

bool	selectrion_rule (int twoJA, int piA, int twoJB, int piB) const

virtual void	updateFrequency (const double)
	Update frequency for frequency-dependant operators.

void	scale (double lambda)
	Permanently re-scales the operator by constant, lambda.

const std::vector< double > &	getv () const
	Returns a const ref to vector v.

double	getc () const
	Returns a const ref to constant c.

int	get_d_order () const

bool	imaginaryQ () const
	returns true if operator is imaginary (has imag MEs)

int	rank () const
	Rank k of operator.

int	parity () const
	returns parity, as integer (+1 or -1)

int	symm_sign (const DiracSpinor &Fa, const DiracSpinor &Fb) const
	returns relative sign between <a\|\|x\|\|b> and <b\|\|x\|\|a>

double	rme3js (const int twoja, const int twojb, int two_mb=1, int two_q=0) const
	ME = rme3js * RME.

DiracSpinor	reduced_rhs (const int ka, const DiracSpinor &Fb) const
	<a\|\|h\|\|b> = Fa * reduced_rhs(a, Fb) (a needed for angular factor)

DiracSpinor	reduced_lhs (const int ka, const DiracSpinor &Fb) const
	<b\|\|h\|\|a> = Fa * reduced_lhs(a, Fb) (a needed for angular factor)

double	reducedME (const DiracSpinor &Fa, const DiracSpinor &Fb) const
	The reduced matrix element.

double	fullME (const DiracSpinor &Fa, const DiracSpinor &Fb, std::optional< int > two_ma=std::nullopt, std::optional< int > two_mb=std::nullopt, std::optional< int > two_q=std::nullopt) const
	Returns "full" matrix element, for optional (ma, mb, q) [taken as int 2*]. If not specified, returns z-component (q=0), with ma=mb=min(ja,jb)

double	matel_factor (MatrixElementType type, int twoJa, int twoJb) const
	Converts reduced matrix element to different "type" (MatrixElementType)

double	matel_factor (MatrixElementType type, const DiracSpinor &Fa, const DiracSpinor &Fb) const

Protected Attributes
std::size_t	m_max_l

LinAlg::Matrix< std::vector< double > >	m_j_lq_r

const Grid *	m_r_grid

const Grid *	m_q_grid

bool	m_subtract_one

Protected Attributes inherited from DiracOperator::TensorOperator
int	m_rank

Parity	m_parity

int	m_diff_order

Realness	opC

bool	m_freqDependantQ {false}

double	m_constant

std::vector< double >	m_vec

Additional Inherited Members
Protected Member Functions inherited from DiracOperator::TensorOperator
	TensorOperator (int rank_k, Parity pi, double constant=1.0, const std::vector< double > &vec={}, int diff_order=0, Realness RorI=Realness::real, bool freq_dep=false)
	Constructs a tensor operator description.

Detailed Description

Matrix element of tensor operator: J_L(qr)*C^L.

Common matrix element for scattering problems. Defined as matrix element of J_L(qr)*C^L. Note: Does NOT include the Sqrt(2L+1) term (or 4pi). JL is spherical bessel function. Uses a look-up table for jL, faster than calculating on-the-fly. Note: different to other operators: rank (rank=L) and q are variable. Must use set_L_q (which sets L and q value) prior to use. Note: this is not thread-safe, so cannot parallelise over L or q.

Constructor & Destructor Documentation

◆ jL() [1/2]

DiracOperator::jL::jL	(	const Grid &	r_grid,
		const Grid &	q_grid,
		std::size_t	max_l,
		bool	subtract_one = `false`
	)

inline

Contruction takes radial grid, a q grid, and a maximum L. Fills lookup table.

◆ jL() [2/2]

DiracOperator::jL::jL ( const jL & other )

inline

Constructing from existing operator: copies JL table - faster. Can copy from a jL of different type (g0,g5 etc)

Member Function Documentation

◆ L()

std::size_t DiracOperator::jL::L ( ) const

inline

Current value of L (should = rank)

◆ max_L()

std::size_t DiracOperator::jL::max_L ( ) const

inline

Maximum L value in table.

◆ set_L_q()

virtual void DiracOperator::jL::set_L_q	(	std::size_t	L,
		double	q
	)

inlinevirtual

Sets the current L and q values for use. Note: NOT thread safe!

Reimplemented in DiracOperator::ig5jL, and DiracOperator::ig0g5jL.

◆ radial_rhs()

DiracSpinor DiracOperator::jL::radial_rhs	(	const int	kappa_a,
		const DiracSpinor &	Fb
	)		const

inlineoverridevirtual

radial_int = Fa * radial_rhs(a, Fb) (a needed for angular factor)

By default, is defined as:

\[ \delta F_{\rm b} = C_{\rm overall}\,v(r) \begin{pmatrix} C_{ff}f_b(r) + C_{fg}g_b(r) \\ C_{gf}f_b(r) + C_{gg}g_b(r) \end{pmatrix} \]

\( C_{f/g} \) are angular coeficients - see TensorOperator::angularCff

◆ radialIntegral()

virtual double DiracOperator::jL::radialIntegral	(	const DiracSpinor &	Fa,
		const DiracSpinor &	Fb
	)		const

inlinefinaloverridevirtual

Radial part of integral R_ab = (Fa|t|Fb).

<a||t||b> = angularF(a,b) * radialIntegral(a,b)

The 'radial' integral \(R_{ab}\) for operator \(t\) is defined as

\[ \langle a ||t|| b \rangle \equiv R_{ab} * A_{ab} \]

where \(A_{ab}\) is TensorOperator::angularF()

By default, is implemented as:

\[ R = \int_0^\infty F_a\cdot\delta F_{\rm b} \,{\rm d}r \]

where \( \delta F_{\rm b} \) is defined in TensorOperator::radial_rhs

So, if TensorOperator::radial_rhs is defined normally, we have:

\[ C_{\rm overall}\int_0^\infty v(r)\left( C_{ff}f_a(r)f_b(r) + C_{fg}f_a(r)g_b(r) + C_{gf}g_a(r)f_b(r) + C_{gg}g_a(r)g_b(r) \right)\,{\rm d}r \]

\( C_{f/g} \) are angular coeficients - see TensorOperator::angularCff

Warning

This is defined for the "standard" case, which doesn't always suit
TensorOperator::radial_rhs may be overridden for special cases
If radial_rhs is overridden, then radialIntegral must also be_

Reimplemented from DiracOperator::TensorOperator.

◆ rme()

double DiracOperator::jL::rme	(	const DiracSpinor &	a,
		const DiracSpinor &	b,
		std::size_t	L,
		double	q
	)		const

inline

Directly calculate reduced matrix element without needing to call set_L_q - this is thread safe.

◆ is_zero()

bool DiracOperator::jL::is_zero	(	const DiracSpinor &	a,
		const DiracSpinor &	b,
		std::size_t	L
	)		const

inline

Checks if specific ME is zero (when not useing set_L_q)

◆ angularF()

virtual double DiracOperator::jL::angularF	(	const int	,
		const int
	)		const

inlineoverridevirtual

angularF: links radiation integral to RME. RME = <a||h||b> = angularF(a,b) * radial_int(a,b)

Implements DiracOperator::TensorOperator.

Reimplemented in DiracOperator::ig0g5jL, and DiracOperator::ig5jL.

◆ angularCff()

virtual double DiracOperator::jL::angularCff	(	int	,
		int
	)		const

inlineoverridevirtual

Angular factor for f_a*f_b part of radial integral.

Often constant, though sometimes depends on \(\kappa_a,\kappa_b\)
\[ \int_0^\infty v(r)\left( C_{ff}f_a(r)f_b(r) + C_{fg}f_a(r)g_b(r) + C_{gf}g_a(r)f_b(r) + C_{gg}g_a(r)g_b(r) \right)\,{\rm d}r \]

Reimplemented from DiracOperator::TensorOperator.

Reimplemented in DiracOperator::ig0g5jL, DiracOperator::g0jL, and DiracOperator::ig5jL.