Fix compilation

Author: niermann999

core/include/detray/builders/bin_fillers.hpp

@@ -9,7 +9,6 @@
 
 // Project include(s).
 #include "detray/builders/detail/bin_association.hpp"
-#include "detray/navigation/accelerators/concepts.hpp"
 #include "detray/utils/grid/detail/axis.hpp"
 #include "detray/utils/grid/detail/concepts.hpp"
 #include "detray/utils/grid/populators.hpp"

core/include/detray/builders/detector_builder.hpp

@@ -1,20 +1,16 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2023 CERN for the benefit of the ACTS project
+ * (c) 2023-2025 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
 // Project include(s).
-#include "detray/builders/grid_factory.hpp"
 #include "detray/builders/volume_builder.hpp"
 #include "detray/builders/volume_builder_interface.hpp"
 #include "detray/core/detector.hpp"
-#include "detray/definitions/geometry.hpp"
-#include "detray/utils/grid/detail/concepts.hpp"
-#include "detray/utils/type_traits.hpp"
 
 // Vecmem include(s)
 #include <vecmem/memory/memory_resource.hpp>
@@ -30,7 +26,6 @@ namespace detray {
 /// @brief Provides functionality to build a detray detector volume by volume
 ///
 /// @tparam metadata the type definitions for the detector
-/// @tparam bfield_bknd_t the type of magnetic field to be used
 /// @tparam volume_builder_t the basic volume builder to be used for the
 ///                          geometry data
 /// @tparam volume_data_t the data structure that holds the volume builders
@@ -141,48 +136,12 @@ class detector_builder {
         return build(resource);
     }
 
-    /// Put the volumes into a search data structure
-    /*template <typename... Args>
-    DETRAY_HOST void set_volume_accelerator([[maybe_unused]] Args&&... args) {
-
-        using vol_finder_t = typename detector_type::volume_accelerator;
-
-        // Add dummy volume grid for now
-        if constexpr (concepts::grid<vol_finder_t>) {
-
-            // TODO: Construct it correctly with the grid builder
-            mask<cylinder3D, algebra_type> vgrid_dims{
-                0u,      0.f,   -constant<scalar_type>::pi,
-                -2000.f, 180.f, constant<scalar_type>::pi,
-                2000.f};
-            darray<std::size_t, 3> n_vgrid_bins{1u, 1u, 1u};
-
-            darray<std::vector<scalar_type>, 3UL> bin_edges{
-                std::vector<scalar_type>{0.f, 180.f},
-                std::vector<scalar_type>{-constant<scalar_type>::pi,
-                                         constant<scalar_type>::pi},
-                std::vector<scalar_type>{-2000.f, 2000.f}};
-
-            grid_factory_type<vol_finder_t> vgrid_factory{};
-            m_vol_finder = vgrid_factory.template new_grid<
-                axis::open<axis::label::e_r>,
-                axis::circular<axis::label::e_phi>,
-                axis::open<axis::label::e_z>, axis::irregular<scalar_type>,
-                axis::regular<scalar_type>, axis::irregular<scalar_type>>(
-                vgrid_dims, n_vgrid_bins, {}, bin_edges);
-        } else {
-            m_vol_finder = vol_finder_t{args...};
-        }
-    }*/
-
     private:
     /// Name of the new detector
     std::string m_detector_name{"detray_detector"};
     /// Data structure that holds a volume builder for every detector volume
     volume_data_t<std::unique_ptr<volume_builder_interface<detector_type>>>
         m_volumes{};
-    /// Data structure to find volumes
-    // typename detector_type::volume_accelerator m_vol_finder{};
 };
 
 }  // namespace detray

core/include/detray/builders/grid_builder.hpp

@@ -14,6 +14,8 @@
 #include "detray/builders/volume_builder.hpp"
 #include "detray/builders/volume_builder_interface.hpp"
 #include "detray/geometry/tracking_volume.hpp"
+#include "detray/navigation/accelerators/concepts.hpp"
+#include "detray/navigation/accelerators/spatial_grid.hpp"
 #include "detray/utils/grid/detail/concepts.hpp"
 
 // System include(s)
