surface_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"
#include "detray/geometry/identifier.hpp"
 
// Sysytem include(s)
#include <memory>
 
namespace detray {

template <typename mask_link_t = dtyped_index<dindex, dindex>,
          typename material_link_t = dtyped_index<dindex, dindex>,
          typename transform_link_t = dindex,
          typename navigation_link_t = std::uint_least16_t>
class surface_descriptor {
 public:
  using navigation_link = navigation_link_t;
  using transform_link = transform_link_t;
  using mask_link = mask_link_t;
  using mask_id = typename mask_link::id_type;
  using material_link = material_link_t;
  using material_id = typename material_link::id_type;

  constexpr surface_descriptor() = default;

  DETRAY_HOST
  constexpr surface_descriptor(const transform_link trf, const mask_link mask,
                               const material_link material,
                               const dindex volume, const surface_id sf_id)
      : m_identifier{geometry::identifier{}
                         .set_volume(volume)
                         .set_id(sf_id)
                         .set_transform(trf)},
        m_mask(mask),
        m_material(material) {}

  DETRAY_HOST_DEVICE
  constexpr auto operator==(const surface_descriptor &rhs) const -> bool {
    return (m_mask == rhs.m_mask && m_material == rhs.m_material &&
            m_identifier == rhs.m_identifier);
  }

  DETRAY_HOST_DEVICE
  auto set_identifier(const geometry::identifier geo_id) -> void {
    m_identifier = geo_id;
  }

  DETRAY_HOST_DEVICE
  constexpr auto identifier() const -> geometry::identifier {
    return m_identifier;
  }

  DETRAY_HOST_DEVICE
  auto set_id(const surface_id new_id) -> void { m_identifier.set_id(new_id); }

  DETRAY_HOST_DEVICE
  constexpr auto id() const -> surface_id { return m_identifier.id(); }

  DETRAY_HOST
  auto set_volume(const dindex new_idx) -> void {
    m_identifier.set_volume(new_idx);
  }

  DETRAY_HOST_DEVICE
  constexpr auto volume() const -> dindex { return m_identifier.volume(); }

  DETRAY_HOST_DEVICE
  auto set_index(const dindex new_idx) -> void {
    m_identifier.set_index(new_idx);
  }

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

  DETRAY_HOST
  auto update_transform(dindex offset) -> void {
    m_identifier.set_transform(transform() + offset);
  }

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

  DETRAY_HOST
  auto update_mask(dindex offset) -> void { m_mask.shift(offset); }

  DETRAY_HOST_DEVICE
  constexpr auto mask() const -> const mask_link & { return m_mask; }

  DETRAY_HOST
  auto update_material(dindex offset) -> void { m_material.shift(offset); }

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

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

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

  DETRAY_HOST_DEVICE
  constexpr auto is_sensitive() const -> bool {
    return m_identifier.id() == surface_id::e_sensitive;
  }

  DETRAY_HOST_DEVICE
  constexpr auto is_portal() const -> bool {
    return m_identifier.id() == surface_id::e_portal;
  }

  DETRAY_HOST_DEVICE
  constexpr auto is_passive() const -> bool {
    return m_identifier.id() == surface_id::e_passive;
  }

  DETRAY_HOST
  friend std::ostream &operator<<(std::ostream &os,
                                  const surface_descriptor &sf) {
    os << sf.m_identifier;
    os << " | mask: " << sf.m_mask;
    os << " | mat.: " << sf.m_material;
    return os;
  }
 
 private:
  geometry::identifier m_identifier{};
  mask_link m_mask{};
  material_link m_material{};
};
 
}  // namespace detray
 
namespace std {
 
// Specialize std::hash so surface descriptors can be used in STL containers
template <typename mask_link_t, typename material_link_t,
          typename transform_link_t, typename navigation_link_t>
struct hash<detray::surface_descriptor<mask_link_t, material_link_t,
                                       transform_link_t, navigation_link_t>> {
  using descr_t =
      detray::surface_descriptor<mask_link_t, material_link_t, transform_link_t,
                                 navigation_link_t>;
 
  auto operator()(const descr_t sf_desc) const noexcept {
    return std::hash<detray::geometry::identifier::value_t>()(
        sf_desc.identifier().value());
  }
};
 
}  // namespace std