traits.hpp

#ifndef __MODELS_TRAITS_HPP__
#define __MODELS_TRAITS_HPP__
 
#include <Kokkos_Core_fwd.hpp>
#include <Kokkos_Random.hpp>
#include <Kokkos_ScatterView.hpp>
#include <common/common.hpp>
#include <common/traits.hpp>
#include <concepts>
#include <mc/alias.hpp>
#include <mc/macros.hpp>
#include <mc/prng/prng.hpp>
#include <optional>
#include <type_traits>

template <std::size_t N1, std::size_t N2>
constexpr std::array<std::string_view, N1 + N2>
concat_arrays(const std::array<std::string_view, N1>& arr1,
              const std::array<std::string_view, N2>& arr2)
{
  std::array<std::string_view, N1 + N2> result;
  std::copy(arr1.begin(), arr1.end(), result.begin());
  std::copy(arr2.begin(), arr2.end(), result.begin() + N1);
  return result;
}
 
template <typename T>
concept ConfigurableInit = requires(T model,
                                    const std::size_t size,
                                    const MC::pool_type& random_pool,
                                    std::size_t idx,
                                    const typename T::SelfParticle& arr,
                                    const T::Config& config) {
  { model.init(random_pool, idx, arr, config) } -> std::same_as<void>;
 
  { model.get_config(size) } -> std::same_as<typename T::Config>;
};
 
template <typename T>
concept NonConfigurableInit = requires(T model,
                                       const MC::pool_type& random_pool,
                                       std::size_t idx,
                                       const typename T::SelfParticle& arr) {
  { model.init(random_pool, idx, arr) } -> std::same_as<void>;
};
using NonConfigType = std::nullopt_t;
template <typename T, typename ViewType>
concept CommonModelType = requires(T model,
                                   T::FloatType d_t,
                                   std::size_t idx,
                                   std::size_t idx2,
                                   double weight,
                                   const T::SelfParticle& arr,
                                   const T::SelfParticle& buffer_arr,
                                   const MC::LocalConcentration& c,
                                   std::size_t position,
                                   const MC::ContributionView& contributions,
                                   const MC::pool_type& random_pool,
                                   const T::Config& config) {
  {
    T::n_var
  } -> std::convertible_to<std::size_t>; 
  typename T::FloatType; 
  typename T::SelfParticle; 
  typename T::Self;         
  typename T::Config;       
 
  // Check if the model is configurable
  // requires(std::is_same_v<typename T::Config, std::nullopt_t> ?
  // NonConfigurableInit<T>
  //                                                             :
  //                                                             ConfigurableInit<T>);
 
  requires ConfigurableInit<T> ||
               (std::is_same_v<typename T::Config, NonConfigType> &&
                NonConfigurableInit<T>);
 
  // {
  //   T::init(random_pool, idx, arr, config)
  // } -> std::same_as<void>; ///< Main init function applied to each MC
  // particle at the begin of the
  //                          ///< simulation
 
  {
    T::mass(idx, arr)
  } -> std::same_as<double>; 
 
  {
    T::update(random_pool, d_t, idx, arr, c)
  } -> std::convertible_to<MC::Status>; 
 
  // {
  //   T::contribution(idx, position, weight, arr, contributions)
  // } -> std::same_as<void>; ///< Get the individual contribution for the MC
  // particle
 
  { T::get_bounds() } -> std::same_as<MC::ContribIndexBounds>;
 
  {
    T::division(random_pool, idx, idx2, arr, buffer_arr)
  } -> std::same_as<void>; 
 
  requires FloatingPointType<typename T::FloatType>;
};

template <typename T>
concept FixedModelType =
    CommonModelType<T, MC::ParticlesModel<T::n_var, typename T::FloatType>>;

template <typename T>
concept DynModelType =
    CommonModelType<T, MC::DynParticlesModel<typename T::FloatType>>;

template <typename T>
concept ModelType = DynModelType<T> || FixedModelType<T>;
 
template <typename T>
concept NonConfigurableModel = ModelType<T> && NonConfigurableInit<T>;
 
template <typename T>
concept ConfigurableModel = ModelType<T> && ConfigurableInit<T>;

template <std::size_t n, typename T>
concept _HasExportProperties = requires(const T obj) {
  { T::names() } -> std::convertible_to<std::array<std::string_view, n>>;
};

template <typename T>
concept HasExportPropertiesFull = FixedModelType<T> && requires(const T obj) {
  { T::names() } -> std::convertible_to<std::array<std::string_view, T::n_var>>;
};

template <typename T>
concept HasExportPropertiesPartial = ModelType<T> && requires(const T obj) {
  { T::names() } -> std::convertible_to<std::vector<std::string_view>>;
  { T::get_number() } -> std::convertible_to<std::vector<std::size_t>>;
};

template <typename T>
concept HasExportProperties =
    HasExportPropertiesFull<T> || HasExportPropertiesPartial<T>;
 
// Helper to detect if `uniform_weight` exists as a type alias (using `using`
// keyword)
template <typename T, typename = void>
struct has_uniform_weight : std::false_type
{
};
 
template <typename T>
struct has_uniform_weight<T, std::void_t<typename T::uniform_weight>>
    : std::true_type
{
};

template <typename T>
concept ConstWeightModelType = ModelType<T> && has_uniform_weight<T>::value;

template <typename T>
concept PreInitModel = ModelType<T> && requires(T model) { T::preinit(); };
 
#endif