@@ -40,7 +42,7 @@ class grid_builder : public volume_decorator<detector_t> {
     using value_type = typename detector_type::surface_type;
     using scalar_type = dscalar<algebra_type>;
 
-    /// Decorate a volume with a grid
+    /// Decorate a volume with a surface accelerator grid
     DETRAY_HOST
     explicit grid_builder(
         std::unique_ptr<volume_builder_interface<detector_t>> vol_builder)
@@ -58,13 +60,13 @@ class grid_builder : public volume_decorator<detector_t> {
     }
 
     /// Set the surface category this grid should contain (type id in the
-    /// accelrator link in the volume)
+    /// accelerator link in the volume descriptor)
     void set_type(std::size_t sf_id) {
         set_type(static_cast<link_id_t>(sf_id));
     }
 
     /// Set the surface category this grid should contain (type id in the
-    /// accelrator link in the volume)
+    /// accelerator link in the volume descriptor)
     void set_type(link_id_t sf_id) {
         // Exclude zero, it is reserved for the brute force method
         assert(static_cast<int>(sf_id) > 0);
@@ -182,11 +184,19 @@ 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>()};
+        // Is the given grid type already an acceleration structure?
+        using spatial_grid_t =
+            std::conditional_t<concepts::surface_accelerator<grid_t>, grid_t,
+                               spatial_grid_impl<grid_t>>;
+        constexpr auto gid{
+            detector_t::accel::template get_id<spatial_grid_t>()};
+        const dindex grid_idx{det.accelerator_store().template size<gid>()};
+
+        // Set: contained surface type, grid type, grid instance index
+        vol_ptr->set_accel_link(m_id, gid, grid_idx);
+
+        // Add to detector
         det._accelerators.template push_back<gid>(m_grid);
-        vol_ptr->set_link(m_id, gid,
-                          det.accelerator_store().template size<gid>() - 1);
 
         return vol_ptr;
     }
