Merge branch 'adye-ckf44' into 'main'

tidy from TrackFindingAlg into TrackFindingMeasurements

See merge request atlas/athena!69997

Tracking/Acts/ActsConfig/python/ActsTrackFindingConfig.py

@@ -24,11 +24,19 @@ def ActsTrackStatePrinterCfg(flags,
 
     kwargs.setdefault("InputSpacePoints", isdet(flags, ["ITkPixelSpacePoints"], ["ITkStripSpacePoints", "ITkStripOverlapSpacePoints"]))
 
-    from ActsConfig.ActsEventCnvConfig import ActsToTrkConverterToolCfg
-    kwargs.setdefault(
-        "ATLASConverterTool",
-        acc.popToolsAndMerge(ActsToTrkConverterToolCfg(flags)),
-    )
+    if 'TrackingGeometryTool' not in kwargs:
+        from ActsConfig.ActsGeometryConfig import ActsTrackingGeometryToolCfg
+        kwargs.setdefault(
+            "TrackingGeometryTool",
+            acc.popToolsAndMerge(ActsTrackingGeometryToolCfg(flags)),
+        )
+
+    if 'ATLASConverterTool' not in kwargs:
+        from ActsConfig.ActsEventCnvConfig import ActsToTrkConverterToolCfg
+        kwargs.setdefault(
+            "ATLASConverterTool",
+            acc.popToolsAndMerge(ActsToTrkConverterToolCfg(flags)),
+        )
 
     acc.setPrivateTools(CompFactory.ActsTrk.TrackStatePrinter(name, **kwargs))
     return acc

Tracking/Acts/ActsTrackReconstruction/src/TrackFindingAlg.cxx

@@ -263,10 +263,7 @@ namespace ActsTrk
 
     // MEASUREMENTS
     std::vector<const xAOD::UncalibratedMeasurementContainer *> uncalibratedMeasurementContainers;
-    std::vector<xAOD::UncalibMeasType> measType;
-    std::array<std::size_t, TrackingSurfaceHelper::s_NMeasTypes> measCount{};
     uncalibratedMeasurementContainers.reserve(m_uncalibratedMeasurementContainerKeys.size());
-    measType.reserve(m_uncalibratedMeasurementContainerKeys.size());
     std::size_t measTotal = 0;
     for (const auto &uncalibratedMeasurementContainerKey : m_uncalibratedMeasurementContainerKeys)
     {
@@ -275,18 +272,6 @@ namespace ActsTrk
       ATH_CHECK(uncalibratedMeasurementContainerHandle.isValid());
       uncalibratedMeasurementContainers.push_back(uncalibratedMeasurementContainerHandle.cptr());
       ATH_MSG_DEBUG("Retrieved " << uncalibratedMeasurementContainers.back()->size() << " input elements from key " << uncalibratedMeasurementContainerKey.key());
-
-      xAOD::UncalibMeasType typ = !uncalibratedMeasurementContainers.back()->empty()
-                                      ? uncalibratedMeasurementContainers.back()->at(0)->type()
-                                      : xAOD::UncalibMeasType::Other;
-      auto ind = static_cast<std::size_t>(typ);
-      if (!(ind < TrackingSurfaceHelper::s_NMeasTypes))
-      {
-        ATH_MSG_FATAL("Measurements " << uncalibratedMeasurementContainerKey.key() << " type " << ind << " larger than " << TrackingSurfaceHelper::s_NMeasTypes - 1);
-        return StatusCode::FAILURE;
-      }
-      measType.push_back(typ);
-      measCount.at(ind) += uncalibratedMeasurementContainers.back()->size();
       measTotal += uncalibratedMeasurementContainers.back()->size();
     }
 
@@ -314,34 +299,20 @@ namespace ActsTrk
       duplicateSeedDetector.addSeeds(icontainer, *seedContainers[icontainer]);
     }
 
+    TrackFindingMeasurements measurements(measTotal);
+
     // @TODO make this condition data
