Split track_finding_analysis into multiple pieces.

So that it would be easier to introduce additional performance
measurements in the next step(s).

Author: krasznaa

examples/run/cpu/seq_example.cpp

@@ -23,7 +23,7 @@
 #include "traccc/seeding/track_params_estimation.hpp"
 
 // performance
-#include "traccc/efficiency/track_finding_analysis.hpp"
+#include "traccc/efficiency/track_finding_efficiency.hpp"
 #include "traccc/performance/timer.hpp"
 
 // options
@@ -160,12 +160,14 @@ int seq_run(const traccc::opts::input_data& input_opts,
     traccc::greedy_ambiguity_resolution_algorithm resolution_alg;
 
     // Performance analysis object(s).
-    std::unique_ptr<traccc::performance::track_finding_analysis>
+    std::unique_ptr<traccc::performance::track_finding_efficiency>
         track_finding_efficiency;
     if (performance_opts.run) {
         track_finding_efficiency =
-            std::make_unique<traccc::performance::track_finding_analysis>(
-                traccc::performance::track_finding_analysis::config{});
+            std::make_unique<traccc::performance::track_finding_efficiency>(
+                traccc::performance::track_finding_efficiency::config{},
+                traccc::performance::truth_filtering::config{},
+                traccc::performance::truth_matching::config{});
     }
 
     // Timers

performance/CMakeLists.txt

@@ -21,8 +21,8 @@ traccc_add_library( traccc_performance performance TYPE SHARED
    "src/efficiency/nseed_performance_writer.cpp"
    "src/efficiency/track_filter.cpp"
    "src/efficiency/track_matcher.cpp"
-   "include/traccc/efficiency/track_finding_analysis.hpp"
-   "src/efficiency/track_finding_analysis.cpp"
+   "include/traccc/efficiency/track_finding_efficiency.hpp"
+   "src/efficiency/track_finding_efficiency.cpp"
    # Resolution calculation code.
    "include/traccc/resolution/fitting_performance_writer.hpp"
    "include/traccc/resolution/res_plot_tool_config.hpp"
@@ -37,6 +37,11 @@ traccc_add_library( traccc_performance performance TYPE SHARED
    "include/traccc/utils/helpers.hpp"
    "src/utils/helpers.hpp"
    "src/utils/helpers.cpp"
+   # Reconstruction performance measurement helper/base code.
+   "include/traccc/performance/truth_filtering.hpp"
+   "src/performance/truth_filtering.cpp"
+   "include/traccc/performance/truth_matching.hpp"
+   "src/performance/truth_matching.cpp"
    # Value/object comparison code.
    "include/traccc/performance/details/is_same_angle.hpp"
    "src/performance/details/is_same_angle.cpp"

performance/include/traccc/efficiency/track_finding_analysis.hpp

@@ -0,0 +1,77 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Library include(s).
+#include "traccc/performance/truth_filtering.hpp"
+#include "traccc/performance/truth_matching.hpp"
+#include "traccc/utils/helpers.hpp"
+
+// Project include(s).
+#include "traccc/definitions/common.hpp"
+#include "traccc/edm/particle.hpp"
+#include "traccc/edm/track_candidate.hpp"
+
+// System include(s).
+#include <cmath>
+#include <memory>
+#include <string>
+
+namespace traccc::performance {
+
+// Forward declaration(s).
+namespace details {
+struct track_finding_efficiency_data;
+}
+
+/// Tool for analyzing the track finding efficiency
+class track_finding_efficiency : public truth_filtering, public truth_matching {
+
+    public:
+    /// Configuration for the efficiency analysis
+    struct config {
+
+        /// Name of the output file to write
+        std::string m_output_name{"track_finding_efficiency.root"};
+
+        /// Binning for the efficiency vs. eta plot
+        plot_helpers::binning m_eta_binning{
+            "Track Finding Efficiency vs. #eta;#eta", 40, -3.f, 3.f};
+        /// Binning for the efficiency vs. phi plot
+        plot_helpers::binning m_phi_binning{
+            "Track Finding Efficiency vs. #phi;#phi", 40, -M_PI, M_PI};
+        /// Binning for the efficiency vs. pT plot
+        plot_helpers::binning m_pt_binning{
+            "Track Finding Efficiency vs. p_{T};p_{T}", 40, 0.f, 120.f};
+
+    };  // struct config
+
+    /// Constructor with a configuration
+    track_finding_efficiency(const config& eff_cfg,
+                             const truth_filtering::config& filter_cfg,
+                             const truth_matching::config& matching_cfg);
+    /// Destructor
+    ~track_finding_efficiency();
+
+    /// Analyze the tracks found in a specific event.
+    ///
+    /// @param reco The reconstructed particle tracks
+    /// @param truth The truth particles
+    ///
+    void analyze(const track_candidate_container_types::const_view& reco,
+                 const particle_container_types::const_view& truth);
+
+    private:
+    /// Configuration for the track finding efficiency measurement
+    config m_config;
+    /// Internal data used by the class
+    std::unique_ptr<details::track_finding_efficiency_data> m_data;
+
+};  // class track_finding_efficiency
+
+}  // namespace traccc::performance

performance/include/traccc/efficiency/track_finding_efficiency.hpp

@@ -0,0 +1,50 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/definitions/common.hpp"
+#include "traccc/edm/particle.hpp"
+
+// System include(s).
+#include <vector>
+
+namespace traccc::performance {
+
+/// Class providing truth particle filtering
+class truth_filtering {
+
+    public:
+    /// Configuration for the truth particle filtering.
+    struct config {
+        /// Truth particle PDG IDs to take into consideration
+        std::vector<int> m_truth_pdgids{-13, 13};
+        /// Minimum truth pT to take into consideration
+        float m_truth_pt_min{500.f * unit<float>::MeV};
+        /// Maximum (absolute) truth pseudorapidity to take into consideration
+        float m_truth_eta_max{3.0f};
+    };  // struct config
+
+    /// Constructor with a configuration
+    truth_filtering(const config& cfg);
+
+    /// Function checking whether a truth particle passes the filter
+    ///
+    /// @param truth The truth particle
+    ///
+    /// @return Whether the truth particle passes the filter
+    ///
+    bool passes(const particle& truth) const;
+
+    private:
+    /// Configuration for the truth particle filtering.
+    config m_config;
+
+};  // class truth_filtering
+
+}  // namespace traccc::performance

performance/include/traccc/performance/truth_filtering.hpp

@@ -0,0 +1,81 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/definitions/common.hpp"
+#include "traccc/edm/measurement.hpp"
+#include "traccc/edm/particle.hpp"
+#include "traccc/edm/seed.hpp"
+#include "traccc/edm/track_candidate.hpp"
+
+namespace traccc::performance {
+
+/// Class providing reco <-> truth track matching
+///
+/// It can be used either on its own to check the match between reconstructed
+/// and truth tracks, or as a base class for classes that do some higher level
+/// performance analysis.
+///
+class truth_matching {
+
+    public:
+    /// Configuration for the track matching
+    struct config {
+        /// Uncertainty in millimeters, withing which measurements would match
+        float m_measurement_uncertainty{1.f * unit<float>::mm};
+        /// Fraction of reco measurements required to match truth measurements
+        float m_measurement_match{1.0};
+    };  // struct config
+
+    /// Constructor with a configuration
+    truth_matching(const config& cfg);
+
+    /// Function checking whether a truth particle and a track seed match
+    ///
+    /// @param reco The track seed
+    /// @param spacepoints The spacepoint collection that the seeds refer to
+    /// @param truth The truth particle
+    ///
+    /// @return Whether the seed matches the truth particle
+    ///
+    bool matches(
+        const seed& reco,
+        const spacepoint_collection_types::const_view spacepoints,
+        const particle_container_types::const_device::const_element_view& truth)
+        const;
+
+    /// Function checking whether a truth particle and reconstructed track match
+    ///
+    /// @param reco The reconstructed track
+    /// @param truth The truth particle
+    ///
+    /// @return Whether the reconstructed track matches the truth particle
+    ///
+    bool matches(
+        const track_candidate_container_types::const_device::const_element_view&
+            reco,
+        const particle_container_types::const_device::const_element_view& truth)
+        const;
+
+    /// Function checking whether two measurement objects match
+    ///
+    /// @param reco The reconstructed measurement
+    /// @param truth The truth measurement
+    ///
+    /// @return Wehther the measurements match
+    ///
+    bool matches(const measurement& reco, const measurement& truth) const;
+
+    private:
+    /// Configuration for the tool
+    config m_config;
+
+};  // class truth_matching
+
+}  // namespace traccc::performance