coulomb_utensor

edrixs.coulomb_utensor.get_gaunt(l1, l2)[source]

Calculate the Gaunt coefficents \(C_{l_1,l_2}(k,m_1,m_2)\)

\[C_{l_1,l_2}(k,m_1,m_2)=\sqrt{\frac{4\pi}{2k+1}} \int \mathop{d\phi} \mathop{d\theta} sin(\theta) Y_{l_1}^{m_1\star}(\theta,\phi) Y_{k}^{m_1-m_2}(\theta,\phi) Y_{l_2}^{m_2}(\theta,\phi)\]

Parameters:

l1: int: The first quantum number of angular momentum.
l2: int: The second quantum number of angular momentum.

Returns:

res: 3d float array

The calculated Gaunt coefficents.

The 1st index (\(= 0, 1, ..., l_1+l_2+1\)) is the order \(k\).

The 2nd index (\(= 0, 1, ... ,2l_1\)) is the magnetic quantum number \(m_1\) plus \(l_1\)

The 3nd index (\(= 0, 1, ... ,2l_2\)) is the magnetic quantum number \(m_2\) plus \(l_2\)

Notes

It should be noted that \(C_{l_1,l_2}(k,m_1,m_2)\) is nonvanishing only when

\(k + l_1 + l_2 = \text{even}\),

and

\(|l_1 - l_2| \leq k \leq l_1 + l_2\).

Please see Ref. [1] p. 10 for more details.

References

[1]

Sugano S, Tanabe Y and Kamimura H. 1970. Multiplets of Transition-Metal Ions in Crystals. Academic Press, New York and London.

Examples

>>> import edrixs

Get gaunt coefficients between \(p\)-shell and \(d\)-shell

>>> g = edrixs.get_gaunt(1, 2)

edrixs.coulomb_utensor.get_umat_kanamori(norbs, U, J)[source]

Calculate the Coulomb interaction tensor for a Kanamori-type interaction. For the \(t2g\)-shell case, it is parameterized by \(U, J\).

Parameters:

norbs: int: number of orbitals (including spin).
U: float: Hubbard \(U\) for electrons residing on the same orbital with opposite spin.
J: float: Hund’s coupling.

Returns:

umat: 4d complex array: The calculated Coulomb interaction tensor

See also

coulomb_utensor.get_umat_kanamori_ge
coulomb_utensor.get_umat_slater
coulomb_utensor.umat_slater

Notes

The order of spin index is: up, down, up, down, …, up, down.

edrixs.coulomb_utensor.get_umat_kanamori_ge(norbs, U1, U2, J, Jx, Jp)[source]

Calculate the Coulomb interaction tensor for a Kanamori-type interaction. For the general case, it is parameterized by \(U_1, U_2, J, J_x, J_p\).

Parameters:

norbs: int: number of orbitals (including spin).
U1: float: Hubbard \(U\) for electrons residing on the same orbital with opposite spin.
U2: float: Hubbard \(U\) for electrons residing on different orbitals.
J: float: Hund’s coupling for density-density interaction.
Jx: float: Hund’s coupling for spin flip.
Jp: float: Hund’s coupling for pair-hopping.

Returns:

umat: 4d complex array: The calculated Coulomb interaction tensor

See also

coulomb_utensor.get_umat_kanamori
coulomb_utensor.get_umat_slater
coulomb_utensor.umat_slater

Notes

The order of spin index is: up, down, up, down, …, up, down.

edrixs.coulomb_utensor.get_umat_slater(case, *args)[source]

Convenient adapter function to return the Coulomb interaction tensor for common case.

Parameters:

case: string

Indicates atomic shells, should be one of

For single shell:

‘s’: single \(s\)-shell (\(l=0\))
‘p’: single \(p\)-shell (\(l=1\))
‘p12’: single \(p_{1/2}\)-shell (\(l=1\))
‘p32’: single \(p_{3/2}\)-shell (\(l=1\))
‘t2g’: single \(t_{2g}\)-shell (\(l_{\text{eff}}=1\))
‘d’: single \(d\)-shell (\(l=2\))
‘d32’: single \(d_{3/2}\)-shell (\(l=2\))
‘d52’: single \(d_{5/2}\)-shell (\(l=2\))
‘f’: single \(f\)-shell (\(l=3\))
‘f52’: single \(f_{5/2}\)-shell (\(l=3\))
‘f72’: single \(f_{7/2}\)-shell (\(l=3\))

For two shells:

case = str1 + str2

where, str1 and str2 are strings and they can be any of

[‘s’, ‘p’, ‘p12’, ‘p32’, ‘t2g’, ‘d’, ‘d32’, ‘d52’, ‘f’, ‘f52’, ‘f72’]

For examples,

‘dp’: 1st \(d\)-shell and 2nd \(p\)-shell
‘dp12’: 1st \(d\)-shell and 2nd \(p_{1/2}\)-shell
‘f52p32’: 1st \(f_{5/2}\)-shell and 2nd \(p_{3/2}\)-shell
‘t2gp’: 1st \(t_{2g}\)-shell and 2nd \(p\)-shell

*args: floats

Variable length argument list. Slater integrals. The order of these integrals shoule be

For only one shell case,

args = [F0, F2, F4, F6, ….]

For two shells case,

args = [FX_11, FX_12, GX_12, FX_22]

where, 1 (2) means 1st (2nd)-shell, and X=0, 2, 4, … or X=1, 3, 5 …, and X should be in ascending order. The following are possible cases:

‘s’:

args = [F0]

‘p’, ‘p12’, ‘p32’:

args = [F0, F2]

‘d’, ‘d32’, ‘d52’, ‘t2g’:

args = [F0, F2, F4]

‘f’, ‘f52’, ‘f72’:

args = [F0, F2, F4, F6]

‘ss’:

args = [F0_11, F0_12, G0_12, F0_22]

‘ps’, ‘p12s’, ‘p32s’:

args = [F0_11, F2_11, F0_12, G1_12, F0_22]

‘ds’, ‘d32s’, ‘d52s’, ‘t2gs’:

args = [F0_11, F2_11, F4_11, F0_12, G2_12, F0_22]

‘fs’, ‘f52s’, ‘f72s’:

args = [F0_11, F2_11, F4_11, F6_11, F0_12, G3_12, F0_22]

‘sp’, ‘sp12’, ‘sp32’:

args = [F0_11, F0_12, G1_12, F0_22, F2_22]

‘pp’, ‘pp12’, ‘pp32’, ‘p12p’, ‘p12p12’, ‘p12p32’, ‘p32p’, ‘p32p12’, ‘p32p32’:

args = [F0_11, F2_11, F0_12, F2_12, G0_12, G2_12, F0_22, F2_22]

‘dp’, ‘dp12’, ‘dp32’, ‘d32p’, ‘d32p12’, ‘d32p32’, ‘d52p’, ‘d52p12’, ‘d52p32’, ‘t2gp’, ‘t2gp12’, t2gp32’:

args = [F0_11, F2_11, F4_11, F0_12, F2_12, G1_12, G3_12, F0_22, F2_22]

‘fp’, ‘fp12’, ‘fp32’, ‘f52p’, ‘f52p12’, ‘f52p32’, ‘f72p’, ‘f72p12’, ‘f72p32’:

args = [F0_11, F2_11, F4_11, F6_11, F0_12, F2_12, G2_12, G4_12, F0_22, F2_22]

‘sd’, ‘sd32’, ‘sd52’:

args = [F0_11, F0_12, G2_12, F0_22, F2_22, F4_22]

‘pd’, ‘pd32’, ‘pd52’, ‘p12d’, ‘p12d32’, ‘p12d52’, ‘p32d’, ‘p32d32’, ‘p32d52’:

args = [F0_11, F2_11, F0_12, F2_12, G1_12, G3_12, F0_22, F2_22, F4_22]

‘dd’, ‘dd32’, ‘dd52’, ‘d32d’, ‘d32d32’, ‘d32d52’, ‘d52d’, ‘d52d32’, ‘d52d52’, ‘t2gd’, ‘t2gd32’, ‘t2gd52’:

args = [F0_11, F2_11, F4_11, F0_12, F2_12, F4_12, G0_12, G2_12, G4_12, F0_22, F2_22, F4_22]

‘fd’, ‘fd32’, ‘fd52’, ‘f52d’, ‘f52d32’, ‘f52d52’, ‘f72d’, ‘f72d32’, ‘f72d52’:

args = [F0_11, F2_11, F4_11, F6_11, F0_12, F2_12, F4_12, G1_12, G3_12, G5_12, F0_22, F2_22, F4_22]

‘sf’, ‘sf52’, ‘sf72’:

args = [F0_11, F0_12, G3_12, F0_22, F2_22, F4_22, F6_22]

‘pf’, ‘pf52’, ‘pf72’, ‘p12f’, ‘p12f52’, ‘p12f72’, ‘p32f’, ‘p32f52’, ‘p32f72’:

args = [F0_11, F2_11, F0_12, F2_12, G2_12, G4_12, F0_22, F2_22, F4_22, F6_22]

‘df’, ‘df52’, ‘df72’, ‘d32f’, ‘d32f52’, ‘d32f72’, ‘d52f’, ‘d52f52’, ‘d52f72’, ‘t2gf’, ‘t2gf52’, ‘t2gf72’:

args = [F0_11, F2_11, F4_11, F0_12, F2_12, F4_12, G1_12, G3_12, G5_12, F0_22, F2_22, F4_22, F6_22]

‘ff’, ‘ff52’, ‘ff72’, ‘f52f’, ‘f52f52’, ‘f52f72’, ‘f72f’, ‘f72f52’, ‘f72f72’:

args = [F0_11, F2_11, F4_11, F6_11, F0_12, F2_12, F4_12, F6_12, G0_12, G2_12, G4_12, G6_12, F0_22, F2_22, F4_22, F6_22]

Returns:

umat: 4d array of complex: the Coulomb interaction tensor

See also

coulomb_utensor.umat_slater
coulomb_utensor.get_umat_kanamori
coulomb_utensor.get_umat_kanamori_ge

Examples

>>> import edrixs
>>> F0_dd, F2_dd, F4_dd = 3.0, 1.0, 0.5
>>> F0_dp, F2_dp, G1_dp, G3_dp = 2.0, 1.0, 0.2, 0.1
>>> F0_pp, F2_pp = 0.0, 0.0
>>> slater = [F0_dd, F2_dd, F4_dd, F0_dp, F2_dp, G1_dp, G3_dp, F0_pp, F2_pp]
>>> umat_d = edrixs.get_umat_slater('d', F0_dd, F2_dd, F4_dd)
>>> umat_dp = edrixs.get_umat_slater('dp', *slater)
>>> umat_t2gp = edrixs.get_umat_slater('t2gp', *slater)
>>> umat_dp32 = edrixs.get_umat_slater('dp32', *slater)

edrixs.coulomb_utensor.get_umat_slater_3shells(shell_name, *args)[source]

Given three shells, build the slater type of Coulomb tensors among the three shells.

Parameters:

shell_name: tuple of three strings

Shells names.

*args: floats

Slater integrals. The order should be

FX_11, FX_12, GX_12, FX_22, FX_13, GX_13, FX_23, GX_23, FX_33

where, 1, 2, 3 means 1st, 2nd, 3rd shell, and X=0, 2, 4, … or X=1, 3, 5 …, and X should be in ascending order.

Returns:

umat: 4d complex array: Rank-4 Coulomb tensors.