-    std::array<std::vector<const Acts::Surface *>, TrackingSurfaceHelper::s_NMeasTypes> acts_surfaces;
-    std::vector<Acts::GeometryIdentifier> geo_ids;
-    geo_ids.reserve(measTotal);
-    for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer)
-    {
-      auto ind = static_cast<std::size_t>(measType[icontainer]);
-      acts_surfaces.at(ind).reserve(measCount[ind]);
-      gatherGeoIds(*m_ATLASConverterTool, *detEleColl[icontainer], geo_ids, acts_surfaces.at(ind));
+    for (std::size_t icontainer = 0; icontainer < detEleColl.size(); ++icontainer) {
+      measurements.addDetectorElements(*detEleColl[icontainer], *uncalibratedMeasurementContainers[icontainer], m_ATLASConverterTool);
     }
-    std::sort(geo_ids.begin(), geo_ids.end());
 
-    TrackingSurfaceHelper tracking_surface_helper(std::move(acts_surfaces));
-
-    TrackFindingMeasurements measurements(geo_ids);
-
-    for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer)
-    {
-      if (measType[icontainer] != xAOD::UncalibMeasType::Other)
-      {
-        tracking_surface_helper.setSiDetectorElements(measType[icontainer], detEleColl[icontainer]);
-      }
+    // NB. must complete all addDetectorElements() before addMeasurements(), so don't combine these loops!
+    for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer) {
       ATH_MSG_DEBUG("Create " << uncalibratedMeasurementContainers[icontainer]->size() << " source links from measurements in " << m_uncalibratedMeasurementContainerKeys[icontainer].key());
       measurements.addMeasurements(icontainer, *uncalibratedMeasurementContainers[icontainer], *detEleColl[icontainer], m_ATLASConverterTool);
     }
 
