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 <cstdint>
#include <mc/alias.hpp>
#include <mc/macros.hpp>
#include <mc/prng/prng.hpp>
#include <type_traits>
#include <optional> 
 
 
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;
}
 
namespace MC
{
 
  // NOLINTBEGIN(hicpp-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
  template <uint64_t Nd, FloatingPointType F> using ParticlesModel = Kokkos::View<F* [Nd]>;
  template <FloatingPointType F> using DynParticlesModel = Kokkos::View<F**>;
  // NOLINTEND(hicpp-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
 
}; // namespace MC
 
template <typename T>
concept ConfigurableInit = requires(T model,
                                     const MC::KPRNG::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>;
};
 
template <typename T>
concept NonConfigurableInit = requires(T model,
                                        const MC::KPRNG::pool_type& random_pool,
                                        std::size_t idx,
                                        const typename T::SelfParticle& arr) {
  { model.init(random_pool, idx, arr) } -> std::same_as<void>;
};
 
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::KPRNG::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, std::nullopt_t> && 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>; 
 
  {
    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