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])
