Fix compilation

Author: niermann999

core/include/detray/builders/grid_builder.hpp

@@ -14,6 +14,7 @@
 #include "detray/builders/volume_builder.hpp"
 #include "detray/builders/volume_builder_interface.hpp"
 #include "detray/geometry/tracking_volume.hpp"
+#include "detray/navigation/accelerators/grid_searcher.hpp"
 #include "detray/utils/grid/detail/concepts.hpp"
 
 // System include(s)
@@ -183,8 +184,13 @@ class grid_builder : public volume_decorator<detector_t> {
         }
 
         // Add the grid to the detector and link it to its volume
-        constexpr auto gid{detector_t::accel::template get_id<grid_t>()};
-        det._accelerators.template push_back<gid>(m_grid);
+        grid_searcher_impl gr_searcher{std::move(m_grid)};
+        using non_owning_searcher_t =
+            typename decltype(gr_searcher)::template type<false>;
+        constexpr auto gid{
+            detector_t::accel::template get_id<non_owning_searcher_t>()};
+
+        det._accelerators.template push_back<gid>(gr_searcher);
         vol_ptr->set_link(m_id, gid,
                           det.accelerator_store().template size<gid>() - 1);
 

core/include/detray/core/detail/alignment.hpp

@@ -25,9 +25,7 @@ typename host_detector_type::view_type misaligned_detector_view(
         detray::get_data(
             detray::detail::get<4>(det_buffer.m_buffer)),  // materials
         detray::get_data(
-            detray::detail::get<5>(det_buffer.m_buffer)),  // accelerators
-        detray::get_data(detray::detail::get<6>(
-            det_buffer.m_buffer))};  // volume search grid
+            detray::detail::get<5>(det_buffer.m_buffer))};  // accelerators
     return detview;
 }
 

core/include/detray/core/detector.hpp

@@ -220,16 +220,17 @@ class detector {
 
     /// @return the volume by global cartesian @param position - const access
     DETRAY_HOST_DEVICE
-    inline const auto &volume(const point3_type &p) const {
+    inline const auto &volume(const point3_type & /*p*/) const {
         volume_type v_desc{};
         // Allow to call the volume search data structure
         v_desc.template set_accel_link<geo_obj_ids::e_volume>(
-            accel::id::e_volume_brute_force, 0u);
-        tracking_volume world{v_desc, *this};
+            accel::id::e_default_volume_searcher, 0u);
+        tracking_volume world{*this, v_desc};
 
-        const dindex volume_index =
+        const dindex volume_index{0u};
+        /*const dindex volume_index =
             world.template visit_accelerator<geo_obj_ids::e_volume,
-                                             volume_search>(p);
+                                             volume_search>(p);*/
         return _volumes[volume_index];
     }
 

core/include/detray/geometry/detail/volume_kernels.hpp

@@ -67,27 +67,6 @@ struct surface_getter {
     }
 };
 
