# The atomic Coulomb interactions are usually initialized based on Hartree-Fock # calculations from, for example, # `Cowan's code <https://www.tcd.ie/Physics/people/Cormac.McGuinness/Cowan/>`_. # edrixs has a database of these. info = edrixs.utils.get_atom_data('Ni', '3d', nd, edge='L3') ################################################################################ # The atomic values are typically scaled to account for screening in the solid. # Here we use 80% scaling. Let's write these out in full, so that nothing is # hidden. Values for :math:`U_{dd}` and :math:`U_{dp}` are those of Ref. [1]_ # obtained by comparing theory and experiment [2]_ [3]_. scale_dd = 0.8 F2_dd = info['slater_i'][1][1] * scale_dd F4_dd = info['slater_i'][2][1] * scale_dd U_dd = 7.3 F0_dd = U_dd + edrixs.get_F0('d', F2_dd, F4_dd) scale_dp = 0.8 F2_dp = info['slater_n'][4][1] * scale_dp G1_dp = info['slater_n'][5][1] * scale_dp G3_dp = info['slater_n'][6][1] * scale_dp U_dp = 8.5 F0_dp = U_dp + edrixs.get_F0('dp', G1_dp, G3_dp) slater = ([F0_dd, F2_dd, F4_dd], # initial [F0_dd, F2_dd, F4_dd, F0_dp, F2_dp, G1_dp, G3_dp]) # with core hole ################################################################################ # Charge-transfer energy scales # ------------------------------------------------------------------------------ # The charge-transfer :math:`\Delta` and Coulomb :math:`U_{dd}` :math:`U_{dp}`
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")
from mpi4py import MPI if __name__ == "__main__": ''' Valence shells: 3d4p, Core shell: 2p Ni :math:`L_{2,3}`-edge, :math:`2p_{1/2,3/2}\\rightarrow 3d` transition. Used to test the ed_2v1c_fort, xas_2v1c_fort, rixs_2v1c_fort solvers. How to run ---------- mpiexec -n 2 python test_2v1c.py ''' F2_dd, F4_dd = 12.234 * 0.65, 7.598 * 0.65 F0_dd = edrixs.get_F0('d', F2_dd, F4_dd) G1_d4p, G3_d4p = 5.787 * 0.7, 3.291 * 0.7 F0_d4p = edrixs.get_F0('dp', G1_d4p, G3_d4p) F2_d4p = 7.721 * 0.95 F0_4p4p, F2_4p4p = 0.0, 0.0 F2_d2p = 7.721 * 0.95 G1_d2p, G3_d2p = 5.787 * 0.7, 3.291 * 0.7 F0_d2p = edrixs.get_F0('dp', G1_d2p, G3_d2p) F0_4p2p = 2.0 F2_4p2p = 2.0 G0_4p2p = 2.0 G2_4p2p = 2.0
v_noccu=(noccu, 0), edge='L3', trans_to_which=2, label=('f', 'd', 'p')) if rank == 0: print(res, flush=True) # Slater integrals si = collections.OrderedDict(res['slater_i']) sn = collections.OrderedDict(res['slater_n']) # Initial Hamiltonian, 5f-5f si['F2_ff'] = si['F2_ff'] * 0.77 si['F4_ff'] = si['F4_ff'] * 0.77 si['F6_ff'] = si['F6_ff'] * 0.77 si['F0_ff'] = edrixs.get_F0('f', si['F2_ff'], si['F4_ff'], si['F6_ff']) # Intermediate Hamiltonian, 5f-5f sn['F2_ff'] = sn['F2_ff'] * 0.77 sn['F4_ff'] = sn['F4_ff'] * 0.77 sn['F6_ff'] = sn['F6_ff'] * 0.77 sn['F0_ff'] = edrixs.get_F0('f', sn['F2_ff'], sn['F4_ff'], sn['F6_ff']) # 5f-6d sn['F0_fd'] = edrixs.get_F0('fd', sn['G1_fd'], sn['G3_fd'], sn['G5_fd']) # 5f-2p sn['F0_fp'] = edrixs.get_F0('fp', sn['G2_fp'], sn['G4_fp']) # 6d-2p sn['F0_dp'] = edrixs.get_F0('dp', sn['G1_dp'], sn['G3_dp']) slater = (list(si.values()), list(sn.values()))
[-2.0 / 3.0, -2.0 / 3.0, +1.0 / 3.0]]).T loc_axis[1] = np.array([[+2.0 / 3.0, -1.0 / 3.0, -2.0 / 3.0], [-1.0 / 3.0, +2.0 / 3.0, -2.0 / 3.0], [+2.0 / 3.0, +2.0 / 3.0, +1.0 / 3.0]]).T loc_axis[2] = np.array([[+2.0 / 3.0, -2.0 / 3.0, -1.0 / 3.0], [+2.0 / 3.0, +1.0 / 3.0, +2.0 / 3.0], [-1.0 / 3.0, -2.0 / 3.0, +2.0 / 3.0]]).T loc_axis[3] = np.array([[-2.0 / 3.0, +2.0 / 3.0, -1.0 / 3.0], [-2.0 / 3.0, -1.0 / 3.0, +2.0 / 3.0], [+1.0 / 3.0, +2.0 / 3.0, +2.0 / 3.0]]).T # Kanamori U, J 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) F0_dd = edrixs.get_F0('d', F2_dd, F4_dd) G1_dp, G3_dp = 0.957, 0.569 F0_dp, F2_dp = edrixs.get_F0('dp', G1_dp, G3_dp), 1.107 slater = ( [F0_dd, F2_dd, F4_dd], # Initial [F0_dd, F2_dd, F4_dd, F0_dp, F2_dp, G1_dp, G3_dp] # Intermediate ) # SOC of 5d zeta_d = 0.45 # Trigonal crystal field cf = edrixs.cf_trigonal_t2g(-0.15)
import matplotlib.pyplot as plt import matplotlib as mpl import edrixs # Setup parameters # ---------------- # Number of occupancy of 3d shell noccu = 8 res = edrixs.get_atom_data('Ni', v_name='3d', v_noccu=noccu, edge='L23') name_i, slat_i = [list(i) for i in zip(*res['slater_i'])] name_n, slat_n = [list(i) for i in zip(*res['slater_n'])] # Slater integrals for initial Hamiltonian without core-hole si = edrixs.rescale(slat_i, ([1, 2], [0.65] * 2)) si[0] = edrixs.get_F0('d', si[1], si[2]) # F0_dd # Slater integrals for intermediate Hamiltonian with core-hole sn = edrixs.rescale(slat_n, ([1, 2, 4, 5, 6], [0.65, 0.65, 0.95, 0.7, 0.7])) sn[0] = edrixs.get_F0('d', sn[1], sn[2]) # F0_dd sn[3] = edrixs.get_F0('dp', sn[5], sn[6]) # F0_dp slater = (si, sn) # Spin-orbit coupling strengths zeta_d_i = res['v_soc_i'][0] # valence 3d electron without core-hole zeta_d_n = res['v_soc_n'][0] # valence 3d electron with core-hole # E_{L2} - E_{L3} = 1.5 * zeta_p zeta_p_n = (res['edge_ene'][0] - res['edge_ene'][1]) / 1.5 # core 2p electron # Tetragonal crystal field
How to run ---------- mpiexec -n 4 python run_rixs_fsolver.py ''' # PARAMETERS # ----------- # Occupancy of U 5f orbitals noccu = 6 res = edrixs.get_atom_data('Pu', v_name='5f', v_noccu=noccu, edge='O45') name_i, slat_i = [list(i) for i in zip(*res['slater_i'])] name_n, slat_n = [list(i) for i in zip(*res['slater_n'])] # Initial Hamiltonian si = edrixs.rescale(slat_i, ([1, 2, 3], [0.77] * 3)) si[0] = edrixs.get_F0('f', si[1], si[2], si[3]) # Intermediate Hamiltonian sn = edrixs.rescale(slat_n, ([1, 2, 3, 5, 6, 7, 8, 9], [0.77] * 3 + [0.6] * 4)) sn[0] = edrixs.get_F0('f', sn[1], sn[2], sn[3]) sn[4] = edrixs.get_F0('fd', sn[7], sn[8], sn[9]) slater = (si, sn) # Spin-Orbit Coupling (SOC) zeta # 5f, without core-hole, from Cowan's code zeta_f_i = res['v_soc_i'][0] * 0.9 # 5f, with core-hole, from Cowan's code zeta_f_n = res['v_soc_n'][0] * 0.9 zeta_d_n = (res['edge_ene'][0] - res['edge_ene'][1]) / 2.5
def do_ed(dq10=1.6, d1=0.1, d3=0.75, ex_x=0., ex_y=0., ex_z=0.): """ Diagonalize Hamiltonian for Ni 3d8 system in tetragonal crytals field and applied exchange field. Parameters ---------- dq10: float Cubic crystal field parameter (eV) Cubic splitting dq1: float Cubic crystal field parameter (eV) t2g splitting dq3: float Cubic crystal field parameter (eV) eg splitting ex_x: float Magnitude of the magnetic exchange field in the x direction (eV) ex_y: float Magnitude of the magnetic exchange field in the y direction (eV) ex_z: float Magnitude of the magnetic exchange field in the z direction (eV) Returns -------- eval_i: 1d array Eigenvalues of initial state Hamiltonian eval_n: 1d array Eigenvalues of intermediate state Hamiltonian dipole_op: 3d array Dipole operator from 2p to 3d state """ # PARAMETERS: # ------------ F2_dd, F4_dd = 12.234 * 0.65, 7.598 * 0.65 Ud_av = 0.0 F0_dd = Ud_av + edrixs.get_F0('d', F2_dd, F4_dd) G1_dp, G3_dp = 5.787 * 0.7, 3.291 * 0.7 F2_dp = 7.721 * 0.95 Udp_av = 0.0 F0_dp = Udp_av + edrixs.get_F0('dp', G1_dp, G3_dp) slater = ( [F0_dd, F2_dd, F4_dd], # Initial [F0_dd, F2_dd, F4_dd, F0_dp, F2_dp, G1_dp, G3_dp] # Intermediate ) zeta_d_i = 0.083 zeta_d_n = 0.102 zeta_p_n = 11.24 cf = edrixs.cf_tetragonal_d(dq10, d1, d3) ext_B = np.array([ex_x, ex_y, ex_z]) result = edrixs.ed_1v1c_py(shell_name=('d', 'p'), v_soc=(zeta_d_i, zeta_d_n), c_soc=zeta_p_n, v_noccu=8, slater=slater, ext_B=ext_B, on_which='spin', v_cfmat=cf) return result
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
def get_hopping_coulomb(): norbs = 28 Ud, JH = edrixs.UJ_to_UdJH(6, 0.45) F0_d, F2_d, F4_d = edrixs.UdJH_to_F0F2F4(Ud, JH) scale_dp = 0.9 G1_dp, G3_dp = 0.894 * scale_dp, 0.531 * scale_dp F2_dp = 1.036 * scale_dp Udp_av = 0.0 F0_dp = Udp_av + edrixs.get_F0('dp', G1_dp, G3_dp) params = [F0_d, F2_d, F4_d] umat_i = edrixs.get_umat_slater('t2g', *params) params = [F0_d, F2_d, F4_d, F0_dp, F2_dp, G1_dp, G3_dp, 0.0, 0.0] umat_tmp = edrixs.get_umat_slater('t2gp', *params) tmat = np.zeros((12, 12), dtype=np.complex128) tmat[0:6, 0:6] = edrixs.tmat_c2j(1) tmat[6:12, 6:12] = edrixs.tmat_c2j(1) umat_i[:, :, :, :] = edrixs.transform_utensor(umat_i, edrixs.tmat_c2j(1)) umat_tmp[:, :, :, :] = edrixs.transform_utensor(umat_tmp, tmat) id1 = [0, 1, 2, 3, 4, 5, 8, 9, 10, 11] id2 = [0, 1, 2, 3, 4, 5, 24, 25, 26, 27] umat_n = np.zeros((norbs, norbs, norbs, norbs), dtype=np.complex) for i in range(10): for j in range(10): for k in range(10): for ll in range(10): umat_n[id2[i], id2[j], id2[k], id2[ll]] = umat_tmp[id1[i], id1[j], id1[k], id1[ll]] emat_i = np.zeros((norbs, norbs), dtype=np.complex128) emat_n = np.zeros((norbs, norbs), dtype=np.complex128) # bath energy level & hybridization strength N_site = 3 data = np.loadtxt('bath_sites.in') e1, v1 = data[:, 0], data[:, 1] e2, v2 = data[:, 2], data[:, 3] h = np.zeros((24, 24), dtype=np.complex) h[0, 0] = h[1, 1] = -14.7627972353 h[2, 2] = h[3, 3] = h[4, 4] = h[5, 5] = -15.4689430453 for i in range(N_site): o = 6 + 6 * i # orbital j=1/2 h[o + 0, o + 0] = h[o + 1, o + 1] = e1[i] h[0, o + 0] = h[1, o + 1] = h[o + 0, 0] = h[o + 1, 1] = v1[i] # orbital j=3/2 h[o + 2, o + 2] = h[o + 3, o + 3] = h[o + 4, o + 4] = h[o + 5, o + 5] = e2[i] h[2, o + 2] = h[3, o + 3] = h[4, o + 4] = h[5, o + 5] = v2[i] h[o + 2, 2] = h[o + 3, 3] = h[o + 4, 4] = h[o + 5, 5] = v2[i] emat_i[0:24, 0:24] += h emat_n[0:24, 0:24] += h # static core-hole potential static_V = 2.0 for i in range(6): emat_n[i, i] -= static_V # Write to files # Search GS inputs edrixs.write_emat(emat_i, "search_gs/hopping_i.in") edrixs.write_umat(umat_i, "search_gs/coulomb_i.in") # 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")
#!/usr/bin/env python import scipy import numpy as np import edrixs if __name__ == "__main__": norbs = 24 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 zeta_d_i, zeta_p_n = 0.35, 1072.6666666666667 Ir_loc2g = np.zeros((2, 3, 3), dtype=np.float64) Ir_loc2g[0] = [[+0.70710678, +0.40824829, +0.57735027], [-0.70710678, +0.40824829, +0.57735027], [+0.00000000, -0.81649658, +0.57735027]] Ir_loc2g[1] = [ [-0.70710678, +0.40824829, -0.57735027], [+0.70710678, +0.40824829, -0.57735027], [+0.00000000, -0.81649658, -0.57735027], ] umat_t2g_i = edrixs.get_umat_slater('t2g', F0_d, F2_d, F4_d) umat_t2g_i = edrixs.transform_utensor(umat_t2g_i, edrixs.tmat_c2r('t2g', True)) params = [
1 impuirty site plus 3 bath sites How to run ---------- mpiexec -n 4 python run_rixs_fsolver.py """ U, J = 6.0, 0.45 # Kanamori U, J Ud, JH = edrixs.UJ_to_UdJH(U, J) F0_dd, F2_dd, F4_dd = edrixs.UdJH_to_F0F2F4(Ud, JH) scale_dp = 0.9 G1_dp, G3_dp = 0.894 * scale_dp, 0.531 * scale_dp F2_dp = 1.036 * scale_dp Udp_av = 0.0 F0_dp = Udp_av + edrixs.get_F0('dp', G1_dp, G3_dp) slater = ( [F0_dd, F2_dd, F4_dd], # initial [F0_dd, F2_dd, F4_dd, F0_dp, F2_dp, G1_dp, G3_dp]) # intermediate nbath = 3 # number of bath sites norb = 6 # number of orbitals for each site # bath energy level & hybridization strength bath_level = np.zeros((nbath, norb), dtype=np.complex) hyb = np.zeros((nbath, norb), dtype=np.complex) e1 = [-3.528372861516216, -1.207615555008166, 6.183392524170465] e2 = [-3.538890277572901, -1.308137924011529, 5.578400781316763] v1 = [2.131943931119928, 0.481470627582356, 1.618130554107574] v2 = [2.108388983547592, 0.517200653226272, 1.674013405873617]
# PARAMETERS # ----------- # The parameters used in this calculation are taken from [PRL 114, 236401 (2015)] # 14 5f-orbitals, 10 5d-orbitals (including spin) # Slater integrals # The Slater integrals are calculated by the Cowan's code: # [https://www.tcd.ie/Physics/people/Cormac.McGuinness/Cowan/] # by using Hartree-Fock mean-field method, and then re-scaled, # for example, Fff: 77%, Ffd: 60%, Gfd: 60% F2_ff, F4_ff, F6_ff = 9.711 * 0.77, 6.364 * 0.77, 4.677 * 0.77 # Here, Uf_av is the averaged Coulomb interaction in 5f shell, we set it to be zero # It doesn't matter here because we are doing single atomic calculation with fixed 5f occupancy. Uf_av = 0.0 # F0_ff is split into two parts: (1) Uf_av, (2) related to F2_f, F4_f, F6_f F0_ff = Uf_av + edrixs.get_F0('f', F2_ff, F4_ff, F6_ff) F2_fd, F4_fd = 10.652 * 0.6, 6.850 * 0.6 G1_fd, G3_fd, G5_fd = 12.555 * 0.6, 7.768 * 0.6, 5.544 * 0.6 Ufd_av = 0.0 F0_fd = Ufd_av + edrixs.get_F0('fd', G1_fd, G3_fd, G5_fd) slater = ( [F0_ff, F2_ff, F4_ff, F6_ff], # Initial [F0_ff, F2_ff, F4_ff, F6_ff, F0_fd, F2_fd, F4_fd, G1_fd, G3_fd, G5_fd] # Intermediate ) # Spin-Orbit Coupling (SOC) zeta # 5f, without core-hole, from Cowan's code zeta_f_i = 0.261 * 0.9 # 5f, with core-hole, from Cowan's code zeta_f_n = 0.274 * 0.9
# Slater parameters # ------------------------------------------------------------------------------ # Here we want to use Hund's interaction # :math:`J_H` and spin orbit coupling :math:`\lambda` as adjustable parameters # to match experiment. We will take # the core hole interaction parameter from the Hartree Fock numbers EDRIXS has # in its database. These need to be converted and arranged into the order # required by EDRIXS. Ud = 2 JH = 0.25 lam = 0.42 F0_d, F2_d, F4_d = edrixs.UdJH_to_F0F2F4(Ud, JH) info = edrixs.utils.get_atom_data('Ir', '5d', v_noccu, edge='L3') G1_dp = info['slater_n'][5][1] G3_dp = info['slater_n'][6][1] F0_dp = edrixs.get_F0('dp', G1_dp, G3_dp) F2_dp = info['slater_n'][4][1] slater_i = [F0_d, F2_d, F4_d] # Fk for d slater_n = [ 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 ] slater = [slater_i, slater_n] v_soc = (lam, lam) ################################################################################ # Diagonalization # ------------------------------------------------------------------------------
""" Do exact diagonalization of a f electronic system with 14 orbitals. You can change noccu to play with it. """ # number of orbitals 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)
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")