Introduce traccc::silicon_detector_description, main branch (2024.06.21.)

benchmarks/common/benchmarks/toy_detector_benchmark.hpp

@@ -42,6 +42,9 @@
 
 class ToyDetectorBenchmark : public benchmark::Fixture {
     public:
+    // VecMem memory resource(s)
+    vecmem::host_memory_resource host_mr;
+
     static const int n_events = 100u;
     static const int n_tracks = 5000u;
 
@@ -80,9 +83,6 @@ class ToyDetectorBenchmark : public benchmark::Fixture {
                      "the simulation data."
                   << std::endl;
 
-        // VecMem memory resource(s)
-        vecmem::host_memory_resource host_mr;
-
         // Use deterministic random number generator for testing
         using uniform_gen_t = detray::detail::random_numbers<
             traccc::scalar, std::uniform_real_distribution<traccc::scalar>>;
@@ -139,7 +139,7 @@ class ToyDetectorBenchmark : public benchmark::Fixture {
                               .replace_files(true)
                               .write_grids(true)
                               .write_material(true)
-                              .path(sim_dir);
+                              .path(full_path);
         detray::io::write_detector(det, name_map, writer_cfg);
     }
 
@@ -157,30 +157,18 @@ class ToyDetectorBenchmark : public benchmark::Fixture {
 
     void SetUp(::benchmark::State& /*state*/) {
 
-        // VecMem memory resource(s)
-        vecmem::host_memory_resource host_mr;
-
-        // Build the detector
-        auto [det, name_map] =
-            detray::build_toy_detector(host_mr, get_toy_config());
-
-        // Read geometry
-        traccc::geometry surface_transforms =
-            traccc::io::alt_read_geometry(det);
-
         // Read events
         for (std::size_t i_evt = 0; i_evt < n_events; i_evt++) {
 
             // Read the hits from the relevant event file
-            traccc::io::spacepoint_reader_output readOut(&host_mr);
-            traccc::io::read_spacepoints(readOut, i_evt, sim_dir,
-                                         surface_transforms);
-            spacepoints.push_back(readOut.spacepoints);
+            traccc::spacepoint_collection_types::host sp{&host_mr};
+            traccc::io::read_spacepoints(sp, i_evt, sim_dir);
+            spacepoints.push_back(sp);
 
             // Read measurements
-            traccc::io::measurement_reader_output meas_read_out(&host_mr);
-            traccc::io::read_measurements(meas_read_out, i_evt, sim_dir);
-            measurements.push_back(meas_read_out.measurements);
+            traccc::measurement_collection_types::host meas{&host_mr};
+            traccc::io::read_measurements(meas, i_evt, sim_dir);
+            measurements.push_back(meas);
         }
     }
 };

benchmarks/cpu/toy_detector_cpu.cpp

@@ -5,6 +5,9 @@
  * Mozilla Public License Version 2.0
  */
 
+// Traccc core include(s).
+#include "traccc/geometry/detector.hpp"
+
 // Traccc algorithm include(s).
 #include "traccc/finding/finding_algorithm.hpp"
 #include "traccc/fitting/fitting_algorithm.hpp"
@@ -13,6 +16,7 @@
 
 // Traccc IO include(s).
 #include "traccc/io/event_map2.hpp"
+#include "traccc/io/read_detector.hpp"
 #include "traccc/io/read_geometry.hpp"
 #include "traccc/io/read_measurements.hpp"
 #include "traccc/io/read_spacepoints.hpp"
@@ -41,23 +45,17 @@ BENCHMARK_F(ToyDetectorBenchmark, CPU)(benchmark::State& state) {
         detray::rk_stepper<b_field_t::view_t,
                            typename detector_type::algebra_type,
                            detray::constrained_step<>>;
-    using host_detector_type = detray::detector<detray::default_metadata>;
+    using host_detector_type = traccc::default_detector::host;
     using host_navigator_type = detray::navigator<const host_detector_type>;
     using host_fitter_type =
         traccc::kalman_fitter<rk_stepper_type, host_navigator_type>;
 
-    // VecMem memory resource(s)
-    vecmem::host_memory_resource host_mr;
-
     // Read back detector file
-    const std::string path = sim_dir;
-    detray::io::detector_reader_config reader_cfg{};
-    reader_cfg.add_file(path + "toy_detector_geometry.json")
-        .add_file(path + "toy_detector_homogeneous_material.json")
-        .add_file(path + "toy_detector_surface_grids.json");
-
-    auto [det, names] =
-        detray::io::read_detector<host_detector_type>(host_mr, reader_cfg);
+    host_detector_type det{host_mr};
+    traccc::io::read_detector(
+        det, host_mr, sim_dir + "toy_detector_geometry.json",
+        sim_dir + "toy_detector_homogeneous_material.json",
+        sim_dir + "toy_detector_surface_grids.json");
 
     // B field
     auto field = detray::bfield::create_const_field(B);
@@ -95,4 +93,4 @@ BENCHMARK_F(ToyDetectorBenchmark, CPU)(benchmark::State& state) {
 
     state.counters["event_throughput_Hz"] = benchmark::Counter(
         static_cast<double>(n_events), benchmark::Counter::kIsRate);
-}
+}

benchmarks/cuda/toy_detector_cuda.cpp

@@ -11,7 +11,9 @@
 #include "traccc/cuda/seeding/seeding_algorithm.hpp"
 #include "traccc/cuda/seeding/track_params_estimation.hpp"
 #include "traccc/device/container_d2h_copy_alg.hpp"
+#include "traccc/geometry/detector.hpp"
 #include "traccc/io/event_map2.hpp"
+#include "traccc/io/read_detector.hpp"
 #include "traccc/io/read_geometry.hpp"
 #include "traccc/io/read_measurements.hpp"
 #include "traccc/io/read_spacepoints.hpp"
@@ -45,16 +47,13 @@ BENCHMARK_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
         detray::rk_stepper<b_field_t::view_t,
                            typename detector_type::algebra_type,
                            detray::constrained_step<>>;
-    using host_detector_type = detray::detector<detray::default_metadata>;
-    using device_detector_type =
-        detray::detector<detray::default_metadata,
-                         detray::device_container_types>;
+    using host_detector_type = traccc::default_detector::host;
+    using device_detector_type = traccc::default_detector::device;
     using device_navigator_type = detray::navigator<const device_detector_type>;
     using device_fitter_type =
         traccc::kalman_fitter<rk_stepper_type, device_navigator_type>;
 
     // Memory resources used by the application.
-    vecmem::host_memory_resource host_mr;
     vecmem::cuda::host_memory_resource cuda_host_mr;
     vecmem::cuda::device_memory_resource device_mr;
     traccc::memory_resource mr{device_mr, &cuda_host_mr};
@@ -67,14 +66,11 @@ BENCHMARK_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
     vecmem::cuda::async_copy async_copy{stream.cudaStream()};
 
     // Read back detector file
-    const std::string path = sim_dir;
-    detray::io::detector_reader_config reader_cfg{};
-    reader_cfg.add_file(path + "toy_detector_geometry.json")
-        .add_file(path + "toy_detector_homogeneous_material.json")
-        .add_file(path + "toy_detector_surface_grids.json");
-
-    auto [det, names] =
-        detray::io::read_detector<host_detector_type>(mng_mr, reader_cfg);
+    host_detector_type det{mng_mr};
+    traccc::io::read_detector(
+        det, mng_mr, sim_dir + "toy_detector_geometry.json",
+        sim_dir + "toy_detector_homogeneous_material.json",
+        sim_dir + "toy_detector_surface_grids.json");
 
     // B field
     auto field = detray::bfield::create_const_field(B);
@@ -93,7 +89,7 @@ BENCHMARK_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
 
     // D2H copy object
     traccc::device::container_d2h_copy_alg<traccc::track_state_container_types>
-        track_state_d2h{mr, copy};
+        track_state_d2h{{device_mr, &host_mr}, copy};
 
     for (auto _ : state) {
 
@@ -115,20 +111,6 @@ BENCHMARK_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
             auto& spacepoints_per_event = spacepoints[i_evt];
             auto& measurements_per_event = measurements[i_evt];
 
-            // Initialize the containers
-            traccc::seed_collection_types::buffer seeds_cuda_buffer(0,
-                                                                    *(mr.host));
-            traccc::bound_track_parameters_collection_types::buffer
-                params_cuda_buffer(0, *mr.host);
-
-            traccc::track_candidate_container_types::buffer
-                track_candidates_cuda_buffer{{{}, *(mr.host)},
-                                             {{}, *(mr.host), mr.host}};
-
-            traccc::track_state_container_types::buffer
-                track_states_cuda_buffer{{{}, *(mr.host)},
-                                         {{}, *(mr.host), mr.host}};
-
             // Copy the spacepoint and module data to the device.
             traccc::spacepoint_collection_types::buffer spacepoints_cuda_buffer(
                 spacepoints_per_event.size(), mr.main);
@@ -142,23 +124,24 @@ BENCHMARK_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
                        measurements_cuda_buffer);
 
             // Run seeding
-            seeds_cuda_buffer = sa_cuda(spacepoints_cuda_buffer);
-            stream.synchronize();
+            traccc::seed_collection_types::buffer seeds_cuda_buffer =
+                sa_cuda(spacepoints_cuda_buffer);
 
             // Run track parameter estimation
-            params_cuda_buffer =
-                tp_cuda(spacepoints_cuda_buffer, seeds_cuda_buffer, B);
-            stream.synchronize();
+            traccc::bound_track_parameters_collection_types::buffer
+                params_cuda_buffer =
+                    tp_cuda(spacepoints_cuda_buffer, seeds_cuda_buffer, B);
 
             // Run CKF track finding
-            track_candidates_cuda_buffer = device_finding(
-                det_view, field, measurements_cuda_buffer, params_cuda_buffer);
-            stream.synchronize();
+            traccc::track_candidate_container_types::buffer
+                track_candidates_cuda_buffer =
+                    device_finding(det_view, field, measurements_cuda_buffer,
+                                   params_cuda_buffer);
 
             // Run track fitting
-            track_states_cuda_buffer =
-                device_fitting(det_view, field, track_candidates_cuda_buffer);
-            stream.synchronize();
+            traccc::track_state_container_types::buffer
+                track_states_cuda_buffer = device_fitting(
+                    det_view, field, track_candidates_cuda_buffer);
 
             // Create a temporary buffer that will receive the device memory.
             auto size = track_states_cuda_buffer.headers.size();
@@ -168,20 +151,9 @@ BENCHMARK_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
                            capacities.begin(),
                            [](const auto& view) { return view.capacity(); });
 
-            traccc::track_state_container_types::buffer
-                track_states_host_buffer{{size, *(mr.host)},
-                                         {capacities, *(mr.host), mr.host}};
-            host_copy.setup(track_states_host_buffer.headers);
-            host_copy.setup(track_states_host_buffer.items);
-
-            // Copy the device container into this temporary host buffer.
-            vecmem::copy::event_type header_event =
-                copy(track_states_cuda_buffer.headers,
-                     track_states_host_buffer.headers,
-                     vecmem::copy::type::device_to_host);
-            vecmem::copy::event_type item_event = copy(
-                track_states_cuda_buffer.items, track_states_host_buffer.items,
-                vecmem::copy::type::device_to_host);
+            // Copy the track states back to the host.
+            traccc::track_state_container_types::host track_states_host =
+                track_state_d2h(track_states_cuda_buffer);
         }
     }
 

