ampsci
High-precision calculations for one- and two-valence atomic systems
DiracOperator::TensorOperatorabstract

General operator (virtual base class); operators derive from this. More...

#include <TensorOperator.hpp>

+ Inheritance diagram for DiracOperator::TensorOperator:

Public Member Functions

 TensorOperator (const TensorOperator &)=default
 
TensorOperatoroperator= (const TensorOperator &)=default
 
 TensorOperator (TensorOperator &&)=default
 
TensorOperatoroperator= (TensorOperator &&)=default
 
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>
 
virtual std::string name () const
 Returns "name" of operator (e.g., 'E1')
 
virtual std::string units () const
 Returns units of operator (usually au, may be MHz, etc.)
 
virtual double angularCff (int, int) const
 Angular factor for f_a*f_b part of radial integral.
 
virtual double angularCgg (int, int) const
 Angular factor for g_a*g_b part of radial integral.
 
virtual double angularCfg (int, int) const
 Angular factor for f_a*g_b part of radial integral.
 
virtual double angularCgf (int, int) const
 Angular factor for g_a*f_b part of radial integral.
 
virtual double angularF (const int, const int) const =0
 angularF: links radiation integral to RME. RME = <a||h||b> = angularF(a,b) * radial_int(a,b)
 
virtual DiracSpinor radial_rhs (const int kappa_a, const DiracSpinor &Fb) const
 radial_int = Fa * radial_rhs(a, Fb) (a needed for angular factor)
 
virtual double radialIntegral (const DiracSpinor &Fa, const DiracSpinor &Fb) const
 Radial part of integral R_ab = (Fa|t|Fb).
 
double rme3js (const int twoja, const int twojb, int two_mb=1, int two_q=0) const
 ME = rme3js * RME.
 
double rme3js (const DiracSpinor &Fa, const DiracSpinor &Fb, 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 Member Functions

 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.
 

Protected Attributes

int m_rank
 
Parity m_parity
 
int m_diff_order
 
Realness opC
 
bool m_freqDependantQ {false}
 
double m_constant
 
std::vector< double > m_vec
 

Detailed Description

General operator (virtual base class); operators derive from this.

  • k is rank, c is multiplicative constant, d_order is derivative order,
  • pi is parity, may be Parity::even or odd.
  • RorI may be Realness::real or Realness::imaginary.
  • Note: You may not construct a TensorOperator. Instead, you must construct one of the derived 'operators' (there are some general ones); see operators.hpp for list of operators. Operators work by overrideing the angularCxx() functions and angularF().
  • c, v, and Cxx are included in radial integral.

Constructor & Destructor Documentation

◆ TensorOperator()

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 
)
inlineprotected

Constructs a tensor operator description.

Initialises the basic properties of a tensor operator.

Parameters
rank_kTensor rank k of the operator.
piParity of the operator (Parity::even or Parity::odd).
constantMultiplicative constant c, included in the radial integral.
vecOverall v=f(r) radial function, as std::vector array
RorISpecifies whether the matrix element is real or imaginary (Realness::real or Realness::imaginary).
freq_depIndicates whether the operator depends on frequency (e.g., dynamic external fields).
Note
TensorOperator is a virtual base class and may not be constructed directly. It is intended to be initialised by derived operator classes.

Member Function Documentation

◆ isZero()

bool DiracOperator::TensorOperator::isZero ( const int  ka,
int  kb 
) const

If matrix element <a|h|b> is zero, returns true.

◆ updateFrequency()

◆ scale()

void DiracOperator::TensorOperator::scale ( double  lambda)

Permanently re-scales the operator by constant, lambda.

◆ getv()

const std::vector< double > & DiracOperator::TensorOperator::getv ( ) const
inline

Returns a const ref to vector v.

◆ getc()

double DiracOperator::TensorOperator::getc ( ) const
inline

Returns a const ref to constant c.

◆ imaginaryQ()

bool DiracOperator::TensorOperator::imaginaryQ ( ) const
inline

returns true if operator is imaginary (has imag MEs)

◆ rank()

int DiracOperator::TensorOperator::rank ( ) const
inline

Rank k of operator.

◆ parity()

int DiracOperator::TensorOperator::parity ( ) const
inline

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

◆ symm_sign()

