def get_self_energy_cf_nosoc(l_list, ispin, rotations):
'''
Get the self energy structure in the case of crystal field splitting
and without spin-orbit interaction.
'''
Jorig = get_J_generator(l_list, iso=1)
Jhalf, Uhalf, self_energy_half = atsym.get_atom_Jnew(rotations, Jorig)
if ispin == 2:
shift = np.max(self_energy_half)
else:
shift = 0
self_energy = block_diag(self_energy_half,
shift_self_energy(self_energy_half, shift))
# spin-fast-index convfention
self_energy = trans_orbital_fast_to_spin_fast(self_energy)
dim_t = Uhalf.shape[0]
J = []
for Jh1 in Jhalf:
J1 = np.zeros(self_energy.shape, dtype=np.complex)
J1[0::2, 0::2] = Jh1
J1[1::2, 1::2] = Jh1
J.append(J1)
U = np.zeros(self_energy.shape, dtype=np.complex)
U[:dim_t, 0::2] = Uhalf
U[dim_t:, 1::2] = Uhalf
return J, U, self_energy
def get_self_energy_average(l_list, ispin):
'''
Get the self energy structure in the case of negligible crystal field
splitting and without spin-orbit interaction.
'''
diag_elem = []
elem_base = 1
for l in l_list:
diag_elem += [elem_base for i in range(2 * l + 1)]
elem_base += 1
elem_base -= 1
if ispin == 2:
diag_elem += [i + elem_base for i in diag_elem]
else:
diag_elem += diag_elem
self_energy = np.diag(diag_elem)
self_energy = trans_orbital_fast_to_spin_fast(self_energy)
U = np.identity(len(self_energy), dtype=complex)
n_half = U.shape[0] / 2
utrans = np.zeros_like(U)
# Similarly transform to spin-fast convention.
utrans[:, ::2] = U[:, :n_half]
utrans[:, 1::2] = utrans[:, ::2]
return None, utrans, self_energy
def get_S_vector(l_list):
'''
Get S-vector in CSH basis with fast orbital index.
'''
Sz = get_matrix_Sz_CSH_orbital_fast(l_list)
Sp = get_matrix_Sp_CSH_spin_fast(l_list)
Sp = trans_orbital_fast_to_spin_fast(Sp, lback=True)
_, Sx, Sy = get_other_op(Sz, Sp)
return [Sx, Sy, Sz]
def get_self_energy_op_nosoc(l_list, ispin):
'''
Get the self energy structure in the case of fully orbital symmetry
breaking but with negligible spin-orbit interaction.
'''
dim_t = int(np.sum(2 * np.array(l_list) + 1) + 0.5)
m_half = np.arange(dim_t * dim_t, dtype=int) + 1
m_half = m_half.reshape((dim_t, dim_t))
if ispin == 2:
shift = np.max(m_half)
else:
shift = 0
from scipy.linalg import block_diag
self_energy = block_diag(m_half, m_half + shift)
# spin-fast-index convention
self_energy = trans_orbital_fast_to_spin_fast(self_energy)
Uhalf = np.identity(dim_t)
# {{orbs}_up, {orbs}_dn} -> {{up,dn}_{orbs}}
U = np.zeros((dim_t * 2, dim_t * 2), dtype=complex)
U[:dim_t, 0::2] = Uhalf
U[dim_t:, 1::2] = Uhalf
return None, U, self_energy