mirror of
https://github.com/triqs/dft_tools
synced 2024-12-25 13:53:40 +01:00
7cf7d09c77
- The issue comes from the fact that the default generated
+= and co by the Python API is the one for immutable types, like int.
- Indeed, in python, for an int :
x=1
id(x)
140266967205832
x+=1
id(x)
140266967205808
- For a mutable type, like a gf, it is necessary to
add explicitly the xxx_inplace_add functions.
- Added :
- the generation of the inplace_xxx functions
- a method in class_ in the wrapper generator that
deduce all += operator from the + operators.
- this assumes that the +=, ... are defined in C++.
- The generation of such operators are optional, with option
with_inplace_operators in the arithmetic flag.
- Also, added the overload g += M and g -= M for
g : GfImfreq, M a complex matrix.
Mainly for legacy Python codes.
169 lines
8.9 KiB
C++
169 lines
8.9 KiB
C++
/*******************************************************************************
|
|
*
|
|
* TRIQS: a Toolbox for Research in Interacting Quantum Systems
|
|
*
|
|
* Copyright (C) 2012 by M. Ferrero, O. Parcollet
|
|
*
|
|
* TRIQS 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.
|
|
*
|
|
* TRIQS 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 should have received a copy of the GNU General Public License along with
|
|
* TRIQS. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
******************************************************************************/
|
|
#ifndef TRIQS_GF_EXPR_H
|
|
#define TRIQS_GF_EXPR_H
|
|
#include <triqs/utility/expression_template_tools.hpp>
|
|
namespace triqs { namespace gfs {
|
|
|
|
using utility::is_in_ZRC;
|
|
using utility::remove_rvalue_ref;
|
|
|
|
namespace gfs_expr_tools {
|
|
|
|
// a wrapper for scalars
|
|
template<typename S> struct scalar_wrap {
|
|
typedef void variable_t;
|
|
typedef void target_t;
|
|
typedef void option_t;
|
|
S s;
|
|
template<typename T> scalar_wrap(T && x):s(std::forward<T>(x)){}
|
|
S singularity() const { return s;}
|
|
template<typename KeyType> S operator[](KeyType && key) const { return s;}
|
|
template<typename ... Args> inline S operator()(Args && ... args) const { return s;}
|
|
friend std::ostream &operator <<(std::ostream &sout, scalar_wrap const &expr){return sout << expr.s; }
|
|
};
|
|
|
|
// Combine the two meshes of LHS and RHS : need to specialize where there is a scalar
|
|
struct combine_mesh {
|
|
template<typename L, typename R>
|
|
auto operator() (L && l, R && r) const -> decltype(std::forward<L>(l).mesh()) {
|
|
if (!(l.mesh() == r.mesh())) TRIQS_RUNTIME_ERROR << "Mesh mismatch : in Green Function Expression "<< l.mesh()<<" vs" <<r.mesh();
|
|
return std::forward<L>(l).mesh();
|
|
}
|
|
template<typename S, typename R> auto operator() (scalar_wrap<S> const &, R && r) const DECL_AND_RETURN(std::forward<R>(r).mesh());
|
|
template<typename S, typename L> auto operator() (L && l, scalar_wrap<S> const &) const DECL_AND_RETURN(std::forward<L>(l).mesh());
|
|
};
|
|
|
|
// Same thing to get the data shape
|
|
// NB : could be unified to one combine<F>, where F is a functor, but an easy usage requires polymorphic lambda ...
|
|
struct combine_shape {
|
|
template<typename L, typename R>
|
|
auto operator() (L && l, R && r) const -> decltype(get_gf_data_shape(std::forward<L>(l))) {
|
|
if (!(get_gf_data_shape(l) == get_gf_data_shape(r)))
|
|
TRIQS_RUNTIME_ERROR << "Shape mismatch in Green Function Expression: " << get_gf_data_shape(l) << " vs "<< get_gf_data_shape(r);
|
|
return get_gf_data_shape(std::forward<L>(l));
|
|
}
|
|
template<typename S, typename R> auto operator() (scalar_wrap<S> const &, R && r) const DECL_AND_RETURN(get_gf_data_shape(std::forward<R>(r)));
|
|
template<typename S, typename L> auto operator() (L && l, scalar_wrap<S> const &) const DECL_AND_RETURN(get_gf_data_shape(std::forward<L>(l)));
|
|
};
|
|
|
|
template<typename T> struct node_t : std::conditional<utility::is_in_ZRC<T>::value, scalar_wrap<T>, typename remove_rvalue_ref<T>::type> {};
|
|
|
|
template <typename A, typename B> struct _or_ {typedef void type;};
|
|
template <typename A> struct _or_<A,A> {typedef A type;};
|
|
template <typename A> struct _or_<void,A> {typedef A type;};
|
|
template <typename A> struct _or_<A,void> {typedef A type;};
|
|
template <> struct _or_<void,void> {typedef void type;};
|
|
|
|
}// gfs_expr_tools
|
|
|
|
template<typename Tag, typename L, typename R> struct gf_expr : TRIQS_CONCEPT_TAG_NAME(ImmutableGreenFunction){
|
|
typedef typename std::remove_reference<L>::type L_t;
|
|
typedef typename std::remove_reference<R>::type R_t;
|
|
typedef typename gfs_expr_tools::_or_<typename L_t::variable_t,typename R_t::variable_t>::type variable_t;
|
|
typedef typename gfs_expr_tools::_or_<typename L_t::target_t,typename R_t::target_t>::type target_t;
|
|
typedef typename gfs_expr_tools::_or_<typename L_t::option_t,typename R_t::option_t>::type option_t;
|
|
static_assert(!std::is_same<variable_t,void>::value, "Cannot combine two gf expressions with different variables");
|
|
static_assert(!std::is_same<target_t,void>::value, "Cannot combine two gf expressions with different target");
|
|
|
|
L l; R r;
|
|
template<typename LL, typename RR> gf_expr(LL && l_, RR && r_):l(std::forward<LL>(l_)), r(std::forward<RR>(r_)) {}
|
|
|
|
auto mesh() const DECL_AND_RETURN(gfs_expr_tools::combine_mesh()(l,r));
|
|
auto singularity() const DECL_AND_RETURN (utility::operation<Tag>()(l.singularity() , r.singularity()));
|
|
auto get_data_shape() const DECL_AND_RETURN (gfs_expr_tools::combine_shape()(l,r));
|
|
|
|
template<typename KeyType> auto operator[](KeyType && key) const DECL_AND_RETURN(utility::operation<Tag>()(l[std::forward<KeyType>(key)] , r[std::forward<KeyType>(key)]));
|
|
template<typename ... Args> auto operator()(Args && ... args) const DECL_AND_RETURN(utility::operation<Tag>()(l(std::forward<Args>(args)...) , r(std::forward<Args>(args)...)));
|
|
friend std::ostream &operator <<(std::ostream &sout, gf_expr const &expr){return sout << "("<<expr.l << " "<<utility::operation<Tag>::name << " "<<expr.r<<")" ; }
|
|
};
|
|
|
|
// -------------------------------------------------------------------
|
|
//a special case : the unary operator !
|
|
template<typename L> struct gf_unary_m_expr : TRIQS_CONCEPT_TAG_NAME(ImmutableGreenFunction){
|
|
typedef typename std::remove_reference<L>::type L_t;
|
|
typedef typename L_t::variable_t variable_t;
|
|
typedef typename L_t::target_t target_t;
|
|
typedef typename L_t::option_t option_t;
|
|
|
|
L l;
|
|
template<typename LL> gf_unary_m_expr(LL && l_) : l(std::forward<LL>(l_)) {}
|
|
|
|
auto mesh() const DECL_AND_RETURN(l.mesh());
|
|
auto singularity() const DECL_AND_RETURN(l.singularity());
|
|
AUTO_DECL get_data_shape() const RETURN (get_gf_data_shape(l));
|
|
|
|
template<typename KeyType> auto operator[](KeyType&& key) const DECL_AND_RETURN( -l[key]);
|
|
template<typename ... Args> auto operator()(Args && ... args) const DECL_AND_RETURN( -l(std::forward<Args>(args)...));
|
|
friend std::ostream &operator <<(std::ostream &sout, gf_unary_m_expr const &expr){return sout << '-'<<expr.l; }
|
|
};
|
|
|
|
// -------------------------------------------------------------------
|
|
// Now we can define all the C++ operators ...
|
|
#define DEFINE_OPERATOR(TAG, OP, TRAIT1, TRAIT2) \
|
|
template<typename A1, typename A2>\
|
|
typename std::enable_if<TRAIT1<A1>::value && TRAIT2 <A2>::value, \
|
|
gf_expr<utility::tags::TAG, typename gfs_expr_tools::node_t<A1>::type, typename gfs_expr_tools::node_t<A2>::type>>::type\
|
|
operator OP (A1 && a1, A2 && a2) { return {std::forward<A1>(a1),std::forward<A2>(a2)};}
|
|
|
|
DEFINE_OPERATOR(plus, +, ImmutableGreenFunction,ImmutableGreenFunction);
|
|
DEFINE_OPERATOR(minus, -, ImmutableGreenFunction,ImmutableGreenFunction);
|
|
DEFINE_OPERATOR(multiplies, *, ImmutableGreenFunction,ImmutableGreenFunction);
|
|
DEFINE_OPERATOR(multiplies, *, is_in_ZRC,ImmutableGreenFunction);
|
|
DEFINE_OPERATOR(multiplies, *, ImmutableGreenFunction,is_in_ZRC);
|
|
DEFINE_OPERATOR(divides, /, ImmutableGreenFunction,ImmutableGreenFunction);
|
|
DEFINE_OPERATOR(divides, /, is_in_ZRC,ImmutableGreenFunction);
|
|
DEFINE_OPERATOR(divides, /, ImmutableGreenFunction,is_in_ZRC);
|
|
#undef DEFINE_OPERATOR
|
|
|
|
// the unary is special
|
|
template<typename A1>
|
|
typename std::enable_if<
|
|
ImmutableGreenFunction<A1>::value,
|
|
gf_unary_m_expr<typename gfs_expr_tools::node_t<A1>::type >
|
|
>::type
|
|
operator - (A1 && a1) { return {std::forward<A1>(a1)};}
|
|
|
|
// Now the inplace operator. Because of expression template, there are useless for speed
|
|
// we implement them trivially.
|
|
|
|
#define DEFINE_OPERATOR(OP1, OP2) \
|
|
template <typename Variable, typename Target, typename Opt, typename T> \
|
|
void operator OP1(gf_view<Variable, Target, Opt> g, T const &x) { \
|
|
g = g OP2 x; \
|
|
} \
|
|
template <typename Variable, typename Target, typename Opt, typename T> \
|
|
void operator OP1(gf<Variable, Target, Opt> &g, T const &x) { \
|
|
g = g OP2 x; \
|
|
}
|
|
|
|
DEFINE_OPERATOR(+=, +);
|
|
DEFINE_OPERATOR(-=, -);
|
|
DEFINE_OPERATOR(*=, *);
|
|
DEFINE_OPERATOR(/=, / );
|
|
|
|
#undef DEFINE_OPERATOR
|
|
|
|
}}//namespace triqs::gf
|
|
#endif
|
|
|
|
|