[block_gf<T>] Block Green functions

This is a specialisation of gf and views for block functions.

A block Green function is nothing but Green function on a discrete domain representing the block indices, and whose value is itself a Green function.

For convenience, the following aliases are provided

template<typename ... T> using block_gf            = gf           <block_index, gf<T...>>;
template<typename ... T> using block_gf_view       = gf_view      <block_index, gf<T...>>;
template<typename ... T> using block_gf_const_view = gf_const_view<block_index, gf<T...>>;

Constructors

The constructors of the gf.

target_shape_t = {}

Factories

Also several factories are provided for these block Green functions.

Factories for the regular type

The factories for the regular type gf are

// From a number and a gf to be copied
template <typename Variable, typename Target, typename Opt>
block_gf<Variable, Target, Opt>
make_block_gf(int n, gf<Variable, Target, Opt> const & g);

// From a vector of gf (moving directly)
template <typename Variable, typename Target, typename Opt>
block_gf<Variable, Target, Opt>
make_block_gf(std::vector<gf<Variable, Target, Opt>> V);

// From a vector of gf or views (a gf must be contructible from GF2)
template <typename Variable, typename Target, typename Opt, typename GF2>
block_gf<Variable, Target, Opt>
make_block_gf(std::vector<GF2> const &V);

// From a init list of GF with the correct type
template <typename Variable, typename Target, typename Opt>
block_gf<Variable, Target, Opt>
make_block_gf(std::initializer_list<gf<Variable, Target, Opt>> const &V);

// From vector<string> and a gf to be copied
template <typename Variable, typename Target, typename Opt>
block_gf<Variable, Target, Opt>
make_block_gf(std::vector<std::string> block_names, gf<Variable, Target, Opt> const &g);

// From vector<string>, vector<gf>
template <typename Variable, typename Target, typename Opt>
block_gf<Variable, Target, Opt>
make_block_gf(std::vector<std::string> block_names, std::vector<gf<Variable, Target, Opt>> V);

// From vector<string>, init_list<GF>
template <typename Variable, typename Target, typename Opt>
block_gf<Variable, Target, Opt>
make_block_gf(std::vector<std::string> block_names,
              std::initializer_list<gf<Variable, Target, Opt>> const &V);

Factories for the view type

The factories for the view type gf_view, gf_const_view are

// Build a view of the gf.
// 1- All Green functions must have the same type
// 2- [Expert only] This is a simplified version of the code.
//    In the real code, the documentation/manual/triqs is of stripped from G in the type deduction.
template<typename ... G>
 gf_view<block_index, G>
 make_block_gf_view(G && ... g);

// Make a view from a vector of gf
template<typename GF>
 gf_view<block_index,GF>
 make_block_gf_view_from_vector (std::vector<GF> V);

Domain & mesh

The domain is a discrete domain …

Singularity

None.

Interpolation method

None.

Data storage

Not exposed to user.

HDF5 storage convention

TO BE WRITTEN.

Iterators

TO BE COMPLETED.

Block gf have a natural iterator, e.g.

// if a BG is block function
for (auto & g: BG) ....

Examples

#include <triqs/gfs.hpp>
#include <triqs/mesh.hpp>
using namespace triqs::gfs;
using namespace triqs::mesh;
using nda::clef::placeholder;
int main() {
  double beta = 1;

  // Make a block gf of 3 gf, which are empty (default constructed).
  auto Bg0                             = block_gf<imfreq>(3);
  auto Bg1                             = block_gf<imfreq>({"a", "b", "c"});
  std::vector<std::string> block_names = {"a", "b", "c"};
  auto Bg11                            = block_gf<imfreq>(block_names);

  // make a few gf<imfreq> ...
  auto g1 = gf<imfreq>({beta, Fermion}, {2, 2});

  // ... and construct some block function out of them.
  auto Bg2 = make_block_gf<imfreq>(3, g1);
  auto Bg3 = make_block_gf<imfreq>({g1, g1, g1});
  auto Bg4 = make_block_gf<imfreq>({"a", "b", "c"}, {g1, g1, g1});

  // do something on all blocks
  for (auto const &g : Bg2) { std::cout << g.mesh() << std::endl; }

  // multiply them by 1,2,3  ...
  auto i = 1;
  for (auto &g : Bg2) g = g * i++;

  // a little save in an hdf5 file ?
  h5::file file("test_block_gf.h5", 'w');
  h5_write(file, "B4", Bg4);
}

Matsubara Freq Mesh of size 2050, Domain: Matsubara domain with beta = 1, statistic = Fermion, positive_only : 0
Matsubara Freq Mesh of size 2050, Domain: Matsubara domain with beta = 1, statistic = Fermion, positive_only : 0
Matsubara Freq Mesh of size 2050, Domain: Matsubara domain with beta = 1, statistic = Fermion, positive_only : 0