AliceO2Group · davidrohr · Jul 25, 2022 · Jul 11, 2022 · Jul 11, 2022 · Jul 11, 2022
@@ -17,7 +17,6 @@ o2_add_library(ITStracking
                        src/TimeFrame.cxx
                        src/IOUtils.cxx
                        src/Label.cxx
-                       src/PrimaryVertexContext.cxx
                        src/Road.cxx
                        src/Tracker.cxx
                        src/TrackerTraits.cxx

@@ -49,7 +49,6 @@ class TimeFrameGPU : public TimeFrame
 
   void checkBufferSizes();
   void initialise(const int iteration,
-                  const MemoryParameters& memParam,
                   const TrackingParameters& trkParam,
                   const int maxLayers);
   /// Getters

@@ -36,7 +36,7 @@ class TrackerTraitsGPU : public TrackerTraits
   ~TrackerTraitsGPU() override = default;
 
   // void computeLayerCells() final;
-  void computeLayerTracklets() final;
+  void computeLayerTracklets(const int iteration) final;
   // void refitTracks(const std::vector<std::vector<TrackingFrameInfo>>& tf, std::vector<TrackITSExt>& tracks) override;
 
  private:

@@ -40,7 +40,7 @@ class VertexerTraitsGPU : public VertexerTraits
  public:
   VertexerTraitsGPU();
   ~VertexerTraitsGPU() override;
-  void initialise(const MemoryParameters& memParams, const TrackingParameters& trackingParams) override;
+  void initialise(const TrackingParameters& trackingParams) override;
   void adoptTimeFrame(TimeFrame* tf) override;
   void computeTracklets() override;
   void computeTrackletMatching() override;

@@ -144,11 +144,10 @@ void TimeFrameGPU<NLayers>::loadToDevice(const int maxLayers)
 
 template <int NLayers>
 void TimeFrameGPU<NLayers>::initialise(const int iteration,
-                                       const MemoryParameters& memParam,
                                        const TrackingParameters& trkParam,
                                        const int maxLayers)
 {
-  o2::its::TimeFrame::initialise(iteration, memParam, trkParam, maxLayers);
+  o2::its::TimeFrame::initialise(iteration, trkParam, maxLayers);
   checkBufferSizes();
   loadToDevice(maxLayers);
 }

@@ -320,7 +320,7 @@ __constant__ StaticTrackingParameters<7> kTrkPar;
 // }
 
 template <int NLayers>
-void TrackerTraitsGPU<NLayers>::computeLayerTracklets()
+void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration)
 {
   //   PrimaryVertexContextNV* primaryVertexContext = static_cast<PrimaryVertexContextNV*>(nullptr); //TODO: FIX THIS with Time Frames
 

@@ -89,13 +89,13 @@ VertexerTraitsGPU::~VertexerTraitsGPU()
   gpu::utils::host::gpuFree(mDeviceIndexTableUtils);
 }
 
-void VertexerTraitsGPU::initialise(const MemoryParameters& memParams, const TrackingParameters& trackingParams)
+void VertexerTraitsGPU::initialise(const TrackingParameters& trackingParams)
 {
   if (!mIndexTableUtils.getNzBins()) {
     updateVertexingParameters(mVrtParams);
   }
   gpu::utils::host::gpuMemcpyHostToDevice(mDeviceIndexTableUtils, &mIndexTableUtils, sizeof(mIndexTableUtils));
-  mTimeFrameGPU->initialise(0, memParams, trackingParams, 3);
+  mTimeFrameGPU->initialise(0, trackingParams, 3);
   setIsGPU(true);
 }
 

@@ -85,14 +85,6 @@ struct TrackingParameters {
   bool FindShortTracks = false;
 };
 
-struct MemoryParameters {
-  /// Memory coefficients
-  MemoryParameters& operator=(const MemoryParameters& t) = default;
-  int MemoryOffset = 256;
-  std::vector<float> CellsMemoryCoefficients = {2.3208e-08f, 2.104e-08f, 1.6432e-08f, 1.2412e-08f, 1.3543e-08f};
-  std::vector<float> TrackletsMemoryCoefficients = {0.0016353f, 0.0013627f, 0.000984f, 0.00078135f, 0.00057934f, 0.00052217f};
-};
-
 inline int TrackingParameters::CellMinimumLevel()
 {
   return MinTrackLength - constants::its::ClustersPerCell + 1;

@@ -112,7 +112,7 @@ class TimeFrame
   std::vector<MCCompLabel>& getCellsLabel(int layer) { return mCellLabels[layer]; }
 
   bool hasMCinformation() const;
-  void initialise(const int iteration, const MemoryParameters& memParam, const TrackingParameters& trkParam, const int maxLayers = 7);
+  void initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers = 7);
 
   bool isClusterUsed(int layer, int clusterId) const;
   void markUsedCluster(int layer, int clusterId);

