Move the calculation of the surface center position into the shapes a…

…nd add an approximation for the annulus shape

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

@@ -79,6 +79,17 @@ struct surface_kernels {
         }
     };
 
+    /// A functor get the surface center in global cartesian coordinates
+    struct center {
+        template <typename mask_group_t, typename index_t>
+        DETRAY_HOST_DEVICE inline point3 operator()(
+            const mask_group_t& mask_group, const index_t& index,
+            const transform3& trf3) const {
+
+            return mask_group[index].center(trf3);
+        }
+    };
+
     /// A functor to perform global to local bound transformation
     struct global_to_bound {
         template <typename mask_group_t, typename index_t>

core/include/detray/geometry/surface.hpp

@@ -142,7 +142,7 @@ class surface {
     /// @returns the center position on the surface in global coordinates
     DETRAY_HOST_DEVICE
     constexpr auto center(const context &ctx) const -> const point3 {
-        return transform(ctx).translation();
+        return visit_mask<typename kernels::center>(transform(ctx));
     }
 
     /// @returns the surface normal in global coordinates at a given bound/local
@@ -277,7 +277,7 @@ class surface {
     /// @tparam functor_t the prescription to be applied to the mask
     /// @tparam Args      types of additional arguments to the functor
     template <typename functor_t, typename... Args>
-    DETRAY_HOST_DEVICE constexpr auto visit_mask(Args &&... args) const {
+    DETRAY_HOST_DEVICE constexpr auto visit_mask(Args &&...args) const {
         const auto &masks = m_detector.mask_store();
 
         return masks.template visit<functor_t>(m_desc.mask(),
@@ -289,7 +289,7 @@ class surface {
     /// @tparam functor_t the prescription to be applied to the mask
     /// @tparam Args      types of additional arguments to the functor
     template <typename functor_t, typename... Args>
-    DETRAY_HOST_DEVICE constexpr auto visit_material(Args &&... args) const {
+    DETRAY_HOST_DEVICE constexpr auto visit_material(Args &&...args) const {
         const auto &materials = m_detector.material_store();
 
         return materials.template visit<functor_t>(m_desc.material(),
@@ -378,10 +378,10 @@ class surface {
 
 template <typename detector_t, typename descr_t>
 DETRAY_HOST_DEVICE surface(const detector_t &, const descr_t &)
-    ->surface<detector_t>;
+    -> surface<detector_t>;
 
 template <typename detector_t>
 DETRAY_HOST_DEVICE surface(const detector_t &, const geometry::barcode)
-    ->surface<detector_t>;
+    -> surface<detector_t>;
 
 }  // namespace detray

core/include/detray/masks/annulus2D.hpp

@@ -264,6 +264,25 @@ class annulus2D {
         return corner_pos;
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(
+        const transform3_t &trf, const bounds_t<scalar_t, kDIM> &bounds) const {
+        using local_frame_t = local_frame_type<transform3_t>;
+        using point3_t = typename local_frame_t::point3;
+
+        // Strip polar system
+        const auto crns = corners(bounds);
+        auto centroid =
+            0.25f * point3_t{crns[0] + crns[2] + crns[4] + crns[6],
+                             crns[1] + crns[3] + crns[5] + crns[7], 0.f};
+
+        return local_frame_t{}.local_to_global(trf, centroid);
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the stereo annulus

core/include/detray/masks/cuboid3D.hpp

@@ -128,6 +128,16 @@ class cuboid3D {
         return o_bounds;
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t &trf,
+                                   const bounds_t<scalar_t, kDIM> &) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the cuboid

core/include/detray/masks/cylinder2D.hpp

@@ -131,6 +131,16 @@ class cylinder2D {
                 xy_bound,  xy_bound,  bounds[e_p_half_z] + env};
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t &trf,
+                                   const bounds_t<scalar_t, kDIM> &) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the cylinder

core/include/detray/masks/cylinder3D.hpp

@@ -124,6 +124,16 @@ class cylinder3D {
                 r_bound,  r_bound,  bounds[e_max_z] + env};
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t &trf,
+                                   const bounds_t<scalar_t, kDIM> &) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the cylinder

core/include/detray/masks/line.hpp

@@ -151,6 +151,16 @@ class line {
         return {-xy_bound, -xy_bound, -z_bound, xy_bound, xy_bound, z_bound};
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t &trf,
+                                   const bounds_t<scalar_t, kDIM> &) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the line

core/include/detray/masks/masks.hpp

@@ -189,6 +189,12 @@ class mask {
     DETRAY_HOST_DEVICE
     auto volume_link() -> links_type& { return _volume_link; }
 
+    /// @returns the masks center in global cartesian coordinates
+    template <typename transform3_t>
+    DETRAY_HOST_DEVICE auto center(const transform3_t& trf) const {
+        return _shape.center(trf, _values);
+    }
+
     /// @brief Lower and upper point for minimum axis aligned bounding box.
     ///
     /// Computes the min and max vertices in a local 3 dim cartesian frame.

core/include/detray/masks/rectangle2D.hpp

@@ -116,6 +116,16 @@ class rectangle2D {
         return {-x_bound, -y_bound, -env, x_bound, y_bound, env};
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t &trf,
+                                   const bounds_t<scalar_t, kDIM> &) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the stereo annulus

core/include/detray/masks/ring2D.hpp

@@ -117,6 +117,16 @@ class ring2D {
         return {-r_bound, -r_bound, -env, r_bound, r_bound, env};
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t &trf,
+                                   const bounds_t<scalar_t, kDIM> &) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the stereo annulus

core/include/detray/masks/single3D.hpp

@@ -117,6 +117,16 @@ class single3D {
         return o_bounds;
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t &trf,
+                                   const bounds_t<scalar_t, kDIM> &) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the single value

core/include/detray/masks/trapezoid2D.hpp

@@ -130,6 +130,16 @@ class trapezoid2D {
         return {-x_bound, -y_bound, -env, x_bound, y_bound, env};
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t &trf,
+                                   const bounds_t<scalar_t, kDIM> &) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the trapezoid

core/include/detray/masks/unbounded.hpp

@@ -79,6 +79,16 @@ class unbounded {
         return shape{}.template local_min_bounds<algebra_t>(bounds, env);
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <
+        typename transform3_t, template <typename, std::size_t> class bounds_t,
+        typename scalar_t, std::size_t kDIM,
+        typename std::enable_if_t<kDIM == boundaries::e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(
+        const transform3_t& trf, const bounds_t<scalar_t, kDIM>& bounds) const {
+        return shape{}.center(trf, bounds);
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values for the underlying shape

core/include/detray/masks/unmasked.hpp

@@ -94,6 +94,16 @@ class unmasked {
         return {-inf, -inf, -inf, inf, inf, inf};
     }
 
+    /// @returns the shapes center in global cartesian coordinates
+    template <typename transform3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE auto center(const transform3_t& trf,
+                                   const bounds_t<scalar_t, kDIM>&) const {
+        return trf.translation();
+    }
+
     /// Generate vertices in local cartesian frame
     ///
     /// @param bounds the boundary values

tests/unit_tests/cpu/masks_annulus2D.cpp

@@ -5,16 +5,16 @@
  * Mozilla Public License Version 2.0
  */
 
-#include <gtest/gtest.h>
-
+// Project include(s)
 #include "detray/definitions/units.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/test/types.hpp"
-#include "detray/tracks/bound_track_parameters.hpp"
+
+// GTest include
+#include <gtest/gtest.h>
 
 using namespace detray;
 using point3_t = test::point3;
-using transform3_t = test::transform3;
 
 constexpr scalar tol{1e-5f};
 

tests/unit_tests/cpu/masks_cylinder.cpp

@@ -5,16 +5,16 @@
  * Mozilla Public License Version 2.0
  */
 
-#include <gtest/gtest.h>
-
+// Project include(s)
 #include "detray/definitions/units.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/test/types.hpp"
-#include "detray/tracks/bound_track_parameters.hpp"
+
+// GTest include
+#include <gtest/gtest.h>
 
 using namespace detray;
 using point3_t = test::point3;
-using transform3_t = test::transform3;
 
 constexpr scalar tol{1e-7f};
 
@@ -41,9 +41,6 @@ GTEST_TEST(detray_masks, cylinder2D) {
     // Move outside point inside using a tolerance
     ASSERT_TRUE(c.is_inside(p2_out, 0.6f) == intersection::status::e_inside);
 
-    // Dummy bound track parameter
-    bound_track_parameters<transform3_t> bound_params;
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = c.local_min_bounds(envelope);
@@ -91,4 +88,4 @@ GTEST_TEST(detray_masks, cylinder3D) {
     ASSERT_NEAR(loc_bounds[cuboid3D<>::e_max_x], (r + envelope), tol);
     ASSERT_NEAR(loc_bounds[cuboid3D<>::e_max_y], (r + envelope), tol);
     ASSERT_NEAR(loc_bounds[cuboid3D<>::e_max_z], (hz + envelope), tol);
-}
+}

tests/unit_tests/cpu/masks_line.cpp

@@ -5,16 +5,16 @@
  * Mozilla Public License Version 2.0
  */
 
-#include <gtest/gtest.h>
-
+// Project include(s)
 #include "detray/definitions/units.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/test/types.hpp"
-#include "detray/tracks/bound_track_parameters.hpp"
+
+// GTest include
+#include <gtest/gtest.h>
 
 using namespace detray;
 using point3_t = test::point3;
-using transform3_t = test::transform3;
 
 namespace {
 
@@ -45,11 +45,6 @@ GTEST_TEST(detray_masks, line_radial_cross_sect) {
     ASSERT_TRUE(ln.is_inside(ln_out1) == intersection::status::e_outside);
     ASSERT_TRUE(ln.is_inside(ln_out2) == intersection::status::e_outside);
 
-    // Dummy bound track parameter
-    bound_track_parameters<transform3_t> bound_params;
-    auto& bound_vec = bound_params.vector();
-    getter::element(bound_vec, e_bound_loc0, 0u) = 1.f;
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = ln.local_min_bounds(envelope);
@@ -83,11 +78,6 @@ GTEST_TEST(detray_masks, line_square_cross_sect) {
     ASSERT_TRUE(ln.is_inside(ln_out1) == intersection::status::e_outside);
     ASSERT_TRUE(ln.is_inside(ln_out2) == intersection::status::e_outside);
 
-    // Dummy bound track parameter
-    bound_track_parameters<transform3_t> bound_params;
-    auto& bound_vec = bound_params.vector();
-    getter::element(bound_vec, e_bound_loc0, 0u) = -1.f;
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = ln.local_min_bounds(envelope);
@@ -97,4 +87,4 @@ GTEST_TEST(detray_masks, line_square_cross_sect) {
     ASSERT_NEAR(loc_bounds[cuboid3D<>::e_max_x], (cell_size + envelope), tol);
     ASSERT_NEAR(loc_bounds[cuboid3D<>::e_max_y], (cell_size + envelope), tol);
     ASSERT_NEAR(loc_bounds[cuboid3D<>::e_max_z], (hz + envelope), tol);
-}
+}