volume_descriptor.hpp

// This file is part of the ACTS project.
//
// Copyright (C) 2016 CERN for the benefit of the ACTS project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
#pragma once
 
// Project include(s)
#include "detray/definitions/detail/qualifiers.hpp"
#include "detray/definitions/geometry.hpp"
#include "detray/definitions/indexing.hpp"
 
// System include(s)
#include <ostream>
#include <utility>
 
namespace detray {

template <typename ID, typename acc_link_t = dtyped_index<dindex, dindex>,
          typename mat_link_t = dtyped_index<dindex, dindex>>
class volume_descriptor {
 public:
  using object_id = ID;

  using sf_link_type =
      dmulti_index<dindex_range,
                   static_cast<std::size_t>(
                       static_cast<std::underlying_type_t<surface_id>>(
                           surface_id::e_all))>;

  using accel_link_type = dmulti_index<acc_link_t, ID::e_size>;

  using material_link = mat_link_t;
  using material_id = typename material_link::id_type;

  constexpr volume_descriptor() = default;

  explicit constexpr volume_descriptor(const volume_id id) : m_id{id} {}

  static consteval bool is_surface_id(const object_id id) {
    return (id == object_id::e_portal || id == object_id::e_sensitive ||
            id == object_id::e_passive);
  }

  static consteval bool is_volume_id(const object_id id) {
    return (id == object_id::e_volume);
  }

  DETRAY_HOST_DEVICE
  constexpr auto id() const -> volume_id { return m_id; }

  DETRAY_HOST_DEVICE
  constexpr auto index() const -> dindex { return m_index; }

  DETRAY_HOST
  constexpr auto set_index(const dindex index) -> void { m_index = index; }

  DETRAY_HOST_DEVICE
  constexpr auto transform() const -> dindex { return m_transform; }

  DETRAY_HOST
  constexpr auto set_transform(const dindex trf_idx) -> void {
    m_transform = trf_idx;
  }

  DETRAY_HOST_DEVICE constexpr auto sf_link() const -> const sf_link_type& {
    return m_sf_links;
  }

  template <surface_id id>
  DETRAY_HOST_DEVICE constexpr auto sf_link() const -> const
      typename sf_link_type::index_type& {
    return detail::get<static_cast<uint>(id)>(m_sf_links);
  }

  template <surface_id id>
  DETRAY_HOST_DEVICE constexpr auto sf_link() ->
      typename sf_link_type::index_type& {
    return detail::get<static_cast<uint>(id)>(m_sf_links);
  }

  DETRAY_HOST_DEVICE constexpr auto full_sf_range() const ->
      typename sf_link_type::index_type {
    using idx_range_t = typename sf_link_type::index_type;
 
    const auto& pt_range = sf_link<surface_id::e_portal>();
    const auto& sen_range = sf_link<surface_id::e_sensitive>();
    const auto& psv_range = sf_link<surface_id::e_passive>();
 
    // Portal range is never empty
    dindex min{detail::get<0>(pt_range)};
    dindex max{detail::get<1>(pt_range)};
 
    constexpr idx_range_t empty{};
    if (sen_range != empty) {
      min = detail::get<0>(sen_range) < min ? detail::get<0>(sen_range) : min;
      max = detail::get<1>(sen_range) > max ? detail::get<1>(sen_range) : max;
    }
 
    if (psv_range != empty) {
      min = detail::get<0>(psv_range) < min ? detail::get<0>(psv_range) : min;
      max = detail::get<1>(psv_range) > max ? detail::get<1>(psv_range) : max;
    }
 
    return idx_range_t{min, max};
  }

  DETRAY_HOST_DEVICE constexpr dindex n_surfaces() const {
    const auto sf_idx_range = full_sf_range();
 
    assert(sf_idx_range[1] > sf_idx_range[0]);
    return sf_idx_range[1] - sf_idx_range[0];
  }

  DETRAY_HOST_DEVICE constexpr dindex to_local_sf_index(dindex sf_idx) const {
    auto full_range = full_sf_range();
 
    assert(full_range[0] <= sf_idx);
    assert(sf_idx < full_range[1]);
 
    return sf_idx - full_range[0];
  }

  DETRAY_HOST_DEVICE constexpr dindex to_global_sf_index(dindex sf_idx) const {
    auto full_range = full_sf_range();
    dindex glob_index{sf_idx + full_range[0]};
 
    assert(full_range[0] <= glob_index);
    assert(glob_index < full_range[1]);
 
    return glob_index;
  }

