TrackerACTS.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICE3_INCLUDE_TRACKERACTS_H_
#define ALICE3_INCLUDE_TRACKERACTS_H_
 
#include "Acts/Definitions/Units.hpp"
#include "Framework/Logger.h"
 
#include "ITStracking/TimeFrame.h"
#include "TH2F.h"
 
namespace o2::trk
{
 
struct TrackerACTSConfig {
  // Seeding parameters
  float minPt = 0.4f * Acts::UnitConstants::GeV;             
  float maxImpactParameter = 10.f * Acts::UnitConstants::mm; 
  float cotThetaMax = std::sinh(4.0f);                       
 
  // Delta R cuts for doublet/triplet formation
  float deltaRMinBottom = 5.f * Acts::UnitConstants::mm;   
  float deltaRMaxBottom = 200.f * Acts::UnitConstants::mm; 
  float deltaRMinTop = 5.f * Acts::UnitConstants::mm;      
  float deltaRMaxTop = 200.f * Acts::UnitConstants::mm;    
 
  // Z cuts
  float zMin = -3000.f * Acts::UnitConstants::mm;
  float zMax = 3000.f * Acts::UnitConstants::mm;
 
  // Collision region
  float collisionRegionMin = -150.f * Acts::UnitConstants::mm;
  float collisionRegionMax = 150.f * Acts::UnitConstants::mm;
 
  // Quality cuts
  float maxSeedsPerMiddleSP = 2;
  float deltaPhiMax = 0.1f; 
};
 
struct SpacePoint {
  float x{0.f};
  float y{0.f};
  float z{0.f};
  int layer{-1};
  int clusterId{-1};
  int rof{-1};
 
  // Derived quantities
  float r() const { return std::hypot(x, y); }
  float radius() const { return r(); } // required by Acts::CylindricalGridElement concept
  float phi() const { return std::atan2(y, x); }
 
  // Variance estimates (can be refined based on cluster properties)
  float varianceR{0.01f}; // ~100 um resolution squared
  float varianceZ{0.01f};
};
 
struct SeedACTS {
  const SpacePoint* bottom{nullptr};
  const SpacePoint* middle{nullptr};
  const SpacePoint* top{nullptr};
  float quality{0.f};
};
 
template <int nLayers>
class TrackerACTS
{
 public:
  TrackerACTS();
  ~TrackerACTS()
  {
    if (mHistSpacePoints) {
      mHistSpacePoints->SaveAs("/tmp/mHistSpacePoints.C");
      delete mHistSpacePoints;
      mHistSpacePoints = nullptr;
    }
  }
 
  void adoptTimeFrame(o2::its::TimeFrame<nLayers>& tf);
 
  void clustersToTracks();
 
  void setConfig(const TrackerACTSConfig& cfg) { mConfig = cfg; }
  TrackerACTSConfig& getConfig() { return mConfig; }
  const TrackerACTSConfig& getConfig() const { return mConfig; }
 
  void setBz(float bz) { mBz = bz; }
 
  float getBz() const { return mBz; }
 
  void printSummary() const;
 
 private:
  TH2F* mHistSpacePoints = nullptr;
 
  void buildSpacePoints(int rof);
 
  void createSeeds();
 
  bool estimateTrackParams(const SeedACTS& seed, o2::its::TrackITSExt& track) const;
 
  void findTracks();
 
  void computeTracksMClabels();
 
  template <typename Func>
  float evaluateTask(Func&& task, std::string_view taskName);
 
  // Configuration
  TrackerACTSConfig mConfig;
 
  // TimeFrame data
  o2::its::TimeFrame<nLayers>* mTimeFrame = nullptr;
 
  // Space points built from clusters
  std::vector<SpacePoint> mSpacePoints;
  std::vector<std::vector<const SpacePoint*>> mSpacePointsPerLayer;
 
  // Seeds
  std::vector<SeedACTS> mSeeds;
 
  // Tracking state
  float mBz{0.5f}; 
  unsigned int mTimeFrameCounter{0};
  double mTotalTime{0.};
 
  // Tracking states for logging
  enum State {
    SpacePointBuilding = 0,
    Seeding,
    TrackFinding,
    NStates,
  };
  State mCurState{SpacePointBuilding};
  static constexpr std::array<const char*, NStates> StateNames{
    "Space point building",
    "ACTS seeding",
    "Track finding"};
};
 
template <int nLayers>
template <typename Func>
float TrackerACTS<nLayers>::evaluateTask(Func&& task, std::string_view taskName)
{
  LOG(debug) << " + Starting " << taskName;
  const auto start = std::chrono::high_resolution_clock::now();
  task();
  const auto end = std::chrono::high_resolution_clock::now();
  std::chrono::duration<double, std::milli> diff{end - start};
 
  LOG(debug) << " - " << taskName << " completed in: " << std::fixed << std::setprecision(2) << diff.count() << " ms";
  return static_cast<float>(diff.count());
}
 
} // namespace o2::trk
 
#endif /* ALICE3_INCLUDE_TRACKERACTS_H_ */