def cf_cubic_d(ten_dq):
"""
Given 10Dq, return cubic crystal field matrix for d orbitals
in the complex harmonics basis.
Parameters
----------
ten_dq: float scalar
The splitting between :math:`eg` and :math:`t2g` orbitals.
Returns
-------
cf: 2d complex array, shape=(10, 10)
The matrix form of crystal field Hamiltonian in complex harmonics basis.
"""
tmp = np.zeros((5, 5), dtype=np.complex)
tmp[0, 0] = 0.6 * ten_dq # dz2
tmp[1, 1] = -0.4 * ten_dq # dzx
tmp[2, 2] = -0.4 * ten_dq # dzy
tmp[3, 3] = 0.6 * ten_dq # dx2-y2
tmp[4, 4] = -0.4 * ten_dq # dxy
cf = np.zeros((10, 10), dtype=np.complex)
cf[0:10:2, 0:10:2] = tmp
cf[1:10:2, 1:10:2] = tmp
cf[:, :] = cb_op(cf, tmat_r2c('d', True))
return cf
def cf_tetragonal_d(ten_dq, d1, d3):
"""
Given 10Dq, d1, d3, return tetragonal crystal field matrix for d orbitals
in the complex harmonics basis.
Parameters
----------
ten_dq: float scalar
Parameter used to label cubic crystal splitting.
d1: float scalar
Paramter used to label tetragonal splitting.
d3: float scalar
Paramter used to label tetragonal splitting.
Returns
-------
cf: 2d complex array, shape=(10, 10)
The matrix form of crystal field Hamiltonian in complex harmonics basis.
"""
dt = (3.0 * d3 - 4.0 * d1) / 35
ds = (d3 + d1) / 7.0
dq = ten_dq / 10.0
tmp = np.zeros((5, 5), dtype=np.complex)
tmp[0, 0] = 6 * dq - 2 * ds - 6 * dt # d3z2-r2
tmp[1, 1] = -4 * dq - 1 * ds + 4 * dt # dzx
tmp[2, 2] = -4 * dq - 1 * ds + 4 * dt # dzy
tmp[3, 3] = 6 * dq + 2 * ds - 1 * dt # dx2-y2
tmp[4, 4] = -4 * dq + 2 * ds - 1 * dt # dxy
cf = np.zeros((10, 10), dtype=np.complex)
cf[0:10:2, 0:10:2] = tmp
cf[1:10:2, 1:10:2] = tmp
cf[:, :] = cb_op(cf, tmat_r2c('d', True))
return cf
def cf_trigonal_t2g(delta):
"""
Given delta, return trigonal crystal field matrix for t2g orbitals
in the complex harmonics basis.
Parameters
----------
delta: float scalar
Parameter used to label trigonal crystal splitting.
Returns
-------
cf: 2d complex array, shape=(6, 6)
The matrix form of crystal field Hamiltonian in complex harmonics basis.
"""
tmp = np.array([[0, delta, delta], [delta, 0, delta], [delta, delta, 0]])
cf = np.zeros((6, 6), dtype=np.complex)
cf[0:6:2, 0:6:2] += tmp
cf[1:6:2, 1:6:2] += tmp
cf[:, :] = cb_op(cf, tmat_r2c('t2g', True))
return cf
def get_trans_oper(case):
"""
Get the matrix of transition operators between two atomic shell in the complex
spherical harmonics basis.
Parameters
----------
case: string
A string indicating the two atomic shells, possible transitions are:
- 'ss': :math:`s \\rightarrow s`
- 'ps': :math:`s \\rightarrow p`
- 't2gs': :math:`s \\rightarrow t2g`
- 'ds': :math:`s \\rightarrow d`
- 'fs': :math:`s \\rightarrow f`
- 'sp': :math:`p \\rightarrow s`
- 'sp12': :math:`p_{1/2} \\rightarrow s`
- 'sp32': :math:`p_{3/2} \\rightarrow s`
- 'pp': :math:`p \\rightarrow p`
- 'pp12': :math:`p_{1/2} \\rightarrow p`
- 'pp32': :math:`p_{3/2} \\rightarrow p`
- 't2gp': :math:`p \\rightarrow t_{2g}`
- 't2gp12': :math:`p_{1/2} \\rightarrow t_{2g}`
- 't2gp32': :math:`p_{3/2} \\rightarrow t_{2g}`
- 'dp': :math:`p \\rightarrow d`
- 'dp12': :math:`p_{1/2} \\rightarrow d`
- 'dp32': :math:`p_{3/2} \\rightarrow d`
- 'fp': :math:`p \\rightarrow f`
- 'fp12': :math:`p_{1/2} \\rightarrow f`
- 'fp32': :math:`p_{3/2} \\rightarrow f`
- 'sd': :math:`d \\rightarrow s`
- 'sd32': :math:`d_{3/2} \\rightarrow s`
- 'sd52': :math:`d_{5/2} \\rightarrow s`
- 'pd': :math:`d \\rightarrow p`
- 'pd32': :math:`d_{3/2} \\rightarrow p`
- 'pd52': :math:`d_{5/2} \\rightarrow p`
- 't2gd': :math:`d \\rightarrow t_{2g}`
- 't2gd32': :math:`d_{3/2} \\rightarrow t_{2g}`
- 't2gd52': :math:`d_{5/2} \\rightarrow t_{2g}`
- 'dd': :math:`d \\rightarrow d`
- 'dd32': :math:`d_{3/2} \\rightarrow d`
- 'dd52': :math:`d_{5/2} \\rightarrow d`
- 'fd': :math:`d \\rightarrow f`
- 'fd32': :math:`d_{3/2} \\rightarrow f`
- 'fd52': :math:`d_{5/2} \\rightarrow f`
- 'sf': :math:`f \\rightarrow s`
- 'sf52': :math:`f_{5/2} \\rightarrow s`
- 'sf72': :math:`f_{7/2} \\rightarrow s`
- 'pf': :math:`f \\rightarrow p`
- 'pf52': :math:`f_{5/2} \\rightarrow p`
- 'pf72': :math:`f_{7/2} \\rightarrow p`
- 't2gf': :math:`f \\rightarrow t_{2g}`
- 't2gf52': :math:`f_{5/2} \\rightarrow t_{2g}`
- 't2gf72': :math:`f_{7/2} \\rightarrow t_{2g}`
- 'df': :math:`f \\rightarrow d`
- 'df52': :math:`f_{5/2} \\rightarrow d`
- 'df72': :math:`f_{7/2} \\rightarrow d`
- 'ff': :math:`f \\rightarrow f`
- 'ff52': :math:`f_{5/2} \\rightarrow f`
- 'ff72': :math:`f_{7/2} \\rightarrow f`
Returns
-------
res: 2d complex array
The calculated transition matrix.
Examples
--------
>>> import edrixs
p to d transition
>>> trans_dp = get_trans_oper('dp')
p to t2g transition
>>> trans_t2gp = get_trans_oper('t2gp')
p_{3/2} to d transition
>>> trans_dp32 = get_trans_oper('dp32')
"""
info = info_atomic_shell()
v_name, c_name = case_to_shell_name(case.strip())
v_orbl, c_orbl = info[v_name][0], info[c_name][0]
v_norb, c_norb = 2 * (2 * v_orbl + 1), 2 * (2 * c_orbl + 1)
if (v_orbl + c_orbl) % 2 == 0:
op = quadrupole_trans_oper(v_orbl, c_orbl)
else:
op = dipole_trans_oper(v_orbl, c_orbl)
# truncate to a sub-shell if necessary
special_shell = ['t2g', 'p12', 'p32', 'd32', 'd52', 'f52', 'f72']
orb_indx = {
special_shell[0]: [2, 3, 4, 5, 8, 9],
special_shell[1]: [0, 1],
special_shell[2]: [2, 3, 4, 5],
special_shell[3]: [0, 1, 2, 3],
special_shell[4]: [4, 5, 6, 7, 8, 9],
special_shell[5]: [0, 1, 2, 3, 4, 5],
special_shell[6]: [6, 7, 8, 9, 10, 11, 12, 13]
}
left_tmat = np.eye(v_norb, dtype=np.complex)
right_tmat = np.eye(c_norb, dtype=np.complex)
indx1 = list(range(0, v_norb))
indx2 = list(range(0, c_norb))
if v_name in special_shell:
if v_name == 't2g':
left_tmat[0:v_norb, 0:v_norb] = tmat_c2r('d', True)
else:
left_tmat[0:v_norb, 0:v_norb] = tmat_c2j(v_orbl)
indx1 = orb_indx[v_name]
if c_name in special_shell[1:]:
right_tmat[0:c_norb, 0:c_norb] = tmat_c2j(c_orbl)
indx2 = orb_indx[c_name]
if (v_orbl + c_orbl) % 2 == 0:
npol = 5
else:
npol = 3
op_tmp = np.zeros((npol, len(indx1), len(indx2)), dtype=np.complex)
for i in range(npol):
op[i] = cb_op2(op[i], left_tmat, right_tmat)
op_tmp[i] = op[i, indx1][:, indx2]
if v_name == 't2g':
op_tmp[i] = np.dot(np.conj(np.transpose(tmat_r2c('t2g', True))),
op_tmp[i])
res = op_tmp
return res
umat = umat_slater(l_list, fk)
# truncate to a sub-shell if necessary
if shells[0] in special_shell:
if shells[0] == 't2g':
tmat = tmat_c2r('d', True)
else:
tmat = tmat_c2j(orbl)
umat = transform_utensor(umat, tmat)
indx = orb_indx[shells[0]]
umat_tmp = np.zeros((len(indx), len(indx), len(indx), len(indx)),
dtype=np.complex)
umat_tmp[:, :, :, :] = umat[indx][:, indx][:, :, indx][:, :, :,
indx]
if shells[0] == 't2g':
umat_tmp[:, :, :, :] = transform_utensor(
umat_tmp, tmat_r2c('t2g', True))
umat = umat_tmp
# two shells
elif len(shells) == 2:
name1, name2 = shells
l1, l2 = info[name1][0], info[name2][0]
n1, n2 = 2 * (2 * l1 + 1), 2 * (2 * l2 + 1)
ntot = n1 + n2
l_list = [l1, l2]
fk = {}
it = 0
for rank in range(0, 2 * l1 + 1, 2):
fk[(rank, 1, 1, 1, 1)] = args[it]
it += 1
for rank in range(0, min(2 * l1, 2 * l2) + 1, 2):
fk[(rank, 1, 2, 1, 2)] = args[it]