dd ACTS tracker

Author: njacazio

Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt

@@ -10,12 +10,18 @@
 # or submit itself to any jurisdiction.
 
 if(Acts_FOUND)
-  set(actsTarget Acts::Core)
+  set(actsSources src/TrackerACTS.cxx)
+  set(actsTarget
+        Acts::Core
+        O2::ACTSInterface
+        O2::ALICE3ACTS
+        ROOT::Tree
+        ROOT::RIO)
 endif()
 
 o2_add_library(ALICE3GlobalReconstruction
                TARGETVARNAME targetName
-               SOURCES src/TimeFrame.cxx
+               SOURCES src/TimeFrame.cxx ${actsSources}
                PUBLIC_LINK_LIBRARIES
                        O2::ITStracking
                        O2::GPUCommon

Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameMixin.h

@@ -71,11 +71,12 @@ class TimeFrameMixin : public Base
   void deriveAndInitTiming(const std::array<gsl::span<const o2::trkft3::ROFRecord>, nLayers>& layerROFs);
 
   const o2::InteractionRecord& getTFAnchorIR() const noexcept { return mTFAnchorIR; }
+  const auto& getClusterSensorIDs() const noexcept { return mClusterSensorIDs; }
 
  protected:
   void initTimingTables(const std::array<o2::its::LayerTiming, nLayers>& timings);
   void updateHostROFVertexLookupTable();
-
+  std::array<std::vector<int>, nLayers> mClusterSensorIDs;
   bool mTimingTablesInitialised{false};
   o2::InteractionRecord mTFAnchorIR{0, 0};
 };
@@ -205,6 +206,7 @@ int TimeFrameMixin<nLayers, Base>::loadROFsFromHitTree(TTree* hitsTree, Geometry
     this->mUnsortedClusters[iLayer].clear();
     this->mTrackingFrameInfo[iLayer].clear();
     this->mClusterExternalIndices[iLayer].clear();
+    mClusterSensorIDs[iLayer].clear();
     this->mClusterSize[iLayer].clear();
   }
 
@@ -228,6 +230,7 @@ int TimeFrameMixin<nLayers, Base>::loadROFsFromHitTree(TTree* hitsTree, Geometry
     this->mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
     this->mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
     this->mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    mClusterSensorIDs[iLayer].reserve(clusterCountPerLayer[iLayer]);
     this->mClusterSize[iLayer].reserve(clusterCountPerLayer[iLayer]);
   }
 
@@ -294,6 +297,7 @@ int TimeFrameMixin<nLayers, Base>::loadROFsFromHitTree(TTree* hitsTree, Geometry
                                         std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
                                         std::array<float, 3>{resolution[layer] * resolution[layer], 0., resolution[layer] * resolution[layer]});
       this->addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), this->mUnsortedClusters[layer].size());
+      mClusterSensorIDs[layer].push_back(hit.GetDetectorID());
       const int layerHitCounter = hitCounterPerLayer[layer]++;
       this->addClusterExternalIndexToLayer(layer, layerHitCounter);
       this->mClusterSize[layer].push_back(1);
@@ -344,10 +348,12 @@ int TimeFrameMixin<nLayers, Base>::loadROFrameData(const std::array<gsl::span<co
     this->mUnsortedClusters[iLayer].clear();
     this->mTrackingFrameInfo[iLayer].clear();
     this->mClusterExternalIndices[iLayer].clear();
+    mClusterSensorIDs[iLayer].clear();
     this->mClusterSize[iLayer].clear();
     this->mUnsortedClusters[iLayer].reserve(layerClusters[iLayer].size());
     this->mTrackingFrameInfo[iLayer].reserve(layerClusters[iLayer].size());
     this->mClusterExternalIndices[iLayer].reserve(layerClusters[iLayer].size());
+    mClusterSensorIDs[iLayer].reserve(layerClusters[iLayer].size());
     this->mClusterSize[iLayer].reserve(layerClusters[iLayer].size());
   }
 
