예제 #1
0
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")
예제 #2
0
# t2g orbitals, dxz, dyz, dxy, :math:`\\hat{d}^{\\dagger}_{\\alpha}\\hat{d}_{\\alpha}`
# First, write their matrice in the real harmonics basis
# |dxz,up>, |dxz,dn>, |dyz,up>, |dyz,dn>, |dxy,up>, |dxy,dn>
# In this basis, they take simple form, only the diagonal terms have element 1
nd_oper = np.zeros((norb, norb, norb), dtype=np.complex)
nd_oper[0, 0, 0] = 1
nd_oper[1, 1, 1] = 1
nd_oper[2, 2, 2] = 1
nd_oper[3, 3, 3] = 1
nd_oper[4, 4, 4] = 1
nd_oper[5, 5, 5] = 1
# Then transform to the complex harmonics basis
# |-1,up>, |-1,dn>, |0,up>, |0,dn>, |+1,up>, |+1,dn>
# comment the following line to calculate the occupancy number
# of the complex harmonics orbitals
nd_oper = edrixs.cb_op(nd_oper, edrixs.tmat_r2c('t2g', True))
# Build the many-body operators for nd
nd_manybody_oper = edrixs.build_opers(2, nd_oper, basis)

# Build many-body Hamiltonian for four-fermion terms in the Fock basis
# H has the dimension of 15*15
H_U = edrixs.build_opers(4, umat, basis)
# Build many-body Hamiltonian for two-fermion terms in the Fock basis
H_soc = edrixs.build_opers(2, emat_soc, basis)
H_zeeman = edrixs.build_opers(2, emat_zeeman, basis)

# The scipy diagonalization returns eigenvalues in ascending order, each repeated according
# to its multiplicity. eigenvectors are returned as a set of column vectors.
# eigenvalue eigenval[n] is associated with eignevector eigenvec[:, n]
# case 1: without SOC
H = H_U + H_zeeman
예제 #3
0
# :math:`|3z^2-r^2,\uparrow>`, :math:`|3z^2-r^2,\downarrow>`,
# :math:`|zx,\uparrow>`, :math:`|zx,\downarrow>`, etc.
# In this basis, they take a simple form: only the diagonal terms have element
# 1. We therefore make a 3D empty array and assign the diagonal as 1. Check
# out the
# `numpy indexing notes <https://numpy.org/doc/stable/reference/arrays.indexing.html>`_
# if needed.
nd_real_harmoic_basis = np.zeros((norb, norb, norb), dtype=np.complex)
indx = np.arange(norb)
nd_real_harmoic_basis[indx, indx, indx] = 1

################################################################################
# Recalling the necessity to put everything in the same basis, we transform
# into the complex harmonic basis and then transform into our Fock basis
nd_complex_harmoic_basis = edrixs.cb_op(nd_real_harmoic_basis,
                                        edrixs.tmat_r2c('d', True))
nd_op = edrixs.build_opers(2, nd_complex_harmoic_basis, basis)

################################################################################
# We apply the operator and print out as follows. Check the
# `numpy docs <https://numpy.org/doc/1.18/reference/generated/numpy.reshape.html>`_
# if the details of how the spin pairs have been added up is not immediately
# transparent.
nd_expt = np.array(
    [edrixs.cb_op(nd_vec, v).diagonal().real for nd_vec in nd_op])

message = "{:>3s}" + "\t{:>6s}" * 5
print(message.format(*"E 3z2-r2 zx zy x2-y2 xy".split(" ")))

message = "{:>3.1f}" + "\t{:>6.1f}" * 5
for evalue, row in zip(e, nd_expt.T):
예제 #4
0
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(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")