from pytriqs.Base.GF_Local import GFBloc_ReFreq, Omega, Wilson, inverse import numpy a = numpy.arange(-1.99, 2.00, 0.02) # Define the energy array eps_d, V = 0.3, 0.2 # Create the real-frequency Green's function and initialize it g = GFBloc_ReFreq(Indices=['s', 'd'], Beta=50, MeshArray=a, Name="s+d") g['d', 'd'] = Omega - eps_d g['d', 's'] = V g['s', 'd'] = V g['s', 's'] = inverse(Wilson(1.0)) g.invert() # Plot it with matplotlib. 'S' means: spectral function ( -1/pi Imag (g) ) from pytriqs.Base.Plot.MatplotlibInterface import oplot 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")
from pytriqs.Base.GF_Local import * from pytriqs.Base.Plot.MatplotlibInterface import oplot, plt # A Green's function on the Matsubara axis set to a semicircular gw = GFBloc_ImFreq(Indices=[1], Beta=50) gw <<= SemiCircular(HalfBandwidth=1) # Create an imaginary-time Green's function and plot it gt = GFBloc_ImTime(Indices=[1], Beta=50) gt <<= InverseFourier(gw) oplot(gt, '-')
# 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 = tight_binding ( BL, hop)
# Compute the density of states
d = dos (TB, nkpts= 500, neps = 101, Name = 'dos')[0]
# Plot the dos it with matplotlib
from pytriqs.Base.Plot.MatplotlibInterface import oplot
from matplotlib import pylab as plt
oplot(d,'-o')
plt.xlim ( -5,5 )
plt.ylim ( 0, 0.4)
plt.savefig("./ex1.png")
import numpy from pytriqs.Base.GF_Local import GFBloc_ReFreq,SemiCircular from pytriqs.Base.Plot.MatplotlibInterface import oplot gf = GFBloc_ReFreq(Indices = [1], Beta = 50, MeshArray = numpy.arange(-30,30,0.1) , Name = "my_block") gf[1,1] = SemiCircular(HalfBandwidth = 2) oplot(gf.InverseFourier().imag, '-o')
from pytriqs.Base.GF_Local import *
from pytriqs.Base.Archive import *
from pytriqs.Base.Plot.MatplotlibInterface import oplot
A = HDF_Archive("solution.h5")
oplot(A['Gl']['up'], '-o', x_window=(15,45) )
from pytriqs.Base.GF_Local import * from pytriqs.Base.Plot.MatplotlibInterface import oplot,plt # A Green's function on the Matsubara axis set to a semicircular gw = GFBloc_ImFreq(Indices = [1], Beta = 50) gw <<= SemiCircular(HalfBandwidth = 1) # Create a Legendre Green's function with 40 coefficients # initialize it from gw and plot it gl = GFBloc_ImLegendre(Indices = [1], Beta = 50, NLegendreCoeffs = 40) gl <<= MatsubaraToLegendre(gw) oplot(gl, '-o')
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.Base.Plot.MatplotlibInterface import oplot
oplot(X, '-o')
from pytriqs.Base.GF_Local import GFBloc_ImFreq, SemiCircular
g = GFBloc_ImFreq(Indices=['eg1', 'eg2'],
Beta=50,
NFreqMatsubara=1000,
Name="egBlock")
g['eg1', 'eg1'] = SemiCircular(HalfBandwidth=1)
g['eg2', 'eg2'] = SemiCircular(HalfBandwidth=2)
from pytriqs.Base.Plot.MatplotlibInterface import oplot, plt
oplot(g, '-o', x_window=(0, 10))
plt.ylim(-2, 1)
from pytriqs.Base.GF_Local import GFBloc_ReFreq, Omega, Wilson, inverse import numpy a = numpy.arange(-1.99,2.00,0.02) # Define the energy array eps_d,V = 0.3, 0.2 # Create the real-frequency Green's function and initialize it g = GFBloc_ReFreq(Indices = ['s','d'], Beta = 50, MeshArray = a, Name = "s+d") g['d','d'] = Omega - eps_d g['d','s'] = V g['s','d'] = V g['s','s'] = inverse( Wilson(1.0) ) g.invert() # Plot it with matplotlib. 'S' means: spectral function ( -1/pi Imag (g) ) from pytriqs.Base.Plot.MatplotlibInterface import oplot 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" )
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.Base.Plot.MatplotlibInterface import oplot
oplot(X,'-o')
from pytriqs.Base.Plot.MatplotlibInterface import oplot
from pytriqs.Base.GF_Local import GFBloc_ImFreq, Omega, inverse
g = GFBloc_ImFreq(Indices = [1], Beta = 300, NFreqMatsubara = 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.Base.Fit.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) )
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 = GFBloc_ImFreq(Indices = [0], Beta = beta, Name = "gm")
gm <<= Function(G)
gm._tail.zero()
gm._tail[1] = numpy.array([[1.0]])
# Real frequency GF (reference)
gr = GFBloc_ReFreq(Indices = [0], Beta = beta, MeshArray = numpy.arange(-6,6,0.01), Name = "gr")
gr <<= Function(G)
gr._tail.zero()
gr._tail[1] = numpy.array([[1.0]])
# Analytic continuation of gm
g_pade = GFBloc_ReFreq(Indices = [0], Beta = beta, MeshArray = numpy.arange(-6,6,0.01), Name = "g_pade")
g_pade.setFromPadeOf(gm, N_Matsubara_Frequencies = L, Freq_Offset = eta)
# Comparison plot
from pytriqs.Base.Plot.MatplotlibInterface 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.Base.GF_Local import *
from pytriqs.Base.Archive import *
from pytriqs.Base.Plot.MatplotlibInterface import oplot
A = HDF_Archive("solution.h5")
oplot(A['G']['up'], '-o', x_window = (0,10))
from pytriqs.Base.Plot.MatplotlibInterface import oplot
from pytriqs.Base.GF_Local import GFBloc_ImFreq, Omega, inverse
g = GFBloc_ImFreq(Indices=[1], Beta=300, NFreqMatsubara=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.Base.Fit.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.Base.Plot.MatplotlibInterface import oplot
from pytriqs.Base.Fit.fit import Fit, linear, quadratic
from pytriqs.Base.GF_Local import *
from pytriqs.Base.GF_Local.Descriptors import iOmega_n
g = GFBloc_ImFreq(Indices = [1], Beta = 300, NFreqMatsubara = 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.Base.Archive import HDF_Archive
R = HDF_Archive('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"
import numpy
class myObject(object):
def _plot_(self, options):
PI = numpy.pi
xdata = numpy.arange(-PI,PI,0.1)
phi = options.pop('phi',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.Base.Plot.MatplotlibInterface import oplot
oplot(X,'-o')
oplot(X,'-x', phi = 0.3)
# 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 = tight_binding(BL, hop)
# Compute the density of states
d = dos(TB, nkpts=500, neps=101, Name='dos')[0]
# Plot the dos it with matplotlib
from pytriqs.Base.Plot.MatplotlibInterface import oplot
from matplotlib import pylab as plt
oplot(d, '-o')
plt.xlim(-5, 5)
plt.ylim(0, 0.4)
plt.savefig("./ex1.png")
from pytriqs.Base.GF_Local import GFBloc_ImFreq, SemiCircular g = GFBloc_ImFreq(Indices = ['eg1','eg2'], Beta = 50, NFreqMatsubara = 1000, Name = "egBlock") g['eg1','eg1'] = SemiCircular(HalfBandwidth = 1) g['eg2','eg2'] = SemiCircular(HalfBandwidth = 2) from pytriqs.Base.Plot.MatplotlibInterface import oplot,plt oplot(g, '-o', x_window = (0,10)) plt.ylim(-2,1)
return 0.5 * GLorentz(z) + 0.5 * GSC(z)
# Matsubara GF
gm = GFBloc_ImFreq(Indices=[0], Beta=beta, Name="gm")
gm <<= Function(G)
gm._tail.zero()
gm._tail[1] = numpy.array([[1.0]])
# Real frequency GF (reference)
gr = GFBloc_ReFreq(Indices=[0],
Beta=beta,
MeshArray=numpy.arange(-6, 6, 0.01),
Name="gr")
gr <<= Function(G)
gr._tail.zero()
gr._tail[1] = numpy.array([[1.0]])
# Analytic continuation of gm
g_pade = GFBloc_ReFreq(Indices=[0],
Beta=beta,
MeshArray=numpy.arange(-6, 6, 0.01),
Name="g_pade")
g_pade.setFromPadeOf(gm, N_Matsubara_Frequencies=L, Freq_Offset=eta)
# Comparison plot
from pytriqs.Base.Plot.MatplotlibInterface import oplot
oplot(gr[0, 0], '-o', RI='S', Name="Original DOS")
oplot(g_pade[0, 0], '-x', RI='S', Name="Pade-reconstructed DOS")
phi = options.pop('phi',
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.Base.Plot.MatplotlibInterface import oplot
oplot(X, '-o')
oplot(X, '-x', phi=0.3)
from pytriqs.Base.GF_Local import *
from pytriqs.Base.Archive import *
from pytriqs.Base.Plot.MatplotlibInterface import oplot
A = HDF_Archive("solution.h5")
oplot(A['G']['up'], '-o', x_window=(0, 10))
import numpy as np
from pytriqs.Base.GF_Local import GFBloc_ReFreq, SemiCircular
g = GFBloc_ReFreq(Indices=['eg1', 'eg2'],
Beta=50,
MeshArray=np.arange(-5, 5, 0.01),
Name="egBlock")
g['eg1', 'eg1'] = SemiCircular(HalfBandwidth=1)
g['eg2', 'eg2'] = SemiCircular(HalfBandwidth=2)
from pytriqs.Base.Plot.MatplotlibInterface import oplot
oplot(g['eg1', 'eg1'], '-o', RI='S') # S : spectral function
oplot(g['eg2', 'eg2'], '-x', RI='S')
import numpy as np from pytriqs.Base.GF_Local import GFBloc_ReFreq, SemiCircular g = GFBloc_ReFreq(Indices=["eg1", "eg2"], Beta=50, MeshArray=np.arange(-5, 5, 0.01), Name="egBlock") g["eg1", "eg1"] = SemiCircular(HalfBandwidth=1) g["eg2", "eg2"] = SemiCircular(HalfBandwidth=2) from pytriqs.Base.Plot.MatplotlibInterface import oplot oplot(g["eg1", "eg1"], "-o", RI="S") # S : spectral function oplot(g["eg2", "eg2"], "-x", RI="S")
from pytriqs.Base.GF_Local import * from pytriqs.Base.Plot.MatplotlibInterface import oplot,plt # A Green's function on the Matsubara axis set to a semicircular gw = GFBloc_ImFreq(Indices = [1], Beta = 50) gw <<= SemiCircular(HalfBandwidth = 1) # Create an imaginary-time Green's function gt = GFBloc_ImTime(Indices = [1], Beta = 50) gt <<= InverseFourier(gw) # Plot the Legendre Green's function oplot(gt, '-')
from pytriqs.Base.GF_Local import * from pytriqs.Base.Plot.MatplotlibInterface import oplot, plt # A Green's function on the Matsubara axis set to a semicircular gw = GFBloc_ImFreq(Indices=[1], Beta=50) gw <<= SemiCircular(HalfBandwidth=1) # Create a Legendre Green's function with 40 coefficients # and initialize it from gw gl = GFBloc_ImLegendre(Indices=[1], Beta=50, NLegendreCoeffs=40) gl <<= MatsubaraToLegendre(gw) # Plot the Legendre Green's function oplot(gl, '-o')
print "Running DMFT calculation for beta=%.2f, U=%.2f, t=%.2f" % (beta,u,t)
IPT.run(N_loops = N_loops, beta=beta, U=u, Initial_G0=Initial_G0, Self_Consistency=Self_Consistency)
# The resulting local GF on the real axis
g_real = GFBloc_ReFreq(Indices = [0], Beta = beta, MeshArray = DOSMesh, Name = '0')
G_real = GF(NameList = ('0',), BlockList = (g_real,), Copy = True)
# Analytic continuation with Pade
G_real['0'].setFromPadeOf(IPT.S.G['0'], N_Matsubara_Frequencies=Pade_L, Freq_Offset=eta)
# Save data to the archive
ar['U' + str(u)] = {'G0': IPT.S.G0, 'G': IPT.S.G, 'Sigma': IPT.S.Sigma, 'G_real':G_real}
# Plot the DOS
fig = plt.figure()
oplot(G_real['0'][0,0], RI='S', Name="DOS", figure = fig)
# Adjust 'y' axis limits accordingly to the Luttinger sum rule
fig.axes[0].set_ylim(0,1/pi/t*1.1)
# Set title of the plot
fig_title = "Local DOS, IPT, Bethe lattice, $\\beta=%.2f$, $U=%.2f$" % (beta,u)
plt.title(fig_title)
# Save the figure as a PNG file
DOS_file = "DOS_beta%.2fU%.2f.png" % (beta,u)
fig.savefig(DOS_file, format="png", transparent=False)
DOS_files.append(DOS_file)
plt.close(fig)
# Create an animated GIF
import numpy
from pytriqs.Base.GF_Local import GFBloc_ReFreq, SemiCircular
from pytriqs.Base.Plot.MatplotlibInterface import oplot
gf = GFBloc_ReFreq(Indices=[1],
Beta=50,
MeshArray=numpy.arange(-30, 30, 0.1),
Name="my_block")
gf[1, 1] = SemiCircular(HalfBandwidth=2)
oplot(gf.InverseFourier().imag, '-o')