]>
Commit | Line | Data |
---|---|---|
326c2d4b | 1 | // @(#) $Id$ |
ce565086 | 2 | // ************************************************************************** |
fbb9b71b | 3 | // This file is property of and copyright by the ALICE HLT Project * |
d54804bf | 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 | // * |
d54804bf | 18 | //*************************************************************************** |
326c2d4b | 19 | |
20 | #include "AliHLTTPCCATracker.h" | |
326c2d4b | 21 | #include "AliHLTTPCCAOutTrack.h" |
d54804bf | 22 | #include "AliHLTTPCCAGrid.h" |
23 | #include "AliHLTTPCCARow.h" | |
24 | #include "AliHLTTPCCATrack.h" | |
4687b8fc | 25 | #include "AliHLTTPCCATracklet.h" |
00d07bcd | 26 | #include "AliHLTTPCCAMath.h" |
27 | #include "AliHLTTPCCAHit.h" | |
4acc2401 | 28 | #include "MemoryAssignmentHelpers.h" |
326c2d4b | 29 | |
dc4788ec | 30 | #include "TStopwatch.h" |
00d07bcd | 31 | #include "AliHLTTPCCAHitArea.h" |
32 | #include "AliHLTTPCCANeighboursFinder.h" | |
33 | #include "AliHLTTPCCANeighboursCleaner.h" | |
34 | #include "AliHLTTPCCAStartHitsFinder.h" | |
35 | #include "AliHLTTPCCATrackletConstructor.h" | |
36 | #include "AliHLTTPCCATrackletSelector.h" | |
37 | #include "AliHLTTPCCAProcess.h" | |
63d8b79d | 38 | #include "AliHLTTPCCASliceTrack.h" |
39 | #include "AliHLTTPCCASliceOutput.h" | |
40 | #include "AliHLTTPCCADataCompressor.h" | |
4acc2401 | 41 | #include "AliHLTTPCCAClusterData.h" |
00d07bcd | 42 | |
43 | #include "AliHLTTPCCATrackParam.h" | |
00d07bcd | 44 | |
b22af1bf | 45 | #include "AliHLTTPCCAGPUConfig.h" |
46 | #include "AliHLTTPCCAGPUTracker.h" | |
47 | ||
00d07bcd | 48 | #if !defined(HLTCA_GPUCODE) |
4687b8fc | 49 | #include <iostream> |
b22af1bf | 50 | #include <string.h> |
00d07bcd | 51 | #endif |
d54804bf | 52 | |
6de2bc40 | 53 | //#define DRAW1 |
326c2d4b | 54 | |
6de2bc40 | 55 | #ifdef DRAW1 |
fbb9b71b | 56 | #include "AliHLTTPCCADisplay.h" |
326c2d4b | 57 | #endif //DRAW |
58 | ||
ce565086 | 59 | #ifdef HLTCA_INTERNAL_PERFORMANCE |
fbb9b71b | 60 | #include "AliHLTTPCCAPerformance.h" |
ce565086 | 61 | #endif |
62 | ||
b22af1bf | 63 | #ifdef HLTCA_STANDALONE |
64 | #include "AliHLTTPCCAStandaloneFramework.h" | |
65 | #endif | |
ce565086 | 66 | |
fbb9b71b | 67 | ClassImp( AliHLTTPCCATracker ) |
326c2d4b | 68 | |
b22af1bf | 69 | |
70 | #if !defined(HLTCA_GPUCODE) | |
71 | ||
72 | AliHLTTPCCATracker::~AliHLTTPCCATracker() | |
326c2d4b | 73 | { |
74 | // destructor | |
7be9b0d7 | 75 | if (!fIsGPUTracker) |
76 | { | |
b22af1bf | 77 | if (fCommonMem) delete fCommonMem; |
78 | if (fHitMemory) delete[] fHitMemory; | |
79 | if (fTrackletMemory) delete[] fTrackletMemory; | |
80 | if (fTrackMemory) delete[] fTrackMemory; | |
81 | fCommonMem = NULL; | |
82 | fHitMemory = fTrackMemory = NULL; | |
7be9b0d7 | 83 | } |
326c2d4b | 84 | } |
00d07bcd | 85 | |
326c2d4b | 86 | // ---------------------------------------------------------------------------------- |
7be9b0d7 | 87 | void AliHLTTPCCATracker::Initialize( const AliHLTTPCCAParam ¶m ) |
326c2d4b | 88 | { |
75192f26 | 89 | // initialisation |
00d07bcd | 90 | fParam = param; |
4687b8fc | 91 | fParam.Update(); |
4acc2401 | 92 | fData.InitializeRows( fParam ); |
93 | ||
326c2d4b | 94 | StartEvent(); |
95 | } | |
96 | ||
7be9b0d7 | 97 | void AliHLTTPCCATracker::StartEvent() |
326c2d4b | 98 | { |
fbb9b71b | 99 | // start new event and fresh the memory |
d54804bf | 100 | |
4acc2401 | 101 | SetupCommonMemory(); |
4acc2401 | 102 | } |
103 | ||
7be9b0d7 | 104 | void AliHLTTPCCATracker::SetGPUTracker() |
105 | { | |
106 | fIsGPUTracker = true; | |
b22af1bf | 107 | fData.SetGpuSliceData(); |
7be9b0d7 | 108 | } |
109 | ||
110 | char* AliHLTTPCCATracker::SetGPUTrackerCommonMemory(char* pGPUMemory) | |
111 | { | |
b22af1bf | 112 | fCommonMem = (commonMemoryStruct*) pGPUMemory; |
113 | return(pGPUMemory + sizeof(commonMemoryStruct)); | |
7be9b0d7 | 114 | } |
115 | ||
116 | ||
b22af1bf | 117 | char* AliHLTTPCCATracker::SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits) |
7be9b0d7 | 118 | { |
119 | fHitMemory = (char*) pGPUMemory; | |
120 | SetPointersHits(MaxNHits); | |
b22af1bf | 121 | pGPUMemory += fHitMemorySize; |
122 | AssignMemory(fTrackletTmpStartHits, pGPUMemory, NHitsTotal()); | |
123 | AssignMemory(fRowStartHitCountOffset, pGPUMemory, Param().NRows()); | |
124 | ||
125 | return(pGPUMemory); | |
7be9b0d7 | 126 | } |
127 | ||
b22af1bf | 128 | char* AliHLTTPCCATracker::SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracks) |
129 | { | |
130 | fTrackletMemory = (char*) pGPUMemory; | |
131 | SetPointersTracklets(MaxNTracks); | |
132 | pGPUMemory += fTrackletMemorySize; | |
133 | AssignMemory(fGPUTrackletTemp, pGPUMemory, MaxNTracks); | |
134 | AssignMemory(fRowBlockTracklets, pGPUMemory, MaxNTracks * 2 * (Param().NRows() / HLTCA_GPU_SCHED_ROW_STEP + 1)); | |
135 | AssignMemory(fRowBlockPos, pGPUMemory, 2 * (Param().NRows() / HLTCA_GPU_SCHED_ROW_STEP + 1)); | |
136 | AssignMemory(fBlockStartingTracklet, pGPUMemory, HLTCA_GPU_BLOCK_COUNT); | |
137 | ||
138 | return(pGPUMemory); | |
139 | } | |
7be9b0d7 | 140 | |
141 | char* AliHLTTPCCATracker::SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTracks, int MaxNHits ) | |
142 | { | |
143 | fTrackMemory = (char*) pGPUMemory; | |
144 | SetPointersTracks(MaxNTracks, MaxNHits); | |
b22af1bf | 145 | pGPUMemory += fTrackMemorySize; |
146 | ||
147 | return(pGPUMemory); | |
7be9b0d7 | 148 | } |
149 | ||
b22af1bf | 150 | void AliHLTTPCCATracker::DumpSliceData(std::ostream &out) |
7be9b0d7 | 151 | { |
b22af1bf | 152 | out << "Slice Data:" << endl; |
7be9b0d7 | 153 | for (int i = 0;i < Param().NRows();i++) |
154 | { | |
155 | out << "Row: " << i << endl; | |
156 | for (int j = 0;j < Row(i).NHits();j++) | |
157 | { | |
b22af1bf | 158 | if (j && j % 16 == 0) out << std::endl; |
159 | out << j << '-' << Data().HitDataY(Row(i), j) << '-' << Data().HitDataZ(Row(i), j) << ", "; | |
7be9b0d7 | 160 | } |
161 | out << endl; | |
162 | } | |
163 | } | |
164 | ||
b22af1bf | 165 | void AliHLTTPCCATracker::DumpLinks(std::ostream &out) |
7be9b0d7 | 166 | { |
b22af1bf | 167 | out << "Hit Links:" << endl; |
168 | for (int i = 0;i < Param().NRows();i++) | |
7be9b0d7 | 169 | { |
b22af1bf | 170 | out << "Row: " << i << endl; |
171 | for (int j = 0;j < Row(i).NHits();j++) | |
7be9b0d7 | 172 | { |
b22af1bf | 173 | if (j && j % 32 == 0) out << endl; |
174 | out << HitLinkUpData(Row(i), j) << "/" << HitLinkDownData(Row(i), j) << ", "; | |
7be9b0d7 | 175 | } |
b22af1bf | 176 | out << endl; |
7be9b0d7 | 177 | } |
7be9b0d7 | 178 | } |
179 | ||
b22af1bf | 180 | void AliHLTTPCCATracker::DumpHitWeights(std::ostream &out) |
7be9b0d7 | 181 | { |
b22af1bf | 182 | out << "Hit Weights:" << endl; |
183 | for (int i = 0;i < Param().NRows();i++) | |
184 | { | |
185 | out << "Row: " << i << ":" << endl; | |
186 | for (int j = 0;j < Row(i).NHits();j++) | |
7be9b0d7 | 187 | { |
b22af1bf | 188 | if (j && j % 32 == 0) out << endl; |
189 | out << HitWeight(Row(i), j) << ", "; | |
7be9b0d7 | 190 | } |
b22af1bf | 191 | out << endl; |
192 | } | |
193 | } | |
194 | ||
195 | int AliHLTTPCCATracker::starthitSortComparison(const void*a, const void* b) | |
196 | { | |
197 | AliHLTTPCCAHitId* aa = (AliHLTTPCCAHitId*) a; | |
198 | AliHLTTPCCAHitId* bb = (AliHLTTPCCAHitId*) b; | |
199 | ||
200 | if (aa->RowIndex() != bb->RowIndex()) return(aa->RowIndex() - bb->RowIndex()); | |
201 | return(aa->HitIndex() - bb->HitIndex()); | |
7be9b0d7 | 202 | } |
203 | ||
b22af1bf | 204 | void AliHLTTPCCATracker::DumpStartHits(std::ostream &out) |
7be9b0d7 | 205 | { |
b22af1bf | 206 | out << "Start Hits: (" << *NTracklets() << ")" << endl; |
207 | #ifdef HLTCA_GPU_SORT_DUMPDATA | |
208 | qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), starthitSortComparison); | |
209 | #endif | |
210 | for (int i = 0;i < *NTracklets();i++) | |
7be9b0d7 | 211 | { |
b22af1bf | 212 | out << TrackletStartHit(i).RowIndex() << "-" << TrackletStartHit(i).HitIndex() << endl; |
7be9b0d7 | 213 | } |
b22af1bf | 214 | out << endl; |
215 | } | |
216 | ||
217 | void AliHLTTPCCATracker::DumpTrackHits(std::ostream &out) | |
218 | { | |
219 | out << "Tracks: (" << *NTracks() << ")" << endl; | |
220 | #ifdef HLTCA_GPU_SORT_DUMPDATA | |
221 | for (int k = 0;k < Param().NRows();k++) | |
7be9b0d7 | 222 | { |
b22af1bf | 223 | for (int l = 0;l < Row(k).NHits();l++) |
7be9b0d7 | 224 | { |
b22af1bf | 225 | #endif |
226 | for (int j = 0;j < *NTracks();j++) | |
227 | { | |
228 | if (Tracks()[j].NHits() == 0 || !Tracks()[j].Alive()) continue; | |
229 | #ifdef HLTCA_GPU_SORT_DUMPDATA | |
230 | if (TrackHits()[Tracks()[j].FirstHitID()].RowIndex() == k && TrackHits()[Tracks()[j].FirstHitID()].HitIndex() == l) | |
231 | { | |
232 | #endif | |
233 | for (int i = 0;i < Tracks()[j].NHits();i++) | |
234 | { | |
235 | out << TrackHits()[Tracks()[j].FirstHitID() + i].RowIndex() << "-" << TrackHits()[Tracks()[j].FirstHitID() + i].HitIndex() << ", "; | |
236 | } | |
237 | out << "(Track: " << j << ")" << endl; | |
238 | #ifdef HLTCA_GPU_SORT_DUMPDATA | |
239 | } | |
240 | } | |
241 | #endif | |
242 | } | |
243 | #ifdef HLTCA_GPU_SORT_DUMPDATA | |
7be9b0d7 | 244 | } |
b22af1bf | 245 | #endif |
7be9b0d7 | 246 | } |
247 | ||
248 | void AliHLTTPCCATracker::DumpTrackletHits(std::ostream &out) | |
249 | { | |
b22af1bf | 250 | out << "Tracklets: (" << *NTracklets() << ")" << endl; |
251 | #ifdef HLTCA_GPU_SORT_DUMPDATA | |
252 | AliHLTTPCCAHitId* tmpIds = new AliHLTTPCCAHitId[*NTracklets()]; | |
253 | AliHLTTPCCATracklet* tmpTracklets = new AliHLTTPCCATracklet[*NTracklets()]; | |
254 | memcpy(tmpIds, TrackletStartHits(), *NTracklets() * sizeof(AliHLTTPCCAHitId)); | |
255 | memcpy(tmpTracklets, Tracklets(), *NTracklets() * sizeof(AliHLTTPCCATracklet)); | |
256 | #ifdef EXTERN_ROW_HITS | |
257 | int* tmpHits = new int[*NTracklets() * Param().NRows()]; | |
258 | memcpy(tmpHits, TrackletRowHits(), *NTracklets() * Param().NRows() * sizeof(int)); | |
259 | #endif | |
260 | qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), starthitSortComparison); | |
261 | for (int i = 0;i < *NTracklets();i++) | |
7be9b0d7 | 262 | { |
263 | for (int j = 0;j < *NTracklets();j++) | |
264 | { | |
b22af1bf | 265 | if (tmpIds[i].RowIndex() == TrackletStartHit(j).RowIndex() && tmpIds[i].HitIndex() == TrackletStartHit(j).HitIndex()) |
7be9b0d7 | 266 | { |
b22af1bf | 267 | memcpy(&Tracklets()[j], &tmpTracklets[i], sizeof(AliHLTTPCCATracklet)); |
268 | #ifdef EXTERN_ROW_HITS | |
269 | if (tmpTracklets[i].NHits()) | |
7be9b0d7 | 270 | { |
b22af1bf | 271 | for (int k = tmpTracklets[i].FirstRow();k <= tmpTracklets[i].LastRow();k++) |
272 | { | |
273 | fTrackletRowHits[k * *NTracklets() + j] = tmpHits[k * *NTracklets() + i]; | |
274 | } | |
7be9b0d7 | 275 | } |
b22af1bf | 276 | #endif |
277 | break; | |
278 | } | |
279 | } | |
280 | } | |
281 | delete[] tmpIds; | |
282 | delete[] tmpTracklets; | |
283 | #ifdef EXTERN_ROW_HITS | |
284 | delete[] tmpHits; | |
285 | #endif | |
286 | #endif | |
287 | for (int j = 0;j < *NTracklets();j++) | |
288 | { | |
289 | out << "Tracklet " << j << " (Hits: " << setw(3) << Tracklets()[j].NHits() << ", Start: " << setw(3) << TrackletStartHit(j).RowIndex() << "-" << setw(3) << TrackletStartHit(j).HitIndex() << ") "; | |
290 | if (Tracklets()[j].NHits() == 0); | |
291 | else if (Tracklets()[j].LastRow() > Tracklets()[j].FirstRow() && (Tracklets()[j].FirstRow() >= Param().NRows() || Tracklets()[j].LastRow() >= Param().NRows())) | |
292 | { | |
293 | #ifdef HLTCA_STANDALONE | |
294 | printf("\nError: First %d Last %d Num %d", Tracklets()[j].FirstRow(), Tracklets()[j].LastRow(), Tracklets()[j].NHits()); | |
295 | #endif | |
296 | } | |
297 | else if (Tracklets()[j].NHits() && Tracklets()[j].LastRow() > Tracklets()[j].FirstRow()) | |
298 | { | |
299 | for (int i = Tracklets()[j].FirstRow();i <= Tracklets()[j].LastRow();i++) | |
300 | { | |
301 | //if (Tracklets()[j].RowHit(i) != -1) | |
302 | #ifdef EXTERN_ROW_HITS | |
303 | out << i << "-" << fTrackletRowHits[i * fCommonMem->fNTracklets + j] << ", "; | |
304 | #else | |
305 | out << i << "-" << Tracklets()[j].RowHit(i) << ", "; | |
306 | #endif | |
7be9b0d7 | 307 | } |
308 | } | |
b22af1bf | 309 | out << endl; |
7be9b0d7 | 310 | } |
311 | } | |
312 | ||
313 | ||
b22af1bf | 314 | void AliHLTTPCCATracker::SetupCommonMemory() |
4acc2401 | 315 | { |
6de2bc40 | 316 | // set up common memory |
317 | ||
7be9b0d7 | 318 | if (!fIsGPUTracker) |
319 | { | |
b22af1bf | 320 | if ( !fCommonMem ) { |
7be9b0d7 | 321 | // the 1600 extra bytes are not used unless fCommonMemorySize increases with a later event |
b22af1bf | 322 | //fCommonMemory = reinterpret_cast<char*> ( new uint4 [ fCommonMemorySize/sizeof( uint4 ) + 100] ); |
323 | fCommonMem = new commonMemoryStruct; | |
7be9b0d7 | 324 | } |
fbb9b71b | 325 | |
b22af1bf | 326 | if (fHitMemory) delete[] fHitMemory; |
327 | if (fTrackletMemory) delete[] fTrackletMemory; | |
328 | if (fTrackMemory) delete[] fTrackMemory; | |
7be9b0d7 | 329 | } |
c259f7e4 | 330 | |
b22af1bf | 331 | fHitMemory = fTrackletMemory = fTrackMemory = 0; |
332 | ||
4acc2401 | 333 | fData.Clear(); |
b22af1bf | 334 | fCommonMem->fNTracklets = 0; |
335 | fCommonMem->fNTracks = 0 ; | |
336 | fCommonMem->fNTrackHits = 0; | |
326c2d4b | 337 | } |
338 | ||
7be9b0d7 | 339 | void AliHLTTPCCATracker::ReadEvent( AliHLTTPCCAClusterData *clusterData ) |
340 | { | |
341 | // read event | |
342 | ||
343 | fClusterData = clusterData; | |
344 | ||
345 | StartEvent(); | |
346 | ||
347 | //* Convert input hits, create grids, etc. | |
348 | fData.InitFromClusterData( *clusterData ); | |
7be9b0d7 | 349 | { |
b22af1bf | 350 | if (!fIsGPUTracker) |
351 | { | |
352 | SetPointersHits( fData.NumberOfHits() ); // to calculate the size | |
353 | fHitMemory = reinterpret_cast<char*> ( new uint4 [ fHitMemorySize/sizeof( uint4 ) + 100] ); | |
354 | } | |
7be9b0d7 | 355 | SetPointersHits( fData.NumberOfHits() ); // set pointers for hits |
7be9b0d7 | 356 | } |
357 | } | |
358 | ||
fbb9b71b | 359 | GPUhd() void AliHLTTPCCATracker::SetPointersHits( int MaxNHits ) |
c259f7e4 | 360 | { |
361 | // set all pointers to the event memory | |
362 | ||
4acc2401 | 363 | char *mem = fHitMemory; |
c259f7e4 | 364 | |
365 | // extra arrays for tpc clusters | |
c259f7e4 | 366 | |
b22af1bf | 367 | #ifdef HLTCA_GPU_SORT_STARTHITS_2 |
368 | AssignMemory( fTrackletStartHits, mem, MaxNHits + 32); | |
369 | #else | |
370 | AssignMemory( fTrackletStartHits, mem, MaxNHits); | |
371 | #endif | |
372 | ||
373 | // calculate the size | |
c259f7e4 | 374 | |
b22af1bf | 375 | fHitMemorySize = mem - fHitMemory; |
376 | } | |
c259f7e4 | 377 | |
b22af1bf | 378 | GPUhd() void AliHLTTPCCATracker::SetPointersTracklets( int MaxNTracklets ) |
379 | { | |
380 | // set all pointers to the tracklets memory | |
381 | char *mem = fTrackletMemory; | |
fbb9b71b | 382 | |
b22af1bf | 383 | // memory for tracklets |
c259f7e4 | 384 | |
b22af1bf | 385 | AssignMemory( fTracklets, mem, MaxNTracklets ); |
386 | #ifdef EXTERN_ROW_HITS | |
387 | AssignMemory( fTrackletRowHits, mem, MaxNTracklets * Param().NRows()); | |
388 | #endif | |
c259f7e4 | 389 | |
b22af1bf | 390 | fTrackletMemorySize = mem - fTrackletMemory; |
c259f7e4 | 391 | } |
392 | ||
393 | ||
fbb9b71b | 394 | GPUhd() void AliHLTTPCCATracker::SetPointersTracks( int MaxNTracks, int MaxNHits ) |
c259f7e4 | 395 | { |
396 | // set all pointers to the tracks memory | |
4acc2401 | 397 | char *mem = fTrackMemory; |
fbb9b71b | 398 | |
c259f7e4 | 399 | // memory for selected tracks |
fbb9b71b | 400 | |
4acc2401 | 401 | AssignMemory( fTracks, mem, MaxNTracks ); |
b22af1bf | 402 | AssignMemory( fTrackHits, mem, 2 * MaxNHits ); |
c259f7e4 | 403 | |
404 | // calculate the size | |
405 | ||
4acc2401 | 406 | fTrackMemorySize = mem - fTrackMemory; |
c259f7e4 | 407 | } |
408 | ||
7be9b0d7 | 409 | GPUh() int AliHLTTPCCATracker::CheckEmptySlice() |
410 | { | |
411 | if ( NHitsTotal() < 1 ) { | |
412 | { | |
413 | SetPointersTracks( 1, 1 ); // to calculate the size | |
414 | fTrackMemory = reinterpret_cast<char*> ( new uint4 [ fTrackMemorySize/sizeof( uint4 ) + 100] ); | |
415 | SetPointersTracks( 1, 1 ); // set pointers for tracks | |
416 | fOutput->SetNTracks( 0 ); | |
417 | fOutput->SetNTrackClusters( 0 ); | |
418 | } | |
326c2d4b | 419 | |
7be9b0d7 | 420 | return 1; |
421 | } | |
422 | return 0; | |
423 | } | |
424 | ||
425 | void AliHLTTPCCATracker::RunNeighboursFinder() | |
326c2d4b | 426 | { |
7be9b0d7 | 427 | AliHLTTPCCAProcess<AliHLTTPCCANeighboursFinder>( Param().NRows(), 1, *this ); |
428 | } | |
6de2bc40 | 429 | |
7be9b0d7 | 430 | void AliHLTTPCCATracker::RunNeighboursCleaner() |
431 | { | |
432 | AliHLTTPCCAProcess<AliHLTTPCCANeighboursCleaner>( Param().NRows() - 2, 1, *this ); | |
433 | } | |
d54804bf | 434 | |
7be9b0d7 | 435 | void AliHLTTPCCATracker::RunStartHitsFinder() |
436 | { | |
437 | AliHLTTPCCAProcess<AliHLTTPCCAStartHitsFinder>( Param().NRows() - 4, 1, *this ); | |
438 | } | |
fbb9b71b | 439 | |
7be9b0d7 | 440 | void AliHLTTPCCATracker::RunTrackletConstructor() |
441 | { | |
b22af1bf | 442 | AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorNewCPU(*this); |
7be9b0d7 | 443 | } |
fbb9b71b | 444 | |
7be9b0d7 | 445 | void AliHLTTPCCATracker::RunTrackletSelector() |
446 | { | |
b22af1bf | 447 | AliHLTTPCCAProcess<AliHLTTPCCATrackletSelector>( 1, fCommonMem->fNTracklets, *this ); |
d54804bf | 448 | } |
449 | ||
b22af1bf | 450 | #ifdef HLTCA_STANDALONE |
451 | void AliHLTTPCCATracker::StandalonePerfTime(int i) | |
452 | { | |
453 | if (fGPUDebugLevel >= 1) | |
454 | { | |
455 | AliHLTTPCCAStandaloneFramework::StandaloneQueryTime(&fPerfTimers[i]); | |
456 | } | |
457 | } | |
458 | #else | |
459 | void AliHLTTPCCATracker::StandalonePerfTime(int /*i*/) {} | |
460 | #endif | |
461 | ||
00d07bcd | 462 | GPUh() void AliHLTTPCCATracker::Reconstruct() |
463 | { | |
464 | //* reconstruction of event | |
4acc2401 | 465 | //std::cout<<"Reconstruct slice "<<fParam.ISlice()<<", nHits="<<NHitsTotal()<<std::endl; |
326c2d4b | 466 | |
00d07bcd | 467 | fTimers[0] = 0; // find neighbours |
468 | fTimers[1] = 0; // construct tracklets | |
469 | fTimers[2] = 0; // fit tracklets | |
470 | fTimers[3] = 0; // prolongation of tracklets | |
471 | fTimers[4] = 0; // selection | |
472 | fTimers[5] = 0; // write output | |
473 | fTimers[6] = 0; | |
474 | fTimers[7] = 0; | |
fbb9b71b | 475 | |
693d2443 | 476 | //if( fParam.ISlice()<1 ) return; //SG!!! |
00d07bcd | 477 | |
00d07bcd | 478 | TStopwatch timer0; |
b22af1bf | 479 | |
480 | StandalonePerfTime(0); | |
481 | ||
482 | fOutput->Clear(); | |
483 | ||
7be9b0d7 | 484 | if (CheckEmptySlice()) return; |
4687b8fc | 485 | |
6de2bc40 | 486 | #ifdef DRAW1 |
f0fb467d | 487 | //if( fParam.ISlice()==2 || fParam.ISlice()==3) |
488 | { | |
fbb9b71b | 489 | AliHLTTPCCADisplay::Instance().ClearView(); |
693d2443 | 490 | AliHLTTPCCADisplay::Instance().SetSliceView(); |
491 | AliHLTTPCCADisplay::Instance().SetCurrentSlice( this ); | |
fbb9b71b | 492 | AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 ); |
4acc2401 | 493 | if ( NHitsTotal() > 0 ) { |
fbb9b71b | 494 | AliHLTTPCCADisplay::Instance().DrawSliceHits( kRed, .5 ); |
693d2443 | 495 | AliHLTTPCCADisplay::Instance().Ask(); |
496 | } | |
f0fb467d | 497 | } |
693d2443 | 498 | #endif |
499 | ||
b22af1bf | 500 | fCommonMem->fNTracklets = fCommonMem->fNTracks = fCommonMem->fNTrackHits = 0; |
4687b8fc | 501 | |
fbb9b71b | 502 | #if !defined(HLTCA_GPUCODE) |
503 | ||
b22af1bf | 504 | /*if (fGPUDebugLevel >= 6) |
7be9b0d7 | 505 | { |
506 | *fGPUDebugOut << endl << endl << "Slice: " << Param().ISlice() << endl; | |
b22af1bf | 507 | *fGPUDebugOut << "Slice Data:" << endl; |
508 | DumpSliceData(*fGPUDebugOut); | |
509 | }*/ | |
510 | ||
511 | StandalonePerfTime(1); | |
693d2443 | 512 | |
7be9b0d7 | 513 | RunNeighboursFinder(); |
514 | ||
b22af1bf | 515 | StandalonePerfTime(2); |
516 | ||
517 | if (fGPUDebugLevel >= 6) DumpLinks(*fGPUDebugOut); | |
518 | ||
fbb9b71b | 519 | #ifdef HLTCA_INTERNAL_PERFORMANCE |
520 | //if( Param().ISlice()<=2 ) | |
ce565086 | 521 | //AliHLTTPCCAPerformance::Instance().LinkPerformance( Param().ISlice() ); |
522 | #endif | |
523 | ||
524 | ||
f0fb467d | 525 | #ifdef DRAW1 |
4acc2401 | 526 | if ( NHitsTotal() > 0 ) { |
fbb9b71b | 527 | AliHLTTPCCADisplay::Instance().DrawSliceLinks( -1, -1, 1 ); |
ce565086 | 528 | AliHLTTPCCADisplay::Instance().Ask(); |
529 | } | |
530 | #endif | |
531 | ||
7be9b0d7 | 532 | RunNeighboursCleaner(); |
ce565086 | 533 | |
b22af1bf | 534 | StandalonePerfTime(3); |
535 | ||
536 | if (fGPUDebugLevel >= 6) DumpLinks(*fGPUDebugOut); | |
fbb9b71b | 537 | |
7be9b0d7 | 538 | RunStartHitsFinder(); |
c259f7e4 | 539 | |
b22af1bf | 540 | StandalonePerfTime(4); |
541 | StandalonePerfTime(5); | |
d54804bf | 542 | |
b22af1bf | 543 | if (fGPUDebugLevel >= 6) DumpStartHits(*fGPUDebugOut); |
544 | ||
7be9b0d7 | 545 | fData.ClearHitWeights(); |
d54804bf | 546 | |
b22af1bf | 547 | SetPointersTracklets( fCommonMem->fNTracklets * 2 ); // to calculate the size |
548 | fTrackletMemory = reinterpret_cast<char*> ( new uint4 [ fTrackletMemorySize/sizeof( uint4 ) + 100] ); | |
549 | SetPointersTracklets( fCommonMem->fNTracklets * 2 ); // set pointers for hits | |
550 | ||
551 | SetPointersTracks( fCommonMem->fNTracklets * 2, NHitsTotal() ); // to calculate the size | |
7be9b0d7 | 552 | fTrackMemory = reinterpret_cast<char*> ( new uint4 [ fTrackMemorySize/sizeof( uint4 ) + 100] ); |
b22af1bf | 553 | SetPointersTracks( fCommonMem->fNTracklets * 2, NHitsTotal() ); // set pointers for hits |
554 | ||
555 | StandalonePerfTime(6); | |
556 | StandalonePerfTime(7); | |
d54804bf | 557 | |
7be9b0d7 | 558 | RunTrackletConstructor(); |
ce565086 | 559 | |
b22af1bf | 560 | StandalonePerfTime(8); |
561 | ||
562 | if (fGPUDebugLevel >= 6) DumpTrackletHits(*fGPUDebugOut); | |
563 | if (fGPUDebugLevel >= 6) DumpHitWeights(*fGPUDebugOut); | |
d54804bf | 564 | |
7be9b0d7 | 565 | //std::cout<<"Slice "<<Param().ISlice()<<": NHits="<<NHitsTotal()<<", NTracklets="<<*NTracklets()<<std::endl; |
d54804bf | 566 | |
7be9b0d7 | 567 | RunTrackletSelector(); |
d54804bf | 568 | |
b22af1bf | 569 | StandalonePerfTime(9); |
570 | ||
7be9b0d7 | 571 | //std::cout<<"Slice "<<Param().ISlice()<<": N start hits/tracklets/tracks = "<<nStartHits<<" "<<nStartHits<<" "<<*fNTracks<<std::endl; |
d54804bf | 572 | |
b22af1bf | 573 | if (fGPUDebugLevel >= 6) DumpTrackHits(*fGPUDebugOut); |
c259f7e4 | 574 | |
575 | //std::cout<<"Memory used for slice "<<fParam.ISlice()<<" : "<<fCommonMemorySize/1024./1024.<<" + "<<fHitMemorySize/1024./1024.<<" + "<<fTrackMemorySize/1024./1024.<<" = "<<( fCommonMemorySize+fHitMemorySize+fTrackMemorySize )/1024./1024.<<" Mb "<<std::endl; | |
576 | ||
fbb9b71b | 577 | WriteOutput(); |
578 | ||
b22af1bf | 579 | StandalonePerfTime(10); |
580 | ||
693d2443 | 581 | #endif |
582 | ||
f0fb467d | 583 | #ifdef DRAW1 |
fbb9b71b | 584 | { |
585 | AliHLTTPCCADisplay &disp = AliHLTTPCCADisplay::Instance(); | |
586 | AliHLTTPCCATracker &slice = *this; | |
b22af1bf | 587 | std::cout << "N out tracks = " << slice.NOutTracks() << std::endl; |
f0fb467d | 588 | AliHLTTPCCADisplay::Instance().SetSliceView(); |
fbb9b71b | 589 | AliHLTTPCCADisplay::Instance().SetCurrentSlice( this ); |
590 | AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 ); | |
f0fb467d | 591 | disp.DrawSliceHits( kRed, .5 ); |
592 | disp.Ask(); | |
b22af1bf | 593 | for ( int itr = 0; itr < slice.NOutTracks(); itr++ ) { |
fbb9b71b | 594 | std::cout << "track N " << itr << ", nhits=" << slice.OutTracks()[itr].NHits() << std::endl; |
f0fb467d | 595 | disp.DrawSliceOutTrack( itr, kBlue ); |
fbb9b71b | 596 | //disp.Ask(); |
597 | //int id = slice.OutTracks()[itr].OrigTrackID(); | |
598 | //AliHLTTPCCATrack &tr = Tracks()[id]; | |
599 | //for( int ih=0; ih<tr.NHits(); ih++ ){ | |
600 | //int ic = (fTrackHits[tr.FirstHitID()+ih]); | |
601 | //std::cout<<ih<<" "<<ID2IRow(ic)<<" "<<ID2IHit(ic)<<std::endl; | |
602 | //} | |
603 | //disp.DrawSliceTrack( id, kBlue ); | |
604 | //disp.Ask(); | |
605 | } | |
606 | disp.Ask(); | |
607 | } | |
d54804bf | 608 | #endif |
dc4788ec | 609 | |
fbb9b71b | 610 | timer0.Stop(); |
611 | fTimers[0] = timer0.CpuTime() / 100.; | |
326c2d4b | 612 | |
fbb9b71b | 613 | } |
326c2d4b | 614 | |
00d07bcd | 615 | GPUh() void AliHLTTPCCATracker::WriteOutput() |
616 | { | |
d54804bf | 617 | // write output |
eb30eb49 | 618 | |
00d07bcd | 619 | TStopwatch timer; |
63d8b79d | 620 | |
4acc2401 | 621 | //cout<<"output: nTracks = "<<*fNTracks<<", nHitsTotal="<<NHitsTotal()<<std::endl; |
63d8b79d | 622 | |
b22af1bf | 623 | fOutput->SetNTracks( fCommonMem->fNTracks ); |
624 | fOutput->SetNTrackClusters( fCommonMem->fNTrackHits ); | |
625 | fOutput->Allocate(); | |
63d8b79d | 626 | |
fbb9b71b | 627 | int nStoredHits = 0; |
15d2e9cf | 628 | |
b22af1bf | 629 | for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) { |
fbb9b71b | 630 | AliHLTTPCCATrack &iTrack = fTracks[iTr]; |
63d8b79d | 631 | |
63d8b79d | 632 | AliHLTTPCCASliceTrack out; |
633 | out.SetFirstClusterRef( nStoredHits ); | |
fbb9b71b | 634 | out.SetNClusters( iTrack.NHits() ); |
63d8b79d | 635 | out.SetParam( iTrack.Param() ); |
636 | ||
637 | fOutput->SetTrack( iTr, out ); | |
638 | ||
fbb9b71b | 639 | int iID = iTrack.FirstHitID(); |
640 | for ( int ith = 0; ith < iTrack.NHits(); ith++ ) { | |
4acc2401 | 641 | const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith]; |
642 | int iRow = ic.RowIndex(); | |
643 | int ih = ic.HitIndex(); | |
fbb9b71b | 644 | |
4acc2401 | 645 | const AliHLTTPCCARow &row = fData.Row( iRow ); |
15d2e9cf | 646 | |
fbb9b71b | 647 | //float y0 = row.Grid().YMin(); |
648 | //float z0 = row.Grid().ZMin(); | |
649 | //float stepY = row.HstepY(); | |
650 | //float stepZ = row.HstepZ(); | |
651 | //float x = row.X(); | |
63d8b79d | 652 | |
15d2e9cf | 653 | //const uint4 *tmpint4 = RowData() + row.FullOffset(); |
654 | //const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4); | |
655 | //ushort2 hh = hits[ih]; | |
fbb9b71b | 656 | //float y = y0 + hh.x*stepY; |
657 | //float z = z0 + hh.y*stepZ; | |
63d8b79d | 658 | |
16b802c5 | 659 | int clusterIndex = fData.ClusterDataIndex( row, ih ); |
660 | int clusterRowIndex = clusterIndex - fClusterData->RowOffset( iRow ); | |
4acc2401 | 661 | |
16b802c5 | 662 | if ( clusterIndex < 0 || clusterIndex >= fClusterData->NumberOfClusters() ) { |
4acc2401 | 663 | //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters() |
664 | //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl; | |
665 | //abort(); | |
666 | continue; | |
667 | } | |
16b802c5 | 668 | if ( clusterRowIndex < 0 || clusterRowIndex >= fClusterData->NumberOfClusters( iRow ) ) { |
4acc2401 | 669 | //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters() |
670 | //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl; | |
671 | //abort(); | |
672 | continue; | |
673 | } | |
63d8b79d | 674 | |
16b802c5 | 675 | float origX = fClusterData->X( clusterIndex ); |
676 | float origY = fClusterData->Y( clusterIndex ); | |
677 | float origZ = fClusterData->Z( clusterIndex ); | |
678 | ||
679 | ||
6de2bc40 | 680 | int id = fClusterData->Id( clusterIndex ); |
15d2e9cf | 681 | |
fbb9b71b | 682 | unsigned short hPackedYZ = 0; |
63d8b79d | 683 | UChar_t hPackedAmp = 0; |
4acc2401 | 684 | float2 hUnpackedYZ; |
685 | hUnpackedYZ.x = origY; | |
686 | hUnpackedYZ.y = origZ; | |
15d2e9cf | 687 | float hUnpackedX = origX; |
688 | ||
6de2bc40 | 689 | fOutput->SetClusterId( nStoredHits, id ); |
b8139972 | 690 | fOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow ); |
63d8b79d | 691 | fOutput->SetClusterPackedYZ( nStoredHits, hPackedYZ ); |
fbb9b71b | 692 | fOutput->SetClusterPackedAmp( nStoredHits, hPackedAmp ); |
63d8b79d | 693 | fOutput->SetClusterUnpackedYZ( nStoredHits, hUnpackedYZ ); |
15d2e9cf | 694 | fOutput->SetClusterUnpackedX( nStoredHits, hUnpackedX ); |
63d8b79d | 695 | nStoredHits++; |
696 | } | |
697 | } | |
fbb9b71b | 698 | |
699 | ||
700 | // old stuff | |
b22af1bf | 701 | #ifndef HLTCA_STANDALONE |
702 | fOutput->SetNOutTrackHits(0); | |
703 | fOutput->SetNOutTracks(0); | |
4687b8fc | 704 | |
4687b8fc | 705 | |
b22af1bf | 706 | for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) { |
4687b8fc | 707 | |
4acc2401 | 708 | const AliHLTTPCCATrack &iTrack = fTracks[iTr]; |
4687b8fc | 709 | |
4acc2401 | 710 | //std::cout<<"iTr = "<<iTr<<", nHits="<<iTrack.NHits()<<std::endl; |
693d2443 | 711 | |
712 | //if( !iTrack.Alive() ) continue; | |
fbb9b71b | 713 | if ( iTrack.NHits() < 3 ) continue; |
b22af1bf | 714 | AliHLTTPCCAOutTrack &out = fOutput->OutTracks()[fOutput->NOutTracks()]; |
715 | out.SetFirstHitRef( fOutput->NOutTrackHits() ); | |
693d2443 | 716 | out.SetNHits( 0 ); |
fbb9b71b | 717 | out.SetOrigTrackID( iTr ); |
693d2443 | 718 | out.SetStartPoint( iTrack.Param() ); |
fbb9b71b | 719 | out.SetEndPoint( iTrack.Param() ); |
720 | ||
721 | int iID = iTrack.FirstHitID(); | |
b22af1bf | 722 | int nOutTrackHitsOld = fOutput->NOutTrackHits(); |
fbb9b71b | 723 | |
724 | for ( int ith = 0; ith < iTrack.NHits(); ith++ ) { | |
4acc2401 | 725 | const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith]; |
726 | const AliHLTTPCCARow &row = Row( ic ); | |
727 | int ih = ic.HitIndex(); | |
b22af1bf | 728 | fOutput->SetOutTrackHit(fOutput->NOutTrackHits(), HitInputID( row, ih )); |
729 | fOutput->SetNOutTrackHits(fOutput->NOutTrackHits() + 1 ); | |
4acc2401 | 730 | //std::cout<<"write i,row,hit,id="<<ith<<", "<<ID2IRow(ic)<<", "<<ih<<", "<<HitInputID( row, ih )<<std::endl; |
b22af1bf | 731 | if ( fOutput->NOutTrackHits() >= 10*NHitsTotal() ) { |
4acc2401 | 732 | std::cout << "fNOutTrackHits>NHitsTotal()" << std::endl; |
fbb9b71b | 733 | //exit(0); |
734 | return;//SG!!! | |
eb30eb49 | 735 | } |
fbb9b71b | 736 | out.SetNHits( out.NHits() + 1 ); |
737 | } | |
738 | if ( out.NHits() >= 2 ) { | |
b22af1bf | 739 | fOutput->SetNOutTracks(fOutput->NOutTracks() + 1); |
fbb9b71b | 740 | } else { |
b22af1bf | 741 | fOutput->SetNOutTrackHits(nOutTrackHitsOld); |
d54804bf | 742 | } |
743 | } | |
b22af1bf | 744 | #endif |
63d8b79d | 745 | |
00d07bcd | 746 | timer.Stop(); |
fbb9b71b | 747 | fTimers[5] += timer.CpuTime(); |
326c2d4b | 748 | } |
749 | ||
7be9b0d7 | 750 | #endif |
751 | ||
4acc2401 | 752 | GPUh() void AliHLTTPCCATracker::FitTrackFull( const AliHLTTPCCATrack &/**/, float * /**/ ) const |
fbb9b71b | 753 | { |
00d07bcd | 754 | // fit track with material |
fbb9b71b | 755 | #ifdef XXX |
756 | //* Fit the track | |
00d07bcd | 757 | FitTrack( iTrack, tt0 ); |
fbb9b71b | 758 | if ( iTrack.NHits() <= 3 ) return; |
759 | ||
00d07bcd | 760 | AliHLTTPCCATrackParam &t = iTrack.Param(); |
761 | AliHLTTPCCATrackParam t0 = t; | |
762 | ||
763 | t.Chi2() = 0; | |
fbb9b71b | 764 | t.NDF() = -5; |
765 | bool first = 1; | |
766 | ||
767 | int iID = iTrack.FirstHitID(); | |
768 | for ( int ih = 0; ih < iTrack.NHits(); ih++, iID++ ) { | |
4acc2401 | 769 | const AliHLTTPCCAHitId &ic = fTrackHits[iID]; |
770 | int iRow = ic.rowIndex(); | |
771 | const AliHLTTPCCARow &row = fData.Row( iRow ); | |
fbb9b71b | 772 | if ( !t0.TransportToX( row.X() ) ) continue; |
773 | float dy, dz; | |
4acc2401 | 774 | const AliHLTTPCCAHit &h = ic.hitIndex(); |
fbb9b71b | 775 | |
776 | // check for wrong hits | |
777 | if ( 0 ) { | |
00d07bcd | 778 | dy = t0.GetY() - h.Y(); |
779 | dz = t0.GetZ() - h.Z(); | |
fbb9b71b | 780 | |
00d07bcd | 781 | //if( dy*dy > 3.5*3.5*(/*t0.GetErr2Y() + */h.ErrY()*h.ErrY() ) ) continue;//SG!!! |
fbb9b71b | 782 | //if( dz*dz > 3.5*3.5*(/*t0.GetErr2Z() + */h.ErrZ()*h.ErrZ() ) ) continue; |
00d07bcd | 783 | } |
326c2d4b | 784 | |
fbb9b71b | 785 | if ( !t.TransportToX( row.X() ) ) continue; |
dc4788ec | 786 | |
00d07bcd | 787 | //* Update the track |
fbb9b71b | 788 | |
789 | if ( first ) { | |
790 | t.Cov()[ 0] = .5 * .5; | |
00d07bcd | 791 | t.Cov()[ 1] = 0; |
fbb9b71b | 792 | t.Cov()[ 2] = .5 * .5; |
00d07bcd | 793 | t.Cov()[ 3] = 0; |
794 | t.Cov()[ 4] = 0; | |
fbb9b71b | 795 | t.Cov()[ 5] = .2 * .2; |
00d07bcd | 796 | t.Cov()[ 6] = 0; |
797 | t.Cov()[ 7] = 0; | |
798 | t.Cov()[ 8] = 0; | |
fbb9b71b | 799 | t.Cov()[ 9] = .2 * .2; |
00d07bcd | 800 | t.Cov()[10] = 0; |
801 | t.Cov()[11] = 0; | |
802 | t.Cov()[12] = 0; | |
803 | t.Cov()[13] = 0; | |
fbb9b71b | 804 | t.Cov()[14] = .2 * .2; |
00d07bcd | 805 | t.Chi2() = 0; |
806 | t.NDF() = -5; | |
807 | } | |
fbb9b71b | 808 | float err2Y, err2Z; |
00d07bcd | 809 | GetErrors2( iRow, t, err2Y, err2Z ); |
810 | ||
fbb9b71b | 811 | if ( !t.Filter2( h.Y(), h.Z(), err2Y, err2Z ) ) continue; |
00d07bcd | 812 | |
fbb9b71b | 813 | first = 0; |
814 | } | |
00d07bcd | 815 | /* |
fbb9b71b | 816 | float cosPhi = iTrack.Param().GetCosPhi(); |
00d07bcd | 817 | p0.Param().TransportToX(ID2Row( iTrack.PointID()[0] ).X()); |
fbb9b71b | 818 | p2.Param().TransportToX(ID2Row( iTrack.PointID()[1] ).X()); |
00d07bcd | 819 | if( p0.Param().GetCosPhi()*cosPhi<0 ){ // change direction |
fbb9b71b | 820 | float *par = p0.Param().Par(); |
821 | float *cov = p0.Param().Cov(); | |
00d07bcd | 822 | par[2] = -par[2]; // sin phi |
823 | par[3] = -par[3]; // DzDs | |
824 | par[4] = -par[4]; // kappa | |
825 | cov[3] = -cov[3]; | |
826 | cov[4] = -cov[4]; | |
827 | cov[6] = -cov[6]; | |
828 | cov[7] = -cov[7]; | |
829 | cov[10] = -cov[10]; | |
830 | cov[11] = -cov[11]; | |
831 | p0.Param().CosPhi() = -p0.Param().GetCosPhi(); | |
832 | } | |
833 | */ | |
834 | #endif | |
835 | } | |
dc4788ec | 836 | |
4acc2401 | 837 | GPUh() void AliHLTTPCCATracker::FitTrack( const AliHLTTPCCATrack &/*track*/, float * /*t0[]*/ ) const |
fbb9b71b | 838 | { |
839 | //* Fit the track | |
00d07bcd | 840 | #ifdef XXX |
fbb9b71b | 841 | AliHLTTPCCAEndPoint &p2 = ID2Point( track.PointID()[1] ); |
4acc2401 | 842 | const AliHLTTPCCAHit &c0 = ID2Hit( fTrackHits[p0.TrackHitID()].HitID() ); |
843 | const AliHLTTPCCAHit &c1 = ID2Hit( fTrackHits[track.HitID()[1]].HitID() ); | |
844 | const AliHLTTPCCAHit &c2 = ID2Hit( fTrackHits[p2.TrackHitID()].HitID() ); | |
845 | const AliHLTTPCCARow &row0 = ID2Row( fTrackHits[p0.TrackHitID()].HitID() ); | |
846 | const AliHLTTPCCARow &row1 = ID2Row( fTrackHits[track.HitID()[1]].HitID() ); | |
847 | const AliHLTTPCCARow &row2 = ID2Row( fTrackHits[p2.TrackHitID()].HitID() ); | |
fbb9b71b | 848 | float sp0[5] = {row0.X(), c0.Y(), c0.Z(), c0.ErrY(), c0.ErrZ() }; |
849 | float sp1[5] = {row1.X(), c1.Y(), c1.Z(), c1.ErrY(), c1.ErrZ() }; | |
850 | float sp2[5] = {row2.X(), c2.Y(), c2.Z(), c2.ErrY(), c2.ErrZ() }; | |
4acc2401 | 851 | //std::cout<<"Fit track, points ="<<sp0[0]<<" "<<sp0[1]<<" / "<<sp1[0]<<" "<<sp1[1]<<" / "<<sp2[0]<<" "<<sp2[1]<<std::endl; |
fbb9b71b | 852 | if ( track.NHits() >= 3 ) { |
853 | p0.Param().ConstructXYZ3( sp0, sp1, sp2, p0.Param().CosPhi(), t0 ); | |
854 | p2.Param().ConstructXYZ3( sp2, sp1, sp0, p2.Param().CosPhi(), t0 ); | |
d54804bf | 855 | //p2.Param() = p0.Param(); |
856 | //p2.Param().TransportToX(row2.X()); | |
857 | //p2.Param().Par()[1] = -p2.Param().Par()[1]; | |
858 | //p2.Param().Par()[4] = -p2.Param().Par()[4]; | |
859 | } else { | |
860 | p0.Param().X() = row0.X(); | |
861 | p0.Param().Y() = c0.Y(); | |
862 | p0.Param().Z() = c0.Z(); | |
fbb9b71b | 863 | p0.Param().Err2Y() = c0.ErrY() * c0.ErrY(); |
864 | p0.Param().Err2Z() = c0.ErrZ() * c0.ErrZ(); | |
d54804bf | 865 | p2.Param().X() = row2.X(); |
866 | p2.Param().Y() = c2.Y(); | |
867 | p2.Param().Z() = c2.Z(); | |
fbb9b71b | 868 | p2.Param().Err2Y() = c2.ErrY() * c2.ErrY(); |
869 | p2.Param().Err2Z() = c2.ErrZ() * c2.ErrZ(); | |
326c2d4b | 870 | } |
00d07bcd | 871 | #endif |
872 | } | |
873 | ||
874 | ||
fbb9b71b | 875 | GPUd() void AliHLTTPCCATracker::GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const |
693d2443 | 876 | { |
877 | // | |
878 | // Use calibrated cluster error from OCDB | |
879 | // | |
880 | ||
63d8b79d | 881 | fParam.GetClusterErrors2( iRow, z, sinPhi, cosPhi, DzDs, Err2Y, Err2Z ); |
f0fb467d | 882 | Err2Y*=fParam.ClusterError2CorrectionY(); |
883 | Err2Z*=fParam.ClusterError2CorrectionZ(); | |
693d2443 | 884 | } |
885 | ||
fbb9b71b | 886 | GPUd() void AliHLTTPCCATracker::GetErrors2( int iRow, const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const |
00d07bcd | 887 | { |
888 | // | |
889 | // Use calibrated cluster error from OCDB | |
890 | // | |
891 | ||
15d2e9cf | 892 | fParam.GetClusterErrors2( iRow, t.GetZ(), t.SinPhi(), t.GetCosPhi(), t.DzDs(), Err2Y, Err2Z ); |
00d07bcd | 893 | } |
894 | ||
4687b8fc | 895 | |
fbb9b71b | 896 | #if !defined(HLTCA_GPUCODE) |
4687b8fc | 897 | |
fbb9b71b | 898 | GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out ) |
00d07bcd | 899 | { |
4687b8fc | 900 | // write event to the file |
fbb9b71b | 901 | for ( int iRow = 0; iRow < fParam.NRows(); iRow++ ) { |
4acc2401 | 902 | out << fData.Row( iRow ).HitNumberOffset() << " " << fData.Row( iRow ).NHits() << std::endl; |
fbb9b71b | 903 | } |
4acc2401 | 904 | out << NHitsTotal() << std::endl; |
fbb9b71b | 905 | |
4acc2401 | 906 | AliHLTResizableArray<float> y( NHitsTotal() ), z( NHitsTotal() ); |
fbb9b71b | 907 | |
908 | for ( int iRow = 0; iRow < fParam.NRows(); iRow++ ) { | |
4acc2401 | 909 | const AliHLTTPCCARow &row = Row( iRow ); |
fbb9b71b | 910 | float y0 = row.Grid().YMin(); |
911 | float z0 = row.Grid().ZMin(); | |
912 | float stepY = row.HstepY(); | |
913 | float stepZ = row.HstepZ(); | |
4acc2401 | 914 | for ( int ih = 0; ih < fData.Row( iRow ).NHits(); ih++ ) { |
915 | int id = HitInputID( row, ih ); | |
916 | y[id] = y0 + HitDataY( row, ih ) * stepY; | |
917 | z[id] = z0 + HitDataZ( row, ih ) * stepZ; | |
4687b8fc | 918 | } |
919 | } | |
4acc2401 | 920 | for ( int ih = 0; ih < NHitsTotal(); ih++ ) { |
fbb9b71b | 921 | out << y[ih] << " " << z[ih] << std::endl; |
4687b8fc | 922 | } |
fbb9b71b | 923 | } |
4687b8fc | 924 | |
fbb9b71b | 925 | GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out ) |
4687b8fc | 926 | { |
fbb9b71b | 927 | //* Write tracks to file |
928 | ||
929 | out << fTimers[0] << std::endl; | |
b22af1bf | 930 | out << fOutput->NOutTrackHits() << std::endl; |
931 | for ( int ih = 0; ih < fOutput->NOutTrackHits(); ih++ ) { | |
932 | out << fOutput->OutTrackHit(ih) << " "; | |
4687b8fc | 933 | } |
fbb9b71b | 934 | out << std::endl; |
935 | ||
b22af1bf | 936 | out << fOutput->NOutTracks() << std::endl; |
fbb9b71b | 937 | |
b22af1bf | 938 | for ( int itr = 0; itr < fOutput->NOutTracks(); itr++ ) { |
939 | const AliHLTTPCCAOutTrack &t = fOutput->OutTrack(itr); | |
fbb9b71b | 940 | AliHLTTPCCATrackParam p1 = t.StartPoint(); |
941 | AliHLTTPCCATrackParam p2 = t.EndPoint(); | |
942 | out << t.NHits() << " "; | |
943 | out << t.FirstHitRef() << " "; | |
944 | out << t.OrigTrackID() << " "; | |
945 | out << std::endl; | |
946 | out << p1.X() << " "; | |
947 | out << p1.SignCosPhi() << " "; | |
948 | out << p1.Chi2() << " "; | |
949 | out << p1.NDF() << std::endl; | |
950 | for ( int i = 0; i < 5; i++ ) out << p1.Par()[i] << " "; | |
951 | out << std::endl; | |
952 | for ( int i = 0; i < 15; i++ ) out << p1.Cov()[i] << " "; | |
953 | out << std::endl; | |
954 | out << p2.X() << " "; | |
955 | out << p2.SignCosPhi() << " "; | |
956 | out << p2.Chi2() << " "; | |
957 | out << p2.NDF() << std::endl; | |
958 | for ( int i = 0; i < 5; i++ ) out << p2.Par()[i] << " "; | |
959 | out << std::endl; | |
960 | for ( int i = 0; i < 15; i++ ) out << p2.Cov()[i] << " "; | |
961 | out << std::endl; | |
4687b8fc | 962 | } |
963 | } | |
964 | ||
965 | GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &in ) | |
966 | { | |
fbb9b71b | 967 | //* Read tracks from file |
b22af1bf | 968 | int tmpval; |
fbb9b71b | 969 | in >> fTimers[0]; |
b22af1bf | 970 | in >> tmpval; |
971 | fOutput->SetNOutTrackHits(tmpval); | |
4687b8fc | 972 | |
b22af1bf | 973 | for ( int ih = 0; ih < fOutput->NOutTrackHits(); ih++ ) { |
974 | in >> tmpval; | |
975 | fOutput->SetOutTrackHit(ih, tmpval); | |
4687b8fc | 976 | } |
b22af1bf | 977 | in >> tmpval; |
978 | fOutput->SetNOutTracks(tmpval); | |
4687b8fc | 979 | |
b22af1bf | 980 | for ( int itr = 0; itr < fOutput->NOutTracks(); itr++ ) { |
981 | AliHLTTPCCAOutTrack &t = fOutput->OutTracks()[itr]; | |
693d2443 | 982 | AliHLTTPCCATrackParam p1, p2; |
fbb9b71b | 983 | int i; |
984 | float f; | |
985 | in >> i; t.SetNHits( i ); | |
986 | in >> i; t.SetFirstHitRef( i ); | |
987 | in >> i; t.SetOrigTrackID( i ); | |
988 | in >> f; p1.SetX( f ); | |
989 | in >> f; p1.SetSignCosPhi( f ); | |
990 | in >> f; p1.SetChi2( f ); | |
991 | in >> i; p1.SetNDF( i ); | |
992 | for ( int j = 0; j < 5; j++ ) { in >> f; p1.SetPar( j, f ); } | |
993 | for ( int j = 0; j < 15; j++ ) { in >> f; p1.SetCov( j, f ); } | |
994 | in >> f; p2.SetX( f ); | |
995 | in >> f; p2.SetSignCosPhi( f ); | |
996 | in >> f; p2.SetChi2( f ); | |
997 | in >> i; p2.SetNDF( i ); | |
998 | for ( int j = 0; j < 5; j++ ) { in >> f; p2.SetPar( j, f ); } | |
999 | for ( int j = 0; j < 15; j++ ) { in >> f; p2.SetCov( j, f ); } | |
693d2443 | 1000 | t.SetStartPoint( p1 ); |
1001 | t.SetEndPoint( p2 ); | |
4687b8fc | 1002 | } |
326c2d4b | 1003 | } |
4687b8fc | 1004 | #endif |