@@ -198,6 +208,7 @@ class grid_builder : public volume_decorator<detector_t> {
     private:
     link_id_t m_id{link_id_t::e_sensitive};
     grid_factory_t m_factory{};
+    // Data owning grid type, so that surface data can be filled into memory
     typename grid_t::template type<true> m_grid{};
     bin_filler_t m_bin_filler{};
     bool m_add_passives{false};

core/include/detray/builders/surface_factory.hpp

@@ -162,15 +162,12 @@ class surface_factory : public surface_factory_interface<detector_t> {
             return {surfaces_offset, surfaces_offset};
         }
 
-        constexpr auto mask_id = detector_t::masks::template get_id<
-            mask<mask_shape_t, algebra_t, volume_link_t>>();
-        if constexpr (static_cast<std::size_t>(mask_id) >=
-                      detector_t::masks::n_types) {
+        using mask_t = mask<mask_shape_t, algebra_t, volume_link_t>;
+        if constexpr (!detector_t::masks::template is_defined<mask_t>()) {
 
             throw std::invalid_argument(
-                "ERROR: Cannot match shape type to mask ID: Found " +
-                std::string(mask_shape_t::name) + " at mask id " +
-                std::to_string(static_cast<std::size_t>(mask_id)));
+                "ERROR: Cannot match shape type to mask ID. Shape type: " +
+                std::string(mask_shape_t::name));
 
         } else {
 
@@ -180,6 +177,8 @@ class surface_factory : public surface_factory_interface<detector_t> {
 
             // The material will be added in a later step
             constexpr auto no_material{surface_t::material_id::e_none};
+            constexpr auto mask_id =
+                detector_t::masks::template get_id<mask_t>();
 
             for (const auto [idx, bounds_per_mask] :
                  detray::views::enumerate(m_bounds)) {

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/detail/multi_store.hpp

@@ -14,7 +14,6 @@
 #include "detray/core/detail/tuple_container.hpp"
 #include "detray/definitions/detail/qualifiers.hpp"
 #include "detray/definitions/indexing.hpp"
-#include "detray/utils/type_list.hpp"
 #include "detray/utils/type_registry.hpp"
 #include "detray/utils/type_traits.hpp"
 
@@ -29,13 +28,11 @@ namespace detray {
 /// @brief Wraps a vecmem enabled tuple and adds functionality to handle data
 /// collections @tparam Ts.
 ///
-/// @tparam An enum of type IDs that needs to match the value types of the
-/// @tparam Ts pack.
+/// @tparam An enum of type IDs that needs to match the value types of the Ts
+/// pack.
 /// @tparam context_t How to retrieve data according to e.g. conditions data
 /// @tparam tuple_t The type of the underlying tuple container.
-/// @tparam container_t The type of container to use for the respective
-///                     data collections.
-/// @tparam Ts the data types (value types of the collections)
+/// @tparam Ts the data collection types
 template <typename ID = std::size_t, typename context_t = empty_context,
           template <typename...> class tuple_t = dtuple, typename... Ts>
 class multi_store {
@@ -53,10 +50,8 @@ class multi_store {
     /// How to find and index a data collection in the store
     /// @{
     using ids = ID;
-    template <typename index_t>
-    using link_type = dtyped_index<ID, index_t>;
-    using single_link = link_type<dindex>;
-    using range_link = link_type<index_range_t>;
+    using single_link = dtyped_index<ID, dindex>;
+    using range_link = dtyped_index<ID, index_range_t>;
     /// @}
 
     /// Allow matching between IDs and collection value types
@@ -387,7 +382,7 @@ class multi_store {
     tuple_type m_tuple_container;
 };
 
-/// Helper type for a data store that uses a sinlge collection container
+/// Helper type for a data store that uses a single collection container
 template <typename ID, typename context_t, template <typename...> class tuple_t,
           template <typename...> class container_t, typename... Ts>
 using regular_multi_store =

core/include/detray/core/detail/single_store.hpp

@@ -43,7 +43,6 @@ class single_store {
 
     /// How to find data in the store
     /// @{
-    using link_type = dindex;
     using single_link = dindex;
     using range_link = dindex_range;
     /// @}

core/include/detray/core/detector.hpp

@@ -221,15 +221,16 @@ class detector {
     /// @return the volume by global cartesian @param position - const access
     DETRAY_HOST_DEVICE
     inline const auto &volume(const point3_type &p) const {
-        volume_type v_desc{};
         // 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_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 =
-            world.template visit_accelerator<geo_obj_ids::e_volume,
-                                             volume_search>(p);
+        dindex volume_index{0u};
+        world.template visit_accelerator<geo_obj_ids::e_volume, volume_search>(
+            p, &volume_index);
         return _volumes[volume_index];
     }
 
@@ -309,19 +310,23 @@ class detector {
         ///@TODO: Move this to a volume search grid type
         template <concepts::accelerator_collection accel_coll_t,
                   typename accel_index_t>
-        DETRAY_HOST_DEVICE inline dindex operator()(
-            const accel_coll_t &coll, const accel_index_t index,
-            const point3_type &p) const {
+        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];
+                const auto volume_accelerator = coll[index];
 
-            // The 3D cylindrical volume search grid is concentric
-            const transform3_type identity{};
-            const auto loc_pos =
-                volume_accelerator.project(identity, p, identity.translation());
+                // The 3D cylindrical volume search grid is concentric
+                const transform3_type identity{};
 
-            // Only one entry per bin
-            return volume_accelerator.search(loc_pos).value();
+                // Only one entry per bin
+                *result = volume_accelerator.search(p).value();
+            }
         }
     };
 

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

@@ -14,6 +14,7 @@
 #include "detray/materials/detail/concepts.hpp"
 #include "detray/materials/detail/material_accessor.hpp"
 #include "detray/materials/material.hpp"
+#include "detray/navigation/accelerators/search_window.hpp"
 #include "detray/navigation/concepts.hpp"
 
 namespace detray::detail {
@@ -96,31 +97,33 @@ struct neighborhood_getter {
     /// to a surface finder data structure
     template <concepts::accelerator_collection accel_coll_t,
               typename accel_index_t, typename detector_t, typename track_t,
-              typename config_t, typename... Args>
+              concepts::arithmetic window_size_t, typename... Args>
     DETRAY_HOST_DEVICE inline void operator()(
         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 track_t &track, const search_window<window_size_t, 2> &win_size,
         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, win_size, ctx)) {
+                functor_t{}(sf, std::forward<Args>(args)...);
+            }
+        } else if constexpr (concepts::volume_accelerator<accel_type>) {
+            // Run over the daughter volumes in a single acceleration data
+            // structure
+            for (const dindex daughter_idx :
+                 accel.search(det, volume, track, win_size, ctx)) {
+                functor_t{}(daughter_idx, std::forward<Args>(args)...);
+            }
         }
     }
 };
 
-/// Query the maximal number of candidates from the acceleration
-struct n_candidates_getter {
-    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();
-    }
-};
-
 }  // namespace detray::detail