  template <surface_id id>
  DETRAY_HOST auto update_sf_link(
      const typename sf_link_type::index_type& other) noexcept -> void {
    auto& rg = sf_link<id>();
    // Range not set yet - initialize
    if (constexpr typename sf_link_type::index_type empty{}; rg == empty) {
      rg = other;
    } else {
      // Update upper border
      assert(detail::get<1>(rg) == detail::get<0>(other));
      rg.set_upper(other.upper());
    }
  }

  template <surface_id id>
  DETRAY_HOST auto update_sf_link(std::size_t shift,
                                  std::size_t n_surfaces = 0) noexcept -> void {
    auto& rg = sf_link<id>();
    // Range not set yet - initialize
    if (constexpr typename sf_link_type::index_type empty{}; rg == empty) {
      rg = {0u, static_cast<dindex>(n_surfaces)};
    }
    // Update
    rg.shift(static_cast<dindex>(shift));
  }

  DETRAY_HOST_DEVICE
  constexpr auto material() const -> const material_link& { return m_mat_link; }

  DETRAY_HOST
  constexpr auto set_material(const material_link& mat_link) -> void {
    m_mat_link = mat_link;
  }

  DETRAY_HOST
  constexpr auto set_material(const material_id mat_id, const dindex mat_idx)
      -> void {
    m_mat_link = {mat_id,
                  static_cast<typename material_link::index_type>(mat_idx)};
  }

  DETRAY_HOST_DEVICE
  constexpr auto has_material() const -> bool {
    return (m_mat_link.id() != material_link::id_type::e_none) &&
           !m_mat_link.is_invalid();
  }

  DETRAY_HOST_DEVICE constexpr auto accel_link() const
      -> const accel_link_type& {
    return m_accel_links;
  }

  DETRAY_HOST_DEVICE constexpr auto accel_link(const ID& id) const
      -> const acc_link_t& {
    static_assert(static_cast<std::size_t>(ID::e_size) >= 1);
    assert(static_cast<std::size_t>(id) < static_cast<std::size_t>(ID::e_size));
    return accel_link_helper<static_cast<ID>(
        static_cast<std::size_t>(ID::e_size) - 1)>(id);
  }

  template <ID obj_id>
  DETRAY_HOST_DEVICE constexpr auto accel_link() const -> const acc_link_t& {
    return detail::get<obj_id>(m_accel_links);
  }

  template <ID obj_id>
  DETRAY_HOST constexpr auto set_accel_link(const acc_link_t link) -> void {
    detail::get<obj_id>(m_accel_links) = link;
  }

  template <ID obj_id>
  DETRAY_HOST constexpr auto set_accel_link(
      const typename acc_link_t::id_type id,
      const typename acc_link_t::index_type index) -> void {
    detail::get<obj_id>(m_accel_links) = acc_link_t{id, index};
  }

  DETRAY_HOST constexpr auto set_accel_link(
      const ID obj_id, const typename acc_link_t::id_type accel_id,
      const typename acc_link_t::index_type index) -> void {
    m_accel_links[obj_id] = acc_link_t{accel_id, index};
  }

  DETRAY_HOST_DEVICE
  constexpr auto operator==(const volume_descriptor& rhs) const -> bool {
    return (m_id == rhs.m_id && m_index == rhs.m_index &&
            m_accel_links == rhs.m_accel_links);
  }

  DETRAY_HOST
  friend std::ostream& operator<<(std::ostream& os,
                                  const volume_descriptor& v_desc) {
    os << "id = " << v_desc.id() << "(" << static_cast<int>(v_desc.id()) << ")";
    os << " | index = " << v_desc.index();
    os << " | trf. = " << v_desc.transform();
    os << " | acc link: " << v_desc.accel_link();
    os << " | sf link: " << v_desc.sf_link();
    os << " | mat link: " << v_desc.material();
    return os;
  }
 
 private:
  template <ID obj_id>
  DETRAY_HOST_DEVICE constexpr auto accel_link_helper(const ID& id) const
      -> const acc_link_t& {
    if (id == obj_id) {
      return accel_link<obj_id>();
    } else if constexpr (static_cast<std::size_t>(obj_id) > 0) {
      return accel_link_helper<static_cast<ID>(
          static_cast<std::size_t>(obj_id) - 1)>(id);
    } else {
      __builtin_unreachable();
    }
  }

  volume_id m_id{volume_id::e_unknown};

  dindex m_index{dindex_invalid};

  dindex m_transform{dindex_invalid};

  sf_link_type m_sf_links{};

  material_link m_mat_link = {};

  accel_link_type m_accel_links{};
};
 
}  // namespace detray