global_initaliser.hpp

#ifndef __CORE_GLOBAL_INITIALLISER_HPP__
#define __CORE_GLOBAL_INITIALLISER_HPP__
 
#include "common/logger.hpp"
#include <array>
#include <cma_utils/alias.hpp>
#include <common/execinfo.hpp>
#include <core/scalar_factory.hpp>
#include <core/simulation_parameters.hpp>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <mc/unit.hpp>
#include <memory>
#include <optional>
#include <simulation/feed_descriptor.hpp>
#include <simulation/mass_transfer.hpp>
#include <simulation/scalar_initializer.hpp>
// #include <simulation/simulation.hpp>
#include <string>
// #include <transitionner/transitionner.hpp>
#include <vector>
 
class ILoadBalancer;
 
namespace Simulation
{
  class SimulationUnit;
}
 
namespace Core
{

  class GlobalInitialiser
  {
  public:
    template <typename T> using OptionalPtr = std::optional<std::unique_ptr<T>>;

    GlobalInitialiser(const ExecInfo& _info,
                      UserControlParameters _user_params,
                      std::shared_ptr<IO::Logger> = nullptr);

    // OptionalPtr<CmaRead::FlowIterator> init_flow_iterator();

    std::optional<bool>
    init_state(const CmaUtils::TransitionnerPtrType& transiionner);
 
    // /**
    //  * @brief Initializes a transitioner with the provided flow iterator.
    //  *
    //  * @param flow_handle A unique pointer to the flow iterator.
    //  * @return An optional unique pointer to the initialized flow map
    //  * transitioner.
    //  */
    // std::optional<CmaUtils::TransitionnerPtrType>
    // init_transitionner(std::unique_ptr<CmaRead::FlowIterator>&& flow_handle);

    std::optional<CmaUtils::TransitionnerPtrType> init_transitionner();

    OptionalPtr<Simulation::SimulationUnit>
    init_simulation(std::optional<Core::ScalarFactory::ScalarVariant> variant);

    OptionalPtr<Simulation::SimulationUnit>
    init_simulation(std::unique_ptr<MC::MonteCarloUnit> _unit,
                    const Simulation::ScalarInitializer& scalar_init);

    std::optional<Simulation::ScalarInitializer> init_scalar();
 
    std::optional<Simulation::ScalarInitializer>
    init_scalar(Core::ScalarFactory::ScalarVariant&& variant);
 
    // Use optional bcause we need to validate step even if theres no mtr
    std::optional<bool> init_mtr_model(
        Simulation::SimulationUnit& unit,
        std::optional<Simulation::MassTransfer::Type::MtrTypeVariant>&&
            variant);

    bool init_feed(
        std::optional<Simulation::Feed::SimulationFeed> feed = std::nullopt);

    OptionalPtr<MC::MonteCarloUnit> init_monte_carlo();

    [[nodiscard]] bool check_init_terminate() const;
 
    [[nodiscard]] SimulationParameters get_parameters() const;
 
    void set_initial_number_particle(uint64_t np) noexcept;
 
  private:
    void set_logger(std::shared_ptr<IO::Logger> _logger);

    enum class InitStep : std::size_t
    {
      // FlowIterator = 0, ///< Step for initializing the flow iterator.
      Transitioner = 0, 
      InitState,        
      Scalar,           
      Feed,             
      MC,               
      SimulationUnit,   
      MTR,
      Count 
    };

    std::array<bool, static_cast<size_t>(InitStep::Count)> validated_steps{};

    template <typename... Args>
    [[nodiscard]] bool check_steps(InitStep step, Args... args) const
    {
      if (!validated_steps[static_cast<size_t>(step)]) // NOLINT
      {
        return false;
      }
 
      return (... && validated_steps[static_cast<size_t>(args)]);
    }

    template <typename... Args> void validate_step(InitStep step, Args... args)
    {
      validated_steps[static_cast<size_t>(step)] = true; // NOLINT
      (void)std::initializer_list<int>{
          (validated_steps[static_cast<size_t>(args)] = true, 0)...};
    }

    // CmtCommons::cma_exported_paths_t
    // get_path_files(const std::string& cma_case_path);

    std::optional<bool>
    host_init_state(const CmaUtils::TransitionnerPtrType& transiionner);

    void mpi_broadcast(); 
 
    ExecInfo info;
    SimulationParameters params;
 
    UserControlParameters user_params;
 
    struct inner
    {
    };

    uint64_t particle_per_process;
    std::vector<double> liquid_volume;
    std::vector<double> gas_volume;
    // CmaRead::Neighbors::Neighbors_const_view_t liquid_neighbors;
 
    std::vector<std::size_t> flat_neighobrs;
 
    double t_per_flowmap{};
    // std::vector<size_t> worker_neighbor_data;
    bool f_init_gas_flow;
    std::optional<Simulation::Feed::SimulationFeed> feed;
    std::shared_ptr<IO::Logger> logger;

 
    bool is_host; 
  };
 
} // namespace Core
 
#endif //__CORE_GLOBAL_INITIALLISER_HPP__