transitionner.hpp

#ifndef __CMA_UTILS_TRANSITIONNER_HPP__
#define __CMA_UTILS_TRANSITIONNER_HPP__
 
#include <cma_read/flow_iterator.hpp>
#include <cma_read/neighbors.hpp>
#include <cma_read/reactorstate.hpp>
#include <cma_utils/cache_hydro_state.hpp>
#include <cma_utils/iteration_state.hpp>
#include <cstddef>
#include <memory>
#include <transitionner/proxy_cache.hpp>
 
namespace CmaUtils
{
  enum class FlowmapTransitionMethod : char
  {
    Discontinuous,  
    InterpolationFO 
  };
 
  // Forward declaration
  class ProxyPreCalculatedHydroState;

  class FlowMapTransitionner
  {
  public:
    FlowMapTransitionner() = default;
    FlowMapTransitionner& operator=(FlowMapTransitionner&&) = default;
    FlowMapTransitionner(FlowMapTransitionner&&) = default;
 
    FlowMapTransitionner& operator=(const FlowMapTransitionner&) = delete;
    FlowMapTransitionner(const FlowMapTransitionner&) = delete;
 
    FlowMapTransitionner(std::size_t _n_flowmap,
                         std::size_t _n_per_flowmap,
                         std::size_t number_time_step,
                         std::unique_ptr<CmaRead::FlowIterator>&& _iterator,
                         bool is_two_phase_flow);
 
    virtual ~FlowMapTransitionner() = default;

    IterationState advance();

    IterationState
    advance_worker(std::span<double> flows,
                   std::span<double> volumeLiq,
                   std::span<double> volumeGas,
                   const CmaRead::Neighbors::Neighbors_const_view_t& neighbors);

    [[nodiscard]] bool is_two_phase_flow() const noexcept;

    [[nodiscard]] std::size_t get_n_timestep() const noexcept;

    [[nodiscard]] virtual const CmaRead::ReactorState&
    get_current_reactor_state() const noexcept = 0;

    static NeighborsView<HostSpace> get_neighbors_view(
        const CmaRead::Neighbors::Neighbors_const_view_t& liquid_neighbors);
 
  protected:
    [[nodiscard]] bool need_liquid_state_calculation() const noexcept;

    IterationState common_advance(
        NeighborsView<HostSpace> host_view,
        std::unordered_map<std::string, std::span<const double>>&& info);

    virtual void update_flow() = 0;

    void update_flow_worker(
        std::span<double> flows,
        std::span<double> volumeLiq,
        std::span<double> volumeGas,
        const CmaRead::Neighbors::Neighbors_const_view_t& neighbors);

    virtual CmaUtils::ProxyPreCalculatedHydroState&
    current_liq_hydro_state() = 0;
    virtual CmaUtils::ProxyPreCalculatedHydroState&
    current_gas_hydro_state() = 0;

    void calculate_full_state(
        const CmaRead::ReactorState& reactor_state,
        CmaUtils::ProxyPreCalculatedHydroState& liq_hydro_state,
        CmaUtils::ProxyPreCalculatedHydroState& gas_hydro_state) const;

    [[nodiscard]] size_t getFlowIndex() const noexcept;

    [[nodiscard]] size_t size() const noexcept;

    [[nodiscard]] const CmaRead::ReactorState&
    get_unchecked(size_t index) const noexcept;
 
    // Buffer for caching, vector have the same size which is the number of
    // flowmap read from case
    std::vector<CmaUtils::ProxyPreCalculatedHydroState>
        liquid_pc; 
    std::vector<CmaUtils::ProxyPreCalculatedHydroState>
        gas_pc; 
 
  private:
    void update_counters();
 
    bool two_phase_flow{};          
    std::size_t n_per_flowmap{};    
    std::size_t n_flowmap{};        
    std::size_t n_timestep{};       
    std::size_t repetition_count{}; 
    std::size_t
        current_flowmap_count{}; 
    std::unique_ptr<CmaRead::FlowIterator>
        iterator; 
  };
 
  [[nodiscard]] inline size_t
  FlowMapTransitionner::getFlowIndex() const noexcept
  {
    // Modulo is used to select correct index into buffers.
    // During the first loop we have repetition_count<n_flowmap but after
    // looping we have repetition_count>n_flowmap
    return this->repetition_count % this->n_flowmap;
  }
 
  [[nodiscard]] inline size_t FlowMapTransitionner::size() const noexcept
  {
    return iterator->size();
  }
 
  [[nodiscard]] inline bool
  FlowMapTransitionner::is_two_phase_flow() const noexcept
  {
    return two_phase_flow;
  }
 
  [[nodiscard]] inline bool
  FlowMapTransitionner::need_liquid_state_calculation() const noexcept
  {
    // We need to calculated new state if:
    //- it is the first time we have this flowmap (this->current_flowmap_count)
    //  We have not already looped through all the flowmap
    return repetition_count < n_flowmap && this->current_flowmap_count == 0;
  }
 
  [[nodiscard]] inline const CmaRead::ReactorState&
  FlowMapTransitionner::get_unchecked(const std::size_t index) const noexcept
  {
    return iterator->get_unchecked(index);
  };
 
}; // namespace CmaUtils
 
#endif