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/traits.hpp>
#include <span>
 
namespace MC
{
  template <typename Space>
  using NeighborsView =
      Kokkos::View<std::size_t**,
                   Kokkos::LayoutRight,
                   Space,
                   Kokkos::MemoryTraits<Kokkos::RandomAccess>>;

  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;

    ReactorDomain(std::span<double> volumes,
                  const NeighborsView<HostSpace>& _neighbors);
    ~ReactorDomain() = default;

    ReactorDomain& operator=(ReactorDomain&& other) noexcept;

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

    void setLiquidNeighbors(const NeighborsView<HostSpace>& data);

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

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

    [[nodiscard]] ConstNeighborsView<ComputeSpace> getNeighbors() const;

    [[deprecated("Not needed anymore")]] static ReactorDomain
    reduce(std::span<const size_t> data, size_t original_size, size_t n_rank);
 
    [[deprecated("Not needed anymore")]] void in_place_reduce(
        std::span<const size_t> data, size_t original_size, size_t n_rank);
 
    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;           
    NeighborsView<ComputeSpace> k_neighbor;
  };
 
  inline ConstNeighborsView<ComputeSpace> ReactorDomain::getNeighbors() const
  {
    return k_neighbor;
  }
 
  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__