transitionner.hpp

#ifndef __CMA_UTILS_TRANSITIONNER_HPP__
#define __CMA_UTILS_TRANSITIONNER_HPP__
 
#include "cma_read/reactorstate.hpp"
#include "cma_utils/cache_hydro_state.hpp"
#include "cma_utils/iteration_state.hpp"
#include <cma_read/flow_iterator.hpp>
#include <cma_read/neighbors.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