evaluate.hpp

Go to the documentation of this file.

// Copyright (c) 2022-2023 Simons Foundation
//
// This program 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.
//
// This program 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 may obtain a copy of the License at
//     https://www.gnu.org/licenses/gpl-3.0.txt
//
// Authors: Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./concepts.hpp"
#include "./prod.hpp"
#include "./utils.hpp"
 
#include <nda/nda.hpp>
 
#include <tuple>
#include <utility>
 
namespace triqs::mesh {

 
  namespace detail {
 
    // Create a new tuple by removing the first element of a given tuple.
    template <typename T>
      requires(std::tuple_size_v<T> >= 1)
    auto pop_front_tuple(T const &tup) {
      return [&]<size_t... Is>(std::index_sequence<Is...>) {
        return std::tie(std::get<Is + 1>(tup)...);
      }(std::make_index_sequence<std::tuple_size_v<T> - 1>{});
    }
  } // namespace detail

  template <Mesh M> FORCEINLINE auto evaluate(M const &, auto const &f, typename M::index_t const &n) { return f(n); }

  template <typename T> FORCEINLINE auto evaluate(Mesh auto const &, auto const &f, mesh::closest_mesh_point_t<T> const &cmp) { return f(cmp); }

  FORCEINLINE auto evaluate(Mesh auto const &, auto const &f, nda::range::all_t) { return f(nda::range::all_t{}); }

  template <Mesh M> FORCEINLINE auto evaluate(M const &m, auto const &f, typename M::mesh_point_t const &mp) {
    if constexpr (MeshWithValues<M>) {
      return evaluate(m, f, mp.value());
    } else {
      return f(mp);
    }
  }

  template <typename... Ds, typename X1, typename... Xs>
  FORCEINLINE auto evaluate(std::tuple<Ds...> const &tup, auto const &f, X1 const &x1, Xs const &...xs) {
    auto const &d1 = std::get<0>(tup);
    if constexpr (sizeof...(Ds) > 1) {
      return evaluate(
         detail::pop_front_tuple(tup),
         [f, &x1, &d1](auto const &...ys) __attribute__((always_inline)) {
           return evaluate(d1, [f, &ys...](auto const &y1) __attribute__((always_inline)) { return f(y1, ys...); }, x1);
         },
         xs...);
    } else {
      return evaluate(d1, f, x1);
    }
  }

  template <Mesh... Ms, typename... Xs> FORCEINLINE auto evaluate(mesh::prod<Ms...> const &m, auto const &f, Xs const &...xs) {
    return evaluate(m.components(), f, xs...);
  }

 
} // namespace triqs::mesh