fourier.hpp

#include "../gf/flatten.hpp"
#include "../gf/gf.hpp"
#include "../gf/gf_const_view.hpp"
#include "../gf/gf_view.hpp"
#include "../gf/targets.hpp"
#include "../block/block_gf.hpp"
#include "../block/map.hpp"
#include "../functions/dlr.hpp"
#include "../../mesh/adjoint.hpp"
#include "../../mesh/brzone.hpp"
#include "../../mesh/cyclat.hpp"
#include "../../mesh/dlr_imfreq.hpp"
#include "../../mesh/dlr_imtime.hpp"
#include "../../mesh/imfreq.hpp"
#include "../../mesh/imtime.hpp"
#include "../../mesh/prod.hpp"
#include "../../mesh/refreq.hpp"
#include "../../mesh/retime.hpp"
#include "../../utility/exceptions.hpp"
#include "../../utility/tuple_tools.hpp"
#include <itertools/itertools.hpp>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

Detailed Description

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

Definition in file fourier.hpp.

Go to the source code of this file.

Functions
template<int N = 0, typename G, typename... Args>
_fourier_lazy< N, typename G::const_view_type, Args... >	triqs::gfs::fourier (G const &g, Args &&...1)
	Build a lazy Fourier transform expression for use in g_out = fourier(g_in, ...) assignments.
template<int N = 0, int... Ns, typename G, typename... Args> requires (is_block_gf_v<G>)
auto	triqs::gfs::make_gf_from_fourier (G const &gin, Args const &...1)
	Fourier transform a block Green's function block-wise, forwarding any extra arguments to each block.
template<int N = 0, typename G, typename M, int R> requires (is_block_gf_v<G>)
auto	triqs::gfs::make_gf_from_fourier (G const &gin, M const &m, std::vector< array< dcomplex, R > > const &known_moments)
	Fourier transform a block Green's function, with per-block known high-frequency moments.
template<int N = 0, typename G, typename M, int R> requires (is_block_gf_v<G>)
auto	triqs::gfs::make_gf_from_fourier (G const &gin, M const &m, std::vector< std::vector< array< dcomplex, R > > > const &known_moments)
	Fourier transform a Block2 Green's function, with per-block known high-frequency moments.
template<int N = 0, int... Ns, typename V, typename T, typename... Args>
auto	triqs::gfs::make_gf_from_fourier (gf< V, T > const &gin, Args &&...1)
	Overload accepting a triqs::gfs::gf input; delegates to the const-view implementation.
template<int N = 0, typename M1, typename M2, typename T, typename... OptArgs>
auto	triqs::gfs::make_gf_from_fourier (gf_const_view< M1, T > gin, M2 const &mesh, OptArgs const &...opt_args)
	Build a new Green's function on the conjugate mesh by Fourier transforming an input Green's function.
template<int N = 0, typename T>
auto	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::brzone, T > gin)
	Fourier transform a Brillouin-zone Green's function to the conjugate cyclic-lattice mesh.
template<int N = 0, typename T>
auto	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::cyclat, T > gin)
	Fourier transform a cyclic-lattice Green's function to the conjugate Brillouin-zone mesh.
template<int N = 0, typename T>
gf< mesh::dlr_imtime, T >	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::dlr_imfreq, T > gin)
	Fourier transform a Matsubara-frequency DLR Green's function to the imaginary-time DLR mesh.
template<int N = 0, typename T>
gf< mesh::dlr_imfreq, typename T::complex_t >	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::dlr_imtime, T > gin)
	Fourier transform an imaginary-time DLR Green's function to the Matsubara-frequency DLR mesh.
template<int N = 0, typename T>
gf< mesh::imtime, T >	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::imfreq, T > gin, int n_tau=-1)
	Fourier transform a Matsubara-frequency Green's function to imaginary time (n_tau time points, -1 for the default).
template<int N = 0, typename T>
gf< mesh::imfreq, typename T::complex_t >	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::imtime, T > gin, int n_iw=-1)
	Fourier transform an imaginary-time Green's function to Matsubara frequencies (n_iw positive frequencies, -1 for the default).
template<int... Ns, typename... Vs, typename T>
auto	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::prod< Vs... >, T > gin)
	Fourier transform the components Ns of a product-mesh Green's function onto their default conjugate meshes.
template<int N1, int N2, typename M1, typename M2, typename... Vs, typename T>
auto	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::prod< Vs... >, T > gin, M1 &&m1, M2 &&m2)
	Fourier transform two components of a product-mesh Green's function onto the explicit meshes m1 and m2.
template<int N1, int N2, int N3, typename M1, typename M2, typename M3, typename... Vs, typename T>
auto	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::prod< Vs... >, T > gin, M1 &&m1, M2 &&m2, M3 &&m3)
	Fourier transform three components of a product-mesh Green's function onto the explicit meshes m1, m2 and m3.
template<int N = 0, typename T>
gf< mesh::retime, T >	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::refreq, T > gin, bool shift_half_bin=false)
	Fourier transform a real-frequency Green's function to real time (set shift_half_bin to shift the time mesh by half a bin).
template<int N = 0, typename T>
gf< mesh::refreq, typename T::complex_t >	triqs::gfs::make_gf_from_fourier (gf_const_view< mesh::retime, T > gin, bool shift_half_bin=false)
	Fourier transform a real-time Green's function to real frequencies (set shift_half_bin to shift the frequency mesh by half a bin).
template<int N = 0, int... Ns, typename V, typename T, typename... Args>
auto	triqs::gfs::make_gf_from_fourier (gf_view< V, T > gin, Args &&...1)
	Overload accepting a triqs::gfs::gf_view input; delegates to the const-view implementation.
template<int... Ns, typename V, typename T>
auto	triqs::gfs::make_gf_from_multi_fourier (gf_const_view< V, T > gin)
	Fourier transform several components of a product-mesh Green's function at once.