def solve_lattice_bse(parm, momsus=False): print '--> solve_lattice_bse' print 'nw =', parm.nw print 'nwf =', parm.nwf # ------------------------------------------------------------------ # -- Setup lattice bl = BravaisLattice([(1, 0, 0), (0, 1, 0)]) bz = BrillouinZone(bl) bzmesh = MeshBrillouinZone(bz, n_k=1) # only one k-point e_k = Gf(mesh=bzmesh, target_shape=[1, 1]) e_k *= 0. # ------------------------------------------------------------------ # -- Lattice single-particle Green's function mesh = MeshImFreq(beta=parm.beta, S='Fermion', n_max=parm.nwf_gf) parm.Sigma_iw = parm.G_iw.copy() G0_iw = parm.G_iw.copy() G0_iw << inverse(iOmega_n + 0.5 * parm.U) parm.Sigma_iw << inverse(G0_iw) - inverse(parm.G_iw) parm.mu = 0.5 * parm.U g_wk = lattice_dyson_g_wk(mu=parm.mu, e_k=e_k, sigma_w=parm.Sigma_iw) g_wr = fourier_wk_to_wr(g_wk) # ------------------------------------------------------------------ # -- Non-interacting generalized lattice susceptibility chi0_wr = chi0r_from_gr_PH(nw=parm.nw, nnu=parm.nwf, gr=g_wr) chi0_wk = chi0q_from_chi0r(chi0_wr) # ------------------------------------------------------------------ # -- Solve lattice BSE parm.chi_wk = chiq_from_chi0q_and_gamma_PH(chi0_wk, parm.gamma_m) # ------------------------------------------------------------------ # -- Store results and static results num = np.squeeze(parm.chi_wk.data.real) ref = np.squeeze(parm.chi_m.data.real) diff = np.max(np.abs(num - ref)) print 'diff =', diff parm.chi_w = chiq_sum_nu_q(parm.chi_wk) # static suscept return parm
def compute_new_weiss_field(G_lattice_iw_list_, Sigma_iw_list_): G0_iw_list = [] for g, s in zip(G_lattice_iw_list_, Sigma_iw_list_): G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) G0_iw << inverse(inverse(g) + s) G0_iw_list.append(G0_iw) return G0_iw_list
def delta_inv(beta, nw, nk=100): mesh = MeshImFreq(beta, 'Fermion', n_max=nw) Sigma0, Sigma1 = 1.337, 3.5235 ek = 2. * np.random.random(nk) - 1. G = Gf(mesh=mesh, target_shape=[1, 1]) Sig = G.copy() for w in Sig.mesh: Sig[w][:] = Sigma0 + Sigma1 / w for e in ek: G << G + inverse(iOmega_n - e - Sig) G /= nk Delta = G.copy() Delta << inverse(G) - iOmega_n + Sig sum_ek = -np.sum(ek) / nk Roo = np.abs(Sigma0) + 1. w = [w for w in mesh] wmax = np.abs(w[-1].value) tail, err = Delta.fit_tail() order = len(tail) trunc_err_anal = (Roo / (0.8 * wmax))**order ratio = tail[0] / sum_ek diff = np.abs(1 - ratio) print '-' * 72 print 'beta =', beta print 'nw =', nw print 'wmax =', wmax print 'tail_fit order =', len(tail) print 'tail_fit err =', err print tail[:3] #print sum_ek print 'trunc_err_anal =', trunc_err_anal print 'ratio =', ratio print 'diff =', diff return diff[0, 0]
def calculate_sigmas(G_iw_list_, G0_iw_list_): Sigma_iw_list = [] for G_iw, G0_iw in zip(G_iw_list_, G0_iw_list_): print ' ' print 'G_iw', G_iw print 'G0_iw', G0_iw Sigma = G0_iw.copy() Sigma << inverse(G0_iw) - inverse(G_iw) Sigma_iw_list.append(Sigma) return Sigma_iw_list
def test_cf_G_tau_and_G_iw_nonint(verbose=False): beta = 3.22 eps = 1.234 niw = 64 ntau = 2 * niw + 1 H = eps * c_dag(0,0) * c(0,0) fundamental_operators = [c(0,0)] ed = TriqsExactDiagonalization(H, fundamental_operators, beta) # ------------------------------------------------------------------ # -- Single-particle Green's functions G_tau = GfImTime(beta=beta, statistic='Fermion', n_points=ntau, target_shape=(1,1)) G_iw = GfImFreq(beta=beta, statistic='Fermion', n_points=niw, target_shape=(1,1)) G_iw << inverse( iOmega_n - eps ) G_tau << InverseFourier(G_iw) G_tau_ed = GfImTime(beta=beta, statistic='Fermion', n_points=ntau, target_shape=(1,1)) G_iw_ed = GfImFreq(beta=beta, statistic='Fermion', n_points=niw, target_shape=(1,1)) ed.set_g2_tau(G_tau_ed[0, 0], c(0,0), c_dag(0,0)) ed.set_g2_iwn(G_iw_ed[0, 0], c(0,0), c_dag(0,0)) # ------------------------------------------------------------------ # -- Compare gfs from pytriqs.utility.comparison_tests import assert_gfs_are_close assert_gfs_are_close(G_tau, G_tau_ed) assert_gfs_are_close(G_iw, G_iw_ed) # ------------------------------------------------------------------ # -- Plotting if verbose: from pytriqs.plot.mpl_interface import oplot, plt subp = [3, 1, 1] plt.subplot(*subp); subp[-1] += 1 oplot(G_tau.real) oplot(G_tau_ed.real) plt.subplot(*subp); subp[-1] += 1 diff = G_tau - G_tau_ed oplot(diff.real) oplot(diff.imag) plt.subplot(*subp); subp[-1] += 1 oplot(G_iw) oplot(G_iw_ed) plt.show()
def dmft_self_consistent_step(p): p = copy.deepcopy(p) p.iter += 1 p.g_w = lattice_dyson_g_w(p.mu, p.e_k, p.sigma_w - np.diag([p.B, -p.B])) p.g0_w = p.g_w.copy() p.g0_w << inverse(inverse(p.g_w) + p.sigma_w) cthyb = triqs_cthyb.Solver(**p.init.dict()) # -- set impurity from lattice cthyb.G0_iw['up'][0, 0] << p.g0_w[0, 0] cthyb.G0_iw['do'][0, 0] << p.g0_w[1, 1] cthyb.solve(**p.solve.dict()) p.dG_l = np.max(np.abs(BlockGf_data(cthyb.G_l-p.G_l))) if hasattr(p,'G_l') else float('nan') p.G_l = cthyb.G_l p.G_tau, p.G_tau_raw = cthyb.G_tau.copy(), cthyb.G_tau.copy() p.G0_w, p.G_w, p.Sigma_w = cthyb.G0_iw.copy(), cthyb.G0_iw.copy(), cthyb.G0_iw.copy() p.G_tau << LegendreToMatsubara(p.G_l) p.G_w << Fourier(p.G_tau) p.Sigma_w << inverse(p.G0_w) - inverse(p.G_w) # -- set lattice from impurity p.sigma_w[0, 0] << p.Sigma_w['up'][0, 0] p.sigma_w[1, 1] << p.Sigma_w['do'][0, 0] # -- local observables p.rho = p.g_w.density() M_old = p.M if hasattr(p, 'M') else float('nan') p.M = 0.5*(p.rho[0, 0] - p.rho[1, 1]) p.dM = np.abs(p.M - M_old) return p
def partition(h_int, h_k, gf_struct, QN=None): p = {} p["verbosity"] = 0 p["max_time"] = -1 p["length_cycle"] = 1 p["n_warmup_cycles"] = 0 p["n_cycles"] = 0 if QN is None: p['partition_method'] = "autopartition" else: p['partition_method'] = "quantum_numbers" p['quantum_numbers'] = QN S = SolverCore(beta=1, gf_struct=gf_struct) S.G0_iw << inverse(iOmega_n - h_k) start = time.clock() S.solve(h_int=h_int, **p) end = time.clock() return S.eigensystems, end - start
[0, V3, 0, E3], ]) h_bath = np.kron(h_bath, I) p.H_bath = get_quadratic_operator(h_bath, p.op_full) # -- Weiss field of the bath h_tot = quadratic_matrix_from_operator(p.H_bath + p.H_loc, p.op_full) g0_iw = GfImFreq(beta=p.beta, statistic='Fermion', n_points=p.nw, target_shape=(8, 8)) g0_iw << inverse(iOmega_n - h_tot) p.g0_iw = g0_iw[:4, :4] # -- Cut out impurity Gf p.g0t_iw = g2_single_particle_transform(p.g0_iw, p.T.H) p.g0_tau = GfImTime(beta=p.beta, statistic='Fermion', n_points=p.ntau, target_shape=(4, 4)) 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)
from pytriqs.gf import Gf, MeshImFreq, MeshImTime from pytriqs.gf import GfImFreq, GfImTime from pytriqs.gf import iOmega_n, inverse, InverseFourier beta = 1.234 eps = 3.55 nw = 100 nt = 1000 g_iw = GfImFreq(name=r'$g(i\omega_n)$', beta=beta, statistic='Fermion', n_points=nw, indices=[1]) g_iw << inverse(iOmega_n - eps) g_tau = GfImTime(name=r'$g(\tau)$', beta=beta, statistic='Fermion', n_points=nt, indices=[1]) g_tau << InverseFourier(g_iw) # -- Test fourier from pytriqs.applications.tprf.fourier import g_iw_from_tau g_iw_ref = g_iw_from_tau(g_tau, nw) np.testing.assert_array_almost_equal(g_iw_ref.data, g_iw.data)
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 delta_w = GfImFreq(indices=orb_names, beta=beta, n_points=n_iw) delta_w_part = delta_w.copy() for e, v in zip(epsilon, V): delta_w_part << inverse(iOmega_n - e) delta_w_part.from_L_G_R(np.transpose(v), delta_w_part, v) delta_w += delta_w_part S.G0_iw << inverse(iOmega_n + 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['G_tau'] = S.G_tau
if not use_interaction: #g_theor = GfImTime(indices = range(len(orb_names)), beta=beta, n_points=n_tau) g_theor = GfImTime(indices=range(len(orb_names)), beta=beta, n_points=1000) for nc, cn in enumerate(orb_names): V = delta_params[cn]['V'] e = delta_params[cn]['e'] e1 = e - V e2 = e + V #g_theor_w = GfImFreq(indices = [0], beta=beta, n_points=1000) g_theor_w = Gf(mesh=MeshImFreq(beta, 'Fermion', 100), target_shape=[]) g_theor_w << 0.5 * inverse(iOmega_n - e1) + 0.5 * inverse(iOmega_n - e2) g_theor[nc, nc] << Fourier(g_theor_w) pp = PdfPages('G%s.pdf' % ('int' if use_interaction else '')) for sn in spin_names: for nc, cn in enumerate(orb_names): plt.clf() gf = rebinning_tau(arch['G_tau'][mkind(sn, cn)[0]], 200) # Plot the results oplot(gf, name="cthyb") # Plot the reference curve if use_interaction: oplot(g_ref[nc, nc], name="ED")
cp = dict(beta=10.0, gf_struct=[['up', [0]], ['do', [0]]], 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'
# 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]) S.G0_iw[b][0,0] << inverse(iOmega_n - e[m] - delta_w) mpi.report("Running the simulation...") # Solve the problem S.solve(h_int=H, **p) # Save results if mpi.is_master_node(): with HDFArchive('nonint.h5','a') as Results: Results[str(modes)] = {'G_tau':S.G_tau,'V':V,'e':e}
from pytriqs.gf import GfReFreq, Omega, Wilson, inverse import numpy eps_d,t = 0.3, 0.2 # Create the real-frequency Green's function and initialize it g = GfReFreq(indices = ['s','d'], window = (-2, 2), n_points = 1000, name = "$G_\mathrm{s+d}$") g['d','d'] = Omega - eps_d g['d','s'] = t g['s','d'] = t g['s','s'] = inverse( Wilson(1.0) ) g.invert() # Plot it with matplotlib. 'S' means: spectral function ( -1/pi Imag (g) ) from pytriqs.plot.mpl_interface import oplot, plt oplot( g['d','d'], '-o', RI = 'S', x_window = (-1.8,1.8), name = "Impurity" ) oplot( g['s','s'], '-x', RI = 'S', x_window = (-1.8,1.8), name = "Bath" ) plt.show()
E_loc = np.array([ [0.2, 0.3], [0.3, 0.4], ]) V = np.array([ [1.0, 0.25], [0.25, -1.0], ]) h_loc = c_dag('0', 0) * E_loc[0, 0] * c('0', 0) + \ c_dag('0', 0) * E_loc[0, 1] * c('0', 1) + \ c_dag('0', 1) * E_loc[1, 0] * c('0', 0) + \ c_dag('0', 1) * E_loc[1, 1] * c('0', 1) Delta_iw << inverse( iOmega_n - Ek ) + inverse( iOmega_n + Ek ) Delta_iw.from_L_G_R(V, Delta_iw, V) Delta_tau = Gf(mesh=tmesh, target_shape=target_shape) Delta_tail, Delta_tail_err = Delta_iw.fit_hermitian_tail() Delta_tau << InverseFourier(Delta_iw, Delta_tail) G0_iw = Gf(mesh=wmesh, target_shape=target_shape) G0_iw << inverse( iOmega_n - Delta_iw - E_loc ) S.G0_iw << G0_iw S.solve( h_int = h_int, length_cycle = 10, n_warmup_cycles = 1,
from pytriqs.plot.mpl_interface import oplot from pytriqs.gf import GfImFreq, Omega, inverse g = GfImFreq(indices=[0], beta=300, n_points=1000, name="g") g << inverse(Omega + 0.5) # the data we want to fit... # The green function for omega \in [0,0.2] X, Y = g.x_data_view(x_window=(0, 0.2), flatten_y=True) from pytriqs.fit import Fit, linear, quadratic fitl = Fit(X, Y.imag, linear) fitq = Fit(X, Y.imag, quadratic) oplot(g, '-o', x_window=(0, 5)) oplot(fitl, '-x', x_window=(0, 0.5)) oplot(fitq, '-x', x_window=(0, 1)) # a bit more complex, we want to fit with a one fermion level .... # Cf the definition of linear and quadratic in the lib one_fermion_level = lambda X, a, b: 1 / (a * X * 1j + b ), r"${1}/(%f x + %f)$", (1, 1) fit1 = Fit(X, Y, one_fermion_level) oplot(fit1, '-x', x_window=(0, 3))
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"]
# Import the Green's functions from pytriqs.gf import GfImFreq, iOmega_n, inverse # Create the Matsubara-frequency Green's function and initialize it g = GfImFreq(indices=[1], beta=50, n_points=1000, name="$G_\mathrm{imp}$") g << inverse(iOmega_n + 0.5) from pytriqs.plot.mpl_interface import oplot oplot(g, '-o', x_window=(0, 10))
n_iw = 100 n_tau = 1000 from pytriqs.gf import MeshImFreq, MeshImTime from pytriqs.gf import BlockGf, inverse, iOmega_n, Fourier iw_mesh = MeshImFreq(beta, 'Fermion', n_iw) G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) debug_H = [] for block, g0_iw in G0_iw: s = (3, 3) H = np.random.random(s) + 1.j * np.random.random(s) H = H + np.conjugate(H.T) g0_iw << inverse(iOmega_n - H - inverse(iOmega_n - 0.3 * H)) debug_H.append(H) # ------------------------------------------------------------------ Delta_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) H_loc_block = [] for block, g0_iw in G0_iw: tail, err = g0_iw.fit_hermitian_tail() H_loc = tail[2] Delta_iw[block] << inverse(g0_iw) + H_loc - iOmega_n H_loc_block.append(H_loc)
Author: Hugo U.R. Strand (2019) """ # ---------------------------------------------------------------------- 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:
# Import the Green's functions from pytriqs.gf import GfImFreq, iOmega_n, inverse # Create the Matsubara-frequency Green's function and initialize it g = GfImFreq(indices = [1], beta = 50, n_points = 1000, name = "imp") g << inverse( iOmega_n + 0.5 ) import pytriqs.utility.mpi as mpi mpi.bcast(g) #Block from pytriqs.gf import * g1 = GfImFreq(indices = ['eg1','eg2'], beta = 50, n_points = 1000, name = "egBlock") g2 = GfImFreq(indices = ['t2g1','t2g2','t2g3'], beta = 50, n_points = 1000, name = "t2gBlock") G = BlockGf(name_list = ('eg','t2g'), block_list = (g1,g2), make_copies = False) mpi.bcast(G) #imtime from pytriqs.gf import * # A Green's function on the Matsubara axis set to a semicircular gw = GfImFreq(indices = [1], beta = 50) gw << SemiCircular(half_bandwidth = 1)
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]))) return histo if mpi.is_master_node(): arch = HDFArchive('asymm_bath.h5', 'w') # Set hybridization function for e in epsilon: delta_w = GfImFreq(indices=[0], beta=beta) delta_w << (V**2) * inverse(iOmega_n - e) S.G0_iw["up"] << inverse(iOmega_n - ed - delta_w) S.G0_iw["dn"] << inverse(iOmega_n - ed - delta_w) S.solve(h_int=H, **p) if mpi.is_master_node(): arch.create_group('epsilon_' + str(e)) gr = arch['epsilon_' + str(e)] gr['G_tau'] = S.G_tau gr['beta'] = beta gr['U'] = U gr['ed'] = ed gr['V'] = V gr['e'] = e
def make_calc(): # ------------------------------------------------------------------ # -- Read precomputed ED data filename = "bse_and_rpa_loc_vs_latt.tar.gz" p = read_TarGZ_HDFArchive(filename)['p'] # ------------------------------------------------------------------ # -- RPA tensor 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(p.gf_struct) p.U_abcd = get_rpa_tensor(p.H_int, fundamental_operators) # ------------------------------------------------------------------ # -- Generalized PH susceptibility loc_bse = ParameterCollection() loc_bse.chi_wnn = chi_from_gg2_PH(p.G_iw, p.G2_iw_ph) loc_bse.chi0_wnn = chi0_from_gg2_PH(p.G_iw, p.G2_iw_ph) loc_bse.gamma_wnn = inverse_PH(loc_bse.chi0_wnn) - inverse_PH( loc_bse.chi_wnn) loc_bse.chi_wnn_ref = inverse_PH( inverse_PH(loc_bse.chi0_wnn) - loc_bse.gamma_wnn) np.testing.assert_array_almost_equal(loc_bse.chi_wnn.data, loc_bse.chi_wnn_ref.data) from triqs_tprf.bse import solve_local_bse loc_bse.gamma_wnn_ref = solve_local_bse(loc_bse.chi0_wnn, loc_bse.chi_wnn) np.testing.assert_array_almost_equal(loc_bse.gamma_wnn.data, loc_bse.gamma_wnn_ref.data) loc_bse.chi0_w = trace_nn(loc_bse.chi0_wnn) loc_bse.chi_w = trace_nn(loc_bse.chi_wnn) # ------------------------------------------------------------------ # -- RPA, using BSE inverses and constant Gamma loc_rpa = ParameterCollection() loc_rpa.chi0_wnn = loc_bse.chi0_wnn loc_rpa.chi0_w = loc_bse.chi0_w loc_rpa.U_abcd = p.U_abcd # -- Build constant gamma from triqs_tprf.rpa_tensor import get_gamma_rpa loc_rpa.gamma_wnn = get_gamma_rpa(loc_rpa.chi0_wnn, loc_rpa.U_abcd) # -- Solve RPA loc_rpa.chi_wnn = inverse_PH( inverse_PH(loc_rpa.chi0_wnn) - loc_rpa.gamma_wnn) loc_rpa.chi_w = trace_nn(loc_rpa.chi_wnn) # ------------------------------------------------------------------ # -- Bubble RPA on lattice lat_rpa = ParameterCollection() # -- Setup dummy lattice Green's function equal to local Green's function bz = BrillouinZone( BravaisLattice(units=np.eye(3), orbital_positions=[(0, 0, 0)])) periodization_matrix = np.diag(np.array(list([1] * 3), dtype=np.int32)) kmesh = MeshBrillouinZone(bz, periodization_matrix) wmesh = MeshImFreq(beta=p.beta, S='Fermion', n_max=p.nwf_gf) lat_rpa.g_wk = Gf(mesh=MeshProduct(wmesh, kmesh), target_shape=p.G_iw.target_shape) lat_rpa.g_wk[:, Idx(0, 0, 0)] = p.G_iw # -- chi0_wk bubble and chi_wk_rpa bubble RPA from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk lat_rpa.chi0_wk = imtime_bubble_chi0_wk(lat_rpa.g_wk, nw=1) from triqs_tprf.lattice import solve_rpa_PH lat_rpa.chi_wk = solve_rpa_PH(lat_rpa.chi0_wk, p.U_abcd) lat_rpa.chi0_w = lat_rpa.chi0_wk[:, Idx(0, 0, 0)] lat_rpa.chi_w = lat_rpa.chi_wk[:, Idx(0, 0, 0)] print '--> cf Tr[chi0] and chi0_wk' print loc_rpa.chi0_w.data.reshape((4, 4)).real print lat_rpa.chi0_w.data.reshape((4, 4)).real np.testing.assert_array_almost_equal(loc_rpa.chi0_w.data, lat_rpa.chi0_w.data, decimal=2) print 'ok!' print '--> cf Tr[chi_rpa] and chi_wk_rpa' print loc_rpa.chi_w.data.reshape((4, 4)).real print lat_rpa.chi_w.data.reshape((4, 4)).real np.testing.assert_array_almost_equal(loc_rpa.chi_w.data, lat_rpa.chi_w.data, decimal=2) print 'ok!' # ------------------------------------------------------------------ # -- Lattice BSE lat_bse = ParameterCollection() lat_bse.g_wk = lat_rpa.g_wk lat_bse.mu = p.mu lat_bse.e_k = Gf(mesh=kmesh, target_shape=p.G_iw.target_shape) lat_bse.e_k[Idx(0, 0, 0)] = np.eye(2) lat_bse.sigma_w = p.G_iw.copy() lat_bse.sigma_w << iOmega_n + lat_bse.mu * np.eye(2) - lat_bse.e_k[Idx( 0, 0, 0)] - inverse(p.G_iw) lat_bse.g_wk_ref = lat_bse.g_wk.copy() lat_bse.g_wk_ref[:, Idx(0, 0, 0)] << inverse(iOmega_n + lat_bse.mu * np.eye(2) - lat_bse.e_k[Idx(0, 0, 0)] - lat_bse.sigma_w) np.testing.assert_array_almost_equal(lat_bse.g_wk.data, lat_bse.g_wk_ref.data) #for w in lat_bse.g_wk.mesh.components[0]: # print w, lat_bse.g_wk[w, Idx(0,0,0)][0, 0] from triqs_tprf.lattice import fourier_wk_to_wr lat_bse.g_wr = fourier_wk_to_wr(lat_bse.g_wk) from triqs_tprf.lattice import chi0r_from_gr_PH lat_bse.chi0_wnr = chi0r_from_gr_PH(nw=1, nn=p.nwf, g_nr=lat_bse.g_wr) from triqs_tprf.lattice import chi0q_from_chi0r lat_bse.chi0_wnk = chi0q_from_chi0r(lat_bse.chi0_wnr) #for n in lat_bse.chi0_wnk.mesh.components[1]: # print n.value, lat_bse.chi0_wnk[Idx(0), n, Idx(0,0,0)][0,0,0,0] # -- Lattice BSE calc from triqs_tprf.lattice import chiq_from_chi0q_and_gamma_PH lat_bse.chi_kwnn = chiq_from_chi0q_and_gamma_PH(lat_bse.chi0_wnk, loc_bse.gamma_wnn) # -- Lattice BSE calc with built in trace from triqs_tprf.lattice import chiq_sum_nu_from_chi0q_and_gamma_PH lat_bse.chi_kw_ref = chiq_sum_nu_from_chi0q_and_gamma_PH( lat_bse.chi0_wnk, loc_bse.gamma_wnn) # -- Lattice BSE calc with built in trace using g_wk from triqs_tprf.lattice import chiq_sum_nu_from_g_wk_and_gamma_PH lat_bse.chi_kw_tail_corr_ref = chiq_sum_nu_from_g_wk_and_gamma_PH( lat_bse.g_wk, loc_bse.gamma_wnn) # -- Trace results from triqs_tprf.lattice import chi0q_sum_nu_tail_corr_PH from triqs_tprf.lattice import chi0q_sum_nu lat_bse.chi0_wk_tail_corr = chi0q_sum_nu_tail_corr_PH(lat_bse.chi0_wnk) lat_bse.chi0_wk = chi0q_sum_nu(lat_bse.chi0_wnk) from triqs_tprf.lattice import chiq_sum_nu, chiq_sum_nu_q lat_bse.chi_kw = chiq_sum_nu(lat_bse.chi_kwnn) np.testing.assert_array_almost_equal(lat_bse.chi_kw.data, lat_bse.chi_kw_ref.data) from triqs_tprf.bse import solve_lattice_bse lat_bse.chi_kw_tail_corr, tmp = solve_lattice_bse(lat_bse.g_wk, loc_bse.gamma_wnn) from triqs_tprf.bse import solve_lattice_bse_e_k_sigma_w lat_bse.chi_kw_tail_corr_new = solve_lattice_bse_e_k_sigma_w( lat_bse.mu, lat_bse.e_k, lat_bse.sigma_w, loc_bse.gamma_wnn) np.testing.assert_array_almost_equal(lat_bse.chi_kw_tail_corr.data, lat_bse.chi_kw_tail_corr_ref.data) np.testing.assert_array_almost_equal(lat_bse.chi_kw_tail_corr.data, lat_bse.chi_kw_tail_corr_new.data) np.testing.assert_array_almost_equal(lat_bse.chi_kw_tail_corr_ref.data, lat_bse.chi_kw_tail_corr_new.data) lat_bse.chi0_w_tail_corr = lat_bse.chi0_wk_tail_corr[:, Idx(0, 0, 0)] lat_bse.chi0_w = lat_bse.chi0_wk[:, Idx(0, 0, 0)] lat_bse.chi_w_tail_corr = lat_bse.chi_kw_tail_corr[Idx(0, 0, 0), :] lat_bse.chi_w = lat_bse.chi_kw[Idx(0, 0, 0), :] print '--> cf Tr[chi0_wnk] and chi0_wk' print lat_bse.chi0_w_tail_corr.data.reshape((4, 4)).real print lat_bse.chi0_w.data.reshape((4, 4)).real print lat_rpa.chi0_w.data.reshape((4, 4)).real np.testing.assert_array_almost_equal(lat_bse.chi0_w_tail_corr.data, lat_rpa.chi0_w.data) np.testing.assert_array_almost_equal(lat_bse.chi0_w.data, lat_rpa.chi0_w.data, decimal=2) print 'ok!' print '--> cf Tr[chi_kwnn] and chi_wk (without chi0 tail corr)' print lat_bse.chi_w.data.reshape((4, 4)).real print loc_bse.chi_w.data.reshape((4, 4)).real np.testing.assert_array_almost_equal(lat_bse.chi_w.data, loc_bse.chi_w.data) print 'ok!' # ------------------------------------------------------------------ # -- Use chi0 tail corrected trace to correct chi_rpa cf bubble dchi_wk = lat_bse.chi0_wk_tail_corr - lat_bse.chi0_wk dchi_w = dchi_wk[:, Idx(0, 0, 0)] loc_rpa.chi_w_tail_corr = loc_rpa.chi_w + dchi_w # -- this will be the same, but it will be close to the real physical value lat_bse.chi_w_tail_corr_ref = lat_bse.chi_w + dchi_w loc_bse.chi_w_tail_corr_ref = loc_bse.chi_w + dchi_w print '--> cf Tr[chi_rpa] and chi_wk_rpa' print loc_rpa.chi_w.data.reshape((4, 4)).real print loc_rpa.chi_w_tail_corr.data.reshape((4, 4)).real print lat_rpa.chi_w.data.reshape((4, 4)).real np.testing.assert_array_almost_equal(loc_rpa.chi_w_tail_corr.data, lat_rpa.chi_w.data, decimal=3) print '--> cf Tr[chi_kwnn] with tail corr (from chi0_wnk)' print lat_bse.chi_w_tail_corr.data.reshape((4, 4)).real print lat_bse.chi_w_tail_corr_ref.data.reshape((4, 4)).real np.testing.assert_array_almost_equal(lat_bse.chi_w_tail_corr.data, lat_bse.chi_w_tail_corr_ref.data) print 'ok!' # ------------------------------------------------------------------ # -- Store to hdf5 filename = 'data_bse_rpa.h5' with HDFArchive(filename, 'w') as res: res['p'] = p
Ek = np.array([ [1.00, 0.5], [0.5, -1.20], ]) E_loc = np.array([ [0.33, 0.5], [0.5, -0.1337], ]) V = np.array([ [1.0, 0.25], [0.25, -1.0], ]) Delta_iw << inverse( iOmega_n - Ek ) + inverse( iOmega_n + Ek ) - E_loc Delta_iw.from_L_G_R(V, Delta_iw, V) Delta_iw_ref = Delta_iw.copy() noise_ampl = 1e-3 def get_noise(): return 2.*np.random.random() - 1. for w in wmesh: re = Delta_iw[w].real + noise_ampl * get_noise() * np.abs(w.value)**2 im = Delta_iw[w].imag + noise_ampl * get_noise() * np.abs(w.value)**2 Delta_iw[w] = re + 1.j * im
# -- 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 S = SolverCore(**p.solver_core.dict()) S.G0_iw << p.G0_iw S.solve(**p.solve.dict()) # -- Store to hdf5 archive p.grab_attribs(S, p.store_list) if mpi.is_master_node(): with HDFArchive("data_ctint.h5", 'w') as results: results["p"] = p
def five_plus_five(use_interaction=True): results_file_name = "5_plus_5." + ("int." if use_interaction else "") + "h5" # Block structure of GF L = 2 # d-orbital spin_names = ("up", "dn") orb_names = cubic_names(L) # Input parameters beta = 40. mu = 26 U = 4.0 J = 0.7 F0 = U F2 = J * (14.0 / (1.0 + 0.63)) F4 = F2 * 0.63 # Dump the local Hamiltonian to a text file (set to None to disable dumping) H_dump = "H.txt" # Dump Delta parameters to a text file (set to None to disable dumping) Delta_dump = "Delta_params.txt" # Hybridization function parameters # Delta(\tau) is diagonal in the basis of cubic harmonics # Each component of Delta(\tau) is represented as a list of single-particle # terms parametrized by pairs (V_k,\epsilon_k). delta_params = { "xy": { 'V': 0.2, 'e': -0.2 }, "yz": { 'V': 0.2, 'e': -0.15 }, "z^2": { 'V': 0.2, 'e': -0.1 }, "xz": { 'V': 0.2, 'e': 0.05 }, "x^2-y^2": { 'V': 0.2, 'e': 0.4 } } atomic_levels = { ('up_xy', 0): -0.2, ('dn_xy', 0): -0.2, ('up_yz', 0): -0.15, ('dn_yz', 0): -0.15, ('up_z^2', 0): -0.1, ('dn_z^2', 0): -0.1, ('up_xz', 0): 0.05, ('dn_xz', 0): 0.05, ('up_x^2-y^2', 0): 0.4, ('dn_x^2-y^2', 0): 0.4 } 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"] = 5000 p["n_warmup_cycles"] = 500 p["n_cycles"] = int(1.e1 / mpi.size) #p["n_cycles"] = int(5.e5 / mpi.size) #p["n_cycles"] = int(5.e6 / mpi.size) p["partition_method"] = "autopartition" p["measure_G_tau"] = True p["move_shift"] = True p["move_double"] = True p["measure_pert_order"] = False p["performance_analysis"] = False p["use_trace_estimator"] = False mpi.report("Welcome to 5+5 (5 orbitals + 5 bath sites) test.") gf_struct = set_operator_structure(spin_names, orb_names, False) mkind = get_mkind(False, None) H = Operator() if use_interaction: # Local Hamiltonian U_mat = U_matrix(L, [F0, F2, F4], basis='cubic') H += h_int_slater(spin_names, orb_names, U_mat, False, H_dump=H_dump) else: mu = 0. p["h_int"] = H # Quantum numbers (N_up and N_down) QN = [Operator(), Operator()] for cn in orb_names: for i, sn in enumerate(spin_names): QN[i] += n(*mkind(sn, cn)) if 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...") H_hyb = Operator() # Set hybridization function if Delta_dump: Delta_dump_file = open(Delta_dump, 'w') for sn, cn in product(spin_names, orb_names): bn, i = mkind(sn, cn) V = delta_params[cn]['V'] e = delta_params[cn]['e'] delta_w = Gf(mesh=MeshImFreq(beta, 'Fermion', n_iw), target_shape=[]) delta_w << (V**2) * inverse(iOmega_n - e) S.G0_iw[bn][i, i] << inverse(iOmega_n + mu - atomic_levels[(bn, i)] - delta_w) cnb = cn + '_b' # bath level a = sn + '_' + cn b = sn + '_' + cn + '_b' H_hyb += ( atomic_levels[(bn,i)] - mu ) * n(a, 0) + \ n(b,0) * e + V * ( c(a,0) * c_dag(b,0) + c(b,0) * c_dag(a,0) ) # Dump Delta parameters if Delta_dump: Delta_dump_file.write(bn + '\t') Delta_dump_file.write(str(V) + '\t') Delta_dump_file.write(str(e) + '\n') if mpi.is_master_node(): filename_ham = 'data_Ham%s.h5' % ('_int' if use_interaction else '') with HDFArchive(filename_ham, 'w') as arch: arch['H'] = H_hyb + H arch['gf_struct'] = gf_struct arch['beta'] = beta mpi.report("Running the simulation...") # Solve the problem S.solve(**p) # Save the results if mpi.is_master_node(): Results = HDFArchive(results_file_name, 'w') Results['G_tau'] = S.G_tau Results['G0_iw'] = S.G0_iw Results['use_interaction'] = use_interaction Results['delta_params'] = delta_params Results['spin_names'] = spin_names Results['orb_names'] = orb_names import __main__ Results.create_group("log") log = Results["log"] log["version"] = version.version log["triqs_hash"] = version.triqs_hash log["cthyb_hash"] = version.cthyb_hash log["script"] = inspect.getsource(__main__)
from pytriqs.gf import GfReFreq, Omega, Wilson, inverse import numpy eps_d, t = 0.3, 0.2 # Create the real-frequency Green's function and initialize it g = GfReFreq(indices=['s', 'd'], window=(-2, 2), n_points=1000, name="$G_\mathrm{s+d}$") g['d', 'd'] = Omega - eps_d g['d', 's'] = t g['s', 'd'] = t g['s', 's'] = inverse(Wilson(1.0)) g.invert() # Plot it with matplotlib. 'S' means: spectral function ( -1/pi Imag (g) ) from pytriqs.plot.mpl_interface import oplot, plt oplot(g['d', 'd'], '-o', RI='S', x_window=(-1.8, 1.8), name="Impurity") oplot(g['s', 's'], '-x', RI='S', x_window=(-1.8, 1.8), name="Bath") plt.show()
def anderson(use_qn=True, use_blocks=True): spin_names = ("up","dn") mkind = lambda spin: (spin,0) if use_blocks else ("tot",spin) # Input parameters beta = 10.0 U = 2.0 mu = 1.0 h = 0.1 V = 0.5 epsilon = 2.3 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"] = 50000 p["n_cycles"] = 5000000 p["measure_density_matrix"] = True p["use_norm_as_weight"] = True results_file_name = "anderson" if use_blocks: results_file_name += ".block" if use_qn: results_file_name += ".qn" results_file_name += ".h5" mpi.report("Welcome to Anderson (1 correlated site + symmetric bath) test.") H = U*n(*mkind("up"))*n(*mkind("dn")) QN = [] if use_qn: for spin in spin_names: QN.append(n(*mkind(spin))) p["quantum_numbers"] = QN p["partition_method"] = "quantum_numbers" 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() ] # convert from dict to list of lists 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 delta_w = GfImFreq(indices = [0], beta=beta) delta_w << (V**2) * inverse(iOmega_n - epsilon) + (V**2) * inverse(iOmega_n + epsilon) for spin in spin_names: bn, i = mkind(spin) S.G0_iw[bn][i,i] << inverse(iOmega_n + mu - {'up':h,'dn':-h}[spin] - delta_w) mpi.report("Running the simulation...") # Solve the problem S.solve(h_int=H, **p) # Save the results if mpi.is_master_node(): static_observables = {'Nup' : n(*mkind("up")), 'Ndn' : n(*mkind("dn")), 'unity' : Operator(1.0)} dm = S.density_matrix for oname in static_observables.keys(): print oname, trace_rho_op(dm,static_observables[oname],S.h_loc_diagonalization) with HDFArchive(results_file_name,'w') as Results: Results['G_tau'] = S.G_tau
} gm_swap_atoms = { 'swap_atoms': { mkind("up", 1): mkind("up", 2), mkind("dn", 1): mkind("dn", 2), mkind("up", 2): mkind("up", 1), mkind("dn", 2): mkind("dn", 1) } } # Construct the solver S = SolverCore(beta=beta, gf_struct=gf_struct, n_tau=n_tau, n_iw=n_iw) # Set hybridization function delta_w = GfImFreq(indices=[1, 2], beta=beta) delta_w << (V**2) * (inverse(iOmega_n - epsilon) + inverse(iOmega_n + epsilon)) for sn in spin_names: S.G0_iw[sn] << inverse(iOmega_n - np.matrix([[-mu, t], [t, -mu]]) - delta_w) if mpi.is_master_node(): arch = HDFArchive( "move_global_beta%.0f_prob%.2f.h5" % (beta, move_global_prob), 'w') arch['beta'] = beta arch['move_global_prob'] = move_global_prob static_observables = { "N1_up": n(*mkind("up", 1)), "N1_dn": n(*mkind("dn", 1)), "N2_up": n(*mkind("up", 2)), "N2_dn": n(*mkind("dn", 2))
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 delta_w = GfImFreq(indices = [0], beta=beta, n_points=n_iw) delta_w << (V**2) * inverse(iOmega_n - epsilon) + (V**2) * inverse(iOmega_n + epsilon) S.G0_iw << inverse(iOmega_n + 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['G_tau'] = S.G_tau
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) mpi.report("Preparing the hybridization function...") # Set hybridization function delta_w = Gf(mesh=S.G0_iw.mesh, target_shape=[]) delta_w << (V**2) * inverse(iOmega_n - epsilon1) + (V**2) * inverse(iOmega_n - epsilon2) for spin in spin_names: bn, i = mkind(spin) S.G0_iw[bn][i, i] << inverse(iOmega_n + mu - { 'up': h, 'dn': -h }[spin] - delta_w) mpi.report("Running the simulation...") # Solve the problem S.solve(h_int=H, **p) # Save the results if mpi.is_master_node():