feat: use free-threading IRT1 when detected as thread-safe (#2370)

### Briefly, what does this PR introduce?
This PR makes avoids locking IRT1 when a thread-safe IRT1 is detected
(e.g. the version with the changes in
eic/irt#49). If a thread-unsafe IRT1 is
detected, we continue locking.

### What kind of change does this PR introduce?
- [ ] Bug fix (issue #__)
- [x] New feature (issue: avoid locking IRT in EICrecon code with
thread-safe design)
- [ ] Documentation update
- [ ] Other: __

### Please check if this PR fulfills the following:
- [ ] Tests for the changes have been added
- [ ] Documentation has been added / updated
- [ ] Changes have been communicated to collaborators

### Does this PR introduce breaking changes? What changes might users
need to make to their code?
No.

### Does this PR change default behavior?
No.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: wdconinc <4656391+wdconinc@users.noreply.github.com>

Author: 4 people

src/algorithms/pid/IrtCherenkovParticleID.cc

@@ -24,6 +24,7 @@
 #include <podio/RelationRange.h>
 #include <algorithm>
 #include <cmath>
+#include <concepts>
 #include <cstddef>
 #include <functional>
 #include <iterator>
@@ -36,9 +37,66 @@
 #include "algorithms/pid/IrtCherenkovParticleIDConfig.h"
 #include "algorithms/pid/Tools.h"
 
+// Feature detection: Check if RadiatorHistory has GetLocations() method
+namespace {
+template <typename T>
+concept HasGetLocations = requires(const T& t) {
+  { t.GetLocations() } -> std::same_as<const std::vector<std::pair<TVector3, TVector3>>&>;
+};
+
+constexpr bool IRT_HAS_RADIATOR_HISTORY_GET_LOCATIONS = HasGetLocations<RadiatorHistory>;
+
+// Helper classes using template specialization to call appropriate methods
+// We use templated helper methods and delayed name lookup to avoid
+// compilation errors when methods don't exist in the unused specialization
+template <bool UseRadiatorHistory> struct IrtHelpers;
+
+// Specialization for new IRT (RadiatorHistory has the methods)
+template <> struct IrtHelpers<true> {
+  template <typename RH, typename CR>
+  static void SetTrajectoryBinCount(RH* rad_history, CR* /*rad*/, unsigned bins) {
+    rad_history->SetTrajectoryBinCount(bins);
+  }
+
+  template <typename RH, typename CR> static void ResetLocations(RH* rad_history, CR* /*rad*/) {
+    rad_history->ResetLocations();
+  }
+
+  template <typename RH, typename CR>
+  static void AddLocation(RH* rad_history, CR* /*rad*/, const TVector3& x, const TVector3& n) {
+    rad_history->AddLocation(x, n);
+  }
+};
+
+// Specialization for old IRT (CherenkovRadiator has the methods)
+template <> struct IrtHelpers<false> {
+  template <typename RH, typename CR>
+  static void SetTrajectoryBinCount(RH* /*rad_history*/, CR* rad, unsigned bins) {
+    rad->SetTrajectoryBinCount(bins);
+  }
+
+  template <typename RH, typename CR> static void ResetLocations(RH* /*rad_history*/, CR* rad) {
+    rad->ResetLocations();
+  }
+
+  template <typename RH, typename CR>
+  static void AddLocation(RH* /*rad_history*/, CR* rad, const TVector3& x, const TVector3& n) {
+    rad->AddLocation(x, n);
+  }
+};
+
+using IrtHelper = IrtHelpers<IRT_HAS_RADIATOR_HISTORY_GET_LOCATIONS>;
+} // namespace
+
 namespace eicrecon {
 
 void IrtCherenkovParticleID::init(CherenkovDetectorCollection* irt_det_coll) {
+  // lock for old IRT versions that use shared radiator state
+  [[maybe_unused]] std::unique_lock<std::mutex> lock;
+  if constexpr (!IRT_HAS_RADIATOR_HISTORY_GET_LOCATIONS) {
+    lock = std::unique_lock<std::mutex>(m_irt_det_mutex);
+  }
+
   // members
   m_irt_det_coll = irt_det_coll;
 
@@ -77,7 +135,6 @@ void IrtCherenkovParticleID::init(CherenkovDetectorCollection* irt_det_coll) {
   trace("Rebinning refractive index tables to have {} bins", m_cfg.numRIndexBins);
   for (auto [rad_name, irt_rad] : m_irt_det->Radiators()) {
     // FIXME: m_cfg.numRIndexBins should be a service configurable
-    std::lock_guard<std::mutex> lock(m_irt_det_mutex);
     auto ri_lookup_table_orig = irt_rad->m_ri_lookup_table;
     if (ri_lookup_table_orig.size() != m_cfg.numRIndexBins) {
       irt_rad->m_ri_lookup_table.clear();
@@ -97,7 +154,6 @@ void IrtCherenkovParticleID::init(CherenkovDetectorCollection* irt_det_coll) {
 
   // check radiators' configuration, and pass it to `m_irt_det`'s radiators
   for (auto [rad_name, irt_rad] : m_pid_radiators) {
-    std::lock_guard<std::mutex> lock(m_irt_det_mutex);
     // find `cfg_rad`, the associated `IrtCherenkovParticleIDConfig` radiator
     auto cfg_rad_it = m_cfg.radiators.find(rad_name);
     if (cfg_rad_it != m_cfg.radiators.end()) {
@@ -179,9 +235,13 @@ void IrtCherenkovParticleID::process(const IrtCherenkovParticleID::Input& input,
     auto irt_particle = std::make_unique<ChargedParticle>();
 
     // loop over radiators
-    // note: this must run exclusively since irt_rad points to shared IRT objects that are
-    // owned by the RichGeo_service; it holds state (e.g. irt_rad->ResetLocation())
-    std::lock_guard<std::mutex> lock(m_irt_det_mutex);
+    // note: for old IRT versions, this must run exclusively since irt_rad points to shared IRT
+    // objects that are owned by the RichGeo_service; it holds state (e.g. IrtHelpers::ResetLocations())
+    [[maybe_unused]] std::unique_lock<std::mutex> lock;
+    if constexpr (!IRT_HAS_RADIATOR_HISTORY_GET_LOCATIONS) {
+      lock = std::unique_lock<std::mutex>(m_irt_det_mutex);
+    }
+
     for (auto [rad_name, irt_rad] : m_pid_radiators) {
 
       // get the `charged_particle` for this radiator
@@ -198,21 +258,23 @@ void IrtCherenkovParticleID::process(const IrtCherenkovParticleID::Input& input,
         trace("No propagated track points in radiator '{}'", rad_name);
         continue;
       }
-      irt_rad->SetTrajectoryBinCount(charged_particle.points_size() - 1);
 
       // start a new IRT `RadiatorHistory`
       // - must be a raw pointer for `irt` compatibility
       // - it will be destroyed when `irt_particle` is destroyed
       auto* irt_rad_history = new RadiatorHistory();
+
+      IrtHelper::SetTrajectoryBinCount(irt_rad_history, irt_rad,
+                                       charged_particle.points_size() - 1);
       irt_particle->StartRadiatorHistory({irt_rad, irt_rad_history});
 
       // loop over `TrackPoint`s of this `charged_particle`, adding each to the IRT radiator
-      irt_rad->ResetLocations();
+      IrtHelper::ResetLocations(irt_rad_history, irt_rad);
       trace("TrackPoints in '{}' radiator:", rad_name);
       for (const auto& point : charged_particle.getPoints()) {
         TVector3 position = Tools::PodioVector3_to_TVector3(point.position);
         TVector3 momentum = Tools::PodioVector3_to_TVector3(point.momentum);
-        irt_rad->AddLocation(position, momentum);
+        IrtHelper::AddLocation(irt_rad_history, irt_rad, position, momentum);
         trace(Tools::PrintTVector3(" point: x", position));
         trace(Tools::PrintTVector3("        p", momentum));
       }

src/algorithms/pid/IrtCherenkovParticleID.h

@@ -59,7 +59,10 @@ class IrtCherenkovParticleID : public IrtCherenkovParticleIDAlgorithm,
   void process(const Input&, const Output&) const;
 
 private:
-  // any access (R or W) to m_irt_det_coll, m_irt_det, m_pid_radiators must be locked
+  // Locking for m_irt_det_coll, m_irt_det, m_pid_radiators:
+  // - Required for old/non-thread-safe IRT versions (detected by !IRT_HAS_RADIATOR_HISTORY_GET_LOCATIONS)
+  //   that use shared radiator state
+  // - Not required for newer thread-safe IRT versions (IRT_HAS_RADIATOR_HISTORY_GET_LOCATIONS)
   inline static std::mutex m_irt_det_mutex;
   CherenkovDetectorCollection* m_irt_det_coll;
   CherenkovDetector* m_irt_det;