@@ -436,6 +442,7 @@ int TimeFrameMixin<nLayers, Base>::loadROFrameData(const std::array<gsl::span<co
                                           std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
                                           std::array<float, 3>{sigmaY2, 0.f, sigmaZ2});
         this->addClusterToLayer(iLayer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), this->mUnsortedClusters[iLayer].size());
+        mClusterSensorIDs[iLayer].push_back(c.chipID);
         this->addClusterExternalIndexToLayer(iLayer, clusterId);
         this->mClusterSize[iLayer].push_back(std::clamp(static_cast<unsigned int>(c.size), 0u, 255u));
       }

Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TrackerACTS.h

@@ -19,12 +19,24 @@
 #ifndef ALICE3_GLOBALRECONSTRUCTION_INCLUDE_TRACKERACTS_H_
 #define ALICE3_GLOBALRECONSTRUCTION_INCLUDE_TRACKERACTS_H_
 
-#include "Acts/Definitions/Units.hpp"
-#include "Framework/Logger.h"
-
-#include "ITStracking/TimeFrame.h"
-#include "TH2F.h"
-
+#include <Acts/Definitions/Units.hpp>
+#include <chrono>
+#include <cmath>
+#include <iomanip>
+#include <string_view>
+#include <Framework/Logger.h>
+#include <array>
+#include <vector>
+#include <unordered_set>
+#include "DataFormatsITS/TrackITS.h"
+#include <ITStracking/TimeFrame.h>
+#include <TH2F.h>
+
+namespace Acts
+{
+class Surface;
+class BoundTrackParameters;
+}
 namespace o2::trk
 {
 
@@ -62,6 +74,8 @@ struct SpacePoint {
   int layer{-1};
   int clusterId{-1};
   int rof{-1};
+  int sensorId{-1};
+  const Acts::Surface* surface{nullptr};
 
   // Derived quantities
   float r() const { return std::hypot(x, y); }
@@ -98,6 +112,10 @@ class TrackerACTS
 
   /// Adopt a TimeFrame for processing
   void adoptTimeFrame(o2::its::TimeFrame<nLayers>& tf);
+  void adoptSensorIDs(const std::array<std::vector<int>, nLayers>& sensorIDs)
+  {
+    mSensorIDs = &sensorIDs;
+  }
 
   /// Main tracking entry point: convert clusters to tracks
   void clustersToTracks();
@@ -125,13 +143,14 @@ class TrackerACTS
   /// Create seeds (triplets) from space points using ACTS SeedFinder
   void createSeeds();
 
-  /// Estimate track parameters from a seed using ACTS
-  bool estimateTrackParams(const SeedACTS& seed, o2::its::TrackITSExt& track) const;
-
   /// Run track finding from seeds
   void findTracks();
 
-  /// Assign MC labels to tracks
+  /// Convert fitted ACTS states to a TrackITSExt and publish it in the TimeFrame.
+  bool acceptTrack(const Acts::BoundTrackParameters& inner,
+                   const Acts::BoundTrackParameters& outer,
+                   const SeedACTS& seed, float chi2);
+  /// Assign one MC label per accepted track, after all ROFs have been processed.
   void computeTracksMClabels();
 
   /// Helper: time a task
@@ -150,12 +169,17 @@ class TrackerACTS
 
   // Seeds
   std::vector<SeedACTS> mSeeds;
+  // Avoid accepting seeds which reuse a cluster already assigned to a track.
+  std::unordered_set<uint64_t> mAcceptedClusters;
+  // Layer-local indices in mUnsortedClusters, in the same order as getTracks().
+  // Keep them separate from the external indices stored in TrackITSExt.
+  std::vector<std::array<int, nLayers>> mAcceptedTrackClusterIndices;
 
   // Tracking state
   float mBz{0.5f}; ///< Magnetic field in Tesla
   unsigned int mTimeFrameCounter{0};
   double mTotalTime{0.};
-
+  const std::array<std::vector<int>, nLayers>* mSensorIDs = nullptr;
   // Tracking states for logging
   enum State {
     SpacePointBuilding = 0,