# [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 gf_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(), range()) 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::mesh;
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>{gf_mesh<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}};
auto g4 = gf<imfreq, scalar_valued>{gf_mesh<imfreq>{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)