]>
Commit | Line | Data |
---|---|---|
71d7c760 | 1 | // $Id$ |
2 | ||
3 | /************************************************************************** | |
9be2600f | 4 | * This file is property of and copyright by the ALICE HLT Project * |
5 | * ALICE Experiment at CERN, All rights reserved. * | |
71d7c760 | 6 | * * |
9be2600f | 7 | * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> * |
8 | * Timm Steinbeck <timm@kip.uni-heidelberg.de> * | |
9 | * for The ALICE HLT Project. * | |
71d7c760 | 10 | * * |
11 | * Permission to use, copy, modify and distribute this software and its * | |
12 | * documentation strictly for non-commercial purposes is hereby granted * | |
13 | * without fee, provided that the above copyright notice appears in all * | |
14 | * copies and that both the copyright notice and this permission notice * | |
15 | * appear in the supporting documentation. The authors make no claims * | |
16 | * about the suitability of this software for any purpose. It is * | |
17 | * provided "as is" without express or implied warranty. * | |
18 | **************************************************************************/ | |
19 | ||
de554e07 | 20 | /** @file AliHLTTPCSliceTrackerComponent.cxx |
21 | @author Timm Steinbeck, Matthias Richter | |
22 | @date | |
23 | @brief The TPC conformal mapping tracker component. | |
24 | */ | |
71d7c760 | 25 | |
db16520a | 26 | #if __GNUC__>= 3 |
71d7c760 | 27 | using namespace std; |
28 | #endif | |
29 | ||
30 | #include "AliHLTTPCSliceTrackerComponent.h" | |
a6c02c85 | 31 | #include "AliHLTTPCTransform.h" |
32 | #include "AliHLTTPCConfMapper.h" | |
33 | #include "AliHLTTPCVertex.h" | |
a6c02c85 | 34 | #include "AliHLTTPCVertexData.h" |
71d7c760 | 35 | #include "AliHLTTPCClusterDataFormat.h" |
a6c02c85 | 36 | #include "AliHLTTPCTransform.h" |
37 | #include "AliHLTTPCTrackSegmentData.h" | |
38 | #include "AliHLTTPCTrackArray.h" | |
71d7c760 | 39 | #include "AliHLTTPCTrackletDataFormat.h" |
ecefc48a | 40 | #include "AliHLTTPCInterMerger.h" |
41 | #include "AliHLTTPCMemHandler.h" | |
5df0cbb9 | 42 | #include "AliHLTTPCDefinitions.h" |
a7c32962 | 43 | //#include "AliHLTTPC.h" |
5df0cbb9 | 44 | //#include <stdlib.h> |
45 | //#include <cerrno> | |
71d7c760 | 46 | |
47 | // this is a global object used for automatic component registration, do not use this | |
48 | AliHLTTPCSliceTrackerComponent gAliHLTTPCSliceTrackerComponent; | |
49 | ||
5df0cbb9 | 50 | /** ROOT macro for the implementation of ROOT specific class methods */ |
71d7c760 | 51 | ClassImp(AliHLTTPCSliceTrackerComponent) |
52 | ||
53 | AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent() | |
6235cd38 | 54 | : |
55 | fTracker(NULL), | |
56 | fVertex(NULL), | |
57 | fDoNonVertex(false), | |
ecefc48a | 58 | fDoPP(false), |
6235cd38 | 59 | fMultiplicity(4000), |
60 | fBField(0.4), | |
6235cd38 | 61 | // BEGINN ############################################## MODIFIY JMT |
62 | fnonvertextracking(kFALSE), | |
ecefc48a | 63 | fmainvertextracking(kTRUE), |
6235cd38 | 64 | // END ################################################# MODIFIY JMT |
ecefc48a | 65 | fpInterMerger(NULL) |
6235cd38 | 66 | { |
67 | // see header file for class documentation | |
68 | // or | |
69 | // refer to README to build package | |
70 | // or | |
71 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
72 | fEta[0] = 0.; | |
73 | fEta[1] = 1.1; | |
74 | } | |
75 | ||
76 | AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent& src) | |
77 | : | |
78 | fTracker(NULL), | |
79 | fVertex(NULL), | |
80 | fDoNonVertex(false), | |
ecefc48a | 81 | fDoPP(false), |
6235cd38 | 82 | fMultiplicity(4000), |
83 | fBField(0.4), | |
738c049f | 84 | // BEGINN ############################################## MODIFIY JMT |
6235cd38 | 85 | fnonvertextracking(kFALSE), |
ecefc48a | 86 | fmainvertextracking(kTRUE), |
738c049f | 87 | // END ################################################# MODIFIY JMT |
ecefc48a | 88 | fpInterMerger(NULL) |
6235cd38 | 89 | { |
90 | // see header file for class documentation | |
91 | HLTFatal("copy constructor untested"); | |
92 | } | |
93 | ||
94 | AliHLTTPCSliceTrackerComponent& AliHLTTPCSliceTrackerComponent::operator=(const AliHLTTPCSliceTrackerComponent& src) | |
95 | { | |
96 | // see header file for class documentation | |
97 | HLTFatal("assignment operator untested"); | |
98 | return *this; | |
99 | } | |
71d7c760 | 100 | |
101 | AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent() | |
6235cd38 | 102 | { |
5df0cbb9 | 103 | // see header file for class documentation |
6235cd38 | 104 | } |
71d7c760 | 105 | |
106 | // Public functions to implement AliHLTComponent's interface. | |
107 | // These functions are required for the registration process | |
108 | ||
109 | const char* AliHLTTPCSliceTrackerComponent::GetComponentID() | |
6235cd38 | 110 | { |
5df0cbb9 | 111 | // see header file for class documentation |
6235cd38 | 112 | |
113 | return "TPCSliceTracker"; | |
114 | } | |
71d7c760 | 115 | |
8ede8717 | 116 | void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) |
6235cd38 | 117 | { |
5df0cbb9 | 118 | // see header file for class documentation |
6235cd38 | 119 | list.clear(); |
96bda103 | 120 | list.push_back( AliHLTTPCDefinitions::fgkClustersDataType ); |
121 | list.push_back( AliHLTTPCDefinitions::fgkVertexDataType ); | |
6235cd38 | 122 | } |
71d7c760 | 123 | |
8ede8717 | 124 | AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType() |
6235cd38 | 125 | { |
5df0cbb9 | 126 | // see header file for class documentation |
96bda103 | 127 | return AliHLTTPCDefinitions::fgkTrackSegmentsDataType; |
6235cd38 | 128 | } |
71d7c760 | 129 | |
130 | void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) | |
6235cd38 | 131 | { |
5df0cbb9 | 132 | // see header file for class documentation |
6235cd38 | 133 | // XXX TODO: Find more realistic values. |
134 | constBase = 0; | |
135 | inputMultiplier = 0.2; | |
136 | } | |
71d7c760 | 137 | |
138 | AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn() | |
6235cd38 | 139 | { |
5df0cbb9 | 140 | // see header file for class documentation |
6235cd38 | 141 | return new AliHLTTPCSliceTrackerComponent; |
142 | } | |
71d7c760 | 143 | |
6235cd38 | 144 | void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phiSegments, Int_t etaSegments, |
71d7c760 | 145 | Int_t trackletlength, Int_t tracklength, |
146 | Int_t rowscopetracklet, Int_t rowscopetrack, | |
6235cd38 | 147 | Double_t minPtFit, Double_t maxangle, |
71d7c760 | 148 | Double_t goodDist, Double_t hitChi2Cut, |
149 | Double_t goodHitChi2, Double_t trackChi2Cut, | |
150 | Int_t maxdist, Double_t maxphi,Double_t maxeta, bool vertexConstraints ) | |
151 | { | |
5df0cbb9 | 152 | // see header file for class documentation |
71d7c760 | 153 | //fTracker->SetClusterFinderParam( fXYClusterError, fZClusterError, kTRUE ); // ?? |
154 | //Set parameters input to the tracker | |
155 | //If no arguments are given, default parameters will be used | |
156 | ||
6235cd38 | 157 | fTracker->SetNSegments(phiSegments,etaSegments); |
158 | fTracker->SetMaxDca(minPtFit); | |
71d7c760 | 159 | // fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack); |
738c049f | 160 | |
161 | // BEGINN ############################################## MODIFIY JMT | |
162 | #if 1 | |
db16520a | 163 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" ); |
738c049f | 164 | |
165 | if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){ | |
166 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE); | |
167 | fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE); | |
168 | ||
169 | fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta); | |
db16520a | 170 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" ); |
738c049f | 171 | } |
172 | else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){ | |
173 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE); | |
174 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE); | |
175 | fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE); | |
176 | fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE); | |
177 | ||
178 | fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta); | |
179 | fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack); | |
db16520a | 180 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" ); |
738c049f | 181 | } |
182 | else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){ | |
183 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE); | |
184 | fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE); | |
185 | ||
186 | fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack); | |
db16520a | 187 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" ); |
738c049f | 188 | } |
189 | #else | |
71d7c760 | 190 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexConstraints); |
191 | fTracker->SetTrackletCuts(maxangle,goodDist,vertexConstraints); | |
192 | ||
193 | if( vertexConstraints ) | |
194 | fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta); | |
195 | else | |
196 | fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack); | |
738c049f | 197 | #endif |
198 | // END ################################################# MODIFIY JMT | |
a6c02c85 | 199 | |
738c049f | 200 | //fTracker->SetParamDone(true); |
a7c32962 | 201 | /* Matthias 13.12.2006 |
202 | * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far | |
203 | * and has always been kTRUE. | |
204 | * In order to remove the AliHLTTPC class (which is the old steering class for | |
205 | * HLT (TPC) tracking) from the compilation, this function can not be activated | |
206 | * again. We have to think about a more elegant way to specify the parameters | |
207 | * anyway. The following line was surely for some testing, but was never active | |
208 | * in a tested release. | |
209 | */ | |
a6c02c85 | 210 | //AliHLTTPC::SetVertexFit( kFALSE ); |
71d7c760 | 211 | |
212 | fTracker->InitVolumes(); | |
213 | } | |
214 | ||
215 | void AliHLTTPCSliceTrackerComponent::SetTrackerParam( bool doPP, int multiplicity, double bField ) | |
216 | { | |
738c049f | 217 | AliHLTTPCTransform::SetBField( bField ); |
db16520a | 218 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField ); |
738c049f | 219 | |
71d7c760 | 220 | if ( doPP ) |
221 | { | |
222 | //tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ?? | |
ecefc48a | 223 | /* the old setup used during TPC |
224 | SetTrackerParam( 50, 100, 3, 10, | |
225 | 2, 2, | |
226 | 0, 0.1745, 5, 100, | |
227 | 5, 50, 50, 0.1, 0.1, kTRUE); | |
228 | */ | |
229 | SetTrackerParam( 50, // phi_segments: Devide the space into phi_segments | |
230 | 100, // ets_segments: Devide the space into eta_segments | |
231 | 3, // trackletlength: Number of hits a tracklet has to have | |
232 | 10, // tracklength: Number of hits a track has to have | |
233 | 6, // rowscopetracklet: Search range of rows for a tracklet | |
234 | 6, // rowscopetrack: Search range of rows for a track | |
235 | 0, // min_pt_fit: Cut for moment fit, use:SetMaxDca(min_pt_fit) | |
236 | AliHLTTPCTransform::Deg2Rad(10), | |
237 | // maxangle: AliHLTTPCTransform::Deg2Rad(10), max angle for the three point look aheand | |
238 | 5, // goodDist: Threshold distancs between two hits when building tracklets | |
239 | 100, // hitChi2Cut: Max chi2 of added hit to track | |
240 | 5, // goodHitChi2: Stop looking for next hit to add if chi2 is less then goodHitChi2 | |
241 | 50, // trackChi2Cut: Max chi2 for track after final fit | |
242 | 50, // maxdist: Maximum distance between two clusters when forming segments | |
243 | 0.1, // maxphi: Max phi difference for neighboring hits | |
244 | 0.1, // maxeta: Max eta difference for neighboring hits | |
245 | kTRUE); // vertexConstrain: False if one want to look for secondary vertex track | |
71d7c760 | 246 | } |
247 | else | |
248 | { | |
249 | int mults[] = { 1000, 2000, 4000, 8000 }; | |
250 | int multCount = 4; | |
251 | int closestMult = 0; | |
252 | int i; | |
253 | int multDist, tmpMultDist; | |
254 | if ( multiplicity>mults[closestMult] ) | |
255 | multDist = multiplicity-mults[closestMult]; | |
256 | else | |
257 | multDist = mults[closestMult]-multiplicity; | |
258 | for ( i = 1; i < multCount; i++ ) | |
259 | { | |
260 | if ( multiplicity>mults[i] ) | |
261 | tmpMultDist = multiplicity-mults[i]; | |
262 | else | |
263 | tmpMultDist = mults[i]-multiplicity; | |
264 | if ( tmpMultDist < multDist ) | |
265 | { | |
266 | closestMult = i; | |
267 | multDist = tmpMultDist; | |
268 | } | |
269 | } | |
270 | ||
271 | double bfs[] = { 0.2, 0.4 }; | |
272 | int bfCount = 2; | |
273 | int closestBf = 0; | |
274 | double bfDist, tmpBFDist; | |
275 | if ( bField>bfs[closestBf] ) | |
276 | bfDist = bField-bfs[closestBf]; | |
277 | else | |
278 | bfDist = bfs[closestBf]-bField; | |
279 | for ( i = 1; i < bfCount; i++ ) | |
280 | { | |
281 | if ( bField>bfs[i] ) | |
282 | tmpBFDist = bField-bfs[i]; | |
283 | else | |
284 | tmpBFDist = bfs[i]-bField; | |
285 | if ( tmpBFDist < bfDist ) | |
286 | { | |
287 | closestBf = i; | |
288 | bfDist = tmpBFDist; | |
289 | } | |
290 | } | |
291 | ||
292 | switch ( closestMult ) | |
293 | { | |
294 | case 0: // 1000 | |
295 | switch ( closestBf ) | |
296 | { | |
297 | case 0: // 0.2 | |
298 | SetTrackerParam( 50, 100, 3, 10, | |
299 | 2, 4, | |
300 | 0, 0.1745, 5, 100, | |
301 | 5, 50, 50, 0.1, 0.1, kTRUE ); | |
302 | break; | |
303 | case 1: // 0.4 | |
304 | SetTrackerParam( 50, 100, 3, 10, | |
305 | 2, 4, | |
306 | 0, 0.1745, 5, 100, | |
307 | 5, 50, 50, 0.1, 0.1, kTRUE ); | |
308 | break; | |
309 | } | |
310 | break; | |
311 | case 1: // 2000 | |
312 | switch ( closestBf ) | |
313 | { | |
314 | case 0: // 0.2 | |
315 | SetTrackerParam( 50, 100, 3, 10, | |
316 | 2, 4, | |
317 | 0, 0.1745, 5, 30, | |
318 | 5, 20, 50, 0.1, 0.1, kTRUE ); | |
319 | break; | |
320 | case 1: // 0.4 | |
321 | SetTrackerParam( 50, 100, 3, 10, | |
322 | 2, 5, | |
323 | 0, 0.1745, 5, 30, | |
324 | 5, 20, 50, 0.1, 0.1, kTRUE ); | |
325 | break; | |
326 | } | |
327 | break; | |
328 | case 2: // 4000 | |
329 | switch ( closestBf ) | |
330 | { | |
331 | case 0: // 0.2 | |
332 | SetTrackerParam( 50, 100, 3, 10, | |
333 | 2 , 10, | |
334 | 0, 0.1745, 5, 20, | |
335 | 5, 10 , 50, 0.1, 0.1, kTRUE ); | |
336 | break; | |
337 | case 1: // 0.4 | |
338 | SetTrackerParam( 50, 100, 3, 10, | |
339 | 2, 10, | |
340 | 0, 0.1745, 5, 20, | |
341 | 5, 10, 50, 0.1, 0.1, kTRUE ); | |
342 | break; | |
343 | } | |
344 | break; | |
345 | case 3: // 8000 | |
346 | switch ( closestBf ) | |
347 | { | |
348 | case 0: // 0.2 | |
349 | SetTrackerParam( 50, 100, 3, 10, | |
350 | 3, 15, | |
351 | 0, 0.1745, 5, 10, | |
352 | 5, 5, 50, 0.1, 0.1, kTRUE ); | |
353 | break; | |
354 | case 1: // 0.4 | |
355 | SetTrackerParam( 50, 100, 3, 10, | |
356 | 2, 15, | |
357 | 0, 0.1745, 5, 15, | |
358 | 5, 5, 50, 0.1, 0.1, kTRUE ); | |
359 | break; | |
360 | } | |
361 | break; | |
362 | } | |
738c049f | 363 | // Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] ); |
364 | // AliHLTTPCTransform::SetBField( bfs[closestBf] ); | |
365 | // AliHLTTPCTransform::SetBField( bField ); | |
366 | // Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField ); | |
71d7c760 | 367 | } |
368 | } | |
369 | ||
370 | ||
371 | ||
372 | int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv ) | |
373 | { | |
5df0cbb9 | 374 | // see header file for class documentation |
a6c02c85 | 375 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" ); |
a6c02c85 | 376 | |
71d7c760 | 377 | if ( fTracker || fVertex ) |
378 | return EINPROGRESS; | |
a6c02c85 | 379 | fTracker = new AliHLTTPCConfMapper(); |
380 | fVertex = new AliHLTTPCVertex(); | |
71d7c760 | 381 | fEta[0] = 0.; |
382 | fEta[1] = 1.1; | |
383 | fDoNonVertex = false; | |
ecefc48a | 384 | Bool_t bDoMerger=kTRUE; |
a6c02c85 | 385 | fMultiplicity = 4000; |
386 | fBField = 0.4; | |
387 | fDoPP = false; | |
71d7c760 | 388 | |
389 | int i = 0; | |
390 | char* cpErr; | |
391 | while ( i < argc ) | |
392 | { | |
ecefc48a | 393 | if ( !strcmp( argv[i], "disable-merger" ) ){ |
394 | bDoMerger = kFALSE; | |
395 | i++; | |
396 | continue; | |
397 | } | |
398 | ||
a6c02c85 | 399 | if ( !strcmp( argv[i], "pp-run" ) ) |
71d7c760 | 400 | { |
401 | fDoPP = true; | |
402 | i++; | |
403 | continue; | |
404 | } | |
a6c02c85 | 405 | if ( !strcmp( argv[i], "multiplicity" ) ) |
71d7c760 | 406 | { |
407 | if ( argc <= i+1 ) | |
408 | { | |
409 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Missing event multiplicity specifier." ); | |
410 | return ENOTSUP; | |
411 | } | |
412 | fMultiplicity = strtoul( argv[i+1], &cpErr, 0 ); | |
413 | if ( *cpErr ) | |
414 | { | |
415 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert event multiplicity specifier '%s'.", argv[i+1] ); | |
416 | return EINVAL; | |
417 | } | |
418 | i += 2; | |
419 | continue; | |
420 | } | |
a6c02c85 | 421 | if ( !strcmp( argv[i], "bfield" ) ) |
71d7c760 | 422 | { |
423 | if ( argc <= i+1 ) | |
424 | { | |
425 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing B-field", "Missing B-field specifier." ); | |
426 | return ENOTSUP; | |
427 | } | |
428 | fBField = strtod( argv[i+1], &cpErr ); | |
429 | if ( *cpErr ) | |
430 | { | |
431 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert B-field specifier '%s'.", argv[i+1] ); | |
432 | return EINVAL; | |
433 | } | |
434 | i += 2; | |
435 | continue; | |
436 | } | |
738c049f | 437 | |
438 | // BEGINN ############################################## MODIFIY JMT | |
439 | if ( !strcmp( argv[i], "nonvertextracking" ) ){ | |
440 | fnonvertextracking = kTRUE; | |
441 | i++; | |
442 | continue; | |
443 | } | |
444 | ||
445 | if ( !strcmp( argv[i], "mainvertextrackingoff" ) ){ | |
446 | fmainvertextracking = kFALSE; | |
447 | i++; | |
448 | continue; | |
449 | } | |
450 | ||
451 | if ( !strcmp( argv[i], "etarange" ) ){ | |
452 | if ( argc <= i+1 ){ | |
453 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Missing Eta-range specifiers." ); | |
454 | return ENOTSUP; | |
455 | } | |
456 | fEta[1] = strtod( argv[i+1], &cpErr ); | |
457 | if ( *cpErr ){ | |
458 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Cannot convert Eta-range specifier '%s'.", argv[i+1] ); | |
459 | return EINVAL; | |
460 | } | |
461 | ||
462 | i += 2; | |
463 | continue; | |
464 | } | |
465 | // END ################################################# MODIFIY JMT | |
71d7c760 | 466 | Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] ); |
467 | return EINVAL; | |
468 | } | |
db16520a | 469 | // #### -B0-CHANGE-START == JMT |
470 | if (fBField == 0.){ | |
471 | // parameter for B=0 T | |
472 | fDoPP = kTRUE; | |
473 | fnonvertextracking = kTRUE; | |
474 | fmainvertextracking = kFALSE; | |
475 | } | |
476 | // #### -B0-CHANGE-END == JMT | |
477 | ||
ecefc48a | 478 | if (bDoMerger) |
479 | fpInterMerger = new AliHLTTPCInterMerger(); | |
480 | ||
71d7c760 | 481 | SetTrackerParam( fDoPP, fMultiplicity, fBField ); |
482 | return 0; | |
483 | } | |
484 | ||
485 | int AliHLTTPCSliceTrackerComponent::DoDeinit() | |
ecefc48a | 486 | { |
5df0cbb9 | 487 | // see header file for class documentation |
ecefc48a | 488 | if ( fTracker ) |
489 | delete fTracker; | |
490 | fTracker = NULL; | |
491 | if ( fVertex ) | |
492 | delete fVertex; | |
493 | fVertex = NULL; | |
494 | if (fpInterMerger) { | |
495 | delete fpInterMerger; | |
496 | } | |
497 | fpInterMerger=NULL; | |
498 | return 0; | |
499 | } | |
71d7c760 | 500 | |
8ede8717 | 501 | int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, |
502 | AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, | |
503 | AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks ) | |
71d7c760 | 504 | { |
5df0cbb9 | 505 | // see header file for class documentation |
a6c02c85 | 506 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "DoEvent()" ); |
5235c3e9 | 507 | if ( evtData.fBlockCnt<=0 ) |
508 | { | |
509 | Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" ); | |
510 | return 0; | |
511 | } | |
8ede8717 | 512 | const AliHLTComponentBlockData* iter = NULL; |
71d7c760 | 513 | unsigned long ndx; |
514 | AliHLTTPCClusterData* inPtrSP; | |
a6c02c85 | 515 | AliHLTTPCVertexData* inPtrV = NULL; |
8ede8717 | 516 | const AliHLTComponentBlockData* vertexIter=NULL; |
71d7c760 | 517 | AliHLTTPCTrackletData* outPtr; |
518 | AliHLTUInt8_t* outBPtr; | |
519 | AliHLTUInt32_t vSize = 0; | |
520 | UInt_t offset=0, mysize, tSize = 0; | |
521 | outBPtr = outputPtr; | |
5235c3e9 | 522 | Int_t slice=-1, patch=-1, row[2]; |
71d7c760 | 523 | Int_t minPatch=INT_MAX, maxPatch = 0; |
524 | offset = 0; | |
525 | std::vector<Int_t> slices; | |
526 | std::vector<Int_t>::iterator slIter, slEnd; | |
527 | std::vector<unsigned> sliceCnts; | |
528 | std::vector<unsigned>::iterator slCntIter; | |
5235c3e9 | 529 | Int_t vertexSlice=-1; |
71d7c760 | 530 | |
531 | // Find min/max rows used in total and find and read out vertex if it is present | |
532 | // also determine correct slice number, if multiple slice numbers are present in event | |
533 | // (which should not happen in the first place) we use the one that occurs the most times | |
534 | row[0] = 0; | |
535 | row[1] = 0; | |
536 | bool found; | |
537 | for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) | |
538 | { | |
539 | iter = blocks+ndx; | |
540 | ||
541 | slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter ); | |
542 | found = false; | |
543 | slIter = slices.begin(); | |
544 | slEnd = slices.end(); | |
545 | slCntIter = sliceCnts.begin(); | |
546 | while ( slIter != slEnd ) | |
547 | { | |
548 | if ( *slIter == slice ) | |
549 | { | |
550 | found = true; | |
551 | break; | |
552 | } | |
553 | slIter++; | |
554 | slCntIter++; | |
555 | } | |
556 | if ( !found ) | |
557 | { | |
558 | slices.insert( slices.end(), slice ); | |
559 | sliceCnts.insert( sliceCnts.end(), 1 ); | |
560 | } | |
561 | else | |
562 | *slCntIter++; | |
563 | ||
96bda103 | 564 | if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType ) |
71d7c760 | 565 | { |
a6c02c85 | 566 | inPtrV = (AliHLTTPCVertexData*)(iter->fPtr); |
71d7c760 | 567 | vertexIter = iter; |
568 | vSize = iter->fSize; | |
569 | fVertex->Read( inPtrV ); | |
570 | vertexSlice = slice; | |
571 | } | |
96bda103 | 572 | if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType ) |
71d7c760 | 573 | { |
574 | patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter ); | |
575 | if ( minPatch>patch ) | |
576 | { | |
577 | minPatch = patch; | |
a6c02c85 | 578 | row[0] = AliHLTTPCTransform::GetFirstRow( patch ); |
71d7c760 | 579 | } |
580 | if ( maxPatch<patch ) | |
581 | { | |
582 | maxPatch = patch; | |
a6c02c85 | 583 | row[1] = AliHLTTPCTransform::GetLastRow( patch ); |
71d7c760 | 584 | } |
585 | } | |
586 | } | |
587 | ||
588 | // Determine slice number to really use. | |
589 | if ( slices.size()>1 ) | |
590 | { | |
591 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event", | |
592 | "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...", | |
593 | evtData.fEventID, evtData.fEventID ); | |
594 | unsigned maxCntSlice=0; | |
595 | slIter = slices.begin(); | |
596 | slEnd = slices.end(); | |
597 | slCntIter = sliceCnts.begin(); | |
598 | while ( slIter != slEnd ) | |
599 | { | |
600 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event", | |
601 | "Slice %lu found %lu times.", *slIter, *slCntIter ); | |
602 | if ( maxCntSlice<*slCntIter ) | |
603 | { | |
604 | maxCntSlice = *slCntIter; | |
605 | slice = *slIter; | |
606 | } | |
607 | slIter++; | |
608 | slCntIter++; | |
609 | } | |
610 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event", | |
611 | "Using slice %lu.", slice ); | |
612 | } | |
5235c3e9 | 613 | else if ( slices.size()>0 ) |
614 | { | |
71d7c760 | 615 | slice = *(slices.begin()); |
5235c3e9 | 616 | } |
617 | else | |
618 | { | |
619 | slice = -1; | |
620 | } | |
71d7c760 | 621 | |
622 | if ( vertexSlice != slice ) | |
623 | { | |
624 | // multiple vertex blocks in event and we used the wrong one... | |
625 | found = false; | |
626 | for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) | |
627 | { | |
628 | iter = blocks+ndx; | |
96bda103 | 629 | if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) ) |
71d7c760 | 630 | { |
a6c02c85 | 631 | inPtrV = (AliHLTTPCVertexData*)(iter->fPtr); |
71d7c760 | 632 | vertexIter = iter; |
633 | vSize = iter->fSize; | |
634 | fVertex->Read( inPtrV ); | |
635 | break; | |
636 | } | |
637 | } | |
638 | } | |
639 | ||
640 | fTracker->InitSector( slice, row, fEta ); | |
641 | fTracker->SetVertex(fVertex); | |
642 | mysize = 0; | |
643 | // read in all hits | |
a6c02c85 | 644 | std::vector<unsigned long> patchIndices; |
645 | std::vector<unsigned long>::iterator pIter, pEnd; | |
71d7c760 | 646 | for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) |
647 | { | |
648 | iter = blocks+ndx; | |
649 | ||
96bda103 | 650 | if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) ) |
71d7c760 | 651 | { |
652 | patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter ); | |
a6c02c85 | 653 | pIter = patchIndices.begin(); |
654 | pEnd = patchIndices.end(); | |
655 | while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch ) | |
656 | pIter++; | |
657 | patchIndices.insert( pIter, ndx ); | |
71d7c760 | 658 | } |
659 | } | |
a6c02c85 | 660 | pIter = patchIndices.begin(); |
661 | pEnd = patchIndices.end(); | |
662 | while ( pIter!=pEnd ) | |
663 | { | |
664 | ndx = *pIter; | |
665 | iter = blocks+ndx; | |
666 | ||
667 | patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter ); | |
668 | inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr); | |
669 | ||
670 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits", | |
671 | "Reading hits for slice %d - patch %d", slice, patch ); | |
672 | fTracker->ReadHits( inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints ); | |
673 | pIter++; | |
674 | } | |
71d7c760 | 675 | |
676 | outPtr = (AliHLTTPCTrackletData*)(outBPtr); | |
738c049f | 677 | // BEGINN ############################################## MODIFIY JMT |
678 | #if 1 | |
679 | fTracker->SetPointers(); | |
680 | if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){ | |
681 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---"); | |
2a083ac4 | 682 | fTracker->MainVertexTrackingA(); |
683 | fTracker->MainVertexTrackingB(); | |
738c049f | 684 | fTracker->FillTracks(); |
685 | } | |
686 | else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){ | |
687 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---"); | |
2a083ac4 | 688 | fTracker->MainVertexTrackingA(); |
689 | fTracker->MainVertexTrackingB(); | |
738c049f | 690 | fTracker->FillTracks(); |
691 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---"); | |
692 | fTracker->NonVertexTracking(); | |
693 | } | |
694 | else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){ | |
695 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---"); | |
696 | fTracker->NonVertexTracking(); | |
697 | fTracker->FillTracks(); | |
698 | } | |
699 | #else | |
71d7c760 | 700 | fTracker->MainVertexTracking_a(); |
701 | fTracker->MainVertexTracking_b(); | |
702 | fTracker->FillTracks(); | |
703 | ||
704 | if ( fDoNonVertex ) | |
705 | fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks | |
738c049f | 706 | #endif |
707 | // END ################################################# MODIFIY JMT | |
71d7c760 | 708 | |
ecefc48a | 709 | UInt_t ntracks0 =0; |
710 | if(fpInterMerger){ | |
711 | AliHLTTPCMemHandler memory; | |
712 | AliHLTTPCTrackSegmentData *trackdata0 = | |
713 | (AliHLTTPCTrackSegmentData *) memory.Allocate(fTracker->GetTracks()); | |
714 | memory.TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks()); | |
715 | fpInterMerger->Reset(); | |
716 | fpInterMerger->Init(row,patch); | |
717 | fpInterMerger->FillTracks(ntracks0,trackdata0); | |
718 | fpInterMerger->Merge(); | |
719 | } | |
720 | ntracks0=0; | |
5df0cbb9 | 721 | AliHLTTPCTrackArray* pArray=fTracker->GetTracks(); |
722 | mysize = pArray->WriteTracks( ntracks0, outPtr->fTracklets ); | |
71d7c760 | 723 | outPtr->fTrackletCnt = ntracks0; |
ecefc48a | 724 | |
71d7c760 | 725 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks", |
726 | "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.", | |
727 | ntracks0, slice, minPatch, maxPatch, row[0], row[1] ); | |
728 | ||
729 | tSize += mysize+sizeof(AliHLTTPCTrackletData); | |
730 | outBPtr += mysize+sizeof(AliHLTTPCTrackletData); | |
731 | ||
8ede8717 | 732 | AliHLTComponentBlockData bd; |
71d7c760 | 733 | FillBlockData( bd ); |
734 | bd.fOffset = offset; | |
735 | bd.fSize = tSize; | |
736 | bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch ); | |
737 | outputBlocks.push_back( bd ); | |
738 | ||
739 | #ifdef FORWARD_VERTEX_BLOCK | |
740 | if ( vertexIter ) | |
741 | { | |
742 | // Copy the descriptor block for the vertex information. | |
743 | bd = *vertexIter; | |
744 | outputBlocks.push_back( bd ); | |
745 | } | |
746 | #endif // FORWARD_VERTEX_BLOCK | |
747 | ||
748 | size = tSize; | |
749 | return 0; | |
750 | } | |
751 | ||
5df0cbb9 | 752 | void AliHLTTPCSliceTrackerComponent::SetTrackerParam1() |
753 | { | |
754 | SetTrackerParam( 10, 20, 5, 10, 2,2, | |
755 | 0, 1.31, 5, 100, | |
756 | 50, 100, 50, 0.1, 0.1, | |
757 | true ); | |
758 | } | |
759 | ||
71d7c760 | 760 |