]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bugfix: static member was not implemented
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCSliceTrackerComponent.cxx
CommitLineData
71d7c760 1// $Id$
2
3/**************************************************************************
4 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5 * *
6 * Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
7 * Timm Steinbeck <timm@kip.uni-heidelberg.de> *
8 * for The ALICE Off-line 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. *
17 **************************************************************************/
18
19///////////////////////////////////////////////////////////////////////////////
20// //
21// a TPC sector tracker processing component for the HLT //
22// //
23///////////////////////////////////////////////////////////////////////////////
24
db16520a 25#if __GNUC__>= 3
71d7c760 26using namespace std;
27#endif
28
29#include "AliHLTTPCSliceTrackerComponent.h"
a6c02c85 30#include "AliHLTTPCTransform.h"
31#include "AliHLTTPCConfMapper.h"
32#include "AliHLTTPCVertex.h"
33#include "AliHLTTPCSpacePointData.h"
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"
a7c32962 40//#include "AliHLTTPC.h"
71d7c760 41#include <stdlib.h>
42#include <errno.h>
43
44// this is a global object used for automatic component registration, do not use this
45AliHLTTPCSliceTrackerComponent gAliHLTTPCSliceTrackerComponent;
46
47ClassImp(AliHLTTPCSliceTrackerComponent)
48
49AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
50 {
51 fTracker = NULL;
52 fVertex = NULL;
53 fEta[0] = 0.;
54 fEta[1] = 1.1;
55 fDoNonVertex = false;
a6c02c85 56 fMultiplicity = 4000;
57 fBField = 0.4;
58 fDoPP = false;
738c049f 59// BEGINN ############################################## MODIFIY JMT
60 fnonvertextracking = kFALSE; // enable NONVERTEX Tracking
61 fmainvertextracking = kTRUE; // enable MAINVERTEX Tracking
62// END ################################################# MODIFIY JMT
71d7c760 63 }
64
65AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
66 {
67 }
68
69// Public functions to implement AliHLTComponent's interface.
70// These functions are required for the registration process
71
72const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
73 {
74 return "TPCSliceTracker";
75 }
76
8ede8717 77void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
71d7c760 78 {
79 list.clear();
80 list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
81 list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
82 }
83
8ede8717 84AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
71d7c760 85 {
86 return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
87 }
88
89void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
90 {
91 // XXX TODO: Find more realistic values.
92 constBase = 0;
93 inputMultiplier = 0.2;
94 }
95
96AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
97 {
98 return new AliHLTTPCSliceTrackerComponent;
99 }
100
101void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
102 Int_t trackletlength, Int_t tracklength,
103 Int_t rowscopetracklet, Int_t rowscopetrack,
104 Double_t min_pt_fit, Double_t maxangle,
105 Double_t goodDist, Double_t hitChi2Cut,
106 Double_t goodHitChi2, Double_t trackChi2Cut,
107 Int_t maxdist, Double_t maxphi,Double_t maxeta, bool vertexConstraints )
108 {
109 //fTracker->SetClusterFinderParam( fXYClusterError, fZClusterError, kTRUE ); // ??
110 //Set parameters input to the tracker
111 //If no arguments are given, default parameters will be used
112
113 fTracker->SetNSegments(phi_segments,eta_segments);
114 fTracker->SetMaxDca(min_pt_fit);
115 // fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
738c049f 116
117// BEGINN ############################################## MODIFIY JMT
118#if 1
db16520a 119 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
738c049f 120
121 if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
122 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
123 fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
124
125 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
db16520a 126 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
738c049f 127 }
128 else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
129 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
130 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
131 fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
132 fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
133
134 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
135 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
db16520a 136 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
738c049f 137 }
138 else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
139 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
140 fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
141
142 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
db16520a 143 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
738c049f 144 }
145#else
71d7c760 146 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexConstraints);
147 fTracker->SetTrackletCuts(maxangle,goodDist,vertexConstraints);
148
149 if( vertexConstraints )
150 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
151 else
152 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
738c049f 153#endif
154// END ################################################# MODIFIY JMT
a6c02c85 155
738c049f 156 //fTracker->SetParamDone(true);
a7c32962 157 /* Matthias 13.12.2006
158 * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
159 * and has always been kTRUE.
160 * In order to remove the AliHLTTPC class (which is the old steering class for
161 * HLT (TPC) tracking) from the compilation, this function can not be activated
162 * again. We have to think about a more elegant way to specify the parameters
163 * anyway. The following line was surely for some testing, but was never active
164 * in a tested release.
165 */
a6c02c85 166 //AliHLTTPC::SetVertexFit( kFALSE );
71d7c760 167
168 fTracker->InitVolumes();
169 }
170
171void AliHLTTPCSliceTrackerComponent::SetTrackerParam( bool doPP, int multiplicity, double bField )
172 {
738c049f 173 AliHLTTPCTransform::SetBField( bField );
db16520a 174 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField );
738c049f 175
71d7c760 176 if ( doPP )
177 {
178 //tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ??
179 SetTrackerParam( 50, 100, 3, 10,
180 2, 2,
181 0, 0.1745, 5, 100,
182 5, 50, 50, 0.1, 0.1, kTRUE);
183 }
184 else
185 {
186 int mults[] = { 1000, 2000, 4000, 8000 };
187 int multCount = 4;
188 int closestMult = 0;
189 int i;
190 int multDist, tmpMultDist;
191 if ( multiplicity>mults[closestMult] )
192 multDist = multiplicity-mults[closestMult];
193 else
194 multDist = mults[closestMult]-multiplicity;
195 for ( i = 1; i < multCount; i++ )
196 {
197 if ( multiplicity>mults[i] )
198 tmpMultDist = multiplicity-mults[i];
199 else
200 tmpMultDist = mults[i]-multiplicity;
201 if ( tmpMultDist < multDist )
202 {
203 closestMult = i;
204 multDist = tmpMultDist;
205 }
206 }
207
208 double bfs[] = { 0.2, 0.4 };
209 int bfCount = 2;
210 int closestBf = 0;
211 double bfDist, tmpBFDist;
212 if ( bField>bfs[closestBf] )
213 bfDist = bField-bfs[closestBf];
214 else
215 bfDist = bfs[closestBf]-bField;
216 for ( i = 1; i < bfCount; i++ )
217 {
218 if ( bField>bfs[i] )
219 tmpBFDist = bField-bfs[i];
220 else
221 tmpBFDist = bfs[i]-bField;
222 if ( tmpBFDist < bfDist )
223 {
224 closestBf = i;
225 bfDist = tmpBFDist;
226 }
227 }
228
229 switch ( closestMult )
230 {
231 case 0: // 1000
232 switch ( closestBf )
233 {
234 case 0: // 0.2
235 SetTrackerParam( 50, 100, 3, 10,
236 2, 4,
237 0, 0.1745, 5, 100,
238 5, 50, 50, 0.1, 0.1, kTRUE );
239 break;
240 case 1: // 0.4
241 SetTrackerParam( 50, 100, 3, 10,
242 2, 4,
243 0, 0.1745, 5, 100,
244 5, 50, 50, 0.1, 0.1, kTRUE );
245 break;
246 }
247 break;
248 case 1: // 2000
249 switch ( closestBf )
250 {
251 case 0: // 0.2
252 SetTrackerParam( 50, 100, 3, 10,
253 2, 4,
254 0, 0.1745, 5, 30,
255 5, 20, 50, 0.1, 0.1, kTRUE );
256 break;
257 case 1: // 0.4
258 SetTrackerParam( 50, 100, 3, 10,
259 2, 5,
260 0, 0.1745, 5, 30,
261 5, 20, 50, 0.1, 0.1, kTRUE );
262 break;
263 }
264 break;
265 case 2: // 4000
266 switch ( closestBf )
267 {
268 case 0: // 0.2
269 SetTrackerParam( 50, 100, 3, 10,
270 2 , 10,
271 0, 0.1745, 5, 20,
272 5, 10 , 50, 0.1, 0.1, kTRUE );
273 break;
274 case 1: // 0.4
275 SetTrackerParam( 50, 100, 3, 10,
276 2, 10,
277 0, 0.1745, 5, 20,
278 5, 10, 50, 0.1, 0.1, kTRUE );
279 break;
280 }
281 break;
282 case 3: // 8000
283 switch ( closestBf )
284 {
285 case 0: // 0.2
286 SetTrackerParam( 50, 100, 3, 10,
287 3, 15,
288 0, 0.1745, 5, 10,
289 5, 5, 50, 0.1, 0.1, kTRUE );
290 break;
291 case 1: // 0.4
292 SetTrackerParam( 50, 100, 3, 10,
293 2, 15,
294 0, 0.1745, 5, 15,
295 5, 5, 50, 0.1, 0.1, kTRUE );
296 break;
297 }
298 break;
299 }
738c049f 300// Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
301// AliHLTTPCTransform::SetBField( bfs[closestBf] );
302// AliHLTTPCTransform::SetBField( bField );
303// Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField );
71d7c760 304 }
305 }
306
307
308
309int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv )
310 {
a6c02c85 311 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
a6c02c85 312
71d7c760 313 if ( fTracker || fVertex )
314 return EINPROGRESS;
a6c02c85 315 fTracker = new AliHLTTPCConfMapper();
316 fVertex = new AliHLTTPCVertex();
71d7c760 317 fEta[0] = 0.;
318 fEta[1] = 1.1;
319 fDoNonVertex = false;
a6c02c85 320 fMultiplicity = 4000;
321 fBField = 0.4;
322 fDoPP = false;
71d7c760 323
324 int i = 0;
325 char* cpErr;
326 while ( i < argc )
327 {
a6c02c85 328 if ( !strcmp( argv[i], "pp-run" ) )
71d7c760 329 {
330 fDoPP = true;
331 i++;
332 continue;
333 }
a6c02c85 334 if ( !strcmp( argv[i], "multiplicity" ) )
71d7c760 335 {
336 if ( argc <= i+1 )
337 {
338 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Missing event multiplicity specifier." );
339 return ENOTSUP;
340 }
341 fMultiplicity = strtoul( argv[i+1], &cpErr, 0 );
342 if ( *cpErr )
343 {
344 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert event multiplicity specifier '%s'.", argv[i+1] );
345 return EINVAL;
346 }
347 i += 2;
348 continue;
349 }
a6c02c85 350 if ( !strcmp( argv[i], "bfield" ) )
71d7c760 351 {
352 if ( argc <= i+1 )
353 {
354 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing B-field", "Missing B-field specifier." );
355 return ENOTSUP;
356 }
357 fBField = strtod( argv[i+1], &cpErr );
358 if ( *cpErr )
359 {
360 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert B-field specifier '%s'.", argv[i+1] );
361 return EINVAL;
362 }
363 i += 2;
364 continue;
365 }
738c049f 366
367// BEGINN ############################################## MODIFIY JMT
368 if ( !strcmp( argv[i], "nonvertextracking" ) ){
369 fnonvertextracking = kTRUE;
370 i++;
371 continue;
372 }
373
374 if ( !strcmp( argv[i], "mainvertextrackingoff" ) ){
375 fmainvertextracking = kFALSE;
376 i++;
377 continue;
378 }
379
380 if ( !strcmp( argv[i], "etarange" ) ){
381 if ( argc <= i+1 ){
382 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Missing Eta-range specifiers." );
383 return ENOTSUP;
384 }
385 fEta[1] = strtod( argv[i+1], &cpErr );
386 if ( *cpErr ){
387 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Cannot convert Eta-range specifier '%s'.", argv[i+1] );
388 return EINVAL;
389 }
390
391 i += 2;
392 continue;
393 }
394// END ################################################# MODIFIY JMT
71d7c760 395 Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
396 return EINVAL;
397 }
db16520a 398// #### -B0-CHANGE-START == JMT
399 if (fBField == 0.){
400 // parameter for B=0 T
401 fDoPP = kTRUE;
402 fnonvertextracking = kTRUE;
403 fmainvertextracking = kFALSE;
404 }
405// #### -B0-CHANGE-END == JMT
406
71d7c760 407 SetTrackerParam( fDoPP, fMultiplicity, fBField );
408 return 0;
409 }
410
411int AliHLTTPCSliceTrackerComponent::DoDeinit()
412 {
413 if ( fTracker )
414 delete fTracker;
415 fTracker = NULL;
416 if ( fVertex )
417 delete fVertex;
418 fVertex = NULL;
419 return 0;
420 }
421
8ede8717 422int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
423 AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
424 AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
71d7c760 425 {
a6c02c85 426 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "DoEvent()" );
5235c3e9 427 if ( evtData.fBlockCnt<=0 )
428 {
429 Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" );
430 return 0;
431 }
8ede8717 432 const AliHLTComponentBlockData* iter = NULL;
71d7c760 433 unsigned long ndx;
434 AliHLTTPCClusterData* inPtrSP;
a6c02c85 435 AliHLTTPCVertexData* inPtrV = NULL;
8ede8717 436 const AliHLTComponentBlockData* vertexIter=NULL;
71d7c760 437 AliHLTTPCTrackletData* outPtr;
438 AliHLTUInt8_t* outBPtr;
439 AliHLTUInt32_t vSize = 0;
440 UInt_t offset=0, mysize, tSize = 0;
441 outBPtr = outputPtr;
5235c3e9 442 Int_t slice=-1, patch=-1, row[2];
71d7c760 443 Int_t minPatch=INT_MAX, maxPatch = 0;
444 offset = 0;
445 std::vector<Int_t> slices;
446 std::vector<Int_t>::iterator slIter, slEnd;
447 std::vector<unsigned> sliceCnts;
448 std::vector<unsigned>::iterator slCntIter;
5235c3e9 449 Int_t vertexSlice=-1;
71d7c760 450
451 // Find min/max rows used in total and find and read out vertex if it is present
452 // also determine correct slice number, if multiple slice numbers are present in event
453 // (which should not happen in the first place) we use the one that occurs the most times
454 row[0] = 0;
455 row[1] = 0;
456 bool found;
457 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
458 {
459 iter = blocks+ndx;
460
461 slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
462 found = false;
463 slIter = slices.begin();
464 slEnd = slices.end();
465 slCntIter = sliceCnts.begin();
466 while ( slIter != slEnd )
467 {
468 if ( *slIter == slice )
469 {
470 found = true;
471 break;
472 }
473 slIter++;
474 slCntIter++;
475 }
476 if ( !found )
477 {
478 slices.insert( slices.end(), slice );
479 sliceCnts.insert( sliceCnts.end(), 1 );
480 }
481 else
482 *slCntIter++;
483
484 if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
485 {
a6c02c85 486 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
71d7c760 487 vertexIter = iter;
488 vSize = iter->fSize;
489 fVertex->Read( inPtrV );
490 vertexSlice = slice;
491 }
492 if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
493 {
494 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
495 if ( minPatch>patch )
496 {
497 minPatch = patch;
a6c02c85 498 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
71d7c760 499 }
500 if ( maxPatch<patch )
501 {
502 maxPatch = patch;
a6c02c85 503 row[1] = AliHLTTPCTransform::GetLastRow( patch );
71d7c760 504 }
505 }
506 }
507
508 // Determine slice number to really use.
509 if ( slices.size()>1 )
510 {
511 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
512 "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
513 evtData.fEventID, evtData.fEventID );
514 unsigned maxCntSlice=0;
515 slIter = slices.begin();
516 slEnd = slices.end();
517 slCntIter = sliceCnts.begin();
518 while ( slIter != slEnd )
519 {
520 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
521 "Slice %lu found %lu times.", *slIter, *slCntIter );
522 if ( maxCntSlice<*slCntIter )
523 {
524 maxCntSlice = *slCntIter;
525 slice = *slIter;
526 }
527 slIter++;
528 slCntIter++;
529 }
530 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
531 "Using slice %lu.", slice );
532 }
5235c3e9 533 else if ( slices.size()>0 )
534 {
71d7c760 535 slice = *(slices.begin());
5235c3e9 536 }
537 else
538 {
539 slice = -1;
540 }
71d7c760 541
542 if ( vertexSlice != slice )
543 {
544 // multiple vertex blocks in event and we used the wrong one...
545 found = false;
546 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
547 {
548 iter = blocks+ndx;
549 if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
550 {
a6c02c85 551 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
71d7c760 552 vertexIter = iter;
553 vSize = iter->fSize;
554 fVertex->Read( inPtrV );
555 break;
556 }
557 }
558 }
559
560 fTracker->InitSector( slice, row, fEta );
561 fTracker->SetVertex(fVertex);
562 mysize = 0;
563 // read in all hits
a6c02c85 564 std::vector<unsigned long> patchIndices;
565 std::vector<unsigned long>::iterator pIter, pEnd;
71d7c760 566 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
567 {
568 iter = blocks+ndx;
569
570 if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
571 {
572 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
a6c02c85 573 pIter = patchIndices.begin();
574 pEnd = patchIndices.end();
575 while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
576 pIter++;
577 patchIndices.insert( pIter, ndx );
71d7c760 578 }
579 }
a6c02c85 580 pIter = patchIndices.begin();
581 pEnd = patchIndices.end();
582 while ( pIter!=pEnd )
583 {
584 ndx = *pIter;
585 iter = blocks+ndx;
586
587 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
588 inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
589
590 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits",
591 "Reading hits for slice %d - patch %d", slice, patch );
592 fTracker->ReadHits( inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints );
593 pIter++;
594 }
71d7c760 595
596 outPtr = (AliHLTTPCTrackletData*)(outBPtr);
738c049f 597// BEGINN ############################################## MODIFIY JMT
598#if 1
599 fTracker->SetPointers();
600 if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
601 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
2a083ac4 602 fTracker->MainVertexTrackingA();
603 fTracker->MainVertexTrackingB();
738c049f 604 fTracker->FillTracks();
605 }
606 else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
607 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
2a083ac4 608 fTracker->MainVertexTrackingA();
609 fTracker->MainVertexTrackingB();
738c049f 610 fTracker->FillTracks();
611 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
612 fTracker->NonVertexTracking();
613 }
614 else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
615 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
616 fTracker->NonVertexTracking();
617 fTracker->FillTracks();
618 }
619#else
71d7c760 620 fTracker->MainVertexTracking_a();
621 fTracker->MainVertexTracking_b();
622 fTracker->FillTracks();
623
624 if ( fDoNonVertex )
625 fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
738c049f 626#endif
627// END ################################################# MODIFIY JMT
71d7c760 628 // XXX Do track merging??
629
630 UInt_t ntracks0=0;
631 mysize = fTracker->GetTracks()->WriteTracks( ntracks0, outPtr->fTracklets );
632 outPtr->fTrackletCnt = ntracks0;
633
634 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks",
635 "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.",
636 ntracks0, slice, minPatch, maxPatch, row[0], row[1] );
637
638 tSize += mysize+sizeof(AliHLTTPCTrackletData);
639 outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
640
8ede8717 641 AliHLTComponentBlockData bd;
71d7c760 642 FillBlockData( bd );
643 bd.fOffset = offset;
644 bd.fSize = tSize;
645 bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
646 outputBlocks.push_back( bd );
647
648#ifdef FORWARD_VERTEX_BLOCK
649 if ( vertexIter )
650 {
651 // Copy the descriptor block for the vertex information.
652 bd = *vertexIter;
653 outputBlocks.push_back( bd );
654 }
655#endif // FORWARD_VERTEX_BLOCK
656
657 size = tSize;
658 return 0;
659 }
660
661