embedding.hpp File Reference

#include "./downfolding.hpp"
#include "utils/defs.hpp"
#include "utils/gf_supp.hpp"
#include "utils/nda_supp.hpp"
#include "utils/range_supp.hpp"
#include <fmt/ranges.h>

Go to the source code of this file.

Classes
class	triqs::modest::embedding
	The embedding class. More...

Namespaces
namespace	triqs
namespace	triqs::modest

Macros
#define	INSTANTIATE(Mesh)

Typedefs
using	triqs::block2_matrix_t = nda::array< nda::matrix< dcomplex >, 2 >
using	triqs::block_matrix_t = std::vector< nda::matrix< dcomplex > >

Functions
	triqs::modest::INSTANTIATE (dlr_imfreq)
	triqs::modest::INSTANTIATE (imfreq)
	triqs::modest::INSTANTIATE (refreq)
template<typename Mesh >
std::vector< gf< Mesh, matrix_valued > >	triqs::modest::rotate_embedded_self_energy (block2_gf< Mesh, matrix_valued > const &Sigma_embed_dynamic_loc, nda::matrix< dcomplex > const &U)
	Rotate the dynamic part of the embedded self-energy from the local (solver) basis to the orbital basis.
template<typename Mesh >
std::vector< gf< Mesh, matrix_valued > >	triqs::modest::rotate_embedded_self_energy (block2_gf< Mesh, matrix_valued > const &Sigma_embed_dynamic_loc, one_body_elements_on_grid const &obe)
	Rotate the dynamic part of the embedded self-energy from the local (solver) basis to the orbital basis.
std::vector< nda::array< dcomplex, 3 > >	triqs::modest::rotate_embedded_self_energy (std::vector< nda::array< dcomplex, 3 > > const &Sigma_embed_dynamic_loc, nda::matrix< dcomplex > const &U)
	Rotate the dynamic part of the embedded self-energy from the local (solver) basis to the orbital basis.
std::vector< nda::array< dcomplex, 3 > >	triqs::modest::rotate_embedded_self_energy (std::vector< nda::array< dcomplex, 3 > > const &Sigma_embed_dynamic_loc, one_body_elements_on_grid const &obe)
	Rotate the dynamic part of the embedded self-energy from the local (solver) basis to the orbital basis.
std::vector< nda::matrix< dcomplex > >	triqs::modest::rotate_embedded_self_energy (std::vector< nda::matrix< dcomplex > > const &Sigma_embed_static_loc, nda::matrix< dcomplex > const &U)
	Rotate the static part of the embedded self-energy from the local (solver) basis to the orbital basis.
std::vector< nda::matrix< dcomplex > >	triqs::modest::rotate_embedded_self_energy (std::vector< nda::matrix< dcomplex > > const &Sigma_embed_static_loc, one_body_elements_on_grid const &obe)
	Rotate the static part of the embedded self-energy from the local (solver) basis to the orbital basis.
Embedding factories functions
Factory functions to create the embedding class for different embedding scenarios. Typically, one will create the embedding from the local space.
embedding	triqs::modest::embedding_builder (std::vector< std::string > const &spin_names, std::vector< std::vector< long > > const &block_decomposition, std::vector< long > const &atom_to_imp)
	Construct the embedding class from the local space, a description of the block decomposition, and an equivalence mapping between atom sites.
embedding	triqs::modest::make_embedding (local_space const &C_space, bool use_atom_equivalences=true, bool use_atom_decomp=false)
	Make an embedding from the local space.
std::pair< one_body_elements_on_grid, embedding >	triqs::modest::make_embedding_with_clusters (one_body_elements_on_grid obe, std::vector< std::vector< long > > const &atom_partition)
	Make an embedding for clusters of atoms.

Macro Definition Documentation

INSTANTIATE

#define INSTANTIATE

(

Mesh

)

Value:

  template block2_gf<Mesh, matrix_valued> embedding::embed(std::vector<block_gf<Mesh, matrix_valued>> const &) const;                                \
  template std::pair<block2_gf<Mesh, matrix_valued>, block2_matrix_t> embedding::embed(std::vector<block_gf<Mesh, matrix_valued>> const &,           \
                                                                                       std::vector<block_matrix_t> const &) const;                   \
  template std::vector<block_gf<Mesh, matrix_valued>> embedding::extract(block2_gf<Mesh, matrix_valued> const &) const;                              \
  template std::vector<std::pair<block_gf<Mesh, matrix_valued>, block_matrix_t>> embedding::make_zero_imp_self_energies(Mesh const &);               \
  template std::vector<gf<Mesh, matrix_valued>> rotate_embedded_self_energy(block2_gf<Mesh, matrix_valued> const &, nda::matrix<dcomplex> const &);  \
  template std::vector<gf<Mesh, matrix_valued>> rotate_embedded_self_energy(block2_gf<Mesh, matrix_valued> const &,                                  \
                                                                            one_body_elements_on_grid const &);

Definition at line 550 of file embedding.hpp.