int DiracOperator::TensorOperator::symm_sign ( const DiracSpinor Fa,
const DiracSpinor Fb 
) const
inline

returns relative sign between <a||x||b> and <b||x||a>

◆ name()

◆ units()

◆ angularCff()

virtual double DiracOperator::TensorOperator::angularCff ( int  ,
int   
) const
inlinevirtual

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 in DiracOperator::VertexQED, DiracOperator::MLVP, DiracOperator::jL, DiracOperator::ig0g5jL, DiracOperator::ScalarOperator, DiracOperator::E1v, DiracOperator::VEk_lowq, DiracOperator::VMk_lowq, DiracOperator::VLk_lowq, DiracOperator::hfs, DiracOperator::g0jL, DiracOperator::ig5jL, DiracOperator::M1, and DiracOperator::NullOperator.

◆ angularCgg()

virtual double DiracOperator::TensorOperator::angularCgg ( int  ,
int   
) const
inlinevirtual

◆ angularCfg()

virtual double DiracOperator::TensorOperator::angularCfg ( int  ,
int   
) const
inlinevirtual

◆ angularCgf()

virtual double DiracOperator::TensorOperator::angularCgf ( int  ,
int   
) const
inlinevirtual

◆ angularF()

◆ radial_rhs()

DiracSpinor DiracOperator::TensorOperator::radial_rhs ( const int  kappa_a,
const DiracSpinor Fb 
) const
virtual

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

See also: TensorOperator::radial_rhs

Reimplemented in DiracOperator::jL, DiracOperator::VEk_Len, DiracOperator::VEk, DiracOperator::VLk, DiracOperator::VMk, DiracOperator::Phik, DiracOperator::Sk, DiracOperator::AEk, DiracOperator::ALk, DiracOperator::AMk, DiracOperator::Phi5k, DiracOperator::S5k, DiracOperator::Phik_lowq, DiracOperator::Sk_lowq, DiracOperator::AEk_lowq, DiracOperator::ALk_lowq, DiracOperator::AMk_lowq, DiracOperator::Phi5k_lowq, DiracOperator::S5k_lowq, DiracOperator::M1nr, and DiracOperator::Vrad.

◆ radialIntegral()

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

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 in DiracOperator::VEk_Len, DiracOperator::VEk, DiracOperator::VLk, DiracOperator::VMk, DiracOperator::Phik, DiracOperator::Sk, DiracOperator::AEk, DiracOperator::ALk, DiracOperator::AMk, DiracOperator::Phi5k, DiracOperator::S5k, DiracOperator::Phik_lowq, DiracOperator::Sk_lowq, DiracOperator::AEk_lowq, DiracOperator::ALk_lowq, DiracOperator::AMk_lowq, DiracOperator::Phi5k_lowq, DiracOperator::S5k_lowq, DiracOperator::jL, DiracOperator::M1nr, and DiracOperator::Vrad.

◆ rme3js() [1/2]

double DiracOperator::TensorOperator::rme3js ( const int  twoja,
const int  twojb,
int  two_mb = 1,
int  two_q = 0 
) const

ME = rme3js * RME.

◆ rme3js() [2/2]

double DiracOperator::TensorOperator::rme3js ( const DiracSpinor Fa,
const DiracSpinor Fb,
int  two_mb = 1,
int  two_q = 0 
) const
inline

ME = rme3js * RME.

◆ reduced_rhs()

DiracSpinor DiracOperator::TensorOperator::reduced_rhs ( const int  ka,
const DiracSpinor Fb 
) const

<a||h||b> = Fa * reduced_rhs(a, Fb) (a needed for angular factor)

◆ reduced_lhs()

DiracSpinor DiracOperator::TensorOperator::reduced_lhs ( const int  ka,
const DiracSpinor Fb 
) const

<b||h||a> = Fa * reduced_lhs(a, Fb) (a needed for angular factor)

◆ reducedME()

double DiracOperator::TensorOperator::reducedME ( const DiracSpinor Fa,
const DiracSpinor Fb 
) const

The reduced matrix element.

◆ fullME()

double DiracOperator::TensorOperator::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)

◆ matel_factor()

double DiracOperator::TensorOperator::matel_factor ( MatrixElementType  type,
int  twoJa,
int  twoJb 
) const

Converts reduced matrix element to different "type" (MatrixElementType)


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