detector.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/builders/grid_builder.hpp"
#include "detray/builders/homogeneous_material_builder.hpp"
#include "detray/builders/homogeneous_volume_material_builder.hpp"
#include "detray/builders/material_map_builder.hpp"
#include "detray/builders/volume_builder.hpp"
#include "detray/core/concepts.hpp"
#include "detray/core/detail/container_buffers.hpp"
#include "detray/core/detail/container_views.hpp"
#include "detray/core/detail/surface_lookup.hpp"
#include "detray/core/name_map.hpp"
#include "detray/definitions/algebra.hpp"
#include "detray/definitions/containers.hpp"
#include "detray/definitions/detail/qualifiers.hpp"
#include "detray/geometry/volume_descriptor.hpp"
#include "detray/utils/concepts.hpp"
#include "detray/utils/print_detector.hpp"
 
// Vecmem include(s)
#include <vecmem/memory/memory_resource.hpp>
 
// System include(s)
#include <sstream>
#include <string>
#include <string_view>
 
namespace detray {
 
namespace detail {
template <typename detector_t, concepts::transform3D transform3_t>
void set_transform(detector_t &det, const transform3_t &trf, unsigned int i) {
  DETRAY_WARN_HOST(
      "Modifying transforms in the detector will be deprecated! "
      "Please, use a separate geometry context in this case");
  det._transforms.at(i) = trf;
}

template <concepts::metadata metadata_t, typename container_t>
class detector {
  // Allow the building of the detector containers
  friend class detray::volume_builder<detector<metadata_t, container_t>>;
  template <concepts::detector, concepts::grid, typename, typename>
  friend class detray::grid_builder;
  friend class detray::homogeneous_material_builder<
      detector<metadata_t, container_t>>;
  friend class detray::homogeneous_volume_material_builder<
      detector<metadata_t, container_t>>;
  template <concepts::detector, std::size_t, typename>
  friend class detray::material_map_builder;
  friend void set_transform<detector<metadata_t, container_t>,
                            dtransform3D<typename metadata_t::algebra_type>>(
      detector<metadata_t, container_t> &,
      const dtransform3D<typename metadata_t::algebra_type> &, unsigned int);

  template <typename T>
  using vector_type = typename container_t::template vector_type<T>;
 
 public:
  using metadata = metadata_t;

  using algebra_type = typename metadata::algebra_type;
  using scalar_type = dscalar<algebra_type>;
  using point2_type = dpoint2D<algebra_type>;
  using point3_type = dpoint3D<algebra_type>;
  using vector3_type = dvector3D<algebra_type>;
  using transform3_type = dtransform3D<algebra_type>;

  using name_map = detray::name_map;

  using surface_type = typename metadata::surface_type;
  using surface_container = vector_type<surface_type>;
  using surface_lookup_container = surface_lookup<surface_type, vector_type>;

  using transform_container =
      typename metadata::template transform_store<vector_type>;
  using geometry_context = typename transform_container::context_type;

  using mask_container = typename metadata::template mask_store<vector_type>;
  using masks = typename mask_container::value_types;

  using material_container =
      typename metadata::template material_store<container_t>;
  using material = typename material_container::value_types;

  using accelerator_container =
      typename metadata::template accelerator_store<container_t>;
  using accel = typename accelerator_container::value_types;

  using geo_obj_ids = typename metadata::geo_objects;
  using material_link = typename material_container::single_link;
  using accel_link = typename accelerator_container::single_link;
  using volume_type = volume_descriptor<geo_obj_ids, accel_link, material_link>;
  using volume_container = vector_type<volume_type>;

  using const_view_type =
      dmulti_view<dvector_view<const volume_type>,
                  typename surface_lookup_container::const_view_type,
                  typename transform_container::const_view_type,
                  typename mask_container::const_view_type,
                  typename material_container::const_view_type,
                  typename accelerator_container::const_view_type>;

 
  using view_type = const_view_type;
 
  static_assert(concepts::device_view<view_type>,
                "Detector view type ill-formed");
  static_assert(concepts::device_view<const_view_type>,
                "Detector const view type ill-formed");

  using buffer_type =
      dmulti_buffer<dvector_buffer<volume_type>,
                    typename surface_lookup_container::buffer_type,
                    typename transform_container::buffer_type,
                    typename mask_container::buffer_type,
                    typename material_container::buffer_type,
                    typename accelerator_container::buffer_type>;
 
  static_assert(concepts::device_buffer<buffer_type>,
                "Detector buffer type ill-formed");
 
  detector() = delete;
  // The detector holds a lot of data and should never be copied
  detector(const detector &) = delete;
  detector &operator=(const detector &) = delete;

  detector(detector &&) noexcept = default;

  detector &operator=(detector &&other) noexcept = default;

  DETRAY_HOST
  explicit detector(vecmem::memory_resource &resource)
      : _volumes(&resource),
        _surfaces(resource),
        _transforms(resource),
        _masks(resource),
        _materials(resource),
        _accelerators(resource) {}

  template <concepts::device_view detector_view_t>
  DETRAY_HOST_DEVICE explicit detector(detector_view_t &det_data)
      : _volumes(detray::detail::get<0>(det_data.m_view)),
        _surfaces(detray::detail::get<1>(det_data.m_view)),
        _transforms(detray::detail::get<2>(det_data.m_view)),
        _masks(detray::detail::get<3>(det_data.m_view)),
        _materials(detray::detail::get<4>(det_data.m_view)),
        _accelerators(detray::detail::get<5>(det_data.m_view)) {}


