orbital_energies = np.array([e for orbital_energy in
[+0.6 * ten_dq, # dz2
-0.4 * ten_dq, # dzx
-0.4 * ten_dq, # dzy
+0.6 * ten_dq, # dx2-y2
-0.4 * ten_dq] # dxy)
for e in [orbital_energy]*2])
CF[diagonal_indices, diagonal_indices] = orbital_energies
################################################################################
# The valence band SOC is constructed in the normal way and transformed into the
# real harmonic basis.
soc = edrixs.cb_op(edrixs.atom_hsoc('d', zeta_d_i), edrixs.tmat_c2r('d', True))
################################################################################
# The total impurity matrices for the ground and core-hole states are then
# the sum of crystal field and spin-orbit coupling. We further needed to apply
# an energy shift along the matrix diagonal, which we do using the
# :code:`np.eye` function which creates a diagonal matrix of ones.
E_d_mat = E_d*np.eye(norb_d)
E_dc_mat = E_dc*np.eye(norb_d)
imp_mat = CF + soc + E_d_mat
imp_mat_n = CF + soc + E_dc_mat
################################################################################
# The energy level of the bath(s) is described by a matrix where the row index
# denotes which bath and the column index denotes which orbital. Here we have
# only one bath, with 10 spin-orbitals. We initialize the matrix to
get the matrix or 4-rank tensor in the single-particle basis, and then call build_opers()
to get the many-body operators.
"""
# t2g system, 6 orbitals and occupied by 2 electrons
norb = 6
noccu = 2
# Hubbard U and Hund's coupling J in the form of Kanamori Coulomb interaction
U, J = 4, 1
# Hubbard Ud and Hund's coupling JH in the form of Slater Coulomb interaction
Ud, JH = edrixs.UJ_to_UdJH(U, J)
# Slater integrals
F0, F2, F4 = edrixs.UdJH_to_F0F2F4(Ud, JH)
# Two fermion terms: spin-orbital coupling (SOC)
# The matrix is in the complex spherical Harmonics basis
soc_zeta = 0.4
emat_soc = edrixs.atom_hsoc('t2g', soc_zeta)
# Four fermion terms: Coulomb interaction
# The 4-rank tensor is in the complex spherical Harmonics basis
umat = edrixs.get_umat_slater('t2g', F0, F2, F4)
# Fock basis in the complex spherical Harmonics basis with the orbital ordering:
# |-1,up>, |-1,dn>, |0,up>, |0,dn>, |+1,up>, |+1,dn>
# basis: 2d list of integers with 1 or 0, the shape is (15, 6) in this case
# where, 15=6*5/2 is the total number of Fock basis and 6 is the total number of
# single-particle orbitals
basis = edrixs.get_fock_bin_by_N(norb, noccu)
# quantum number of orbital angular momentum for t2g: l=1
ll = 1
# Matrices of lx,ly,lz,sx,sy,sz,jx,jy,jz in the single-particle basis
# lx: l_orb[0], ly: l_orb[1], lz: l_orb[2]
l_orb = edrixs.get_orb_momentum(ll, True)
def get_hopping_coulomb(locaxis):
# Number of orbitals
nt2g, nporb, norbs = 6, 6, 24
# On-site Coulomb interaction tensor
Ud, JH = edrixs.UJ_to_UdJH(2, 0.3)
F0_d, F2_d, F4_d = edrixs.UdJH_to_F0F2F4(Ud, JH)
G1_dp, G3_dp = 0.957, 0.569
F0_dp, F2_dp = edrixs.get_F0('dp', G1_dp, G3_dp), 1.107
umat_t2g_i = edrixs.get_umat_slater('t2g', F0_d, F2_d, F4_d)
params = [
F0_d,
F2_d,
F4_d, # Fk for d
F0_dp,
F2_dp, # Fk for dp
G1_dp,
G3_dp, # Gk for dp
0.0,
0.0 # Fk for p
]
umat_t2gp_n = edrixs.get_umat_slater('t2gp', *params)
# static core-hole potential
static_v = 2.0
for i in range(0, nt2g):
for j in range(nt2g, nt2g + nporb):
umat_t2gp_n[i, j, j, i] += static_v
umat_i = np.zeros((norbs, norbs, norbs, norbs), dtype=np.complex128)
umat_n = np.zeros((norbs, norbs, norbs, norbs), dtype=np.complex128)
umat_i[0:6, 0:6, 0:6, 0:6] = umat_t2g_i
umat_i[6:12, 6:12, 6:12, 6:12] = umat_t2g_i
indx = np.array([[0, 1, 2, 3, 4, 5, 12, 13, 14, 15, 16, 17],
[6, 7, 8, 9, 10, 11, 18, 19, 20, 21, 22, 23]])
for m in range(2):
for i in range(12):
for j in range(12):
for k in range(12):
for l in range(12):
umat_n[indx[m, i], indx[m, j], indx[m, k],
indx[m, l]] += umat_t2gp_n[i, j, k, l]
emat_i = np.zeros((norbs, norbs), dtype=np.complex128)
emat_n = np.zeros((norbs, norbs), dtype=np.complex128)
# SOC
zeta_d_i, zeta_p_n = 0.35, 1072.6666666666667
soc_d = edrixs.atom_hsoc('t2g', zeta_d_i)
soc_p = edrixs.atom_hsoc('p', zeta_p_n)
emat_i[0:6, 0:6] += soc_d
emat_i[6:12, 6:12] += soc_d
emat_n[0:6, 0:6] += soc_d
emat_n[6:12, 6:12] += soc_d
emat_n[12:18, 12:18] += soc_p
emat_n[18:24, 18:24] += soc_p
for i in range(2 * nt2g):
emat_n[i, i] -= 6 * static_v
# Crystal field and hoppings between the two Ir-sites
t1, t2, delta = -0.18, 0.036, -0.03
# Uncomment the following line to do calculation without hopping and crystal filed splitting.
# t1, t2, delta = 0, 0, -0.03
crys_tmp = np.array(
[[0, delta, delta, t1, t2, t1], [delta, 0, delta, t2, t1, t1],
[delta, delta, 0, t1, t1, t2], [t1, t2, t1, 0, delta, delta],
[t2, t1, t1, delta, 0, delta], [t1, t1, t2, delta, delta, 0]],
dtype=np.complex)
# transform spin to local axis
dmat = np.zeros((2, 2, 2), dtype=np.complex128)
ang1, ang2, ang3 = edrixs.rmat_to_euler(locaxis[0])
dmat[0] = edrixs.dmat_spinor(ang1, ang2, ang3)
ang1, ang2, ang3 = edrixs.rmat_to_euler(locaxis[1])
dmat[1] = edrixs.dmat_spinor(ang1, ang2, ang3)
t_spinor = np.zeros((12, 12), dtype=np.complex128)
for i in range(2):
off = i * 6
t_spinor[off + 0:off + 2, off + 0:off + 2] = dmat[i]
t_spinor[off + 2:off + 4, off + 2:off + 4] = dmat[i]
t_spinor[off + 4:off + 6, off + 4:off + 6] = dmat[i]
crys_spin = np.zeros((12, 12), dtype=np.complex128)
crys_spin[0:12:2, 0:12:2] = crys_tmp
crys_spin[1:12:2, 1:12:2] = crys_tmp
t_orb = np.zeros((12, 12), dtype=np.complex128)
t_orb[0:6, 0:6] = edrixs.tmat_r2c('t2g', True)
t_orb[6:12, 6:12] = edrixs.tmat_r2c('t2g', True)
crys_spin[:, :] = edrixs.cb_op(crys_spin, np.dot(t_spinor, t_orb))
emat_i[0:12, 0:12] += crys_spin
emat_n[0:12, 0:12] += crys_spin
# Write to files
# ED inputs
edrixs.write_emat(emat_i, "ed/hopping_i.in")
edrixs.write_umat(umat_i, "ed/coulomb_i.in")
# XAS inputs
edrixs.write_emat(emat_n, "xas/hopping_n.in")
edrixs.write_umat(umat_n, "xas/coulomb_n.in")
# RIXS inputs
edrixs.write_emat(emat_i, "rixs_pp/hopping_i.in")
edrixs.write_umat(umat_i, "rixs_pp/coulomb_i.in")
edrixs.write_emat(emat_n, "rixs_pp/hopping_n.in")
edrixs.write_umat(umat_n, "rixs_pp/coulomb_n.in")
edrixs.write_emat(emat_i, "rixs_ps/hopping_i.in")
edrixs.write_umat(umat_i, "rixs_ps/coulomb_i.in")
edrixs.write_emat(emat_n, "rixs_ps/hopping_n.in")
edrixs.write_umat(umat_n, "rixs_ps/coulomb_n.in")
_ = ax.set_xticks([])
################################################################################
# We see Hund's rules in action! Rule 1 says that the highest spin :math:`S=1`
# state has the lowest energy. Of the two :math:`S=1` states, the state with
# larger :math:`L=1` is lower energy following rule 2.
################################################################################
# Spin orbit coupling
# ------------------------------------------------------------------------------
# For fun, we can see how this changes when we add spin orbit coupling (SOC).
# This is a two-fermion operator that we create, transform into the Fock basis
# and add to the prior Hamiltonian. To make things easy, let us make the SOC
# small so that the LS coupling approximation is valid and we can
# still track the states.
soc = edrixs.atom_hsoc('p', 0.1)
n_fermion = 2
H2 = H + edrixs.build_opers(n_fermion, soc, basis)
################################################################################
# Then, we redo the diagonalization and print the results.
e2, v2 = scipy.linalg.eigh(H2)
e2 = np.round(e2, decimals=6)
degeneracy2 = [sum(eval == e2) for eval in e2]
print()
message = "With SOC\n {:<3s}\t{:>8s}\t{:>8s}\t{:>8s}\t{:>8s}\t{:>8s}"
print(message.format("#", "E", "S(S+1)", "L(L+1)", "J(J+1)", "degen."))
J2_val_soc = edrixs.cb_op(J2, v2).diagonal().real
L2_val_soc = edrixs.cb_op(L2, v2).diagonal().real
S2_val_soc = edrixs.cb_op(S2, v2).diagonal().real
for i, eigenvalue in enumerate(e2):
def ed():
# 1-10: Ni-3d valence orbitals, 11-16: Ni-2p core orbitals
# Single particle basis: complex shperical Harmonics
ndorb, nporb, ntot = 10, 6, 16
emat_i = np.zeros((ntot, ntot), dtype=np.complex)
emat_n = np.zeros((ntot, ntot), dtype=np.complex)
# 4-index Coulomb interaction tensor, parameterized by
# Slater integrals, which are obtained from Cowan's code
F2_d, F4_d = 7.9521, 4.9387
# Averaged dd Coulomb interaction is set to be zero
F0_d = edrixs.get_F0('d', F2_d, F4_d)
G1_dp, G3_dp = 4.0509, 2.3037
# Averaged dp Coulomb interaction is set to be zero
F0_dp, F2_dp = edrixs.get_F0('dp', G1_dp, G3_dp), 7.33495
umat_i = edrixs.get_umat_slater(
'dp',
F0_d,
F2_d,
F4_d, # dd
0,
0,
0,
0, # dp
0,
0) # pp
umat_n = edrixs.get_umat_slater(
'dp',
F0_d,
F2_d,
F4_d, # dd
F0_dp,
F2_dp,
G1_dp,
G3_dp, # dp
0,
0) # pp
# Atomic spin-orbit coupling
zeta_d, zeta_p = 0.083, 11.24
emat_i[0:ndorb, 0:ndorb] += edrixs.atom_hsoc('d', zeta_d)
emat_n[0:ndorb, 0:ndorb] += edrixs.atom_hsoc('d', zeta_d)
emat_n[ndorb:ntot, ndorb:ntot] += edrixs.atom_hsoc('p', zeta_p)
# Tetragonal crystal field splitting terms,
# which are first defined in the real cubic Harmonics basis,
# and then transformed to complex shperical Harmonics basis.
dt, ds, dq = 0.011428, 0.035714, 0.13
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
tmp[:, :] = edrixs.cb_op(tmp, edrixs.tmat_r2c('d'))
emat_i[0:ndorb:2, 0:ndorb:2] += tmp
emat_i[1:ndorb:2, 1:ndorb:2] += tmp
emat_n[0:ndorb:2, 0:ndorb:2] += tmp
emat_n[1:ndorb:2, 1:ndorb:2] += tmp
# Build Fock basis in its binary form
basis_i = edrixs.get_fock_bin_by_N(ndorb, 8, nporb, nporb)
basis_n = edrixs.get_fock_bin_by_N(ndorb, 9, nporb, nporb - 1)
ncfg_i, ncfg_n = len(basis_i), len(basis_n)
# Build many-body Hamiltonian in Fock basis
hmat_i = np.zeros((ncfg_i, ncfg_i), dtype=np.complex)
hmat_n = np.zeros((ncfg_n, ncfg_n), dtype=np.complex)
hmat_i[:, :] += edrixs.two_fermion(emat_i, basis_i, basis_i)
hmat_i[:, :] += edrixs.four_fermion(umat_i, basis_i)
hmat_n[:, :] += edrixs.two_fermion(emat_n, basis_n, basis_n)
hmat_n[:, :] += edrixs.four_fermion(umat_n, basis_n)
# Do exact-diagonalization to get eigenvalues and eigenvectors
eval_i, evec_i = np.linalg.eigh(hmat_i)
eval_n, evec_n = np.linalg.eigh(hmat_n)
# Build dipolar transition operators
dipole = np.zeros((3, ntot, ntot), dtype=np.complex)
T_abs = np.zeros((3, ncfg_n, ncfg_i), dtype=np.complex)
T_emi = np.zeros((3, ncfg_i, ncfg_n), dtype=np.complex)
tmp = edrixs.get_trans_oper('dp')
for i in range(3):
dipole[i, 0:ndorb, ndorb:ntot] = tmp[i]
# First, in the Fock basis
T_abs[i] = edrixs.two_fermion(dipole[i], basis_n, basis_i)
# Then, transfrom to the eigenvector basis
T_abs[i] = edrixs.cb_op2(T_abs[i], evec_n, evec_i)
T_emi[i] = np.conj(np.transpose(T_abs[i]))
return eval_i, eval_n, T_abs, T_emi
indx = np.array([[0, 1, 2, 3, 4, 5, 12, 13, 14, 15, 16, 17],
[6, 7, 8, 9, 10, 11, 18, 19, 20, 21, 22, 23]])
for m in range(2):
for i in range(12):
for j in range(12):
for k in range(12):
for l in range(12):
umat_n[m, indx[m, i], indx[m, j], indx[m, k],
indx[m, l]] += umat_t2gp_n[i, j, k, l]
emat_i = np.zeros((norbs, norbs), dtype=np.complex128)
emat_n = np.zeros((2, norbs, norbs), dtype=np.complex128)
soc_d = edrixs.cb_op(edrixs.atom_hsoc('t2g', zeta_d_i),
edrixs.tmat_c2r('t2g', True))
soc_p = edrixs.cb_op(edrixs.atom_hsoc('p', zeta_p_n),
edrixs.tmat_c2r('p', True))
emat_i[0:6, 0:6] += soc_d
emat_i[6:12, 6:12] += soc_d
emat_n[0, 0:6, 0:6] += soc_d
emat_n[0, 6:12, 6:12] += soc_d
emat_n[0, 12:18, 12:18] += soc_p
emat_n[1, 0:6, 0:6] += soc_d
emat_n[1, 6:12, 6:12] += soc_d
emat_n[1, 18:24, 18:24] += soc_p
# crystal field and hopping between the two Ir atom
a, b, c = -0.18, 0.036, -0.03
norbs = 14
# number of occupancy, change this number and re-run it to see how it will change.
noccu = 7
# Slater integrals: FX, x=0, 2, 4, 2*3=6
F2_f, F4_f, F6_f = 9.711 * 0.77, 6.364 * 0.77, 4.677 * 0.77
# set the average Coulomb interaction energy Uf_ave to zero
Uf_av = 0.0
F0_f = Uf_av + edrixs.get_F0('f', F2_f, F4_f, F6_f)
# get rank-4 Coulomb U-tensor
params = [F0_f, F2_f, F4_f, F6_f]
umat_i = edrixs.get_umat_slater('f', *params)
# SOC strength
zeta_f_i = 0.261 * 0.9
hsoc_i = edrixs.atom_hsoc('f', zeta_f_i)
# prepare files for ed.x
# write control parameters to file
edrixs.write_config(ed_solver=2,
num_val_orbs=norbs,
neval=100,
ncv=200,
nvector=1,
idump=True)
# write nonzeros terms of two-fermion terms hsoc_i to file 'hopping_i.in', read by ed.x
edrixs.write_emat(hsoc_i, 'hopping_i.in', 1E-10)
# write nonzeros terms of four-fermion terms umat to file 'coulomb_i.in', read by ed.x
edrixs.write_umat(umat_i, 'coulomb_i.in', 1E-10)
# write fock basis of decimal format to file 'fock_i.in', read by ed.x
edrixs.write_fock_dec_by_N(norbs, noccu, "fock_i.in")
def get_hopping_coulomb(locaxis):
# Number of orbitals for each site
ndorb, nporb = 6, 4
# Number of sites
nsite = 2
# Total number of orbitals
ntot = nsite * (ndorb + nporb)
# orbital orders:
# 0-5: 1st-site-t2g
# 6-11: 2nd-site-t2g
# 12-15: 1st-site-2p
# 16-19: 2nd-site-2p
# On-site Coulomb interaction tensor
U, J = 2.0, 0.3
Ud, JH = edrixs.UJ_to_UdJH(U, J)
F0_dd, F2_dd, F4_dd = edrixs.UdJH_to_F0F2F4(Ud, JH) # k=0, 2, 2*l
G1_dp, G3_dp = 0.957, 0.569 # k=|2-1|, |2+1|
F0_dp, F2_dp = edrixs.get_F0('dp', G1_dp,
G3_dp), 1.107 # k=0, min(2*2, 2*1)
# just one site t2g-subspace
umat_tmp_i = edrixs.get_umat_slater('t2g', F0_dd, F2_dd, F4_dd)
params = [
F0_dd,
F2_dd,
F4_dd, # FX for dd
F0_dp,
F2_dp, # FX for dp
G1_dp,
G3_dp, # GX for dp
0,
0 # FX for pp
]
# just one site
umat_tmp_n = edrixs.get_umat_slater('t2gp32', *params) # 2p_3/2 -> t2g
# static core-hole potential
static_v = 2.0
for i in range(0, ndorb):
for j in range(ndorb, ndorb + nporb):
umat_tmp_n[i, j, j, i] += static_v
# two sites as a whole
umat_i = np.zeros((ntot, ntot, ntot, ntot), dtype=np.complex)
umat_n = np.zeros((ntot, ntot, ntot, ntot), dtype=np.complex)
umat_i[0:ndorb, 0:ndorb, 0:ndorb,
0:ndorb] = umat_tmp_i # 1st site 5d-valence
umat_i[ndorb:2 * ndorb, ndorb:2 * ndorb, ndorb:2 * ndorb,
ndorb:2 * ndorb] = umat_tmp_i # 2nd site 5d-valence
indx = np.array([
[
0,
1,
2,
3,
4,
5, # orbital indices for 1st site 5d-t2g
12,
13,
14,
15
], # orbital indices for 1st site 2p-core
[
6,
7,
8,
9,
10,
11, # orbital indices for 2nd site 5d-t2g
16,
17,
18,
19
] # orbital indices for 2nd site 2p-core
])
# copy umat_tmp_n (one site) to umat_n (two sites)
ndp = ndorb + nporb
for m in range(nsite):
for i in range(ndp):
for j in range(ndp):
for k in range(ndp):
for l in range(ndp):
umat_n[indx[m, i], indx[m, j], indx[m, k],
indx[m, l]] += umat_tmp_n[i, j, k, l]
# two fermion terms, SOC, crystal field, and hopping between the two sites
emat_i = np.zeros((ntot, ntot), dtype=np.complex)
emat_n = np.zeros((ntot, ntot), dtype=np.complex)
# SOC
zeta_d_i = 0.35
soc_d = edrixs.atom_hsoc('t2g', zeta_d_i)
emat_i[0:ndorb, 0:ndorb] += soc_d
emat_i[ndorb:2 * ndorb, ndorb:2 * ndorb] += soc_d
emat_n[0:ndorb, 0:ndorb] += soc_d
emat_n[ndorb:2 * ndorb, ndorb:2 * ndorb] += soc_d
# Terms from static core-hole potential
for i in range(2 * ndorb):
emat_n[i, i] -= nporb * static_v
# Crystal field and hoppings between the two Ir-sites
d = -0.03 # trgional splitting in t2g-subspace
# Uncomment the following line to do calculation without hopping and crystal filed splitting.
t1, t2 = -0.18, 0.036 # hopping between the two-sites in t2g-subspace
cf_tmp = np.array([ # dzx_1, dzy_1, dxy_1, dzx_2, dzy_2, dxy_2
[0, d, d, t1, t2, t1], # dzx_1
[d, 0, d, t2, t1, t1], # dzy_1
[d, d, 0, t1, t1, t2], # dxy_1
[t1, t2, t1, 0, d, d], # dzx_2
[t2, t1, t1, d, 0, d], # dzy_2
[t1, t1, t2, d, d, 0], # dxy_2
])
# Including spin degree of freedom, in global axis
cf_spin = np.zeros((2 * ndorb, 2 * ndorb), dtype=np.complex)
cf_spin[0:2 * ndorb:2, 0:2 * ndorb:2] = cf_tmp
cf_spin[1:2 * ndorb:2, 1:2 * ndorb:2] = cf_tmp
# Transform spin basis to local axis
# 1/2-spinor matrix
t_spinor = np.zeros((2 * ndorb, 2 * ndorb), dtype=np.complex128)
for i in range(nsite):
alpha, beta, gamma = edrixs.rmat_to_euler(locaxis[i])
dmat = edrixs.dmat_spinor(alpha, beta, gamma)
for j in range(ndorb // 2):
off = i * ndorb + j * 2
t_spinor[off:off + 2, off:off + 2] = dmat
# Transform orbital basis from real cubic to complex harmonics
t_orb = np.zeros((2 * ndorb, 2 * ndorb), dtype=np.complex128)
t_orb[0:ndorb, 0:ndorb] = edrixs.tmat_r2c('t2g', True)
t_orb[ndorb:2 * ndorb, ndorb:2 * ndorb] = edrixs.tmat_r2c('t2g', True)
# Do the tranformation
cf_spin[:, :] = edrixs.cb_op(cf_spin, np.dot(t_spinor, t_orb))
emat_i[0:2 * ndorb, 0:2 * ndorb] += cf_spin
emat_n[0:2 * ndorb, 0:2 * ndorb] += cf_spin
# Write emat and umat to files
# ED inputs
edrixs.write_emat(emat_i, "ed/hopping_i.in")
edrixs.write_umat(umat_i, "ed/coulomb_i.in")
# XAS inputs
edrixs.write_emat(emat_n, "xas/hopping_n.in")
edrixs.write_umat(umat_n, "xas/coulomb_n.in")
# RIXS inputs
edrixs.write_emat(emat_i, "rixs_pp/hopping_i.in")
edrixs.write_umat(umat_i, "rixs_pp/coulomb_i.in")
edrixs.write_emat(emat_n, "rixs_pp/hopping_n.in")
edrixs.write_umat(umat_n, "rixs_pp/coulomb_n.in")
edrixs.write_emat(emat_i, "rixs_ps/hopping_i.in")
edrixs.write_umat(umat_i, "rixs_ps/coulomb_i.in")
edrixs.write_emat(emat_n, "rixs_ps/hopping_n.in")
edrixs.write_umat(umat_n, "rixs_ps/coulomb_n.in")