from pytriqs.base.gf_local import * from pytriqs.base.archive import * from pytriqs.base.plot.mpl_interface import oplot A = HDFArchive("solution.h5") oplot(A["Gl"]["up"], "-o", x_window=(15, 45))
from pytriqs.base.gf_local import GfReFreq, 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 = GfReFreq(indices=["s", "d"], beta=50, mesh_array=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.mpl_interface 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 from pytriqs.base.gf_local import GfReFreq,SemiCircular from pytriqs.base.plot.mpl_interface import oplot gf = GfReFreq(indices = [1], beta = 50, mesh_array = numpy.arange(-30,30,0.1) , name = "my_block") gf[1,1] = SemiCircular(half_bandwidth = 2) oplot(gf.InverseFourier().imag, '-o')
# Import the Green's functions from pytriqs.base.gf_local import GfImFreq, iOmega_n, inverse # Create the Matsubara-frequency Green's function and initialize it g = GfImFreq(indices = [1], beta = 50, n_matsubara = 1000, name = "imp") g <<= inverse( iOmega_n + 0.5 ) from pytriqs.base.plot.mpl_interface import oplot oplot(g, '-o', x_window = (0,10))
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 = GfReFreq(indices = [0], beta = beta, mesh_array = DOSMesh, name = '0') G_real = BlockGf(name_list = ('0',), block_list = (g_real,), make_copies = True) # Analytic continuation with Pade G_real['0'].set_from_pade(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
from pytriqs.base.gf_local import * from pytriqs.base.archive import * from pytriqs.base.plot.mpl_interface import oplot A = HDFArchive("solution.h5") oplot(A['G']['up'], '-o', x_window = (0,10))
from pytriqs.base.gf_local import * from pytriqs.base.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 an imaginary-time Green's function and plot it gt = GfImTime(indices = [1], beta = 50) gt <<= InverseFourier(gw) oplot(gt, '-')
from pytriqs.base.plot.mpl_interface import oplot from pytriqs.base.gf_local import GfImFreq, Omega, inverse g = GfImFreq(indices = [1], beta = 300, n_matsubara = 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) )
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.mpl_interface import oplot oplot(X,'-o')
import numpy as np from pytriqs.base.gf_local import GfReFreq, SemiCircular g = GfReFreq(indices = ['eg1', 'eg2'], beta = 50, mesh_array = np.arange(-5,5,0.01) , name = "egBlock") g['eg1','eg1'] = SemiCircular(half_bandwidth = 1) g['eg2','eg2'] = SemiCircular(half_bandwidth = 2) from pytriqs.base.plot.mpl_interface import oplot oplot(g['eg1','eg1'], '-o', RI = 'S') # S : spectral function oplot(g['eg2','eg2'], '-x', RI = 'S')
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.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.base.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")
from pytriqs.base.gf_local import * from pytriqs.base.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_legendre_coeffs = 40) gl <<= MatsubaraToLegendre(gw) # Plot the Legendre Green's function oplot(gl, '-o')
from pytriqs.base.gf_local import GfReFreq from pytriqs.base.archive import HDFArchive from math import pi R = HDFArchive('myfile.h5', 'r') from pytriqs.base.plot.mpl_interface import oplot, plt plt.xrange(-1,1) plt.yrange(0,7) for name, g in R.items() : # iterate on the elements of R, like a dict ... oplot( (- 1/pi * g).imag, "-o", name = name) p.savefig("./tut_ex3b.png")
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], beta = beta, mesh_array = 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 = GfReFreq(indices = [0], beta = beta, mesh_array = numpy.arange(-6,6,0.01), name = "g_pade") g_pade.set_from_pade(gm, N_Matsubara_Frequencies = L, Freq_Offset = eta) # Comparison plot from pytriqs.base.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.base.plot.mpl_interface 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 = GfImFreq(indices = [1], beta = 300, n_matsubara = 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 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"