def plot_ln_abs(gl, *args, **kwargs):
g = gl.copy()
for s, b in gl:
for i in range(len(b.data[0, :, :])):
for j in range(len(b.data[0, :, :])):
for n in range(len(b.data[:, 0, 0])):
g[s].data[n, i, j] = log(abs(b.data[n, i, j]))
for s, b in g:
for i in b.indices:
for j in b.indices:
oplot(b[i, j], name = s+'_'+str(i)+str(j), *args, **kwargs)
plt.gca().set_ylabel('$\\mathrm{ln}\\,\\mathrm{abs}\\,\\tilde{G}(l)$')
def plot_from_archive(archive, function, loops = [-1], indices = [(0, 0)], blocks = ['up'], **kwargs):
archive = HDFArchive(archive, 'r')
for l in loops:
if l < 0:
ll = archive['results']['n_dmft_loops'] + l
else:
ll = l
for ind in indices:
for s in blocks:
f_name = s + '_' + str(ind[0]) + str(ind[1]) + '_it' + str(ll)
if 'raw' in function: f_name += '_raw'
f = archive['results'][str(ll)][function]
if 'iw' in function:
if 'RI' in kwargs.keys():
if kwargs['RI'] == 'R':
oplot(f[s][ind], name = 'Re_' + f_name, **kwargs)
if kwargs['RI'] == 'I':
oplot(f[s][ind], name = 'Im_' + f_name, **kwargs)
else:
oplot(f[s][ind], name = 'Re_' + f_name, RI = 'R', **kwargs)
oplot(f[s][ind], name = 'Im_' + f_name, RI = 'I', **kwargs)
elif function == 'g_transf_l':
plt.plot(f[s].data[:, ind[0], ind[1]], label = f_name, **kwargs)
plt.xlabel('$l_n$')
plt.ylabel('$\\tilde{G}(l_n)$')
else:
oplot(f[s][ind], name = f_name, **kwargs)
y_ax_lab = '$'
if 'transf' in function: y_ax_lab += '\\tilde{'
if 'sigma' in function: y_ax_lab += '\\Sigma'
elif 'g' in function: y_ax_lab += 'G'
elif 'delta' in function: y_ax_lab += '\\Delta'
else: y_ax_lab += function
if 'transf' in function: y_ax_lab += '}'
y_ax_lab += "("
if 'iw' in function: y_ax_lab += 'i\\omega_n'
elif 'tau' in function: y_ax_lab += '\\tau'
y_ax_lab += ')$'
plt.gca().set_ylabel(y_ax_lab)
del archive
import numpy as np from pytriqs.gf import GfReFreq, SemiCircular g = GfReFreq(indices = ['eg1', 'eg2'], window = (-5, 5), n_points = 1000, name = "egBlock") g['eg1','eg1'] = SemiCircular(half_bandwidth = 1) g['eg2','eg2'] = SemiCircular(half_bandwidth = 2) from pytriqs.plot.mpl_interface import oplot oplot(g['eg1','eg1'], '-o', RI = 'S') # S : spectral function oplot(g['eg2','eg2'], '-x', RI = 'S')
from pytriqs.gf.local import GfImFreq, SemiCircular g = GfImFreq(indices = ['eg1','eg2'], beta = 50, n_points = 1000, name = "egBlock") g['eg1','eg1'] = SemiCircular(half_bandwidth = 1) g['eg2','eg2'] = SemiCircular(half_bandwidth = 2) from pytriqs.plot.mpl_interface import oplot, plt oplot(g, '-o', x_window = (0,10)) plt.ylim(-2,1)
return 0.7/(z-2.6+0.3*1j) + 0.3/(z+3.4+0.1*1j)
# Semicircle
def GSC(z):
return 2.0*(z + sqrt(1-z**2)*(log(1-z) - log(-1+z))/pi)
# A superposition of GLorentz(z) and GSC(z) with equal weights
def G(z):
return 0.5*GLorentz(z) + 0.5*GSC(z)
# Matsubara GF
gm = GfImFreq(indices = [0], beta = beta, name = "gm")
gm << Function(G)
gm.tail.zero()
gm.tail[1] = numpy.array([[1.0]])
# Real frequency BlockGf(reference)
gr = GfReFreq(indices = [0], window = (-5.995, 5.995), n_points = 1200, name = "gr")
gr << Function(G)
gr.tail.zero()
gr.tail[1] = numpy.array([[1.0]])
# Analytic continuation of gm
g_pade = GfReFreq(indices = [0], window = (-5.995, 5.995), n_points = 1200, name = "g_pade")
g_pade.set_from_pade(gm, n_points = L, freq_offset = eta)
# Comparison plot
from pytriqs.plot.mpl_interface import oplot
oplot(gr[0,0], '-o', RI = 'S', name = "Original DOS")
oplot(g_pade[0,0], '-x', RI = 'S', name = "Pade-reconstructed DOS")
from matplotlib.backends.backend_pdf import PdfPages
N_max = 10
arch = HDFArchive('nonint.h5','r')
for i in arch:
subarch = arch[i]
pp = PdfPages("G_nonint_%s.pdf"%i)
G_tau = subarch['G_tau']
V = subarch['V']
e = subarch['e']
beta = G_tau.beta
n_tau = len(G_tau.mesh)
for m, b in enumerate(G_tau.indices):
g_theor = GfImTime(indices = [0], beta=beta, n_points=n_tau)
e1 = e[m] - V[m]
e2 = e[m] + V[m]
g_theor_w = GfImFreq(indices = [0], beta=beta)
g_theor_w << 0.5*inverse(iOmega_n - e1) + 0.5*inverse(iOmega_n - e2)
g_theor[0,0] << InverseFourier(g_theor_w)
plt.clf()
oplot(rebinning_tau(G_tau[b][0,0],200), name="cthyb")
oplot(g_theor[0,0], name="Theory")
pp.savefig(plt.gcf())
pp.close()
from pytriqs.gf.local import * from pytriqs.plot.mpl_interface import oplot # A Green's function on the Matsubara axis set to a semicircular gw = GfImFreq(indices=[1], beta=50) gw << SemiCircular(half_bandwidth=1) # Create a Legendre Green's function with 40 coefficients # initialize it from gw and plot it gl = GfLegendre(indices=[1], beta=50, n_points=40) gl << MatsubaraToLegendre(gw) oplot(gl, "-o")
from pytriqs.plot.mpl_interface import oplot
from pytriqs.fit.fit import Fit, linear, quadratic
from pytriqs.gf.local import *
from pytriqs.gf.local.descriptors import iOmega_n
g = GfImFreq(indices = [1], beta = 300, n_points = 1000, name = "g")
g << inverse( iOmega_n + 0.5 )
print " van plot"
oplot (g, '-o', x_window = (0,3) )
print "plot done"
g << inverse( iOmega_n + 0.5 )
print "ok ----------------------"
from pytriqs.archive import HDFArchive
R = HDFArchive('myfile.h5', 'r')
for n, calculation in R.items() :
#g = calculation['g']
g << inverse( iOmega_n + 0.5 )
print "pokokook"
X,Y = g.x_data_view (x_window = (0,0.2), flatten_y = True )
#fitl = Fit ( X,Y.imag, linear )
g << inverse( iOmega_n + 0.5 )
print " van plot"
from pytriqs.gf.local import *
from pytriqs.archive import *
from pytriqs.plot.mpl_interface import oplot, plt
with HDFArchive("dmft_solution.h5", "r") as ar:
for i in range(5):
oplot(ar["G_iw-%i" % i]["up"], "-o", mode="I", label="Iteration = %s" % i, x_window=(0, 2))
plt.legend(loc=4)
from pytriqs.gf.local import *
from pytriqs.archive import *
from pytriqs.plot.mpl_interface import oplot, plt
with HDFArchive("dmft_solution.h5", 'r') as ar:
for i in range(5):
oplot(ar['G_iw-%i' % i]['up'],
'-o',
mode='I',
label='Iteration = %s' % i,
x_window=(0, 2))
plt.legend(loc=4)
# Plot G(\tau)
pp = PdfPages('G_asymm_bath.pdf')
for e_group_name in arch:
e_group = arch[e_group_name]
e_group_ed = arch_ed[e_group_name]
beta = e_group['beta']
U = e_group['U']
ed = e_group['ed']
V = e_group['V']
e = e_group['e']
plt.clf()
oplot(rebinning_tau(e_group['G_tau']['up'],300),name="CTHYB,$\uparrow\uparrow$")
oplot(rebinning_tau(e_group['G_tau']['dn'],300),name="CTHYB,$\downarrow\downarrow$")
oplot(rebinning_tau(e_group_ed['G_tau']['up'],300),name="ED,$\uparrow\uparrow$")
oplot(rebinning_tau(e_group_ed['G_tau']['dn'],300),name="ED,$\downarrow\downarrow$")
a = plt.gca()
a.set_ylabel('$G(\\tau)$')
a.set_xlim((0,beta))
a.set_ylim((-1,0))
a.legend(loc='lower right',prop={'size':10})
a.set_title("$U=%.1f$, $\epsilon_d=%.1f$, $V=%.1f$, $\epsilon_k=%.1f$" % (U,ed,V,e))
histo_a = plt.axes([.35, .15, .3, .4], axisbg='y')
opcount_data = []
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()
from params import *
arch = HDFArchive(chi_filename, 'r')
ed_arch = HDFArchive(chi_ed_filename, 'r')
pp = PdfPages('chi.pdf')
spin_names = ('up', 'dn')
spin_labels = {'up': '\uparrow\uparrow', 'dn': '\downarrow\downarrow'}
# G_tau
delta_max_text = ""
for sn in spin_names:
g = arch['G_tau'][sn]
g_ed = ed_arch['G_tau'][sn]
oplot(g, mode='R', lw=0.5, label="QMC, $%s$" % spin_labels[sn])
oplot(g_ed, mode='R', lw=0.5, label="ED, $%s$" % spin_labels[sn])
delta_max = np.max(np.abs(g.data[:, 0, 0] - g_ed.data[:, 0, 0]))
delta_max_text += "$\\delta^{max}_{%s} = %f$\n" % (spin_labels[sn],
delta_max)
ax = plt.gca()
ax.set_title('$G(\\tau)$')
ax.set_ylabel('$G(\\tau)$')
ax.set_xlim((0, beta))
ax.set_ylim((-1, 0.05))
ax.legend(loc='lower center', prop={'size': 10})
ax.text(beta / 2, -0.5, delta_max_text, horizontalalignment='center')
pp.savefig(plt.gcf())
# G_iw
plt.cla()
N_max = 10
arch = HDFArchive('nonint.h5', 'r')
for i in arch:
subarch = arch[i]
pp = PdfPages("G_nonint_%s.pdf" % i)
G_tau = subarch['G_tau']
V = subarch['V']
e = subarch['e']
beta = G_tau.beta
n_tau = len(G_tau.mesh)
for m, b in enumerate(G_tau.indices):
g_theor = GfImTime(indices=[0], beta=beta, n_points=n_tau)
e1 = e[m] - V[m]
e2 = e[m] + V[m]
g_theor_w = GfImFreq(indices=[0], beta=beta)
g_theor_w << 0.5 * inverse(iOmega_n - e1) + 0.5 * inverse(iOmega_n -
e2)
g_theor[0, 0] << InverseFourier(g_theor_w)
plt.clf()
oplot(rebinning_tau(G_tau[b][0, 0], 200), name="cthyb")
oplot(g_theor[0, 0], name="Theory")
pp.savefig(plt.gcf())
pp.close()
axes.set_ylabel('$G(\\tau)$')
axes.legend(loc='best', prop={'size': 8}, ncol=2)
pp = PdfPages('G.pdf')
ed_arch = HDFArchive('spinless.ed.h5', 'r')
for use_qn in (False, True):
file_name = "spinless"
if use_qn: file_name += ".qn"
file_name += ".h5"
try:
arch = HDFArchive(file_name, 'r')
plt.clf()
name = 'cthyb' + (' (QN)' if use_qn else '')
for i1, i2 in product(("A", "B"), ("A", "B")):
#GF = rebinning_tau(arch['tot'][i1,i2],500)
#oplot(GF, name=name + ",%s%s" % (i1,i2))
oplot(arch["tot"][i1, i2], name=name + ",%s%s" % (i1, i2))
oplot(ed_arch["tot"][i1, i2], name="ED, %s%s" % (i1, i2))
setup_fig()
pp.savefig(plt.gcf())
except IOError:
pass
pp.close()
from pytriqs.gf.local import *
from pytriqs.archive import HDFArchive
from matplotlib import pyplot as plt
from pytriqs.plot.mpl_interface import oplot
# Read data from archive
ar = HDFArchive('results.h5', 'r')
# Plot input and reconstructed G(\tau)
oplot(ar['g_tau'][0, 0], mode='R', linewidth=0.8, label="$G_{00}(\\tau)$")
oplot(ar['g_tau'][1, 1], mode='R', linewidth=0.8, label="$G_{11}(\\tau)$")
oplot(ar['g_rec_tau'][0, 0],
mode='R',
linewidth=0.8,
label="$G_{00}^\mathrm{rec}(\\tau)$")
oplot(ar['g_rec_tau'][1, 1],
mode='R',
linewidth=0.8,
label="$G_{11}^\mathrm{rec}(\\tau)$")
plt.xlim((0, 20))
plt.ylabel("$G(\\tau)$")
plt.legend(loc="lower center")
# get S_w from the auxilliary spectral function Aaux_w
Aaux_w = {}
w = res['up_0'].omega
for key in res:
Aaux_w[key] = res[key].analyzer_results['LineFitAnalyzer']['A_out']
isc.set_Gaux_w_from_Aaux_w(Aaux_w,
w,
np_interp_A=10000,
np_omega=4000,
w_min=-1.0,
w_max=1.0)
# save SigmaContinuator again (now it contains S_w)
with HDFArchive('Sr2RuO4_b37.h5', 'a') as ar:
isc = ar['isc']
# check linfit and plot S_w
plt.figure()
plt.subplot(1, 2, 1)
for key in res:
res[key].analyzer_results['LineFitAnalyzer'].plot_linefit()
plt.ylim(1e1, 1e4)
plt.subplot(1, 2, 2)
oplot(isc.S_w['up_0'], mode='I', label='maxent xy', lw=3)
oplot(isc.S_w['up_1'], mode='I', label='maxent xz', lw=3)
plt.ylabel(r'$\Sigma(\omega)$')
plt.xlim(-0.75, 0.75)
plt.ylim(-0.4, 0.0)
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)
if False:
from pytriqs.plot.mpl_interface import oplot, plt
subp = [1, 3, 1]
plt.subplot(*subp)
subp[-1] += 1
oplot(g_iw)
plt.subplot(*subp)
subp[-1] += 1
oplot(g_tau)
plt.subplot(*subp)
subp[-1] += 1
oplot(g_iw_ref)
plt.show()
import numpy
class myObject(object):
def _plot_(self, options):
PI = numpy.pi
xdata = numpy.arange(-PI, PI, 0.1)
ydata1 = numpy.cos(xdata)
ydata2 = numpy.sin(xdata)
return ([{
'type': "XY",
'xdata': xdata,
'ydata': ydata1,
'label': 'Cos'
}, {
'type': "XY",
'xdata': xdata,
'ydata': ydata2,
'label': 'Sin'
}])
X = myObject()
from pytriqs.plot.mpl_interface import oplot
oplot(X, '-o')
from pytriqs.gf.local import * from pytriqs.plot.mpl_interface import oplot,plt # A Green's function on the Matsubara axis set to a semicircular gw = GfImFreq(indices = [1], beta = 50) gw <<= SemiCircular(half_bandwidth = 1) # Create a Legendre Green's function with 40 coefficients # initialize it from gw and plot it gl = GfLegendre(indices = [1], beta = 50, n_points = 40) gl <<= MatsubaraToLegendre(gw) oplot(gl, '-o')
from pytriqs.gf.local import *
from pytriqs.archive import HDFArchive
from matplotlib import pyplot as plt
from pytriqs.plot.mpl_interface import oplot
# Read data from archive
ar = HDFArchive('results.h5', 'r')
# Plot input and reconstructed \chi(i\omega_n)
oplot(ar['chi_iw'][0,0], mode='R', linewidth=0.8, label="$\chi_0(i\\omega_n)$")
oplot(ar['chi_rec_iw'][0,0], mode='R', linewidth=0.8, label="$\chi_\mathrm{0,rec}(i\\omega_n)$")
oplot(ar['chi_iw'][1,1], mode='R', linewidth=0.8, label="$\chi_1(i\\omega_n)$")
oplot(ar['chi_rec_iw'][1,1], mode='R', linewidth=0.8, label="$\chi_\mathrm{1,rec}(i\\omega_n)$")
plt.xlim((0, 3))
plt.ylabel("$\chi'(i\\omega_n)$")
plt.legend(loc="upper right")
def setup_fig():
axes = plt.gca()
axes.set_ylabel('$G(\\tau)$')
axes.legend(loc='lower center',prop={'size':10})
pp = PdfPages('G.pdf')
for plot_objs in objects_to_plot:
try:
plt.clf()
for obj in plot_objs:
if type(obj) is tuple:
filename = params.results_file_name(*obj)
name = 'cthyb'
if obj[0]: name += '(QN)'
else:
filename = 'spinless.' + obj + '.h5'
name = {'ed':'ED', 'matrix':'Matrix'}[obj]
arch = HDFArchive(filename,'r')
for i1,i2 in product((0,1),(0,1)):
oplot(arch["tot"][i1,i2], name=name + ",%i%i" % (i1,i2))
setup_fig()
pp.savefig(plt.gcf())
except IOError: pass
pp.close()
from pytriqs.gf import *
from pytriqs.archive import *
from pytriqs.plot.mpl_interface import oplot
with HDFArchive('aim_solution.h5','r') as ar:
oplot(ar['G_iw']['up'], '-o', x_window = (0,10))
#!/usr/bin/env pytriqs
from ClusterDMFT.cdmft import CDmft
from ClusterDMFT.evaluation.analytical_continuation import pade_tr as pade
from pytriqs.gf.local import BlockGf, GfImFreq, GfReFreq
from pytriqs.plot.mpl_interface import oplot
from numpy import pi
from matplotlib import pyplot as plt, cm
import sys
n_start = int(sys.argv[1])
n_stop = int(sys.argv[2])
n_step = int(sys.argv[3])
max_w = int(sys.argv[4])
max_y = int(sys.argv[5])
for arch in sys.argv[6:len(sys.argv)]:
x = CDmft(archive = arch)
g = x.load('g_0_c_iw', 0)
for n in range(n_start, n_stop, n_step):
g_w = pade(g, pade_n_omega_n = n, pade_eta = 0.001, dos_n_points = 1200, dos_window = (-max_w, max_w), clip_threshold = 0)
oplot(g_w, RI = 'S', name = str(n), color = cm.jet((n - n_start) /float(n_stop - n_start)))
filename = 'dosNonInt_' + arch[0:-3] + '_' + str(n_start) + str(n_stop) + str(n_step) + '.png'
plt.gca().set_ylim(0, max_y)
plt.savefig(filename)
plt.close()
print filename + ' ready'
del x
if use_qn: file_name += ".qn"
file_name += ".h5"
mkind = lambda spin: (spin,0) if use_blocks else ("tot",spin)
try:
arch = HDFArchive(file_name,'r')
plt.clf()
name_parts = []
if use_blocks: name_parts.append('Block')
if use_qn: name_parts.append('QN')
name = 'cthyb' + (' (' + ', '.join(name_parts) + ')' if len(name_parts) else '')
for spin in spin_names:
bn, i = mkind(spin)
GF = rebinning_tau(arch['G_tau'][bn],500)
if use_blocks:
oplot(GF, name=name + "," + {'up':"$\uparrow\uparrow$",'dn':"$\downarrow\downarrow$"}[spin])
else:
i = spin_names.index(i)
oplot(GF[i,i], name=name + "," + {'up':"$\uparrow\uparrow$",'dn':"$\downarrow\downarrow$"}[spin])
oplot(ed_arch[spin], name="ED," + {'up':"$\uparrow\uparrow$",'dn':"$\downarrow\downarrow$"}[spin])
setup_fig()
pp.savefig(plt.gcf())
except IOError: pass
pp.close()
from pytriqs.gf.local import * from pytriqs.plot.mpl_interface import oplot # A Green's function on the Matsubara axis set to a semicircular gw = GfImFreq(indices = [1], beta = 50) gw << SemiCircular(half_bandwidth = 1) # Create an imaginary-time Green's function gt = GfImTime(indices = [1], beta = 50) gt << InverseFourier(gw) # Plot the Legendre Green's function oplot(gt, '-')
from pytriqs.gf.local import * from pytriqs.plot.mpl_interface import oplot # A Green's function on the Matsubara axis set to a semicircular gw = GfImFreq(indices=[1], beta=50) gw << SemiCircular(half_bandwidth=1) # Create an imaginary-time Green's function and plot it gt = GfImTime(indices=[1], beta=50) gt << InverseFourier(gw) oplot(gt, "-")
from numpy import pi
from matplotlib import pyplot as plt, cm
import sys
n_start = int(sys.argv[1])
n_stop = int(sys.argv[2])
n_step = int(sys.argv[3])
max_w = int(sys.argv[4])
max_a = int(sys.argv[5])
cmaps_pool = [cm.Reds, cm.Blues, cm.Greens, cm.Greys]
for arch in sys.argv[6:len(sys.argv)]:
print 'loading '+arch+' ...'
x = CDmft(archive = arch)
g = x.load('G_sym_iw')
cmaps = list()
n_orbs = int(g.n_blocks * .5)
for i in range(n_orbs):
cmaps.append(cmaps_pool[i%(len(cmaps_pool))])
for n in range(n_start, n_stop, n_step):
for s, b in g:
g_w = pade(g, s, pade_n_omega_n = n, pade_eta = 10**-2, dos_n_points = 1200, dos_window = (-max_w, max_w), clip_threshold = 0)
oplot(g_w, RI = 'S', name = s[0]+s[2]+' '+str(n), color = cmaps[int(s[0])](((n - n_start) /float(n_stop - n_start))*.5 + .5))
filename = 'dos_orb_' + arch[0:-3] + '_' + str(n_start) + str(n_stop) + str(n_step) + '.png'
plt.gca().set_ylim(0, max_a)
plt.savefig(filename)
plt.close()
print filename + ' ready'
del x
BL = BravaisLattice(units=[(1, 0, 0), (0, 1, 0)])
# Prepare a nearest neighbour hopping on BL
t = -1.00 # First neighbour Hopping
tp = 0.0 * t # Second neighbour Hopping
# Hopping[ Displacement on the lattice] = [[t11,t12,t13....],[t21,t22,t23....],...,[....,tnn]]
# where n=Number_Orbitals
hop = {
(1, 0): [[t]],
(-1, 0): [[t]],
(0, 1): [[t]],
(0, -1): [[t]],
(1, 1): [[tp]],
(-1, -1): [[tp]],
(1, -1): [[tp]],
(-1, 1): [[tp]]
}
TB = TightBinding(BL, hop)
# Compute the density of states
d = dos(TB, n_kpts=500, n_eps=101, name='dos')[0]
# Plot the dos it with matplotlib
from pytriqs.plot.mpl_interface import oplot
from matplotlib import pylab as plt
oplot(d, '-o')
plt.xlim(-5, 5)
plt.ylim(0, 0.4)
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()
with HDFArchive('preblur.h5', 'w') as ar:
ar['result_normal'] = result_normal.data
ar['results_preblur'] = [r.data for r in results_preblur]
# extract the chi2 value from the optimal alpha for each blur parameter
chi2s = []
# we have to reverse-sort it because fit_piecewise expects it in that order
b_vals = sorted(results_preblur.keys(), reverse=True)
for b in b_vals:
r = results_preblur[b]
alpha_index = r.analyzer_results['LineFitAnalyzer']['alpha_index']
chi2s.append(r.chi2[alpha_index])
# perform a linefit to get the optimal b value
b_index, _ = fit_piecewise(np.log10(b_vals), np.log10(chi2s))
b_ideal = b_vals[b_index]
print('Ideal b value = ', b_ideal)
if plot:
import matplotlib.pyplot as plt
from pytriqs.plot.mpl_interface import oplot
oplot(G_w, mode='S')
result_normal.analyzer_results['LineFitAnalyzer'].plot_A_out()
results_preblur[b_ideal].analyzer_results['LineFitAnalyzer'].plot_A_out()
plt.xlabel(r'$\omega$')
plt.ylabel(r'$A(\omega)$')
plt.legend(['original', 'normal', 'preblur'])
plt.xlim(-2.5, 2.5)
plt.savefig('preblur_A.png')
plt.show()
from pytriqs.gf.local import *
from pytriqs.archive import HDFArchive
from matplotlib import pyplot as plt
from pytriqs.plot.mpl_interface import oplot
# Read data from archive
ar = HDFArchive('results.h5', 'r')
# Plot input and reconstructed \chi(i\omega_n)
oplot(ar['chi_iw'][0, 0],
mode='R',
linewidth=0.8,
label="$\chi_0(i\\omega_n)$")
oplot(ar['chi_rec_iw'][0, 0],
mode='R',
linewidth=0.8,
label="$\chi_\mathrm{0,rec}(i\\omega_n)$")
oplot(ar['chi_iw'][1, 1],
mode='R',
linewidth=0.8,
label="$\chi_1(i\\omega_n)$")
oplot(ar['chi_rec_iw'][1, 1],
mode='R',
linewidth=0.8,
label="$\chi_\mathrm{1,rec}(i\\omega_n)$")
plt.xlim((0, 3))
plt.ylabel("$\chi'(i\\omega_n)$")
plt.legend(loc="upper right")
from pytriqs.gf.local import *
from pytriqs.archive import *
from pytriqs.plot.mpl_interface import oplot
A = HDFArchive("solution.h5")
oplot(A['Gl']['up'], '-o', x_window=(15,45) )
from params import *
arch = HDFArchive(chi_filename,'r')
ed_arch = HDFArchive(chi_ed_filename,'r')
pp = PdfPages('chi.pdf')
spin_names = ('up','dn')
spin_labels = {'up':'\uparrow\uparrow', 'dn':'\downarrow\downarrow'}
# G_tau
delta_max_text = ""
for sn in spin_names:
g = arch['G_tau'][sn]
g_ed = ed_arch['G_tau'][sn]
oplot(g, mode='R', lw=0.5, label="QMC, $%s$" % spin_labels[sn])
oplot(g_ed, mode='R', lw=0.5, label="ED, $%s$" % spin_labels[sn])
delta_max = np.max(np.abs(g.data[:,0,0] - g_ed.data[:,0,0]))
delta_max_text += "$\\delta^{max}_{%s} = %f$\n" % (spin_labels[sn],delta_max)
ax = plt.gca()
ax.set_title('$G(\\tau)$')
ax.set_ylabel('$G(\\tau)$')
ax.set_xlim((0,beta))
ax.set_ylim((-1,0.05))
ax.legend(loc='lower center',prop={'size':10})
ax.text(beta/2,-0.5,delta_max_text,horizontalalignment='center')
pp.savefig(plt.gcf())
# G_iw
plt.cla()
delta_max_text = ""
from pytriqs.plot.mpl_interface import oplot
from pytriqs.gf.local 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))
from math import pi from pytriqs.gf import * gw = GfReFreq(indices = [1], window = (-5, 5), n_points = 1001, name = "egBlock") gw << SemiCircular(2.0) gt = GfReTime(indices = [1], window = (-5*2*pi*(100.0/101.0),5*2*pi*(100.0/101.0)), n_points = 1001, name = "egBlock") gt << InverseFourier(gw) from pytriqs.plot.mpl_interface import oplot oplot(gt.imag, '-o')
from pytriqs.gf.local import *
from pytriqs.archive import HDFArchive
from matplotlib import pyplot as plt
from pytriqs.plot.mpl_interface import oplot
# Read data from archive
ar = HDFArchive('results.h5', 'r')
# Plot imaginary part of the susceptibility on the real axis
oplot(ar['chi_w'][0,0], mode='I', linewidth=0.8, label="$\chi''_0(\\omega)$")
oplot(ar['chi_w'][1,1], mode='I', linewidth=0.8, label="$\chi''_1(\\omega)$")
plt.xlim((-5.0,5.0))
plt.ylim((-1.5,1.5))
plt.ylabel("$\chi(\\omega)$")
plt.legend(loc = "lower right")
#!/usr/bin/env pytriqs
from ClusterDMFT.cdmft import CDmft
from pytriqs.plot.mpl_interface import oplot
import sys
from matplotlib import pyplot as plt
for n, arch in enumerate(sys.argv[1:]):
c = CDmft(archive = arch)
g = c.load('Delta_sym_tau')
for s, b in g:
for i in range(len(b.data[0,:,:])):
for j in range(len(b.data[0,:,:])):
oplot(b[i, j])
plt.gca().set_ylabel('$\Delta_{'+s+'\\,'+str(i)+str(j)+'}^{(s)}(\\tau)$')
plt.savefig(arch[0:-3]+'_Delta_'+s+'_'+str(i)+str(j)+'.png', dpi = 300)
plt.close()
#!/usr/bin/env pytriqs
from ClusterDMFT.periodization import Periodization
from matplotlib import pyplot as plt
from pytriqs.plot.mpl_interface import oplot
import sys
arch = sys.argv[1]
lat = Periodization(archive = arch)
oplot(_tr_g_lat_pade([lat.get_g_lat_loc()])[0], RI = 'S', name = 'local_DOS')
plt.savefig('plot.png')
from pytriqs.gf.local import GfImFreq, SemiCircular g = GfImFreq(indices=['eg1', 'eg2'], beta=50, n_points=1000, name="egBlock") g['eg1', 'eg1'] = SemiCircular(half_bandwidth=1) g['eg2', 'eg2'] = SemiCircular(half_bandwidth=2) from pytriqs.plot.mpl_interface import oplot, plt oplot(g, '-o', x_window=(0, 10)) plt.ylim(-2, 1)
H_loc_block.append(H_loc)
tau_mesh = MeshImTime(beta, 'Fermion', n_tau)
Delta_tau = BlockGf(mesh=tau_mesh, gf_struct=gf_struct)
Delta_tau << Fourier(Delta_iw)
# ------------------------------------------------------------------
# ------------------------------------------------------------------
exit()
from pytriqs.plot.mpl_interface import oplot, oploti, oplotr, plt
subp = [3, 1, 1]
plt.subplot(*subp)
subp[-1] += 1
oplot(G0_iw)
plt.subplot(*subp)
subp[-1] += 1
oplot(Delta_iw)
plt.subplot(*subp)
subp[-1] += 1
oplot(Delta_tau)
plt.show()
exit()
# -- Convert the impurity model to ndarrays with W2Dynamics format
# -- O : composite spin and orbital index
# -- s, o : pure spin and orbital indices
from pyed.OperatorUtils import fundamental_operators_from_gf_struct
from pytriqs.gf.local import *
from pytriqs.archive import *
from pytriqs.plot.mpl_interface import oplot
A = HDFArchive("solution.h5")
G_iw = GfImFreq(indices = [0], beta = 50.0)
G_iw << Fourier(A['G_tau']['up'])
oplot(G_iw, '-o', x_window = (0,10))
from pytriqs.gf.local import *
from pytriqs.archive import *
from pytriqs.plot.mpl_interface import oplot
with HDFArchive('slater_five_band.h5','r') as ar:
# Calculate orbital- and spin-averaged Green's function
G_tau = ar['G_tau-1']
g_tau_ave = G_tau['up_0'].copy()
g_tau_ave.zero()
for name, g in G_tau: g_tau_ave += g
g_tau_ave = g_tau_ave/10.
g_tau_rebin = rebinning_tau(g_tau_ave,1000)
g_tau_rebin.name = r'$G_{\rm ave}$'
oplot(g_tau_rebin,linewidth=2,label='')
import numpy as np from pytriqs.gf.local import GfReFreq, SemiCircular g = GfReFreq(indices = ['eg1', 'eg2'], window = (-5, 5), n_points = 1000, name = "egBlock") g['eg1','eg1'] = SemiCircular(half_bandwidth = 1) g['eg2','eg2'] = SemiCircular(half_bandwidth = 2) from pytriqs.plot.mpl_interface import oplot oplot(g['eg1','eg1'], '-o', RI = 'S') # S : spectral function oplot(g['eg2','eg2'], '-x', RI = 'S')
from pytriqs.gf.local import *
from pytriqs.archive import HDFArchive
from matplotlib import pyplot as plt
from pytriqs.plot.mpl_interface import oplot
# Read data from archive
ar = HDFArchive('results.h5', 'r')
# Plot input and reconstructed correlator
oplot(ar['g_tau'], mode='R', linewidth=0.8, label="$g(\\tau)$")
oplot(ar['g_rec_tau'],
mode='R',
linewidth=0.8,
label="$g_\mathrm{rec}(\\tau)$")
plt.xlim((0, 10))
plt.ylabel("$g(\\tau)$")
plt.legend(loc="upper right")
from pytriqs.gf.local import * gw = GfReFreq(indices=[1], window=(-5, 5), n_points=300, name="egBlock") gw <<= SemiCircular(2.0) # This is a GfReTime gt = gw.inverse_fourier() from pytriqs.plot.mpl_interface import oplot oplot(gt.imag, '-o')
from pytriqs.plot.mpl_interface import oplot
from pytriqs.fit.fit import Fit, linear, quadratic
from pytriqs.gf import *
from pytriqs.gf.descriptors import iOmega_n
g = GfImFreq(indices=[1], beta=300, n_points=1000, name="g")
g << inverse(iOmega_n + 0.5)
print " van plot"
oplot(g, '-o', x_window=(0, 3))
print "plot done"
g << inverse(iOmega_n + 0.5)
print "ok ----------------------"
from pytriqs.archive import HDFArchive
R = HDFArchive('myfile.h5', 'r')
for n, calculation in R.items():
#g = calculation['g']
g << inverse(iOmega_n + 0.5)
print "pokokook"
X, Y = g.x_data_view(x_window=(0, 0.2), flatten_y=True)
#fitl = Fit ( X,Y.imag, linear )
g << inverse(iOmega_n + 0.5)
print " van plot"
oplot(g, '-o', x_window=(0, 3))
a = analytic_hubbard_atom(**parm.dict())
a.G_iw.name = r'$G_{analytic}$'
plt.figure(figsize=(3.25 * 2, 3 * 2))
subp = [2, 2, 1]
plt.subplot(*subp)
subp[-1] += 1
oploti(p.G_iw)
oploti(a.G_iw)
plt.subplot(*subp)
subp[-1] += 1
diff = a.G_iw.copy()
diff << p.G_iw['up'] - a.G_iw
diff.name = r'$G_{ctint} - G_{analytic}$'
oplot(diff)
plt.subplot(*subp)
subp[-1] += 1
vmax = np.max(np.abs(p.chi_m.data.real))
opt = dict(vmax=vmax, vmin=-vmax, cmap='PuOr')
data = np.squeeze(p.chi_m.data.real)
plt.pcolormesh(data, **opt)
plt.tight_layout()
plt.show()
from pytriqs.plot.mpl_interface import oplot
from pytriqs.gf.local 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) )
from pytriqs.gf.local import GfReFreq
from pytriqs.archive import HDFArchive
from math import pi
R = HDFArchive('myfile.h5', 'r')
from pytriqs.plot.mpl_interface import oplot, plt
for name, g in R.items() : # iterate on the elements of R, like a dict ...
oplot( (- 1/pi * g).imag, "-o", name = name)
plt.xlim(-1,1)
plt.ylim(0,7)
p.savefig("./tut_ex3b.png")
from pytriqs.gf.local import GfReFreq
from pytriqs.archive import HDFArchive
from math import pi
R = HDFArchive('myfile.h5', 'r')
from pytriqs.plot.mpl_interface import oplot, plt
for name, g in R.items(): # iterate on the elements of R, like a dict ...
oplot((-1 / pi * g).imag, "-o", name=name)
plt.xlim(-1, 1)
plt.ylim(0, 7)
p.savefig("./tut_ex3b.png")
from pytriqs.gf import * from pytriqs.plot.mpl_interface import oplot, plt # A Green's function on the Matsubara axis set to a semicircular gw = GfImFreq(indices=[1], beta=50) gw << SemiCircular(half_bandwidth=1) # Create a Legendre Green's function with 40 coefficients # and initialize it from gw gl = GfLegendre(indices=[1], beta=50, n_points=40) gl << MatsubaraToLegendre(gw) # Plot the Legendre Green's function oplot(gl, '-o')
# Semicircle
def GSC(z):
return 2.0 * (z + sqrt(1 - z**2) * (log(1 - z) - log(-1 + z)) / pi)
# A superposition of GLorentz(z) and GSC(z) with equal weights
def G(z):
return 0.5 * GLorentz(z) + 0.5 * GSC(z)
# Matsubara GF
gm = GfImFreq(indices=[0], beta=beta, name="gm", n_points=2000)
gm << Function(G)
# Real frequency BlockGf(reference)
gr = GfReFreq(indices=[0], window=(-5.995, 5.995), n_points=1200, name="gr")
gr << Function(G)
# Analytic continuation of gm
g_pade = GfReFreq(indices=[0],
window=(-5.995, 5.995),
n_points=1200,
name="g_pade")
g_pade.set_from_pade(gm, n_points=L, freq_offset=eta)
# Comparison plot
from pytriqs.plot.mpl_interface import oplot
oplot(gr[0, 0], '-o', RI='S', name="Original DOS")
oplot(g_pade[0, 0], '-x', RI='S', name="Pade-reconstructed DOS")
from pytriqs.gf import * from pytriqs.plot.mpl_interface import oplot # A Green's function on the Matsubara axis set to a semicircular gw = GfImFreq(indices=[1], beta=50) gw << SemiCircular(half_bandwidth=1) # Create an imaginary-time Green's function and plot it gt = GfImTime(indices=[1], beta=50) gt << InverseFourier(gw) oplot(gt, '-')
#!/usr/bin/env pytriqs
from ClusterDMFT.cdmft import CDmft
from pytriqs.plot.mpl_interface import oplot
import sys
from matplotlib import pyplot as plt
max_freq = int(sys.argv[1])
for n, arch in enumerate(sys.argv[2:]):
c = CDmft(archive = arch)
g = c.load('g_c_iw')
for s, b in g:
for i in range(len(b.data[0,:,:])):
for j in range(len(b.data[0,:,:])):
oplot(b[i, j], x_window = (0, max_freq), RI = 'R', name = 'Re')
oplot(b[i, j], x_window = (0, max_freq), RI = 'I', name = 'Im')
if s == 'up':
sout = '\\uparrow'
elif s == 'down' or s == 'dn':
sout = '\\downarrow'
else:
sout = s
plt.gca().set_ylabel('$G_{'+sout+'\\,'+str(i)+str(j)+'}^{(c)}(i\\omega_n)$')
plt.savefig(arch[0:-3]+'_G_'+s+'_'+str(i)+str(j)+'.pdf', dpi = 300)
plt.close()
from pytriqs.gf.local import *
from pytriqs.archive import HDFArchive
from matplotlib import pyplot as plt
from pytriqs.plot.mpl_interface import oplot
# Read data from archive
ar = HDFArchive('results.h5', 'r')
# Plot input and reconstructed G(\tau)
oplot(ar['g_tau'][0,0], mode='R', linewidth=0.8, label="$G_{00}(\\tau)$")
oplot(ar['g_tau'][1,1], mode='R', linewidth=0.8, label="$G_{11}(\\tau)$")
oplot(ar['g_rec_tau'][0,0], mode='R', linewidth=0.8, label="$G_{00}^\mathrm{rec}(\\tau)$")
oplot(ar['g_rec_tau'][1,1], mode='R', linewidth=0.8, label="$G_{11}^\mathrm{rec}(\\tau)$")
plt.xlim((0, 20))
plt.ylabel("$G(\\tau)$")
plt.legend(loc="lower center")
0) # Crucial : removes the entry from the dict
ydata1 = numpy.cos(xdata + phi)
ydata2 = numpy.sin(xdata + phi)
return ([{
'type':
"XY",
'xdata':
xdata,
'ydata':
ydata1,
'label':
r'$x \rightarrow \cos (x + \phi), \quad \phi = %s$' % phi
}, {
'type':
"XY",
'xdata':
xdata,
'ydata':
ydata2,
'label':
r'$x \rightarrow \sin (x + \phi), \quad \phi = %s$' % phi
}])
X = myObject()
from pytriqs.plot.mpl_interface import oplot
oplot(X, '-o')
oplot(X, '-x', phi=0.3)
# where n=Number_Orbitals
hop= { (1,0) : [[ t]],
(-1,0) : [[ t]],
(0,1) : [[ t]],
(0,-1) : [[ t]],
(1,1) : [[ tp]],
(-1,-1): [[ tp]],
(1,-1) : [[ tp]],
(-1,1) : [[ tp]]}
TB = TightBinding ( BL, hop)
# Compute the density of states
d = dos (TB, n_kpts= 500, n_eps = 101, name = 'dos')[0]
# Plot the dos it with matplotlib
from pytriqs.plot.mpl_interface import oplot
from matplotlib import pylab as plt
oplot(d,'-o')
plt.xlim ( -5,5 )
plt.ylim ( 0, 0.4)
plt.savefig("./ex1.png")
plt.ylim(1e1, 1e3)
# curvature(alpha)
plt.subplot(2, 2, 3)
res.analyzer_results['Chi2CurvatureAnalyzer'].plot_curvature()
# probablity(alpha)
plt.subplot(2, 2, 2)
res.plot_probability()
# backtransformed G_rec(tau) and original G(tau)
# by default (plot_G=True) also original G(tau) is plotted
plt.subplot(2, 2, 4)
res.plot_G_rec(alpha_index=5)
plt.tight_layout()
# spectral function A
fig2 = plt.figure()
oplot(G_w, mode='S', color='k', lw=3, label='Original Model')
plt.plot(res.omega,
res.analyzer_results['LineFitAnalyzer']['A_out'],
'-',
lw=3,
label='LineFit')
plt.plot(res.omega,
res.analyzer_results['Chi2CurvatureAnalyzer']['A_out'],
'--',
lw=3,
label='Chi2Curvature')
plt.plot(res.omega,
res.analyzer_results['BryanAnalyzer']['A_out'],
'-',
lw=3,
label='Bryan')