  std::string name(const name_map &names) const {
    return names.get_detector_name();
  }

  DETRAY_HOST_DEVICE
  inline auto volumes() const -> const vector_type<volume_type> & {
    return _volumes;
  }

  DETRAY_HOST_DEVICE
  inline const auto &volume(dindex volume_index) const {
    return _volumes[volume_index];
  }

  DETRAY_HOST
  inline const auto &volume(const std::string_view volume_name,
                            const name_map &names) const {
    return _volumes.at(names.at(volume_name));
  }

  DETRAY_HOST_DEVICE
  inline const auto &volume(const point3_type &p) const {
    // Allow to call the volume search data structure
    // TODO: Add volume accelerator builder
    volume_type v_desc{};
    v_desc.template set_accel_link<geo_obj_ids::e_volume>(
        accel::id::e_volume_default, 0u);
    tracking_volume world{*this, v_desc};
 
    dindex volume_index{0u};
    world.template visit_accelerator<geo_obj_ids::e_volume, volume_search>(
        p, &volume_index);
    return _volumes[volume_index];
  }

  DETRAY_HOST_DEVICE
  inline const auto &portals() const {
    // All portals are registered with the brute force search
    return _accelerators.template get<accel::id::e_surface_brute_force>().all();
  }

  DETRAY_HOST_DEVICE
  inline auto surfaces() const -> const surface_lookup_container & {
    return _surfaces;
  }

  template <typename query_t>
  DETRAY_HOST_DEVICE constexpr decltype(auto) surface(query_t &&q) const {
    return _surfaces.search(std::forward<query_t>(q));
  }

  DETRAY_HOST_DEVICE
  inline auto transform_store(const geometry_context & /*ctx*/ = {}) const
      -> const transform_container & {
    return _transforms;
  }

  DETRAY_HOST_DEVICE
  inline auto mask_store() const -> const mask_container & { return _masks; }

  DETRAY_HOST_DEVICE
  inline auto material_store() const -> const material_container & {
    return _materials;
  }

  DETRAY_HOST_DEVICE
  inline auto accelerator_store() const -> const accelerator_container & {
    return _accelerators;
  }

  DETRAY_HOST auto get_data() -> const_view_type {
    return const_view_type{detray::get_data(std::as_const(_volumes)),
                           detray::get_data(std::as_const(_surfaces)),
                           detray::get_data(std::as_const(_transforms)),
                           detray::get_data(std::as_const(_masks)),
                           detray::get_data(std::as_const(_materials)),
                           detray::get_data(std::as_const(_accelerators))};
  }

  DETRAY_HOST auto get_data() const -> const_view_type {
    return const_view_type{
        detray::get_data(_volumes),    detray::get_data(_surfaces),
        detray::get_data(_transforms), detray::get_data(_masks),
        detray::get_data(_materials),  detray::get_data(_accelerators)};
  }
 
 private:
  DETRAY_HOST
  friend std::ostream &operator<<(std::ostream &os, const detector &d) {
    os << utils::print_detector(d) << std::endl;
    return os;
  }

  struct volume_search {
    template <concepts::accelerator_collection accel_coll_t,
              typename accel_index_t>
    DETRAY_HOST_DEVICE inline void operator()(const accel_coll_t &coll,
                                              const accel_index_t index,
                                              const point3_type &p,
                                              dindex *const result) const {
      using accel_type = typename accel_coll_t::value_type;
 
      if constexpr (concepts::volume_accelerator<accel_type>) {
        const auto volume_accelerator = coll[index];
 
        // Only one entry per bin
        *result = volume_accelerator.search(p).value();
      }
    }
  };

  volume_container _volumes;

  surface_lookup_container _surfaces;

  transform_container _transforms;

  mask_container _masks;

  material_container _materials;

  accelerator_container _accelerators;
};
 
}  // namespace detail
 
namespace host {
 
template <concepts::metadata metadata_t>
using detector = detray::detail::detector<metadata_t, host_container_types>;
 
}  // namespace host
 
namespace device {
 
template <concepts::metadata metadata_t>
using detector =
    detray::detail::detector<metadata_t, const_device_container_types>;
 
}  // namespace device
 
template <typename T>
struct detector_traits {};

template <concepts::metadata metadata_t>
struct detector_traits<metadata_t> {
  using metadata_type = metadata_t;

  using host = detray::host::detector<metadata_type>;

  using device = detray::device::detector<metadata_type>;

  using view = typename host::const_view_type;

  using buffer = typename host::buffer_type;
};

template <concepts::metadata metadata_t, typename container_t>
struct detector_traits<detail::detector<metadata_t, container_t>> {
 private:
  using T = detector_traits<metadata_t>;
 
 public:
  using metadata_type = typename T::metadata_type;
  using host = typename T::host;
  using device = typename T::device;
  using view = typename T::view;
  using buffer = typename T::buffer;
};


template <typename D>
using detector_metadata_t = typename detector_traits<D>::metadata_type;

template <typename D>
using detector_host_t = typename detector_traits<D>::host;

template <typename D>
using detector_device_t = typename detector_traits<D>::device;

template <typename D>
using detector_view_t = typename detector_traits<D>::view;

template <typename D>
using detector_buffer_t = typename detector_traits<D>::buffer;

 
}  // namespace detray