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 which is parameterized by Slater integrals \(F^{k}\):

\[U_{m_{l_i}m_{s_i}, m_{l_j}m_{s_j}, m_{l_t}m_{s_t}, m_{l_u}m_{s_u}}^{i,j,t,u} =\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.

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)