def DMFT_SCC(fDelta, fileGf):
"""This subroutine creates Delta.inp from Gf.out for DMFT on bethe
lattice: Delta=t^2*G If Gf.out does not exist, it creates Gf.out
which corresponds to the non-interacting model In the latter case
also creates the inpurity cix file, which contains information
about the atomic states."""
w_n = gf.matsubara_freq(BETA, 3 * BETA)
try:
hyb = 0.25 * np.squeeze(np.load(fileGf))
# If output file exists, start from previous iteration
delta = np.array([w_n, hyb.real, hyb.imag])
if args.AFM:
delta = np.array(
[w_n, hyb[1].real, hyb[1].imag, hyb[0].real, hyb[0].imag])
except Exception: # otherwise start from non-interacting limit
print('Starting from non-interacting model at beta' + str(BETA))
hyb = 0.25 * gf.greenF(w_n)
if args.insulator:
hyb = 0.25 * gf.greenF(w_n, sigma=-1j * args.U[0]**2 / 4 / w_n)
# creating impurity cix file
with open(params['cix'][0], 'w') as f:
f.write(icix)
# Preparing input file Delta.inp
delta = np.array([w_n, hyb.real, hyb.imag])
if args.AFM:
delta = np.array([w_n, hyb.real, hyb.imag, hyb.real, hyb.imag])
np.savetxt(fDelta, delta.T)
def plot_tails(BETA, U, tp, ax=None):
w_n = gf.matsubara_freq(BETA, BETA, BETA / 2.)
if ax is None:
ax = plt
ax.plot(w_n, -1 / w_n, '--')
ax.plot(w_n, -tp / w_n**2, '--')
ax.plot(w_n, -1 / w_n + (U**2 / 4 + 0.25) / w_n**3, '--')
def processing(BETA, U, tp, ax):
with tdp.HDFArchive('DIMER_PM_B{}_tp0.3.h5'.format(BETA)) as data:
# print(data)
giw = tdp.get_giw(data['U' + str(U)], slice(-1, -3, -1))
giw_s = np.squeeze(.5 * (giw['sym_up'].data + giw['sym_dw'].data))
giw_s = giw_s[len(giw_s) / 2:len(giw_s) / 2 + 300]
w_n = gf.matsubara_freq(BETA, len(giw_s))
giw_a = np.squeeze(.5 * (giw['asym_up'].data + giw['asym_dw'].data))
giw_a = giw_a[len(giw_a) / 2:len(giw_a) / 2 + 300]
# more Avgs
giw_s = 0.5j * (giw_s + giw_a).imag + 0.5 * (giw_s - giw_a).real
x = int(.9 * BETA)
der1 = (giw_s.real * w_n**2)[x:int(1.2 * BETA)].mean()
der2 = ((giw_s.imag + 1 / w_n) * w_n**3)[x:int(1.2 * BETA)].mean()
tails = -1j / w_n + der1 / w_n**2 + der2 * 1j / w_n**3
giw_s[x:] = tails[x:]
sidab = 1j * w_n - tp - .25 * giw_s - 1 / giw_s
w = np.linspace(0, 1, 40)
swa = gf.pade_continuation(sidab, w_n[:int(1.8 * BETA)], 1j * w)
ax[0].plot(w_n, sidab.imag)
ax[0].plot(w, swa.imag, "k:")
ax[1].plot(w_n, sidab.real)
ax[1].plot(w, swa.real, "k:")
sig_11_0 = np.polyfit(w_n[:2], sidab.imag[:2], 1)[1]
rtp = np.polyfit(w_n[:2], sidab.real[:2], 1)[1]
return swa.imag[0], swa.real[0], sig_11_0, rtp
def test_pade():
"""Test pade Analytical Continuation for the semi-circular DOS"""
w_n = gf.matsubara_freq(200)
giw = gf.greenF(w_n)
omega = np.linspace(-0.7, 0.7, 100) # avoid semicircle edges
gw_ref = gf.greenF(-1j * omega + 1e-5)
pade_c = gf.pade_coefficients(giw, w_n)
gw_cont = gf.pade_rec(pade_c, omega, w_n)
assert np.allclose(gw_ref, gw_cont, 1e-3)
def test_hilbert_trans_integral(halfbandwidth):
"""Test hilbert transform of semi-circle to direct integral"""
w = np.linspace(-3, 3, 2**9)
w_n = gf.matsubara_freq(20)
giw = gf.greenF(w_n, D=halfbandwidth)
rho_w = dos.bethe_lattice(w, halfbandwidth / 2)
Apiw = np.array([simps(rho_w / (1j * iw - w), w) for iw in w_n])
assert np.allclose(Apiw, giw, 2e-4)
def collect_bined_saves():
binede_dat = glob('gtau_bin_*')
G = np.array([np.load(dfile) for dfile in binede_dat])
gtau = G.mean(1)
tau, w_n = gf.tau_wn_setup(dict(BETA=32., N_MATSUBARA=32))
fw = gf.matsubara_freq(32., 64, -63)
giw = gf.gt_fouriertrans(gtau, tau, w_n, [1., 0., .25 + 2.5**2 / 4])
sgiw = np.concatenate((giw.conj().T[::-1], giw.T))
np.savez('bined', w_n=fw, giw=sgiw)
def refine_mat_solution(end_solver, u_int):
"""Takes the end converged dmft solver in matsubara frequencies
and increases the range of the matsubara frequencies to get
nicer plots"""
beta = end_solver.beta
sim = TwoSite_Matsubara(beta, end_solver.t, beta)
sim.omega = 1j * matsubara_freq(beta)
sim.mu = end_solver.mu
sim.solve(u_int / 2, u_int, end_solver.hyb_V())
return sim
def test_tail_fit(moments):
wn = gf.matsubara_freq(50)
moment = np.array(moments)
tail = gf.tail(wn, moment * np.array([1j, 1, 1j]),
np.arange(len(moment)) + 1)
tailn = np.sum(
np.random.randn(len(wn), 2) * 0.00005 * np.array((1, 1j)), 1)
tail = tail + tailn
fit_moments = gf.lin_tail_fit(wn, tail, -20, 30)[1]
print(fit_moments - moment)
assert np.allclose(moment, fit_moments, atol=3e-3)
def refine_mat_solution(end_solver, u_int):
"""Takes the end converged dmft solver in matsubara frequencies
and increases the range of the matsubara frequencies to get
nicer plots"""
beta = end_solver.beta
sim = TwoSite_Matsubara(beta, end_solver.t, beta)
sim.omega = 1j*matsubara_freq(beta)
sim.mu = end_solver.mu
sim.solve(u_int/2, u_int, end_solver.hyb_V())
return sim
def test_tail_fit_semicirc():
wn = gf.matsubara_freq(50)
gci = gf.greenF(wn)
tailn = np.sum(
np.random.randn(len(wn), 2) * 0.00006 * np.array(
(1, 1j)), 1) / (wn**2 + 3)
tail = gci + tailn
fit_moments = gf.lin_tail_fit(wn, tail, -45, 45)[1]
moment = np.array((-1, 0, 0.25))
print(fit_moments - moment)
assert np.allclose(moment, fit_moments, atol=7e-3)
def test_hilbert_trans_func(halfbandwidth):
"""Test Hilbert transforms of semi-circle"""
# Match in the 2 forms
w_n = gf.matsubara_freq(200)
giw = gf.greenF(w_n, sigma=-1j / w_n, mu=-0.2, D=halfbandwidth)
ss = gf.semi_circle_hiltrans(1j * w_n - .2 + 1j / w_n, D=halfbandwidth)
assert np.allclose(ss, giw)
# corresponds to semi-circle
w = np.linspace(-3, 3, 2**9)
ss = gf.semi_circle_hiltrans(w + 1e-5j, D=halfbandwidth)
assert np.allclose(dos.bethe_lattice(w, halfbandwidth / 2),
-ss.imag / np.pi,
atol=1e-4)
def ploter(fname, args):
array = np.load(fname)
if args.transpose:
array = np.transpose(array)
print('The inspected array has a shape: {}'.format(array.shape))
x = np.arange(len(array))
if args.beta:
x = gf.matsubara_freq(args.beta, len(array))
if 'complex' in str(array.dtype):
plt.plot(x, array.real, '--')
plt.plot(x, array.imag, '-')
plt.title('-- is real, - is imaginary')
else:
plt.plot(x, array)
def plot_fit_dos(beta, avg, filestr='SB_PM_B{}', xlim=2):
"""Plot the evolution of the Green's function in DMFT iterations"""
_, axes = plt.subplots(1, 2, figsize=(13, 8))
u_range, fit_gf, lgiw = fit_dos(beta, avg, filestr)
w_n = gf.matsubara_freq(beta, len(lgiw[0]))
omega = np.arange(0, w_n[2], 0.05)
for u_int, gfit, giw in zip(u_range, fit_gf, lgiw):
axes[0].plot(w_n, giw.imag, 'o:', label='U=' + str(u_int))
axes[0].plot(omega, gfit(omega), 'k:')
axes[0].set_xlim([0, xlim])
axes[1].plot(u_range, [dos(0) for dos in fit_gf], 'o-')
plt.show()
plt.close()
def estimate_dos_at_fermi_level_U_vs_tp(tpr, ulist, beta, phase):
dos_fl = []
w_n = gf.matsubara_freq(beta, 3)
save_file = 'dimer_ipt_{}_B{}.npy'.format(phase, beta)
if os.path.exists(save_file):
return -np.load(save_file).T
for tp in tpr:
filestr = 'disk/phase_Dimer_ipt_{}_B{}/tp{:.3}/giw.npy'.format(
phase, beta, tp)
gfs = np.load(filestr)
dos_fl.append(
np.array([gf.fit_gf(w_n, gfs[i][0][:3])(0.) for i in ulist]))
np.save(save_file, dos_fl)
return -np.array(dos_fl).T
def estimate_dos_at_fermi_level_T_vs_U(tp, ulist, temp, phase):
dos_fl = []
save_file = 'dimer_ipt_{}_tp{:.2}.npy'.format(phase, tp)
if os.path.exists(save_file):
return -np.load(save_file)
for T in temp:
w_n = gf.matsubara_freq(1 / T, 3)
filestr = 'disk/phase_Dimer_ipt_{}_tp{}/B{:.5}/giw.npy'.format(
phase, tp, 1 / T)
gfs = np.load(filestr)
dos_fl.append(
np.array([gf.fit_gf(w_n, gfs[i][0][:3])(0.) for i in ulist]))
np.save(save_file, dos_fl)
return -np.array(dos_fl)
def dos_at_fermi_level_fixbeta(xlist, ylist, beta, phasename, datapath):
dos_fl = []
w_n = gf.matsubara_freq(beta, 3)
save_file = 'phase_dimer_ipt_{}.npy'.format(phasename)
if os.path.exists(save_file):
dos_fl = np.load(save_file)
return dos_fl
for xdat in xlist:
filestr = datapath.format(phasename, xdat)
gfs = np.load(filestr)
dos_fl.append(np.array([gf.fit_gf(w_n, gfs[i][0][:3])(0.)
for i in ylist]))
dos_fl = -np.array(dos_fl).T
np.save(save_file, dos_fl)
return dos_fl
def dos_at_fermi_level_temp(xlist, temp, phasename, datapath):
dos_fl = []
save_file = 'phase_dimer_ipt_{}.npy'.format(phasename)
if os.path.exists(save_file):
dos_fl = np.load(save_file)
return dos_fl
for T in temp:
w_n = gf.matsubara_freq(1 / T, 3)
filestr = datapath.format(phasename, 1 / T)
gfs = np.load(filestr)
dos_fl.append(np.array([gf.fit_gf(w_n, gfs[i][0][:3])(0.)
for i in xlist]))
dos_fl = -np.array(dos_fl)
np.save(save_file, dos_fl)
return dos_fl
def DMFT_SCC(fDelta):
"""This subroutine creates Delta.inp from Gf.out for DMFT on bethe
lattice: Delta=t^2*G If Gf.out does not exist, it creates Gf.out
which corresponds to the non-interacting model In the latter case
also creates the inpurity cix file, which contains information
about the atomic states."""
fileGf = 'Gf.out'
try:
Gf = np.loadtxt(fileGf).T
# If output file exists, start from previous iteration
except Exception: # otherwise start from non-interacting limit
print('Starting from non-interacting model at beta' + str(BETA))
w_n = gf.matsubara_freq(BETA)
Gf = gf.greenF(w_n)
Gf = np.array([w_n, Gf.real, Gf.imag])
# Preparing input file Delta.inp
delta = np.array(
[Gf[0], 0.25 * Gf[1], 0.25 * Gf[2], 0.25 * Gf[1], 0.25 * Gf[2]]).T
np.savetxt(fDelta, delta)
def test_dimer_energies(u_int, mu, tp, beta=100):
h_loc, (a_up, b_up, a_dw, b_dw) = dimer.hamiltonian(u_int, mu, tp)
e_imp = (tp * (a_up.T * b_up + a_dw.T * b_dw + b_up.T * a_up +
b_dw.T * a_dw)).todense()
eig_e, eig_v = op.diagonalize(h_loc.todense())
w_n = gf.matsubara_freq(beta, 2**8) # n=2**7=256
gf_di = op.gf_lehmann(eig_e, eig_v, a_up.T, beta, 1j * w_n)
gf_of = op.gf_lehmann(eig_e, eig_v, a_up.T, beta, 1j * w_n, b_up)
ekin_gf = dimer.ekin(gf_di, gf_of, w_n, tp, beta, 0)
ekin_ed = op.expected_value(e_imp, eig_e, eig_v, beta)
assert abs(ekin_ed - ekin_gf) < 5e-4
epot_gf = dimer.epot(gf_di, w_n, beta, u_int**2 / 4 + tp**2, ekin_gf,
u_int)
docc = (a_up.T * a_up * a_dw.T * a_dw +
b_up.T * b_up * b_dw.T * b_dw).todense()
epot_ed = op.expected_value(docc, eig_e, eig_v, beta) * u_int
assert abs(epot_ed - epot_gf) < 1e-3
def estimate_gap_U_vs_tp(tpr, u_range, beta, phase):
w_n = gf.matsubara_freq(beta, max(2**ceil(log(6 * beta) / log(2)), 256))
gaps = []
for tp in tpr:
filestr = 'disk/phase_Dimer_ipt_{}_B{}/tp{:.3}/giw.npy'.format(
phase, beta, tp)
gfs = np.load(filestr)
for i, u_int in enumerate(u_range):
gf_aa, gf_ab = 1j * gfs[i][0], gfs[i][1]
gr_ss, gr_sa = dimer.pade_diag(
gf_aa, gf_ab, w_n, np.arange(0, beta + 100, 9, dtype=np.int),
w)
gloc = (gr_ss + gr_sa) / 2
gaps.append(measure_gap(gloc, rw))
#plt.plot(w, -gloc.imag + i * 0.1)
#plt.plot(gaps[-1] / 2, i * 0.1, 'o')
gaps = np.array(gaps).reshape(len(tpr), len(u_range)).T
return gaps
Aw = data['Aw']
w = data['w']
plt.plot(w, Aw)
plt.show()
###############################################################################
# High temperature seeds
# ----------------------
hot_beta = np.round(1 / np.arange(1 / 25, .2, 1.44e-3), 3)
gfsiw = []
wnli = []
for beta in hot_beta:
freq = 2 * int(beta * 3)
wnh = gf.matsubara_freq(beta, freq, 1 - freq)
wnli.append(wnh)
print(beta)
gfsiw.append(hilbert_trans(1j * wnh, w, differential_weight(w), Aw, 0))
plt.plot(wnh, gfsiw[-1].imag, 'o:')
plt.plot(wnh, gfsiw[-1].real, 'o:')
# triqs blocks
gfarr = GfImFreq(indices=[0], beta=beta, n_points=int(beta * 3))
G_iw = BlockGf(name_list=['asym_dw', 'asym_up', 'sym_dw', 'sym_up'],
block_list=(gfarr, gfarr, gfarr, gfarr), make_copies=True)
dlat.gf_sym_2_triqs_blockgf(gfsiw[-1], G_iw, u_int, tp)
with HDFArchive('DIMER_PM_met_B{}_tp0.3.h5'.format(beta), 'a') as dest:
dest['/U{}/it000/G_iw'.format(u_int)] = G_iw
def __init__(self, beta=100, t=1, nfreq=20):
super(TwoSite_Matsubara, self).__init__(beta, t)
self.omega = 1j*matsubara_freq(beta, nfreq)
self.solve(0, 0, 0)
f, axw = plt.subplots(2, sharex=True)
f.subplots_adjust(hspace=0)
w = np.linspace(-1.5, 1.5, 500) + 1j*1e-2
for mu, c in zip(mu_v, c_v):
gws = gf(w, M, mu, beta)
for gw in gws:
first = np.allclose(gw, gws[0])
axw[0].plot(w.real, gw.real, c if first else c+'--',
label=r'$\mu={}$'.format(mu) if first else None)
axw[1].plot(w.real, -1*gw.imag/np.pi, c if first else c+'--')
axw[0].legend()
axw[0].set_title(r'Real Frequencies Green functions, $\beta={}$, $M={}$'.format(beta, M))
axw[0].set_ylabel(r'$\Re e G(\omega)$')
axw[1].set_ylabel(r'$A(\omega)$')
axw[1].set_xlabel(r'$\omega$')
g, axwn = plt.subplots(2, sharex=True)
g.subplots_adjust(hspace=0)
wn = matsubara_freq(beta, 32)
for mu, c in zip(mu_v, c_v):
giw = gf(1j*wn, M, mu, beta)[0]
axwn[0].plot(wn, giw.real, c+'s-', label=r'$\mu={}$'.format(mu))
axwn[1].plot(wn, giw.imag, c+'o-')
axwn[0].legend()
axwn[0].set_title(r'Matsubara Green functions, $\beta={}$, $M={}$'.format(beta, M))
axwn[1].set_xlabel(r'$\omega_n$')
axwn[0].set_ylabel(r'$\Re e G(i\omega_n)$')
axwn[1].set_ylabel(r'$\Im m G(i\omega_n)$')
# S = w -tp - t^2 G_sym - G_sym^-1
fac = np.arctan(10 * np.sqrt(3) / 2.5)
omega = np.tan(np.linspace(-fac, fac, 351)) * 2.5 / np.sqrt(3)
tp = 0.5
BETA = 100.
u_int = 1.67
u_str = 'U' + str(u_int)
workdir = "/home/oscar/orlando/dev/dmft-learn/examples/dimer_bethe/tp03f/"
workdir = "/home/oscar/orlando/dev/dmft-learn/examples/dimer_bethe/"
filename = workdir + 'DIMER_PM_{}_B{}_tp{}.h5'.format('ins', BETA, tp)
giw = dimer.extract_flat_gf_iter(filename, u_int, 2)
nfreq = giw.shape[-1]
wn = gf.matsubara_freq(BETA, nfreq, 1 - nfreq)
giw = giw.reshape(-1, 2, 2, nfreq)
giw[:, 1] = -giw[:, 1].conjugate()
giw = giw.reshape(-1, nfreq)
gerr = giw.std(0).clip(3e-4)
defaultM = gaussian(omega, tp, tp**2 + 0.25 + u_int**2 / 4)
Model_gw = Maxent(omega=omega, defaultModel=defaultM, tol=1e-5,
minimizer='Bryan', w_n=wn, giw=giw.mean(0),
giw_std=gerr, max_nfreq=int(2 * BETA))
Model_gw.getAllSpecFs(alphamin=0.6, alphamax=2, numAlpha=24)
fig, ax = plt.subplots(1, 2, gridspec_kw=dict(
f.subplots_adjust(hspace=0)
w = np.linspace(-1.5, 1.5, 500) + 1j * 1e-2
for mu, c in zip(mu_v, c_v):
gw = gf(w, U, mu, beta)
axw[0].plot(w.real, gw.real, c, label=r'$\mu={}$'.format(mu))
axw[1].plot(w.real, -1 * gw.imag / np.pi, c)
axw[0].legend()
axw[0].set_title(r'Real Frequencies Green functions, $\beta={}$'.format(beta))
axw[0].set_ylabel(r'$\Re e G(\omega)$')
axw[1].set_ylabel(r'$A(\omega)$')
axw[1].set_xlabel(r'$\omega$')
gwp, axwn = plt.subplots(2, sharex=True)
gwp.subplots_adjust(hspace=0)
gtp, axt = plt.subplots()
wn = matsubara_freq(beta, 64)
tau = np.linspace(0, beta, 2**10)
for mu, c in zip(mu_v, c_v):
giw = gf(1j * wn, U, mu, beta)
axwn[0].plot(wn, giw.real, c + 's-', label=r'$\mu={}$'.format(mu))
axwn[1].plot(wn, giw.imag, c + 'o-')
gt = gw_invfouriertrans(giw, tau, wn)
axt.plot(tau, gt, label=r'$\mu={}$'.format(mu))
axwn[0].legend()
axwn[0].set_title(r'Matsubara Green functions, $\beta={}$'.format(beta))
axwn[1].set_xlabel(r'$\omega_n$')
axwn[0].set_ylabel(r'$\Re e G(i\omega_n)$')
axwn[1].set_ylabel(r'$\Im m G(i\omega_n)$')
def test_fit_gf():
"""Test the interpolation of Green function in Bethe Lattice"""
w_n = gf.matsubara_freq(100, 3)
giw = gf.greenF(w_n).imag
cont_g = gf.fit_gf(w_n, giw)
assert abs(cont_g(0.) + 2.) < 1e-4
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Make plots out of CTQMC results',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-BETA', metavar='B', type=float,
default=200., help='The inverse temperature')
parser.add_argument('-tp', default=0.18, type=float,
help='The dimerization strength')
parser.add_argument('-file', default='DIMER_{simt}_B{BETA}_tp{tp}.h5',
help='File to process')
args = parser.parse_args()
BETA = args.BETA
tp = args.tp
w_n = gf.matsubara_freq(100., 300)
w = np.linspace(-4, 4, 1000)
w_set = np.arange(100)
eps_k = np.linspace(-1., 1., 61)
with tdp.HDFArchive(args.file) as data:
for u_str in data:
giw = tdp.get_giw(data[u_str], slice(-1, -5, -1))
giw_s = np.squeeze(.5 * (giw['sym_up'].data + giw['sym_dw'].data))
giw_s = giw_s[len(giw_s) / 2:len(giw_s) / 2 + 300]
gs = gf.pade_continuation(giw_s, w_n, w, w_set)
siw_s = 1j * w_n - tp - .25 * giw_s - 1 / giw_s
ss = gf.pade_continuation(siw_s, w_n, w, w_set)
gst = gf.semi_circle_hiltrans(
w - tp - (ss.real - 1j * np.abs(ss.imag)))
Gd, Gc = dimer.gf_met(-1j * w, mu, tab, t, 0.)
Gd, Gc = dimer.self_consistency(w, Gd, Gc, mu, tab, t2)
plt.plot(w.real, -Gd.imag / np.pi, label=r'$t_c={}$'.format(tab))
# plt.plot(w.real, Gd.real, label=r'$\Re e Gd$')
# plt.plot(w.real, Gc.real, label=r'$\Re e Gc$')
# plt.plot(w.real, Gc.imag, label=r'$\Im m Gc$')
plt.legend(loc=0)
plt.xlabel(r'$\omega$')
plt.ylabel(r'$A(\omega)$')
######################################################################
# Matsubara frequency Green's function
# ====================================
w_n = gf.matsubara_freq(50., 512)
iw_n = 1j * w_n
plt.figure()
for tab in [0, 0.25, 0.5, 0.75, 1.1]:
Gd, Gc = dimer.gf_met(w_n, mu, tab, t, 0.)
Gd, Gc = dimer.self_consistency(iw_n, Gd, Gc, mu, tab, t2)
plt.plot(w_n, Gd.imag, 'o-', label=r'$t_c={}$'.format(tab))
plt.legend(loc=0)
plt.xlim([0, 6.5])
plt.xlabel(r'$i\omega_n$')
plt.ylabel(r'$G(i\omega_n)$')
def __init__(self, beta=100, t=1, nfreq=20):
super(TwoSite_Matsubara, self).__init__(beta, t)
self.omega = 1j * matsubara_freq(beta, nfreq)
self.solve(0, 0, 0)
# Redo from the QMC tau, tail following G(tau) discontinuity
gt = gtau.sum(0) * .5
gt = np.concatenate((gt, [-1 - gt[0]]))
taub = np.concatenate((tau, [64.]))
gtautck = splrep(taub, gt, s=0)
dev0 = [splev(0, gtautck, der=i) for i in range(4)]
devb = [splev(64, gtautck, der=i) for i in range(4)]
ders = np.abs(-gf.np.array(dev0) - gf.np.array(devb))
taud = np.arange(0, 64, 64 / 1024.)
plt.plot(taub, gt, taud, splev(taud, gtautck, der=0), '+-')
wnl = gf.matsubara_freq(64., 1024)
gif = gf.gt_fouriertrans(splev(taud, gtautck, der=0), taud, wnl, ders)
# plt.plot(wnl, gif.real * wnl**2, wnl, (gif.imag + 1 / wnl) * wnl**3)
# plt.ylim([-3, 3])
# tail replacement
tail = -1j / wnl - ders[1] / wnl**2 + \
ders[2] * 1j / wnl**3 + ders[3] / wnl**4
x = 64
gif[x:] = tail[x:]
# plt.plot(wnl, gif.real * wnl**2, wnl, (gif.imag + 1 / wnl) * wnl**3)
plt.figure('G(iwn)')
plt.plot(wnl, gif.real, 'o:', label='metal Re')
plt.plot(wnl, gif.imag, 's:', label='metal Im')