core/CMakeLists.txt

@@ -32,9 +32,11 @@ traccc_add_library( traccc_core core TYPE SHARED
   "include/traccc/edm/track_state.hpp"
   "include/traccc/edm/cell.hpp"
   # Geometry description.
+  "include/traccc/geometry/detector.hpp"
   "include/traccc/geometry/module_map.hpp"
   "include/traccc/geometry/geometry.hpp"
   "include/traccc/geometry/pixel_data.hpp"
+  "include/traccc/geometry/silicon_detector_description.hpp"
   # Utilities.
   "include/traccc/utils/algorithm.hpp"
   "include/traccc/utils/type_traits.hpp"
@@ -103,7 +105,7 @@ traccc_add_library( traccc_core core TYPE SHARED
   "include/traccc/ambiguity_resolution/greedy_ambiguity_resolution_algorithm.hpp"
   "src/ambiguity_resolution/greedy_ambiguity_resolution_algorithm.cpp" )
 target_link_libraries( traccc_core
-  PUBLIC Eigen3::Eigen vecmem::core detray::core traccc::Thrust
+  PUBLIC Eigen3::Eigen vecmem::core detray::core detray::utils traccc::Thrust
          traccc::algebra )
 
 # Prevent Eigen from getting confused when building code for a

core/include/traccc/clusterization/clusterization_algorithm.hpp

@@ -12,6 +12,7 @@
 #include "traccc/clusterization/sparse_ccl_algorithm.hpp"
 #include "traccc/edm/cell.hpp"
 #include "traccc/edm/measurement.hpp"
+#include "traccc/geometry/silicon_detector_description.hpp"
 #include "traccc/utils/algorithm.hpp"
 
 // VecMem include(s).
@@ -31,7 +32,7 @@ namespace traccc::host {
 class clusterization_algorithm
     : public algorithm<measurement_collection_types::host(
           const cell_collection_types::const_view&,
-          const cell_module_collection_types::const_view&)> {
+          const silicon_detector_description::const_view&)> {
 
     public:
     using config_type = std::monostate;
@@ -45,12 +46,12 @@ class clusterization_algorithm
     /// Construct measurements for each detector module
     ///
     /// @param cells_view The cells for every detector module in the event
-    /// @param modules_view A collection of detector modules
+    /// @param dd_view The detector description
     /// @return The measurements reconstructed for every detector module
     ///
-    output_type operator()(const cell_collection_types::const_view& cells_view,
-                           const cell_module_collection_types::const_view&
-                               modules_view) const override;
+    output_type operator()(
+        const cell_collection_types::const_view& cells_view,
+        const silicon_detector_description::const_view& dd_view) const override;
 
     private:
     /// @name Sub-algorithms used by this algorithm

core/include/traccc/clusterization/details/measurement_creation.hpp

@@ -12,46 +12,50 @@
 #include "traccc/definitions/qualifiers.hpp"
 #include "traccc/edm/cell.hpp"
 #include "traccc/edm/measurement.hpp"
+#include "traccc/geometry/silicon_detector_description.hpp"
 
 namespace traccc::details {
 
 /// Function used for retrieving the cell signal based on the module id
 TRACCC_HOST_DEVICE
-inline scalar signal_cell_modelling(scalar signal_in, const cell_module& mod);
+inline scalar signal_cell_modelling(
+    scalar signal_in, const silicon_detector_description::const_device&);
 
 /// Function for pixel segmentation
 TRACCC_HOST_DEVICE
-inline vector2 position_from_cell(const cell& cell, const cell_module& mod);
+inline vector2 position_from_cell(
+    const cell& cell,
+    const silicon_detector_description::const_device& det_descr);
 
 /// Function used for calculating the properties of the cluster during
 /// measurement creation
 ///
-/// @param[in] cluster The vector of cells describing the identified cluster
-/// @param[in] mod     The cell module
-/// @param[out] mean   The mean position of the cluster/measurement
-/// @param[out] var    The variation on the mean position of the
-///                    cluster/measurement
+/// @param[in] cluster   The vector of cells describing the identified cluster
+/// @param[in] det_descr The detector description
+/// @param[out] mean     The mean position of the cluster/measurement
+/// @param[out] var      The variation on the mean position of the
+///                      cluster/measurement
 /// @param[out] totalWeight The total weight of the cluster/measurement
 ///
 TRACCC_HOST_DEVICE inline void calc_cluster_properties(
-    const cell_collection_types::const_device& cluster, const cell_module& mod,
-    point2& mean, point2& var, scalar& totalWeight);
+    const cell_collection_types::const_device& cluster,
+    const silicon_detector_description::const_device& det_descr, point2& mean,
+    point2& var, scalar& totalWeight);
 
 /// Function used for calculating the properties of the cluster during
 /// measurement creation
 ///
-/// @param[out] measurements is the measurement collection where the measurement
-///                          object will be filled
-/// @param[in] measurement_index is the index of the measurement object to fill
-/// @param[in] cluster is the input cell vector
-/// @param[in] mod  is the cell module where the cluster belongs to
-/// @param[in] mod_link is the module index
+/// @param[out] measurements Measurement collection where the measurement is to
+///                          be filled
+/// @param[in] index     Index of the measurement object to fill
+/// @param[in] cluster   Cell vector describing the measurement's cluster
+/// @param[in] det_descr Detector description
 ///
 TRACCC_HOST_DEVICE inline void fill_measurement(
     measurement_collection_types::device& measurements,
-    std::size_t measurement_index,
-    const cell_collection_types::const_device& cluster, const cell_module& mod,
-    const unsigned int mod_link);
+    measurement_collection_types::device::size_type index,
+    const cell_collection_types::const_device& cluster,
+    const silicon_detector_description::const_device& det_descr);
 
 }  // namespace traccc::details