matsubara.hh

Go to the documentation of this file.

#pragma once
 
// DiFfRG
#include <DiFfRG/common/kokkos.hh>
#include <DiFfRG/common/math.hh>
 
// C++ standard library
#include <vector>
 
namespace DiFfRG
{
  template <typename NT> class MatsubaraQuadrature
  {
  public:
    int predict_size(const NT T, const NT typical_E = 1., const int step = 2);
 
    MatsubaraQuadrature(const NT T, const NT typical_E = 1., const int step = 2, const int min_size = 0,
                        const int max_size = 256, const int vacuum_quad_size = 48, const int precision_factor = 1);
 
    MatsubaraQuadrature();
 
    void reinit(const NT T, const NT typical_E = 1., const int step = 2, const int min_size = 0,
                const int max_size = 256, const int vacuum_quad_size = 48, const int precision_factor = 1);
 
    size_t size() const;
 
    NT get_T() const;
 
    NT get_typical_E() const;
 
    template <typename F> auto sum(const F &f) const
    {
      auto sum = T * f(static_cast<NT>(0));
      for (int i = 0; i < m_size; ++i)
        sum += host_weights[i] * (f(host_nodes[i]) + f(-host_nodes[i]));
      return sum;
    }
 
    template <typename MemorySpace> Kokkos::View<const NT *, MemorySpace> nodes() const
    {
      if constexpr (std::is_same_v<MemorySpace, Kokkos::DefaultExecutionSpace::memory_space>) {
        return device_nodes;
      } else if constexpr (std::is_same_v<MemorySpace, Kokkos::DefaultHostExecutionSpace::memory_space>) {
        return host_nodes;
      } else {
        throw std::runtime_error("Invalid memory space");
      }
    }
 
    template <typename MemorySpace> Kokkos::View<const NT *, MemorySpace> weights() const
    {
      if constexpr (std::is_same_v<MemorySpace, Kokkos::DefaultExecutionSpace::memory_space>) {
        return device_weights;
      } else if constexpr (std::is_same_v<MemorySpace, Kokkos::DefaultHostExecutionSpace::memory_space>) {
        return host_weights;
      } else {
        throw std::runtime_error("Invalid memory space");
      }
    }
 
  private:
    NT T, typical_E;
 
    Kokkos::View<NT *, GPU_memory> device_nodes;
    Kokkos::View<NT *, GPU_memory> device_weights;
 
    Kokkos::View<NT *, CPU_memory> host_nodes;
    Kokkos::View<NT *, CPU_memory> host_weights;
 
    int m_size;
 
    void write_data(const std::vector<NT> &x, const std::vector<NT> &w);
 
    void reinit_0();
 
    int vacuum_quad_size;
    int precision_factor;
  };
} // namespace DiFfRG