def setup_dmft_calculation(p): p = copy.deepcopy(p) p.iter = 0 # -- Local Hubbard interaction from pytriqs.operators import n p.solve.h_int = p.U*n('up', 0)*n('do', 0) - 0.5*p.U*(n('up', 0) + n('do', 0)) # -- 2D square lattice w. nearest neighbour hopping t from triqs_tprf.tight_binding import TBLattice T = -p.t * np.eye(2) H = TBLattice( units = [(1, 0, 0), (0, 1, 0)], orbital_positions = [(0,0,0)]*2, orbital_names = ['up', 'do'], hopping = {(0, +1) : T, (0, -1) : T, (+1, 0) : T, (-1, 0) : T}) p.e_k = H.on_mesh_brillouin_zone(n_k = (p.n_k, p.n_k, 1)) # -- Initial zero guess for the self-energy p.sigma_w = Gf(mesh=MeshImFreq(p.init.beta, 'Fermion', p.init.n_iw), target_shape=[2, 2]) p.sigma_w.zero() return p
def get_static_observables(parms, spin_names, flavor_names): ret = { 'N' : triqs_ops.Operator(), 'Sz' : triqs_ops.Operator(), } for sn, s in enumerate(spin_names): for o in flavor_names: sp = mkind(s, o) ret['N'] += triqs_ops.n(*sp) ret['Sz'] += (-1)**sn * triqs_ops.n(*sp) return ret
def get_quantum_numbers(parms, spin_names, flavor_names, is_kanamori): qn = [] for s in spin_names: tmp = triqs_ops.Operator() for o in flavor_names: tmp += triqs_ops.n(*mkind(s, o)) qn.append(tmp) if is_kanamori: for o in flavor_names: dn = triqs_ops.n(*mkind(spin_names[0], o))\ - triqs_ops.n(*mkind(spin_names[1],o)) qn.append(dn*dn) return qn
p = {} p["max_time"] = -1 p["random_name"] = "" p["random_seed"] = 123 * mpi.rank + 567 p["length_cycle"] = 50 p["n_warmup_cycles"] = 20000 p["n_cycles"] = 1000000 p["performance_analysis"] = True p["measure_pert_order"] = True # Block structure of GF gf_struct = [['up', [0]], ['dn', [0]]] # Hamiltonian H = U * n("up", 0) * n("dn", 0) # Quantum numbers qn = [n("up", 0), n("dn", 0)] p["partition_method"] = "quantum_numbers" p["quantum_numbers"] = qn # Construct solver S = SolverCore(beta=beta, gf_struct=gf_struct, n_tau=n_tau, n_iw=n_iw) def read_histo(f, type_of_col_1): histo = [] for line in f: cols = filter(lambda s: s, line.split(' ')) histo.append((type_of_col_1(cols[0]), float(cols[1]), float(cols[2])))
n_iw=1025, n_tau=2500, n_l=20) solver = SolverCore(**cp) # Set hybridization function mu = 0.5 half_bandwidth = 1.0 delta_w = GfImFreq(indices=[0], beta=cp['beta']) delta_w << (half_bandwidth / 2.0)**2 * SemiCircular(half_bandwidth) for name, g0 in solver.G0_iw: g0 << inverse(iOmega_n + mu - delta_w) sp = dict( h_int=n('up', 0) * n('do', 0) + c_dag('up', 0) * c('do', 0) + c_dag('do', 0) * c('up', 0), max_time=-1, length_cycle=50, n_warmup_cycles=50, n_cycles=500, move_double=False, ) solver.solve(**sp) filename = 'h5_read_write.h5' with HDFArchive(filename, 'w') as A: A['solver'] = solver
g0_wk = lattice_dyson_g0_wk(mu=mu, e_k=e_k, mesh=wmesh) chi00_wk = imtime_bubble_chi0_wk(g0_wk, nw=1) # ------------------------------------------------------------------ # -- RPA fundamental_operators = [c(0, 0), c(0, 1)] chi_wk_vec = [] U_vec = np.arange(1.0, 5.0, 1.0) for u in U_vec: print '--> RPA chi_wk, U =', u H_int = u * n(0, 0) * n(0, 1) U_int_abcd = quartic_tensor_from_operator(H_int, fundamental_operators) print U_int_abcd.reshape((4, 4)).real U_int_abcd = quartic_permutation_symmetrize(U_int_abcd) print U_int_abcd.reshape((4, 4)).real # -- Group in Gamma order cc^+cc^+ ( from c^+c^+cc ) U_abcd = np.zeros_like(U_int_abcd) for a, b, c, d in itertools.product(range(U_abcd.shape[0]), repeat=4): U_abcd[a, b, c, d] = U_int_abcd[b, d, a, c] chi_wk = solve_rpa_PH(chi00_wk, U_abcd)
g2_n_wf = 5 # GF structure gf_struct = {'up' : [0], 'dn' : [0]} # Conversion from TRIQS to Pomerol notation for operator indices index_converter = {} index_converter.update({(sn, 0) : ("loc", 0, "down" if sn == "dn" else "up") for sn in spin_names}) index_converter.update({("B%i_%s" % (k, sn), 0) : ("bath" + str(k), 0, "down" if sn == "dn" else "up") for k, sn in product(range(len(epsilon)), spin_names)}) # Make PomerolED solver object ed = PomerolED(index_converter, verbose = True) # Local Hamiltonian H_loc = e_d*(n('up', 0) + n('dn', 0)) + h*(n('up', 0) - n('dn', 0)) # Bath Hamiltonian H_bath = sum(eps*n("B%i_%s" % (k, sn), 0) for sn, (k, eps) in product(spin_names, enumerate(epsilon))) # Hybridization Hamiltonian H_hyb = Operator() for k, v in enumerate(V): H_hyb += sum( v * c_dag("B%i_%s" % (k, sn), 0) * c(sn, 0) + np.conj(v) * c_dag(sn, 0) * c("B%i_%s" % (k, sn), 0) for sn in spin_names) # Complete Hamiltonian H = H_loc + H_hyb + H_bath
def make_calc(beta=2.0, h_field=0.0): # ------------------------------------------------------------------ # -- Hubbard atom with two bath sites, Hamiltonian p = ParameterCollection( beta=beta, V1=2.0, V2=5.0, epsilon1=0.10, epsilon2=3.00, h_field=h_field, mu=0.0, U=5.0, ntau=800, niw=15, ) # ------------------------------------------------------------------ print '--> Solving SIAM with parameters' print p # ------------------------------------------------------------------ up, do = 'up', 'dn' docc = c_dag(up, 0) * c(up, 0) * c_dag(do, 0) * c(do, 0) mA = c_dag(up, 0) * c(up, 0) - c_dag(do, 0) * c(do, 0) nA = c_dag(up, 0) * c(up, 0) + c_dag(do, 0) * c(do, 0) nB = c_dag(up, 1) * c(up, 1) + c_dag(do, 1) * c(do, 1) nC = c_dag(up, 2) * c(up, 2) + c_dag(do, 2) * c(do, 2) p.H = -p.mu * nA + p.U * docc + p.h_field * mA + \ p.epsilon1 * nB + p.epsilon2 * nC + \ p.V1 * (c_dag(up,0)*c(up,1) + c_dag(up,1)*c(up,0) + \ c_dag(do,0)*c(do,1) + c_dag(do,1)*c(do,0) ) + \ p.V2 * (c_dag(up,0)*c(up,2) + c_dag(up,2)*c(up,0) + \ c_dag(do,0)*c(do,2) + c_dag(do,2)*c(do,0) ) # ------------------------------------------------------------------ fundamental_operators = [ c(up, 0), c(do, 0), c(up, 1), c(do, 1), c(up, 2), c(do, 2) ] ed = TriqsExactDiagonalization(p.H, fundamental_operators, p.beta) g_tau = GfImTime(beta=beta, statistic='Fermion', n_points=400, indices=[0]) g_iw = GfImFreq(beta=beta, statistic='Fermion', n_points=10, indices=[0]) p.G_tau = BlockGf(name_list=[up, do], block_list=[g_tau] * 2, make_copies=True) p.G_iw = BlockGf(name_list=[up, do], block_list=[g_iw] * 2, make_copies=True) ed.set_g2_tau(p.G_tau[up][0, 0], c(up, 0), c_dag(up, 0)) ed.set_g2_tau(p.G_tau[do][0, 0], c(do, 0), c_dag(do, 0)) ed.set_g2_iwn(p.G_iw[up][0, 0], c(up, 0), c_dag(up, 0)) ed.set_g2_iwn(p.G_iw[do][0, 0], c(do, 0), c_dag(do, 0)) p.magnetization = ed.get_expectation_value(0.5 * mA) p.O_tau = Gf(mesh=MeshImTime(beta, 'Fermion', 400), target_shape=[]) ed.set_g2_tau(p.O_tau, n(up, 0), n(do, 0)) p.O_tau.data[:] *= -1. p.exp_val = ed.get_expectation_value(n(up, 0) * n(do, 0)) # ------------------------------------------------------------------ # -- Store to hdf5 filename = 'data_pyed_h_field_%4.4f.h5' % h_field with HDFArchive(filename, 'w') as res: res['p'] = p
from pytriqs.operators import n, c, c_dag, Operator import pytriqs.utility.mpi as mpi from pytriqs.gf import Gf, MeshImFreq, MeshImTime, iOmega_n, inverse, Fourier, InverseFourier beta = 10.0 gf_struct = [['0', [0, 1]]] target_shape = [2, 2] nw = 48 nt = 3 * nw S = SolverCore(beta=beta, gf_struct=gf_struct, n_iw=nw, n_tau=nt) h_int = n('0', 0) * n('0', 1) wmesh = MeshImFreq(beta=beta, S='Fermion', n_max=nw) tmesh = MeshImTime(beta=beta, S='Fermion', n_max=nt) Delta_iw = Gf(mesh=wmesh, target_shape=target_shape) Ek = np.array([ [1.00, 0.75], [0.75, -1.20], ]) E_loc = np.array([ [0.2, 0.3], [0.3, 0.4], ])
if __name__ == '__main__': orb_idxs = list(range(3)) gf_struct = [['up', orb_idxs], ['do', orb_idxs]] fundamental_operators = fundamental_operators_from_gf_struct(gf_struct) beta = 10.0 U = 2.0 mu = 1.0 h = 0.1 #V = 0.5 V = 1.0 epsilon = 2.3 H = U * n('up', 0) * n('do', 0) + \ - mu * (n('up', 0) + n('do', 0)) + \ h * n('up', 0) - h * n('do', 0) + \ epsilon * (n('up', 1) + n('do', 1)) - epsilon * (n('up', 2) + n('do', 2)) + \ V * ( c_dag('up', 0) * c('up', 1) + c_dag('up', 1) * c('up', 0) ) + \ V * ( c_dag('do', 0) * c('do', 1) + c_dag('do', 1) * c('do', 0) ) + \ V * ( c_dag('up', 0) * c('up', 2) + c_dag('up', 2) * c('up', 0) ) + \ V * ( c_dag('do', 0) * c('do', 2) + c_dag('do', 2) * c('do', 0) ) ed = TriqsExactDiagonalization(H, fundamental_operators, beta) n_tau = 101 G_tau_up = Gf(mesh=MeshImTime(beta, 'Fermion', n_tau), target_shape=[]) G_tau_do = Gf(mesh=MeshImTime(beta, 'Fermion', n_tau), target_shape=[]) ed.set_g2_tau(G_tau_up, c('up', 0), c_dag('up', 0))
def run_calculation(use_qn=True): # Input parameters beta = 10.0 U = 2.0 mu = 1.0 epsilon = 2.3 t = 0.1 n_iw = 1025 n_tau = 10001 p = {} p["max_time"] = -1 p["random_name"] = "" p["random_seed"] = 123 * mpi.rank + 567 p["length_cycle"] = 50 p["n_warmup_cycles"] = 20000 p["n_cycles"] = 1000000 results_file_name = "spinless" if use_qn: results_file_name += ".qn" results_file_name += ".h5" mpi.report( "Welcome to spinless (spinless electrons on a correlated dimer) test.") H = U * n("tot", "A") * n("tot", "B") QN = [] if use_qn: QN.append(n("tot", "A") + n("tot", "B")) p["partition_method"] = "quantum_numbers" p["quantum_numbers"] = QN gf_struct = [["tot", ["A", "B"]]] mpi.report("Constructing the solver...") ## Construct the solver S = SolverCore(beta=beta, gf_struct=gf_struct, n_iw=n_iw, n_tau=n_tau) mpi.report("Preparing the hybridization function...") ## Set hybridization function delta_w = GfImFreq(indices=["A", "B"], beta=beta) delta_w << inverse(iOmega_n - np.array([[epsilon, -t], [-t, epsilon]]) ) + inverse(iOmega_n - np.array([[-epsilon, -t], [-t, -epsilon]])) S.G0_iw["tot"] << inverse(iOmega_n - np.array([[-mu, -t], [-t, -mu]]) - delta_w) mpi.report("Running the simulation...") ## Solve the problem S.solve(h_int=H, **p) ## Save the results if mpi.is_master_node(): with HDFArchive(results_file_name, 'w') as Results: Results["tot"] = S.G_tau["tot"]
p = {} p["max_time"] = -1 p["random_name"] = "" p["random_seed"] = 123 * mpi.rank + 567 p["length_cycle"] = 50 p["n_warmup_cycles"] = 50000 p["n_cycles"] = 5000000 p["measure_G_tau"] = False p["measure_G_l"] = True results_file_name = "legendre.h5" mpi.report("Welcome to Legendre (1 correlated site + symmetric bath) test.") H = U*n(*mkind("up"))*n(*mkind("dn")) QN = [] for spin in spin_names: QN.append(n(*mkind(spin))) gf_struct = {} for spin in spin_names: bn, i = mkind(spin) gf_struct.setdefault(bn,[]).append(i) gf_struct = [ [key, value] for key, value in gf_struct.items() ] mpi.report("Constructing the solver...") # Construct the solver S = SolverCore(beta=beta, gf_struct=gf_struct, n_tau=n_tau, n_iw=n_iw, n_l=n_l)
chi0_q0_ref = chi0_q0_integral(t, beta) print 'chi0_q0 =', chi00_wk[Idx(0), Idx(0, 0, 0)][0, 0, 0, 0].real print 'chi0_q0_ref =', chi0_q0_ref np.testing.assert_almost_equal( chi00_wk_analytic[Idx(0), Idx(0, 0, 0)][0, 0, 0, 0], chi0_q0_ref) # ------------------------------------------------------------------ # -- RPA tensor gf_struct = [[0, [0, 1]]] from pytriqs.operators import n, c, c_dag, Operator, dagger H_int = U * n(0, 0) * n(0, 1) print 'H_int =', H_int from triqs_tprf.rpa_tensor import get_rpa_tensor from triqs_tprf.rpa_tensor import fundamental_operators_from_gf_struct fundamental_operators = fundamental_operators_from_gf_struct(gf_struct) print fundamental_operators U_abcd = get_rpa_tensor(H_int, fundamental_operators) print 'U_abcd =\n', U_abcd.reshape((4, 4)) # ------------------------------------------------------------------ # -- RPA from triqs_tprf.lattice import solve_rpa_PH
import pytriqs.utility.mpi as mpi from pytriqs.gf import inverse, iOmega_n, SemiCircular, BlockGf from pytriqs.operators import n from pytriqs.archive import HDFArchive from triqs_cthyb import Solver # ---------------------------------------------------------------------- if __name__ == '__main__': solv = Solver(beta=10., gf_struct=[['0', [0]]]) solv.G0_iw['0'][0, 0] << inverse(iOmega_n - 0.5 - SemiCircular(2.)) solv.solve( h_int=1.0 * n('0', 0), n_warmup_cycles=int(1e0), n_cycles=int(1e1 / mpi.size), ) if mpi.is_master_node(): filename = 'data.h5' with HDFArchive(filename, 'w') as res: res['solv'] = solv with HDFArchive(filename, 'r') as res: ref_solv = res['solv'] cf_attr = [
n_iw=1025, n_tau=2500, n_l=20) solver = SolverCore(**cp) # Set hybridization function mu = 0.5 half_bandwidth = 1.0 delta_w = GfImFreq(indices=[0], beta=cp['beta']) delta_w << (half_bandwidth / 2.0)**2 * SemiCircular(half_bandwidth) for name, g0 in solver.G0_iw: g0 << inverse(iOmega_n + mu - delta_w) sp = dict( h_int=n('up', 0) * n('do', 0), max_time=-1, length_cycle=50, n_warmup_cycles=50, n_cycles=500, move_double=False, ) solver.solve(**sp) sp = solver.last_solve_parameters cp = solver.last_constr_parameters filename = 'h5_read_write.h5' with HDFArchive(filename, 'w') as A:
U = 1.0 # Coulomb repulsion mu = 0.4 # Chemical potential h_field = 0.01 spin_names = ("up", "dn") # Conversion from TRIQS to Pomerol notation for operator indices index_converter = {} index_converter.update({(sn, 0): ("A", 0, "down" if sn == "dn" else "up") for sn in spin_names}) # Make PomerolED solver object ed = PomerolED(index_converter, verbose=True) # Hamiltonian H = -mu * (n('up', 0) + n('dn', 0)) - h_field * (n('up', 0) - n('dn', 0)) H += U * n('up', 0) * n('dn', 0) # Diagonalize H ed.diagonalize(H) # Compute reference values of <n('up', 0)> and <n('dn', 0)> w = np.array([ 1.0, np.exp(beta * (mu + h_field)), np.exp(beta * (mu - h_field)), np.exp(-beta * (-2 * mu + U)) ]) Z = np.sum(w) w /= Z n_up_ref, n_dn_ref = complex(w[1] + w[3]), complex(w[2] + w[3])
n_tau = 10001 p = {} p["max_time"] = -1 p["random_name"] = "" p["random_seed"] = 123 * mpi.rank + 567 p["length_cycle"] = 50 p["n_warmup_cycles"] = 100000 p["n_cycles"] = 1000000 p["measure_G_tau"] = True p["measure_density_matrix"] = True p["use_norm_as_weight"] = True move_global_prob = 0.05 H = U * n(*mkind("up", 1)) * n(*mkind("dn", 1)) + U * n(*mkind("up", 2)) * n( *mkind("dn", 2)) # Global moves gm_flip_spins_1 = { 'flip_spins_1': { mkind("up", 1): mkind("dn", 1), mkind("dn", 1): mkind("up", 1) } } gm_flip_spins_all = { 'flip_spins_all': { mkind("up", 1): mkind("dn", 1), mkind("dn", 1): mkind("up", 1), mkind("up", 2): mkind("dn", 2), mkind("dn", 2): mkind("up", 2)
# Pomerol: site_label, orbital_index, spin_name index_converter = {} # Local degrees of freedom index_converter.update({(sn, o): ("loc", o, "down" if sn == "dn" else "up") for sn, o in product(spin_names, orb_names)}) # Bath degrees of freedom index_converter.update({("B_" + sn, o): ("bath", o, "down" if sn == "dn" else "up") for sn, o in product(spin_names, orb_names)}) # Make PomerolED solver object ed = PomerolED(index_converter, verbose=True) # Number of particles on the impurity N = sum(n(sn, o) for sn, o in product(spin_names, orb_names)) # Local Hamiltonian H_loc = 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_loc -= mu * N # Bath Hamiltonian H_bath = sum(epsilon[o] * n("B_" + sn, o) for sn, o in product(spin_names, orb_names)) # Hybridization Hamiltonian H_hyb = sum(V[o1, o2] * c_dag("B_" + sn, o1) * c(sn, o2) + np.conj(V[o2, o1]) * c_dag(sn, o1) * c("B_" + sn, o2) for sn, o1, o2 in product(spin_names, orb_names, orb_names))
p = {} p["max_time"] = -1 p["random_name"] = "" p["random_seed"] = 123 * mpi.rank + 567 p["length_cycle"] = 50 p["n_warmup_cycles"] = 50000 p["n_cycles"] = 5000000 p["measure_G_tau"] = False p["measure_G_l"] = True results_file_name = "legendre.h5" mpi.report("Welcome to Legendre (1 correlated site + symmetric bath) test.") H = U * n(*mkind("up")) * n(*mkind("dn")) QN = [] for spin in spin_names: QN.append(n(*mkind(spin))) gf_struct = {} for spin in spin_names: bn, i = mkind(spin) gf_struct.setdefault(bn, []).append(i) gf_struct = [[key, value] for key, value in gf_struct.items()] mpi.report("Constructing the solver...") # Construct the solver S = SolverCore(beta=beta, gf_struct=gf_struct, n_tau=n_tau, n_iw=n_iw, n_l=n_l)
p["n_warmup_cycles"] = 50000 p["n_cycles"] = 1200000 for modes in range(1,N_max+1): V = [0.2]*modes e = [-0.2]*modes #gf_struct = {str(n):[0] for n in range(0,len(V))} gf_struct = [ [str(bidx), [0]] for bidx in range(0,len(V)) ] # Local Hamiltonian H = Operator() # Quantum numbers (N_up and N_down) QN = [] for b, idxs in gf_struct: QN.append(n(b,0)) 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) mpi.report("Preparing the hybridization function...") # Set hybridization function #for m, b in enumerate(sorted(gf_struct.keys())): for m, (b, idxs) in enumerate(gf_struct): delta_w = Gf(mesh=S.G0_iw.mesh, target_shape=[]) delta_w << (V[m]**2) * inverse(iOmega_n - e[m])
p["n_cycles"] = 1200000 for modes in range(1, N_max + 1): V = [0.2] * modes e = [-0.2] * modes #gf_struct = {str(n):[0] for n in range(0,len(V))} gf_struct = [[str(bidx), [0]] for bidx in range(0, len(V))] # Local Hamiltonian H = Operator() # Quantum numbers (N_up and N_down) QN = [] for b, idxs in gf_struct: QN.append(n(b, 0)) 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) mpi.report("Preparing the hybridization function...") # Set hybridization function #for m, b in enumerate(sorted(gf_struct.keys())): for m, (b, idxs) in enumerate(gf_struct): delta_w = GfImFreq(indices=[0], beta=beta) delta_w << (V[m]**2) * inverse(iOmega_n - e[m])
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) mpi.report("Preparing the hybridization function...") # Set hybridization function
Units = np.dot(P, Units_prim) print 'Units =\n', Units t_r = TBSuperLattice(t_r_prim, P) t_r.bz = BrillouinZone(t_r.bl) e_k = t_r.on_mesh_brillouin_zone(n_k) print e_k.target_shape print 'eps(k=0) =\n', e_k[Idx(0, 0, 0)] # -- Local double occ and spin operators gf_struct = [[0, [0, 1, 2, 3]]] docc = n(0, 0) * n(0, 2) + n(0, 1) * n(0, 3) print 'docc =', docc sigma_x = 0.5 * np.rot90(np.diag([1., 1.])) sigma_y = 0.5 * np.rot90(np.diag([1.j, -1.j])) sigma_z = 0.5 * np.diag([1., -1.]) print 'sigma_x =\n', sigma_x print 'sigma_y =\n', sigma_y print 'sigma_z =\n', sigma_z Sx1 = np.kron(sigma_x, np.diag([1., 0.])) Sx2 = np.kron(sigma_x, np.diag([0., 1.])) Sy1 = np.kron(sigma_y, np.diag([1., 0.]))
( 0, ): h_loc, (+1, ): T, (-1, ): T, }, orbital_positions=[(0, 0, 0)] * 2, orbital_names=['up', 'do'], ) e_k = t_r.on_mesh_brillouin_zone(n_k) # -- Local double occupancy operator gf_struct = [[0, [0, 1]]] docc = n(0, 0) * n(0, 1) Sz = 0.5 * np.diag([1., -1.]) # -- Sweep in interaction U U_vec = np.arange(9., -0.5, -1.5) h_vec = 1e-3 * np.linspace(-1., 1., num=11) res = [] M0 = np.zeros((2, 2)) M = -5.0 * Sz mu = 0. for U in U_vec:
g2_blocks = set([("up", "up"), ("up", "dn"), ("dn", "up")]) gf_struct = {"up": orb_names, "dn": orb_names} print "Block structure of single-particle Green's functions:", gf_struct # Conversion from TRIQS to Pomerol notation for operator indices # TRIQS: block_name, inner_index # Pomerol: site_label, orbital_index, spin_name index_converter = {(sn, o): ("loc", o, "down" if sn == "dn" else "up") for sn, o in product(spin_names, orb_names)} # Make PomerolED solver object ed = PomerolED(index_converter, verbose=True) # Number of particles on the impurity N = sum(n(sn, o) for sn, o in product(spin_names, orb_names)) # 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 -= mu * N # Diagonalize H ed.diagonalize(H) # Compute G(i\omega) G_iw = ed.G_iw(gf_struct, beta, n_iw) # Compute G(\tau) G_tau = ed.G_tau(gf_struct, beta, n_tau)
# GF structure gf_struct = {'up': [0], 'dn': [0]} # Conversion from TRIQS to Pomerol notation for operator indices index_converter = {} index_converter.update({(sn, 0): ("loc", 0, "down" if sn == "dn" else "up") for sn in spin_names}) index_converter.update({("B%i_%s" % (k, sn), 0): ("bath" + str(k), 0, "down" if sn == "dn" else "up") for k, sn in product(range(len(epsilon)), spin_names)}) # Make PomerolED solver object ed = PomerolED(index_converter, verbose=True) # Number of particles on the impurity H_loc = -mu * (n('up', 0) + n('dn', 0)) + U * n('up', 0) * n('dn', 0) # Bath Hamiltonian H_bath = sum(eps * n("B%i_%s" % (k, sn), 0) for sn, (k, eps) in product(spin_names, enumerate(epsilon))) # Hybridization Hamiltonian H_hyb = Operator() for k, v in enumerate(V): H_hyb += sum(v * c_dag("B%i_%s" % (k, sn), 0) * c(sn, 0) + np.conj(v) * c_dag(sn, 0) * c("B%i_%s" % (k, sn), 0) for sn in spin_names) # Complete Hamiltonian H = H_loc + H_hyb + H_bath
post_process=True, ) p.version = ParameterCollection() p.version.grab_attribs(version, ['version', 'ctint_hash', 'triqs_hash']) # -- The alpha tensor p.diag = 0.5 + p.delta p.odiag = 0.5 - p.delta p.solve.alpha = [[[p.diag, p.odiag] for i in indices] for bl, indices in p.gf_struct] # -- Total impurity hamiltonian and interaction part p.H_0 = -p.mu * (n('up', 0) + n('dn', 0)) - p.h * (n('up', 0) - n('dn', 0)) p.H_int = p.U * n('up', 0) * n('dn', 0) p.H = p.H_0 + p.H_int p.solve.h_int = p.H_int # -- Non-Interacting Impurity Green function iw_mesh = MeshImFreq(p.beta, 'Fermion', p.n_iw) p.G0_iw = Gf_from_struct(mesh=iw_mesh, struct=p.gf_struct) h_field_dict = dict(up=p.h, dn=-p.h) for name, g0_iw in p.G0_iw: h_field = h_field_dict[name] g0_iw << inverse(iOmega_n + p.mu + h_field) # -- CTINT