Local Green’s functions

In this first part, we present a couple of examples in the form of a tutorial. The full reference is presented in the next sections.

A simple example

As a first example, we construct and plot the following Matsubara Green’s function:

\[G_{11} (i \omega_n) = \frac{1}{i \omega_n + 0.5}\]

This is done with the code :

# Import the Green's functions 
from triqs.gf import GfImFreq, iOmega_n, inverse

# Create the Matsubara-frequency Green's function and initialize it
g = GfImFreq(indices = [1], beta = 50, n_points = 1000, name = "$G_\mathrm{imp}$")
g << inverse( iOmega_n + 0.5 )

from triqs.plot.mpl_interface import oplot
oplot(g, '-o',  x_window  = (0,10))

(Source code, png, hires.png, pdf)

../../_images/example.png

In this very simple example, the Green’s function is just a 1x1 block. Let’s go through the different steps of the example:

# Import the Green's functions 
from triqs.gf import GfImFreq, iOmega_n, inverse

This imports all the necessary classes to manipulate Green’s functions. In this example it allows to use GfImFreq:

# Create the Matsubara-frequency Green's function and initialize it
g = GfImFreq(indices = [1], beta = 50, n_points = 1000, name = "$G_\mathrm{imp}$")

This creates a block Green’s function which has just one index (1). beta is the inverse temperature, n_points is the number of Matsubara frequencies.

g << inverse( iOmega_n + 0.5 )

This initializes the block with \(1/(i \omega_n + 0.5)\). Two points are worth noting here:

  • The right hand side (RHS) of this statement is a lazy expression: its evaluation is delayed until it is needed to fill the Green function.

  • The funny << operator means “set from”. It fills the Green function with the evaluation of the expression at the right.

oplot(g, '-o',  x_window  = (0,10))

These lines plot the block Green’s function (both the real and imaginary parts) using the matplotlib plotter. More details can be found in the section Plotting TRIQS objects.

A slightly more complicated example

Let’s turn to another example. This time we consider a problem of a d-impurity level embedded in a flat conduction bath \(\Delta\) of s-electrons. We want to construct the corresponding 2x2 Green’s function:

\[\begin{split}\hat{G}^\mathrm{s+d} (\omega_n) = \begin{pmatrix} \omega_n - \epsilon_d & V \\ V & \Delta^{-1} \end{pmatrix}^{-1}\end{split}\]

This is done with the code:

from triqs.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 triqs.plot.mpl_interface import oplot, plt
oplot( g['d','d'], '-o', mode = 'S', x_window  = (-1.8,1.8), name = "Impurity" )
oplot( g['s','s'], '-x', mode = 'S', x_window  = (-1.8,1.8), name = "Bath" )
plt.show()

(Source code, png, hires.png, pdf)

../../_images/impinbath.png

Again, the Green’s function is just one block, but this time it is a 2x2 block with off-diagonal elements. Another difference is that we use real-frequency Green’s functions in this example:

# 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}$")

In this constructor for the block Green’s function, we specify that there are two indices s and d. Because it is a real-frequency Green’s function we need to define the mesh on which it is computed. This is done with the window and n_points options.

g['d','d'] = Omega - eps_d
g['d','s'] = t
g['s','d'] = t
g['s','s'] = inverse( Wilson(1.0) )

These lines initialize specific entries of the block Green’s function. Note how the elements are accessed with [index1,index2]. These lines also show how to initialize a Green’s function to a constant or to the inverse of a Flat bath (constant spectral function on an interval \([-D,D]\), with \(D=1.0\) in our example).

g.invert()

invert() inverts the entire block Green’s function (as a matrix).

# Plot it with matplotlib. 'S' means: spectral function ( -1/pi Imag (g) )
from triqs.plot.mpl_interface import oplot, plt
oplot( g['d','d'], '-o', mode = 'S', x_window  = (-1.8,1.8), name = "Impurity" )
oplot( g['s','s'], '-x', mode = 'S', x_window  = (-1.8,1.8), name = "Bath" )

Here, we isolate some elements of the blocks Green’s function. It is also the first example of an operation on the block Green’s function, which is multiplied by a scalar. The last lines of the script just plot these new objects.