A bunch of patches and hacks to make sure single_store::at() does not get called with default context

Author: Vakho Tsulaia

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

@@ -71,12 +71,12 @@ struct neighborhood_getter {
     DETRAY_HOST_DEVICE inline void operator()(
         const accel_group_t &group, const accel_index_t index,
         const detector_t &det, const typename detector_t::volume_type &volume,
-        const track_t &track, const config_t &cfg, Args &&... args) const {
+        const track_t &track, const config_t &cfg, const typename detector_t::geometry_context& ctx, Args &&... args) const {
 
         decltype(auto) accel = group[index];
 
         // Run over the surfaces in a single acceleration data structure
-        for (const auto &sf : accel.search(det, volume, track, cfg)) {
+        for (const auto &sf : accel.search(det, volume, track, cfg, ctx)) {
             functor_t{}(sf, std::forward<Args>(args)...);
         }
     }

core/include/detray/geometry/tracking_volume.hpp

@@ -44,6 +44,7 @@ class tracking_volume {
 
     /// Volume descriptor type
     using descr_t = typename detector_t::volume_type;
+    using context_t = typename detector_t::geometry_context;
 
     public:
     /// In case the geometry needs to be printed
@@ -154,9 +155,9 @@ class tracking_volume {
               int I = static_cast<int>(descr_t::object_id::e_size) - 1,
               typename track_t, typename config_t, typename... Args>
     DETRAY_HOST_DEVICE constexpr void visit_neighborhood(
-        const track_t &track, const config_t &cfg, Args &&... args) const {
+        const track_t &track, const config_t &cfg, const context_t &ctx, Args &&... args) const {
         visit_surfaces_impl<detail::neighborhood_getter<functor_t>>(
-            m_detector, m_desc, track, cfg, std::forward<Args>(args)...);
+	    m_detector, m_desc, track, cfg, ctx, std::forward<Args>(args)...);
     }
 
     /// Call a functor on the volume material with additional arguments.

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

@@ -60,7 +60,8 @@ class brute_force_collection {
             const detector_t& /*det*/,
             const typename detector_t::volume_type& /*volume*/,
             const track_t& /*track*/,
-            const config_t& /*navigation_config*/) const {
+	    const config_t& /*navigation_config*/,
+	    const typename detector_t::geometry_context& /*ctx*/) const {
             return *this;
         }
 

core/include/detray/navigation/intersection_kernel.hpp

@@ -50,11 +50,11 @@ struct intersection_initialize {
             {0.f, 1.f * unit<scalar_t>::mm},
         const scalar_t mask_tol_scalor = 0.f,
         const scalar_t overstep_tol = 0.f) const {
-
+      typename transform_container_t::context_type ctx{0}; // Hack!
         using mask_t = typename mask_group_t::value_type;
         using algebra_t = typename mask_t::algebra_type;
 
-        const auto &ctf = contextual_transforms.at(surface.transform());
+        const auto &ctf = contextual_transforms.at(surface.transform(),ctx);
 
         // Run over the masks that belong to the surface (only one can be hit)
         for (const auto &mask :
@@ -142,8 +142,8 @@ struct intersection_update {
 
         using mask_t = typename mask_group_t::value_type;
         using algebra_t = typename mask_t::algebra_type;
-
-        const auto &ctf = contextual_transforms.at(sfi.sf_desc.transform());
+        typename transform_container_t::context_type ctx{0}; // Hack!
+        const auto &ctf = contextual_transforms.at(sfi.sf_desc.transform(),ctx);
 
         // Run over the masks that belong to the surface
         for (const auto &mask :

core/include/detray/navigation/navigator.hpp

@@ -122,6 +122,7 @@ class navigator {
     using vector3_type = dvector3D<algebra_type>;
 
     using volume_type = typename detector_type::volume_type;
+    using context_type  = typename detector_t::geometry_context;
     using nav_link_type = typename detector_type::surface_type::navigation_link;
     using intersection_type = intersection_t;
     using inspector_type = inspector_t;
@@ -621,7 +622,8 @@ class navigator {
     /// @param propagation contains the stepper and navigator states
     template <typename propagator_state_t>
     DETRAY_HOST_DEVICE inline bool init(propagator_state_t &propagation,
-                                        const navigation::config &cfg) const {
+                                        const navigation::config &cfg,
+					const context_type& ctx = {}) const {
 
         state &navigation = propagation._navigation;
         const auto &det = navigation.detector();
@@ -634,7 +636,7 @@ class navigator {
 
         // Search for neighboring surfaces and fill candidates into cache
         volume.template visit_neighborhood<candidate_search>(
-            track, cfg, det, track, navigation,
+            track, cfg, ctx, det, track, navigation,
             std::array<scalar_type, 2u>{cfg.min_mask_tolerance,
                                         cfg.max_mask_tolerance},
             static_cast<scalar_type>(cfg.mask_tolerance_scalor),

core/include/detray/propagator/actors/parameter_resetter.hpp

@@ -70,7 +70,7 @@ struct parameter_resetter : actor {
 
         using geo_cxt_t =
             typename propagator_state_t::detector_type::geometry_context;
-        const geo_cxt_t ctx{};
+        const geo_cxt_t ctx{0}; // Hack!
 
         // Surface
         const auto sf = navigation.get_surface();

core/include/detray/propagator/actors/parameter_transporter.hpp

@@ -99,7 +99,7 @@ struct parameter_transporter : actor {
 
         using detector_type = typename propagator_state_t::detector_type;
         using geo_cxt_t = typename detector_type::geometry_context;
-        const geo_cxt_t ctx{};
+        const geo_cxt_t ctx{0}; // Hack!
 
         // Current Surface
         const auto sf = navigation.get_surface();

core/include/detray/propagator/actors/pointwise_material_interactor.hpp

@@ -142,7 +142,7 @@ struct pointwise_material_interactor : actor {
 
             auto &stepping = prop_state._stepping;
 
-            this->update(geo_context_type{}, stepping._ptc,
+            this->update(geo_context_type{0}, stepping._ptc,         // Hack!
                          stepping._bound_params, interactor_state,
                          static_cast<int>(navigation.direction()),
                          navigation.get_surface());

core/include/detray/propagator/base_stepper.hpp

@@ -91,13 +91,13 @@ class base_stepper {
         template <typename detector_t>
         DETRAY_HOST_DEVICE state(
             const bound_track_parameters_type &bound_params,
-            const detector_t &det)
+            const detector_t &det,
+	    const typename detector_t::geometry_context& ctx = {})
             : _bound_params(bound_params) {
 
             // Surface
             const auto sf = tracking_surface{det, bound_params.surface_link()};
 
-            const typename detector_t::geometry_context ctx{};
             sf.template visit_mask<
                 typename parameter_resetter<algebra_t>::kernel>(
                 sf.transform(ctx), sf.index(), *this);

core/include/detray/propagator/propagation_config.hpp

@@ -11,6 +11,7 @@
 #include "detray/definitions/detail/qualifiers.hpp"
 #include "detray/navigation/navigation_config.hpp"
 #include "detray/propagator/stepping_config.hpp"
+#include "detray/core/detail/data_context.hpp"
 
 // System inlcudes
 #include <ostream>
@@ -21,6 +22,7 @@ namespace detray::propagation {
 struct config {
     navigation::config navigation{};
     stepping::config stepping{};
+    geometry_context context{};
 };
 
 /// Print the propagation configuration
@@ -31,7 +33,9 @@ inline std::ostream& operator<<(std::ostream& out,
         << "----------------------------\n"
         << cfg.navigation << "\nParameter Transport\n"
         << "----------------------------\n"
-        << cfg.stepping << "\n";
+        << cfg.stepping << "\nGeometry Context\n"
+        << "----------------------------\n"
+        << cfg.context.get() << "\n";
 
     return out;
 }

core/include/detray/propagator/propagator.hpp

@@ -34,6 +34,7 @@ struct propagator {
     using navigator_type = navigator_t;
     using intersection_type = typename navigator_type::intersection_type;
     using detector_type = typename navigator_type::detector_type;
+    using context_type = typename detector_type::geometry_context;
     using actor_chain_type = actor_chain_t;
     using algebra_type = typename stepper_t::algebra_type;
     using scalar_type = dscalar<algebra_type>;
@@ -60,6 +61,7 @@ struct propagator {
     struct state {
 
         using detector_type = typename navigator_t::detector_type;
+        using context_type = typename detector_type::geometry_context;
         using navigator_state_type = typename navigator_t::state;
         using actor_chain_type = actor_chain_t;
         using scalar_type = typename navigator_t::scalar_type;
@@ -101,8 +103,9 @@ struct propagator {
         template <typename field_t>
         DETRAY_HOST_DEVICE state(const bound_track_parameters_type &param,
                                  const field_t &magnetic_field,
-                                 const detector_type &det)
-            : _stepping(param, magnetic_field, det), _navigation(det) {}
+                                 const detector_type &det,
+				 const context_type &ctx = {})
+	  : _stepping(param, magnetic_field, det, ctx), _navigation(det) {}
 
         /// Set the particle hypothesis
         DETRAY_HOST_DEVICE
@@ -135,7 +138,7 @@ struct propagator {
 
         // Initialize the navigation
         propagation._heartbeat =
-            m_navigator.init(propagation, m_cfg.navigation);
+            m_navigator.init(propagation, m_cfg.navigation, m_cfg.context);
 
         // Run all registered actors/aborters after init
         run_actors(actor_state_refs, propagation);

core/include/detray/propagator/rk_stepper.hpp

@@ -66,8 +66,8 @@ class rk_stepper final
         template <typename detector_t>
         DETRAY_HOST_DEVICE state(
             const bound_track_parameters_type& bound_params,
-            const magnetic_field_t& mag_field, const detector_t& det)
-            : base_type::state(bound_params, det), _magnetic_field(mag_field) {}
+            const magnetic_field_t& mag_field, const detector_t& det, const typename detector_t::geometry_context& ctx = {})
+	  : base_type::state(bound_params, det, ctx), _magnetic_field(mag_field) {}
 
         /// stepping data required for RKN4
         struct {

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

@@ -273,10 +273,12 @@ class grid_impl {
     template <typename detector_t, typename track_t, typename config_t>
     DETRAY_HOST_DEVICE auto search(
         const detector_t &det, const typename detector_t::volume_type &volume,
-        const track_t &track, const config_t &cfg) const {
+        const track_t &track, const config_t &cfg, const typename detector_t::geometry_context& /*ctx*/) const {
 
         // Track position in grid coordinates
-        const auto &trf = det.transform_store().at(volume.transform());
+//        const auto &trf = det.transform_store().at(volume.transform(),ctx);
+        typename detector_t::geometry_context cttx{0}; // Hack!
+        const auto &trf = det.transform_store().at(volume.transform(),cttx);
         const auto loc_pos = project(trf, track.pos(), track.dir());
 
         // Grid lookup