void check_input_gf(gf_const_view<GfOpts...> g, gf_const_view<GfOpts...> S) {
if(g.mesh() != S.mesh() || get_target_shape(g) != get_target_shape(S))
fatal_error("input quantity and the error-bar function S must have equivalent structure");
auto shape = get_target_shape(g);
if(shape[0] != shape[1]) fatal_error("matrix-valued input quantities must be square");
}
template<typename MeshType> void check_gf_dim(gf_const_view<MeshType> g, int expected_dim) {
auto shape = get_target_shape(g);
if(shape[0] != expected_dim || shape[1] != expected_dim)
fatal_error("expected a " + mesh_traits<MeshType>::name()
+ " Green's function with matrix dimensions "
+ to_string(expected_dim) + "x" + to_string(expected_dim));
}
gf<imtime, T, S> make_gf_from_inverse_fourier(gf_const_view<imfreq, T, S, E> const& gw, int n_tau = -1) {
if (n_tau == -1) n_tau = 2*(gw.mesh().last_index() + 1) +1;
auto m = gf_mesh<imtime>{gw.mesh().domain(), n_tau};
auto gt = gf<imtime, T, S, E>{m, get_target_shape(gw)};
gt() = inverse_fourier(gw);
return gt;
}
gf<imfreq, T, S> make_gf_from_fourier(gf_const_view<imtime, T, S, E> const& gt, int n_iw = -1) {
if (n_iw == -1) n_iw = (gt.mesh().size() - 1) / 2;
auto m = gf_mesh<imfreq>{gt.mesh().domain(), n_iw};
auto gw = gf<imfreq, T, S>{m, get_target_shape(gt)};
gw() = fourier(gt);
return gw;
}
void fit_tail(gf_view<imfreq> gf, tail_view known_moments, int n_moments, int n_min, int n_max,
bool replace_by_fit ) {
if (get_target_shape(gf) != known_moments.shape()) TRIQS_RUNTIME_ERROR << "shape of tail does not match shape of gf";
gf.singularity() = fit_tail_impl(gf, known_moments, n_moments, n_min, n_max);
if (replace_by_fit) { // replace data in the fitting range by the values from the fitted tail
int i = 0;
for (auto iw : gf.mesh()) { // (arrays::range(n_min,n_max+1)) {
if (i >= n_min) gf[iw] = evaluate(gf.singularity(),iw);
i++;
}
}
}
// Legendre coefficients
som_core::som_core(gf_const_view<legendre> g_l, gf_const_view<legendre> S_l,
observable_kind kind, vector<double> const& norms) :
mesh(g_l.mesh()), kind(kind), norms(make_default_norms(norms,get_target_shape(g_l)[0])),
rhs(input_data_r_t()), error_bars(input_data_r_t()) {
if(is_stat_relevant(kind)) check_gf_stat(g_l, observable_statistics(kind));
check_input_gf(g_l,S_l);
if(!is_gf_real(g_l) || !is_gf_real(S_l))
fatal_error("Legendre " + observable_name(kind) + " must be real");
gf<legendre, matrix_real_valued> g_l_real = real(g_l), S_l_real = real(S_l);
set_input_data(make_const_view(g_l_real), make_const_view(S_l_real));
}
void som_core::set_input_data(gf_const_view<GfOpts...> g, gf_const_view<GfOpts...> S) {
using mesh_t = typename gf_const_view<GfOpts...>::mesh_t;
auto & rhs_ = (input_data_t<mesh_t>&)rhs;
auto & error_bars_ = (input_data_t<mesh_t>&)error_bars;
auto gf_dim = get_target_shape(g)[0];
results.reserve(gf_dim);
for(int i = 0; i < gf_dim; ++i) {
rhs_.emplace_back(g.data()(range(),i,i));
error_bars_.emplace_back(S.data()(range(),i,i));
results.emplace_back(ci);
}
histograms.resize(gf_dim);
}
// Imaginary frequency
som_core::som_core(gf_const_view<imfreq> g_iw, gf_const_view<imfreq> S_iw,
observable_kind kind, vector<double> const& norms) :
mesh(g_iw.mesh()), kind(kind), norms(make_default_norms(norms,get_target_shape(g_iw)[0])),
rhs(input_data_c_t()), error_bars(input_data_c_t()) {
if(is_stat_relevant(kind)) check_gf_stat(g_iw, observable_statistics(kind));
check_input_gf(g_iw,S_iw);
if(!is_gf_real_in_tau(g_iw) || !is_gf_real_in_tau(S_iw))
fatal_error("imaginary frequency " + observable_name(kind) + " must be real in \\tau-domain");
auto g_iw_pos = positive_freq_view(g_iw);
auto S_iw_pos = positive_freq_view(S_iw);
check_input_gf(g_iw_pos,S_iw_pos);
set_input_data(g_iw_pos,S_iw_pos);
}
gf<retime, Target, Singularity> make_gf_from_inverse_fourier(gf_const_view<refreq, Target, Singularity, Evaluator> const& gw) {
auto gt = gf<retime, Target>{make_mesh_fourier_compatible(gw.mesh()), get_target_shape(gw)};
gt() = inverse_fourier(gw);
return gt;
}
gf<refreq, Target, Singularity> make_gf_from_fourier(gf_const_view<retime, Target, Singularity, Evaluator> const& gt) {
auto gw = gf<refreq, Target>{make_mesh_fourier_compatible(gt.mesh()), get_target_shape(gt)};
gw() = fourier(gt);
return gw;
}
tail fit_tail_impl(gf_view<imfreq> gf, const tail_view known_moments, int n_moments, int n_min, int n_max) {
// precondition : check that n_max is not too large
n_max = std::min(n_max, int(gf.mesh().size()-1));
tail res(get_target_shape(gf));
if (known_moments.size())
for (int i = known_moments.order_min(); i <= known_moments.order_max(); i++) res(i) = known_moments(i);
// if known_moments.size()==0, the lowest order to be obtained from the fit is determined by order_min in known_moments
// if known_moments.size()==0, the lowest order is the one following order_max in known_moments
int n_unknown_moments = n_moments - known_moments.size();
if (n_unknown_moments < 1) return known_moments;
// get the number of even unknown moments: it is n_unknown_moments/2+1 if the first
// moment is even and n_moments is odd; n_unknown_moments/2 otherwise
int omin = known_moments.size() == 0 ? known_moments.order_min() : known_moments.order_max() + 1; // smallest unknown moment
int omin_even = omin % 2 == 0 ? omin : omin + 1;
int omin_odd = omin % 2 != 0 ? omin : omin + 1;
int size_even = n_unknown_moments / 2;
if (n_unknown_moments % 2 != 0 && omin % 2 == 0) size_even += 1;
int size_odd = n_unknown_moments - size_even;
int size1 = n_max - n_min + 1;
// size2 is the number of moments
arrays::matrix<double> A(size1, std::max(size_even, size_odd), FORTRAN_LAYOUT);
arrays::matrix<double> B(size1, 1, FORTRAN_LAYOUT);
arrays::vector<double> S(std::max(size_even, size_odd));
const double rcond = 0.0;
int rank;
for (int i = 0; i < get_target_shape(gf)[0]; i++) {
for (int j = 0; j < get_target_shape(gf)[1]; j++) {
// fit the odd moments
S.resize(size_odd);
A.resize(size1,size_odd); //when resizing, gelss segfaults
for (int k = 0; k < size1; k++) {
auto n = n_min + k;
auto iw = std::complex<double>(gf.mesh().index_to_point(n));
B(k, 0) = imag(gf.data()(gf.mesh().index_to_linear(n), i, j));
// subtract known tail if present
if (known_moments.size() > 0)
B(k, 0) -= imag(evaluate(slice_target(known_moments, arrays::range(i, i + 1), arrays::range(j, j + 1)), iw)(0, 0));
for (int l = 0; l < size_odd; l++) {
int order = omin_odd + 2 * l;
A(k, l) = imag(pow(iw, -1.0 * order)); // set design matrix for odd moments
}
}
arrays::lapack::gelss(A, B, S, rcond, rank);
for (int m = 0; m < size_odd; m++) {
res(omin_odd + 2 * m)(i, j) = B(m, 0);
}
// fit the even moments
S.resize(size_even);
A.resize(size1,size_even); //when resizing, gelss segfaults
for (int k = 0; k < size1; k++) {
auto n = n_min + k;
auto iw = std::complex<double>(gf.mesh().index_to_point(n));
B(k, 0) = real(gf.data()(gf.mesh().index_to_linear(n), i, j));
// subtract known tail if present
if (known_moments.size() > 0)
B(k, 0) -= real(evaluate(slice_target(known_moments, arrays::range(i, i + 1), arrays::range(j, j + 1)), iw)(0, 0));
for (int l = 0; l < size_even; l++) {
int order = omin_even + 2 * l;
A(k, l) = real(pow(iw, -1.0 * order)); // set design matrix for odd moments
}
}
arrays::lapack::gelss(A, B, S, rcond, rank);
for (int m = 0; m < size_even; m++) {
res(omin_even + 2 * m)(i, j) = B(m, 0);
}
}
}
res.mask()()=n_moments;
return res; // return tail
}
gf_view<Variable, Target, tail, Evaluator, C> make_gf_view_from_g_and_tail(gf_impl<Variable, Target, no_tail, Evaluator, V, C> const &g,
tail_view t) {
details::_equal_or_throw(t.shape(), get_target_shape(g));
return {g.mesh(), g.data(), t, g.symmetry(), g.indices(), g.name};
}
gf_view<Variable, Target> make_gf_from_g_and_tail(gf_impl<Variable, Target, S, Evaluator, V, C> const &g, tail t) {
details::_equal_or_throw(t.shape(), get_target_shape(g));
auto g2 = gf<Variable, Target, no_tail>{g}; // copy the function without tail
return {std::move(g2.mesh()), std::move(g2.data()), std::move(t), g2.symmetry()};
}
gf<imtime, Target, Opt> make_gf_from_inverse_fourier(gf_impl<imfreq, Target, Opt, V, C> const& gw, mesh_kind mk = full_bins) {
auto gt = gf<imtime, Target, Opt>{make_mesh_fourier_compatible(gw.mesh(), mk), get_target_shape(gw)};
gt() = inverse_fourier(gw);
return gt;
}
gf<imfreq, Target, Opt> make_gf_from_fourier(gf_impl<imtime, Target, Opt, V, C> const& gt) {
auto gw = gf<imfreq, Target, Opt>{make_mesh_fourier_compatible(gt.mesh()), get_target_shape(gt)};
gw() = fourier(gt);
return gw;
}
