Adapted traccc::performance to the SoA track fit EDM.

Author: krasznaa

performance/CMakeLists.txt

@@ -44,16 +44,19 @@ traccc_add_library( traccc_performance performance TYPE SHARED
    "src/performance/details/is_same_scalar.cpp"
    "include/traccc/performance/details/is_same_object.hpp"
    "include/traccc/performance/impl/is_same_object.ipp"
-   "include/traccc/performance/impl/is_same_fitting_result.ipp"
    "include/traccc/performance/impl/is_same_seed.ipp"
    "include/traccc/performance/impl/is_same_measurement.ipp"
    "include/traccc/performance/impl/is_same_spacepoint.ipp"
    "include/traccc/performance/impl/is_same_track_candidate.ipp"
+   "include/traccc/performance/impl/is_same_track_fit.ipp"
    "include/traccc/performance/impl/is_same_track_parameters.ipp"
+   "include/traccc/performance/impl/is_same_track_state.ipp"
    "src/performance/details/is_same_object.cpp"
    "include/traccc/performance/details/comparator_factory.hpp"
    "include/traccc/performance/impl/comparator_factory.ipp"
    "include/traccc/performance/impl/seed_comparator_factory.ipp"
+   "include/traccc/performance/impl/track_candidate_comparator_factory.ipp"
+   "include/traccc/performance/impl/track_fit_comparator_factory.ipp"
    # Collection/container comparison code.
    "include/traccc/performance/collection_comparator.hpp"
    "include/traccc/performance/impl/collection_comparator.ipp"

performance/include/traccc/efficiency/finding_performance_writer.hpp

@@ -14,8 +14,10 @@
 #include "traccc/utils/truth_matching_config.hpp"
 
 // Project include(s).
+#include "traccc/edm/measurement.hpp"
 #include "traccc/edm/track_candidate_collection.hpp"
-#include "traccc/edm/track_state.hpp"
+#include "traccc/edm/track_fit_collection.hpp"
+#include "traccc/edm/track_state_collection.hpp"
 #include "traccc/utils/event_data.hpp"
 
 // System include(s).
@@ -73,8 +75,13 @@ class finding_performance_writer : public messaging {
         const measurement_collection_types::const_view& measurements_view,
         const event_data& evt_data);
 
-    void write(const track_state_container_types::const_view& track_states_view,
-               const event_data& evt_data);
+    void write(
+        const edm::track_fit_collection<default_algebra>::const_view&
+            track_fit_view,
+        const edm::track_state_collection<default_algebra>::const_view&
+            track_states_view,
+        const measurement_collection_types::const_view& measurements_view,
+        const event_data& evt_data);
 
     void finalize();
 

performance/include/traccc/performance/details/comparator_factory.hpp

@@ -42,3 +42,4 @@ class comparator_factory {
 // Include the specialised implementation(s).
 #include "traccc/performance/impl/seed_comparator_factory.ipp"
 #include "traccc/performance/impl/track_candidate_comparator_factory.ipp"
+#include "traccc/performance/impl/track_fit_comparator_factory.ipp"

performance/include/traccc/performance/details/is_same_object.hpp

@@ -45,9 +45,10 @@ class is_same_object {
 #include "traccc/performance/impl/is_same_object.ipp"
 
 // Include specialisations for the core library types
-#include "traccc/performance/impl/is_same_fitting_result.ipp"
 #include "traccc/performance/impl/is_same_measurement.ipp"
 #include "traccc/performance/impl/is_same_seed.ipp"
 #include "traccc/performance/impl/is_same_spacepoint.ipp"
 #include "traccc/performance/impl/is_same_track_candidate.ipp"
+#include "traccc/performance/impl/is_same_track_fit.ipp"
 #include "traccc/performance/impl/is_same_track_parameters.ipp"
+#include "traccc/performance/impl/is_same_track_state.ipp"

performance/include/traccc/performance/details/projector.hpp

@@ -47,12 +47,4 @@ struct projector<traccc::bound_track_parameters<algebra_t>> {
     }
 };
 
-template <>
-struct projector<fitting_result<traccc::default_algebra>> {
-    static constexpr bool exists = true;
-
-    float operator()(const fitting_result<traccc::default_algebra>& i) {
-        return static_cast<float>(i.trk_quality.ndf);
-    }
-};
 }  // namespace traccc::details

performance/include/traccc/performance/impl/is_same_fitting_result.ipp

@@ -0,0 +1,105 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023-2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/edm/measurement.hpp"
+#include "traccc/edm/track_fit_collection.hpp"
+#include "traccc/edm/track_state_collection.hpp"
+
+// Local include(s).
+#include "traccc/performance/impl/is_same_track_state.ipp"
+
+namespace traccc::details {
+
+/// @c traccc::is_same_object specialisation for @c traccc::edm::track_fit<T>
+template <typename T>
+class is_same_object<edm::track_fit<T>> {
+
+    public:
+    /// Constructor with a reference object, and an allowed uncertainty
+    is_same_object(
+        const measurement_collection_types::const_view& ref_meas,
+        const measurement_collection_types::const_view& test_meas,
+        const edm::track_state_collection<default_algebra>::const_view&
+            ref_states,
+        const edm::track_state_collection<default_algebra>::const_view&
+            test_states,
+        const edm::track_fit<T>& ref, scalar unc = float_epsilon)
+        : m_ref_meas(ref_meas),
+          m_test_meas(test_meas),
+          m_ref_states(ref_states),
+          m_test_states(test_states),
+          m_ref(ref),
+          m_unc(unc) {}
+
+    /// Specialised implementation for @c traccc::edm::track_fit<T>
+    bool operator()(const edm::track_fit<T>& obj) const {
+
+        // Compare the fit outcomes.
+        if (obj.fit_outcome() != m_ref.fit_outcome()) {
+            return false;
+        }
+        // Compare the parameters.
+        if (!is_same_object<bound_track_parameters<>>(m_ref.params(),
+                                                      m_unc)(obj.params())) {
+            return false;
+        }
+        // Compare the scalar values.
+        if (!is_same_scalar(obj.ndf(), m_ref.ndf(), m_unc) ||
+            !is_same_scalar(obj.chi2(), m_ref.chi2(), m_unc) ||
+            !is_same_scalar(obj.pval(), m_ref.pval(), m_unc)) {
+            return false;
+        }
+        // Compare the number of holes.
+        if (obj.nholes() != m_ref.nholes()) {
+            return false;
+        }
+
+        // The two tracks need to have the same number of states.
+        if (obj.state_indices().size() != m_ref.state_indices().size()) {
+            return false;
+        }
+
+        // Now compare the track states one by one.
+        const edm::track_state_collection<default_algebra>::const_device
+            ref_states{m_ref_states};
+        const edm::track_state_collection<default_algebra>::const_device
+            test_states{m_test_states};
+        for (unsigned int i = 0; i < obj.state_indices().size(); ++i) {
+            if (!is_same_object<edm::track_state_collection<
+                    default_algebra>::const_device::const_proxy_type>(
+                    m_ref_meas, m_test_meas,
+                    ref_states.at(m_ref.state_indices()[i]),
+                    m_unc)(test_states.at(obj.state_indices()[i]))) {
+                return false;
+            }
+        }
+
+        // If we got here, the two track fits are the same.
+        return true;
+    }
+
+    private:
+    /// Measurements for the reference object
+    const measurement_collection_types::const_view m_ref_meas;
+    /// Measurements for the test object
+    const measurement_collection_types::const_view m_test_meas;
+    /// States for the reference object
+    const edm::track_state_collection<default_algebra>::const_view m_ref_states;
+    /// States for the test object
+    const edm::track_state_collection<default_algebra>::const_view
+        m_test_states;
+    /// The reference object
+    const edm::track_fit<T> m_ref;
+    /// The uncertainty
+    scalar m_unc;
+
+};  // class is_same_object<edm::track_fit<T>>
+
+}  // namespace traccc::details

performance/include/traccc/performance/impl/is_same_track_fit.ipp

@@ -0,0 +1,82 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023-2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/edm/measurement.hpp"
+#include "traccc/edm/track_state_collection.hpp"
+
+// Local include(s).
+#include "traccc/performance/impl/is_same_measurement.ipp"
+
+namespace traccc::details {
+
+/// @c traccc::is_same_object specialisation for
+/// @c traccc::edm::track_state_collection
+template <typename T>
+class is_same_object<edm::track_state<T>> {
+
+    public:
+    /// Constructor with a reference object, and an allowed uncertainty
+    is_same_object(const measurement_collection_types::const_view& ref_meas,
+                   const measurement_collection_types::const_view& test_meas,
+                   const edm::track_state<T>& ref, scalar unc = float_epsilon)
+        : m_ref_meas(ref_meas),
+          m_test_meas(test_meas),
+          m_ref(ref),
+          m_unc(unc) {}
+
+    /// Specialised implementation for @c traccc::edm::track_state<T>
+    bool operator()(const edm::track_state<T>& obj) const {
+
+        // Compare the state words.
+        if (obj.state() != m_ref.state()) {
+            return false;
+        }
+        // Compare the chi2 values.
+        if (!is_same_scalar(obj.filtered_chi2(), m_ref.filtered_chi2(),
+                            m_unc) ||
+            !is_same_scalar(obj.smoothed_chi2(), m_ref.smoothed_chi2(),
+                            m_unc) ||
+            !is_same_scalar(obj.backward_chi2(), m_ref.backward_chi2(),
+                            m_unc)) {
+            return false;
+        }
+        // Compare the fitted parameters.
+        if (!is_same_object<bound_track_parameters<>>(
+                m_ref.filtered_params(), m_unc)(obj.filtered_params()) ||
+            !is_same_object<bound_track_parameters<>>(
+                m_ref.smoothed_params(), m_unc)(obj.smoothed_params())) {
+            return false;
+        }
+        // Compare the measurements that they point at.
+        const measurement_collection_types::const_device ref_meas{m_ref_meas};
+        const measurement_collection_types::const_device test_meas{m_test_meas};
+        if (!is_same_object<measurement>(
+                ref_meas.at(m_ref.measurement_index()),
+                m_unc)(test_meas.at(obj.measurement_index()))) {
+            return false;
+        }
+
+        // If we got here, the two track states are the same.
+        return true;
+    }
+
+    private:
+    /// Measurements for the reference object
+    const measurement_collection_types::const_view m_ref_meas;
+    /// Measurements for the test object
+    const measurement_collection_types::const_view m_test_meas;
+    /// The reference object
+    const edm::track_state<T> m_ref;
+    /// The uncertainty
+    scalar m_unc;
+
+};  // class is_same_object<edm::track_state<T>>
+
+}  // namespace traccc::details

performance/include/traccc/performance/impl/is_same_track_state.ipp

@@ -0,0 +1,60 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/edm/measurement.hpp"
+#include "traccc/edm/track_fit_collection.hpp"
+#include "traccc/edm/track_state_collection.hpp"
+
+// Local include(s).
+#include "traccc/performance/details/is_same_object.hpp"
+
+namespace traccc::details {
+
+/// @c traccc::details::comparator_factory specialisation for
+/// @c traccc::edm::track_fit
+template <typename T>
+class comparator_factory<edm::track_fit<T>> {
+
+    public:
+    /// Constructor with all necessary arguments
+    comparator_factory(
+        const measurement_collection_types::const_view& ref_meas,
+        const measurement_collection_types::const_view& test_meas,
+        const edm::track_state_collection<default_algebra>::const_view&
+            ref_states,
+        const edm::track_state_collection<default_algebra>::const_view&
+            test_states)
+        : m_ref_meas(ref_meas),
+          m_test_meas(test_meas),
+          m_ref_states(ref_states),
+          m_test_states(test_states) {}
+
+    /// Instantiate an instance of a comparator object
+    is_same_object<edm::track_fit<T>> make_comparator(
+        const edm::track_fit<T>& ref, scalar unc = float_epsilon) const {
+
+        return is_same_object<edm::track_fit<T>>(
+            m_ref_meas, m_test_meas, m_ref_states, m_test_states, ref, unc);
+    }
+
+    private:
+    /// Measurement container for the reference track candidates
+    const measurement_collection_types::const_view m_ref_meas;
+    /// Measurement container for the test track candidates
+    const measurement_collection_types::const_view m_test_meas;
+    /// States for the reference object
+    const edm::track_state_collection<default_algebra>::const_view m_ref_states;
+    /// States for the test object
+    const edm::track_state_collection<default_algebra>::const_view
+        m_test_states;
+
+};  // class comparator_factory
+
+}  // namespace traccc::details