global_initaliser.hpp

#ifndef __CORE_GLOBAL_INITIALLISER_HPP__
#define __CORE_GLOBAL_INITIALLISER_HPP__
 
#include "transitionner/transitionner.hpp"
#include <core/scalar_factory.hpp>
#include <core/simulation_parameters.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 <cstddef>
#include <cstdint>
#include <initializer_list>
#include <mc/unit.hpp>
#include <memory>
#include <optional>
#include <simulation/feed_descriptor.hpp>
#include <simulation/scalar_initializer.hpp>
#include <simulation/simulation.hpp>
#include <string>
#include <vector>
 
 
class ILoadBalancer;
 
namespace Core
{
 
  class GlobalInitialiser
  {
  public:
    template <typename T> using OptionalPtr = std::optional<std::unique_ptr<T>>;
 
    GlobalInitialiser(const ExecInfo& _info, UserControlParameters _user_params);
 
    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=std::nullopt);
 
 
    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);
 
    void 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:
    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;
 
    bool is_host; 
  };
 
} // namespace Core
 
#endif //__CORE_GLOBAL_INITIALLISER_HPP__