[gf<imfreq>] Green function on Matsubara frequencies

This is a specialisation of gf for imaginary Matsubara frequencies.

Synopsis

gf<imfreq, Target, Opt>

The Target template parameter can take the following values:

Target

Meaning

scalar_valued

The function is scalar valued (double, complex…).

matrix_valued [default]

The function is matrix valued.

Domain & mesh

The domain is triqs::gfs::matsubara_domain.

The Matsubara frequencies are \(\omega_n=\frac{(2n+1)\pi}{\beta}\) for fermions and \(\omega_n=\frac{2n\pi}{\beta}\) for bosons.

The mesh is mesh::imfreq.

Evaluation method

  • No interpolation.

  • Return type:

    • If Target==scalar_valued: a complex

    • If Target==matrix_valued: an object modeling ImmutableMatrix concept.

  • When the point is outside of the mesh, the high-frequency moments of the Green function are automatically determined using a least-square fitting procedure. They are then used to calculate the value of the Green function at the point.

Data storage

  • If Target==scalar_valued :

    • data_t: 1d array of complex<double>.

    • g.data()(i) is the value of g for the i-th point of the mesh.

  • If Target==matrix_valued :

    • data_t: 3d array (C ordered) of complex<double>.

    • g.data()(i, range::all, range::all) is the value of g for the i-th point of the mesh.

HDF5 storage convention

h5 tag: ImFreq

TODO: DECIDE if we have 2 tag, one for scalar, one for matrix….

Examples

#include <triqs/gfs.hpp>
#include <triqs/mesh.hpp>
using namespace triqs::gfs;
using namespace triqs;
int main() {
  double beta = 10;
  int Nfreq   = 100;

  // --- first a matrix_valued function ------------

  // First give information to build the mesh, second to build the target
  auto g1 = gf<imfreq>{{beta, Fermion, Nfreq}, {1, 1}};
  // or a more verbose/explicit form ...
  auto g2 = gf<imfreq>{{beta, Fermion, Nfreq}, make_shape(1, 1)};

  // Filling the gf with something...
  nda::clef::placeholder<0> wn_;
  g1(wn_) << 1 / (wn_ + 2);

  // evaluation at n=3
  std::cout << g1(3) << " == " << 1 / (1i * M_PI / beta * (2 * 3 + 1) + 2) << std::endl;
  // the high frequency expansion was automatically computed.
  // std::cout << g1.singularity() << std::endl; // a bit verbose..

  // --- a scalar_valued function ------------

  // same a before, but without the same of the target space ...
  auto g3 = gf<imfreq, scalar_valued>{{beta, Fermion, Nfreq}};

  g3(wn_) << 1 / (wn_ + 2);

  // evaluation at n=3.
  std::cout << g3(3) << " == " << 1 / (1i * std::acos(-1) / beta * (2 * 3 + 1) + 2) << std::endl;
}


[[(0.226344,-0.248878)]] == (0.226344,-0.248878)
(0.226344,-0.248878) == (0.226344,-0.248878)

Free functions