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>
#include <type_traits>
 
namespace MC
{
 
  struct LeavingFlow
  {
    std::size_t index;
    double flow;
  };
 
  template <typename ExecSpace, bool is_const = true> struct MoveInfo
  {
    // Kokkos::View<std::size_t**, Kokkos::LayoutRight, ExecSpace> neighbors;
    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;
 
    // template <bool B = is_const>
    //   requires(!B)
    // explicit MoveInfo() : MoveInfo(0, 0)
    // {
    // }
 
    // template <bool B = is_const>
    //   requires(B)
    // explicit MoveInfo()
    // {
    // }
 
    // template <bool B = is_const>
    //   requires(!B)
    // explicit MoveInfo(const std::size_t n_compartments, const std::size_t
    // n_flows)
    //     : neighbors("neighbors", 0, 0),
    //       diag_transition("diag_transition", n_compartments),
    //       leaving_flow("leaving_flow", n_flows),
    //       liquid_volume("liquid_volume", n_compartments)
 
    // {
    // }
  };

  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) const;
 
    void init_inner(const std::size_t n_flows);
 
    [[nodiscard]] MoveInfo<ComputeSpace, true> get_const_inner()
    {
      return {inner.neighbors,
              inner.diag_transition,
              inner.cumulative_probability,
              inner.leaving_flow,
              inner.liquid_volume};
    }

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

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

    // [[nodiscard]] NeighborsView<ComputeSpace, true> getNeighbors() const;
 
    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);
    }
    MoveInfo<ComputeSpace, false> inner;
 
  private:
    double _total_volume = 0.; 
    size_t id = 0;             
    size_t size = 0;           

    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;
  }
 
} // namespace MC
 
#endif //__MC_REACTORDOMAIN_HPP__