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