edrixs.coulomb_utensor.umat_slater(l_list, fk)[source]

Calculate the Coulomb interaction tensor defined via

\[\hat{U} = \sum_{i j u t} \sum_{m_l,m_s} U_{m_{l_i}m_{s_i}, m_{l_j}m_{s_j}, m_{l_u}m_{s_u}, m_{l_t}m_{s_t}}^{i,j,u,t} \hat{f}^{\dagger}_{i} \hat{f}^{\dagger}_{j} \hat{f}_{t} \hat{f}_{u} ,\]

which is parameterized by Slater integrals \(F^{k}\):

\[U_{m_{l_i}m_{s_i}, m_{l_j}m_{s_j}, m_{l_u}m_{s_u}, m_{l_t}m_{s_t}}^{i,j,u,t} =\frac{1}{2} \delta_{m_{s_i},m_{s_t}}\delta_{m_{s_j},m_{s_u}} \delta_{m_{l_i}+m_{l_j}, m_{l_t}+m_{l_u}} \sum_{k}C_{l_i,l_t}(k,m_{l_i},m_{l_t})C_{l_u,l_j} (k,m_{l_u},m_{l_j})F^{k}_{i,j,t,u}\]

where \(m_s\) is the magnetic quantum number for spin and \(m_l\) is the magnetic quantum number for orbital. \(F^{k}_{i,j,t,u}\) are Slater integrals. \(C_{l_i,l_j}(k,m_{l_i},m_{l_j})\) are Gaunt coefficients. Note that the matrix is indexed with respect to the second quantization convention, where the last two indices in the tensor are swapped with respect to the operators so double occupancy involves matrix elements umat[i, j, j, i].

\[\]

Parameters:

l_list: list of int: contains the quantum number of orbital angular momentum \(l\) for each shell.
fk: dict of float: contains all the possible Slater integrals between the shells in l_list, the key is a tuple of 5 ints (\(k,i,j,t,u\)), where \(k\) is the order, \(i,j,t,u\) are the shell indices begin with 1.

Returns:

umat: 4d array of complex: contains the Coulomb interaction tensor.

See also

coulomb_utensor.get_umat_slater
coulomb_utensor.get_umat_kanamori
coulomb_utensor.get_umat_kanamori_ge

Examples

>>> import edrixs

For only one \(d\)-shell

>>> l_list = [2]
>>> fk={}
>>> F0, F2, F4 = 5.0, 4.0 2.0
>>> fk[(0,1,1,1,1)] = F0
>>> fk[(2,1,1,1,1)] = F2
>>> fk[(4,1,1,1,1)] = F4
>>> umat_d = edrixs.umat_slater(l_list, fk)

For one \(d\)-shell and one \(p\)-shell

>>> l_list = [2,1]
>>> fk={}
>>> F0_dd, F2_dd, F4_dd = 5.0, 4.0, 2.0
>>> F0_dp, F2_dp = 4.0, 2.0
>>> G1_dp, G3_dp = 2.0, 1.0
>>> F0_pp, F2_pp = 2.0, 1.0

>>> fk[(0,1,1,1,1)] = F0_dd
>>> fk[(2,1,1,1,1)] = F2_dd
>>> fk[(4,1,1,1,1)] = F4_dd

>>> fk[(0,1,2,1,2)] = F0_dp
>>> fk[(0,2,1,2,1)] = F0_dp
>>> fk[(2,1,2,1,2)] = F2_dp
>>> fk[(2,2,1,2,1)] = F2_dp

>>> fk[(1,1,2,2,1)] = G1_dp
>>> fk[(1,2,1,1,2)] = G1_dp
>>> fk[(3,1,2,2,1)] = G3_dp
>>> fk[(3,2,1,1,2)] = G3_dp

>>> fk[(0,2,2,2,2)] = F0_pp
>>> fk[(2,2,2,2,2)] = F2_pp

>>> umat_dp = edrixs.umat_slater(l_list, fk)