utils.hh

Go to the documentation of this file.

#pragma once
 
// standard library
#include <future>
#include <memory>
#include <tbb/tbb.h>
#include <tuple>
#include <vector>
 
// DiFfRG
#include <DiFfRG/discretization/grid/coordinates.hh>
 
namespace DiFfRG
{
  template <typename NT, typename FUN, typename Coordinates, typename... T>
    requires IsCoordinate<Coordinates>
  std::shared_ptr<std::vector<std::future<NT>>> request_data(FUN &fun, Coordinates &coordinates, const double k,
                                                             std::tuple<T...> args)
  {
    return std::apply([&](auto... args) { return request_data<NT>(fun, coordinates, k, args...); }, args);
  }
 
  template <typename NT, typename FUN, typename Coordinates, typename... T>
    requires IsCoordinate<Coordinates>
  std::shared_ptr<std::vector<std::future<NT>>> request_data(FUN &fun, Coordinates &coordinates, const double k,
                                                             T... args)
  {
    auto futures = std::make_shared<std::vector<std::future<NT>>>();
    auto grid = make_grid(coordinates);
 
    auto req_point = [&](auto... p) { return fun.template request<NT>(k, p..., args...); };
 
    for (uint i = 0; i < coordinates.size(); ++i) {
      auto p = grid[i];
      std::apply([&](auto... p) { futures->emplace_back(std::move(req_point(p...))); }, p);
    }
 
    return futures;
  }
 
  template <typename NT, typename FUN, typename GRID, typename... T>
    requires IsContainer<GRID>
  std::shared_ptr<std::vector<std::future<NT>>> request_data(FUN &fun, const GRID &grid, const double k,
                                                             std::tuple<T...> args)
  {
    return std::apply([&](auto... args) { return request_data<NT>(fun, grid, k, args...); }, args);
  }
 
  template <typename NT, typename FUN, typename GRID, typename... T>
    requires IsContainer<GRID>
  std::shared_ptr<std::vector<std::future<NT>>> request_data(FUN &fun, const GRID &grid, const double k, T... args)
  {
    auto futures = std::make_shared<std::vector<std::future<NT>>>();
 
    auto req_point = [&](auto... p) { return fun.template request<NT>(k, p..., args...); };
 
    for (uint i = 0; i < grid.size(); ++i) {
      auto p = grid[i];
      if constexpr (std::is_same_v<decltype(p), double> || std::is_same_v<decltype(p), float>)
        futures->emplace_back(std::move(req_point(p)));
      else
        std::apply([&](auto... p) { futures->emplace_back(std::move(req_point(p...))); }, p);
    }
 
    return futures;
  }
 
  template <typename NT1, typename NT2, typename... T>
  void update_data(std::shared_ptr<std::vector<std::future<NT1>>> futures, NT2 *destination)
  {
    for (uint i = 0; i < futures->size(); ++i)
      destination[i] = static_cast<NT2>((*futures)[i].get());
  }
 
  template <typename NT, typename INT, typename... T>
  void update_interpolator(std::shared_ptr<std::vector<std::future<NT>>> futures, INT &destination)
  {
    for (uint i = 0; i < futures->size(); ++i)
      destination[i] = (*futures)[i].get();
    destination.update();
  }
 
  template <typename NT, typename FUN, typename GRID, typename... T>
  void get_data(NT *dest, FUN &fun, const GRID &grid, const double k, std::tuple<T...> args)
  {
    std::apply([&](auto... args) { get_data<NT>(dest, fun, grid, k, args...); }, args);
  }
 
  template <typename NT, typename FUN, typename GRID, typename... T>
  void get_data(NT *dest, FUN &fun, const GRID &grid, const double k, T... args)
  {
    auto req_point = [&](auto... p) { return fun.template get<NT>(k, p..., args...); };
 
    // for (uint i = 0; i < grid.size(); ++i) {
    tbb::parallel_for(tbb::blocked_range<uint>(0, grid.size()), [&](const tbb::blocked_range<uint> &r) {
      for (uint i = r.begin(); i < r.end(); ++i) {
        auto p = grid[i];
        if constexpr (std::is_same_v<decltype(p), double> || std::is_same_v<decltype(p), float>)
          dest[i] = req_point(p);
        else
          std::apply([&](auto... p) { dest[i] = req_point(p...); }, p);
      }
    });
  }
 
} // namespace DiFfRG