-    if (!m_trackStatePrinter.empty())
-    {
+    if (!m_trackStatePrinter.empty()) {
       m_trackStatePrinter->printMeasurements(ctx, uncalibratedMeasurementContainers, detEleColl, measurements.measurementOffsetVector());
     }
 
@@ -370,7 +341,6 @@ namespace ActsTrk
         continue;
       ATH_CHECK(findTracks(ctx,
                            measurements,
-                           tracking_surface_helper,
                            duplicateSeedDetector,
                            *estimatedTrackParametersContainers[icontainer],
                            seedContainers[icontainer],
@@ -448,7 +418,6 @@ namespace ActsTrk
   StatusCode
   TrackFindingAlg::findTracks(const EventContext &ctx,
                               const TrackFindingMeasurements &measurements,
-                              const TrackingSurfaceHelper &tracking_surface_helper,
                               DuplicateSeedDetector &duplicateSeedDetector,
                               const ActsTrk::BoundTrackParametersContainer &estimatedTrackParameters,
                               const ActsTrk::SeedContainer *seeds,
@@ -496,7 +465,7 @@ namespace ActsTrk
     // Therefore, passing them without checking if they are enabled is safe.
     OnTrackCalibrator calibrator = OnTrackCalibrator<ActsTrk::MutableTrackStateBackend>(
 	*m_ATLASConverterTool,
-	tracking_surface_helper,
+	measurements.trackingSurfaceHelper(),
 	m_pixelCalibTool,
 	m_stripCalibTool);
 
@@ -558,7 +527,7 @@ namespace ActsTrk
         // Perform KF before CKF
         const auto fittedSeedCollection = m_fitterTool->fit(ctx, *(*seeds)[iseed], *initialParameters,
                                                             tgContext, mfContext, calContext,
-                                                            tracking_surface_helper);
+                                                            measurements.trackingSurfaceHelper());
         if (not fittedSeedCollection)
         {
           ATH_MSG_WARNING("KF Fitted Track is nullptr");

Tracking/Acts/ActsTrackReconstruction/src/TrackFindingAlg.h

@@ -33,7 +33,6 @@
 #include "xAODMeasurementBase/UncalibratedMeasurement.h"
 #include "GeoPrimitives/GeoPrimitives.h"
 #include "GaudiKernel/EventContext.h"
-#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
 
 // Other
 #include <limits>
@@ -47,7 +46,6 @@
 #include "StoreGate/WriteHandleKey.h"
 #include "ActsEvent/TrackContainerHandlesHelper.h"
 
-class TrackingSurfaceHelper;
 namespace
 {
   // Forward-declare internal classes defined in TrackFindingData.h and used only in TrackFindingAlg.cxx.
@@ -156,7 +154,6 @@ namespace ActsTrk
     StatusCode
     findTracks(const EventContext &ctx,
                const TrackFindingMeasurements &measurements,
-               const TrackingSurfaceHelper &tracking_surface_helper,
                DuplicateSeedDetector &duplicateSeedDetector,
                const ActsTrk::BoundTrackParametersContainer &estimatedTrackParameters,
                const ActsTrk::SeedContainer *seeds,

Tracking/Acts/ActsTrackReconstruction/src/TrackFindingData.h

@@ -16,8 +16,10 @@
 #include "Acts/TrackFinding/CombinatorialKalmanFilter.hpp"
 #include "Acts/TrackFinding/TrackSelector.hpp"
 #include "InDetReadoutGeometry/SiDetectorElement.h"
+#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
 
 #include "ActsGeometry/ATLASSourceLink.h"
+#include "ActsGeometry/TrackingSurfaceHelper.h"
 #include "ActsEventCnv/IActsToTrkConverterTool.h"
 #include "src/ITrackStatePrinter.h"
 
@@ -339,25 +341,51 @@ namespace
   // === TrackFindingMeasurements ============================================
 
   // Helper class to convert xAOD::PixelClusterContainer or xAOD::StripClusterContainer to UncalibSourceLinkMultiset.
-  class TrackFindingMeasurements
-  {
+  class TrackFindingMeasurements {
   public:
-    TrackFindingMeasurements(const std::vector<Acts::GeometryIdentifier> &ordered_geo_ids)
-        : m_orderedGeoIds(&ordered_geo_ids)
-    {
-      m_measurementRanges.resize(m_orderedGeoIds->size(), MeasurementRange());
-      m_measurementOffset.reserve(2); // pixels+strips
+    TrackFindingMeasurements(std::size_t measTotal) {
+      m_orderedGeoIds.reserve(measTotal);
+      m_measurementOffset.reserve(2);  // pixels+strips
     }
 
     TrackFindingMeasurements() = delete;
     TrackFindingMeasurements(const TrackFindingMeasurements &) = delete;
     TrackFindingMeasurements &operator=(const TrackFindingMeasurements &) = delete;
 
+    void addDetectorElements(const InDetDD::SiDetectorElementCollection &detElems,
+                             const xAOD::UncalibratedMeasurementContainer &clusterContainer,
+                             const ToolHandle<ActsTrk::IActsToTrkConverterTool> &ATLASConverterTool) {
+      auto measType = static_cast<std::size_t>(clusterContainerMeasType(clusterContainer));
+      if (!(measType < m_actsSurfaces.size())) {
+        std::stringstream msg;
+        msg << "Measurements of type " << measType << " larger than " << m_actsSurfaces.size() - 1;
+        throw std::runtime_error(msg.str());
+      }
+      m_actsSurfaces[measType].reserve(m_actsSurfaces[measType].size() + clusterContainer.size());  // may extend previous data, but usually starts from empty
+      gatherGeoIds(*ATLASConverterTool, detElems, m_orderedGeoIds, m_actsSurfaces[measType]);
+      m_sorted = false;
+    }
+
+    // NB. all addDetectorElements() must have been done before calling first addMeasurements().
     void addMeasurements(size_t typeIndex,
                          const xAOD::UncalibratedMeasurementContainer &clusterContainer,
                          const InDetDD::SiDetectorElementCollection &detElems,
-                         const ToolHandle<ActsTrk::IActsToTrkConverterTool> &ATLASConverterTool)
-    {
+                         const ToolHandle<ActsTrk::IActsToTrkConverterTool> &ATLASConverterTool) {
+      if (!m_sorted) {
+        std::sort(m_orderedGeoIds.begin(), m_orderedGeoIds.end());
+        m_sorted = true;
+        m_measurementRanges.resize(m_orderedGeoIds.size());
+      }
+
+      if (!m_trackingSurfaceHelper) {
+        m_trackingSurfaceHelper = std::make_unique<TrackingSurfaceHelper>(std::move(m_actsSurfaces));
+      }
+
+      xAOD::UncalibMeasType measType = clusterContainerMeasType(clusterContainer);
+      if (measType != xAOD::UncalibMeasType::Other) {
+        m_trackingSurfaceHelper->setSiDetectorElements(measType, &detElems);
+      }
+
       // m_measurementOffset only needed for TrackStatePrinter, but it is trivial overhead to save it for each event
       if (!(typeIndex < m_measurementOffset.size()))
         m_measurementOffset.resize(typeIndex + 1);
@@ -387,8 +415,8 @@ namespace
         {
           const Acts::Surface &surface = ATLASConverterTool->trkSurfaceToActsSurface(elem->surface());
           std::vector<Acts::GeometryIdentifier>::const_iterator
-              geo_iter = std::lower_bound(m_orderedGeoIds->begin(), m_orderedGeoIds->end(), surface.geometryId());
-          if (geo_iter == m_orderedGeoIds->end() || *geo_iter != surface.geometryId())
+              geo_iter = std::lower_bound(m_orderedGeoIds.begin(), m_orderedGeoIds.end(), surface.geometryId());
+          if (geo_iter == m_orderedGeoIds.end() || *geo_iter != surface.geometryId())
           {
             std::stringstream msg;
             msg << "Measurement with unexpected Acts geometryId: " << surface.geometryId()
@@ -396,7 +424,7 @@ namespace
                 << " idHash=" << measurement->identifierHash();
             throw std::runtime_error(msg.str());
           }
-          range_idx = geo_iter - m_orderedGeoIds->begin();
+          range_idx = geo_iter - m_orderedGeoIds.begin();
           if (m_measurementRanges[range_idx].first != std::numeric_limits<unsigned int>::max())
           {
             std::stringstream msg;
@@ -434,16 +462,23 @@ namespace
 
     size_t measurementOffset(size_t typeIndex) const { return typeIndex < m_measurementOffset.size() ? m_measurementOffset[typeIndex] : 0u; }
     std::vector<size_t> measurementOffsetVector() const { return m_measurementOffset; }
-
-    const std::vector<Acts::GeometryIdentifier> &orderedGeoIds() const { return *m_orderedGeoIds; }
+    const std::vector<Acts::GeometryIdentifier> &orderedGeoIds() const { return m_orderedGeoIds; }
     const MeasurementRangeList &measurementRanges() const { return m_measurementRanges; }
+    const TrackingSurfaceHelper &trackingSurfaceHelper() const { return *m_trackingSurfaceHelper; }
 
   private:
-    std::vector<size_t> m_measurementOffset;
-    const std::vector<Acts::GeometryIdentifier> *m_orderedGeoIds;
+    static xAOD::UncalibMeasType clusterContainerMeasType(const xAOD::UncalibratedMeasurementContainer &clusterContainer) {
+      return !clusterContainer.empty() ? clusterContainer.at(0)->type()
+                                       : xAOD::UncalibMeasType::Other;
+    }
 
+    std::vector<size_t> m_measurementOffset;
+    std::vector<Acts::GeometryIdentifier> m_orderedGeoIds;
+    std::array<std::vector<const Acts::Surface *>, TrackingSurfaceHelper::s_NMeasTypes> m_actsSurfaces;
+    std::unique_ptr<TrackingSurfaceHelper> m_trackingSurfaceHelper;
     MeasurementRangeList m_measurementRanges;
     std::size_t m_measurementsTotal = 0;
+    bool m_sorted = false;
   };
 
 } // anonymous namespace