IM-SRG++  0
Public Member Functions | Public Attributes | List of all members
ThreeBodyME Class Reference

#include <ThreeBodyME.hh>

Public Member Functions

 ThreeBodyME (ModelSpace *)
 
 ThreeBodyME (ModelSpace *ms, int e3max)
 
void Allocate ()
 
void SetModelSpace (ModelSpace *ms)
 
vector< pair< int, double > > AccessME (int Jab_in, int Jde_in, int J2, int tab_in, int tde_in, int T2, int i, int j, int k, int l, int m, int n) const
 
ThreeBME_type AddToME (int Jab_in, int Jde_in, int J2, int tab_in, int tde_in, int T2, int i, int j, int k, int l, int m, int n, ThreeBME_type V)
 
void SetME (int Jab_in, int Jde_in, int J2, int tab_in, int tde_in, int T2, int i, int j, int k, int l, int m, int n, ThreeBME_type V)
 
ThreeBME_type GetME (int Jab_in, int Jde_in, int J2, int tab_in, int tde_in, int T2, int i, int j, int k, int l, int m, int n) const
 
ThreeBME_type GetME_pn (int Jab_in, int Jde_in, int J2, int i, int j, int k, int l, int m, int n) const
 
int SortOrbits (int a_in, int b_in, int c_in, int &a, int &b, int &c) const
 
double RecouplingCoefficient (int recoupling_case, double ja, double jb, double jc, int Jab_in, int Jab, int J) const
 Coefficients for recoupling three body matrix elements.
 
void SetE3max (int e)
 
int GetE3max () const
 
void Erase ()
 
void Deallocate ()
 Free up the memory used for the matrix elements.
 
size_t size ()
 
void WriteBinary (ofstream &)
 
void ReadBinary (ifstream &)
 

Public Attributes

ModelSpacemodelspace
 
vector< ThreeBME_type > MatEl
 
vector< vector< vector< vector< vector< vector< size_t > > > > > > OrbitIndex
 
int E3max
 
size_t total_dimension
 

Detailed Description

The three-body piece of an operator, stored in nested vectors. The 3BMEs are stored in unnormalized JT coupled form \( \langle (abJ_{ab}t_{ab})c | V | (deJ_{de}t_{de})f \rangle_{JT} \). To minimize the number of stored matrix elements, only elements with \( a\geq b \geq c, a\geq d\geq e \geq f \) are stored. The other combinations are obtained on the fly by GetME(). The storage format is MatEl[{a,b,c,d,e,f,J,Jab,Jde}][T_index] = \( \langle (abJ_{ab}t_{ab})c | V | (deJ_{de}t_{de})f \rangle_{JT} \).

Member Function Documentation

vector< pair< int, double > > ThreeBodyME::AccessME ( int  Jab_in,
int  Jde_in,
int  J2,
int  tab_in,
int  tde_in,
int  T2,
int  a_in,
int  b_in,
int  c_in,
int  d_in,
int  e_in,
int  f_in 
) const

Since the code for setting or getting matrix elements is almost identical, do all the work here to pull out a list of indices and coefficients which are needed for setting or getting.

ThreeBME_type ThreeBodyME::GetME ( int  Jab_in,
int  Jde_in,
int  J2,
int  tab_in,
int  tde_in,
int  T2,
int  a_in,
int  b_in,
int  c_in,
int  d_in,
int  e_in,
int  f_in 
) const

Get three body matrix element in isospin formalism \( V_{abcdef}^{J_{ab}J_{de}Jt_{ab}t_{de}T} \) (which is how they're stored). The elements are stored with the following restrictions: \( a\geq b \geq c\), \( d\geq e \geq f\), \( a\geq d\). If \( a=d\) then \( b \geq e\), and if \( b=e \) then \( c \geq f \). Other orderings are obtained by recoupling on the fly.

ThreeBME_type ThreeBodyME::GetME_pn ( int  Jab_in,
int  Jde_in,
int  J2,
int  a,
int  b,
int  c,
int  d,
int  e,
int  f 
) const

Get three body matrix element in proton-neutron formalism.

\[ V_{abcdef}^{(pn)} = \sum_{t_{ab} t_{de} T} <t_a t_b | t_{ab}> <t_d t_e | t_{de}> <t_{ab} t_c | T> <t_{de} t_f| T> V_{abcdef}^{t_{ab} t_{de} T} \]

void ThreeBodyME::SetME ( int  Jab_in,
int  Jde_in,
int  J2,
int  tab_in,
int  tde_in,
int  T2,
int  a_in,
int  b_in,
int  c_in,
int  d_in,
int  e_in,
int  f_in,
ThreeBME_type  V 
)

Set a three body matrix element. Since only a subset of orbit orderings are stored, we need to recouple if the input ordering is different. In order to set rather than just add to the matrix element, we need to get the current value and add the difference.

int ThreeBodyME::SortOrbits ( int  a_in,
int  b_in,
int  c_in,
int &  a,
int &  b,
int &  c 
) const

Rearrange orbits (abc) so that a>=b>=c and return an int which reflects the required reshuffling

  • 0: (abc)_in -> (abc)
  • 1: (bca)_in -> (abc)
  • 2: (cab)_in -> (abc)
  • 3: (acb)_in -> (abc) – odd permutation
  • 4: (bac)_in -> (abc) – odd permutation
  • 5: (cba)_in -> (abc) – odd permutation

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