LCPQ/dft_tools
3
0
Fork 0
mirror of https://github.com/triqs/dft_tools synced 2024-12-25 05:43:40 +01:00
Code Issues Releases Wiki Activity

implement gf_const_view

Browse Source
This commit is contained in:
Olivier Parcollet 2013-10-18 13:39:00 +02:00
parent 445f7d42e1
commit 9edda8724d
15 changed files with 345 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/triqs/gfs/gf_scalar.cpp
View File

@ -15,7 +15,7 @@ int main() {
// test hdf5 // test hdf5
H5::H5File file("gf_scalar.h5", H5F_ACC_TRUNC); H5::H5File file("gf_scalar.h5", H5F_ACC_TRUNC);
h5_write(file, "g", G); h5_write(file, "g", G);
h5_write(file, "gm", reinterpret_scalar_valued_gf_as_matrix_valued(G())); h5_write(file, "gm", reinterpret_scalar_valued_gf_as_matrix_valued(G));
} }
TRIQS_CATCH_AND_ABORT; TRIQS_CATCH_AND_ABORT;

72
triqs/gfs/block.hpp
View File

@ -43,20 +43,23 @@ namespace triqs { namespace gfs {
template<typename Target, typename Opt> struct h5_name<block_index,Target,Opt> { static std::string invoke(){ return "BlockGf";}}; template<typename Target, typename Opt> struct h5_name<block_index,Target,Opt> { static std::string invoke(){ return "BlockGf";}};
template <typename Target, typename Opt, bool IsView> struct h5_rw<block_index,Target,Opt,IsView> { template <typename Target, typename Opt> struct h5_rw<block_index,Target,Opt> {
static void write (h5::group gr, gf_impl<block_index,Target,Opt,IsView> const & g) { static void write (h5::group gr, gf_const_view<block_index,Target,Opt> g) {
for (size_t i =0; i<g.mesh().size(); ++i) h5_write(gr,g.mesh().domain().names()[i],g._data[i]); for (size_t i =0; i<g.mesh().size(); ++i) h5_write(gr,g.mesh().domain().names()[i],g._data[i]);
//h5_write(gr,"symmetry",g._symmetry); //h5_write(gr,"symmetry",g._symmetry);
} }
static void read (h5::group gr, gf_impl<block_index,Target,Opt,IsView> & g) { template<bool IsView>
static void read (h5::group gr, gf_impl<block_index,Target,Opt,IsView,false> &g) {
// does not work : need to read the block name and remake the mesh... // does not work : need to read the block name and remake the mesh...
g._mesh = gf_mesh<block_index,Opt> (gr.get_all_subgroup_names()); g._mesh = gf_mesh<block_index,Opt> (gr.get_all_subgroup_names());
g._data.resize(g._mesh.size()); g._data.resize(g._mesh.size());
//if (g._data.size() != g._mesh.size()) TRIQS_RUNTIME_ERROR << "h5 read block gf : number of block mismatch";
for (size_t i =0; i<g.mesh().size(); ++i) h5_read(gr,g.mesh().domain().names()[i],g._data[i]); for (size_t i =0; i<g.mesh().size(); ++i) h5_read(gr,g.mesh().domain().names()[i],g._data[i]);
//h5_read(gr,"symmetry",g._symmetry); //h5_read(gr,"symmetry",g._symmetry);
} }
}; };
/// --------------------------- data access --------------------------------- /// --------------------------- data access ---------------------------------
@ -78,19 +81,17 @@ namespace triqs { namespace gfs {
} // gfs_implementation } // gfs_implementation
// ------------------------------- Free Factories for regular type -------------------------------------------------- // ------------------------------- aliases --------------------------------------------------
template<typename G0, typename ... G> template<typename ... T> using block_gf = gf<block_index, gf<T...>>;
gf_view<block_index, typename std::remove_reference<G0>::type::view_type> make_block_gf_view(G0 && g0, G && ... g) { template<typename ... T> using block_gf_view = gf_view<block_index, gf<T...>>;
auto V = std::vector<typename std::remove_reference<G0>::type::view_type>{std::forward<G0>(g0), std::forward<G>(g)...}; template<typename ... T> using block_gf_const_view = gf_const_view<block_index, gf<T...>>;
return { {int(V.size())}, std::move(V), nothing{}, nothing{} } ;
//return { gf_mesh<block_index, Opt> {int(V.size())}, std::move(V), nothing{}, nothing{} } ; // ------------------------------- Free Factories for regular type --------------------------------------------------
}
// from a number and a gf to be copied // from a number and a gf to be copied
template <typename Variable, typename Target, typename Opt> template <typename Variable, typename Target, typename Opt>
gf<block_index,gf<Variable,Target,Opt>> block_gf<Variable, Target, Opt> make_block_gf(int n, gf<Variable, Target, Opt> const & g) {
make_block_gf(int n, gf<Variable,Target,Opt> g) {
auto V = std::vector<gf<Variable, Target, Opt>>{}; auto V = std::vector<gf<Variable, Target, Opt>>{};
for (int i = 0; i < n; ++i) V.push_back(g); for (int i = 0; i < n; ++i) V.push_back(g);
return {{n}, std::move(V), nothing{}, nothing{}}; return {{n}, std::move(V), nothing{}, nothing{}};
@ -98,15 +99,13 @@ namespace triqs { namespace gfs {
// from a vector of gf (moving directly) // from a vector of gf (moving directly)
template <typename Variable, typename Target, typename Opt, typename GF2> template <typename Variable, typename Target, typename Opt, typename GF2>
gf<block_index,gf<Variable,Target,Opt>> block_gf<Variable, Target, Opt> make_block_gf(std::vector<gf<Variable, Target, Opt>> &&V) {
make_block_gf(std::vector<gf<Variable,Target,Opt>> && V) {
return {{int(V.size())}, std::move(V), nothing{}, nothing{}}; return {{int(V.size())}, std::move(V), nothing{}, nothing{}};
} }
// from a vector of gf : generalized to have a different type of gf in the vector (e.g. views...) // from a vector of gf : generalized to have a different type of gf in the vector (e.g. views...)
template <typename Variable, typename Target, typename Opt, typename GF2> template <typename Variable, typename Target, typename Opt, typename GF2>
gf<block_index,gf<Variable,Target,Opt>> block_gf<Variable, Target, Opt> make_block_gf(std::vector<GF2> const &V) {
make_block_gf(std::vector<GF2> const & V) {
auto V2 = std::vector<gf<Variable, Target, Opt>>{}; auto V2 = std::vector<gf<Variable, Target, Opt>>{};
for (auto const &g : V) V2.push_back(g); for (auto const &g : V) V2.push_back(g);
return {{int(V.size())}, std::move(V2), nothing{}, nothing{}}; return {{int(V.size())}, std::move(V2), nothing{}, nothing{}};
@ -114,27 +113,44 @@ namespace triqs { namespace gfs {
// from a init list of GF with the correct type // from a init list of GF with the correct type
template <typename Variable, typename Target, typename Opt> template <typename Variable, typename Target, typename Opt>
gf<block_index,gf<Variable,Target,Opt>> block_gf<Variable, Target, Opt> make_block_gf(std::initializer_list<gf<Variable, Target, Opt>> const &V) {
make_block_gf(std::initializer_list<gf<Variable,Target,Opt>> const & V) { return { {int(V.size())}, V, nothing{}, nothing{}} ; } return {{int(V.size())}, V, nothing{}, nothing{}};
}
// 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> const &block_names, gf<Variable, Target, Opt> const &g) {
auto V = std::vector<gf<Variable, Target, Opt>>{};
for (int i = 0; i < block_names.size(); ++i) V.push_back(g);
return {{block_names}, std::move(V), nothing{}, nothing{}};
}
// from vector<string>, vector<gf> // from vector<string>, vector<gf>
template <typename Variable, typename Target, typename Opt> template <typename Variable, typename Target, typename Opt>
gf<block_index,gf<Variable,Target,Opt>> block_gf<Variable, Target, Opt> make_block_gf(std::vector<std::string> const &block_names,
make_block_gf(std::vector<std::string> const & block_names, std::vector<gf<Variable,Target,Opt>> V) { std::vector<gf<Variable, Target, Opt>> V) {
if (block_names.size()!=V.size()) TRIQS_RUNTIME_ERROR << "make_block_gf(vector<string>, vector<gf>) : the two vectors do not have the same size !"; if (block_names.size() != V.size())
TRIQS_RUNTIME_ERROR << "make_block_gf(vector<string>, vector<gf>) : the two vectors do not have the same size !";
return {{block_names}, std::move(V), nothing{}, nothing{}}; return {{block_names}, std::move(V), nothing{}, nothing{}};
} }
// from vector<string>, init_list<GF> // from vector<string>, init_list<GF>
template <typename Variable, typename Target, typename Opt> template <typename Variable, typename Target, typename Opt>
gf<block_index,gf<Variable,Target,Opt>> block_gf<Variable, Target, Opt> make_block_gf(std::vector<std::string> const &block_names,
make_block_gf(std::vector<std::string> const & block_names, std::initializer_list<gf<Variable,Target,Opt>> const & V) { std::initializer_list<gf<Variable, Target, Opt>> const &V) {
if (block_names.size() != V.size()) TRIQS_RUNTIME_ERROR << "make_block_gf(vector<string>, init_list) : size mismatch !"; if (block_names.size() != V.size()) TRIQS_RUNTIME_ERROR << "make_block_gf(vector<string>, init_list) : size mismatch !";
return {{block_names}, V, nothing{}, nothing{}}; return {{block_names}, V, nothing{}, nothing{}};
} }
// ------------------------------- Free Factories for view type -------------------------------------------------- // ------------------------------- Free Factories for view type --------------------------------------------------
template<typename G0, typename ... G>
gf_view<block_index, typename std::remove_reference<G0>::type::view_type> make_block_gf_view(G0 && g0, G && ... g) {
auto V = std::vector<typename std::remove_reference<G0>::type::view_type>{std::forward<G0>(g0), std::forward<G>(g)...};
return { {int(V.size())}, std::move(V), nothing{}, nothing{} } ;
//return { gf_mesh<block_index, Opt> {int(V.size())}, std::move(V), nothing{}, nothing{} } ;
}
template<typename GF, typename GF2> template<typename GF, typename GF2>
gf_view<block_index,GF> gf_view<block_index,GF>
make_block_gf_view_from_vector (std::vector<GF2> V) { return { {int(V.size())}, std::move(V), nothing{}, nothing{}} ; } make_block_gf_view_from_vector (std::vector<GF2> V) { return { {int(V.size())}, std::move(V), nothing{}, nothing{}} ; }
@ -145,8 +161,6 @@ namespace triqs { namespace gfs {
template<typename T> size_t n_blocks (gf<block_index,T> const & g) { return g.mesh().size();} template<typename T> size_t n_blocks (gf<block_index,T> const & g) { return g.mesh().size();}
template<typename T> size_t n_blocks (gf_view<block_index,T> const & g) { return g.mesh().size();} template<typename T> size_t n_blocks (gf_view<block_index,T> const & g) { return g.mesh().size();}
template<typename T> using block_gf = gf<block_index, gf<T>>;
// an iterator over the block // an iterator over the block
template<typename Target, typename Opt> template<typename Target, typename Opt>
class block_gf_iterator : class block_gf_iterator :
@ -165,11 +179,11 @@ namespace triqs { namespace gfs {
bool at_end() const { return mesh_it.at_end();} bool at_end() const { return mesh_it.at_end();}
}; };
template<typename Target, typename Opt, bool B> template<typename Target, typename Opt, bool B, bool C>
block_gf_iterator<Target,Opt> begin(gf_impl<block_index,Target,Opt,B> const & bgf) { return {bgf,false};} block_gf_iterator<Target,Opt> begin(gf_impl<block_index,Target,Opt,B,C> const & bgf) { return {bgf,false};}
template<typename Target, typename Opt, bool B> template<typename Target, typename Opt, bool B, bool C>
block_gf_iterator<Target,Opt> end(gf_impl<block_index,Target,Opt,B> const & bgf) { return {bgf,true};} block_gf_iterator<Target,Opt> end(gf_impl<block_index,Target,Opt,B,C> const & bgf) { return {bgf,true};}
}} }}
#endif #endif

23
triqs/gfs/curry.hpp
View File

@ -49,9 +49,9 @@ namespace triqs { namespace gfs {
template<typename M0, typename M1, typename ...M> auto rm_tuple_of_size_one(std::tuple<M0,M1,M...> const & t) DECL_AND_RETURN(t); template<typename M0, typename M1, typename ...M> auto rm_tuple_of_size_one(std::tuple<M0,M1,M...> const & t) DECL_AND_RETURN(t);
template<typename M> auto rm_tuple_of_size_one(std::tuple<M> const & t) DECL_AND_RETURN(std::get<0>(t)); template<typename M> auto rm_tuple_of_size_one(std::tuple<M> const & t) DECL_AND_RETURN(std::get<0>(t));
template<int ... pos, typename Opt, typename Target, bool B, typename IT, typename ... Ms> template<int ... pos, typename Opt, typename Target, bool B, bool IsConst, typename IT, typename ... Ms>
gf_view< typename cart_prod_impl< triqs::tuple::filter_out_t<std::tuple<Ms...>, pos...>>::type ,Target, Opt> gf_view< typename cart_prod_impl< triqs::tuple::filter_out_t<std::tuple<Ms...>, pos...>>::type ,Target, Opt,IsConst>
partial_eval(gf_impl< cartesian_product<Ms...>, Target,Opt,B> const & g, IT index) { partial_eval(gf_impl< cartesian_product<Ms...>, Target,Opt,B,IsConst> const & g, IT index) {
// meshes of the returned gf_view : just drop the mesh of the evaluated variables // meshes of the returned gf_view : just drop the mesh of the evaluated variables
auto meshes_tuple_partial = triqs::tuple::filter_out<pos...>(g.mesh().components()); auto meshes_tuple_partial = triqs::tuple::filter_out<pos...>(g.mesh().components());
// a view of the array of g, with the dimension sizeof...(Ms) // a view of the array of g, with the dimension sizeof...(Ms)
@ -61,7 +61,7 @@ namespace triqs { namespace gfs {
// from it, we make a slice of the array of g, corresponding to the data of the returned gf_view // from it, we make a slice of the array of g, corresponding to the data of the returned gf_view
auto arr2 = triqs::tuple::apply(arr, arr_args); auto arr2 = triqs::tuple::apply(arr, arr_args);
// finally, we build the view on this data. // finally, we build the view on this data.
using r_t = gf_view< cart_prod< triqs::tuple::filter_out_t<std::tuple<Ms...>, pos...>> ,Target, Opt>; using r_t = gf_view< cart_prod< triqs::tuple::filter_out_t<std::tuple<Ms...>, pos...>> ,Target, Opt,IsConst>;
return r_t{ rm_tuple_of_size_one(meshes_tuple_partial), arr2, typename r_t::singularity_non_view_t{}, typename r_t::symmetry_t{} }; return r_t{ rm_tuple_of_size_one(meshes_tuple_partial), arr2, typename r_t::singularity_non_view_t{}, typename r_t::symmetry_t{} };
} }
@ -78,19 +78,24 @@ namespace triqs { namespace gfs {
}; };
// curry function ... // curry function ...
template<int ... pos, typename Target, typename Opt, bool B, typename ... Ms> template <int... pos, typename Target, typename Opt, bool IsConst, typename... Ms>
gf_view<cart_prod<triqs::tuple::filter_t<std::tuple<Ms...>, pos...>>, gf_view<cart_prod<triqs::tuple::filter_t<std::tuple<Ms...>, pos...>>,
lambda_valued<curry_polymorphic_lambda<gf_view<cartesian_product<Ms...>, Target,Opt>,pos...>>, lambda_valued<curry_polymorphic_lambda<gf_view<cartesian_product<Ms...>, Target, Opt,IsConst>, pos...>>, Opt, IsConst>
Opt> curry(gf_view<cartesian_product<Ms...>, Target, Opt, IsConst> g) {
curry (gf_impl<cartesian_product<Ms...>, Target,Opt,B> const & g) {
// pick up the meshed corresponding to the curryed variables // pick up the meshed corresponding to the curryed variables
auto meshes_tuple = triqs::tuple::filter<pos...>(g.mesh().components()); auto meshes_tuple = triqs::tuple::filter<pos...>(g.mesh().components());
// building the view // building the view
return {rm_tuple_of_size_one(meshes_tuple),curry_polymorphic_lambda<gf_view<cartesian_product<Ms...>, Target,Opt>, pos ...>{g}, nothing(), nothing()}; return {rm_tuple_of_size_one(meshes_tuple),curry_polymorphic_lambda<gf_view<cartesian_product<Ms...>, Target,Opt,IsConst>, pos ...>{g}, nothing(), nothing()};
//using m_t = gf_mesh< cart_prod< triqs::tuple::filter_t<std::tuple<Ms...>,pos...>>>; //using m_t = gf_mesh< cart_prod< triqs::tuple::filter_t<std::tuple<Ms...>,pos...>>>;
//return {triqs::tuple::apply_construct<m_t>(meshes_tuple),curry_polymorphic_lambda<gf_view<cartesian_product<Ms...>, Target,Opt>, pos ...>{g}, nothing(), nothing()}; //return {triqs::tuple::apply_construct<m_t>(meshes_tuple),curry_polymorphic_lambda<gf_view<cartesian_product<Ms...>, Target,Opt>, pos ...>{g}, nothing(), nothing()};
}; };
template <int... pos, typename Target, typename Opt, typename... Ms>
auto curry(gf<cartesian_product<Ms...>, Target, Opt> & g) DECL_AND_RETURN(curry<pos...>(g()));
template <int... pos, typename Target, typename Opt, typename... Ms>
auto curry(gf<cartesian_product<Ms...>, Target, Opt> const & g) DECL_AND_RETURN(curry<pos...>(g()));
} // gf_implementation } // gf_implementation
using gfs_implementation::partial_eval; using gfs_implementation::partial_eval;
using gfs_implementation::curry; using gfs_implementation::curry;

47
triqs/gfs/data_proxies.hpp
View File

@ -34,22 +34,27 @@ namespace triqs { namespace gfs {
/// The storage /// The storage
typedef arrays::array<T, R> storage_t; typedef arrays::array<T, R> storage_t;
typedef typename storage_t::view_type storage_view_t; typedef typename storage_t::view_type storage_view_t;
typedef typename storage_t::const_view_type storage_const_view_t;
/// The data access /// The data access
auto operator()(storage_t& data, long i) const DECL_AND_RETURN(arrays::make_tensor_proxy(data, i)); auto operator()(storage_t& data, long i) const DECL_AND_RETURN(arrays::make_tensor_proxy(data, i));
auto operator()(storage_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_tensor_proxy(data, i)); auto operator()(storage_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_tensor_proxy(data, i));
auto operator()(storage_view_t& data, long i) const DECL_AND_RETURN(arrays::make_tensor_proxy(data, i)); auto operator()(storage_view_t& data, long i) const DECL_AND_RETURN(arrays::make_tensor_proxy(data, i));
auto operator()(storage_view_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_tensor_proxy(data, i)); auto operator()(storage_view_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_tensor_proxy(data, i));
auto operator()(storage_const_view_t& data, long i) const DECL_AND_RETURN(arrays::make_const_tensor_proxy(data, i));
auto operator()(storage_const_view_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_tensor_proxy(data, i));
#ifdef TRIQS_GF_DATA_PROXIES_WITH_SIMPLE_VIEWS #ifdef TRIQS_GF_DATA_PROXIES_WITH_SIMPLE_VIEWS
auto operator()(storage_t & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis())); auto operator()(storage_t & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
auto operator()(storage_t const & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis())); auto operator()(storage_t const & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
auto operator()(storage_view_t & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis())); auto operator()(storage_view_t & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
auto operator()(storage_view_t const & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis())); auto operator()(storage_view_t const & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
auto operator()(storage_const_view_t & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
auto operator()(storage_const_view_t const & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
#endif #endif
template<typename S, typename RHS> static void assign_to_scalar (S & data, RHS && rhs) { data() = std::forward<RHS>(rhs);} template<typename S, typename RHS> static void assign_to_scalar (S & data, RHS && rhs) { data() = std::forward<RHS>(rhs);}
template<typename RHS> static void rebind (storage_view_t & data, RHS && rhs) { data.rebind(rhs.data()); } template <typename ST, typename RHS> static void rebind(ST& data, RHS&& rhs) { data.rebind(rhs.data()); }
}; };
//---------------------------- 3d array : returns matrices in this case ! ---------------------------------- //---------------------------- 3d array : returns matrices in this case ! ----------------------------------
@ -58,12 +63,15 @@ namespace triqs { namespace gfs {
/// The storage /// The storage
typedef arrays::array<T,3> storage_t; typedef arrays::array<T,3> storage_t;
typedef typename storage_t::view_type storage_view_t; typedef typename storage_t::view_type storage_view_t;
typedef typename storage_t::const_view_type storage_const_view_t;
/// The data access /// The data access
auto operator()(storage_t& data, long i) const DECL_AND_RETURN(arrays::make_matrix_proxy(data, i)); auto operator()(storage_t& data, long i) const DECL_AND_RETURN(arrays::make_matrix_proxy(data, i));
auto operator()(storage_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_matrix_proxy(data, i)); auto operator()(storage_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_matrix_proxy(data, i));
auto operator()(storage_view_t& data, long i) const DECL_AND_RETURN(arrays::make_matrix_proxy(data, i)); auto operator()(storage_view_t& data, long i) const DECL_AND_RETURN(arrays::make_matrix_proxy(data, i));
auto operator()(storage_view_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_matrix_proxy(data, i)); auto operator()(storage_view_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_matrix_proxy(data, i));
auto operator()(storage_const_view_t& data, long i) const DECL_AND_RETURN(arrays::make_const_matrix_proxy(data, i));
auto operator()(storage_const_view_t const& data, long i) const DECL_AND_RETURN(arrays::make_const_matrix_proxy(data, i));
#ifdef TRIQS_DATA_PROXIES_OLD_MATRIX_VIEW_PROXY #ifdef TRIQS_DATA_PROXIES_OLD_MATRIX_VIEW_PROXY
arrays::matrix_view_proxy<storage_t,0> operator()(storage_t & data, size_t i) const { return arrays::matrix_view_proxy<storage_t,0>(data,i); } arrays::matrix_view_proxy<storage_t,0> operator()(storage_t & data, size_t i) const { return arrays::matrix_view_proxy<storage_t,0>(data,i); }
@ -78,10 +86,13 @@ namespace triqs { namespace gfs {
auto operator()(storage_view_t & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis())); auto operator()(storage_view_t & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
auto operator()(storage_view_t const & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis())); auto operator()(storage_view_t const & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
auto operator()(storage_const_view_t & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
auto operator()(storage_const_view_t const & data, size_t i) const DECL_AND_RETURN(data(i,arrays::ellipsis()));
#endif #endif
template <typename S, typename RHS> static void assign_to_scalar(S& data, RHS&& rhs) { data() = std::forward<RHS>(rhs); } template <typename S, typename RHS> static void assign_to_scalar(S& data, RHS&& rhs) { data() = std::forward<RHS>(rhs); }
template<typename RHS> static void rebind (storage_view_t & data, RHS && rhs) { data.rebind(rhs.data()); } template <typename ST, typename RHS> static void rebind(ST& data, RHS&& rhs) { data.rebind(rhs.data()); }
}; };
//---------------------------- 1d array ---------------------------------- //---------------------------- 1d array ----------------------------------
@ -90,34 +101,57 @@ namespace triqs { namespace gfs {
/// The storage /// The storage
typedef arrays::array<T,1> storage_t; typedef arrays::array<T,1> storage_t;
typedef typename storage_t::view_type storage_view_t; typedef typename storage_t::view_type storage_view_t;
typedef typename storage_t::const_view_type storage_const_view_t;
/// The data access /// The data access
auto operator()(storage_t & data,size_t i) const -> decltype(data(i)) { return data(i);} auto operator()(storage_t & data,size_t i) const -> decltype(data(i)) { return data(i);}
auto operator()(storage_t const & data,size_t i) const -> decltype(data(i)) { return data(i);} auto operator()(storage_t const & data,size_t i) const -> decltype(data(i)) { return data(i);}
auto operator()(storage_view_t & data,size_t i) const -> decltype(data(i)) { return data(i);} auto operator()(storage_view_t & data,size_t i) const -> decltype(data(i)) { return data(i);}
auto operator()(storage_view_t const & data,size_t i) const -> decltype(data(i)) { return data(i);} auto operator()(storage_view_t const & data,size_t i) const -> decltype(data(i)) { return data(i);}
auto operator()(storage_const_view_t & data,size_t i) const -> decltype(data(i)) { return data(i);}
auto operator()(storage_const_view_t const & data,size_t i) const -> decltype(data(i)) { return data(i);}
template<typename S, typename RHS> static void assign_to_scalar (S & data, RHS && rhs) { data() = std::forward<RHS>(rhs);} template<typename S, typename RHS> static void assign_to_scalar (S & data, RHS && rhs) { data() = std::forward<RHS>(rhs);}
template<typename RHS> static void rebind (storage_view_t & data, RHS && rhs) { data.rebind(rhs.data()); } template <typename ST, typename RHS> static void rebind(ST& data, RHS&& rhs) { data.rebind(rhs.data()); }
}; };
//---------------------------- vector ---------------------------------- //---------------------------- vector ----------------------------------
template<typename V> struct view_proxy : public V {
view_proxy() : V(typename V::regular_type()) {}
view_proxy(V const &v) : V(v){};
view_proxy(view_proxy const & p) : V(p) {};
template<typename ... Args> explicit view_proxy(Args && ... args) : V (std::forward<Args>(args)...){}
view_proxy & operator = ( view_proxy const & cp ) { this->rebind(cp); return *this;}
view_proxy & operator = ( V const & v ) { this->rebind(v); return *this;}
using V::operator=;
//template<typename X> view_proxy & operator = (X && x) { V::operator=( std::forward<X>(x) ); return *this;}
};
template<typename T> struct data_proxy_vector { template<typename T> struct data_proxy_vector {
typedef typename T::view_type Tv; typedef typename T::view_type Tv;
typedef typename T::const_view_type Tcv;
/// The storage /// The storage
typedef std::vector<T> storage_t; typedef std::vector<T> storage_t;
typedef std::vector<Tv> storage_view_t; typedef std::vector<view_proxy<Tv>> storage_view_t;
typedef std::vector<view_proxy<Tcv>> storage_const_view_t;
/// The data access /// The data access
T & operator()(storage_t & data, size_t i) { return data[i];} T & operator()(storage_t & data, size_t i) { return data[i];}
T const & operator()(storage_t const & data, size_t i) const { return data[i];} T const & operator()(storage_t const & data, size_t i) const { return data[i];}
Tv & operator()(storage_view_t & data, size_t i) { return data[i];} Tv & operator()(storage_view_t & data, size_t i) { return data[i];}
Tv const & operator()(storage_view_t const & data, size_t i) const { return data[i];} Tv const & operator()(storage_view_t const & data, size_t i) const { return data[i];}
Tcv & operator()(storage_const_view_t & data, size_t i) { return data[i];}
Tcv const & operator()(storage_const_view_t const & data, size_t i) const { return data[i];}
/*Tv operator()(storage_view_t & data, size_t i) const { return data[i];}
Tv operator()(storage_view_t const & data, size_t i) const { return data[i];}
Tcv operator()(storage_const_view_t & data, size_t i) const { return data[i];}
Tcv operator()(storage_const_view_t const & data, size_t i) const { return data[i];}
*/
template<typename S, typename RHS> static void assign_to_scalar (S & data, RHS && rhs) {for (size_t i =0; i<data.size(); ++i) data[i] = rhs;} template<typename S, typename RHS> static void assign_to_scalar (S & data, RHS && rhs) {for (size_t i =0; i<data.size(); ++i) data[i] = rhs;}
template<typename RHS> static void rebind (storage_view_t & data, RHS && rhs) { data.clear(); for (auto & x : rhs.data()) data.push_back(x);} template <typename ST, typename RHS> static void rebind(ST& data, RHS&& rhs) { data.clear(); for (auto & x : rhs.data()) data.push_back(x);}
}; };
//---------------------------- lambda ---------------------------------- //---------------------------- lambda ----------------------------------
@ -127,13 +161,14 @@ namespace triqs { namespace gfs {
/// The storage /// The storage
typedef F storage_t; typedef F storage_t;
typedef F storage_view_t; typedef F storage_view_t;
typedef F storage_const_view_t;
/// The data access /// The data access
auto operator()(storage_t & data, size_t i) DECL_AND_RETURN( data(i)); auto operator()(storage_t & data, size_t i) DECL_AND_RETURN( data(i));
auto operator()(storage_t const & data, size_t i) const DECL_AND_RETURN( data(i)); auto operator()(storage_t const & data, size_t i) const DECL_AND_RETURN( data(i));
template<typename S, typename RHS> static void assign_to_scalar (S & data, RHS && rhs) = delete; template<typename S, typename RHS> static void assign_to_scalar (S & data, RHS && rhs) = delete;
template<typename RHS> static void rebind (storage_view_t & data, RHS && rhs) = delete;// { data = std::forward<RHS>(rhs);} template <typename ST, typename RHS> static void rebind(ST& data, RHS&& rhs) = delete;
}; };

173
triqs/gfs/gf.hpp
View File

@ -35,10 +35,21 @@ namespace triqs { namespace gfs {
template <typename T> long get_shape(std::vector<T> const &x) { return x.size(); } template <typename T> long get_shape(std::vector<T> const &x) { return x.size(); }
// the gf mesh
template <typename Variable, typename Opt = void> struct gf_mesh; template <typename Variable, typename Opt = void> struct gf_mesh;
template<typename Variable, typename Target=matrix_valued, typename Opt=void> class gf; // the regular type
template<typename Variable, typename Target=matrix_valued, typename Opt=void> class gf_view; // the view type // The regular type
template<typename Variable, typename Target, typename Opt, bool IsView> class gf_impl; template <typename Variable, typename Target = matrix_valued, typename Opt = void> class gf;
// The view type
template <typename Variable, typename Target = matrix_valued, typename Opt = void, bool IsConst = false> class gf_view;
// The const view type
template <typename Variable, typename Target = matrix_valued, typename Opt = void>
using gf_const_view = gf_view<Variable, Target, Opt, true>;
// the implementation class
template<typename Variable, typename Target, typename Opt, bool IsView, bool IsConst> class gf_impl;
// various implementation traits // various implementation traits
namespace gfs_implementation { // never use using of this... namespace gfs_implementation { // never use using of this...
@ -65,16 +76,17 @@ namespace triqs { namespace gfs {
template<typename Variable, typename Opt> struct h5_name<Variable,scalar_valued,Opt> { static std::string invoke(){ return h5_name<Variable,matrix_valued,Opt>::invoke() + "_s";}}; template<typename Variable, typename Opt> struct h5_name<Variable,scalar_valued,Opt> { static std::string invoke(){ return h5_name<Variable,matrix_valued,Opt>::invoke() + "_s";}};
// the h5 write and read of gf members, so that we can specialize it e.g. for block gf // the h5 write and read of gf members, so that we can specialize it e.g. for block gf
template <typename Variable, typename Target, typename Opt, bool IsView> struct h5_rw { template <typename Variable, typename Target, typename Opt> struct h5_rw {
static void write (h5::group gr, gf_impl<Variable,Target,Opt,IsView> const & g) { static void write (h5::group gr, gf_const_view<Variable,Target,Opt> g) {
h5_write(gr,"data",g._data); h5_write(gr,"data",g._data);
h5_write(gr,"singularity",g._singularity); h5_write(gr,"singularity",g._singularity);
h5_write(gr,"mesh",g._mesh); h5_write(gr,"mesh",g._mesh);
h5_write(gr,"symmetry",g._symmetry); h5_write(gr,"symmetry",g._symmetry);
} }
static void read (h5::group gr, gf_impl<Variable,Target,Opt,IsView> & g) { template<bool B>
static void read (h5::group gr, gf_impl<Variable,Target,Opt,B,false> & g) {
h5_read(gr,"data",g._data); h5_read(gr,"data",g._data);
h5_read(gr,"singularity",g._singularity); h5_read(gr,"singularity",g._singularity);
h5_read(gr,"mesh",g._mesh); h5_read(gr,"mesh",g._mesh);
@ -149,10 +161,13 @@ namespace triqs { namespace gfs {
// ---------------------- implementation -------------------------------- // ---------------------- implementation --------------------------------
/// A common implementation class for gf and gf_view. They will only redefine contructor and = ... /// A common implementation class for gf and gf_view. They will only redefine contructor and = ...
template<typename Variable, typename Target, typename Opt, bool IsView> class gf_impl : template<typename Variable, typename Target, typename Opt, bool IsView, bool IsConst> class gf_impl :
TRIQS_CONCEPT_TAG_NAME(ImmutableGreenFunction){ TRIQS_CONCEPT_TAG_NAME(ImmutableGreenFunction){
static_assert(!( !IsView && IsConst), "Internal error");
public : public :
typedef gf_view<Variable,Target,Opt> view_type; typedef gf_view<Variable,Target,Opt> mutable_view_type;
typedef gf_const_view<Variable,Target,Opt> const_view_type;
typedef typename std::conditional <IsConst, const_view_type, mutable_view_type>::type view_type;
typedef gf<Variable,Target,Opt> regular_type; typedef gf<Variable,Target,Opt> regular_type;
typedef Variable variable_t; typedef Variable variable_t;
@ -169,7 +184,9 @@ namespace triqs { namespace gfs {
typedef gfs_implementation::data_proxy<Variable,Target,Opt> data_proxy_t; typedef gfs_implementation::data_proxy<Variable,Target,Opt> data_proxy_t;
typedef typename data_proxy_t::storage_t data_regular_t; typedef typename data_proxy_t::storage_t data_regular_t;
typedef typename data_proxy_t::storage_view_t data_view_t; typedef typename data_proxy_t::storage_view_t data_view_t;
typedef typename std::conditional<IsView, data_view_t, data_regular_t>::type data_t; typedef typename data_proxy_t::storage_const_view_t data_const_view_t;
typedef typename std::conditional<IsView, typename std::conditional<IsConst, data_const_view_t, data_view_t>::type,
data_regular_t>::type data_t;
typedef typename gfs_implementation::singularity<Variable,Target,Opt>::type singularity_non_view_t; typedef typename gfs_implementation::singularity<Variable,Target,Opt>::type singularity_non_view_t;
typedef typename view_type_if_exists_else_type<singularity_non_view_t>::type singularity_view_t; typedef typename view_type_if_exists_else_type<singularity_non_view_t>::type singularity_view_t;
@ -207,7 +224,8 @@ namespace triqs { namespace gfs {
protected: protected:
gf_impl(gf_impl<Variable,Target,Opt,!IsView> const & x): _mesh(x.mesh()), _data(factory<data_t>(x.data())), template<typename G>
gf_impl(G && x, bool): _mesh(x.mesh()), _data(factory<data_t>(x.data())),
_singularity(factory<singularity_t>(x.singularity())), _symmetry(x.symmetry()), _evaluator(x.get_evaluator()){} _singularity(factory<singularity_t>(x.singularity())), _symmetry(x.symmetry()), _evaluator(x.get_evaluator()){}
template<typename M, typename D, typename S, typename SY, typename EV> template<typename M, typename D, typename S, typename SY, typename EV>
@ -225,7 +243,8 @@ namespace triqs { namespace gfs {
// ------------- All the call operators ----------------------------- // ------------- All the call operators -----------------------------
// First, a simple () returns a view, like for an array... // First, a simple () returns a view, like for an array...
view_type operator()() const { return *this;} const_view_type operator()() const { return *this;}
view_type operator()() { return *this; }
/// Calls are (perfectly) forwarded to the evaluator::operator(), except mesh_point_t and when /// Calls are (perfectly) forwarded to the evaluator::operator(), except mesh_point_t and when
/// there is at least one lazy argument ... /// there is at least one lazy argument ...
@ -241,7 +260,6 @@ namespace triqs { namespace gfs {
>::type // end of add_Const >::type // end of add_Const
operator() (Arg0&& arg0, Args&&... args) const { return _evaluator(this,std::forward<Arg0>( arg0), std::forward<Args>(args)...); } operator() (Arg0&& arg0, Args&&... args) const { return _evaluator(this,std::forward<Arg0>( arg0), std::forward<Args>(args)...); }
// WHY SEPARATE ARg0 ?
template<typename Arg0, typename ...Args> template<typename Arg0, typename ...Args>
typename clef::_result_of::make_expr_call<gf_impl &,Arg0, Args...>::type typename clef::_result_of::make_expr_call<gf_impl &,Arg0, Args...>::type
operator()(Arg0 &&arg0, Args&&... args) & { operator()(Arg0 &&arg0, Args&&... args) & {
@ -260,20 +278,6 @@ namespace triqs { namespace gfs {
return clef::make_expr_call(std::move(*this),std::forward<Arg0>(arg0), std::forward<Args>(args)...); return clef::make_expr_call(std::move(*this),std::forward<Arg0>(arg0), std::forward<Args>(args)...);
} }
/*
// on mesh component for composite meshes
// enable iif the first arg is a mesh_point_t for the first component of the mesh_t
template<typename Arg0, typename ... Args, bool MeshIsComposite = std::is_base_of<tag::composite, mesh_t>::value >
typename std::enable_if< MeshIsComposite && std::is_base_of< tag::mesh_point, Arg0>::value, r_type>::type
operator() (Arg0 const & arg0, Args const & ... args)
{ return _data_proxy(_data, _mesh.mesh_pt_components_to_linear(arg0, args...));}
template<typename Arg0, typename ... Args, bool MeshIsComposite = std::is_base_of<tag::composite, mesh_t>::value >
typename std::enable_if< MeshIsComposite && std::is_base_of< tag::mesh_point, Arg0>::value, cr_type>::type
operator() (Arg0 const & arg0, Args const & ... args) const
{ return _data_proxy(_data, _mesh.mesh_pt_components_to_linear(arg0, args...));}
*/
//// [] and access to the grid point //// [] and access to the grid point
typedef typename std::result_of<data_proxy_t(data_t &,size_t)>::type r_type; typedef typename std::result_of<data_proxy_t(data_t &,size_t)>::type r_type;
typedef typename std::result_of<data_proxy_t(data_t const &,size_t)>::type cr_type; typedef typename std::result_of<data_proxy_t(data_t const &,size_t)>::type cr_type;
@ -325,13 +329,13 @@ namespace triqs { namespace gfs {
friend std::string get_triqs_hdf5_data_scheme(gf_impl const & g) { return "Gf" + gfs_implementation::h5_name<Variable,Target,Opt>::invoke();} friend std::string get_triqs_hdf5_data_scheme(gf_impl const & g) { return "Gf" + gfs_implementation::h5_name<Variable,Target,Opt>::invoke();}
friend class gfs_implementation::h5_rw<Variable,Target,Opt,IsView>; friend class gfs_implementation::h5_rw<Variable,Target,Opt>;
/// Write into HDF5 /// Write into HDF5
friend void h5_write (h5::group fg, std::string subgroup_name, gf_impl const & g) { friend void h5_write (h5::group fg, std::string subgroup_name, gf_impl const & g) {
auto gr = fg.create_group(subgroup_name); auto gr = fg.create_group(subgroup_name);
gr.write_triqs_hdf5_data_scheme(g); gr.write_triqs_hdf5_data_scheme(g);
gfs_implementation::h5_rw<Variable,Target,Opt,IsView>::write(gr, g); gfs_implementation::h5_rw<Variable,Target,Opt>::write(gr, g);
} }
/// Read from HDF5 /// Read from HDF5
@ -342,7 +346,7 @@ namespace triqs { namespace gfs {
auto tag_expected= get_triqs_hdf5_data_scheme(g); auto tag_expected= get_triqs_hdf5_data_scheme(g);
if (tag_file != tag_expected) if (tag_file != tag_expected)
TRIQS_RUNTIME_ERROR<< "h5_read : mismatch of the tag TRIQS_HDF5_data_scheme tag in the h5 group : found "<<tag_file << " while I expected "<< tag_expected; TRIQS_RUNTIME_ERROR<< "h5_read : mismatch of the tag TRIQS_HDF5_data_scheme tag in the h5 group : found "<<tag_file << " while I expected "<< tag_expected;
gfs_implementation::h5_rw<Variable,Target,Opt,IsView>::read(gr, g); gfs_implementation::h5_rw<Variable,Target,Opt>::read(gr, g);
} }
//----------------------------- BOOST Serialization ----------------------------- //----------------------------- BOOST Serialization -----------------------------
@ -378,10 +382,7 @@ namespace triqs { namespace gfs {
} }
template <typename RHS> void triqs_clef_auto_assign_impl(RHS const &rhs, std::integral_constant<bool, true>) { template <typename RHS> void triqs_clef_auto_assign_impl(RHS const &rhs, std::integral_constant<bool, true>) {
for (auto const & w: this->mesh()) { for (auto const & w: this->mesh()) {
//std::cout << "abot "<<w.components_tuple()<<std::endl ;
//std::cout << "eefef "<< triqs::tuple::apply(rhs,w.components_tuple()) << std::endl ;
(*this)[w] = triqs::tuple::apply(rhs,w.components_tuple()); (*this)[w] = triqs::tuple::apply(rhs,w.components_tuple());
//std::cout << "done "<<std::endl ;
} }
//for (auto w: this->mesh()) triqs::tuple::apply(*this,w.components_tuple()) = triqs::tuple::apply(rhs,w.components_tuple()); //for (auto w: this->mesh()) triqs::tuple::apply(*this,w.components_tuple()) = triqs::tuple::apply(rhs,w.components_tuple());
} }
@ -389,15 +390,15 @@ namespace triqs { namespace gfs {
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
///The regular class of GF ///The regular class of GF
template<typename Variable, typename Target, typename Opt> class gf : public gf_impl<Variable,Target,Opt,false> { template<typename Variable, typename Target, typename Opt> class gf : public gf_impl<Variable,Target,Opt,false, false> {
typedef gf_impl<Variable,Target,Opt,false> B; typedef gf_impl<Variable,Target,Opt,false,false> B;
typedef gfs_implementation::factories<Variable,Target,Opt> factory; typedef gfs_implementation::factories<Variable,Target,Opt> factory;
public : public :
gf():B() {} gf():B() {}
gf(gf const & g): B(g){} gf(gf const & g): B(g){}
gf(gf && g) noexcept : B(std::move(g)){} gf(gf && g) noexcept : B(std::move(g)){}
gf(gf_view<Variable,Target,Opt> const & g): B(g){} gf(gf_view<Variable,Target,Opt> const & g): B(g, bool() ){}
template<typename GfType> gf(GfType const & x,typename std::enable_if<ImmutableGreenFunction<GfType>::value>::type *dummy =0 ): B() { *this = x;} template<typename GfType> gf(GfType const & x,typename std::enable_if<ImmutableGreenFunction<GfType>::value>::type *dummy =0 ): B() { *this = x;}
gf(typename B::mesh_t m, gf(typename B::mesh_t m,
@ -431,14 +432,50 @@ namespace triqs { namespace gfs {
}; };
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
///The View class of GF ///The const View class of GF
template<typename Variable, typename Target, typename Opt> class gf_view : public gf_impl<Variable,Target,Opt,true> { template<typename Variable, typename Target, typename Opt> class gf_view<Variable,Target,Opt,true> : public gf_impl<Variable,Target,Opt,true,true> {
typedef gf_impl<Variable,Target,Opt,true> B; typedef gf_impl<Variable,Target,Opt,true,true> B;
public : public :
gf_view() = delete;
gf_view(gf_view const & g): B(g){} gf_view(gf_view const & g): B(g){}
gf_view(gf_view && g) noexcept : B(std::move(g)){} gf_view(gf_view && g) noexcept : B(std::move(g)){}
template<bool V> gf_view(gf_impl<Variable,Target,Opt,V> const & g): B(g){} gf_view(gf_impl<Variable,Target,Opt,true,true> const & g) : B(g, bool()){} // from a const_view
gf_view(gf_impl<Variable,Target,Opt,true,false> const & g): B(g, bool()){} // from a view
gf_view(gf_impl<Variable,Target,Opt,false,false> const & g): B(g, bool()){} // from a const gf
gf_view(gf_impl<Variable,Target,Opt,false,false> & g): B(g, bool()){} // from a gf &
gf_view(gf_impl<Variable,Target,Opt,false,false> && g) noexcept: B(std::move(g), bool()){} // from a gf &&
template<typename D>
gf_view (typename B::mesh_t const & m,
D const & dat,typename B::singularity_view_t const & t,typename B::symmetry_t const & s,
typename B::evaluator_t const &e = typename B::evaluator_t () ) :
B(m,factory<typename B::data_t>(dat),t,s,e) {}
void rebind (gf_view const &X) noexcept {
this->_mesh = X._mesh; this->_symmetry = X._symmetry;
this->_data_proxy.rebind(this->_data,X);
this->_singularity.rebind(X._singularity);
}
gf_view & operator = (gf_view const & ) = delete;
}; // class gf_const_view
// ---------------------------------------------------------------------------------
///The View class of GF
template<typename Variable, typename Target, typename Opt> class gf_view<Variable,Target,Opt,false> : public gf_impl<Variable,Target,Opt,true,false> {
typedef gf_impl<Variable,Target,Opt,true,false> B;
public :
gf_view() = delete;
gf_view(gf_view const & g): B(g){}
gf_view(gf_view && g) noexcept : B(std::move(g)){}
gf_view(gf_impl<Variable,Target,Opt,true,true> const & g) = delete; // from a const view : impossible
gf_view(gf_impl<Variable,Target,Opt,true,false> const & g): B(g, bool()){} // from a view
gf_view(gf_impl<Variable,Target,Opt,false,false> const & g) = delete; // from a const gf : impossible
//gf_view(gf_impl<Variable,Target,Opt,false,false> const & g): B(g, bool()){} // from a gf &
gf_view(gf_impl<Variable,Target,Opt,false,false> & g): B(g, bool()){} // from a gf &
gf_view(gf_impl<Variable,Target,Opt,false,false> && g) noexcept: B(std::move(g), bool()){} // from a gf &&
template<typename D> template<typename D>
gf_view (typename B::mesh_t const & m, gf_view (typename B::mesh_t const & m,
@ -474,33 +511,67 @@ namespace triqs { namespace gfs {
} }
// tool for lazy transformation // tool for lazy transformation
template<typename Tag, typename D, typename Target = matrix_valued> struct gf_keeper{ gf_view<D,Target> g; gf_keeper (gf_view<D,Target> const & g_) : g(g_) {} }; template <typename Tag, typename D, typename Target = matrix_valued> struct gf_keeper {
gf_const_view<D, Target> g;
};
// ---------------------------------- slicing ------------------------------------ // ---------------------------------- slicing ------------------------------------
// slice // slice
template<typename Variable, typename Target, typename Opt, typename... Args> template <typename Variable, typename Target, typename Opt, bool IsConst, typename... Args>
gf_view<Variable,matrix_valued,Opt> slice_target (gf_view<Variable,Target,Opt> g, Args&& ... args) { gf_view<Variable, matrix_valued, Opt,IsConst> slice_target(gf_view<Variable, Target, Opt, IsConst> g, Args &&... args) {
static_assert(std::is_same<Target, matrix_valued>::value, "slice_target only for matrix_valued GF's"); static_assert(std::is_same<Target, matrix_valued>::value, "slice_target only for matrix_valued GF's");
using arrays::range; using arrays::range;
//auto sg=slice_target (g.singularity(),range(args,args+1)...); return {g.mesh(), g.data()(range(), std::forward<Args>(args)...),
return gf_view<Variable,matrix_valued,Opt>(g.mesh(), g.data()(range(), std::forward<Args>(args)... ), slice_target (g.singularity(), std::forward<Args>(args)...) , g.symmetry()); slice_target(g.singularity(), std::forward<Args>(args)...), g.symmetry()};
} }
template <typename Variable, typename Target, typename Opt, typename... Args> template <typename Variable, typename Target, typename Opt, typename... Args>
gf_view<Variable,scalar_valued,Opt> slice_target_to_scalar (gf_view<Variable,Target,Opt> g, Args&& ... args) { gf_view<Variable, matrix_valued, Opt> slice_target(gf<Variable, Target, Opt> & g, Args &&... args) {
return slice_target(g(), std::forward<Args>(args)...);
}
template <typename Variable, typename Target, typename Opt, typename... Args>
gf_const_view<Variable, matrix_valued, Opt> slice_target(gf<Variable, Target, Opt> const &g, Args &&... args) {
return slice_target(g(), std::forward<Args>(args)...);
}
// slice to scalar
template <typename Variable, typename Target, typename Opt, bool IsConst, typename... Args>
gf_view<Variable, scalar_valued, Opt, IsConst> slice_target_to_scalar(gf_view<Variable, Target, Opt, IsConst> g,
Args &&... args) {
static_assert(std::is_same<Target, matrix_valued>::value, "slice_target only for matrix_valued GF's"); static_assert(std::is_same<Target, matrix_valued>::value, "slice_target only for matrix_valued GF's");
using arrays::range; using arrays::range;
auto sg=slice_target (g.singularity(),range(args,args+1)...); return {g.mesh(), g.data()(range(), std::forward<Args>(args)...),
return gf_view<Variable,scalar_valued,Opt>(g.mesh(), g.data()(range(), std::forward<Args>(args)... ), sg, g.symmetry()); slice_target(g.singularity(), range(args, args + 1)...), g.symmetry()};
}
template <typename Variable, typename Target, typename Opt, typename... Args>
gf_view<Variable, scalar_valued, Opt> slice_target_to_scalar(gf<Variable, Target, Opt> & g, Args &&... args) {
return slice_target_to_scalar(g(), std::forward<Args>(args)...);
}
template <typename Variable, typename Target, typename Opt, typename... Args>
gf_const_view<Variable, scalar_valued, Opt> slice_target_to_scalar(gf<Variable, Target, Opt> const &g, Args &&... args) {
return slice_target_to_scalar(g(), std::forward<Args>(args)...);
} }
// a scalar_valued gf can be viewed as a 1x1 matrix // a scalar_valued gf can be viewed as a 1x1 matrix
template<typename Variable, typename Opt, typename... Args> template<typename Variable, typename Opt, bool IsConst, typename... Args>
gf_view<Variable,matrix_valued,Opt> reinterpret_scalar_valued_gf_as_matrix_valued (gf_view<Variable,scalar_valued,Opt> g) { gf_view<Variable,matrix_valued,Opt,IsConst> reinterpret_scalar_valued_gf_as_matrix_valued (gf_view<Variable,scalar_valued,Opt,IsConst> g) {
typedef typename gf_view<Variable,matrix_valued,Opt>::data_view_t a_t; typedef typename gf_view<Variable,matrix_valued,Opt,IsConst>::data_view_t a_t;
auto a = a_t {typename a_t::indexmap_type (join(g.data().shape(),make_shape(1,1))), g.data().storage()}; auto a = a_t {typename a_t::indexmap_type (join(g.data().shape(),make_shape(1,1))), g.data().storage()};
return gf_view<Variable,matrix_valued,Opt>(g.mesh(), a, g.singularity(), g.symmetry()); return {g.mesh(), a, g.singularity(), g.symmetry()};
}
template<typename Variable, typename Opt, typename... Args>
gf_view<Variable,matrix_valued,Opt> reinterpret_scalar_valued_gf_as_matrix_valued (gf<Variable,scalar_valued,Opt> & g) {
return reinterpret_scalar_valued_gf_as_matrix_valued(g());
}
template<typename Variable, typename Opt, typename... Args>
gf_const_view<Variable,matrix_valued,Opt> reinterpret_scalar_valued_gf_as_matrix_valued (gf<Variable,scalar_valued,Opt> const & g) {
return reinterpret_scalar_valued_gf_as_matrix_valued(g());
} }
/* /*

12
triqs/gfs/local/fourier_matsubara.cpp
View File

@ -44,7 +44,7 @@ namespace triqs { namespace gfs {
tqa::vector<dcomplex> g_in, g_out; tqa::vector<dcomplex> g_in, g_out;
void direct (gf_view<imfreq,scalar_valued> gw, gf_view<imtime,scalar_valued> const gt) { void direct (gf_view<imfreq,scalar_valued> gw, gf_const_view<imtime,scalar_valued> gt) {
using namespace impl_local_matsubara; using namespace impl_local_matsubara;
auto ta = gt(freq_infty()); auto ta = gt(freq_infty());
//TO BE MODIFIED AFTER SCALAR IMPLEMENTATION TODO //TO BE MODIFIED AFTER SCALAR IMPLEMENTATION TODO
@ -81,7 +81,7 @@ namespace triqs { namespace gfs {
gw.singularity() = gt.singularity();// set tail gw.singularity() = gt.singularity();// set tail
} }
void inverse(gf_view<imtime,scalar_valued> gt, gf_view<imfreq,scalar_valued> const gw){ void inverse(gf_view<imtime,scalar_valued> gt, gf_const_view<imfreq,scalar_valued> gw){
using namespace impl_local_matsubara; using namespace impl_local_matsubara;
static bool Green_Function_Are_Complex_in_time = false; static bool Green_Function_Are_Complex_in_time = false;
// If the Green function are NOT complex, then one use the symmetry property // If the Green function are NOT complex, then one use the symmetry property
@ -139,12 +139,12 @@ namespace triqs { namespace gfs {
}; };
void fourier_impl (gf_view<imfreq,scalar_valued> gw , gf_view<imtime,scalar_valued> const gt, scalar_valued){ void fourier_impl (gf_view<imfreq,scalar_valued> gw , gf_const_view<imtime,scalar_valued> gt, scalar_valued){
impl_worker w; impl_worker w;
w.direct(gw,gt); w.direct(gw,gt);
} }
void fourier_impl (gf_view<imfreq,matrix_valued> gw , gf_view<imtime,matrix_valued> const gt, matrix_valued){ void fourier_impl (gf_view<imfreq,matrix_valued> gw , gf_const_view<imtime,matrix_valued> gt, matrix_valued){
impl_worker w; impl_worker w;
for (size_t n1=0; n1<gt.data().shape()[1];n1++) for (size_t n1=0; n1<gt.data().shape()[1];n1++)
for (size_t n2=0; n2<gt.data().shape()[2];n2++){ for (size_t n2=0; n2<gt.data().shape()[2];n2++){
@ -158,12 +158,12 @@ namespace triqs { namespace gfs {
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void inverse_fourier_impl (gf_view<imtime,scalar_valued> gt , gf_view<imfreq,scalar_valued> const gw, scalar_valued){ void inverse_fourier_impl (gf_view<imtime,scalar_valued> gt , gf_const_view<imfreq,scalar_valued> gw, scalar_valued){
impl_worker w; impl_worker w;
w.inverse(gt,gw); w.inverse(gt,gw);
} }
void inverse_fourier_impl (gf_view<imtime,matrix_valued> gt , gf_view<imfreq,matrix_valued> const gw, matrix_valued){ void inverse_fourier_impl (gf_view<imtime,matrix_valued> gt , gf_const_view<imfreq,matrix_valued> gw, matrix_valued){
impl_worker w; impl_worker w;
for (size_t n1=0; n1<gw.data().shape()[1];n1++) for (size_t n1=0; n1<gw.data().shape()[1];n1++)
for (size_t n2=0; n2<gw.data().shape()[2];n2++){ for (size_t n2=0; n2<gw.data().shape()[2];n2++){

24
triqs/gfs/local/fourier_matsubara.hpp
View File

@ -28,19 +28,19 @@
namespace triqs { namespace gfs { namespace triqs { namespace gfs {
// First the implementation of the fourier transform // First the implementation of the fourier transform
void fourier_impl (gf_view<imfreq,scalar_valued> gw , gf_view<imtime,scalar_valued> const gt, scalar_valued); void fourier_impl (gf_view<imfreq,scalar_valued> gw , gf_const_view<imtime,scalar_valued> gt, scalar_valued);
void fourier_impl (gf_view<imfreq,matrix_valued> gw , gf_view<imtime,matrix_valued> const gt, matrix_valued); void fourier_impl (gf_view<imfreq,matrix_valued> gw , gf_const_view<imtime,matrix_valued> gt, matrix_valued);
void inverse_fourier_impl (gf_view<imtime,scalar_valued> gt, gf_view<imfreq,scalar_valued> const gw, scalar_valued); void inverse_fourier_impl (gf_view<imtime,scalar_valued> gt, gf_const_view<imfreq,scalar_valued> gw, scalar_valued);
void inverse_fourier_impl (gf_view<imtime,matrix_valued> gt, gf_view<imfreq,matrix_valued> const gw, matrix_valued); void inverse_fourier_impl (gf_view<imtime,matrix_valued> gt, gf_const_view<imfreq,matrix_valued> gw, matrix_valued);
inline gf_view<imfreq,matrix_valued> fourier (gf_view<imtime,matrix_valued> const gt) { inline gf_view<imfreq,matrix_valued> fourier (gf_const_view<imtime,matrix_valued> gt) {
int L = (gt.mesh().kind() == full_bins ? gt.mesh().size()-1 : gt.mesh().size() ); int L = (gt.mesh().kind() == full_bins ? gt.mesh().size()-1 : gt.mesh().size() );
auto gw = gf<imfreq,matrix_valued>{ {gt.domain(),L}, gt.data().shape().front_pop() }; auto gw = gf<imfreq,matrix_valued>{ {gt.domain(),L}, gt.data().shape().front_pop() };
auto V = gw(); auto V = gw();
fourier_impl(V, gt, matrix_valued()); fourier_impl(V, gt, matrix_valued());
return gw; return gw;
} }
inline gf_view<imfreq,scalar_valued> fourier (gf_view<imtime,scalar_valued> const gt) { inline gf_view<imfreq,scalar_valued> fourier (gf_const_view<imtime,scalar_valued> gt) {
int L = (gt.mesh().kind() == full_bins ? gt.mesh().size()-1 : gt.mesh().size() ); int L = (gt.mesh().kind() == full_bins ? gt.mesh().size()-1 : gt.mesh().size() );
auto gw = gf<imfreq,scalar_valued>{ {gt.domain(),L} }; auto gw = gf<imfreq,scalar_valued>{ {gt.domain(),L} };
auto V = gw(); auto V = gw();
@ -48,7 +48,7 @@ namespace triqs { namespace gfs {
return gw; return gw;
} }
inline gf_view<imtime, matrix_valued> inverse_fourier (gf_view<imfreq, matrix_valued> const gw, mesh_kind mk = half_bins) { inline gf_view<imtime, matrix_valued> inverse_fourier (gf_const_view<imfreq, matrix_valued> gw, mesh_kind mk = half_bins) {
double pi = std::acos(-1); double pi = std::acos(-1);
int L = (mk == full_bins ? gw.mesh().size()+1 : gw.mesh().size() ); int L = (mk == full_bins ? gw.mesh().size()+1 : gw.mesh().size() );
auto gt = gf<imtime,matrix_valued>{ {gw.domain(),L}, gw.data().shape().front_pop()}; auto gt = gf<imtime,matrix_valued>{ {gw.domain(),L}, gw.data().shape().front_pop()};
@ -56,7 +56,7 @@ namespace triqs { namespace gfs {
inverse_fourier_impl(V, gw, matrix_valued()); inverse_fourier_impl(V, gw, matrix_valued());
return gt; return gt;
} }
inline gf_view<imtime,scalar_valued> inverse_fourier (gf_view<imfreq,scalar_valued> const gw, mesh_kind mk = half_bins) { inline gf_view<imtime,scalar_valued> inverse_fourier (gf_const_view<imfreq,scalar_valued> gw, mesh_kind mk = half_bins) {
double pi = std::acos(-1); double pi = std::acos(-1);
int L = (mk == full_bins ? gw.mesh().size()+1 : gw.mesh().size() ); int L = (mk == full_bins ? gw.mesh().size()+1 : gw.mesh().size() );
auto gt = gf<imtime,scalar_valued>{ {gw.domain(),L} }; auto gt = gf<imtime,scalar_valued>{ {gw.domain(),L} };
@ -65,10 +65,10 @@ namespace triqs { namespace gfs {
return gt; return gt;
} }
inline gf_keeper<tags::fourier,imtime,scalar_valued> lazy_fourier (gf_view<imtime,scalar_valued> const & g) { return g;} inline gf_keeper<tags::fourier,imtime,scalar_valued> lazy_fourier (gf_const_view<imtime,scalar_valued> g) { return {g};}
inline gf_keeper<tags::fourier,imfreq,scalar_valued> lazy_inverse_fourier (gf_view<imfreq,scalar_valued> const & g) { return g;} inline gf_keeper<tags::fourier,imfreq,scalar_valued> lazy_inverse_fourier (gf_const_view<imfreq,scalar_valued> g) { return {g};}
inline gf_keeper<tags::fourier,imtime,matrix_valued> lazy_fourier (gf_view<imtime,matrix_valued> const & g) { return g;} inline gf_keeper<tags::fourier,imtime,matrix_valued> lazy_fourier (gf_const_view<imtime,matrix_valued> g) { return {g};}
inline gf_keeper<tags::fourier,imfreq,matrix_valued> lazy_inverse_fourier (gf_view<imfreq,matrix_valued> const & g) { return g;} inline gf_keeper<tags::fourier,imfreq,matrix_valued> lazy_inverse_fourier (gf_const_view<imfreq,matrix_valued> g) { return {g};}
void triqs_gf_view_assign_delegation( gf_view<imfreq,scalar_valued> g, gf_keeper<tags::fourier,imtime,scalar_valued> const & L); void triqs_gf_view_assign_delegation( gf_view<imfreq,scalar_valued> g, gf_keeper<tags::fourier,imtime,scalar_valued> const & L);
void triqs_gf_view_assign_delegation( gf_view<imfreq,matrix_valued> g, gf_keeper<tags::fourier,imtime,matrix_valued> const & L); void triqs_gf_view_assign_delegation( gf_view<imfreq,matrix_valued> g, gf_keeper<tags::fourier,imtime,matrix_valued> const & L);

12
triqs/gfs/local/fourier_real.cpp
View File

@ -37,7 +37,7 @@ namespace triqs { namespace gfs {
tqa::vector<dcomplex> g_in, g_out; tqa::vector<dcomplex> g_in, g_out;
void direct (gf_view<refreq,scalar_valued> gw, gf_view<retime,scalar_valued> const gt){ void direct (gf_view<refreq,scalar_valued> gw, gf_const_view<retime,scalar_valued> gt){
size_t L = gt.mesh().size(); size_t L = gt.mesh().size();
if (gw.mesh().size() != L) TRIQS_RUNTIME_ERROR << "Meshes are different"; if (gw.mesh().size() != L) TRIQS_RUNTIME_ERROR << "Meshes are different";
@ -70,7 +70,7 @@ namespace triqs { namespace gfs {
} }
void inverse(gf_view<retime,scalar_valued> gt, gf_view<refreq,scalar_valued> const gw){ void inverse(gf_view<retime,scalar_valued> gt, gf_const_view<refreq,scalar_valued> gw){
size_t L = gw.mesh().size(); size_t L = gw.mesh().size();
if ( L != gt.mesh().size()) TRIQS_RUNTIME_ERROR << "Meshes are different"; if ( L != gt.mesh().size()) TRIQS_RUNTIME_ERROR << "Meshes are different";
@ -108,12 +108,12 @@ namespace triqs { namespace gfs {
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
void fourier_impl(gf_view<refreq,scalar_valued> gw, gf_view<retime,scalar_valued> const gt, scalar_valued){ void fourier_impl(gf_view<refreq,scalar_valued> gw, gf_const_view<retime,scalar_valued> gt, scalar_valued){
impl_worker w; impl_worker w;
w.direct(gw, gt); w.direct(gw, gt);
} }
void fourier_impl(gf_view<refreq,matrix_valued> gw, gf_view<retime,matrix_valued> const gt, matrix_valued){ void fourier_impl(gf_view<refreq,matrix_valued> gw, gf_const_view<retime,matrix_valued> gt, matrix_valued){
impl_worker w; impl_worker w;
for (size_t n1=0; n1<gw.data().shape()[1];n1++) for (size_t n1=0; n1<gw.data().shape()[1];n1++)
for (size_t n2=0; n2<gw.data().shape()[2];n2++) { for (size_t n2=0; n2<gw.data().shape()[2];n2++) {
@ -125,12 +125,12 @@ namespace triqs { namespace gfs {
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void inverse_fourier_impl (gf_view<retime,scalar_valued> gt, gf_view<refreq,scalar_valued> const gw, scalar_valued){ void inverse_fourier_impl (gf_view<retime,scalar_valued> gt, gf_const_view<refreq,scalar_valued> gw, scalar_valued){
impl_worker w; impl_worker w;
w.inverse(gt,gw); w.inverse(gt,gw);
} }
void inverse_fourier_impl (gf_view<retime,matrix_valued> gt, gf_view<refreq,matrix_valued> const gw, matrix_valued){ void inverse_fourier_impl (gf_view<retime,matrix_valued> gt, gf_const_view<refreq,matrix_valued> gw, matrix_valued){
impl_worker w; impl_worker w;
for (size_t n1=0; n1<gt.data().shape()[1];n1++) for (size_t n1=0; n1<gt.data().shape()[1];n1++)
for (size_t n2=0; n2<gt.data().shape()[2];n2++) { for (size_t n2=0; n2<gt.data().shape()[2];n2++) {

24
triqs/gfs/local/fourier_real.hpp
View File

@ -28,12 +28,12 @@
namespace triqs { namespace gfs { namespace triqs { namespace gfs {
// First the implementation of the fourier transform // First the implementation of the fourier transform
void fourier_impl (gf_view<refreq,scalar_valued> gw , gf_view<retime,scalar_valued> const gt, scalar_valued); void fourier_impl (gf_view<refreq,scalar_valued> gw , gf_const_view<retime,scalar_valued> gt, scalar_valued);
void fourier_impl (gf_view<refreq,matrix_valued> gw , gf_view<retime,matrix_valued> const gt, matrix_valued); void fourier_impl (gf_view<refreq,matrix_valued> gw , gf_const_view<retime,matrix_valued> gt, matrix_valued);
void inverse_fourier_impl (gf_view<retime,scalar_valued> gt, gf_view<refreq,scalar_valued> const gw, scalar_valued); void inverse_fourier_impl (gf_view<retime,scalar_valued> gt, gf_const_view<refreq,scalar_valued> gw, scalar_valued);
void inverse_fourier_impl (gf_view<retime,matrix_valued> gt, gf_view<refreq,matrix_valued> const gw, matrix_valued); void inverse_fourier_impl (gf_view<retime,matrix_valued> gt, gf_const_view<refreq,matrix_valued> gw, matrix_valued);
inline gf_view<refreq,matrix_valued> fourier (gf_view<retime, matrix_valued> const gt) { inline gf_view<refreq,matrix_valued> fourier (gf_const_view<retime, matrix_valued> gt) {
double pi = std::acos(-1); double pi = std::acos(-1);
int L = gt.mesh().size(); int L = gt.mesh().size();
double wmin = -pi * (L-1) / (L*gt.mesh().delta()); double wmin = -pi * (L-1) / (L*gt.mesh().delta());
@ -43,7 +43,7 @@ namespace triqs { namespace gfs {
fourier_impl(V, gt, matrix_valued()); fourier_impl(V, gt, matrix_valued());
return gw; return gw;
} }
inline gf_view<refreq,scalar_valued> fourier (gf_view<retime, scalar_valued> const gt) { inline gf_view<refreq,scalar_valued> fourier (gf_const_view<retime, scalar_valued> gt) {
double pi = std::acos(-1); double pi = std::acos(-1);
int L = gt.mesh().size(); int L = gt.mesh().size();
double wmin = -pi * (L-1) / (L*gt.mesh().delta()); double wmin = -pi * (L-1) / (L*gt.mesh().delta());
@ -54,7 +54,7 @@ namespace triqs { namespace gfs {
return gw; return gw;
} }
inline gf_view<retime,matrix_valued> inverse_fourier (gf_view<refreq,matrix_valued> const gw) { inline gf_view<retime,matrix_valued> inverse_fourier (gf_const_view<refreq,matrix_valued> gw) {
double pi = std::acos(-1); double pi = std::acos(-1);
int L = gw.mesh().size(); int L = gw.mesh().size();
double tmin = -pi * (L-1) / (L*gw.mesh().delta()); double tmin = -pi * (L-1) / (L*gw.mesh().delta());
@ -64,7 +64,7 @@ namespace triqs { namespace gfs {
inverse_fourier_impl(V, gw, matrix_valued()); inverse_fourier_impl(V, gw, matrix_valued());
return gt; return gt;
} }
inline gf_view<retime,scalar_valued> inverse_fourier (gf_view<refreq,scalar_valued> const gw) { inline gf_view<retime,scalar_valued> inverse_fourier (gf_const_view<refreq,scalar_valued> gw) {
double pi = std::acos(-1); double pi = std::acos(-1);
int L = gw.mesh().size(); int L = gw.mesh().size();
double tmin = -pi * (L-1) / (L*gw.mesh().delta()); double tmin = -pi * (L-1) / (L*gw.mesh().delta());
@ -75,10 +75,10 @@ namespace triqs { namespace gfs {
return gt; return gt;
} }
inline gf_keeper<tags::fourier,retime,scalar_valued> lazy_fourier (gf_view<retime,scalar_valued> const & g) { return g;} inline gf_keeper<tags::fourier, retime, scalar_valued> lazy_fourier(gf_const_view<retime, scalar_valued> g) { return {g}; }
inline gf_keeper<tags::fourier,refreq,scalar_valued> lazy_inverse_fourier (gf_view<refreq,scalar_valued> const & g) { return g;} inline gf_keeper<tags::fourier, refreq, scalar_valued> lazy_inverse_fourier(gf_const_view<refreq, scalar_valued> g) { return {g}; }
inline gf_keeper<tags::fourier,retime,matrix_valued> lazy_fourier (gf_view<retime,matrix_valued> const & g) { return g;} inline gf_keeper<tags::fourier, retime, matrix_valued> lazy_fourier(gf_const_view<retime, matrix_valued> g) { return {g}; }
inline gf_keeper<tags::fourier,refreq,matrix_valued> lazy_inverse_fourier (gf_view<refreq,matrix_valued> const & g) { return g;} inline gf_keeper<tags::fourier, refreq, matrix_valued> lazy_inverse_fourier(gf_const_view<refreq, matrix_valued> g) { return {g}; }
void triqs_gf_view_assign_delegation( gf_view<refreq,scalar_valued> g, gf_keeper<tags::fourier,retime,scalar_valued> const & L); void triqs_gf_view_assign_delegation( gf_view<refreq,scalar_valued> g, gf_keeper<tags::fourier,retime,scalar_valued> const & L);
void triqs_gf_view_assign_delegation( gf_view<refreq,matrix_valued> g, gf_keeper<tags::fourier,retime,matrix_valued> const & L); void triqs_gf_view_assign_delegation( gf_view<refreq,matrix_valued> g, gf_keeper<tags::fourier,retime,matrix_valued> const & L);

2
triqs/gfs/local/functions.cpp
View File

@ -87,7 +87,7 @@ namespace triqs { namespace gfs {
// compute a tail from the Legendre GF // compute a tail from the Legendre GF
// this is Eq. 8 of our paper // this is Eq. 8 of our paper
local::tail_view get_tail(gf_view<legendre> const & gl, int size = 10, int omin = -1) { local::tail_view get_tail(gf_const_view<legendre> gl, int size = 10, int omin = -1) {
auto sh = gl.data().shape().front_pop(); auto sh = gl.data().shape().front_pop();
local::tail t(sh, size, omin); local::tail t(sh, size, omin);

2
triqs/gfs/local/functions.hpp
View File

@ -36,7 +36,7 @@ namespace triqs {
tqa::matrix<double> density(gf_view<legendre> const & g); tqa::matrix<double> density(gf_view<legendre> const & g);
local::tail_view get_tail(gf_view<legendre> const & gl, int size, int omin); local::tail_view get_tail(gf_const_view<legendre> gl, int size, int omin);
void enforce_discontinuity(gf_view<legendre> & gl, triqs::arrays::array_view<double,2> disc); void enforce_discontinuity(gf_view<legendre> & gl, triqs::arrays::array_view<double,2> disc);

16
triqs/gfs/local/legendre_matsubara.cpp
View File

@ -29,7 +29,7 @@ using namespace triqs::utility;
namespace triqs { namespace gfs { namespace triqs { namespace gfs {
void legendre_matsubara_direct(gf_view<imfreq> & gw, gf_view<legendre> const & gl) { void legendre_matsubara_direct(gf_view<imfreq> & gw, gf_const_view<legendre> gl) {
gw() = 0.0; gw() = 0.0;
triqs::arrays::range R; triqs::arrays::range R;
@ -45,7 +45,7 @@ void legendre_matsubara_direct(gf_view<imfreq> & gw, gf_view<legendre> const & g
} }
void legendre_matsubara_inverse (gf_view<legendre> & gl, gf_view<imfreq> const & gw) { void legendre_matsubara_inverse (gf_view<legendre> & gl, gf_const_view<imfreq> gw) {
gl() = 0.0; gl() = 0.0;
@ -62,7 +62,7 @@ void legendre_matsubara_inverse (gf_view<legendre> & gl, gf_view<imfreq> const &
} }
void legendre_matsubara_direct (gf_view<imtime> & gt, gf_view<legendre> const & gl) { void legendre_matsubara_direct (gf_view<imtime> & gt, gf_const_view<legendre> gl) {
gt() = 0.0; gt() = 0.0;
legendre_generator L; legendre_generator L;
@ -78,7 +78,7 @@ void legendre_matsubara_direct (gf_view<imtime> & gt, gf_view<legendre> const &
} }
void legendre_matsubara_inverse (gf_view<legendre> & gl, gf_view<imtime> const & gt) { void legendre_matsubara_inverse (gf_view<legendre> & gl, gf_const_view<imtime> gt) {
gl() = 0.0; gl() = 0.0;
legendre_generator L; legendre_generator L;
@ -95,10 +95,10 @@ void legendre_matsubara_inverse (gf_view<legendre> & gl, gf_view<imtime> const &
} }
gf_keeper<tags::legendre,legendre> lazy_legendre_imfreq (gf_view<legendre> const & gl) { return gl; } gf_keeper<tags::legendre,legendre> lazy_legendre_imfreq (gf_const_view<legendre> gl) { return {gl}; }
gf_keeper<tags::legendre,legendre> lazy_legendre_imtime (gf_view<legendre> const & gl) { return gl; } gf_keeper<tags::legendre,legendre> lazy_legendre_imtime (gf_const_view<legendre> gl) { return {gl}; }
gf_keeper<tags::legendre,imfreq> lazy_imfreq_legendre (gf_view<imfreq> const & gw) { return gw; } gf_keeper<tags::legendre,imfreq> lazy_imfreq_legendre (gf_const_view<imfreq> gw) { return {gw}; }
gf_keeper<tags::legendre,imtime> lazy_imtime_legendre (gf_view<imtime> const & gt) { return gt; } gf_keeper<tags::legendre,imtime> lazy_imtime_legendre (gf_const_view<imtime> gt) { return {gt}; }
void triqs_gf_view_assign_delegation( gf_view<imfreq> &gw, gf_keeper<tags::legendre,legendre> const & L) { void triqs_gf_view_assign_delegation( gf_view<imfreq> &gw, gf_keeper<tags::legendre,legendre> const & L) {
legendre_matsubara_direct(gw, L.g); legendre_matsubara_direct(gw, L.g);

16
triqs/gfs/local/legendre_matsubara.hpp
View File

@ -28,18 +28,18 @@
namespace triqs { namespace gfs { namespace triqs { namespace gfs {
void legendre_matsubara_direct (gf_view<imfreq> &gw, gf_view<legendre> const &gl); void legendre_matsubara_direct (gf_view<imfreq> &gw, gf_const_view<legendre> gl);
void legendre_matsubara_inverse (gf_view<legendre> &gl, gf_view<imfreq> const &gw); void legendre_matsubara_inverse (gf_view<legendre> &gl, gf_const_view<imfreq> gw);
void legendre_matsubara_direct (gf_view<imtime> &gt, gf_view<legendre> const &gl); void legendre_matsubara_direct (gf_view<imtime> &gt, gf_const_view<legendre> gl);
void legendre_matsubara_inverse (gf_view<legendre> &gl, gf_view<imtime> const &gt); void legendre_matsubara_inverse (gf_view<legendre> &gl, gf_const_view<imtime> gt);
namespace tags { struct legendre{}; } namespace tags { struct legendre{}; }
gf_keeper<tags::legendre,legendre> lazy_legendre_imfreq (gf_view<legendre> const & gl); gf_keeper<tags::legendre,legendre> lazy_legendre_imfreq (gf_const_view<legendre> gl);
gf_keeper<tags::legendre,legendre> lazy_legendre_imtime (gf_view<legendre> const & gl); gf_keeper<tags::legendre,legendre> lazy_legendre_imtime (gf_const_view<legendre> gl);
gf_keeper<tags::legendre,imfreq> lazy_imfreq_legendre (gf_view<imfreq> const & gw); gf_keeper<tags::legendre,imfreq> lazy_imfreq_legendre (gf_const_view<imfreq> gw);
gf_keeper<tags::legendre,imtime> lazy_imtime_legendre (gf_view<imtime> const & gt); gf_keeper<tags::legendre,imtime> lazy_imtime_legendre (gf_const_view<imtime> gt);
void triqs_gf_view_assign_delegation( gf_view<imfreq> &gw, gf_keeper<tags::legendre,legendre> const & L); void triqs_gf_view_assign_delegation( gf_view<imfreq> &gw, gf_keeper<tags::legendre,legendre> const & L);
void triqs_gf_view_assign_delegation( gf_view<imtime> &gt, gf_keeper<tags::legendre,legendre> const & L); void triqs_gf_view_assign_delegation( gf_view<imtime> &gt, gf_keeper<tags::legendre,legendre> const & L);

6
triqs/gfs/meshes/product.hpp
View File

@ -176,9 +176,9 @@ namespace triqs { namespace gfs {
// reinterpret_linear_array(m,A) returns a d-dimensionnal view of the array // reinterpret_linear_array(m,A) returns a d-dimensionnal view of the array
// with indices egal to the indices of the components of the mesh. // with indices egal to the indices of the components of the mesh.
// Very useful for slicing, currying functions. // Very useful for slicing, currying functions.
template<typename ... Meshes, typename T, ull_t OptionsFlags, int R > template<typename ... Meshes, typename T, ull_t OptionsFlags, ull_t To, int R , bool B, bool C>
arrays::array_view<T, sizeof...(Meshes)+ R-1,OptionsFlags> arrays::array_view<T, sizeof...(Meshes)+ R-1,OptionsFlags,To,true,C>
reinterpret_linear_array(mesh_product<Meshes...> const & m, arrays::array_view<T,R,OptionsFlags> const & A) { reinterpret_linear_array(mesh_product<Meshes...> const & m, arrays::array_view<T,R,OptionsFlags,To,B,C> A) {
return { {join (m.all_size_as_mini_vector(), get_shape(A).front_pop())}, A.storage()}; return { {join (m.all_size_as_mini_vector(), get_shape(A).front_pop())}, A.storage()};
} }

17
triqs/gfs/product.hpp
View File

@ -59,29 +59,32 @@ namespace triqs { namespace gfs {
template<typename Opt, int R, typename ... Ms> struct h5_name<cartesian_product<Ms...>,tensor_valued<R>,Opt> : h5_name<cartesian_product<Ms...>,matrix_valued,Opt> {}; template<typename Opt, int R, typename ... Ms> struct h5_name<cartesian_product<Ms...>,tensor_valued<R>,Opt> : h5_name<cartesian_product<Ms...>,matrix_valued,Opt> {};
// a slight difference with the generic case : reinterpret the data array to avoid flattening the variables // a slight difference with the generic case : reinterpret the data array to avoid flattening the variables
template <typename Opt, bool IsView, int R, typename ... Ms> template <typename Opt, int R, typename ... Ms>
struct h5_rw<cartesian_product<Ms...>,tensor_valued<R>,Opt,IsView> { struct h5_rw<cartesian_product<Ms...>,tensor_valued<R>,Opt> {
typedef gf_impl<cartesian_product<Ms...>,tensor_valued<R>,Opt,IsView> g_t; typedef gf<cartesian_product<Ms...>,tensor_valued<R>,Opt> g_t;
static void write (h5::group gr, g_t const & g) { static void write (h5::group gr, typename g_t::const_view_type g) {
h5_write(gr,"data",reinterpret_linear_array(g.mesh(), g().data())); h5_write(gr,"data",reinterpret_linear_array(g.mesh(), g().data()));
h5_write(gr,"singularity",g._singularity); h5_write(gr,"singularity",g._singularity);
h5_write(gr,"mesh",g._mesh); h5_write(gr,"mesh",g._mesh);
h5_write(gr,"symmetry",g._symmetry); h5_write(gr,"symmetry",g._symmetry);
} }
static void read (h5::group gr, g_t & g) { template<bool IsView>
static void read (h5::group gr, gf_impl<cartesian_product<Ms...>,tensor_valued<R>,Opt,IsView,false> & g) {
using G_t= gf_impl<cartesian_product<Ms...>,tensor_valued<R>,Opt,IsView,false> ;
h5_read(gr,"mesh",g._mesh); h5_read(gr,"mesh",g._mesh);
auto arr = arrays::array<typename g_t::data_t::value_type, sizeof...(Ms)+ R>{}; auto arr = arrays::array<typename G_t::data_t::value_type, sizeof...(Ms)+ R>{};
h5_read(gr,"data",arr); h5_read(gr,"data",arr);
auto sh = arr.shape(); auto sh = arr.shape();
arrays::mini_vector<size_t,R+1> sh2; arrays::mini_vector<size_t,R+1> sh2;
sh2[0] = g._mesh.size(); sh2[0] = g._mesh.size();
for (int u=1; u<R+1; ++u) sh2[u] = sh[sizeof...(Ms)-1+u]; for (int u=1; u<R+1; ++u) sh2[u] = sh[sizeof...(Ms)-1+u];
g._data = arrays::array<typename g_t::data_t::value_type, R+1>{sh2, std::move(arr.storage())}; g._data = arrays::array<typename G_t::data_t::value_type, R+1>{sh2, std::move(arr.storage())};
h5_read(gr,"singularity",g._singularity); h5_read(gr,"singularity",g._singularity);
h5_read(gr,"symmetry",g._symmetry); h5_read(gr,"symmetry",g._symmetry);
} }
}; };
/// --------------------------- data access --------------------------------- /// --------------------------- data access ---------------------------------