@@ -27,12 +27,10 @@
 #include <sstream>
 
 #include "ITStracking/Configuration.h"
-#include "DetectorsBase/MatLayerCylSet.h"
 #include "CommonConstants/MathConstants.h"
 #include "ITStracking/Definitions.h"
 #include "ITStracking/ROframe.h"
 #include "ITStracking/MathUtils.h"
-#include "DetectorsBase/Propagator.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Road.h"
 
@@ -61,41 +59,30 @@ class Tracker
   ~Tracker();
 
   void adoptTimeFrame(TimeFrame& tf);
-  void setBz(float bz);
-  float getBz() const;
 
   void clustersToTracks(
     std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; }, std::function<void(std::string s)> = [](std::string s) { std::cerr << s << std::endl; });
-  void clustersToTracksGPU(std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; });
-  void setSmoothing(bool v) { mApplySmoothing = v; }
-  bool getSmoothing() const { return mApplySmoothing; }
-
   std::vector<TrackITSExt>& getTracks();
 
-  void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType& type) { mCorrType = type; }
-  void setParameters(const std::vector<MemoryParameters>&, const std::vector<TrackingParameters>&);
+  void setParameters(const std::vector<TrackingParameters>&);
   void getGlobalConfiguration();
-  bool isMatLUT() const { return o2::base::Propagator::Instance()->getMatLUT() && (mCorrType == o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT); }
-  // GPU-specific interfaces
-  TimeFrame* getTimeFrameGPU();
-  void loadToDevice();
+  void setBz(float);
+  void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type);
+  bool isMatLUT() const;
   void setNThreads(int n);
-  int getNThreads() const { return mNThreads; }
+  int getNThreads() const;
 
  private:
-  track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const Cluster& cluster3,
-                                    const TrackingFrameInfo& tf3, float resolution);
-  template <typename... T>
-  void initialiseTimeFrame(T&&... args);
-  void computeTracklets();
-  void computeCells();
+  void initialiseTimeFrame(int& iteration);
+  void computeTracklets(int& iteration);
+  void computeCells(int& iteration);
   void findCellsNeighbours(int& iteration);
   void findRoads(int& iteration);
-  void findTracks();
   void findShortPrimaries();
-  void extendTracks();
-  bool fitTrack(TrackITSExt& track, int start, int end, int step, const float chi2cut = o2::constants::math::VeryBig, const float maxQoverPt = o2::constants::math::VeryBig);
-  void traverseCellsTree(const int, const int);
+  void findTracks();
+  void extendTracks(int& iteration);
+
+  // MC interaction
   void computeRoadsMClabels();
   void computeTracksMClabels();
   void rectifyClusterIndices();
@@ -106,35 +93,21 @@ class Tracker
   TrackerTraits* mTraits = nullptr; /// Observer pointer, not owned by this class
   TimeFrame* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
 
-  std::vector<MemoryParameters> mMemParams;
   std::vector<TrackingParameters> mTrkParams;
-
-  int mNThreads = 1;
-  bool mCUDA = false;
-  bool mApplySmoothing = false;
-  o2::base::PropagatorImpl<float>::MatCorrType mCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
-  float mBz = 5.f;
   std::uint32_t mTimeFrameCounter = 0;
   o2::gpu::GPUChainITS* mRecoChain = nullptr;
 
   unsigned int mNumberOfRuns{0};
 };
 
-inline void Tracker::setParameters(const std::vector<MemoryParameters>& memPars, const std::vector<TrackingParameters>& trkPars)
+inline void Tracker::setParameters(const std::vector<TrackingParameters>& trkPars)
 {
-  mMemParams = memPars;
   mTrkParams = trkPars;
 }
 
-inline float Tracker::getBz() const
-{
-  return mBz;
-}
-
-template <typename... T>
-void Tracker::initialiseTimeFrame(T&&... args)
+inline void Tracker::initialiseTimeFrame(int& iteration)
 {
-  mTimeFrame->initialise(std::forward<T>(args)...);
+  mTimeFrame->initialise(iteration, mTrkParams[iteration]);
 }
 
 template <typename... T>