64 computePointerWithAlignment(base, mR, kNChambers);
65 computePointerWithAlignment(base, mHypothesis, mNCandidates * mMaxBackendThreads);
66 computePointerWithAlignment(base, mCandidates, mNCandidates * 2 * mMaxBackendThreads);
70template <
class TRDTRK,
class PROP>
77 if (mGenerateSpacePoints) {
78 computePointerWithAlignment(base, mSpacePoints, mNMaxSpacePoints);
80 computePointerWithAlignment(base, mTrackletIndexArray, (kNChambers + 1) * mNMaxCollisions);
84template <
class TRDTRK,
class PROP>
90 computePointerWithAlignment(base, mTracks, mNMaxTracks);
91 computePointerWithAlignment(base, mTrackAttribs, mNMaxTracks);
95template <
class TRDTRK,
class PROP>
96GPUTRDTracker_t<TRDTRK, PROP>::GPUTRDTracker_t() : mR(nullptr), mIsInitialized(
false), mGenerateSpacePoints(
false), mProcessPerTimeFrame(
false), mNAngleHistogramBins(25), mAngleHistogramRange(50), mMemoryPermanent(-1), mMemoryTracklets(-1), mMemoryTracks(-1), mNMaxCollisions(0), mNMaxTracks(0), mNMaxSpacePoints(0), mTracks(nullptr), mTrackAttribs(nullptr), mNCandidates(1), mNTracks(0), mNEvents(0), mMaxBackendThreads(100), mTrackletIndexArray(nullptr), mFT0TriggeredBC(nullptr), mNFT0BC(0), mHypothesis(nullptr), mCandidates(nullptr), mSpacePoints(nullptr), mGeo(nullptr), mRecoParam(nullptr), mDebugOutput(
false), mMaxEta(0.84f), mRoadZ(18.f), mTPCVdrift(2.58f), mTPCTDriftOffset(0.f), mDebug(new
GPUTRDTrackerDebug<TRDTRK>())
103template <
class TRDTRK,
class PROP>
112template <
class TRDTRK,
class PROP>
118 mRecoParam = GetConstantMem()->calibObjects.trdRecoParam;
120 mDebug->ExpandVectors();
121 mIsInitialized =
true;
124template <
class TRDTRK,
class PROP>
130 mGeo = (
const GPUTRDGeometry*)GetConstantMem()->calibObjects.trdGeometry;
132 GPUFatal(
"TRD geometry must be provided externally");
135 float x0[kNLayers] = {300.2f, 312.8f, 325.4f, 338.0f, 350.6f, 363.2f};
136 auto* matrix = mGeo->GetClusterMatrix(0);
137 float loc[3] = {mGeo->AnodePos(), 0.f, 0.f};
138 float glb[3] = {0.f, 0.f, 0.f};
139 for (
int32_t iDet = 0; iDet < kNChambers; ++iDet) {
140 matrix = mGeo->GetClusterMatrix(iDet);
142 mR[iDet] =
x0[mGeo->GetLayer(iDet)];
145 matrix->LocalToMaster(loc, glb);
150template <
class TRDTRK,
class PROP>
159template <
class TRDTRK,
class PROP>
167 for (
uint32_t iColl = 0; iColl < GetConstantMem()->ioPtrs.nTRDTriggerRecords; ++iColl) {
168 if (GetConstantMem()->ioPtrs.trdTrigRecMask && GetConstantMem()->ioPtrs.trdTrigRecMask[iColl] == 0) {
174 if (mProcessPerTimeFrame) {
175 idxOffset = GetConstantMem()->ioPtrs.trdTrackletIdxFirst[iColl];
176 nTrklts = (iColl < GetConstantMem()->ioPtrs.nTRDTriggerRecords - 1) ? GetConstantMem()->ioPtrs.trdTrackletIdxFirst[iColl + 1] - GetConstantMem()->ioPtrs.trdTrackletIdxFirst[iColl] : GetConstantMem()->ioPtrs.nTRDTracklets - GetConstantMem()->ioPtrs.trdTrackletIdxFirst[iColl];
178 nTrklts = GetConstantMem()->ioPtrs.nTRDTracklets;
181 int32_t* trkltIndexArray = &mTrackletIndexArray[iColl * (kNChambers + 1) + 1];
182 trkltIndexArray[-1] = 0;
186 for (
int32_t iTrklt = 0; iTrklt < nTrklts; ++iTrklt) {
187 if (
tracklets[iTrklt].GetDetector() > currDet) {
188 nextDet =
tracklets[iTrklt].GetDetector();
189 for (
int32_t iDet = currDet; iDet < nextDet; ++iDet) {
190 trkltIndexArray[iDet] = trkltCounter;
196 for (
int32_t iDet = currDet; iDet <= kNChambers; ++iDet) {
197 trkltIndexArray[iDet] = trkltCounter;
199 if (mGenerateSpacePoints) {
200 if (!CalculateSpacePoints(iColl)) {
201 GPUError(
"Space points for at least one chamber could not be calculated (for interaction %i)", iColl);
206 if (mGenerateSpacePoints) {
212template <
class TRDTRK,
class PROP>
218 if (!mIsInitialized) {
221 GPUError(
"Cannot change mNCandidates after initialization");
225template <
class TRDTRK,
class PROP>
231 GPUInfo(
"##############################################################");
232 GPUInfo(
"Current settings for GPU TRD tracker:");
233 GPUInfo(
" maxChi2(%.2f), chi2Penalty(%.2f), nCandidates(%i), maxMissingLayers(%i)", Param().
rec.trd.maxChi2, Param().
rec.trd.penaltyChi2, mNCandidates, Param().
rec.trd.stopTrkAfterNMissLy);
234 GPUInfo(
" ptCut = %.2f GeV, abs(eta) < %.2f", Param().
rec.trd.minTrackPt, mMaxEta);
235 GPUInfo(
"##############################################################");
238template <
class TRDTRK,
class PROP>
241 mDebug->CreateStreamer();
249 return &Param().polynomialField;
252template <
class TRDTRK,
class PROP>
255 return GetConstantMem()->calibObjects.o2Propagator;
258template <
class TRDTRK,
class PROP>
261 if (!trk.CheckNumericalQuality()) {
264 if (CAMath::Abs(trk.getEta()) > mMaxEta) {
267 if (trk.getPt() < Param().
rec.trd.minTrackPt) {
273template <
class TRDTRK,
class PROP>
276 if (mNTracks >= mNMaxTracks) {
278 GPUError(
"Error: Track dropped (no memory available) -> must not happen");
282 if (checkTrack && !CheckTrackTRDCandidate(trk)) {
285 mTracks[mNTracks] = trk;
286 mTracks[mNTracks].setRefGlobalTrackIdRaw(tpcTrackId);
288 mTrackAttribs[mNTracks] = *attribs;
294template <
class TRDTRK,
class PROP>
300 GPUInfo(
"There are in total %i tracklets loaded", GetConstantMem()->ioPtrs.nTRDTracklets);
301 GPUInfo(
"There are %i tracks loaded. mNMaxTracks(%i)", mNTracks, mNMaxTracks);
303 auto* trk = &(mTracks[
i]);
304 GPUInfo(
"track %i: x=%f, alpha=%f, nTracklets=%i, pt=%f, time=%f",
i, trk->getX(), trk->getAlpha(), trk->getNtracklets(), trk->getPt(), mTrackAttribs[
i].mTime);
308template <
class TRDTRK,
class PROP>
319 for (
uint32_t iColl = 0; iColl < GetConstantMem()->ioPtrs.nTRDTriggerRecords; ++iColl) {
320 if (GetConstantMem()->ioPtrs.trdTrigRecMask && GetConstantMem()->ioPtrs.trdTrigRecMask[iColl] == 0) {
323 if (GetConstantMem()->ioPtrs.trdTriggerTimes[iColl] > mTrackAttribs[iTrk].GetTimeMin() && GetConstantMem()->ioPtrs.trdTriggerTimes[iColl] < mTrackAttribs[iTrk].GetTimeMax()) {
325 GPUError(
"Found too many collision candidates for track with tMin(%f) and tMax(%f)", mTrackAttribs[iTrk].GetTimeMin(), mTrackAttribs[iTrk].GetTimeMax());
328 collisionIds[nColls++] = iColl;
334template <
class TRDTRK,
class PROP>
340 int32_t collisionIds[20] = {0};
342 if (mProcessPerTimeFrame) {
343 nCollisionIds = GetCollisionIDs(iTrk, collisionIds);
344 if (nCollisionIds == 0) {
346 GPUInfo(
"Did not find TRD data for track %i with t=%f. tMin(%f), tMax(%f)", iTrk, mTrackAttribs[iTrk].mTime, mTrackAttribs[iTrk].GetTimeMin(), mTrackAttribs[iTrk].GetTimeMax());
352 PROP prop(getPropagatorParam());
353 mTracks[iTrk].setChi2(Param().
rec.trd.penaltyChi2);
355 auto trkStart = mTracks[iTrk];
356 for (
int32_t iColl = 0; iColl < nCollisionIds; ++iColl) {
358 auto trkCopy = trkStart;
359 prop.setTrack(&trkCopy);
360 prop.setFitInProjections(
true);
361 if (!FollowProlongation(&prop, &trkCopy, iTrk, threadId, collisionIds[iColl])) {
365 if (trkCopy.getReducedChi2() < mTracks[iTrk].getReducedChi2()) {
366 mTracks[iTrk] = trkCopy;
371template <
class TRDTRK,
class PROP>
380 int32_t idxOffset = iCollision * (kNChambers + 1);
384 for (
int32_t iDet = 0; iDet < kNChambers; ++iDet) {
385 int32_t iFirstTrackletInDet = mTrackletIndexArray[idxOffset + iDet];
386 int32_t iFirstTrackletInNextDet = mTrackletIndexArray[idxOffset + iDet + 1];
387 int32_t nTrackletsInDet = iFirstTrackletInNextDet - iFirstTrackletInDet;
388 if (nTrackletsInDet == 0) {
391 if (!mGeo->ChamberInGeometry(iDet)) {
392 GPUError(
"Found TRD tracklets in chamber %i which is not included in the geometry", iDet);
395 auto* matrix = mGeo->GetClusterMatrix(iDet);
397 GPUError(
"No cluster matrix available for chamber %i. Skipping it...", iDet);
403 int32_t trkltIdxOffset = (mProcessPerTimeFrame) ? GetConstantMem()->ioPtrs.trdTrackletIdxFirst[iCollision] : 0;
404 int32_t trkltIdxStart = trkltIdxOffset + iFirstTrackletInDet;
405 for (
int32_t trkltIdx = trkltIdxStart; trkltIdx < trkltIdxStart + nTrackletsInDet; ++trkltIdx) {
407 float xTrkltDet[3] = {0.f};
408 float xTrkltSec[3] = {0.f};
409 xTrkltDet[0] = mGeo->AnodePos() + sRadialOffset;
410 xTrkltDet[1] =
tracklets[trkltIdx].GetY();
411 xTrkltDet[2] =
pp->GetRowPos(trkltZbin) -
pp->GetRowSize(trkltZbin) / 2.f -
pp->GetRowPos(
pp->GetNrows() / 2);
413 matrix->LocalToMaster(xTrkltDet, xTrkltSec);
414 mSpacePoints[trkltIdx].setX(xTrkltSec[0]);
415 mSpacePoints[trkltIdx].setY(xTrkltSec[1]);
416 mSpacePoints[trkltIdx].setZ(xTrkltSec[2]);
417 mSpacePoints[trkltIdx].setDy(
tracklets[trkltIdx].GetdY());
425template <
class TRDTRK,
class PROP>
436 GPUInfo(
"Start track following for track %i at x=%f with pt=%f",
t->getRefGlobalTrackIdRaw(),
t->getX(),
t->getPt());
445 for (
int32_t iBC = 0; iBC < mNFT0BC; iBC++) {
446 int32_t deltaBC = CAMath::Round(mFT0TriggeredBC[iBC] - GetConstantMem()->ioPtrs.trdTriggerTimes[collisionId] / o2::constants::lhc::LHCBunchSpacingMUS);
447 if (nIdxBCMin == -1 && deltaBC > mRecoParam->getPileUpRangeBefore()) {
450 if (deltaBC >= mRecoParam->getPileUpRangeAfter()) {
454 if (iBC == mNFT0BC - 1) {
456 if (nIdxBCMin == -1) {
458 nIdxBCMin = nIdxBCMax;
463 float zShiftTrk = 0.f;
464 if (mProcessPerTimeFrame) {
465 zShiftTrk = (mTrackAttribs[iTrk].mTime - GetConstantMem()->ioPtrs.trdTriggerTimes[collisionId]) * mTPCVdrift * mTrackAttribs[iTrk].mSide;
473 const GPUTRDSpacePoint* spacePoints = GetConstantMem()->ioPtrs.trdSpacePoints;
475#ifdef ENABLE_GPUTRDDEBUG
476 TRDTRK trackNoUp(*
t);
479 int32_t candidateIdxOffset = threadId * 2 * mNCandidates;
480 int32_t hypothesisIdxOffset = threadId * mNCandidates;
481 int32_t trkltIdxOffset = collisionId * (kNChambers + 1);
482 int32_t glbTrkltIdxOffset = (mProcessPerTimeFrame) ? GetConstantMem()->ioPtrs.trdTrackletIdxFirst[collisionId] : 0;
485 if (mNCandidates > 1) {
487 mCandidates[candidateIdxOffset] = *
t;
496 const int32_t nMaxChambersToSearch = 4;
498 mDebug->SetGeneralInfo(mNEvents, mNTracks, iTrk,
t->getPt());
500 for (
int32_t iLayer = 0; iLayer < kNLayers; ++iLayer) {
503 int32_t currIdx = candidateIdxOffset + iLayer % 2;
504 int32_t nextIdx = candidateIdxOffset + (iLayer + 1) % 2;
505 pad = mGeo->GetPadPlane(iLayer, 0);
506 float tilt = CAMath::Tan(CAMath::Pi() / 180.f * pad->GetTiltingAngle());
507 const float zMaxTRD = pad->GetRow0();
514 for (
int32_t iCandidate = 0; iCandidate < nCandidates; iCandidate++) {
516 int32_t det[nMaxChambersToSearch] = {-1, -1, -1, -1};
518 if (mNCandidates > 1) {
519 trkWork = &mCandidates[2 * iCandidate + currIdx];
520 prop->setTrack(trkWork);
523 if (trkWork->getIsStopped()) {
524 Hypothesis hypo(trkWork->getNlayersFindable(), iCandidate, -1, trkWork->getChi2());
525 InsertHypothesis(hypo, nCurrHypothesis, hypothesisIdxOffset);
531 if (!prop->propagateToX(mR[2 * kNLayers + iLayer], .8f, 2.f)) {
533 GPUInfo(
"Track propagation failed for track %i candidate %i in layer %i (pt=%f, x=%f, mR[layer]=%f)", iTrk, iCandidate, iLayer, trkWork->getPt(), trkWork->getX(), mR[2 * kNLayers + iLayer]);
539 if (!AdjustSector(prop, trkWork)) {
541 GPUInfo(
"Adjusting sector failed for track %i candidate %i in layer %i", iTrk, iCandidate, iLayer);
547 if (IsGeoFindable(trkWork, iLayer, prop->getAlpha(), zShiftTrk)) {
548 trkWork->setIsFindable(iLayer);
552 roadY = 7.f * CAMath::Sqrt(trkWork->getSigmaY2() + 0.1f * 0.1f) + Param().rec.trd.extraRoadY;
554 roadZ = mRoadZ + Param().rec.trd.extraRoadZ;
556 if (CAMath::Abs(trkWork->getZ() + zShiftTrk) - roadZ >= zMaxTRD) {
558 GPUInfo(
"Track out of TRD acceptance with z=%f in layer %i (eta=%f)", trkWork->getZ() + zShiftTrk, iLayer, trkWork->getEta());
564 FindChambersInRoad(trkWork, roadY, roadZ, iLayer, det, zMaxTRD, prop->getAlpha(), zShiftTrk);
567 mDebug->SetTrackParameter(*trkWork, iLayer);
570 for (
int32_t iDet = 0; iDet < nMaxChambersToSearch; iDet++) {
575 pad = mGeo->GetPadPlane(currDet);
576 int32_t currSec = mGeo->GetSector(currDet);
577 if (currSec != GetSector(prop->getAlpha())) {
578 if (!prop->rotate(GetAlphaOfSector(currSec))) {
580 GPUWarning(
"Track could not be rotated in tracklet coordinate system");
585 if (currSec != GetSector(prop->getAlpha())) {
586 GPUError(
"Track is in sector %i and sector %i is searched for tracklets", GetSector(prop->getAlpha()), currSec);
590 if (!prop->propagateToX(mR[currDet], .8f, .2f)) {
592 GPUWarning(
"Track parameter for track %i, x=%f at chamber %i x=%f in layer %i cannot be retrieved", iTrk, trkWork->getX(), currDet, mR[currDet], iLayer);
597 for (
int32_t trkltIdx = glbTrkltIdxOffset + mTrackletIndexArray[trkltIdxOffset + currDet]; trkltIdx < glbTrkltIdxOffset + mTrackletIndexArray[trkltIdxOffset + currDet + 1]; ++trkltIdx) {
598 if (CAMath::Abs(trkWork->getY() - spacePoints[trkltIdx].getY()) > roadY || CAMath::Abs(trkWork->getZ() + zShiftTrk - spacePoints[trkltIdx].getZ()) > roadZ) {
604 prop->getPropagatedYZ(spacePoints[trkltIdx].
getX(), projY, projZ);
606 float tiltCorr = tilt * (spacePoints[trkltIdx].getZ() - projZ);
607 float dyTiltCorr = tilt * trkWork->getTgl() * mGeo->GetCdrHght();
608 float lPad = pad->GetRowSize(
tracklets[trkltIdx].GetZbin());
609 if (!((CAMath::Abs(spacePoints[trkltIdx].getZ() - projZ) < lPad) && (trkWork->getSigmaZ2() < (lPad * lPad / 12.f)))) {
617 float yCorrPileUp = 0.f;
618 float yCorrPileUp_weightedMean = 0.f;
619 float yAddErrPileUp2 = 0.f;
621 float zShiftTrkPileUp = 0.f;
622 if (nIdxBCMax - nIdxBCMin >= 2) {
626 float sumCorr2 = 0.f;
629 float slopeFactor =
tracklets[trkltIdx].GetSlopeFloat() * mGeo->GetPadPlaneWidthIPad(
tracklets[trkltIdx].GetDetector()) / 4.f;
630 for (
int32_t iBC = nIdxBCMin; iBC < nIdxBCMax; iBC++) {
631 int32_t deltaBC = CAMath::Round(mFT0TriggeredBC[iBC] - GetConstantMem()->ioPtrs.trdTriggerTimes[collisionId] / o2::constants::lhc::LHCBunchSpacingMUS);
632 float probBC = mRecoParam->getPileUpProbTracklet(deltaBC,
true, (
tracklets[trkltIdx].GetQ0() != 0), (
tracklets[trkltIdx].GetQ1() != 0));
633 sumCorr += probBC * slopeFactor * deltaBC;
634 sumCorr2 += probBC * slopeFactor * deltaBC * slopeFactor * deltaBC;
636 yCorrPileUp_weightedMean -= slopeFactor * deltaBC * probBC;
637 if (probBC > maxProb) {
639 yCorrPileUp = -slopeFactor * deltaBC;
640 zShiftTrkPileUp = -deltaBC * o2::constants::lhc::LHCBunchSpacingMUS * mTPCVdrift * mTrackAttribs[iTrk].mSide;
643 if (sumProb > 1e-6f) {
644 yAddErrPileUp2 = sumCorr2 / sumProb - 2 * yCorrPileUp * sumCorr / sumProb + yCorrPileUp * yCorrPileUp;
645 yCorrPileUp_weightedMean /= sumProb;
650 int nTrackletsChamber = mTrackletIndexArray[trkltIdxOffset + currDet + 1] - mTrackletIndexArray[trkltIdxOffset + currDet];
651 float angularPull = GetAngularPull(spacePoints[trkltIdx].getDy() + dyTiltCorr, trkWork->getSnp(), nTrackletsChamber);
654 float zPosCorr = spacePoints[trkltIdx].getZ() + mRecoParam->getZCorrCoeffNRC() * trkWork->getTgl();
656 float yPosCorr = spacePoints[trkltIdx].getY() - tiltCorr + yCorrPileUp_weightedMean;
657 zPosCorr -= zShiftTrk + zShiftTrkPileUp;
660 if (Param().
rec.trd.useAngularPull == 3 || Param().
rec.trd.useAngularPull == 4) {
661 float corrPull = -angularPull * mRecoParam->getCorrYDy(trkWork->getSnp());
662 yPosCorr += corrPull;
665 float deltaY = yPosCorr - projY;
666 float deltaZ = zPosCorr - projZ;
668 float trkltPosTmpYZ[2] = {yPosCorr, zPosCorr};
669 float trkltCovTmp[3] = {0.f};
670 if ((CAMath::Abs(deltaY) < roadY) && (CAMath::Abs(deltaZ) < roadZ)) {
672 RecalcTrkltCov(tilt, trkWork->getSnp(), pad->GetRowSize(
tracklets[trkltIdx].GetZbin()), (Param().
rec.trd.useAngularPull == 2 || Param().
rec.trd.useAngularPull == 4 ? angularPull : 0.f), nTrackletsChamber, trkltCovTmp);
673 trkltCovTmp[0] += yAddErrPileUp2;
674 float chi2 = prop->getPredictedChi2(trkltPosTmpYZ, trkltCovTmp);
676 if (Param().
rec.trd.addDeflectionInChi2 >= 1 && (trkWork->getSnp() < 1.f - 1e-6f) && (trkWork->getSnp() > -1.f + 1e-6f)) {
678 float trkltCovTmpWithDy[6] = {trkltCovTmp[0], trkltCovTmp[1], trkltCovTmp[2], 0.f, 0.f, 0.f};
679 RecalcTrkltCovDy(tilt, trkWork->getSnp(), (Param().
rec.trd.useAngularPull == 2 || Param().
rec.trd.useAngularPull == 4 ? angularPull : 0.f), nTrackletsChamber, trkltCovTmpWithDy);
680 trkltCovTmpWithDy[0] += trkWork->getSigmaY2();
681 trkltCovTmpWithDy[1] += trkWork->getSigmaZY();
682 trkltCovTmpWithDy[2] += trkWork->getSigmaZ2();
684 if (Param().
rec.trd.useAngularPull == 3 || Param().
rec.trd.useAngularPull == 4) {
686 trkltCovTmpWithDy[3] = 0.;
687 trkltCovTmpWithDy[4] = 0.;
691 trkltCovTmpWithDy[3] += trkWork->getSigmaSnpY() * mGeo->GetCdrHght();
692 trkltCovTmpWithDy[4] += trkWork->getSigmaSnpZ() * mGeo->GetCdrHght();
695 float sigmaZ2 = trkltCovTmpWithDy[2];
696 float sigmaDy2 = trkltCovTmpWithDy[5];
699 if (InvertCov(trkltCovTmpWithDy)) {
700 float deltaDy = spacePoints[trkltIdx].getDy() + dyTiltCorr - mRecoParam->convertAngleToDy(trkWork->getSnp());
701 if (Param().
rec.trd.addDeflectionInChi2 == 2 || Param().
rec.trd.addDeflectionInChi2 == 3) {
703 double likelihood = mRecoParam->getDyLikelihood(trkWork->getSnp(), spacePoints[trkltIdx].getDy() + dyTiltCorr, nTrackletsChamber);
704 if (likelihood < 1e-6f) {
707 deltaDy = CAMath::Sqrt(-2.f * CAMath::Log(likelihood) * sigmaDy2) * (deltaDy > 0.f ? 1.f : -1.f);
709 if (Param().rec.trd.addDeflectionInChi2 == 3) {
711 double likelihood = mRecoParam->getZLikelihood(deltaZ, pad->GetRowSize(
tracklets[trkltIdx].GetZbin()), CAMath::Sqrt(trkWork->getSigmaZ2()));
712 if (likelihood < 1e-6f) {
715 deltaZ = CAMath::Sqrt(-2.f * CAMath::Log(likelihood) * sigmaZ2) * (deltaZ > 0.f ? 1.f : -1.f);
717 chi2 = deltaY * trkltCovTmpWithDy[0] * deltaY + 2 * deltaY * trkltCovTmpWithDy[1] * deltaZ + 2 * deltaY * trkltCovTmpWithDy[3] * deltaDy + deltaZ * trkltCovTmpWithDy[2] * deltaZ + 2 * deltaZ * trkltCovTmpWithDy[4] * deltaDy + deltaDy * trkltCovTmpWithDy[5] * deltaDy;
721 if ((
chi2 > Param().
rec.trd.maxChi2) || (Param().rec.trd.applyDeflectionCut && CAMath::Abs(angularPull) > 4)) {
724 Hypothesis hypo(trkWork->getNlayersFindable(), iCandidate, trkltIdx, trkWork->getChi2() +
chi2);
725 InsertHypothesis(hypo, nCurrHypothesis, hypothesisIdxOffset);
731 Hypothesis hypoNoUpdate(trkWork->getNlayersFindable(), iCandidate, -1, trkWork->getChi2() + Param().
rec.trd.penaltyChi2);
732 InsertHypothesis(hypoNoUpdate, nCurrHypothesis, hypothesisIdxOffset);
736 mDebug->SetChi2Update(mHypothesis[0 + hypothesisIdxOffset].mChi2 -
t->getChi2(), iLayer);
737 mDebug->SetRoad(roadY, roadZ, iLayer);
738 bool wasTrackStored =
false;
746 for (
int32_t iUpdate = 0; iUpdate < nCurrHypothesis && iUpdate < mNCandidates; iUpdate++) {
747 if (mHypothesis[iUpdate + hypothesisIdxOffset].mCandidateId == -1) {
754 nCandidates = iUpdate + 1;
755 if (mNCandidates > 1) {
756 mCandidates[2 * iUpdate + nextIdx] = mCandidates[2 * mHypothesis[iUpdate + hypothesisIdxOffset].mCandidateId + currIdx];
757 trkWork = &mCandidates[2 * iUpdate + nextIdx];
759 if (mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId == -1) {
761 if (trkWork->getIsFindable(iLayer)) {
762 if (trkWork->getNmissingConsecLayers(iLayer) > Param().
rec.trd.stopTrkAfterNMissLy) {
763 trkWork->setIsStopped();
765 trkWork->setChi2(trkWork->getChi2() + Param().
rec.trd.penaltyChi2);
767 if (iUpdate == 0 && mNCandidates > 1) {
768 *
t = mCandidates[2 * iUpdate + nextIdx];
773 if (mNCandidates > 1) {
774 prop->setTrack(trkWork);
776 int32_t trkltSec = mGeo->GetSector(
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetDetector());
777 if (trkltSec != GetSector(prop->getAlpha())) {
779 prop->rotate(GetAlphaOfSector(trkltSec));
781 if (!prop->propagateToX(spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getX(), .8f, 2.f)) {
783 GPUWarning(
"Final track propagation for track %i update %i in layer %i failed", iTrk, iUpdate, iLayer);
785 trkWork->setChi2(trkWork->getChi2() + Param().
rec.trd.penaltyChi2);
786 if (trkWork->getIsFindable(iLayer)) {
787 if (trkWork->getNmissingConsecLayers(iLayer) >= Param().
rec.trd.stopTrkAfterNMissLy) {
788 trkWork->setIsStopped();
791 if (iUpdate == 0 && mNCandidates > 1) {
792 *
t = mCandidates[2 * iUpdate + nextIdx];
797 pad = mGeo->GetPadPlane(
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetDetector());
798 float tiltCorrUp = tilt * (spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getZ() - trkWork->getZ());
799 float dyTiltCorr = tilt * trkWork->getTgl() * mGeo->GetCdrHght();
801 float yPosCorrUp = spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getY() - tiltCorrUp;
803 float zPosCorrUp = spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getZ() + mRecoParam->getZCorrCoeffNRC() * trkWork->getTgl();
804 zPosCorrUp -= zShiftTrk;
805 float padLength = pad->GetRowSize(
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetZbin());
806 if (!((trkWork->getSigmaZ2() < (padLength * padLength / 12.f)) && (CAMath::Abs(spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getZ() - trkWork->getZ()) < padLength))) {
814 float yCorrPileUp = 0.f;
815 float yCorrPileUp_weightedMean = 0.f;
816 float yAddErrPileUp2 = 0.f;
817 float zShiftTrkPileUp = 0.f;
818 if (nIdxBCMax - nIdxBCMin >= 2) {
822 float sumCorr2 = 0.f;
825 float slopeFactor =
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetSlopeFloat() * mGeo->GetPadPlaneWidthIPad(
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetDetector()) / 4.f;
826 for (
int32_t iBC = nIdxBCMin; iBC < nIdxBCMax; iBC++) {
827 int32_t deltaBC = CAMath::Round(mFT0TriggeredBC[iBC] - GetConstantMem()->ioPtrs.trdTriggerTimes[collisionId] / o2::constants::lhc::LHCBunchSpacingMUS);
828 float probBC = mRecoParam->getPileUpProbTracklet(deltaBC,
true, (
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetQ0() != 0), (
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetQ1() != 0));
829 sumCorr += probBC * slopeFactor * deltaBC;
830 sumCorr2 += probBC * slopeFactor * deltaBC * slopeFactor * deltaBC;
832 yCorrPileUp_weightedMean -= slopeFactor * deltaBC * probBC;
833 if (probBC > maxProb) {
835 yCorrPileUp = -slopeFactor * deltaBC;
836 zShiftTrkPileUp = -deltaBC * o2::constants::lhc::LHCBunchSpacingMUS * mTPCVdrift * mTrackAttribs[iTrk].mSide;
839 if (sumProb > 1e-6f) {
840 yAddErrPileUp2 = sumCorr2 / sumProb - 2 * yCorrPileUp * sumCorr / sumProb + yCorrPileUp * yCorrPileUp;
841 yCorrPileUp_weightedMean /= sumProb;
845 zPosCorrUp -= zShiftTrkPileUp;
847 yPosCorrUp += yCorrPileUp_weightedMean;
849 const auto currDet =
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetDetector();
850 int nTrackletsChamber = mTrackletIndexArray[trkltIdxOffset + currDet + 1] - mTrackletIndexArray[trkltIdxOffset + currDet];
851 float angularPull = GetAngularPull(spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getDy() + dyTiltCorr, trkWork->getSnp(), nTrackletsChamber);
854 if (Param().
rec.trd.useAngularPull == 3 || Param().
rec.trd.useAngularPull == 4) {
855 float corrPull = -angularPull * mRecoParam->getCorrYDy(trkWork->getSnp());
856 yPosCorrUp += corrPull;
859 float trkltPosUp[2] = {yPosCorrUp, zPosCorrUp};
860 float trkltCovUp[3] = {0.f};
861 RecalcTrkltCov(tilt, trkWork->getSnp(), pad->GetRowSize(
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetZbin()), ((Param().
rec.trd.useAngularPull != 0) ? angularPull : 0.f), nTrackletsChamber, trkltCovUp);
862 trkltCovUp[0] += yAddErrPileUp2;
864#ifdef ENABLE_GPUTRDDEBUG
865 prop->setTrack(&trackNoUp);
866 prop->rotate(GetAlphaOfSector(trkltSec));
868 prop->propagateToX(mR[
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetDetector()], .8f, 2.f);
869 prop->setTrack(trkWork);
872 if (!wasTrackStored) {
873#ifdef ENABLE_GPUTRDDEBUG
874 mDebug->SetTrackParameterNoUp(trackNoUp, iLayer);
876 mDebug->SetTrackParameter(*trkWork, iLayer);
877 mDebug->SetRawTrackletPosition(spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].
getX(), spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].
getY(), spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getZ(), iLayer);
878 mDebug->SetCorrectedTrackletPosition(trkltPosUp, iLayer);
879 mDebug->SetTrackletCovariance(trkltCovUp, iLayer);
880 mDebug->SetTrackletProperties(spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getDy(),
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetDetector(), iLayer);
881 wasTrackStored =
true;
884 if (!prop->update(trkltPosUp, trkltCovUp)) {
886 GPUWarning(
"Failed to update track %i with space point in layer %i", iTrk, iLayer);
888 trkWork->setChi2(trkWork->getChi2() + Param().
rec.trd.penaltyChi2);
889 if (trkWork->getIsFindable(iLayer)) {
890 if (trkWork->getNmissingConsecLayers(iLayer) >= Param().
rec.trd.stopTrkAfterNMissLy) {
891 trkWork->setIsStopped();
894 if (iUpdate == 0 && mNCandidates > 1) {
895 *
t = mCandidates[2 * iUpdate + nextIdx];
899 if (!trkWork->CheckNumericalQuality()) {
901 GPUInfo(
"Track %i has invalid covariance matrix. Aborting track following\n", iTrk);
905 trkWork->addTracklet(iLayer, mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId);
906 trkWork->setChi2(mHypothesis[iUpdate + hypothesisIdxOffset].mChi2);
907 trkWork->setIsFindable(iLayer);
908 trkWork->setCollisionId(collisionId);
910 float projZEntry, projYEntry;
912 prop->getPropagatedYZ(trkWork->getX() - mGeo->GetCdrHght(), projYEntry, projZEntry);
918 const auto padrowEntry = pad->GetPadRowNumber(projZEntry);
919 const auto padrowExit = pad->GetPadRowNumber(trkWork->getZ());
920 if (padrowEntry != padrowExit) {
921 trkWork->setIsCrossingNeighbor(iLayer);
922 trkWork->setHasPadrowCrossing();
926 for (
int32_t trkltIdx = glbTrkltIdxOffset + mTrackletIndexArray[trkltIdxOffset + currDet]; trkltIdx < glbTrkltIdxOffset + mTrackletIndexArray[trkltIdxOffset + currDet + 1]; ++trkltIdx) {
928 if (mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId == trkltIdx) {
931 if (CAMath::Abs(
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetZbin() -
tracklets[trkltIdx].GetZbin()) == 1 &&
932 CAMath::Abs(
tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetY() -
tracklets[trkltIdx].GetY()) < 1) {
933 trkWork->setIsCrossingNeighbor(iLayer);
934 trkWork->setHasNeighbor();
938 if (iUpdate == 0 && mNCandidates > 1) {
939 *
t = mCandidates[2 * iUpdate + nextIdx];
946 GPUInfo(
"Track %i cannot be followed. Stopped in layer %i", iTrk, iLayer);
957 mDebug->SetTrack(*
t);
961 GPUInfo(
"Ended track following for track %i at x=%f with pt=%f. Attached %i tracklets",
t->getRefGlobalTrackIdRaw(),
t->getX(),
t->getPt(),
t->getNtracklets());
963 if (nCurrHypothesis > 1) {
964 if (CAMath::Abs(mHypothesis[hypothesisIdxOffset + 1].GetReducedChi2() - mHypothesis[hypothesisIdxOffset].GetReducedChi2()) < Param().
rec.trd.chi2SeparationCut) {
971template <
class TRDTRK,
class PROP>
978 if (nCurrHypothesis == 0) {
980 mHypothesis[idxOffset] = hypo;
982 }
else if (nCurrHypothesis > 0 && nCurrHypothesis < mNCandidates) {
984 for (
int32_t i = idxOffset;
i < nCurrHypothesis + idxOffset; ++
i) {
985 if (hypo.GetReducedChi2() < mHypothesis[
i].GetReducedChi2()) {
986 for (
int32_t k = nCurrHypothesis + idxOffset; k >
i; --k) {
987 mHypothesis[k] = mHypothesis[k - 1];
989 mHypothesis[
i] = hypo;
994 mHypothesis[nCurrHypothesis + idxOffset] = hypo;
999 int32_t i = nCurrHypothesis + idxOffset - 1;
1000 for (;
i >= idxOffset; --
i) {
1001 if (mHypothesis[
i].GetReducedChi2() < hypo.GetReducedChi2()) {
1005 if (
i < (nCurrHypothesis + idxOffset - 1)) {
1007 for (
int32_t k = nCurrHypothesis + idxOffset - 1; k >
i + 1; --k) {
1008 mHypothesis[k] = mHypothesis[k - 1];
1010 mHypothesis[
i + 1] = hypo;
1015template <
class TRDTRK,
class PROP>
1031template <
class TRDTRK,
class PROP>
1039 float alpha = mGeo->GetAlpha();
1040 float xTmp =
t->getX();
1041 float y =
t->getY();
1042 float yMax =
t->getX() * CAMath::Tan(0.5f *
alpha);
1043 float alphaCurr =
t->getAlpha();
1045 if (CAMath::Abs(
y) > 2.f *
yMax) {
1047 GPUInfo(
"AdjustSector: Track %i with pT = %f crossing two sector boundaries at x = %f",
t->getRefGlobalTrackIdRaw(),
t->getPt(),
t->getX());
1053 while (CAMath::Abs(
y) >
yMax) {
1058 float alphaNew = alphaCurr +
alpha * sign;
1059 if (alphaNew > CAMath::Pi()) {
1060 alphaNew -= 2 * CAMath::Pi();
1061 }
else if (alphaNew < -CAMath::Pi()) {
1062 alphaNew += 2 * CAMath::Pi();
1064 if (!prop->rotate(alphaNew)) {
1067 if (!prop->propagateToX(xTmp, .8f, 2.f)) {
1076template <
class TRDTRK,
class PROP>
1083 alpha += 2.f * CAMath::Pi();
1084 }
else if (
alpha >= 2.f * CAMath::Pi()) {
1085 alpha -= 2.f * CAMath::Pi();
1090template <
class TRDTRK,
class PROP>
1096 float alpha = 2.0f * CAMath::Pi() / (
float)kNSectors * ((
float)sec + 0.5f);
1097 if (
alpha > CAMath::Pi()) {
1098 alpha -= 2 * CAMath::Pi();
1103template <
class TRDTRK,
class PROP>
1104GPUd()
void GPUTRDTracker_t<TRDTRK, PROP>::RecalcTrkltCov(const
float tilt, const
float snp, const
float rowSize, const
float pull, const
int occupancy,
float (&cov)[3])
1110 float t2 = tilt * tilt;
1111 float c2 = 1.f / (1.f + t2);
1112 float sy2 = mRecoParam->getRPhiRes(snp, CAMath::Abs(pull), occupancy);
1113 float sz2 = rowSize * rowSize / 12.f;
1114 cov[0] = c2 * (sy2 + t2 * sz2);
1115 cov[1] = c2 * tilt * (sz2 - sy2);
1116 cov[2] = c2 * (t2 * sy2 + sz2);
1119template <
class TRDTRK,
class PROP>
1120GPUd()
void GPUTRDTracker_t<TRDTRK, PROP>::RecalcTrkltCovDy(const
float tilt, const
float snp, const
float pull, const
int occupancy,
float (&cov)[6])
1122 float t2 = tilt * tilt;
1123 float c2 = 1.f / (1.f + t2);
1125 float sdy2 = mRecoParam->getDyRes(snp, occupancy);
1126 cov[3] = mRecoParam->getCorrYDy(snp) * CAMath::Sqrt(sdy2 * c2);
1127 cov[4] = -tilt * mRecoParam->getCorrYDy(snp) * CAMath::Sqrt(sdy2 * c2);
1131template <
class TRDTRK,
class PROP>
1136 float c00 = cov[2] * cov[5] - cov[4] * cov[4];
1137 float c01 = cov[4] * cov[3] - cov[1] * cov[5];
1138 float c02 = cov[1] * cov[4] - cov[2] * cov[3];
1139 float c11 = cov[5] * cov[0] - cov[3] * cov[3];
1140 float c12 = cov[3] * cov[1] - cov[4] * cov[0];
1141 float c22 = cov[0] * cov[2] - cov[1] * cov[1];
1143 float t0 = CAMath::Abs(cov[0]);
1144 float t1 = CAMath::Abs(cov[1]);
1145 float t2 = CAMath::Abs(cov[3]);
1153 det = c12 * c01 - c11 * c02;
1156 det = c11 * c22 - c12 * c12;
1158 }
else if (t2 >=
t1) {
1160 det = c12 * c01 - c11 * c02;
1163 det = c02 * c12 - c01 * c22;
1166 if (det == 0 || tmp == 0) {
1170 float s = tmp / det;
1182template <
class TRDTRK,
class PROP>
1185 float dYtrack = mRecoParam->convertAngleToDy(snp);
1186 float dYresolution = mRecoParam->getDyRes(snp, occupancy);
1187 if (dYresolution < 1e-6f) {
1190 return (dYtracklet - dYtrack) / CAMath::Sqrt(dYresolution);
1193template <
class TRDTRK,
class PROP>
1194GPUd() int
GPUTRDTracker_t<TRDTRK, PROP>::GetNtrackletsChamber(
int collisionId,
int detector)
const
1197 int32_t trkltIdxOffset = collisionId * (kNChambers + 1);
1198 int nTrackletsChamber = mTrackletIndexArray[trkltIdxOffset + detector + 1] - mTrackletIndexArray[trkltIdxOffset + detector];
1199 return nTrackletsChamber;
1202template <
class TRDTRK,
class PROP>
1211 const float yMax = CAMath::Abs(mGeo->GetCol0(iLayer));
1212 float zTrk =
t->getZ() + zShiftTrk;
1214 int32_t currStack = mGeo->GetStack(zTrk, iLayer);
1220 if (currStack > -1) {
1222 currDet = mGeo->GetDetector(iLayer, currStack, currSec);
1223 det[nDets++] = currDet;
1225 int32_t lastPadRow = mGeo->GetRowMax(iLayer, currStack, 0);
1226 float zCenter =
pp->GetRowPos(lastPadRow / 2);
1227 if ((zTrk + roadZ) >
pp->GetRow0() || (zTrk - roadZ) <
pp->GetRowEnd()) {
1228 int32_t addStack = zTrk > zCenter ? currStack - 1 : currStack + 1;
1229 if (addStack < kNStacks && addStack > -1) {
1230 det[nDets++] = mGeo->GetDetector(iLayer, addStack, currSec);
1234 if (CAMath::Abs(zTrk) >
zMax) {
1237 currDet = mGeo->GetDetector(iLayer, 0, currSec);
1239 currDet = mGeo->GetDetector(iLayer, kNStacks - 1, currSec);
1241 det[nDets++] = currDet;
1242 currStack = mGeo->GetStack(currDet);
1246 currDet = GetDetectorNumber(zTrk + 4.0f,
alpha, iLayer);
1247 if (currDet != -1) {
1248 det[nDets++] = currDet;
1250 currDet = GetDetectorNumber(zTrk - 4.0f,
alpha, iLayer);
1251 if (currDet != -1) {
1252 det[nDets++] = currDet;
1257 if ((CAMath::Abs(
t->getY()) + roadY) >
yMax) {
1258 const int32_t nStacksToSearch = nDets;
1260 if (
t->getY() > 0) {
1261 newSec = (currSec + 1) % kNSectors;
1263 newSec = (currSec > 0) ? currSec - 1 : kNSectors - 1;
1266 currStack = mGeo->GetStack(det[idx]);
1267 det[nDets++] = mGeo->GetDetector(iLayer, currStack, newSec);
1271 for (
int32_t iDet = 0; iDet < nDets; iDet++) {
1272 if (!mGeo->ChamberInGeometry(det[iDet])) {
1278template <
class TRDTRK,
class PROP>
1286 float zTrk =
t->getZ() + zShiftTrk;
1296 if (!mGeo->ChamberInGeometry(det)) {
1301 if (mChamberStatus[det]) {
1306 float yMax =
pp->GetColEnd();
1307 float zMax =
pp->GetRow0();
1308 float zMin =
pp->GetRowEnd();
1314 if (
yMax - CAMath::Abs(
t->getY()) < epsY) {
1318 if (!((zTrk >
zMin + epsZ) && (zTrk <
zMax - epsZ))) {
1333#ifndef GPUCA_GPUCODE