-/// A functor to access the daughter volumes of a volume
-template <typename functor_t>
-struct volume_getter {
-
-    /// Call operator that forwards the functor call to all contained daughter
-    /// volumes
-    template <concepts::accelerator_collection accel_coll_t,
-              typename accel_index_t, typename... Args>
-    DETRAY_HOST_DEVICE inline void operator()(const accel_coll_t &,
-                                              const accel_index_t,
-                                              Args &&...) const {
-
-        using accel_type = typename accel_coll_t::value_type;
-
-        if constexpr (concepts::volume_accelerator<accel_type>) {
-            // Run over all the daughter volumes
-            // TODO: Implement e.g. BVH
-        }
-    }
-};
-
 /// A functor to find surfaces in the neighborhood of a track position
 template <typename functor_t>
 struct neighborhood_getter {
@@ -104,22 +83,37 @@ struct neighborhood_getter {
         const typename detector_t::geometry_context &ctx,
         Args &&...args) const {
 
+        using accel_type = typename accel_coll_t::value_type;
+
         decltype(auto) accel = coll[index];
 
-        // Run over the surfaces in a single acceleration data structure
-        for (const auto &sf : accel.search(det, volume, track, cfg, ctx)) {
-            functor_t{}(sf, std::forward<Args>(args)...);
+        if constexpr (concepts::surface_accelerator<accel_type>) {
+            // Run over the surfaces in a single acceleration data structure
+            for (const auto &sf : accel.search(det, volume, track, cfg, ctx)) {
+                functor_t{}(sf, std::forward<Args>(args)...);
+            }
         }
     }
 };
 
-/// Query the maximal number of candidates from the acceleration
-struct n_candidates_getter {
+/// A functor to access the daughter volumes of a volume
+template <typename functor_t>
+struct volume_getter {
+
+    /// Call operator that forwards the functor call to all contained daughter
+    /// volumes
     template <concepts::accelerator_collection accel_coll_t,
-              typename accel_index_t>
-    DETRAY_HOST_DEVICE inline auto operator()(const accel_coll_t &coll,
-                                              const accel_index_t index) const {
-        return coll[index].n_max_candidates();
+              typename accel_index_t, typename... Args>
+    DETRAY_HOST_DEVICE inline void operator()(const accel_coll_t &,
+                                              const accel_index_t,
+                                              Args &&...) const {
+
+        using accel_type = typename accel_coll_t::value_type;
+
+        if constexpr (concepts::volume_accelerator<accel_type>) {
+            // Run over all the daughter volumes
+            // TODO: Implement e.g. BVH
+        }
     }
 };
 

core/include/detray/geometry/tracking_volume.hpp

@@ -88,6 +88,12 @@ class tracking_volume {
     DETRAY_HOST_DEVICE
     constexpr auto index() const -> dindex { return m_desc.index(); }
 
+    /// @returns the volume name (add an offset for the detector name).
+    DETRAY_HOST
+    auto name(const name_map &names) const -> std::string {
+        return names.empty() ? "unknown volume" : names.at(m_desc.index() + 1u);
+    }
+
     /// @returns the (non contextual) transform for the placement of the
     /// volume in the detector geometry.
     DETRAY_HOST_DEVICE
@@ -144,7 +150,7 @@ class tracking_volume {
     /// @tparam functor_t the prescription to be applied to the surfaces
     /// @tparam Args      types of additional arguments to the functor
     template <object_id I, typename functor_t, typename... Args>
-    DETRAY_HOST_DEVICE constexpr void visit_accelerator(Args &&... args) const {
+    DETRAY_HOST_DEVICE constexpr void visit_accelerator(Args &&...args) const {
         static_assert(I < object_id::e_all);
 
         if (const auto &link{m_desc.template accel_link<I>()};
@@ -163,8 +169,7 @@ class tracking_volume {
     /// @tparam Args      types of additional arguments to the functor
     template <typename functor_t,
               int I = static_cast<int>(object_id::e_all) - 1, typename... Args>
-    DETRAY_HOST_DEVICE constexpr void visit_accelerators(
-        Args &&... args) const {
+    DETRAY_HOST_DEVICE constexpr void visit_accelerators(Args &&...args) const {
         // Get the acceleration data structures for this volume and only visit,
         // if object type is contained in volume
         visit_accelerator<static_cast<object_id>(I), functor_t>(
@@ -184,7 +189,7 @@ class tracking_volume {
     /// @tparam functor_t the prescription to be applied to the surfaces
     /// @tparam Args      types of additional arguments to the functor
     template <surface_id I, typename functor_t, typename... Args>
-    DETRAY_HOST_DEVICE constexpr void visit_surfaces(Args &&... args) const {
+    DETRAY_HOST_DEVICE constexpr void visit_surfaces(Args &&...args) const {
         using surface_getter_t = detail::surface_getter<functor_t>;
 
         // Dispatch to the correct acceleration structure
@@ -223,7 +228,7 @@ class tracking_volume {
     /// @tparam Args      types of additional arguments to the functor
     template <surface_id I, typename functor_t, typename... Args>
     DETRAY_HOST_DEVICE constexpr void visit_daughter_volumes(
-        Args &&... args) const {
+        Args &&...args) const {
         using volume_getter_t = detail::volume_getter<functor_t>;
 
         visit_accelerator<object_id::e_volume, volume_getter_t>(
@@ -243,9 +248,10 @@ class tracking_volume {
     /// @tparam Args      types of additional arguments to the functor
     template <object_id I, typename functor_t, typename track_t,
               typename config_t, typename... Args>
-    DETRAY_HOST_DEVICE constexpr void visit_neighborhood(
-        const track_t &track, const config_t &cfg, const context_t &ctx,
-        Args &&... args) const {
+    DETRAY_HOST_DEVICE constexpr void visit_neighborhood(const track_t &track,
+                                                         const config_t &cfg,
+                                                         const context_t &ctx,
+                                                         Args &&...args) const {
         if constexpr (I == object_id::e_all) {
             visit_accelerators<detail::neighborhood_getter<functor_t>>(
                 m_detector, m_desc, track, cfg, ctx,
@@ -372,12 +378,6 @@ class tracking_volume {
         return true;
     }
 
-    /// @returns the volume name (add an offset for the detector name).
-    DETRAY_HOST_DEVICE
-    auto name(const name_map &names) const -> std::string {
-        return names.empty() ? "" : names.at(m_desc.index() + 1u);
-    }
-
     /// @returns a string stream that prints the volume details
     DETRAY_HOST
     friend std::ostream &operator<<(std::ostream &os,

core/include/detray/navigation/accelerators/concepts.hpp

@@ -24,12 +24,10 @@ namespace detray::concepts {
 /// Concept for a detray geometry acceleration structures
 template <class A>
 concept accelerator = requires(const A acc) {
-
     typename A::value_type;
 
     // Iterate through all contained geometry objects
-    { acc.all() }
-    ->ranges::range_of<typename A::value_type>;
+    { acc.all() } -> ranges::range_of<typename A::value_type>;
 
     // TODO: In order to require the search method, we need to pass a detector
     // which is auto-deduced
@@ -38,20 +36,20 @@ concept accelerator = requires(const A acc) {
 /// Concept for a collection of accelerator (data) that can be stored in the
 /// detector
 template <class AC>
-concept accelerator_collection = viewable<AC>&& bufferable<AC>&& requires(
-    const AC accel_coll, unsigned int idx) {
-
-    typename AC::size_type;
-    requires concepts::accelerator<typename AC::value_type>;
+concept accelerator_collection =
+    viewable<AC> && bufferable<AC> &&
+    requires(const AC accel_coll, unsigned int idx) {
+        typename AC::size_type;
+        requires concepts::accelerator<typename AC::value_type>;
 
-    { accel_coll[idx] }
-    ->concepts::accelerator;
-};
+        { accel_coll[idx] } -> concepts::accelerator;
+    };
 
 /// Acceleration structure that contains surfaces (surface descriptors)
 /// TODO: Add surface descriptor concept to geometry package
 template <class A>
-concept surface_accelerator = concepts::accelerator<A>&&
+concept surface_accelerator =
+    concepts::accelerator<A> &&
     std::same_as<typename A::value_type,
                  surface_descriptor<typename A::value_type::mask_link,
                                     typename A::value_type::material_link,
@@ -61,7 +59,7 @@ concept surface_accelerator = concepts::accelerator<A>&&
 /// Acceleration structure that contains volumes (volume indices)
 template <class A>
 concept volume_accelerator =
-    concepts::accelerator<A>&& std::same_as<typename A::value_type, dindex>;
+    concepts::accelerator<A> && std::same_as<typename A::value_type, dindex>;
 
 /// Brute force acceleration structures
 /// @{
@@ -77,10 +75,10 @@ concept brute_force_volume_searcher =
 /// Grid based acceleration structures
 /// @{
 template <class A>
-concept surface_grid = concepts::grid<A>&& concepts::surface_accelerator<A>;
+concept surface_grid = concepts::grid<A> && concepts::surface_accelerator<A>;
 
 template <class A>
-concept volume_grid = concepts::grid<A>&& concepts::volume_accelerator<A>;
+concept volume_grid = concepts::grid<A> && concepts::volume_accelerator<A>;
 /// @}
 
 }  // namespace detray::concepts

core/include/detray/navigation/accelerators/grid_searcher.hpp

@@ -8,7 +8,7 @@
 #pragma once
 
 // Project include(s)
-#include "detray/geometry/detail/surface_descriptor.hpp"
+#include "detray/geometry/surface_descriptor.hpp"
 #include "detray/utils/grid/detail/axis_helpers.hpp"
 #include "detray/utils/grid/detail/bin_view.hpp"
 #include "detray/utils/grid/detail/grid_bins.hpp"
@@ -25,42 +25,29 @@ class grid_searcher_impl : public grid_impl<axes_t, bin_t, serializer_t> {
     using base_grid = grid_impl<axes_t, bin_t, serializer_t>;
 
     public:
-    /// Adopt type definitions and static variables of the underlying grid
-    /// @{
-    template <typename neighbor_t>
-    using neighborhood_type = darray<neighbor_t, base_grid::dim>;
-
-    static constexpr unsigned int dim{base_grid::dim};
-    static constexpr bool is_owning{base_grid::is_owning};
-
     using value_type = typename base_grid::value_type;
-    using algebra_type = typename base_grid::algebra_type;
-    using scalar_type = typename base_grid::scalar_type;
     using point_type = typename base_grid::point_type;
 
-    using bin_type = typename base_grid::bin_type;
-    using glob_bin_index = typename base_grid::glob_bin_index;
-    using loc_bin_index = typename base_grid::loc_bin_index;
-    using axes_type = typename base_grid::axes_type;
-    using bin_storage = typename base_grid::bin_storage;
-    using bin_container_type = typename base_grid::bin_container_type;
-
-    using view_type = typename base_grid::view_type;
-    using const_view_type = typename base_grid::const_view_type;
-    using buffer_type = typename base_grid::buffer_type;
-
-    template <std::size_t DIM>
-    using serializer_type = typename base_grid::template serializer_type<DIM>;
+    template <typename neighbor_t>
+    using neighborhood_type = darray<neighbor_t, base_grid::dim>;
 
     /// Find the corresponding (non-)owning grid type
     template <bool owning>
     using type = grid_searcher_impl<typename axes_t::template type<owning>,
                                     bin_t, serializer_t>;
-    /// @}
 
     /// Use all of the grid constructors
     using base_grid::base_grid;
 
+    /// Construct from existing grid
+    DETRAY_HOST_DEVICE
+    explicit constexpr grid_searcher_impl(base_grid &&gr)
+        : base_grid(std::move(gr)) {}
+
+    /// Construct from existing grid
+    DETRAY_HOST_DEVICE
+    explicit constexpr grid_searcher_impl(base_grid &gr) : base_grid(gr) {}
+
     /// Interface for the navigator
     template <typename detector_t, typename track_t, typename config_t>
     DETRAY_HOST_DEVICE auto search(
@@ -115,6 +102,12 @@ class grid_searcher_impl : public grid_impl<axes_t, bin_t, serializer_t> {
     }
 };
 
+template <typename axes_t, typename bin_t,
+          template <std::size_t> class serializer_t>
+DETRAY_HOST_DEVICE grid_searcher_impl(
+    grid_impl<axes_t, bin_t, serializer_t> &&gr)
+    -> grid_searcher_impl<axes_t, bin_t, serializer_t>;
+
 template <concepts::algebra algebra_t, typename axes_t, typename bin_t,
           template <std::size_t> class serializer_t = simple_serializer,
           typename containers = host_container_types, bool ownership = true>

core/include/detray/utils/grid/detail/concepts.hpp

@@ -50,8 +50,7 @@ concept axis = requires(const A ax) {
         ax.bin_edges(dindex())
     } -> std::same_as<darray<typename A::scalar_type, 2>>;
 
-    { ax.bin_edges() }
-    ->detray::ranges::range_of<typename A::scalar_type>;
+    { ax.bin_edges() } -> detray::ranges::range_of<typename A::scalar_type>;
 
     { ax.span() } -> std::same_as<darray<typename A::scalar_type, 2>>;
 
@@ -91,8 +90,7 @@ concept grid = viewable<G> && bufferable<G> && requires(const G g) {
         g.serialize(typename G::loc_bin_index())
     } -> std::same_as<typename G::glob_bin_index>;
 
-    { g.bins() }
-    ->detray::ranges::range_of<typename G::bin_type>;
+    { g.bins() } -> detray::ranges::range_of<typename G::bin_type>;
 
     {
         g.bin(typename G::glob_bin_index())

core/include/detray/utils/grid/grid.hpp

@@ -245,7 +245,7 @@ class grid_impl {
     }
 
     /// @param indices the single indices corresponding to a multi_bin
-    template <typename... I>
+    template <concepts::index... I>
         requires(sizeof...(I) == dim)
     DETRAY_HOST_DEVICE decltype(auto) bin(I... indices) const {
         return bin(loc_bin_index{indices...});