def run_kanamori(max_orbitals,orbital_mixing):
for num_orbitals in range(2,max_orbitals+1):
orb_names = range(num_orbitals)
gf_struct = set_operator_structure(spin_names,orb_names,True)
mkind = get_mkind(True,None)
U = 1.0*(np.ones((num_orbitals,num_orbitals))-np.eye(num_orbitals))
Up = 2.0*np.ones((num_orbitals,num_orbitals))
J = 0.2
V = 0.3
h_k = V*np.ones((num_orbitals,num_orbitals)) if orbital_mixing else V*np.eye(num_orbitals)
h_int = h_int_kanamori(spin_names,orb_names,U,Up,J,True)
# Quantum numbers
QN = [sum([n(*mkind("up",o)) for o in orb_names],Operator()), # N_up
sum([n(*mkind("dn",o)) for o in orb_names],Operator())] # N_down
if not orbital_mixing:
# PS quantum number
QN.append(Operator())
for i, o in enumerate(orb_names):
dn = n(*mkind("up",o)) - n(*mkind("dn",o))
QN[2] += (2**i)*dn*dn
eig_qn,time_qn = partition(h_int,h_k,gf_struct,QN)
eig_ap,time_ap = partition(h_int,h_k,gf_struct)
model = "Kanamori, %i orbitals"%num_orbitals
if orbital_mixing: model += " (orbital mixing)"
print_line(model,2**(2*num_orbitals),(len(eig_qn),time_qn),(len(eig_ap),time_ap))
def test_quartic(verbose=False):
if verbose:
print '--> test_quartic'
num_orbitals = 2
num_spins = 2
U, J = 1.0, 0.2
up, do = 0, 1
spin_names = [up, do]
orb_names = range(num_orbitals)
U_ab, UPrime_ab = U_matrix_kanamori(n_orb=2, U_int=U, J_hund=J)
if verbose:
print 'U_ab =\n', U_ab
print 'UPrime_ab =\n', UPrime_ab
T_ab = np.array([
[1., 1.],
[1., -1.],
]) / np.sqrt(2.)
# -- Check hermitian
np.testing.assert_array_almost_equal(np.mat(T_ab) * np.mat(T_ab).H, np.eye(2))
I = np.eye(num_spins)
T_ab_spin = np.kron(T_ab, I)
H_int = h_int_kanamori(
spin_names, orb_names, U_ab, UPrime_ab, J_hund=J,
off_diag=True, map_operator_structure=None, H_dump=None)
op_imp = [c(up,0), c(do,0), c(up,1), c(do,1)]
Ht_int = operator_single_particle_transform(H_int, T_ab_spin, op_imp)
if verbose:
print 'H_int =', H_int
print 'Ht_int =', Ht_int
from transform_kanamori import h_int_kanamori_transformed
Ht_int_ref = h_int_kanamori_transformed(
[T_ab, T_ab], spin_names, orb_names, U_ab, UPrime_ab, J_hund=J,
off_diag=True, map_operator_structure=None, H_dump=None)
if verbose:
print 'Ht_int_ref =', Ht_int_ref
assert( (Ht_int_ref - Ht_int).is_zero() )
def run_kanamori(max_orbitals, orbital_mixing):
for num_orbitals in range(2, max_orbitals + 1):
orb_names = range(num_orbitals)
gf_struct = set_operator_structure(spin_names, orb_names, True)
mkind = get_mkind(True, None)
U = 1.0 * (np.ones(
(num_orbitals, num_orbitals)) - np.eye(num_orbitals))
Up = 2.0 * np.ones((num_orbitals, num_orbitals))
J = 0.2
V = 0.3
h_k = V * np.ones(
(num_orbitals,
num_orbitals)) if orbital_mixing else V * np.eye(num_orbitals)
h_int = h_int_kanamori(spin_names, orb_names, U, Up, J, True)
# Quantum numbers
QN = [
sum([n(*mkind("up", o)) for o in orb_names], Operator()), # N_up
sum([n(*mkind("dn", o)) for o in orb_names], Operator())
] # N_down
if not orbital_mixing:
# PS quantum number
QN.append(Operator())
for i, o in enumerate(orb_names):
dn = n(*mkind("up", o)) - n(*mkind("dn", o))
QN[2] += (2**i) * dn * dn
eig_qn, time_qn = partition(h_int, h_k, gf_struct, QN)
eig_ap, time_ap = partition(h_int, h_k, gf_struct)
model = "Kanamori, %i orbitals" % num_orbitals
if orbital_mixing: model += " (orbital mixing)"
print_line(model, 2**(2 * num_orbitals), (len(eig_qn), time_qn),
(len(eig_ap), time_ap))
# Definition of a 3-orbital atom
spin_names = ('up', 'dn')
orb_names = [0, 1, 2]
# Set of fundamental operators
fops = [(sn, on) for sn, on in product(spin_names, orb_names)]
# Numbers of particles with spin up/down
N_up = n('up', 0) + n('up', 1) + n('up', 2)
N_dn = n('dn', 0) + n('dn', 1) + n('dn', 2)
# Construct Hubbard-Kanamori Hamiltonian
U = 3.0 * np.ones((3, 3))
Uprime = 2.0 * np.ones((3, 3))
J_hund = 0.5
H = h_int_kanamori(spin_names, orb_names, U, Uprime, J_hund, True)
# Add chemical potential
H += -4.0 * (N_up + N_dn)
# Add hopping terms between orbitals 0 and 1 with some complex amplitude
H += 0.1j * (c_dag('up', 0) * c('up', 1) - c_dag('up', 1) * c('up', 0))
H += 0.1j * (c_dag('dn', 0) * c('dn', 1) - c_dag('dn', 1) * c('dn', 0))
# Split H into blocks and diagonalize it using N_up and N_dn quantum numbers
ad = AtomDiag(H, fops, [N_up, N_dn])
print ad.n_subspaces # Number of invariant subspaces, 4 * 4 = 16
# Now split using the total number of particles, N = N_up + N_dn
ad = AtomDiag(H, fops, [N_up + N_dn])
print ad.n_subspaces # 7
epsilon = 2.3
# Hybridization matrices
V = 2.0 * np.eye(num_orbitals) + 0.2 * (np.ones(num_orbitals) - np.eye(num_orbitals))
# Block structure of GF
spin_names = ('up','dn')
orb_names = range(num_orbitals)
gf_struct = set_operator_structure(spin_names,orb_names,True)
# Construct solver
S = SolverCore(beta=beta, gf_struct=gf_struct, n_iw=1025, n_tau=2500)
# Hamiltonian
H = h_int_kanamori(spin_names,orb_names,
np.array([[0,U-3*J],[U-3*J,0]]),
np.array([[U,U-2*J],[U-2*J,U]]),
J,True)
H += h*S_op('z',spin_names,orb_names,True)
# Set hybridization function
delta_w = GfImFreq(indices = orb_names, beta=beta)
delta_w << inverse(iOmega_n - epsilon) + inverse(iOmega_n + epsilon)
delta_w.from_L_G_R(V, delta_w, V)
S.G0_iw << inverse(iOmega_n + mu - delta_w)
# Parameters
p = {}
p["max_time"] = -1
p["random_name"] = ""
p["random_seed"] = 123 * mpi.rank + 567
p["length_cycle"] = 50
p["random_name"] = ""
p["random_seed"] = 123 * mpi.rank + 567
p["length_cycle"] = 50
p["n_warmup_cycles"] = 50000
p["n_cycles"] = 3000000
results_file_name = "kanamori" + (".qn" if use_qn else "") + ".h5"
mpi.report("Welcome to Kanamori benchmark.")
gf_struct = set_operator_structure(spin_names,orb_names,False)
mkind = get_mkind(False,None)
## Hamiltonian
H = h_int_kanamori(spin_names,orb_names,
np.array([[0,U-3*J],[U-3*J,0]]),
np.array([[U,U-2*J],[U-2*J,U]]),
J,False)
if use_qn:
QN = [sum([n(*mkind("up",o)) for o in orb_names],Operator()),
sum([n(*mkind("dn",o)) for o in orb_names],Operator())]
for o in orb_names:
dn = n(*mkind("up",o)) - n(*mkind("dn",o))
QN.append(dn*dn)
p["partition_method"] = "quantum_numbers"
p["quantum_numbers"] = QN
mpi.report("Constructing the solver...")
# Construct the solver
S = SolverCore(beta=beta, gf_struct=gf_struct, n_tau=n_tau, n_iw=n_iw)
# Definition of a 3-orbital atom
spin_names = ('up','dn')
orb_names = [0,1,2]
# Set of fundamental operators
fops = [(sn,on) for sn, on in product(spin_names,orb_names)]
# Numbers of particles with spin up/down
N_up = n('up',0) + n('up',1) + n('up',2)
N_dn = n('dn',0) + n('dn',1) + n('dn',2)
# Construct Hubbard-Kanamori Hamiltonian
U = 3.0 * np.ones((3,3))
Uprime = 2.0 * np.ones((3,3))
J_hund = 0.5
H = h_int_kanamori(spin_names, orb_names, U, Uprime, J_hund, True)
# Add chemical potential
H += -4.0 * (N_up + N_dn)
# Add hopping terms between orbitals 0 and 1 with some complex amplitude
H += 0.1j * (c_dag('up',0) * c('up',1) - c_dag('up',1) * c('up',0))
H += 0.1j * (c_dag('dn',0) * c('dn',1) - c_dag('dn',1) * c('dn',0))
# Split H into blocks and diagonalize it using N_up and N_dn quantum numbers
ad = AtomDiag(H, fops, [N_up,N_dn])
print ad.n_subspaces # Number of invariant subspaces, 4 * 4 = 16
# Now split using the total number of particles, N = N_up + N_dn
ad = AtomDiag(H, fops, [N_up+N_dn])
print ad.n_subspaces # 7
U = 2.4
J = 0.6
from pytriqs.operators.util.U_matrix import U_matrix_kanamori, U_matrix
from pytriqs.operators.util.hamiltonians import h_int_kanamori
orb_names = [0, 1]
spin_names = ['up', 'do']
U_ab, UPrime_ab = U_matrix_kanamori(n_orb=len(orb_names), U_int=U, J_hund=J)
H_int = h_int_kanamori(spin_names,
orb_names,
U_ab,
UPrime_ab,
J_hund=J,
off_diag=False,
map_operator_structure=None,
H_dump=None) # orbital diag
print 'H_int =\n', H_int
# ----------------------------------------------------------------------
# -- RPA rank 4 (antisymmetrized) interaction tensor
from triqs_tprf.rpa_tensor import get_rpa_tensor
from triqs_tprf.rpa_tensor import fundamental_operators_from_gf_struct
gf_struct = [['up_0', [0]], ['do_0', [0]], ['up_1', [0]], ['do_1', [0]]]
fundamental_operators = fundamental_operators_from_gf_struct(gf_struct)
print 'T_bath =\n', T_bath
V = block_diag(V, V)
T_imp = block_diag(T_imp, T_imp)
T_bath = block_diag(T_bath, T_bath)
print 'V =\n', V
print 'T_imp =\n', T_imp
print 'T_bath =\n', T_bath
T = np.block([[T_imp, V], [V.T, T_bath]])
print 'T =\n', T
H_int = h_int_kanamori(spin_names, imp_idxs,
np.array([[0, U - 3 * J], [U - 3 * J, 0]]),
np.array([[U, U - 2 * J], [U - 2 * J, U]]), J, True)
H = H_int + get_quadratic_operator(T, fop)
up, do = spin_names
index_converter = {
(up, 0): ('loc', 0, 'up'),
(do, 0): ('loc', 0, 'down'),
(up, 1): ('loc', 1, 'up'),
(do, 1): ('loc', 1, 'down'),
(up, 2): ('loc', 2, 'up'),
(do, 2): ('loc', 2, 'down'),
(up, 3): ('loc', 3, 'up'),
(do, 3): ('loc', 3, 'down'),
(up, 4): ('loc', 4, 'up'),
p.g0_tau << InverseFourier(p.g0_iw)
p.g0t_tau = g2_single_particle_transform(p.g0_tau, p.T.H)
p.g0_tau_ref = g2_single_particle_transform(p.g0t_tau, p.T)
np.testing.assert_array_almost_equal(p.g0_tau_ref.data, p.g0_tau.data)
# -- Interaction Hamiltonian: Kanamori interaction
U_ab, UPrime_ab = U_matrix_kanamori(n_orb=p.num_orbitals,
U_int=p.U,
J_hund=p.J)
H_int = h_int_kanamori(p.spin_names,
p.orb_names,
U_ab,
UPrime_ab,
J_hund=p.J,
off_diag=True,
map_operator_structure=None,
H_dump=None)
p.H_int = relabel_operators(H_int, p.spin_block_ops, p.org_ops)
# -- Complete 2site + 2bath Hamiltonian
p.H = p.H_loc + p.H_bath + p.H_int
# -- Single particle transformed Hamiltonian
p.Ht = operator_single_particle_transform(p.H, p.T, p.op_imp)
p.Ht_int = operator_single_particle_transform(p.H_int, p.T, p.op_imp)
