]>
Commit | Line | Data |
---|---|---|
00d07bcd | 1 | // @(#) $Id: AliHLTTPCCATrackletConstructor.cxx 27042 2008-07-02 12:06:02Z richterm $ |
ce565086 | 2 | // ************************************************************************** |
fbb9b71b | 3 | // This file is property of and copyright by the ALICE HLT Project * |
00d07bcd | 4 | // ALICE Experiment at CERN, All rights reserved. * |
5 | // * | |
6 | // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> * | |
7 | // Ivan Kisel <kisel@kip.uni-heidelberg.de> * | |
8 | // for The ALICE HLT Project. * | |
9 | // * | |
10 | // Permission to use, copy, modify and distribute this software and its * | |
11 | // documentation strictly for non-commercial purposes is hereby granted * | |
12 | // without fee, provided that the above copyright notice appears in all * | |
13 | // copies and that both the copyright notice and this permission notice * | |
14 | // appear in the supporting documentation. The authors make no claims * | |
15 | // about the suitability of this software for any purpose. It is * | |
16 | // provided "as is" without express or implied warranty. * | |
ce565086 | 17 | // * |
00d07bcd | 18 | //*************************************************************************** |
19 | ||
20 | #include "AliHLTTPCCATracker.h" | |
21 | #include "AliHLTTPCCATrackParam.h" | |
4687b8fc | 22 | #include "AliHLTTPCCATrackParam.h" |
00d07bcd | 23 | #include "AliHLTTPCCAGrid.h" |
00d07bcd | 24 | #include "AliHLTTPCCAMath.h" |
25 | #include "AliHLTTPCCADef.h" | |
ce565086 | 26 | #include "AliHLTTPCCATracklet.h" |
00d07bcd | 27 | #include "AliHLTTPCCATrackletConstructor.h" |
28 | ||
b22af1bf | 29 | #define kMaxRowGap 4 |
00d07bcd | 30 | |
f0bada7f | 31 | GPUdi() void AliHLTTPCCATrackletConstructor::InitTracklet( AliHLTTPCCATrackParam &tParam ) |
00d07bcd | 32 | { |
73a33d2e | 33 | //Initialize Tracklet Parameters using default values |
34 | tParam.InitParam(); | |
00d07bcd | 35 | } |
36 | ||
e4818148 | 37 | GPUdi() bool AliHLTTPCCATrackletConstructor::CheckCov(AliHLTTPCCATrackParam &tParam) |
38 | { | |
39 | bool ok = 1; | |
40 | const float *c = tParam.Cov(); | |
41 | for ( int i = 0; i < 15; i++ ) ok = ok && CAMath::Finite( c[i] ); | |
42 | for ( int i = 0; i < 5; i++ ) ok = ok && CAMath::Finite( tParam.Par()[i] ); | |
43 | ok = ok && ( tParam.X() > 50 ); | |
44 | if ( c[0] <= 0 || c[2] <= 0 || c[5] <= 0 || c[9] <= 0 || c[14] <= 0 ) ok = 0; | |
45 | return(ok); | |
46 | } | |
47 | ||
00d07bcd | 48 | |
f0bada7f | 49 | GPUdi() void AliHLTTPCCATrackletConstructor::StoreTracklet |
fbb9b71b | 50 | ( int /*nBlocks*/, int /*nThreads*/, int /*iBlock*/, int /*iThread*/, |
8566066c | 51 | AliHLTTPCCASharedMemory |
f0bada7f | 52 | #if defined(HLTCA_GPUCODE) | defined(EXTERN_ROW_HITS) |
8566066c | 53 | &s |
54 | #else | |
55 | &/*s*/ | |
31649d4b | 56 | #endif //!HLTCA_GPUCODE |
8566066c | 57 | , AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam ) |
fbb9b71b | 58 | { |
00d07bcd | 59 | // reconstruction of tracklets, tracklet store step |
fbb9b71b | 60 | |
fbb9b71b | 61 | do { |
b22af1bf | 62 | if ( r.fNHits < TRACKLET_SELECTOR_MIN_HITS ) { |
00d07bcd | 63 | r.fNHits = 0; |
64 | break; | |
65 | } | |
ce565086 | 66 | |
fbb9b71b | 67 | if ( 0 ) { |
68 | if ( 1. / .5 < CAMath::Abs( tParam.QPt() ) ) { //SG!!! | |
69 | r.fNHits = 0; | |
70 | break; | |
ce565086 | 71 | } |
72 | } | |
fbb9b71b | 73 | |
74 | { | |
e4818148 | 75 | bool ok = CheckCov(tParam); |
fbb9b71b | 76 | |
77 | if ( !ok ) { | |
78 | r.fNHits = 0; | |
79 | break; | |
00d07bcd | 80 | } |
fbb9b71b | 81 | } |
82 | } while ( 0 ); | |
83 | ||
84 | if ( !SAVE() ) return; | |
85 | ||
e4818148 | 86 | /*#ifndef HLTCA_GPUCODE |
87 | printf("Tracklet %d: Hits %3d NDF %3d Chi %8.4f Sign %f Cov: %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f\n", r.fItr, r.fNHits, tParam.GetNDF(), tParam.GetChi2(), tParam.GetSignCosPhi(), | |
88 | tParam.Cov()[0], tParam.Cov()[1], tParam.Cov()[2], tParam.Cov()[3], tParam.Cov()[4], tParam.Cov()[5], tParam.Cov()[6], tParam.Cov()[7], tParam.Cov()[8], tParam.Cov()[9], | |
89 | tParam.Cov()[10], tParam.Cov()[11], tParam.Cov()[12], tParam.Cov()[13], tParam.Cov()[14]); | |
90 | #endif*/ | |
91 | ||
ce565086 | 92 | AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr]; |
93 | ||
fbb9b71b | 94 | tracklet.SetNHits( r.fNHits ); |
95 | ||
96 | if ( r.fNHits > 0 ) { | |
91794c67 | 97 | if ( CAMath::Abs( tParam.Par()[4] ) < 1.e-4 ) tParam.SetPar( 4, 1.e-4 ); |
b22af1bf | 98 | if (r.fStartRow < r.fFirstRow) r.fFirstRow = r.fStartRow; |
99 | tracklet.SetFirstRow( r.fFirstRow ); | |
ce565086 | 100 | tracklet.SetLastRow( r.fLastRow ); |
444e5682 | 101 | #ifdef HLTCA_GPUCODE |
73a33d2e | 102 | tracklet.SetParam( tParam.fParam ); |
444e5682 | 103 | #else |
104 | tracklet.SetParam( tParam.GetParam() ); | |
31649d4b | 105 | #endif //HLTCA_GPUCODE |
6f0cdd46 | 106 | int w = tracker.CalculateHitWeight(r.fNHits, tParam.GetChi2(), r.fItr); |
107 | tracklet.SetHitWeight(w); | |
b22af1bf | 108 | for ( int iRow = r.fFirstRow; iRow <= r.fLastRow; iRow++ ) { |
109 | #ifdef EXTERN_ROW_HITS | |
110 | int ih = tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr]; | |
111 | #else | |
112 | int ih = tracklet.RowHit( iRow ); | |
31649d4b | 113 | #endif //EXTERN_ROW_HITS |
fbb9b71b | 114 | if ( ih >= 0 ) { |
1e63725a | 115 | #if defined(HLTCA_GPUCODE) |
f0bada7f | 116 | tracker.MaximizeHitWeight( s.fRows[ iRow ], ih, w ); |
b22af1bf | 117 | #else |
118 | tracker.MaximizeHitWeight( tracker.Row( iRow ), ih, w ); | |
1e63725a | 119 | #endif //HLTCA_GPUCODE |
00d07bcd | 120 | } |
121 | } | |
fbb9b71b | 122 | } |
b22af1bf | 123 | |
00d07bcd | 124 | } |
125 | ||
f0bada7f | 126 | GPUdi() void AliHLTTPCCATrackletConstructor::UpdateTracklet |
fbb9b71b | 127 | ( int /*nBlocks*/, int /*nThreads*/, int /*iBlock*/, int /*iThread*/, |
8566066c | 128 | AliHLTTPCCASharedMemory |
f0bada7f | 129 | #if defined(HLTCA_GPUCODE) | defined(EXTERN_ROW_HITS) |
8566066c | 130 | &s |
131 | #else | |
132 | &/*s*/ | |
31649d4b | 133 | #endif //HLTCA_GPUCODE |
8566066c | 134 | , AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam, int iRow ) |
fbb9b71b | 135 | { |
00d07bcd | 136 | // reconstruction of tracklets, tracklets update step |
137 | ||
fbb9b71b | 138 | if ( !r.fGo ) return; |
139 | ||
b22af1bf | 140 | #ifndef EXTERN_ROW_HITS |
ce565086 | 141 | AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr]; |
31649d4b | 142 | #endif //EXTERN_ROW_HITS |
ce565086 | 143 | |
1e63725a | 144 | #if defined(HLTCA_GPUCODE) |
b22af1bf | 145 | const AliHLTTPCCARow &row = s.fRows[iRow]; |
146 | #else | |
fbb9b71b | 147 | const AliHLTTPCCARow &row = tracker.Row( iRow ); |
1e63725a | 148 | #endif //HLTCA_GPUCODE |
fbb9b71b | 149 | |
150 | float y0 = row.Grid().YMin(); | |
151 | float stepY = row.HstepY(); | |
152 | float z0 = row.Grid().ZMin(); | |
153 | float stepZ = row.HstepZ(); | |
154 | float stepYi = row.HstepYi(); | |
155 | float stepZi = row.HstepZi(); | |
156 | ||
157 | if ( r.fStage == 0 ) { // fitting part | |
158 | do { | |
159 | ||
160 | if ( iRow < r.fStartRow || r.fCurrIH < 0 ) break; | |
b22af1bf | 161 | if ( ( iRow - r.fStartRow ) % 2 != 0 ) |
162 | { | |
163 | #ifndef EXTERN_ROW_HITS | |
164 | tracklet.SetRowHit(iRow, -1); | |
165 | #else | |
166 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1; | |
31649d4b | 167 | #endif //EXTERN_ROW_HITS |
b22af1bf | 168 | break; // SG!!! - jump over the row |
169 | } | |
170 | ||
f0bada7f | 171 | |
b22af1bf | 172 | ushort2 hh; |
b22af1bf | 173 | #if defined(HLTCA_GPU_TEXTURE_FETCH) |
8566066c | 174 | hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + r.fCurrIH); |
b22af1bf | 175 | #else |
176 | hh = tracker.HitData(row)[r.fCurrIH]; | |
31649d4b | 177 | #endif //HLTCA_GPU_TEXTURE_FETCH |
fbb9b71b | 178 | |
179 | int oldIH = r.fCurrIH; | |
b22af1bf | 180 | #if defined(HLTCA_GPU_TEXTURE_FETCH) |
8566066c | 181 | r.fCurrIH = tex1Dfetch(gAliTexRefs, ((char*) tracker.Data().HitLinkUpData(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + r.fCurrIH); |
b22af1bf | 182 | #else |
183 | r.fCurrIH = tracker.HitLinkUpData(row)[r.fCurrIH]; // read from linkup data | |
31649d4b | 184 | #endif //HLTCA_GPU_TEXTURE_FETCH |
fbb9b71b | 185 | |
186 | float x = row.X(); | |
187 | float y = y0 + hh.x * stepY; | |
188 | float z = z0 + hh.y * stepZ; | |
fbb9b71b | 189 | |
190 | if ( iRow == r.fStartRow ) { | |
191 | tParam.SetX( x ); | |
192 | tParam.SetY( y ); | |
193 | tParam.SetZ( z ); | |
194 | r.fLastY = y; | |
195 | r.fLastZ = z; | |
fbb9b71b | 196 | } else { |
197 | ||
198 | float err2Y, err2Z; | |
199 | float dx = x - tParam.X(); | |
200 | float dy = y - r.fLastY;//tParam.Y(); | |
201 | float dz = z - r.fLastZ;//tParam.Z(); | |
202 | r.fLastY = y; | |
203 | r.fLastZ = z; | |
204 | ||
205 | float ri = 1. / CAMath::Sqrt( dx * dx + dy * dy ); | |
5abba7a4 | 206 | if ( iRow == r.fStartRow + 2 ) { //SG!!! important - thanks to Matthias |
fbb9b71b | 207 | tParam.SetSinPhi( dy*ri ); |
208 | tParam.SetSignCosPhi( dx ); | |
209 | tParam.SetDzDs( dz*ri ); | |
4acc2401 | 210 | //std::cout << "Init. errors... " << r.fItr << std::endl; |
fbb9b71b | 211 | tracker.GetErrors2( iRow, tParam, err2Y, err2Z ); |
4acc2401 | 212 | //std::cout << "Init. errors = " << err2Y << " " << err2Z << std::endl; |
fbb9b71b | 213 | tParam.SetCov( 0, err2Y ); |
214 | tParam.SetCov( 2, err2Z ); | |
215 | } | |
fbb9b71b | 216 | float sinPhi, cosPhi; |
217 | if ( r.fNHits >= 10 && CAMath::Abs( tParam.SinPhi() ) < .99 ) { | |
218 | sinPhi = tParam.SinPhi(); | |
219 | cosPhi = CAMath::Sqrt( 1 - sinPhi * sinPhi ); | |
220 | } else { | |
221 | sinPhi = dy * ri; | |
222 | cosPhi = dx * ri; | |
223 | } | |
91794c67 | 224 | if ( !tParam.TransportToX( x, sinPhi, cosPhi, tracker.Param().ConstBz(), -1 ) ) { |
b22af1bf | 225 | #ifndef EXTERN_ROW_HITS |
226 | tracklet.SetRowHit( iRow, -1 ); | |
227 | #else | |
228 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1; | |
31649d4b | 229 | #endif //EXTERN_ROW_HITS |
fbb9b71b | 230 | break; |
231 | } | |
fbb9b71b | 232 | tracker.GetErrors2( iRow, tParam.GetZ(), sinPhi, cosPhi, tParam.GetDzDs(), err2Y, err2Z ); |
1e63725a | 233 | |
fbb9b71b | 234 | if ( !tParam.Filter( y, z, err2Y, err2Z, .99 ) ) { |
b22af1bf | 235 | #ifndef EXTERN_ROW_HITS |
236 | tracklet.SetRowHit( iRow, -1 ); | |
237 | #else | |
238 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1; | |
31649d4b | 239 | #endif //EXTERN_ROW_HITS |
fbb9b71b | 240 | break; |
241 | } | |
00d07bcd | 242 | } |
b22af1bf | 243 | #ifndef EXTERN_ROW_HITS |
244 | tracklet.SetRowHit( iRow, oldIH ); | |
245 | #else | |
246 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = oldIH; | |
31649d4b | 247 | #endif //!EXTERN_ROW_HITS |
00d07bcd | 248 | r.fNHits++; |
249 | r.fLastRow = iRow; | |
ce565086 | 250 | r.fEndRow = iRow; |
00d07bcd | 251 | break; |
fbb9b71b | 252 | } while ( 0 ); |
253 | ||
254 | if ( r.fCurrIH < 0 ) { | |
693d2443 | 255 | r.fStage = 1; |
fbb9b71b | 256 | if ( CAMath::Abs( tParam.SinPhi() ) > .999 ) { |
fbb9b71b | 257 | r.fNHits = 0; r.fGo = 0; |
258 | } else { | |
259 | //tParam.SetCosPhi( CAMath::Sqrt(1-tParam.SinPhi()*tParam.SinPhi()) ); | |
693d2443 | 260 | } |
fbb9b71b | 261 | } |
262 | } else { // forward/backward searching part | |
263 | do { | |
fbb9b71b | 264 | if ( r.fStage == 2 && ( ( iRow >= r.fEndRow ) || |
265 | ( iRow >= r.fStartRow && ( iRow - r.fStartRow ) % 2 == 0 ) | |
266 | ) ) break; | |
267 | if ( r.fNMissed > kMaxRowGap ) { | |
268 | break; | |
269 | } | |
270 | ||
271 | r.fNMissed++; | |
272 | ||
273 | float x = row.X(); | |
274 | float err2Y, err2Z; | |
91794c67 | 275 | if ( !tParam.TransportToX( x, tParam.SinPhi(), tParam.GetCosPhi(), tracker.Param().ConstBz(), .99 ) ) { |
b22af1bf | 276 | #ifndef EXTERN_ROW_HITS |
277 | tracklet.SetRowHit(iRow, -1); | |
278 | #else | |
279 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1; | |
31649d4b | 280 | #endif //!EXTERN_ROW_HITS |
fbb9b71b | 281 | break; |
282 | } | |
4acc2401 | 283 | if ( row.NHits() < 1 ) { |
284 | // skip empty row | |
b22af1bf | 285 | #ifndef EXTERN_ROW_HITS |
286 | tracklet.SetRowHit(iRow, -1); | |
287 | #else | |
288 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1; | |
31649d4b | 289 | #endif //!EXTERN_ROW_HITS |
4acc2401 | 290 | break; |
291 | } | |
1e63725a | 292 | |
b22af1bf | 293 | #ifndef HLTCA_GPU_TEXTURE_FETCH |
294 | const ushort2 *hits = tracker.HitData(row); | |
31649d4b | 295 | #endif //!HLTCA_GPU_TEXTURE_FETCH |
fbb9b71b | 296 | |
297 | float fY = tParam.GetY(); | |
298 | float fZ = tParam.GetZ(); | |
299 | int best = -1; | |
300 | ||
301 | { // search for the closest hit | |
4acc2401 | 302 | const int fIndYmin = row.Grid().GetBinBounded( fY - 1.f, fZ - 1.f ); |
303 | assert( fIndYmin >= 0 ); | |
fbb9b71b | 304 | |
305 | int ds; | |
306 | int fY0 = ( int ) ( ( fY - y0 ) * stepYi ); | |
307 | int fZ0 = ( int ) ( ( fZ - z0 ) * stepZi ); | |
308 | int ds0 = ( ( ( int )1 ) << 30 ); | |
309 | ds = ds0; | |
310 | ||
fbb9b71b | 311 | unsigned int fHitYfst = 1, fHitYlst = 0, fHitYfst1 = 1, fHitYlst1 = 0; |
312 | ||
fbb9b71b | 313 | { |
314 | int nY = row.Grid().Ny(); | |
315 | ||
b22af1bf | 316 | #ifndef HLTCA_GPU_TEXTURE_FETCH |
317 | const unsigned short *sGridP = tracker.FirstHitInBin(row); | |
31649d4b | 318 | #endif //!HLTCA_GPU_TEXTURE_FETCH |
b22af1bf | 319 | |
320 | #ifdef HLTCA_GPU_TEXTURE_FETCH | |
8566066c | 321 | fHitYfst = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin); |
322 | fHitYlst = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+2); | |
323 | fHitYfst1 = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+nY); | |
324 | fHitYlst1 = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+nY+2); | |
b22af1bf | 325 | #else |
fbb9b71b | 326 | fHitYfst = sGridP[fIndYmin]; |
327 | fHitYlst = sGridP[fIndYmin+2]; | |
328 | fHitYfst1 = sGridP[fIndYmin+nY]; | |
329 | fHitYlst1 = sGridP[fIndYmin+nY+2]; | |
31649d4b | 330 | #endif //HLTCA_GPU_TEXTURE_FETCH |
b22af1bf | 331 | assert( (signed) fHitYfst <= row.NHits() ); |
332 | assert( (signed) fHitYlst <= row.NHits() ); | |
333 | assert( (signed) fHitYfst1 <= row.NHits() ); | |
334 | assert( (signed) fHitYlst1 <= row.NHits() ); | |
fbb9b71b | 335 | } |
1e63725a | 336 | |
337 | for ( unsigned int fIh = fHitYfst; fIh < fHitYlst; fIh++ ) { | |
b22af1bf | 338 | assert( (signed) fIh < row.NHits() ); |
339 | ushort2 hh; | |
e4818148 | 340 | if (r.fStage <= 2 || tracker.HitWeight(row, fIh) >= 0) |
341 | { | |
342 | ||
b22af1bf | 343 | #if defined(HLTCA_GPU_TEXTURE_FETCH) |
e4818148 | 344 | hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + fIh); |
b22af1bf | 345 | #else |
e4818148 | 346 | hh = hits[fIh]; |
31649d4b | 347 | #endif //HLTCA_GPU_TEXTURE_FETCH |
e4818148 | 348 | int ddy = ( int )( hh.x ) - fY0; |
349 | int ddz = ( int )( hh.y ) - fZ0; | |
350 | int dds = CAMath::Abs( ddy ) + CAMath::Abs( ddz ); | |
351 | if ( dds < ds ) { | |
352 | ds = dds; | |
353 | best = fIh; | |
354 | } | |
fbb9b71b | 355 | } |
356 | } | |
357 | ||
b22af1bf | 358 | for ( unsigned int fIh = fHitYfst1; fIh < fHitYlst1; fIh++ ) { |
359 | ushort2 hh; | |
360 | #if defined(HLTCA_GPU_TEXTURE_FETCH) | |
8566066c | 361 | hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + fIh); |
b22af1bf | 362 | #else |
363 | hh = hits[fIh]; | |
31649d4b | 364 | #endif //HLTCA_GPU_TEXTURE_FETCH |
fbb9b71b | 365 | int ddy = ( int )( hh.x ) - fY0; |
366 | int ddz = ( int )( hh.y ) - fZ0; | |
367 | int dds = CAMath::Abs( ddy ) + CAMath::Abs( ddz ); | |
fbb9b71b | 368 | if ( dds < ds ) { |
369 | ds = dds; | |
370 | best = fIh; | |
371 | } | |
372 | } | |
373 | }// end of search for the closest hit | |
374 | ||
b22af1bf | 375 | if ( best < 0 ) |
376 | { | |
377 | #ifndef EXTERN_ROW_HITS | |
378 | tracklet.SetRowHit(iRow, -1); | |
379 | #else | |
380 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1; | |
31649d4b | 381 | #endif //!EXTERN_ROW_HITS |
b22af1bf | 382 | break; |
383 | } | |
fbb9b71b | 384 | |
b22af1bf | 385 | ushort2 hh; |
386 | #if defined(HLTCA_GPU_TEXTURE_FETCH) | |
8566066c | 387 | hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + best); |
b22af1bf | 388 | #else |
389 | hh = hits[best]; | |
31649d4b | 390 | #endif //HLTCA_GPU_TEXTURE_FETCH |
fbb9b71b | 391 | |
fbb9b71b | 392 | tracker.GetErrors2( iRow, *( ( AliHLTTPCCATrackParam* )&tParam ), err2Y, err2Z ); |
fbb9b71b | 393 | |
394 | float y = y0 + hh.x * stepY; | |
395 | float z = z0 + hh.y * stepZ; | |
396 | float dy = y - fY; | |
397 | float dz = z - fZ; | |
398 | ||
399 | const float kFactor = tracker.Param().HitPickUpFactor() * tracker.Param().HitPickUpFactor() * 3.5 * 3.5; | |
400 | float sy2 = kFactor * ( tParam.GetErr2Y() + err2Y ); | |
401 | float sz2 = kFactor * ( tParam.GetErr2Z() + err2Z ); | |
402 | if ( sy2 > 2. ) sy2 = 2.; | |
403 | if ( sz2 > 2. ) sz2 = 2.; | |
404 | ||
fbb9b71b | 405 | if ( CAMath::FMulRZ( dy, dy ) > sy2 || CAMath::FMulRZ( dz, dz ) > sz2 ) { |
b22af1bf | 406 | #ifndef EXTERN_ROW_HITS |
407 | tracklet.SetRowHit(iRow, -1); | |
408 | #else | |
409 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1; | |
31649d4b | 410 | #endif //!EXTERN_ROW_HITS |
fbb9b71b | 411 | break; |
412 | } | |
e4818148 | 413 | #ifdef GLOBAL_TRACKING_EXTRAPOLATE_ONLY |
414 | if ( r.fStage <= 2) | |
415 | #endif | |
416 | if (!tParam.Filter( y, z, err2Y, err2Z, .99 ) ) { | |
417 | break; | |
418 | } | |
b22af1bf | 419 | #ifndef EXTERN_ROW_HITS |
420 | tracklet.SetRowHit( iRow, best ); | |
421 | #else | |
422 | tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = best; | |
31649d4b | 423 | #endif //!EXTERN_ROW_HITS |
fbb9b71b | 424 | r.fNHits++; |
425 | r.fNMissed = 0; | |
426 | if ( r.fStage == 1 ) r.fLastRow = iRow; | |
427 | else r.fFirstRow = iRow; | |
428 | } while ( 0 ); | |
429 | } | |
00d07bcd | 430 | } |
431 | ||
b22af1bf | 432 | #ifdef HLTCA_GPUCODE |
b22af1bf | 433 | |
2fba026d | 434 | #include "AliHLTTPCCATrackletConstructorGPU.h" |
b22af1bf | 435 | |
31649d4b | 436 | #else //HLTCA_GPUCODE |
437 | ||
f0bada7f | 438 | GPUdi() void AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorCPU(AliHLTTPCCATracker &tracker) |
b22af1bf | 439 | { |
440 | //Tracklet constructor simple CPU Function that does not neew a scheduler | |
441 | GPUshared() AliHLTTPCCASharedMemory sMem; | |
442 | sMem.fNTracklets = *tracker.NTracklets(); | |
443 | for (int iTracklet = 0;iTracklet < *tracker.NTracklets();iTracklet++) | |
444 | { | |
445 | AliHLTTPCCATrackParam tParam; | |
446 | AliHLTTPCCAThreadMemory rMem; | |
447 | ||
448 | AliHLTTPCCAHitId id = tracker.TrackletStartHits()[iTracklet]; | |
449 | ||
450 | rMem.fStartRow = rMem.fEndRow = rMem.fFirstRow = rMem.fLastRow = id.RowIndex(); | |
451 | rMem.fCurrIH = id.HitIndex(); | |
452 | rMem.fStage = 0; | |
453 | rMem.fNHits = 0; | |
454 | rMem.fNMissed = 0; | |
455 | ||
456 | AliHLTTPCCATrackletConstructor::InitTracklet(tParam); | |
457 | ||
458 | rMem.fItr = iTracklet; | |
459 | rMem.fGo = 1; | |
460 | ||
8566066c | 461 | for (int j = rMem.fStartRow;j < tracker.Param().NRows();j++) |
462 | { | |
463 | UpdateTracklet(1, 1, 0, iTracklet, sMem, rMem, tracker, tParam, j); | |
464 | if (!rMem.fGo) break; | |
465 | } | |
466 | ||
467 | rMem.fNMissed = 0; | |
468 | rMem.fStage = 2; | |
469 | if ( rMem.fGo ) | |
470 | { | |
471 | if ( !tParam.TransportToX( tracker.Row( rMem.fEndRow ).X(), tracker.Param().ConstBz(), .999 ) ) rMem.fGo = 0; | |
472 | } | |
473 | ||
474 | for (int j = rMem.fEndRow;j >= 0;j--) | |
475 | { | |
476 | if (!rMem.fGo) break; | |
477 | UpdateTracklet( 1, 1, 0, iTracklet, sMem, rMem, tracker, tParam, j); | |
478 | } | |
479 | ||
b22af1bf | 480 | StoreTracklet( 1, 1, 0, iTracklet, sMem, rMem, tracker, tParam ); |
481 | } | |
482 | } | |
e4818148 | 483 | |
484 | GPUdi() int AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorGlobalTracking(AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam& tParam, int row, int increment) | |
485 | { | |
486 | AliHLTTPCCAThreadMemory rMem; | |
487 | GPUshared() AliHLTTPCCASharedMemory sMem; | |
488 | sMem.fNTracklets = *tracker.NTracklets(); | |
489 | rMem.fItr = 0; | |
490 | rMem.fStage = 3; | |
491 | rMem.fNHits = rMem.fNMissed = 0; | |
492 | rMem.fGo = 1; | |
493 | while (rMem.fGo && row >= 0 && row < tracker.Param().NRows()) | |
494 | { | |
495 | UpdateTracklet(1, 1, 0, 0, sMem, rMem, tracker, tParam, row); | |
496 | row += increment; | |
497 | } | |
498 | if (!CheckCov(tParam)) rMem.fNHits = 0; | |
499 | return(rMem.fNHits); | |
500 | } | |
501 | ||
31649d4b | 502 | #endif //HLTCA_GPUCODE |