def window_conv_depr():
nwf_vec = np.array([5, 10, 20, 40, 80, 160, 320])
diff_vec = np.zeros_like(nwf_vec, dtype=np.float)
for idx, nwf in enumerate(nwf_vec):
d = analytic_solution(beta=2.0, U=5.0, nw=1, nwf=nwf)
diff = np.max(np.abs(d.gamma_m.data - d.gamma_m_num.data))
diff_vec[idx] = diff
print 'nwf, diff =', idx, nwf, diff
print diff_vec
from pytriqs.plot.mpl_interface import oplot, oplotr, oploti, plt
x = 1. / nwf_vec
plt.figure(figsize=(3.25, 3))
plt.plot(x, diff_vec, 'o-', alpha=0.75)
plt.xlabel(r'$1/n_{w}$')
plt.ylabel(r'$\max|\Gamma_{ana} - \Gamma_{num}|$')
plt.ylim([0, diff_vec.max()])
plt.xlim([0, x.max()])
plt.tight_layout()
plt.savefig('figure_bse_hubbard_atom_convergence.pdf')
plt.show()
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 plot_res(ana, pom):
from triqs_tprf.plot import plot_g2, get_g2_opt
from pytriqs.plot.mpl_interface import oplot, oplotr, oploti, plt
opt = get_g2_opt(pom.chi, cplx='re', cut=0.1)
plt.figure(figsize=(6, 6))
plot_g2(pom.G2_iw_ph,
cplx='re',
opt=opt,
idx_labels=[r'\uparrow', r'\downarrow'])
plt.figure(figsize=(6, 6))
plot_g2(pom.chi0,
cplx='re',
opt=opt,
idx_labels=[r'\uparrow', r'\downarrow'])
plt.figure(figsize=(6, 6))
plot_g2(pom.chi,
cplx='re',
opt=opt,
idx_labels=[r'\uparrow', r'\downarrow'])
plt.figure(figsize=(3, 3))
plot_g2(pom.chi_m,
cplx='re',
opt=opt,
idx_labels=[r'\uparrow', r'\downarrow'])
plt.figure(figsize=(3, 3))
plot_g2(pom.chi0_m,
cplx='re',
opt=opt,
idx_labels=[r'\uparrow', r'\downarrow'])
opt = get_g2_opt(pom.gamma, cplx='re', cut=0.1)
opt['vmin'] = -5.
opt['vmax'] = +5.
plt.figure(figsize=(6, 6))
plot_g2(pom.gamma,
cplx='re',
opt=opt,
idx_labels=[r'\uparrow', r'\downarrow'])
plt.figure(figsize=(3, 3))
plot_g2(ana.gamma_m,
cplx='re',
opt=opt,
idx_labels=[r'\uparrow', r'\downarrow'])
plt.show()
def strip_sigma(nw, beta, sigma_in, debug=False):
np.testing.assert_almost_equal(beta, sigma_in.mesh.beta)
wmesh = MeshImFreq(beta, 'Fermion', n_max=nw)
sigma = Gf(mesh=wmesh, target_shape=sigma_in.target_shape)
for w in wmesh:
index = w.linear_index + wmesh.first_index() # absolute index
sigma[w] = sigma_in[Idx(index)]
if debug:
from pytriqs.plot.mpl_interface import oplot, plt
oplot(p.Sigmalatt_iw)
oplot(sigma, 'x')
plt.show()
exit()
return sigma
ax = plt.subplot(*subp)
subp[-1] += 1
plt.title('Re ' + label + ' [:,i,:]')
plt.pcolormesh(s.real, **opt)
plt.colorbar()
ax = plt.subplot(*subp)
subp[-1] += 1
plt.title('Im ' + label + ' [:,i,:]')
plt.pcolormesh(s.imag)
plt.colorbar()
s1 = np.squeeze(g1.data[:, :, idx])
s2 = np.squeeze(g2.data[:, :, idx])
s = s1 - s2
a = plt.subplot(*subp)
subp[-1] += 1
plt.title('Re ' + label + ' [:,:,i]')
plt.pcolormesh(s.real, **opt)
plt.colorbar()
a = plt.subplot(*subp)
subp[-1] += 1
plt.title('Im ' + label + ' [:,:,i]')
plt.pcolormesh(s.imag)
plt.colorbar()
plt.tight_layout()
plt.show()
a['Delta_iw_fit'] = Delta_iw_fit
# -- Plot
from pytriqs.plot.mpl_interface import oplot, oplotr, oploti, plt
plt.figure(figsize=(10, 10))
ylim = [-4, 4]
plt.plot([w_min.imag]*2, ylim, 'sr-', lw=0.5)
plt.plot([w_max.imag]*2, ylim, 'sr-', lw=0.5)
for i1, i2 in itertools.product(range(2), repeat=2):
oplotr(Delta_iw[i1, i2], alpha=0.1)
oploti(Delta_iw[i1, i2], alpha=0.1)
oplotr(Delta_iw_ref[i1, i2], lw=4, alpha=0.25)
oploti(Delta_iw_ref[i1, i2], lw=4, alpha=0.25)
oplotr(Delta_iw_fit[i1, i2])
oploti(Delta_iw_fit[i1, i2])
ax = plt.gca()
ax.legend_ = None
plt.ylim([-1, 1])
plt.tight_layout()
plt.savefig(figure_filename)
plt.show(); exit()
from pytriqs.gf.local 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 dcore_check(filename, fileplot=None):
"""
Main routine for checking convergence
Parameters
----------
filename : string
Input-file name
fileplot : string
Output file name. File format is determined by the extension (pdf, eps, jpg, etc).
"""
if mpi.is_master_node():
print("\n @ Reading {0} ...".format(filename))
#
# Construct a parser with default values
#
pars = create_parser()
#
# Parse keywords and store
#
pars.read(filename)
p = pars.as_dict()
#
solver = DMFTCoreSolver(p["model"]["seedname"], p)
#
# Just for convenience
sol = solver.S
output_file = p["model"]["seedname"] + '.out.h5'
output_group = 'dmft_out'
beta = p["system"]["beta"]
omega_check = p['tool']['omega_check']
gs = GridSpec(2, 1)
if fileplot is not None: # if graph is to be printed in a file
import matplotlib
matplotlib.use('Agg') # do not plot on x11
from pytriqs.plot.mpl_interface import oplot, plt
plt.figure(figsize=(8, 10))
#
# Chemical potential
#
ar = HDFArchive(output_file, 'r')
iteration_number = ar[output_group]['iterations']
perform_tail_fit = p["system"]["perform_tail_fit"] and \
not ar[output_group]['parameters']["system"]["perform_tail_fit"]
nsh = solver.SK.n_inequiv_shells
print(" Total number of Iteration: {0}".format(iteration_number))
print("\n Iter Chemical-potential")
for itr in range(1, iteration_number + 1):
print(" {0} {1}".format(
itr, ar[output_group]['chemical_potential'][str(itr)]))
#
# Read Sigma and average it
#
sigma_ave = []
sigma_fit = []
nsigma = 0
itr_sigma = [0] * 7
for itr in range(1, iteration_number + 1):
if itr > iteration_number - 7:
itr_sigma[nsigma] = itr
sigma_ave.append(
GfImFreq(indices=[0], beta=beta, n_points=p["system"]["n_iw"]))
sigma_fit.append(
GfImFreq(indices=[0], beta=beta, n_points=p["system"]["n_iw"]))
sigma_ave[nsigma].data[:, 0, 0] = 0.0
sigma_fit[nsigma].data[:, 0, 0] = 0.0
norb_tot = 0
for ish in range(nsh):
spn = solver.SK.spin_block_names[solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['SO']]
norb = solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['dim']
sol[ish].Sigma_iw << ar[output_group]['Sigma_iw'][str(itr)][
str(ish)]
sigma_iw_fit = sol[ish].Sigma_iw.copy()
if perform_tail_fit:
tail_fit(sigma_iw_fit,
fit_max_moment=p["system"]["fit_max_moment"],
fit_min_w=p["system"]["fit_min_w"],
fit_max_w=p["system"]["fit_max_w"])
for isp in spn:
for iorb in range(norb):
norb_tot += 1
for jorb in range(norb):
sigma_ave[nsigma].data[:, 0, 0] += sol[
ish].Sigma_iw[isp].data[:, iorb, jorb]
sigma_fit[nsigma].data[:, 0, 0] += sigma_iw_fit[
isp].data[:, iorb, jorb]
sigma_ave[nsigma].data[:, 0, 0] /= norb_tot
sigma_fit[nsigma].data[:, 0, 0] /= norb_tot
nsigma += 1
#
# Real part
#
plt.subplot(gs[0])
for itr in range(nsigma):
oplot(sigma_ave[itr],
'-o',
mode='R',
x_window=(0.0, omega_check),
name='Sigma-%s' % itr_sigma[itr])
if perform_tail_fit:
oplot(sigma_fit[itr],
'-o',
mode='R',
x_window=(0.0, omega_check),
name='S_fit-%s' % itr_sigma[itr])
plt.legend(loc=0)
#
# Imaginary part
#
plt.subplot(gs[1])
for itr in range(nsigma):
oplot(sigma_ave[itr],
'-o',
mode='I',
x_window=(0.0, omega_check),
name='Sigma-%s' % itr_sigma[itr])
if perform_tail_fit:
oplot(sigma_fit[itr],
'-o',
mode='I',
x_window=(0.0, omega_check),
name='S_fit-%s' % itr_sigma[itr])
plt.legend(loc=0)
plt.show()
if fileplot is not None:
plt.savefig(fileplot)
#
# Output Sigma into a text file
#
print("\n Output Local Self Energy : ",
p["model"]["seedname"] + "_sigma.dat")
with open(p["model"]["seedname"] + "_sigma.dat", 'w') as fo:
print("# Local self energy at imaginary frequency", file=fo)
#
# Column information
#
print("# [Column] Data", file=fo)
print("# [1] Frequency", file=fo)
icol = 1
for ish in range(nsh):
spn = solver.SK.spin_block_names[solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['SO']]
norb = solver.SK.corr_shells[solver.SK.inequiv_to_corr[ish]]['dim']
for isp in spn:
for iorb in range(norb):
for jorb in range(norb):
icol += 1
print("# [%d] Re(Sigma_{shell=%d, spin=%s, %d, %d})" %
(icol, ish, isp, iorb, jorb),
file=fo)
icol += 1
print("# [%d] Im(Sigma_{shell=%d, spin=%s, %d, %d})" %
(icol, ish, isp, iorb, jorb),
file=fo)
#
# Write data
#
omega = [x for x in sol[0].Sigma_iw.mesh]
for iom in range(len(omega)):
print("%f " % omega[iom].imag, end="", file=fo)
for ish in range(nsh):
spn = solver.SK.spin_block_names[solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['SO']]
norb = solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['dim']
for isp in spn:
for iorb in range(norb):
for jorb in range(norb):
print("%f %f " %
(sol[ish].Sigma_iw[isp].data[iom, iorb,
jorb].real,
sol[ish].Sigma_iw[isp].data[iom, iorb,
jorb].imag),
end="",
file=fo)
print("", file=fo)
#
# Output Legendre polynomial
#
if p["system"]["n_l"] > 0:
#
# Output Sigma into a text file
#
print("\n Output Local Self Energy : ",
p["model"]["seedname"] + "_legendre.dat")
with open(p["model"]["seedname"] + "_legendre.dat", 'w') as fo:
print("# Local self energy at imaginary frequency", file=fo)
#
# Column information
#
print("# [Column] Data", file=fo)
print("# [1] Order of Legendre polynomials", file=fo)
icol = 1
for ish in range(nsh):
sol[ish].G_l << ar[output_group]['G_l'][str(ish)]
spn = solver.SK.spin_block_names[solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['SO']]
norb = solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['dim']
for isp in spn:
for iorb in range(norb):
for jorb in range(norb):
icol += 1
print(
"# [%d] Re(G_l_{shell=%d, spin=%s, %d, %d})" %
(icol, ish, isp, iorb, jorb),
file=fo)
icol += 1
print(
"# [%d] Im(G_l_{shell=%d, spin=%s, %d, %d})" %
(icol, ish, isp, iorb, jorb),
file=fo)
#
# Write data
#
for il in range(p["system"]["n_l"]):
print("%d " % il, end="", file=fo)
for ish in range(nsh):
spn = solver.SK.spin_block_names[solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['SO']]
norb = solver.SK.corr_shells[
solver.SK.inequiv_to_corr[ish]]['dim']
for isp in spn:
for iorb in range(norb):
for jorb in range(norb):
print("%f %f " %
(sol[ish].G_l[isp].data[il, iorb,
jorb].real,
sol[ish].G_l[isp].data[il, iorb,
jorb].imag),
end="",
file=fo)
print("", file=fo)
#
# Finish
#
del ar
print("\n Done\n")
