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)
# sx: s_spin[0], sy: s_spin[1], sz: s_spin[2]
s_spin = edrixs.get_spin_momentum(ll)
# jx: j_so[0], jy: j_so[1], jz: j_so[2]
j_so = l_orb + s_spin
# very small Zeeman splitting along z-direction
emat_zeeman = (l_orb[2] + s_spin[2]) * 1e-10
# many-body operators of L^2, Lz
v_orbl = 2
sx = edrixs.get_sx(v_orbl)
sy = edrixs.get_sy(v_orbl)
sz = edrixs.get_sz(v_orbl)
zeeman = ext_B[0] * (2 * sx) + ext_B[1] * (2 * sy) + ext_B[2] * (2 * sz)
emat_chb[0:norb_d, 0:norb_d] += zeeman
################################################################################
# Build the Fock basis and Hamiltonain and Diagonalize
# ------------------------------------------------------------------------------
# We create the fock basis and build the Hamiltonian using the full set of
# :math:`20` spin orbitals, specifying that they are occuplied by :math:`18`
# electrons. See the :ref:`sphx_glr_auto_examples_example_0_ed_calculator.py`
# example for more details if needed. We also set the ground state to zero
# energy.
basis = np.array(edrixs.get_fock_bin_by_N(ntot, v_noccu))
H = (edrixs.build_opers(2, emat_chb, basis) +
edrixs.build_opers(4, umat, basis))
e, v = scipy.linalg.eigh(H)
e -= e[0]
################################################################################
# State analysis
# ------------------------------------------------------------------------------
# Now we have all the eigenvectors in the Fock basis, we need to pick out the
# states that have 8, 9 and 10 :math:`d`-electrons, respectively.
# The modulus squared of these coeffcients need to be added up to get
# :math:`\alpha`, :math:`\beta`, and :math:`\gamma`.
num_d_electrons = basis[:, :norb_d].sum(1)
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
crys_spin[0:12:2, 0:12:2] = crys_tmp
crys_spin[1:12:2, 1:12:2] = crys_tmp
crys_spin[:, :] = edrixs.cb_op(crys_spin, t_spinor)
emat_i[0:12, 0:12] += crys_spin
emat_n[0, 0:12, 0:12] += crys_spin
emat_n[1, 0:12, 0:12] += crys_spin
# static core-hole potential
core_v = 2.0
for i in range(0, 6):
emat_n[0, i, i] -= core_v
for i in range(6, 12):
emat_n[1, i, i] -= core_v
basis_i = edrixs.get_fock_bin_by_N(12, 9, 12, 12)
basis_n = []
tmp = edrixs.get_fock_bin_by_N(12, 10, 6, 5, 6, 6)
basis_n.append(tmp)
tmp = edrixs.get_fock_bin_by_N(12, 10, 6, 6, 6, 5)
basis_n.append(tmp)
ncfgs_i, ncfgs_n = len(basis_i), len(basis_n[0])
hmat_i = np.zeros((ncfgs_i, ncfgs_i), dtype=np.complex128)
hmat_n = np.zeros((2, ncfgs_n, ncfgs_n), dtype=np.complex128)
print("edrixs >>> building Hamiltonian without core-hole ...")
hmat_i[:, :] += edrixs.two_fermion(emat_i, basis_i, basis_i)
hmat_i[:, :] += edrixs.four_fermion(umat_i, basis_i)
eval_i, evec_i = scipy.linalg.eigh(hmat_i)
print("edrixs >>> Done!")
# 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")
# we also use pure Python ED solver to get the eigenvalues
print("edrixs >>> building Fock basis ...")
basis_i = edrixs.get_fock_bin_by_N(norbs, noccu)
print("edrixs >>> Done!")
print("edrixs >>> building Hamiltonian ...")
H = edrixs.build_opers(2, hsoc_i, basis_i)
H += edrixs.build_opers(4, umat_i, basis_i)
print("edrixs >>> Done!")
print("edrixs >>> diagonalize Hamiltonian ...")
eval_i, evec_i = scipy.linalg.eigh(H)
edrixs.write_tensor(eval_i, "eval_i.dat", fmt_float='{:20.10f}')
print("edrixs >>> Done!")
# spectra with and without multi-orbital terms switched on for system with and
# without a cubic crystal field. We will use a :math:`d`-shell with two
# electrons.
ten_dqs = [0, 2, 4, 12]
def diagonalize(ten_dq, umat):
emat = edrixs.cb_op(edrixs.cf_cubic_d(ten_dq),
edrixs.tmat_c2r('d', ispin=True))
H = (edrixs.build_opers(4, umat, basis) +
edrixs.build_opers(2, emat, basis))
e, v = scipy.linalg.eigh(H)
return e - e.min()
basis = edrixs.get_fock_bin_by_N(10, 2)
umat_no_multiorbital = np.copy(umat)
B = F2 / 49 - 5 * F4 / 441
for val in [np.sqrt(3) * B / 2, np.sqrt(3) * B, 3 * B / 2]:
umat_no_multiorbital[(np.abs(umat) - val) < 1e-6] = 0
fig, axs = plt.subplots(1, len(ten_dqs), figsize=(8, 3))
for cind, (ax, ten_dq) in enumerate(zip(axs, ten_dqs)):
ax.hlines(diagonalize(ten_dq, umat),
xmin=0,
xmax=1,
label='on',
color=f'C{cind}')
ax.hlines(diagonalize(ten_dq, umat_no_multiorbital),
xmin=1.5,
