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 = MeshBrZone(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 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 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 extract_deltaiw_and_tij_from_G0(G0_iw, gf_struct): iw_mesh = G0_iw.mesh 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() #print "---------------" #print "tail", tail H_loc = tail[2] #print "---------------" #print "H_loc", H_loc Delta_iw[block] << iOmega_n - H_loc - inverse(g0_iw) H_loc_block.append(H_loc) return Delta_iw, H_loc_block
# Import the Green's functions from triqs.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 triqs.plot.mpl_interface import oplot oplot(g, '-o', x_window=(0, 10))
orb_names = [0] # ==== Local Hamiltonian ==== h_0 = - mu*( n('up',0) + n('dn',0) ) - h*( n('up',0) - n('dn',0) ) h_int = U * n('up',0) * n('dn',0) h_imp = h_0 + h_int # ==== Bath & Coupling Hamiltonian ==== h_bath, h_coup = 0, 0 for i, E_i, V_i in zip([0, 1], E, V): for sig in ['up','dn']: h_bath += E_i * n(sig,'b_' + str(i)) h_coup += V_i * (c_dag(sig,0) * c(sig,'b_' + str(i)) + c_dag(sig,'b_' + str(i)) * c(sig,0)) # ==== Total impurity hamiltonian and fundamental operators ==== h_tot = h_imp + h_coup + h_bath # ==== Green function structure ==== gf_struct = [ [s, orb_names] for s in spin_names ] # ==== Hybridization Function ==== n_iw = int(10 * beta) iw_mesh = MeshImFreq(beta, 'Fermion', n_iw) Delta = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) Delta << sum([V_i*V_i * inverse(iOmega_n - E_i) for V_i,E_i in zip(V, E)]); # ==== Non-Interacting Impurity Green function ==== G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) G0_iw['up'] << inverse(iOmega_n + mu + h - Delta['up']) G0_iw['dn'] << inverse(iOmega_n + mu - h - Delta['dn'])
mu = 2. # Chemical potential U = 5. # On-site density-density interaction h = 0.2 # Local magnetic field Gamma = 1. # Hybridization energy spin_names = ['up', 'dn'] orb_names = [0] # ==== Local Hamiltonian ==== h_0 = - mu*( n('up',0) + n('dn',0) ) - h*( n('up',0) - n('dn',0) ) h_int = U * n('up',0) * n('dn',0) h_imp = h_0 + h_int # ==== Green function structure ==== gf_struct = [ [s, orb_names] for s in spin_names ] # ==== Hybridization Function ==== n_iw = int(10 * beta) iw_mesh = MeshImFreq(beta, 'Fermion', n_iw) Delta = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) Delta << 0.; for iw in Delta['up'].mesh: Delta['up'][iw] = -1j * Gamma * sign(iw.imag) Delta['dn'][iw] = -1j * Gamma * sign(iw.imag) # ==== Non-Interacting Impurity Green function ==== G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) G0_iw['up'] << inverse(iOmega_n + mu + h - Delta['up']) G0_iw['dn'] << inverse(iOmega_n + mu - h - Delta['dn'])
# -- 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
from triqs.plot.mpl_interface import oplot from triqs.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 triqs.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))
h_imp = h_0 + h_int # ==== Bath & Coupling hamiltonian ==== orb_bath_names = ['b_' + str(o) for o in orb_names] c_dag_bath_vec = { s: matrix([[c_dag(s, o) for o in orb_bath_names]]) for s in spin_names } c_bath_vec = { s: matrix([[c(s, o)] for o in orb_bath_names]) for s in spin_names } h_bath = sum(c_dag_bath_vec[s] * h_bath_mat * c_bath_vec[s] for s in spin_names)[0,0] h_coup = sum(c_dag_vec[s] * V_mat * c_bath_vec[s] + c_dag_bath_vec[s] * V_mat * c_vec[s] for s in spin_names)[0,0] # FIXME Adjoint # ==== Total impurity hamiltonian ==== h_tot = h_imp + h_coup + h_bath # ==== Green function structure ==== gf_struct = [ [s, orb_names] for s in spin_names ] # ==== Non-Interacting Impurity Green function ==== n_iw = int(10 * beta) iw_mesh = MeshImFreq(beta, 'Fermion', n_iw) G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) h_tot_mat = block([[h_0_mat, V_mat ], [V_mat.H, h_bath_mat]]) for bl, iw in product(spin_names, iw_mesh): G0_iw[bl][iw] = inv(iw.value * eye(2*n_orb) - h_tot_mat)[:n_orb, :n_orb] # ==== Hybridization Function ==== Delta = G0_iw.copy() Delta['up'] << iOmega_n - h_0_mat - inverse(G0_iw['up']) Delta['dn'] << iOmega_n - h_0_mat - inverse(G0_iw['dn'])
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 << Fourier(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 triqs.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 triqs.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()
orb_names = [i for i in range(norb)] gf_struct = [[s, orb_names] for s in spin_names] ### generate hybridisation function iw_mesh = MeshImFreq(beta, 'Fermion', niw) Delta_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) ### generate random values for hybridisation function for block, delta_iw in Delta_iw: ### generate random hermitian bath energies s = (norb, norb) eps = 5.0 * (np.random.random(s) - 0.5) + 3.j * (np.random.random(s) - 0.5) eps = eps + np.conjugate(eps.T) delta_block = inverse(iOmega_n - eps) delta_iw << delta_block ### multiply everything (element-wise) with hermitian matrix ### since Delta(iw) does not have high frequency tail of 1 randmat = 5.0 * (np.random.random(s) - 0.5) + 3.j * (np.random.random(s) - 0.5) randmat = randmat + np.conjugate(randmat.T) for ni, i in enumerate(delta_iw.data): delta_iw.data[ni, :, :, ] = np.multiply(i, randmat) ### generate G0 G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) H_0_original = []
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=int)) kmesh = MeshBrZone(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
h_imp = h_0 + h_int # ==== Bath & Coupling hamiltonian ==== c_dag_bath_vec = matrix( [[c_dag('bl', o) for o in range(n_orb, n_orb + n_orb_bath)]]) c_bath_vec = matrix([[c('bl', o)] for o in range(n_orb, n_orb + n_orb_bath)]) h_bath = (c_dag_bath_vec * h_bath_mat * c_bath_vec)[0, 0] h_coup = (c_dag_vec * V_mat * c_bath_vec + c_dag_bath_vec * V_mat * c_vec)[0, 0] # FIXME Adjoint # ==== Total impurity hamiltonian ==== h_tot = h_imp + h_coup + h_bath # ==== Green function structure ==== gf_struct = [('bl', n_orb)] # ==== Hybridization Function ==== n_iw = int(10 * beta) iw_mesh = MeshImFreq(beta, 'Fermion', n_iw) Delta = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) # FIXME Delta['bl'] << V_mat * inverse(iOmega_n - h_bath_mat) * V_mat.transpose() for iw in iw_mesh: Delta['bl'][iw] = V_mat * inv(iw.value * eye(n_orb) - h_bath_mat) * V_mat.transpose() # ==== Non-Interacting Impurity Green function ==== G0_iw = Delta.copy() G0_iw['bl'] << inverse(iOmega_n - h_0_mat - Delta['bl'])
h_int = h_int_kanamori(block_names, orb_names, Umat, Upmat, J, off_diag=True, map_operator_structure=op_map) h_imp = h_0 + h_int # ==== Non-Interacting Impurity Green function ==== iw_mesh = MeshImFreq(beta, 'Fermion', n_iw) k_mesh = MeshBrZone(TBL.bz, n_k) k_iw_mesh = MeshProduct(k_mesh, iw_mesh) G0_k_iw = BlockGf(mesh=k_iw_mesh, gf_struct=gf_struct) G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) iw_vec = array([iw.value * np.eye(n_idx) for iw in iw_mesh]) k_vec = array([k.value for k in k_mesh]) e_k_vec = TBL.hopping(k_vec.T.copy() / 2. / pi).transpose(2, 0, 1) mu_mat = mu * np.eye(n_idx) G0_k_iw['bl'].data[:] = linalg.inv(iw_vec[None, ...] + mu_mat[None, None, ...] - e_k_vec[::, None, ...]) G0_iw['bl'].data[:] = np.sum(G0_k_iw['bl'].data[:], axis=0) / len(k_mesh) # ==== Hybridization Function ==== Delta = G0_iw.copy() Delta['bl'] << iOmega_n + mu_mat - h_0_mat - inverse(G0_iw['bl'])
def run_test(t1, filename): dptkeys = [ 'verbosity', 'calculate_sigma', 'calculate_sigma1', 'calculate_sigma2' ] parms = { # Solver parameters 'n_iw': 100, # Physical parameters 'U': 0.5, 't1': t1, 'beta': 10, # DMFT loop control parameters 'calculate_sigma': True, 'calculate_sigma1': True, 'calculate_sigma2': True, 'measure_G2_iw_ph': True, "measure_G2_n_bosonic": 10, "measure_G2_n_fermionic": 10, "verbosity": 4, } parms["N_x"] = 2 parms["N_y"] = 1 parms["N_z"] = 1 parms["ksi_delta"] = 1.0 # Chemical potential depends on the definition of H(k) that is used parms['chemical_potential_bare'] = 0. parms['chemical_potential'] = parms['U'] / 2. + parms[ 'chemical_potential_bare'] n_orbs = 1 # Number of orbitals off_diag = True spin_names = ['up', 'dn'] # Outer (non-hybridizing) blocks orb_names = ['%s' % i for i in range(n_orbs)] # Orbital indices gf_struct = op.set_operator_structure(spin_names, orb_names, off_diag=off_diag) if haspomerol: ##### # # Reference: 4 site cluster, calculate only G, not G2 # ##### def calc_reference(): ref_orbs = [ '%s' % i for i in range(n_orbs * parms['N_x'] * parms['N_y']) ] ref_gf_struct = op.set_operator_structure(spin_names, ref_orbs, off_diag=off_diag) ref_index_converter = {(sn, o): ("loc", int(o), "down" if sn == "dn" else "up") for sn, o in product(spin_names, ref_orbs)} #print ref_index_converter,ref_orbs ref_ed = PomerolED(ref_index_converter, verbose=True) ref_N = sum( ops.n(sn, o) for sn, o in product(spin_names, ref_orbs)) # 2 3 # 0 1 ref_H = (parms["U"] * (ops.n('up', '0') * ops.n('dn', '0') + ops.n('up', '1') * ops.n('dn', '1')) - 2. * parms['t1'] * (ops.c_dag('up', '0') * ops.c('up', '1') + ops.c_dag('up', '1') * ops.c('up', '0') + ops.c_dag('dn', '0') * ops.c('dn', '1') + ops.c_dag('dn', '1') * ops.c('dn', '0')) - parms['chemical_potential'] * ref_N) # Run the solver ref_ed.diagonalize(ref_H) # Compute G(i\omega) ref_G_iw = ref_ed.G_iw(ref_gf_struct, parms['beta'], parms['n_iw']) return ref_G_iw ref_G_iw = calc_reference() ref = ref_G_iw[ref_spin] g2_blocks = set([("up", "up"), ("up", "dn"), ("dn", "up"), ("dn", "dn")]) index_converter = {(sn, o): ("loc", int(o), "down" if sn == "dn" else "up") for sn, o in product(spin_names, orb_names)} # 1 Bath degree of freedom # Level of the bath sites epsilon = [ -parms['chemical_potential_bare'], ] 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) N = sum(ops.n(sn, o) for sn, o in product(spin_names, orb_names)) H_loc = (parms["U"] * (ops.n('up', '0') * ops.n('dn', '0')) - parms['chemical_potential'] * N) # Bath Hamiltonian: levels H_bath = sum(eps * ops.n("B%i_%s" % (k, sn), 0) for sn, (k, eps) in product(spin_names, enumerate(epsilon))) # Hybridization Hamiltonian # Bath-impurity hybridization V = [ -2 * bath_prefactor * t1, ] H_hyb = ops.Operator() for k, v in enumerate(V): H_hyb += sum( v * ops.c_dag("B%i_%s" % (k, sn), 0) * ops.c(sn, '0') + np.conj(v) * ops.c_dag(sn, '0') * ops.c("B%i_%s" % (k, sn), 0) for sn in spin_names) # Obtain bath sites from Delta and create H_ED H_ED = H_loc + H_bath + H_hyb # Run the solver ed.diagonalize(H_ED) # Compute G(i\omega) G_iw = ed.G_iw(gf_struct, parms['beta'], parms['n_iw']) if parms["measure_G2_iw_ph"]: common_g2_params = { 'gf_struct': gf_struct, 'beta': parms['beta'], 'blocks': g2_blocks, 'n_iw': parms['measure_G2_n_bosonic'] } G2_iw = ed.G2_iw_inu_inup(channel="PH", block_order="AABB", n_inu=parms['measure_G2_n_fermionic'], **common_g2_params) if mpi.is_master_node(): with ar.HDFArchive(filename, 'w') as arch: arch["parms"] = parms arch["G_iw"] = G_iw arch["G2_iw"] = G2_iw arch["ref"] = ref else: # haspomerol is False with ar.HDFArchive(filename, 'r') as arch: ref = arch['ref'] G_iw = arch['G_iw'] G2_iw = arch['G2_iw'] BL = lattice.BravaisLattice(units=[ (1, 0, 0), ]) #linear lattice kmesh = gf.MeshBrillouinZone(lattice.BrillouinZone(BL), parms["N_x"]) Hk_blocks = [gf.Gf(indices=orb_names, mesh=kmesh) for spin in spin_names] Hk = gf.BlockGf(name_list=spin_names, block_list=Hk_blocks) def Hk_f(k): return -2 * parms['t1'] * (np.cos(k[0])) * np.eye(1) for spin, _ in Hk: for k in Hk.mesh: Hk[spin][k] = Hk_f(k.value) # Construct the DF2 program X = dualfermion.Dpt(beta=parms['beta'], gf_struct=gf_struct, Hk=Hk, n_iw=parms['n_iw'], n_iw2=parms["measure_G2_n_fermionic"], n_iW=parms["measure_G2_n_bosonic"]) for name, g0 in X.Delta: X.Delta[name] << gf.inverse( gf.iOmega_n + parms['chemical_potential_bare']) * bath_prefactor**2 * 4 * t1**2 X.G2_iw << G2_iw # Run the dual perturbation theory X.gimp << G_iw # Load G from impurity solver dpt_parms = {key: parms[key] for key in parms if key in dptkeys} X.run(**dpt_parms)
from triqs.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 triqs.plot.mpl_interface import oplot, plt oplot(g['d', 'd'], '-o', mode='S', x_window=(-1.8, 1.8), name="Impurity") oplot(g['s', 's'], '-x', mode='S', x_window=(-1.8, 1.8), name="Bath") plt.show()
# ==== Green function structure ==== gf_struct = [[s, orb_names] for s in spin_names] # ==== Hybridization Function ==== n_iw = int(10 * beta) iw_mesh = MeshImFreq(beta, 'Fermion', n_iw) Delta = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) # FIXME Delta['up'] << V_mat.transpose() * inverse(iOmega_n - h_bath_mat) * V_mat for bl, iw in product(spin_names, iw_mesh): Delta[bl][iw] = V_mat * inv(iw.value * eye(len(orb_bath_names)) - h_bath_mat) * V_mat.transpose() # ==== Non-Interacting Impurity Green function ==== G0_iw = Delta.copy() G0_iw['up'] << inverse( iOmega_n - h_0_mat - Delta['up']) # FIXME Should work for BlockGf G0_iw['dn'] << inverse(iOmega_n - h_0_mat - Delta['dn']) # ==== Construct the CTHYB solver using the G0_iw Interface ==== constr_params = { 'beta': beta, 'gf_struct': gf_struct, 'n_iw': n_iw, 'n_tau': 10000 } from w2dyn_cthyb import Solver S = Solver(**constr_params) # --------- Initialize G0_iw ---------- S.G0_iw << G0_iw
beta=10.0) beta = Delta_tau.mesh.beta n_iw = 100 n_tau = 1000 ### generate a hybridisation function iw_mesh = MeshImFreq(beta, 'Fermion', n_iw) Delta_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) for block, delta_iw in Delta_iw: s = (3, 3) eps = np.random.random(s) + 1.j * np.random.random(s) eps = eps + np.conjugate(eps.T) delta_block = inverse(iOmega_n - 0.3 * eps) delta_iw << delta_block ### generate the corresponding hybridisation function and hopping matrix G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct) H_loc_original = [] for block, g0_iw in G0_iw: #print "block", block s = (3, 3) H = np.random.random(s) + 1.j * np.random.random(s) H = H + np.conjugate(H.T) #print "" #print "H", H g0_iw << inverse(iOmega_n - H - Delta_iw[block])