simple_model.hpp

#ifndef __SIMPLE_MODEL_HPP__
#define __SIMPLE_MODEL_HPP__
 
#include "common/traits.hpp"
#include "models/uptake_dyn.hpp"
#include "models/utils.hpp"
#include <mc/prng/prng_extension.hpp>
#include <mc/traits.hpp>
#include <models/uptake.hpp>
#include <optional>
#include <string_view>
 
namespace Models
{
  template <FloatingPointType F>
  static F consteval get_phi_s_max(F density, F dl)
  {
    // dl and density must be same unit, dl*density -> mass and y is mass yield
    return (dl * density) * 0.5;
  }
  struct SimpleModel
  {
    using uniform_weight = std::true_type; // Using type alias
    using Self = SimpleModel;
    using FloatType = float;
    using Config = std::nullopt_t;
 
    enum class particle_var : int
    {
      length = INDEX_FROM_ENUM(Uptakeparticle_var::COUNT),
      age,
      phi_s,
      t_div,
      COUNT
    };
 
    static constexpr std::size_t n_var = INDEX_FROM_ENUM(particle_var::COUNT);
    static constexpr std::string_view name = "simple";
    using SelfParticle = MC::ParticlesModel<Self::n_var, Self::FloatType>;
 
    MODEL_CONSTANT FloatType l_max_m = 5e-6;   // m
    MODEL_CONSTANT FloatType l_c_m = 3e-6;     // m
    MODEL_CONSTANT FloatType d_m = 0.6e-6;     // m
    MODEL_CONSTANT FloatType l_min_m = 0.9e-6; // m
    MODEL_CONSTANT FloatType lin_density
        = c_linear_density(static_cast<FloatType>(1000), d_m);
 
    MODEL_CONSTANT FloatType phi_s_max
        = get_phi_s_max<FloatType>(lin_density, 8 * 2e-10); // kgS/s
 
    MODEL_CONSTANT FloatType phi_perm_max = phi_s_max / 40.; // kgS/
 
    MODEL_CONSTANT FloatType frequency_division = 1. / 1000; // Hz
 
    KOKKOS_INLINE_FUNCTION static void init(const MC::pool_type& random_pool,
                                            std::size_t idx,
                                            const SelfParticle& arr);
 
    KOKKOS_INLINE_FUNCTION static MC::Status
    update(const MC::pool_type& random_pool,
           FloatType d_t,
           std::size_t idx,
           const SelfParticle& arr,
           const MC::LocalConcentration& c);
 
    KOKKOS_INLINE_FUNCTION static void
    division(const MC::pool_type& random_pool,
             std::size_t idx,
             std::size_t idx2,
             const SelfParticle& arr,
             const SelfParticle& buffer_arr);
 
    KOKKOS_INLINE_FUNCTION static void
    contribution(std::size_t idx,
                 std::size_t position,
                 double weight,
                 const SelfParticle& arr,
                 const MC::ContributionView& contributions);
 
    KOKKOS_INLINE_FUNCTION static double
    mass(std::size_t idx, const SelfParticle& arr)
    {
      return GET_PROPERTY(SimpleModel::particle_var::length) * lin_density;
    }
 
    // inline constexpr static std::array<std::string_view, n_var> names()
    // {
    //   constexpr std::size_t ln_var = n_var - Uptake<SimpleModel>::n_var;
    //   constexpr auto _names = concat_arrays<Uptake<SimpleModel>::n_var,
    //   ln_var>(
    //       Uptake<SimpleModel>::names(), {"length", "age", "phi_s", "t_div"});
 
    //   return _names;
    // }
  };
 
  CHECK_MODEL(SimpleModel)
 
  KOKKOS_INLINE_FUNCTION void
  SimpleModel::init([[maybe_unused]] const MC::pool_type& random_pool,
                    std::size_t idx,
                    const SelfParticle& arr)
  {
    MODEL_CONSTANT auto division_time_d
        = MC::Distributions::TruncatedNormal<FloatType>(
            500,
            500. / 2.,
            10,
            1200); //-Kokkos::log(random_number) / frequency_division;
    MODEL_CONSTANT auto l_distribution
        = MC::Distributions::TruncatedNormal<FloatType>(
            l_min_m, l_min_m / 5., l_min_m * 0.5, l_max_m);
    auto gen = random_pool.get_state();
    arr(idx, static_cast<int>(particle_var::length)) = l_distribution.draw(gen);
    GET_PROPERTY(SimpleModel::particle_var::t_div) = division_time_d.draw(gen);
    random_pool.free_state(gen);
    arr(idx, static_cast<int>(particle_var::age)) = 0;
    arr(idx, static_cast<int>(particle_var::phi_s)) = 0;
 
    Uptake<UptakeDefault<typename Self::FloatType>, SimpleModel>::init(
        random_pool, idx, arr);
  }
 
  KOKKOS_INLINE_FUNCTION MC::Status
  SimpleModel::update([[maybe_unused]] const MC::pool_type& random_pool,
                      FloatType d_t,
                      std::size_t idx,
                      const SelfParticle& arr,
                      const MC::LocalConcentration& c)
  {
 
    const auto phi_s
        = Uptake<UptakeDefault<typename Self::FloatType>,
                 SimpleModel>::uptake_step(phi_s_max, d_t, idx, arr, c);
 
    GET_PROPERTY(SimpleModel::particle_var::age) += d_t;
    GET_PROPERTY(SimpleModel::particle_var::phi_s) = phi_s;
 
    return (GET_PROPERTY(SimpleModel::particle_var::t_div)
            <= GET_PROPERTY(SimpleModel::particle_var::age))
               ? MC::Status::Division
               : MC::Status::Idle;
  }
 
  KOKKOS_INLINE_FUNCTION void
  SimpleModel::division(const MC::pool_type& random_pool,
                        std::size_t idx,
                        std::size_t idx2,
                        const SelfParticle& arr,
                        const SelfParticle& buffer_arr)
  {
 
    const FloatType new_current_length
        = arr(idx, static_cast<int>(particle_var::length))
          / static_cast<FloatType>(2.);
    buffer_arr(idx2, static_cast<int>(particle_var::length))
        = new_current_length;
    arr(idx, static_cast<int>(particle_var::length)) = new_current_length;
 
    arr(idx, static_cast<int>(particle_var::age)) = 0;
    buffer_arr(idx2, static_cast<int>(particle_var::age)) = 0;
 
    // auto gen = random_pool.get_state();
    //  GET_PROPERTY_FROM(idx2, buffer_arr, SimpleModel::particle_var::t_div) =
    //  division_time_d.draw(gen);
    //  GET_PROPERTY(SimpleModel::particle_var::t_div) =
    //  division_time_d.draw(gen); random_pool.free_state(gen);
 
    Uptake<UptakeDefault<typename Self::FloatType>, SimpleModel>::division(
        random_pool, idx, idx2, arr, buffer_arr);
  }
 
  KOKKOS_INLINE_FUNCTION void
  SimpleModel::contribution([[maybe_unused]] std::size_t idx,
                            std::size_t position,
                            double weight,
                            [[maybe_unused]] const SelfParticle& arr,
                            const MC::ContributionView& contributions)
  {
    auto access = contributions.access();
    access(position, 0)
        += -weight * GET_PROPERTY(SimpleModel::particle_var::phi_s); // NOLINT
  }
 
} // namespace Models
 
#endif