remove python changes

Author: niermann999

core/include/detray/core/detector.hpp

@@ -220,7 +220,8 @@ class detector {
     inline const auto &volume(const point3_type &p) const {
         volume_type v_desc{};
         // Allow to call the volume search data structure
-        v_desc.set_accel_link(geo_obj_ids::e_volume, 0u);
+        v_desc.template set_accel_link<geo_obj_ids::e_volume>(
+            accel::id::e_volume_brute_force, 0u);
         tracking_volume world{v_desc, *this};
 
         const dindex volume_index =
@@ -328,12 +329,13 @@ class detector {
     /// Volume lookup in the volume acceleration data structures
     struct volume_search {
         ///@TODO: Move this to a volume search grid type
-        template <typename accel_group_t, typename accel_index_t>
+        template <concepts::accelerator_collection accel_coll_t,
+                  typename accel_index_t>
         DETRAY_HOST_DEVICE inline dindex operator()(
-            const accel_group_t &group, const accel_index_t index,
+            const accel_coll_t &coll, const accel_index_t index,
             const point3_type &p) const {
 
-            const auto volume_accelerator = group[index];
+            const auto volume_accelerator = coll[index];
 
             // The 3D cylindrical volume search grid is concentric
             const transform3_type identity{};

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

@@ -52,7 +52,7 @@ class volume_descriptor {
     ///          surface store.
     ///
     /// E.g. a 'portal' can be found under @c ID::e_portal in this link,
-    /// and will then receive link to the @c brute_force_finder that holds the
+    /// and will then receive link to the @c brute_force_searcher that holds the
     /// portals (the accelerator structure's id and index).
     using accel_link_type = dmulti_index<acc_link_t, ID::e_size>;
 
@@ -68,6 +68,17 @@ class volume_descriptor {
     /// @param id id values that determines how to interpret the bounds.
     explicit constexpr volume_descriptor(const volume_id id) : m_id{id} {}
 
+    /// @returns true if the object ID corresponds to a surface
+    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);
+    }
+
+    /// @returns true if the object ID corresponds to a [daughter] volume
+    static consteval bool is_volume_id(const object_id id) {
+        return (id == object_id::e_volume);
+    }
+
     /// @returns the volume shape id, e.g. 'cylinder'
     DETRAY_HOST_DEVICE
     constexpr auto id() const -> volume_id { return m_id; }

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

@@ -50,16 +50,17 @@ template <typename functor_t>
 struct surface_getter {
 
     /// Call operator that forwards the functor to all contained surfaces
-    template <typename accel_group_t, typename accel_index_t, typename... Args>
-    DETRAY_HOST_DEVICE inline void operator()(const accel_group_t &group,
+    template <concepts::accelerator_collection accel_coll_t,
+              typename accel_index_t, typename... Args>
+    DETRAY_HOST_DEVICE inline void operator()(const accel_coll_t &coll,
                                               const accel_index_t index,
                                               Args &&... args) const {
 
-        using accel_type = typename accel_group_t::value_type;
+        using accel_type = typename accel_coll_t::value_type;
 
         if constexpr (concepts::surface_accelerator<accel_type>) {
             // Run over the surfaces in a single acceleration data structure
-            for (const auto &sf : group[index].all()) {
+            for (const auto &sf : coll[index].all()) {
                 functor_t{}(sf, std::forward<Args>(args)...);
             }
         }
@@ -68,16 +69,17 @@ struct surface_getter {
 
 /// A functor to access the daughter volumes of a volume
 template <typename functor_t>
-struct daughter_volume_getter {
+struct volume_getter {
 
     /// Call operator that forwards the functor call to all contained daughter
     /// volumes
-    template <typename accel_group_t, typename accel_index_t, typename... Args>
-    DETRAY_HOST_DEVICE inline void operator()(const accel_group_t &group,
-                                              const accel_index_t index,
-                                              Args &&... args) const {
+    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_group_t::value_type;
+        using accel_type = typename accel_coll_t::value_type;
 
         if constexpr (concepts::volume_accelerator<accel_type>) {
             // Run over all the daughter volumes
@@ -92,17 +94,17 @@ struct neighborhood_getter {
 
     /// Call operator that forwards the neighborhood search call in a volume
     /// to a surface finder data structure
-    template <typename accel_group_t, typename accel_index_t,
-              typename detector_t, typename track_t, typename config_t,
-              typename... Args>
+    template <concepts::accelerator_collection accel_coll_t,
+              typename accel_index_t, typename detector_t, typename track_t,
+              typename config_t, typename... Args>
     DETRAY_HOST_DEVICE inline void operator()(
-        const accel_group_t &group, const accel_index_t index,
+        const accel_coll_t &coll, const accel_index_t index,
         const detector_t &det, const typename detector_t::volume_type &volume,
         const track_t &track, const config_t &cfg,
         const typename detector_t::geometry_context &ctx,
         Args &&... args) const {
 
-        decltype(auto) accel = group[index];
+        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)) {
@@ -113,10 +115,11 @@ struct neighborhood_getter {
 
 /// Query the maximal number of candidates from the acceleration
 struct n_candidates_getter {
-    template <typename accel_group_t, typename accel_index_t>
-    DETRAY_HOST_DEVICE inline auto operator()(const accel_group_t &group,
+    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 group[index].n_max_candidates();
+        return coll[index].n_max_candidates();
     }
 };
 

core/include/detray/geometry/tracking_volume.hpp

@@ -68,17 +68,6 @@ class tracking_volume {
     constexpr tracking_volume(const detector_t &det, const dindex vol_idx)
         : tracking_volume(det, det.volume(vol_idx)) {}
 
-    /// @returns true if the object ID corresponds to a surface
-    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);
-    }
-
-    /// @returns true if the object ID corresponds to a [daughter] volume
-    static consteval bool is_volume_id(const object_id id) {
-        return (id == object_id::e_volume);
-    }
-
     /// @returns access to the underlying detector
     DETRAY_HOST_DEVICE
     auto detector() const -> const detector_t & { return m_detector; }
@@ -160,21 +149,16 @@ class tracking_volume {
 
         if (const auto &link{m_desc.template accel_link<I>()};
             !link.is_invalid()) {
-            if constexpr (tracking_volume::is_surface_id(I)) {
-                // Run over the surfaces in a single acceleration data structure
-                // and apply the functor to the resulting neighborhood
-                m_detector.accelerator_store().template visit<functor_t>(
-                    link, std::forward<Args>(args)...);
-            } else {
-                // TODO: Call volume accelerator to find daughter volumes
-                // [...]
-            }
+            // Run over the surfaces in a single acceleration data structure
+            // and apply the functor to the resulting neighborhood
+            m_detector.accelerator_store().template visit<functor_t>(
+                link, std::forward<Args>(args)...);
         }
     }
 
     /// Apply a functor to all acceleration structures of this volume.
     ///
-    /// @tparam I type of object to retrieve (passive, portal, sensitive etc)
+    /// @tparam I type of object to retrieve (surface types, daughters etc)
     /// @tparam functor_t the prescription to be applied to the acc structure
     /// @tparam Args      types of additional arguments to the functor
     template <typename functor_t,
@@ -195,6 +179,8 @@ class tracking_volume {
     /// Apply a functor to all surfaces of a given surface id (portal, passive,
     /// sensitive) in the volume
     ///
+    /// Translates the detray surface type id to the volume geometry object id
+    ///
     /// @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>
@@ -231,8 +217,25 @@ class tracking_volume {
         }
     }
 
-    /// Apply a functor to a neighborhood of surfaces around a track position
-    /// in the volume.
+    /// Apply a functor to all daughter volumes
+    ///
+    /// @tparam functor_t the prescription to be applied to the daughter volumes
+    /// @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 {
+        using volume_getter_t = detail::volume_getter<functor_t>;
+
+        visit_accelerator<object_id::e_volume, volume_getter_t>(
+            std::forward<Args>(args)...);
+    }
+
+    /// Apply a functor to a neighborhood of geometric objects around a
+    /// track position in the volume.
+    ///
+    /// @note: The acceleration structures in the volume might return different
+    /// geometric objects (e.g. surfaces vs. volumes). The passed functor must
+    /// provide corresponding overloads of the call operator.
     ///
     /// @tparam functor_t the prescription to be applied to the surfaces (
     ///                   customization point for the navigation)

core/include/detray/navigation/accelerators/brute_force_finder.hpp renamed to core/include/detray/navigation/accelerators/brute_force_searcher.hpp

@@ -45,6 +45,7 @@ class brute_force_collection {
         : public detray::ranges::subrange<const vector_type<value_t>> {
 
         using base = detray::ranges::subrange<const vector_type<value_t>>;
+        using value_type = value_t;
 
         /// Default constructor
         brute_forcer() = default;

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

@@ -8,6 +8,8 @@
 #pragma once
 
 // Project include(s)
+#include "detray/core/detail/container_buffers.hpp"
+#include "detray/core/detail/container_views.hpp"
 #include "detray/definitions/indexing.hpp"
 #include "detray/geometry/detail/surface_descriptor.hpp"
 #include "detray/utils/concepts.hpp"
@@ -27,7 +29,23 @@ concept accelerator = requires(const A acc) {
 
     // Iterate through all contained geometry objects
     { acc.all() }
-    ->detray::ranges::range_of<typename A::value_type>;
+    ->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
+};
+
+/// 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>;
+
+    { accel_coll[idx] }
+    ->concepts::accelerator;
 };
 
 /// Acceleration structure that contains surfaces (surface descriptors)
@@ -48,11 +66,11 @@ concept volume_accelerator =
 /// Brute force acceleration structures
 /// @{
 template <class A>
-concept brute_force_surface_finder =
+concept brute_force_surface_searcher =
     !concepts::grid<A> && concepts::volume_accelerator<A>;
 
 template <class A>
-concept brute_force_volume_finder =
+concept brute_force_volume_searcher =
     !concepts::grid<A> && concepts::surface_accelerator<A>;
 /// @}
 

core/include/detray/navigation/accelerators/accelerator_grid.hpp renamed to core/include/detray/navigation/accelerators/grid_searcher.hpp

@@ -10,24 +10,22 @@
 // Project include(s)
 #include "detray/geometry/detail/surface_descriptor.hpp"
 #include "detray/utils/grid/detail/axis_helpers.hpp"
-#include "detray/utils/grid/detail/grid_bins.hpp"
 #include "detray/utils/grid/detail/bin_view.hpp"
+#include "detray/utils/grid/detail/grid_bins.hpp"
 #include "detray/utils/grid/grid.hpp"
 #include "detray/utils/grid/grid_collection.hpp"
 
 namespace detray {
 
 /// @brief An N-dimensional spacial grid for geometry object searches.
-///
-/// @tparam value_t Type of values contained in the grid
 template <typename axes_t, typename bin_t,
           template <std::size_t> class serializer_t = simple_serializer>
-class accelerator_grid_impl : public grid_impl<axes_t, bin_t, serializer_t> {
+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
+    /// Adopt type definitions and static variables of the underlying grid
     /// @{
     template <typename neighbor_t>
     using neighborhood_type = darray<neighbor_t, base_grid::dim>;
@@ -56,8 +54,8 @@ class accelerator_grid_impl : public grid_impl<axes_t, bin_t, serializer_t> {
 
     /// Find the corresponding (non-)owning grid type
     template <bool owning>
-    using type =
-        accelerator_grid_impl<typename axes_t::template type<owning>, bin_t, serializer_t>;
+    using type = grid_searcher_impl<typename axes_t::template type<owning>,
+                                    bin_t, serializer_t>;
     /// @}
 
     /// Use all of the grid constructors
@@ -117,12 +115,11 @@ class accelerator_grid_impl : public grid_impl<axes_t, bin_t, serializer_t> {
     }
 };
 
-/// Type alias for easier construction
 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>
-using accelerator_grid =
-    accelerator_grid_impl<coordinate_axes<axes_t, algebra_t, ownership, containers>, bin_t,
-              simple_serializer>;
+using grid_searcher = grid_searcher_impl<
+    coordinate_axes<axes_t, algebra_t, ownership, containers>, bin_t,
+    simple_serializer>;
 
-}  // namespace detray
+}  // namespace detray

detectors/include/detray/detectors/default_metadata.hpp

@@ -21,8 +21,8 @@
 #include "detray/materials/material_map.hpp"
 #include "detray/materials/material_rod.hpp"
 #include "detray/materials/material_slab.hpp"
-#include "detray/navigation/accelerators/accelerator_grid.hpp"
-#include "detray/navigation/accelerators/brute_force_finder.hpp"
+#include "detray/navigation/accelerators/brute_force_searcher.hpp"
+#include "detray/navigation/accelerators/grid_searcher.hpp"
 
 namespace detray {
 
@@ -110,8 +110,8 @@ struct default_metadata {
     // surface grid definition: bin-content: darray<surface_type, 9>
     template <typename axes_t, typename bin_entry_t, typename container_t>
     using surface_grid_t =
-        accelerator_grid<algebra_type, axes_t, bins::dynamic_array<bin_entry_t>,
-                         simple_serializer, container_t, false>;
+        grid_searcher<algebra_type, axes_t, bins::dynamic_array<bin_entry_t>,
+                      simple_serializer, container_t, false>;
 
     // 2D cylindrical grid for the barrel layers
     template <typename bin_entry_t, typename container_t>
@@ -270,11 +270,11 @@ unbounded_cell, unmasked_plane*/>;
     /// Volume search grid
     template <typename container_t = host_container_types>
     using volume_accelerator =
-        accelerator_grid<algebra_type,
-                         axes<cylinder3D, axis::bounds::e_open, axis::irregular,
-                              axis::regular, axis::irregular>,
-                         bins::single<dindex>, simple_serializer, container_t,
-                         false>;
+        grid_searcher<algebra_type,
+                      axes<cylinder3D, axis::bounds::e_open, axis::irregular,
+                           axis::regular, axis::irregular>,
+                      bins::single<dindex>, simple_serializer, container_t,
+                      false>;
 
     /// How to store the acceleration data structures
     template <typename container_t = host_container_types>

detectors/include/detray/detectors/itk_metadata.hpp

@@ -21,8 +21,8 @@
 #include "detray/geometry/shapes/ring2D.hpp"
 #include "detray/materials/material_map.hpp"
 #include "detray/materials/material_slab.hpp"
-#include "detray/navigation/accelerators/accelerator_grid.hpp"
-#include "detray/navigation/accelerators/brute_force_finder.hpp"
+#include "detray/navigation/accelerators/brute_force_searcher.hpp"
+#include "detray/navigation/accelerators/grid_searcher.hpp"
 
 // Linear algebra types
 #include "detray/definitions/algebra.hpp"
@@ -160,10 +160,11 @@ struct itk_metadata {
     /// given position. Here: Uniform grid with a 3D cylindrical shape
     template <typename container_t = host_container_types>
     using volume_accelerator =
-        grid<algebra_type,
-             axes<cylinder3D, axis::bounds::e_open, axis::irregular,
-                  axis::regular, axis::irregular>,
-             bins::single<dindex>, simple_serializer, container_t, false>;
+        grid_searcher<algebra_type,
+                      axes<cylinder3D, axis::bounds::e_open, axis::irregular,
+                           axis::regular, axis::irregular>,
+                      bins::single<dindex>, simple_serializer, container_t,
+                      false>;
 
     /// The tuple store that hold the acceleration data structures for all
     /// volumes. Every collection of accelerationdata structures defines its