47 LogFunc evalLog = [](
const std::string&) {};
52 if (mTrkParams[0].PerPrimaryVertexProcessing) {
53 for (
int iROF{0}; iROF < mTimeFrame->
getNrof(); ++iROF) {
54 maxNvertices = std::max(maxNvertices, (
int)mTimeFrame->
getPrimaryVertices(iROF).size());
59 for (
int iteration = 0; iteration < (
int)mTrkParams.size(); ++iteration) {
60 if (iteration == 3 && mTrkParams[0].DoUPCIteration) {
63 double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
64 int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-
static_cast<int>(mTimeFrame->
getNumberOfTracks())};
65 int nROFsIterations = mTrkParams[iteration].nROFsPerIterations > 0 ? mTimeFrame->
getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->
getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
66 int iVertex{std::min(maxNvertices, 0)};
67 logger(std::format(
"==== ITS {} Tracking iteration {} summary ====", mTraits->
getName(), iteration));
69 total += evaluateTask(&Tracker::initialiseTimeFrame,
"Timeframe initialisation", logger, iteration);
71 for (
int iROFs{0}; iROFs < nROFsIterations; ++iROFs) {
72 timeTracklets += evaluateTask(&Tracker::computeTracklets,
"Tracklet finding", evalLog, iteration, iROFs, iVertex);
74 if (!mTimeFrame->
checkMemory(mTrkParams[iteration].MaxMemory)) {
75 mTimeFrame->
printSliceInfo(iROFs, mTrkParams[iteration].nROFsPerIterations);
76 error(std::format(
"Too much memory used during trackleting in iteration {} in ROF span {}-{}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
77 iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTimeFrame->
getArtefactsMemory() /
GB, mTrkParams[iteration].MaxMemory /
GB));
78 if (mTrkParams[iteration].DropTFUponFailure) {
84 if (trackletsPerCluster > mTrkParams[iteration].TrackletsPerClusterLimit) {
85 error(std::format(
"Too many tracklets per cluster ({}) in iteration {} in ROF span {}-{}:, check the detector status and/or the selections. Current limit is {}",
86 trackletsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].TrackletsPerClusterLimit));
90 timeCells += evaluateTask(&Tracker::computeCells,
"Cell finding", evalLog, iteration);
92 if (!mTimeFrame->
checkMemory(mTrkParams[iteration].MaxMemory)) {
93 mTimeFrame->
printSliceInfo(iROFs, mTrkParams[iteration].nROFsPerIterations);
94 error(std::format(
"Too much memory used during cell finding in iteration {} in ROF span {}-{}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
95 iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTimeFrame->
getArtefactsMemory() /
GB, mTrkParams[iteration].MaxMemory /
GB));
96 if (mTrkParams[iteration].DropTFUponFailure) {
102 if (cellsPerCluster > mTrkParams[iteration].CellsPerClusterLimit) {
103 error(std::format(
"Too many cells per cluster ({}) in iteration {} in ROF span {}-{}, check the detector status and/or the selections. Current limit is {}",
104 cellsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].CellsPerClusterLimit));
108 timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours,
"Neighbour finding", evalLog, iteration);
110 timeRoads += evaluateTask(&Tracker::findRoads,
"Road finding", evalLog, iteration);
113 }
while (iVertex < maxNvertices && !dropTF);
114 logger(std::format(
" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
115 logger(std::format(
" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
116 logger(std::format(
" - Neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
117 logger(std::format(
" - Track finding: {} tracks found in {:.2f} ms", nTracks + mTimeFrame->
getNumberOfTracks(), timeRoads));
118 total += timeTracklets + timeCells + timeNeighbours + timeRoads;
121 auto timeExtending = evaluateTask(&Tracker::extendTracks,
"Extending tracks", [](
const std::string&) {}, iteration);
122 total += timeExtending;
123 logger(std::format(
" - Extending Tracks: {} extended tracks using {} clusters found in {:.2f} ms", nExtendedTracks + mTimeFrame->
mNExtendedTracks, nExtendedClusters + mTimeFrame->
mNExtendedUsedClusters, timeExtending));
126 error(
"...Dropping Timeframe...");
128 ++mNumberOfDroppedTFs;
135 total += evaluateTask(&Tracker::findShortPrimaries,
"Short primaries finding", logger);
137 logger(std::format(
" `-> found {} additional tracks", nTracksA - nTracksB));
141 logger(std::format(
"=== TimeFrame {} processing completed in: {:.2f} ms using {} thread(s) ===", mTimeFrameCounter, total, mTraits->
getNThreads()));
145 computeTracksMClabels();
147 rectifyClusterIndices();
152void Tracker::initialiseTimeFrame(
int& iteration)
157void Tracker::computeTracklets(
int& iteration,
int& iROFslice,
int& iVertex)
162void Tracker::computeCells(
int& iteration)
167void Tracker::findCellsNeighbours(
int& iteration)
172void Tracker::findRoads(
int& iteration)
177void Tracker::extendTracks(
int& iteration)
182void Tracker::findShortPrimaries()
187void Tracker::computeRoadsMClabels()
196 int roadsNum{
static_cast<int>(mTimeFrame->
getRoads().size())};
198 for (
int iRoad{0}; iRoad < roadsNum; ++iRoad) {
200 Road<5>& currentRoad{mTimeFrame->
getRoads()[iRoad]};
201 std::vector<std::pair<MCCompLabel, size_t>> occurrences;
202 bool isFakeRoad{
false};
203 bool isFirstRoadCell{
true};
205 for (
int iCell{0}; iCell < mTrkParams[0].CellsPerRoad(); ++iCell) {
206 const int currentCellIndex{currentRoad[iCell]};
209 if (isFirstRoadCell) {
216 const CellSeed& currentCell{mTimeFrame->
getCells()[iCell][currentCellIndex]};
218 if (isFirstRoadCell) {
220 const int cl0index{mTimeFrame->
getClusters()[iCell][currentCell.getFirstClusterIndex()].clusterId};
223 for (
size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
224 std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
225 for (
auto&
label : cl0labs) {
226 if (
label == occurrence.first) {
234 for (
auto&
label : cl0labs) {
235 occurrences.emplace_back(
label, 1);
239 const int cl1index{mTimeFrame->
getClusters()[iCell + 1][currentCell.getSecondClusterIndex()].clusterId};
243 for (
size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
244 std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
245 for (
auto&
label : cl1labs) {
246 if (
label == occurrence.first) {
254 for (
auto&
label : cl1labs) {
255 occurrences.emplace_back(
label, 1);
259 isFirstRoadCell =
false;
262 const int cl2index{mTimeFrame->
getClusters()[iCell + 2][currentCell.getThirdClusterIndex()].clusterId};
265 for (
size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
266 std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
267 for (
auto&
label : cl2labs) {
268 if (
label == occurrence.first) {
276 for (
auto&
label : cl2labs) {
277 occurrences.emplace_back(
label, 1);
282 std::sort(occurrences.begin(), occurrences.end(), [](
auto e1,
auto e2) {
283 return e1.second > e2.second;
286 auto maxOccurrencesValue = occurrences[0].first;
287 mTimeFrame->
setRoadLabel(iRoad, maxOccurrencesValue.getRawValue(), isFakeRoad);
291void Tracker::computeTracksMClabels()
293 for (
int iROF{0}; iROF < mTimeFrame->
getNrof(); ++iROF) {
294 for (
auto& track : mTimeFrame->getTracks(iROF)) {
295 std::vector<std::pair<MCCompLabel, size_t>> occurrences;
299 const int index = track.getClusterIndex(iCluster);
305 for (
size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
306 std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
307 for (
auto&
label : labels) {
308 if (
label == occurrence.first) {
316 for (
auto&
label : labels) {
317 occurrences.emplace_back(
label, 1);
321 std::sort(std::begin(occurrences), std::end(occurrences), [](
auto e1,
auto e2) {
322 return e1.second > e2.second;
325 auto maxOccurrencesValue = occurrences[0].first;
326 uint32_t
pattern = track.getPattern();
329 auto clid = track.getClusterIndex(ic);
332 for (
auto& currentLabel : labelsSpan) {
333 if (currentLabel == maxOccurrencesValue) {
341 if (occurrences[0].second < track.getNumberOfClusters()) {
342 maxOccurrencesValue.setFakeFlag();
344 mTimeFrame->
getTracksLabel(iROF).emplace_back(maxOccurrencesValue);
349void Tracker::rectifyClusterIndices()
351 for (
int iROF{0}; iROF < mTimeFrame->
getNrof(); ++iROF) {
352 for (
auto& track : mTimeFrame->getTracks(iROF)) {
354 const int index = track.getClusterIndex(iCluster);
366 if (tc.useMatCorrTGeo) {
368 }
else if (tc.useFastMaterial) {
374 int nROFsPerIterations = tc.nROFsPerIterations > 0 ? tc.nROFsPerIterations : -1;
375 if (tc.nOrbitsPerIterations > 0) {
378 for (
auto&
params : mTrkParams) {
379 if (
params.NLayers == 7) {
380 for (
int i{0};
i < 7; ++
i) {
381 params.SystErrorY2[
i] = tc.sysErrY2[
i] > 0 ? tc.sysErrY2[
i] :
params.SystErrorY2[
i];
382 params.SystErrorZ2[
i] = tc.sysErrZ2[
i] > 0 ? tc.sysErrZ2[
i] :
params.SystErrorZ2[
i];
385 params.DeltaROF = tc.deltaRof;
386 params.DoUPCIteration = tc.doUPCIteration;
387 params.MaxChi2ClusterAttachment = tc.maxChi2ClusterAttachment > 0 ? tc.maxChi2ClusterAttachment :
params.MaxChi2ClusterAttachment;
388 params.MaxChi2NDF = tc.maxChi2NDF > 0 ? tc.maxChi2NDF :
params.MaxChi2NDF;
389 params.PhiBins = tc.LUTbinsPhi > 0 ? tc.LUTbinsPhi :
params.PhiBins;
390 params.ZBins = tc.LUTbinsZ > 0 ? tc.LUTbinsZ :
params.ZBins;
392 params.NSigmaCut *= tc.nSigmaCut > 0 ? tc.nSigmaCut : 1.f;
393 params.CellDeltaTanLambdaSigma *= tc.deltaTanLres > 0 ? tc.deltaTanLres : 1.f;
394 params.TrackletMinPt *= tc.minPt > 0 ? tc.minPt : 1.f;
395 params.nROFsPerIterations = nROFsPerIterations;
396 params.PerPrimaryVertexProcessing = tc.perPrimaryVertexProcessing;
397 params.SaveTimeBenchmarks = tc.saveTimeBenchmarks;
398 params.FataliseUponFailure = tc.fataliseUponFailure;
399 params.DropTFUponFailure = tc.dropTFUponFailure;
400 for (
int iD{0}; iD < 3; ++iD) {
401 params.Diamond[iD] = tc.diamondPos[iD];
403 params.UseDiamond = tc.useDiamond;
405 params.MaxMemory = tc.maxMemory;
407 if (tc.useTrackFollower > 0) {
408 params.UseTrackFollower =
true;
412 params.UseTrackFollowerMix = ((tc.useTrackFollower & (1 << 0)) != 0);
413 params.UseTrackFollowerTop = ((tc.useTrackFollower & (1 << 1)) != 0);
414 params.UseTrackFollowerBot = ((tc.useTrackFollower & (1 << 2)) != 0);
415 params.TrackFollowerNSigmaCutZ = tc.trackFollowerNSigmaZ;
416 params.TrackFollowerNSigmaCutPhi = tc.trackFollowerNSigmaPhi;
418 if (tc.cellsPerClusterLimit >= 0) {
419 params.CellsPerClusterLimit = tc.cellsPerClusterLimit;
421 if (tc.trackletsPerClusterLimit >= 0) {
422 params.TrackletsPerClusterLimit = tc.trackletsPerClusterLimit;
424 if (tc.findShortTracks >= 0) {
425 params.FindShortTracks = tc.findShortTracks;
463 LOGP(info,
"Tracker summary: Processed {} TFs (dropped {}) in TOT={:.2f} s, AVG/TF={:.2f} s", mTimeFrameCounter, mNumberOfDroppedTFs, mTotalTime * 1.e-3, mTotalTime * 1.e-3 / ((mTimeFrameCounter > 0) ? (
double)mTimeFrameCounter : -1.0));
Class to handle Kalman smoothing for ITS tracking. Its instance stores the state of the track to the ...
static const TrackerParamConfig & Instance()
gsl::span< const Vertex > getPrimaryVertices(int rofId) const
int mNExtendedUsedClusters
unsigned long getArtefactsMemory()
void setRoadLabel(int i, const unsigned long long &lab, bool fake)
std::vector< std::vector< CellSeed > > & getCells()
std::vector< MCCompLabel > & getTracksLabel(const int rofId)
bool hasMCinformation() const
std::vector< std::vector< Cluster > > & getClusters()
void initialiseRoadLabels()
std::vector< Road< 5 > > & getRoads()
size_t getNumberOfTracks() const
bool checkMemory(unsigned long max)
int getNumberOfNeighbours() const
int getClusterExternalIndex(int layerId, const int clId) const
const gsl::span< const MCCompLabel > getClusterLabels(int layerId, const Cluster &cl) const
void printSliceInfo(const int, const int)
static constexpr int MaxClusters
< heavy version of TrackITS, with clusters embedded
virtual void findRoads(const int iteration)
virtual void extendTracks(const int iteration)
virtual int getTFNumberOfCells() const
virtual void adoptTimeFrame(TimeFrame *tf)
virtual void computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
virtual void setBz(float bz)
virtual bool supportsFindShortPrimaries() const noexcept
virtual int getTFNumberOfTracklets() const
virtual void findCellsNeighbours(const int iteration)
virtual int getTFNumberOfClusters() const
virtual void findShortPrimaries()
virtual void initialiseTimeFrame(const int iteration)
void UpdateTrackingParameters(const std::vector< TrackingParameters > &trkPars)
void setCorrType(const o2::base::PropagatorImpl< float >::MatCorrType type)
virtual void computeLayerCells(const int iteration)
virtual bool supportsExtendTracks() const noexcept
virtual const char * getName() const noexcept
void adoptTimeFrame(TimeFrame &tf)
void setCorrType(const o2::base::PropagatorImpl< float >::MatCorrType type)
void printSummary() const
void getGlobalConfiguration()
Tracker(TrackerTraits *traits)
void clustersToTracks(LogFunc=[](std::string s) { std::cout<< s<< std::endl;}, LogFunc=[](std::string s) { std::cerr<< s<< std::endl;})
GLint GLint GLsizei GLint GLenum GLenum type
GLenum const GLfloat * params
GLuint GLsizei const GLchar * label
constexpr int UnusedIndex
constexpr bool DoTimeBenchmarks
a couple of static helper functions to create timestamp values for CCDB queries or override obsolete ...
std::unique_ptr< GPUReconstructionTimeframe > tf
std::array< uint16_t, 5 > pattern