domain.hpp

#ifndef __MC_REACTORDOMAIN_HPP__
#define __MC_REACTORDOMAIN_HPP__
 
#include <Kokkos_Core.hpp>
#include <cassert>
#include <common/common.hpp>
#include <cstddef>
#include <cstdint>
#include <mc/alias.hpp>
#include <mc/traits.hpp>
#include <span>
 
namespace MC
{

  struct LeavingFlow
  {
    using float_type = double;
    std::size_t index;
    float_type flow;
    float_type volume;
  };

  template <typename ExecSpace, bool is_const = true> struct DomainState
  {
    MC::NeighborsView<ExecSpace, is_const> neighbors;
    DiagonalView<ExecSpace, is_const> diag_transition;
    CumulativeProbabilityView<ExecSpace, is_const> cumulative_probability;
    LeavingFlowView<is_const> leaving_flow;
    VolumeView<ExecSpace, is_const> liquid_volume;
    MoveProbabilityView<ExecSpace, is_const> move_probability;
  };

  class ReactorDomain
  {
  public:
    using n_cells_view_type = Kokkos::View<uint64_t*, ComputeSpace>;
    ReactorDomain(const ReactorDomain&) = delete;
    ReactorDomain& operator=(const ReactorDomain&) = delete;

    ReactorDomain();

    ReactorDomain(ReactorDomain&& other) noexcept = default;

    explicit ReactorDomain(std::span<double> volumes);
 
    ReactorDomain(double total_volume, std::size_t size);

    ~ReactorDomain() = default;

    ReactorDomain& operator=(ReactorDomain&& other) noexcept;
 
    void update(std::span<const double> newliquid_volume,
                std::span<const std::size_t> neighors_flat,
                std::span<const double> out_flows,
                std::span<const double> proba_flat);
 
    void set_leaving_flow(std::size_t i,
                          std::size_t i_flow,
                          double flow,
                          double volume) const;

    void set_move_probability(double d_t) const;
 
    void init_inner(std::size_t n_flows);
 
    [[nodiscard]] DomainState<ComputeSpace, true> get_const_inner();

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

    [[nodiscard]] double getTotalVolume() const noexcept;

    template <class Archive>
    void
    save(Archive& ar) const
    {
 
      ar(id, size, _total_volume);
    }
 
    template <class Archive>
    void
    load(Archive& ar)
    {
      ar(id, size, _total_volume);
    }
 
  private:
    double _total_volume = 0.; 
    size_t id = 0;             
    size_t size = 0;           
    DomainState<ComputeSpace, false> inner;

    Kokkos::View<double*, HostSpace> host_liquid_volume;
    Kokkos::View<double*, HostSpace> host_diag_transition;
    Kokkos::View<double*, HostSpace> host_move_probability;

    void setVolumes(std::span<double const> volumes_liq);

    void setLiquidNeighbors(std::size_t e1,
                            std::size_t e2,
                            std::span<const size_t> flat_data);
  };
 
  // inline NeighborsView<ComputeSpace, true> ReactorDomain::getNeighbors() const
  // {
  //   return this->inner.neighbors;
  // }
 
  inline size_t
  ReactorDomain::getNumberCompartments() const noexcept
  {
    return size;
  }
 
  inline double
  ReactorDomain::getTotalVolume() const noexcept
  {
    return this->_total_volume;
  }
 
  [[nodiscard]] inline DomainState<ComputeSpace, true>
  ReactorDomain::get_const_inner()
  {
 
    return {
      inner.neighbors,    inner.diag_transition, inner.cumulative_probability,
      inner.leaving_flow, inner.liquid_volume,   inner.move_probability
    };
  }
 
} // namespace MC
 
#endif //__MC_REACTORDOMAIN_HPP__