mcinit.hpp

#ifndef __MC_INIT_HPP__
#define __MC_INIT_HPP__
 
#include "mc/prng/prng.hpp"
#include <biocma_cst_config.hpp>
#include <cassert>
#include <common/execinfo.hpp>
#include <common/logger.hpp>
#include <cstdint>
#include <mc/domain.hpp>
#include <mc/particles_container.hpp>
#include <mc/traits.hpp>
#include <mc/unit.hpp>
#include <memory>
#include <span>
#include <stdexcept>
#include <utility>
 
namespace
{
  template <ModelType Model>
  void
  log_model_info(const std::shared_ptr<IO::Logger>& _logger)
  {
    if constexpr (ConstWeightModelType<Model>)
    {
      if (_logger)
      {
        if constexpr (has_name<Model>)
        {
          _logger->print("Model", IO::format(Model::name, " Const Weights"));
        }
        else
        {
          _logger->print("Model", "Const Weights");
        }
      }
    }
  }
} // namespace
 
namespace MC
{
 
  void impl_init(const ExecInfo& info,
 
                 double& total_mass,
                 uint64_t n_particles,
                 MonteCarloUnit& unit,
                 AutoGenerated::ContainerVariant&& container,
                 bool uniform_init);
 
  void post_init_weight(std::unique_ptr<MonteCarloUnit>& unit,
                        double x0,
                        double total_mass);
  template <ModelType Model>
  std::unique_ptr<MonteCarloUnit>
  init(const std::shared_ptr<IO::Logger>& _logger,
       const ExecInfo& info,
       uint64_t n_particles,
       std::size_t seed,
       std::span<double> volumes,
       std::span<const size_t> _neighbors,
       bool uniform_mc_init,
       double& total_mass)
  {
    (void)_neighbors; // TODO remove
    log_model_info<Model>(_logger);
 
    auto unit = std::make_unique<MonteCarloUnit>();
    unit->domain = ReactorDomain(volumes);
    unit->rng = KPRNG(seed);
 
    ParticlesContainer<Model> container(load_tuning_constant(), n_particles);
    try
    {
      impl_init(info,
                total_mass,
                n_particles,
                *unit,
                std::move(container),
                uniform_mc_init);
    }
    catch (const std::runtime_error& e)
    {
 
      if (_logger)
      {
        _logger->error(e.what());
      }
 
      return nullptr;
    }
 
    return unit;
  }
 
} // namespace MC
 
#endif //__MC_INIT_HPP__