global_initaliser.hpp

#ifndef __CORE_GLOBAL_INITIALLISER_HPP__
#define __CORE_GLOBAL_INITIALLISER_HPP__
 
#include "common/logger.hpp"
#include <array>
#include <cma_read/flow_iterator.hpp>
#include <cma_read/neighbors.hpp>
#include <cmt_common/cma_case.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(std::unique_ptr<CmaRead::FlowIterator>& flow_handle);

    OptionalPtr<CmaUtils::FlowMapTransitionner>
    init_transitionner(std::unique_ptr<CmaRead::FlowIterator>&& flow_handle);

    OptionalPtr<CmaUtils::FlowMapTransitionner> 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);
 
    std::optional<bool>
    init_mtr_model(Simulation::SimulationUnit& unit,
                   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, 
      Transitioner,     
      InitState,        
      Scalar,           
      Feed,             
      MC,               
      SimulationUnit,   
      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(std::unique_ptr<CmaRead::FlowIterator>& flow_handle);

    void mpi_broadcast(); 
 
    ExecInfo info;
    SimulationParameters params;
 
    UserControlParameters user_params;

    uint64_t particle_per_process;
    std::vector<double> liquid_volume;
    std::vector<double> gas_volume;
    CmaRead::Neighbors::Neighbors_const_view_t liquid_neighbors;
    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__