Project
Loading...
Searching...
No Matches
GPUTrackingRefit.cxx
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
14
15#define GPUCA_CADEBUG 0
16
17#include "GPUTrackingRefit.h"
18#include "GPUO2DataTypes.h"
19#include "GPUTPCGMTrackParam.h"
20#include "GPUTPCGMMergedTrack.h"
21#include "GPUTPCGMPropagator.h"
22#include "GPUConstantMem.h"
27#include "GPUParam.inc"
28#include "GPUCommonArray.h"
29#include "GPUParam.h"
31
32#ifndef GPUCA_GPUCODE_DEVICE
33#include <type_traits>
34#endif
35
36using namespace o2::gpu;
37using namespace o2::track;
38using namespace o2::base;
39using namespace o2::tpc;
40
41static constexpr int32_t kIGNORE_ENDS = 3;
42
43#define IgnoreErrors(SNP) \
44 if (mIgnoreErrorsOnTrackEnds) { \
45 if (abs(i - stop) <= kIGNORE_ENDS && (CAMath::Abs(SNP) >= Propagator::MAX_SIN_PHI || abs(start - stop) < 30)) { \
46 break; \
47 } \
48 if (abs(i - start) <= kIGNORE_ENDS && (CAMath::Abs(SNP) >= Propagator::MAX_SIN_PHI || abs(start - stop) < 30)) { \
49 continue; \
50 } \
51 }
52// End IgnoreErrors
53
54#ifndef GPUCA_GPUCODE
58
63
67#endif
68
69namespace o2::gpu::internal
70{
71namespace // anonymous
72{
73template <class T>
74struct refitTrackTypes;
75template <>
76struct refitTrackTypes<GPUTPCGMTrackParam> {
77 using propagator = GPUTPCGMPropagator;
78};
79template <>
80struct refitTrackTypes<TrackParCov> {
81 using propagator = const Propagator*;
82};
83} // anonymous namespace
84} // namespace o2::gpu::internal
85
86template <>
87GPUd() void GPUTrackingRefit::initProp<GPUgeneric() GPUTPCGMPropagator>(GPUTPCGMPropagator& prop) // FIXME: GPUgeneric() needed to make the clang spirv output link correctly
88{
89 prop.SetMaterialTPC();
90 prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
91 prop.SetSeedingErrors(false);
92 prop.SetFitInProjections(mPparam->rec.fitInProjections != 0);
93 prop.SetPropagateBzOnly(false);
94 prop.SetPolynomialField(&mPparam->polynomialField);
95 prop.SetMatLUT(mPmatLUT);
96}
97
98template <>
99GPUd() void GPUTrackingRefit::initProp<const Propagator * GPUgeneric()>(const Propagator*& prop) // FIXME: GPUgeneric() needed to make the clang spirv output link correctly
100{
101 prop = mPpropagator;
102}
103
104template <class T, class S, class U>
105GPUd() void GPUTrackingRefit::convertTrack(T& trk, const S& trkX, U& prop, float* chi2)
106{
107 trk = trkX;
108}
109
110// Generic
111template <>
113{
114 convertTrackParam(trk, trkX);
115 prop.SetTrack(&trk, trkX.getAlpha());
116}
117template <>
119{
120 convertTrackParam(trk, trkX);
121 trk.setAlpha(prop.GetAlpha());
122}
123// GPUTPCGMMergedTrack input
124template <>
125GPUd() void GPUTrackingRefit::convertTrack<TrackParCov, GPUTPCGMMergedTrack, const Propagator*>(TrackParCov& trk, const GPUTPCGMMergedTrack& trkX, const Propagator*& prop, float* chi2)
126{
127 initProp(prop);
128 convertTrackParam(trk, trkX.GetParam());
129 trk.setAlpha(trkX.GetAlpha());
130 *chi2 = trkX.GetParam().GetChi2();
131}
132template <>
133GPUd() void GPUTrackingRefit::convertTrack<GPUTPCGMMergedTrack, TrackParCov, const Propagator*>(GPUTPCGMMergedTrack& trk, const TrackParCov& trkX, const Propagator*& prop, float* chi2)
134{
135 convertTrackParam(trk.Param(), trkX);
136 trk.SetAlpha(trkX.getAlpha());
137 trk.Param().SetChi2(*chi2);
138}
139template <>
141{
142 initProp(prop);
143 trk = trkX.GetParam();
144 prop.SetTrack(&trk, trkX.GetAlpha());
145}
146template <>
148{
149 trk.SetParam(trkX);
150 trk.SetAlpha(prop.GetAlpha());
151}
152// TrackTPC input
153template <>
154GPUd() void GPUTrackingRefit::convertTrack<TrackParCov, TrackTPC, const Propagator*>(TrackParCov& trk, const TrackTPC& trkX, const Propagator*& prop, float* chi2)
155{
156 initProp(prop);
157 convertTrack<TrackParCov, TrackParCov, const Propagator*>(trk, trkX, prop, nullptr);
158 *chi2 = trkX.getChi2();
159}
160template <>
161GPUd() void GPUTrackingRefit::convertTrack<TrackTPC, TrackParCov, const Propagator*>(TrackTPC& trk, const TrackParCov& trkX, const Propagator*& prop, float* chi2)
162{
163 convertTrack<TrackParCov, TrackParCov, const Propagator*>(trk, trkX, prop, nullptr);
164 trk.setChi2(*chi2);
165}
166template <>
168{
169 initProp(prop);
170 convertTrack<GPUTPCGMTrackParam, TrackParCov, GPUTPCGMPropagator>(trk, trkX, prop, nullptr);
171 trk.SetChi2(trkX.getChi2());
172}
173template <>
175{
176 convertTrack<TrackParCov, GPUTPCGMTrackParam, GPUTPCGMPropagator>(trk, trkX, prop, nullptr);
177 trk.setChi2(trkX.GetChi2());
178}
179// TrackParCovWithArgs input
180template <>
181GPUd() void GPUTrackingRefit::convertTrack<TrackParCov, GPUTrackingRefit::TrackParCovWithArgs, const Propagator*>(TrackParCov& trk, const GPUTrackingRefit::TrackParCovWithArgs& trkX, const Propagator*& prop, float* chi2)
182{
183 initProp(prop);
184 convertTrack<TrackParCov, TrackParCov, const Propagator*>(trk, trkX.trk, prop, nullptr);
185 *chi2 = trkX.chi2 ? *trkX.chi2 : 0.f;
186}
187template <>
188GPUd() void GPUTrackingRefit::convertTrack<GPUTrackingRefit::TrackParCovWithArgs, TrackParCov, const Propagator*>(GPUTrackingRefit::TrackParCovWithArgs& trk, const TrackParCov& trkX, const Propagator*& prop, float* chi2)
189{
190 convertTrack<TrackParCov, TrackParCov, const Propagator*>(trk.trk, trkX, prop, nullptr);
191 if (trk.chi2) {
192 *trk.chi2 = *chi2;
193 }
194}
195template <>
196GPUd() void GPUTrackingRefit::convertTrack<GPUTPCGMTrackParam, GPUTrackingRefit::TrackParCovWithArgs, GPUTPCGMPropagator>(GPUTPCGMTrackParam& trk, const GPUTrackingRefit::TrackParCovWithArgs& trkX, GPUTPCGMPropagator& prop, float* chi2)
197{
198 initProp(prop);
199 convertTrack<GPUTPCGMTrackParam, TrackParCov, GPUTPCGMPropagator>(trk, trkX.trk, prop, nullptr);
200 trk.SetChi2(trkX.chi2 ? *trkX.chi2 : 0.f);
201}
202template <>
203GPUd() void GPUTrackingRefit::convertTrack<GPUTrackingRefit::TrackParCovWithArgs, GPUTPCGMTrackParam, GPUTPCGMPropagator>(GPUTrackingRefit::TrackParCovWithArgs& trk, const GPUTPCGMTrackParam& trkX, GPUTPCGMPropagator& prop, float* chi2)
204{
205 convertTrack<TrackParCov, GPUTPCGMTrackParam, GPUTPCGMPropagator>(trk.trk, trkX, prop, chi2);
206 if (trk.chi2) {
207 *trk.chi2 = trkX.GetChi2();
208 }
209}
210
211GPUd() static const float* getPar(const GPUTPCGMTrackParam& trk) { return trk.GetPar(); }
212GPUd() static const float* getPar(const TrackParCov& trk) { return trk.getParams(); }
213
214template <class T, class S>
215GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov)
216{
217 CADEBUG(int32_t ii; printf("\nRefitting track\n"));
218 typename internal::refitTrackTypes<S>::propagator prop;
219 S trk;
220 float TrackParCovChi2 = 0.f;
221 convertTrack<S, T, typename internal::refitTrackTypes<S>::propagator>(trk, trkX, prop, &TrackParCovChi2);
222 int32_t begin = 0, count;
223 float tOffset;
224 if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
225 count = trkX.NClusters();
226 if (trkX.Looper()) {
227 int32_t leg = mPtrackHits[trkX.FirstClusterRef() + trkX.NClusters() - 1].leg;
228 for (int32_t i = trkX.NClusters() - 2; i > 0; i--) {
229 if (mPtrackHits[trkX.FirstClusterRef() + i].leg != leg) {
230 begin = i + 1;
231 break;
232 }
233 }
234 }
235 tOffset = trkX.GetParam().GetTZOffset();
236 } else if constexpr (std::is_same_v<T, TrackTPC>) {
237 count = trkX.getNClusters();
238 tOffset = trkX.getTime0();
239 } else if constexpr (std::is_same_v<T, TrackParCovWithArgs>) {
240 count = trkX.clusRef.getEntries();
241 tOffset = trkX.time0;
242 } else {
243 static_assert("Invalid template");
244 }
245 if constexpr (std::is_same_v<S, GPUTPCGMTrackParam>) {
246 CADEBUG(printf("\t%21sInit Alpha %8.3f , X %8.3f - Y %8.3f, Z %8.3f - QPt %7.2f (%7.2f), SP %5.2f (%5.2f) --- Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f\n", "", prop.GetAlpha(), trk.GetX(), trk.Par()[0], trk.Par()[1], trk.Par()[4], prop.GetQPt0(), trk.Par()[2], prop.GetSinPhi0(), sqrtf(trk.Cov()[0]), sqrtf(trk.Cov()[2]), sqrtf(trk.Cov()[5]), sqrtf(trk.Cov()[14])));
247 }
248
249 int32_t direction = outward ? -1 : 1;
250 int32_t start = outward ? count - 1 : begin;
251 int32_t stop = outward ? begin - 1 : count;
252 const ClusterNative* cl = nullptr;
253 uint8_t sector = 255, row = 255;
254 int32_t lastSector = -1, currentSector = -1, currentRow = -1;
255 int16_t clusterState = 0, nextState = 0;
256 int32_t nFitted = 0;
257 float sumInvSqrtCharge = 0.f;
258 int32_t nAvgCharge = 0;
259
260 for (int32_t i = start; i != stop; i += cl ? 0 : direction) {
261 float x = 0, y = 0, z = 0, charge = 0; // FIXME: initialization unneeded, but GCC incorrectly produces uninitialized warnings otherwise
262 float time = 0.f, invCharge = 0.f, invSqrtCharge = 0.f; // Same here...
263 int32_t clusters = 0;
264 while (true) {
265 if (!cl) {
266 CADEBUG(ii = i);
267 if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
268 const auto& hit = mPtrackHits[trkX.FirstClusterRef() + i];
269 cl = &mPclusterNative->clustersLinear[hit.num];
271 cl = nullptr;
272 if (i + direction != stop) {
273 i += direction;
274 continue;
275 }
276 break;
277 }
278 row = hit.row;
279 sector = hit.sector;
280 nextState = mPclusterState[hit.num];
281 } else if constexpr (std::is_same_v<T, TrackTPC>) {
282 cl = &trkX.getCluster(mPtrackHitReferences, i, *mPclusterNative, sector, row);
283 nextState = mPclusterState[cl - mPclusterNative->clustersLinear];
284 } else if constexpr (std::is_same_v<T, TrackParCovWithArgs>) {
285 cl = &TrackTPC::getCluster(mPtrackHitReferences, i, *mPclusterNative, sector, row, trkX.clusRef);
286 nextState = mPclusterState[cl - mPclusterNative->clustersLinear];
287 } else {
288 static_assert("Invalid template");
289 }
290 }
291 if (clusters == 0 || (row == currentRow && sector == currentSector)) {
292 if (clusters == 1) {
293 x *= charge;
294 y *= charge;
295 z *= charge;
296 }
297 if (clusters == 0) {
298 mPfastTransformHelper->Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, tOffset);
299 CADEBUG(printf("\tHit %3d/%3d Row %3d: Cluster Alpha %8.3f %3d, X %8.3f - Y %8.3f, Z %8.3f - State %d\n", ii, count, row, mPparam->Alpha(sector), (int32_t)sector, x, y, z, (int32_t)nextState));
300 currentRow = row;
301 currentSector = sector;
302 charge = cl->qTot;
303 clusterState = nextState;
304 time = cl->getTime();
305 invSqrtCharge = CAMath::InvSqrt(cl->qMax);
306 invCharge = (1.f / cl->qMax);
307 } else {
308 float xx, yy, zz;
309 mPfastTransformHelper->Transform(sector, row, cl->getPad(), cl->getTime(), xx, yy, zz, tOffset);
310 CADEBUG(printf("\tHit %3d/%3d Row %3d: Cluster Alpha %8.3f %3d, X %8.3f - Y %8.3f, Z %8.3f - State %d\n", ii, count, row, mPparam->Alpha(sector), (int32_t)sector, xx, yy, zz, (int32_t)nextState));
311 x += xx * cl->qTot;
312 y += yy * cl->qTot;
313 z += zz * cl->qTot;
314 charge += cl->qTot;
315 clusterState |= nextState;
316 }
317 cl = nullptr;
318 clusters++;
319 if (i + direction != stop) {
320 i += direction;
321 continue;
322 }
323 }
324 break;
325 }
326 if (clusters == 0) {
327 continue;
328 } else if (clusters > 1) {
329 x /= charge;
330 y /= charge;
331 z /= charge;
332 CADEBUG(printf("\tMerged Hit Row %3d: Cluster Alpha %8.3f %3d, X %8.3f - Y %8.3f, Z %8.3f - State %d\n", row, mPparam->Alpha(sector), (int32_t)sector, x, y, z, (int32_t)clusterState));
333 }
334
335 float invAvgCharge = (sumInvSqrtCharge += invSqrtCharge) / ++nAvgCharge;
336 invAvgCharge *= invAvgCharge;
337
338 if constexpr (std::is_same_v<S, GPUTPCGMTrackParam>) {
339 if (prop.PropagateToXAlpha(x, mPparam->Alpha(currentSector), !outward)) {
340 IgnoreErrors(trk.GetSinPhi());
341 return -2;
342 }
343 if (resetCov) {
344 trk.ResetCovariance();
345 } else if (lastSector != -1 && (lastSector < 18) != (sector < 18)) {
346 if (mPparam->rec.tpc.addErrorsCECrossing) {
347 if (mPparam->rec.tpc.addErrorsCECrossing >= 2) {
348 trk.AddCovDiagErrorsWithCorrelations(mPparam->rec.tpc.errorsCECrossing);
349 } else {
350 trk.AddCovDiagErrors(mPparam->rec.tpc.errorsCECrossing);
351 }
352 } else if (trk.Cov()[2] < 0.5f) {
353 trk.Cov()[2] = 0.5f;
354 }
355 }
356 CADEBUG(printf("\t%21sPropaga Alpha %8.3f , X %8.3f - Y %8.3f, Z %8.3f - QPt %7.2f (%7.2f), SP %5.2f (%5.2f) --- Res %8.3f %8.3f --- Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f - YPt %8.3f\n", "", prop.GetAlpha(), x, trk.Par()[0], trk.Par()[1], trk.Par()[4], prop.GetQPt0(), trk.Par()[2], prop.GetSinPhi0(), trk.Par()[0] - y, trk.Par()[1] - z, sqrtf(trk.Cov()[0]), sqrtf(trk.Cov()[2]), sqrtf(trk.Cov()[5]), sqrtf(trk.Cov()[14]), trk.Cov()[10]));
357 lastSector = sector;
358 if (prop.Update(y, z, row, *mPparam, clusterState, 0, nullptr, true, sector, time, invAvgCharge, invCharge)) {
359 IgnoreErrors(trk.GetSinPhi());
360 return -3;
361 }
362 trk.ConstrainSinPhi();
363 CADEBUG(printf("\t%21sFit Alpha %8.3f , X %8.3f - Y %8.3f, Z %8.3f - QPt %7.2f (%7.2f), SP %5.2f (%5.2f), DzDs %5.2f %16s --- Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f - YPt %8.3f\n", "", prop.GetAlpha(), x, trk.Par()[0], trk.Par()[1], trk.Par()[4], prop.GetQPt0(), trk.Par()[2], prop.GetSinPhi0(), trk.Par()[3], "", sqrtf(trk.Cov()[0]), sqrtf(trk.Cov()[2]), sqrtf(trk.Cov()[5]), sqrtf(trk.Cov()[14]), trk.Cov()[10]));
364 } else if constexpr (std::is_same_v<S, TrackParCov>) {
365 if (!trk.rotate(mPparam->Alpha(currentSector))) {
366 IgnoreErrors(trk.getSnp());
367 return -1;
368 }
369 if (!prop->PropagateToXBxByBz(trk, x, GPUCA_MAX_SIN_PHI_LOW)) {
370 IgnoreErrors(trk.getSnp());
371 return -2;
372 }
373 if (lastSector != -1 && (lastSector < 18) != (sector < 18)) {
374 if (mPparam->rec.tpc.addErrorsCECrossing) {
375 trk.updateCov(mPparam->rec.tpc.errorsCECrossing, mPparam->rec.tpc.addErrorsCECrossing >= 2);
376 } else if (trk.getCov()[2] < 0.5f) {
377 trk.setCov(0.5f, 2);
378 }
379 }
380 if (resetCov) {
381 trk.resetCovariance();
382 float bzkG = prop->getNominalBz(), qptB5Scale = CAMath::Abs(bzkG) > 0.1f ? CAMath::Abs(bzkG) / 5.006680f : 1.f;
383 float q2pt2 = trk.getQ2Pt() * trk.getQ2Pt(), q2pt2Wgh = q2pt2 * qptB5Scale * qptB5Scale;
384 float err2 = (100.f + q2pt2Wgh) / (1.f + q2pt2Wgh) * q2pt2; // -> 100 for high pTs, -> 1 for low pTs.
385 trk.setCov(err2, 14); // 100% error
386 TrackParCovChi2 = 0.f;
387 }
388 CADEBUG(printf("\t%21sPropaga Alpha %8.3f , X %8.3f - Y %8.3f, Z %8.3f - QPt %7.2f (%7.2f), SP %5.2f (%5.2f) --- Res %8.3f %8.3f --- Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f - YPt %8.3f\n", "", trk.getAlpha(), x, trk.getParams()[0], trk.getParams()[1], trk.getParams()[4], trk.getParams()[4], trk.getParams()[2], trk.getParams()[2], trk.getParams()[0] - y, trk.getParams()[1] - z, sqrtf(trk.getCov()[0]), sqrtf(trk.getCov()[2]), sqrtf(trk.getCov()[5]), sqrtf(trk.getCov()[14]), trk.getCov()[10]));
389 std::array<float, 2> p = {y, z};
390 std::array<float, 3> c = {0, 0, 0};
391 GPUTPCGMPropagator::GetErr2(c[0], c[2], *mPparam, getPar(trk)[2], getPar(trk)[3], z, x, y, currentRow, clusterState, sector, time, invAvgCharge, invCharge, false);
392 TrackParCovChi2 += trk.getPredictedChi2(p, c);
393 if (!trk.update(p, c)) {
394 IgnoreErrors(trk.getSnp());
395 return -3;
396 }
397 CADEBUG(printf("\t%21sFit Alpha %8.3f , X %8.3f - Y %8.3f, Z %8.3f - QPt %7.2f (%7.2f), SP %5.2f (%5.2f), DzDs %5.2f %16s --- Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f - YPt %8.3f\n", "", trk.getAlpha(), x, trk.getParams()[0], trk.getParams()[1], trk.getParams()[4], trk.getParams()[4], trk.getParams()[2], trk.getParams()[2], trk.getParams()[3], "", sqrtf(trk.getCov()[0]), sqrtf(trk.getCov()[2]), sqrtf(trk.getCov()[5]), sqrtf(trk.getCov()[14]), trk.getCov()[10]));
398 } else {
399 static_assert("Invalid template");
400 }
401 resetCov = false;
402 nFitted++;
403 }
404 if constexpr (std::is_same_v<S, GPUTPCGMTrackParam>) {
405 float alpha = prop.GetAlpha();
406 trk.MoveToReference(prop, *mPparam, alpha);
407 trk.NormalizeAlpha(alpha);
408 prop.SetAlpha(alpha);
409 } else if constexpr (std::is_same_v<S, TrackParCov>) {
410 static constexpr float kDeg2Rad = M_PI / 180.f;
411 static constexpr float kSectAngle = 2 * M_PI / 18.f;
412 if (mPparam->rec.tpc.trackReferenceX <= 500) {
413 if (prop->PropagateToXBxByBz(trk, mPparam->rec.tpc.trackReferenceX)) {
414 if (CAMath::Abs(trk.getY()) > trk.getX() * CAMath::Tan(kSectAngle / 2.f)) {
415 float newAlpha = trk.getAlpha() + CAMath::Round(CAMath::ATan2(trk.getY(), trk.getX()) / kDeg2Rad / 20.f) * kSectAngle;
416 GPUTPCGMTrackParam::NormalizeAlpha(newAlpha);
417 trk.rotate(newAlpha) && prop->PropagateToXBxByBz(trk, mPparam->rec.tpc.trackReferenceX);
418 }
419 }
420 }
421 } else {
422 static_assert("Invalid template");
423 }
424
425 convertTrack<T, S, typename internal::refitTrackTypes<S>::propagator>(trkX, trk, prop, &TrackParCovChi2);
426 return nFitted;
427}
428
429#if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.
430template GPUdni() int32_t GPUTrackingRefit::RefitTrack<GPUTPCGMMergedTrack, TrackParCov>(GPUTPCGMMergedTrack& trk, bool outward, bool resetCov);
431template GPUdni() int32_t GPUTrackingRefit::RefitTrack<GPUTPCGMMergedTrack, GPUTPCGMTrackParam>(GPUTPCGMMergedTrack& trk, bool outward, bool resetCov);
432template GPUdni() int32_t GPUTrackingRefit::RefitTrack<TrackTPC, TrackParCov>(TrackTPC& trk, bool outward, bool resetCov);
433template GPUdni() int32_t GPUTrackingRefit::RefitTrack<TrackTPC, GPUTPCGMTrackParam>(TrackTPC& trk, bool outward, bool resetCov);
434template GPUdni() int32_t GPUTrackingRefit::RefitTrack<GPUTrackingRefit::TrackParCovWithArgs, TrackParCov>(GPUTrackingRefit::TrackParCovWithArgs& trk, bool outward, bool resetCov);
435template GPUdni() int32_t GPUTrackingRefit::RefitTrack<GPUTrackingRefit::TrackParCovWithArgs, GPUTPCGMTrackParam>(GPUTrackingRefit::TrackParCovWithArgs& trk, bool outward, bool resetCov);
436#endif
437
438#ifndef GPUCA_GPUCODE
440{
441 mPclusterState = v->ioPtrs.mergedTrackHitStates;
442 mPclusterNative = v->ioPtrs.clustersNative;
443 mPtrackHits = v->ioPtrs.mergedTrackHits;
444 mPfastTransformHelper = v->calibObjects.fastTransformHelper;
445 mPmatLUT = v->calibObjects.matLUT;
446 mPparam = p ? p : &v->param;
447}
448#endif
Helper class to access correction maps.
Base track model for the Barrel, params only, w/o covariance.
int16_t charge
Definition RawEventData.h:5
int16_t time
Definition RawEventData.h:4
int32_t i
#define GPUdni()
#define GPUgeneric()
#define GPUCA_MAX_SIN_PHI_LOW
#define GPUCA_MAX_SIN_PHI
#define CADEBUG(...)
Definition GPUDef.h:79
uint8_t leg
#define IgnoreErrors(SNP)
uint32_t c
Definition RawData.h:2
void SetMaxData(const GPUTrackingInOutPointers &io)
void SetPtrsFromGPUConstantMem(const GPUConstantMem *v, GPUParam *p=nullptr)
GLfloat GLfloat GLfloat alpha
Definition glcorearb.h:279
GLint GLenum GLint x
Definition glcorearb.h:403
GLint GLsizei count
Definition glcorearb.h:399
const GLdouble * v
Definition glcorearb.h:832
GLint y
Definition glcorearb.h:270
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
GLuint start
Definition glcorearb.h:469
GLdouble GLdouble GLdouble z
Definition glcorearb.h:843
const o2::track::TrackParCov & trkX
GPUd() const expr uint32_t MultivariatePolynomialHelper< Dim
Global TPC definitions and constants.
Definition SimTraits.h:167
Enum< T >::Iterator begin(Enum< T >)
Definition Defs.h:173
TrackParCovF TrackParCov
Definition Track.h:33
std::vector< Cluster > clusters
std::vector< int > row