[gf<imtime>] Matsubara imaginary time

This is a specialisation of gf for imaginary Matsubara time.

Synopsis

gf<imtime, 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 the set of real numbers between 0 and \(\beta\) since the function is periodic (resp. antiperiodic) for bosons (resp. fermions), i.e.

• \(G(\tau+\beta)=-G(\tau)\) for fermions

• \(G(\tau+\beta)=G(\tau)\) for bosons.

The domain is implemented in

The mesh is mesh::imtime.

Singularity

The singularity is a high frequency expansion, High-Frequency moments of the Green’s function.

Evaluation method

• Use a linear interpolation between the two closest point of the mesh.

• 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 evaluation of the gf returns:

  • the evaluation of the high frequency tail

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.

TO DO: complex OR DOUBLE: FIX and document !!

HDF5 storage convention

h5 tag: ImTime

Examples

#include <triqs/gfs.hpp>
#include <triqs/mesh.hpp>
using namespace triqs::gfs;
using namespace triqs;
int main() {
  double beta = 10, a = 1;
  int n_times = 1000;

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

  // First give information to build the mesh, second to build the target
  auto g1 = gf<imtime, matrix_valued>{{beta, Fermion, n_times}, {1, 1}};

  // or a more verbose/explicit form ...
  auto g2 = gf<imtime>{{beta, Fermion, n_times}, make_shape(1, 1)};

  nda::clef::placeholder<0> tau_;
  g1(tau_) << exp(-a * tau_) / (1 + exp(-beta * a));

  // evaluation at tau=3.2
  std::cout << nda::make_regular(g1(3.2)) << " == " << exp(-a * 3.2) / (1 + exp(-beta * a)) << std::endl;

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

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

  g3(tau_) << exp(-a * tau_) / (1 + exp(-beta * a));

  // evaluation at tau=3.2
  std::cout << g3(3.2) << " == " << exp(-a * 3.2) / (1 + exp(-beta * a)) << std::endl;
}

[[(0.0407608,0)]] == 0.0407604
(0.0407608,0) == 0.0407604