latest/doxygen/gfs_8hpp_source.html

// Copyright (c) 2013-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)

// Copyright (c) 2013-2018 Centre national de la recherche scientifique (CNRS)

// Copyright (c) 2018-2023 Simons Foundation

// Copyright (c) 2023 Hugo U.R. Strand

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You may obtain a copy of the License at

//     https://www.gnu.org/licenses/gpl-3.0.txt

//

// Authors: Michel Ferrero, Olivier Parcollet, Hugo U. R. Strand, Nils Wentzell


#pragma once


// for python code generator, we need to know what has to been included.

#define TRIQS_INCLUDED_GF


// BACKWARD COMPAT

#include "./arrays.hpp"


// the meshes

#include "./mesh.hpp"

namespace triqs::gfs {

  using mesh::brzone;

  using mesh::chebyshev;

  using mesh::cyclat;

  using mesh::dlr;

  using mesh::dlr_imfreq;

  using mesh::dlr_imtime;

  using mesh::imfreq;

  using mesh::imtime;

  using mesh::legendre;

  using mesh::make_adjoint_mesh;

  using mesh::prod;

  using mesh::refreq;

  using mesh::retime;

} // namespace triqs::gfs


// the targets

#include "./gfs/gf/defs.hpp"

#include "./gfs/gf/targets.hpp"


// gf class and its mechanisms

#include "./gfs/gf/gf.hpp"

#include "./gfs/gf/gf_view.hpp"

#include "./gfs/gf/gf_const_view.hpp"

#include "./gfs/make_gf.hpp"

#include "./gfs/gf/auto_assign.hpp"

#include "./gfs/gf/mpi.hpp"


// expression template

#include "./gfs/gf/gf_expr.hpp"


// evaluator

#include "./gfs/evaluator.hpp"


// block gf

#include "./gfs/block/block_gf.hpp"

#include "./gfs/block/block_gf_view.hpp"

#include "./gfs/block/mpi.hpp"

#include "./gfs/block/factories.hpp"

#include "./gfs/block/functions.hpp"

#include "./gfs/block/expr.hpp"

#include "./gfs/block/auto_assign.hpp"

#include "./gfs/block/map.hpp"

#include "./gfs/block/mapped_functions.hxx"


// hdf5

#include "./gfs/h5.hpp"


#include "./gfs/functions/functions2.hpp"

#include "./gfs/functions/imfreq.hpp"

#include "./gfs/functions/imtime.hpp"

#include "./gfs/functions/legendre.hpp"

#include "./gfs/functions/density.hpp"

#include "./gfs/functions/dlr.hpp"


// fourier

#include "./gfs/transform/fourier.hpp"

#include "./gfs/transform/legendre_matsubara.hpp"


#include "./gfs/transform/partial_transform.hpp"


#ifdef C2PY_INCLUDED

#include "./c2py_converters/gf.hpp"

#endif

arrays.hpp
Backward-compatibility umbrella header pulling in the nda array library.

auto_assign.hpp
Provides the CLEF auto-assignment hooks for block Green's functions.

mpi.hpp
Provides MPI routines for block Green's function objects.

block_gf.hpp
Provides the block Green's function container.

block_gf_view.hpp
Provides a non-owning view of a block Green's function.

defs.hpp
Provides common type aliases, forward declarations and internal helpers for the Green's function cont...

density.hpp
Provides functions to compute the density (occupation) from Green's functions.

evaluator.hpp
Provides the gf_evaluator that evaluates a Green's function at arbitrary mesh points.

expr.hpp
Provides the lazy expression templates that fuse arithmetic operations on block Green's functions.

factories.hpp
Provides the free factory functions for block Green's functions.

fourier.hpp
Provides the Fourier transform factories and the lazy fourier(...) assignment for Green's functions.

functions2.hpp
Provides tail fitting, slicing, inversion, reality and matrix-multiplication functions for Green's fu...

auto_assign.hpp
Provides the CLEF auto-assignment hooks for Green's functions.

mpi.hpp
Provides MPI routines for Green's function objects.

gf_const_view.hpp
Provides the triqs::gfs::gf_const_view container, a read-only non-owning view of a Green's function.

gf_expr.hpp
Provides the lazy expression templates that fuse arithmetic operations on Green's functions.

gf_view.hpp
Provides a mutable non-owning view of a Green's function.

functions.hpp
Provides the block-wise lazy Fourier transform for block Green's functions.

dlr.hpp
Provides conversions between Green's functions and the Discrete Lehmann Representation (DLR).

imfreq.hpp
Provides Matsubara-frequency-specific functions and reality / hermiticity helpers for Green's functio...

imtime.hpp
Provides imaginary-time Green's function utilities.

legendre.hpp
Provides functions specific to Legendre-basis Green's functions.

gf.hpp
Provides the Green's function class.

triqs::mesh::make_adjoint_mesh
imfreq make_adjoint_mesh(imtime const &m, long n_iw=-1)
Create the adjoint imaginary-frequency mesh to a given imaginary-time mesh.
Definition adjoint.hpp:50

h5.hpp
Provides the HDF5 read/write machinery for Green's functions.

legendre_matsubara.hpp
Provides transformations between Legendre-basis and Matsubara (imaginary-time / imaginary-frequency) ...

make_gf.hpp
Provides factory functions to construct Green's functions from a mesh and target, or from another Gre...

map.hpp
Provides the function applying a callable block by block to a block Green's function.

mapped_functions.hxx
Provides block-wise applications (via triqs::gfs::map_block_gf) of common Green's function operations...

mesh.hpp
Umbrella header for the TRIQS mesh types.

partial_transform.hpp
Provides a helper to apply a transform to a single component of a product-mesh Green's function.

targets.hpp
Provides the target types that fix the value stored at each mesh point of a Green's function.