]> 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
code documentation
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCSliceTrackerComponent.cxx
CommitLineData
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
e67b0680 26// see header file for class documentation
27// or
28// refer to README to build package
29// or
30// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
31
db16520a 32#if __GNUC__>= 3
71d7c760 33using namespace std;
34#endif
35
36#include "AliHLTTPCSliceTrackerComponent.h"
a6c02c85 37#include "AliHLTTPCTransform.h"
38#include "AliHLTTPCConfMapper.h"
39#include "AliHLTTPCVertex.h"
a6c02c85 40#include "AliHLTTPCVertexData.h"
71d7c760 41#include "AliHLTTPCClusterDataFormat.h"
a6c02c85 42#include "AliHLTTPCTransform.h"
43#include "AliHLTTPCTrackSegmentData.h"
44#include "AliHLTTPCTrackArray.h"
71d7c760 45#include "AliHLTTPCTrackletDataFormat.h"
ecefc48a 46#include "AliHLTTPCInterMerger.h"
47#include "AliHLTTPCMemHandler.h"
5df0cbb9 48#include "AliHLTTPCDefinitions.h"
669159ae 49#include "TString.h"
50#include "TObjString.h"
51#include "TObjArray.h"
52#include "AliCDBEntry.h"
53#include "AliCDBManager.h"
a7c32962 54//#include "AliHLTTPC.h"
5df0cbb9 55//#include <stdlib.h>
56//#include <cerrno>
71d7c760 57
58// this is a global object used for automatic component registration, do not use this
59AliHLTTPCSliceTrackerComponent gAliHLTTPCSliceTrackerComponent;
60
5df0cbb9 61/** ROOT macro for the implementation of ROOT specific class methods */
71d7c760 62ClassImp(AliHLTTPCSliceTrackerComponent)
63
64AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
6235cd38 65 :
66 fTracker(NULL),
67 fVertex(NULL),
68 fDoNonVertex(false),
ecefc48a 69 fDoPP(false),
e6421c43 70 fDoPbPb(false),
6235cd38 71 fMultiplicity(4000),
72 fBField(0.4),
6235cd38 73 fnonvertextracking(kFALSE),
ecefc48a 74 fmainvertextracking(kTRUE),
e6421c43 75 fpInterMerger(NULL),
76 fPhisegment(50),
77 fEtasegment(100),
78 fTrackletlength(3),
79 fTracklength(60),
80 fRowscopetracklet(6),
81 fRowscopetrack(6),
82 fMinPtFit(0),
83 fMaxangle(0.1745),
84 fGoodDist(5),
85 fHitChi2Cut(100),
86 fGoodHitChi2(5),
87 fTrackChi2Cut(50),
88 fMaxdist(50),
89 fMaxphi(0.1),
90 fMaxeta(0.1)
6235cd38 91{
92 // see header file for class documentation
93 // or
94 // refer to README to build package
95 // or
96 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
97 fEta[0] = 0.;
98 fEta[1] = 1.1;
99}
100
71d7c760 101AliHLTTPCSliceTrackerComponent::~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
109const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
6235cd38 110{
5df0cbb9 111 // see header file for class documentation
6235cd38 112
113 return "TPCSliceTracker";
114}
71d7c760 115
7bcd6cad 116void AliHLTTPCSliceTrackerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& 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 124AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
6235cd38 125{
5df0cbb9 126 // see header file for class documentation
96bda103 127 return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
6235cd38 128}
71d7c760 129
130void 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;
e6421c43 135 inputMultiplier = 1;
6235cd38 136}
71d7c760 137
138AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
6235cd38 139{
5df0cbb9 140 // see header file for class documentation
6235cd38 141 return new AliHLTTPCSliceTrackerComponent;
142}
71d7c760 143
6235cd38 144void 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,
e6421c43 150 Int_t maxdist, Double_t maxphi,Double_t maxeta)
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
db16520a 161 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
738c049f 162
163 if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
164 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
165 fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
166
167 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
db16520a 168 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
738c049f 169 }
170 else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
171 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
172 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
173 fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
174 fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
175
176 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
177 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
db16520a 178 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
738c049f 179 }
180 else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
181 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
182 fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
183
184 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
db16520a 185 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
738c049f 186 }
71d7c760 187
738c049f 188 //fTracker->SetParamDone(true);
a7c32962 189 /* Matthias 13.12.2006
190 * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
191 * and has always been kTRUE.
192 * In order to remove the AliHLTTPC class (which is the old steering class for
193 * HLT (TPC) tracking) from the compilation, this function can not be activated
194 * again. We have to think about a more elegant way to specify the parameters
195 * anyway. The following line was surely for some testing, but was never active
196 * in a tested release.
197 */
a6c02c85 198 //AliHLTTPC::SetVertexFit( kFALSE );
71d7c760 199
200 fTracker->InitVolumes();
201 }
202
738c049f 203
e6421c43 204void AliHLTTPCSliceTrackerComponent::SetTrackerParam( Bool_t doPP, Bool_t doPbPb, Int_t multiplicity,
205 Double_t bField, Int_t etasegment, Double_t hitchi2cut,
206 Int_t rowscopetracklet, Int_t rowscopetrack,
207 Int_t trackletlength, Int_t tracklength )
208{
209 // see header file for class documentation
210 AliHLTTPCTransform::SetBField( bField );
211 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField );
212
213 if ( doPP )
214 {
215 //tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ??
216
217 SetTrackerParam( 50, 100, 3, 10,
218 2, 2,
219 0, 0.1745, 5, 100,
220 5, 50, 50, 0.1, 0.1);
221 }
222 else if(doPbPb)
223 {
224 int mults[] = { 1000, 2000, 4000, 8000 };
225 int multCount = 4;
226 int closestMult = 0;
227 int i;
228 int multDist, tmpMultDist;
229 if ( multiplicity>mults[closestMult] )
230 multDist = multiplicity-mults[closestMult];
231 else
232 multDist = mults[closestMult]-multiplicity;
233 for ( i = 1; i < multCount; i++ )
71d7c760 234 {
e6421c43 235 if ( multiplicity>mults[i] )
236 tmpMultDist = multiplicity-mults[i];
237 else
238 tmpMultDist = mults[i]-multiplicity;
239 if ( tmpMultDist < multDist )
240 {
241 closestMult = i;
242 multDist = tmpMultDist;
243 }
71d7c760 244 }
e6421c43 245
246 double bfs[] = { 0.2, 0.4 };
247 int bfCount = 2;
248 int closestBf = 0;
249 double bfDist, tmpBFDist;
250 if ( bField>bfs[closestBf] )
251 bfDist = bField-bfs[closestBf];
252 else
253 bfDist = bfs[closestBf]-bField;
254 for ( i = 1; i < bfCount; i++ )
71d7c760 255 {
e6421c43 256 if ( bField>bfs[i] )
257 tmpBFDist = bField-bfs[i];
258 else
259 tmpBFDist = bfs[i]-bField;
260 if ( tmpBFDist < bfDist )
71d7c760 261 {
e6421c43 262 closestBf = i;
263 bfDist = tmpBFDist;
71d7c760 264 }
e6421c43 265 }
266
267 switch ( closestMult )
268 {
269 case 0: // 1000
270 switch ( closestBf )
71d7c760 271 {
e6421c43 272 case 0: // 0.2
273 SetTrackerParam( 50, 100, 3, 10,
274 2, 4,
275 0, 0.1745, 5, 100,
276 5, 50, 50, 0.1, 0.1);
277 break;
278 case 1: // 0.4
279 SetTrackerParam( 50, 100, 3, 10,
280 2, 4,
281 0, 0.1745, 5, 100,
282 5, 50, 50, 0.1, 0.1);
283 break;
71d7c760 284 }
e6421c43 285 break;
286 case 1: // 2000
287 switch ( closestBf )
71d7c760 288 {
e6421c43 289 case 0: // 0.2
290 SetTrackerParam( 50, 100, 3, 10,
291 2, 4,
292 0, 0.1745, 5, 30,
293 5, 20, 50, 0.1, 0.1);
294 break;
295 case 1: // 0.4
296 SetTrackerParam( 50, 100, 3, 10,
297 2, 5,
298 0, 0.1745, 5, 30,
299 5, 20, 50, 0.1, 0.1);
300 break;
301 }
302 break;
303 case 2: // 4000
304 switch ( closestBf )
305 {
306 case 0: // 0.2
307 SetTrackerParam( 50, 100, 3, 10,
308 2 , 10,
309 0, 0.1745, 5, 20,
310 5, 10 , 50, 0.1, 0.1);
311 break;
312 case 1: // 0.4
313 SetTrackerParam( 50, 100, 3, 10,
314 2, 10,
315 0, 0.1745, 5, 20,
316 5, 10, 50, 0.1, 0.1);
317 break;
318 }
319 break;
320 case 3: // 8000
321 switch ( closestBf )
322 {
323 case 0: // 0.2
324 SetTrackerParam( 50, 100, 3, 10,
325 3, 15,
326 0, 0.1745, 5, 10,
327 5, 5, 50, 0.1, 0.1);
328 break;
329 case 1: // 0.4
330 SetTrackerParam( 50, 100, 3, 10,
331 2, 15,
332 0, 0.1745, 5, 15,
333 5, 5, 50, 0.1, 0.1);
334 break;
71d7c760 335 }
e6421c43 336 break;
71d7c760 337 }
e6421c43 338 // Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
339 // AliHLTTPCTransform::SetBField( bfs[closestBf] );
340 // AliHLTTPCTransform::SetBField( bField );
341 // Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField );
71d7c760 342 }
e6421c43 343 else
344 {
345 SetTrackerParam( 50, etasegment, trackletlength, tracklength,
346 rowscopetracklet, rowscopetrack,
347 0, 0.1745, 5, hitchi2cut,
348 5, 50, 50, 0.1, 0.1);
349 }
350}
71d7c760 351
352int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv )
353 {
5df0cbb9 354 // see header file for class documentation
a6c02c85 355 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
a6c02c85 356
71d7c760 357 if ( fTracker || fVertex )
358 return EINPROGRESS;
a6c02c85 359 fTracker = new AliHLTTPCConfMapper();
360 fVertex = new AliHLTTPCVertex();
71d7c760 361 fEta[0] = 0.;
362 fEta[1] = 1.1;
363 fDoNonVertex = false;
a6c02c85 364 fMultiplicity = 4000;
e6421c43 365 fBField = 0.5;
a6c02c85 366 fDoPP = false;
e6421c43 367 fDoPbPb = false;
368 fPhisegment=50;
369 fEtasegment=100;
370 fTrackletlength=3;
371 fTracklength=60;
372 fRowscopetracklet=6;
373 fRowscopetrack=6;
374 fMinPtFit=0;
375 fMaxangle=0.1745;
376 fGoodDist=5;
377 fHitChi2Cut=100;
378 fGoodHitChi2=5;
379 fTrackChi2Cut=50;
380 fMaxdist=50;
381 fMaxphi=0.1;
382 fMaxeta=0.1;
669159ae 383 int iResult=0;
437e8e54 384
669159ae 385 TString configuration="";
386 TString argument="";
387 for (int i=0; i<argc && iResult>=0; i++) {
388 argument=argv[i];
389 if (!configuration.IsNull()) configuration+=" ";
390 configuration+=argument;
391 }
ecefc48a 392
669159ae 393 if (!configuration.IsNull()) {
394 iResult=Configure(configuration.Data());
395 } else {
396 iResult=Reconfigure(NULL, NULL);
397 }
398
399 return iResult;
71d7c760 400 }
401
402int AliHLTTPCSliceTrackerComponent::DoDeinit()
ecefc48a 403{
5df0cbb9 404 // see header file for class documentation
ecefc48a 405 if ( fTracker )
406 delete fTracker;
407 fTracker = NULL;
408 if ( fVertex )
409 delete fVertex;
410 fVertex = NULL;
411 if (fpInterMerger) {
412 delete fpInterMerger;
413 }
414 fpInterMerger=NULL;
415 return 0;
416}
71d7c760 417
8ede8717 418int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
5d2abf3b 419 AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
7bcd6cad 420 AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks )
71d7c760 421 {
5df0cbb9 422 // see header file for class documentation
a6c02c85 423 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "DoEvent()" );
5235c3e9 424 if ( evtData.fBlockCnt<=0 )
425 {
426 Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" );
427 return 0;
428 }
8ede8717 429 const AliHLTComponentBlockData* iter = NULL;
71d7c760 430 unsigned long ndx;
431 AliHLTTPCClusterData* inPtrSP;
a6c02c85 432 AliHLTTPCVertexData* inPtrV = NULL;
8ede8717 433 const AliHLTComponentBlockData* vertexIter=NULL;
71d7c760 434 AliHLTTPCTrackletData* outPtr;
435 AliHLTUInt8_t* outBPtr;
436 AliHLTUInt32_t vSize = 0;
437 UInt_t offset=0, mysize, tSize = 0;
438 outBPtr = outputPtr;
5235c3e9 439 Int_t slice=-1, patch=-1, row[2];
71d7c760 440 Int_t minPatch=INT_MAX, maxPatch = 0;
441 offset = 0;
442 std::vector<Int_t> slices;
443 std::vector<Int_t>::iterator slIter, slEnd;
444 std::vector<unsigned> sliceCnts;
445 std::vector<unsigned>::iterator slCntIter;
5235c3e9 446 Int_t vertexSlice=-1;
71d7c760 447
448 // Find min/max rows used in total and find and read out vertex if it is present
449 // also determine correct slice number, if multiple slice numbers are present in event
450 // (which should not happen in the first place) we use the one that occurs the most times
451 row[0] = 0;
452 row[1] = 0;
453 bool found;
454 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
455 {
456 iter = blocks+ndx;
457
cb703d46 458 if(iter->fDataType!=AliHLTTPCDefinitions::fgkClustersDataType){
459 HLTDebug("Data block type is not of type AliHLTTPCDefinitions::fgkClustersDataType");
460 continue;
461 }
462
71d7c760 463 slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
464 found = false;
465 slIter = slices.begin();
466 slEnd = slices.end();
467 slCntIter = sliceCnts.begin();
468 while ( slIter != slEnd )
469 {
470 if ( *slIter == slice )
471 {
472 found = true;
473 break;
474 }
475 slIter++;
476 slCntIter++;
477 }
478 if ( !found )
479 {
480 slices.insert( slices.end(), slice );
481 sliceCnts.insert( sliceCnts.end(), 1 );
482 }
483 else
484 *slCntIter++;
485
96bda103 486 if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
71d7c760 487 {
a6c02c85 488 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
71d7c760 489 vertexIter = iter;
490 vSize = iter->fSize;
491 fVertex->Read( inPtrV );
492 vertexSlice = slice;
493 }
96bda103 494 if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
71d7c760 495 {
496 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
497 if ( minPatch>patch )
498 {
499 minPatch = patch;
a6c02c85 500 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
71d7c760 501 }
502 if ( maxPatch<patch )
503 {
504 maxPatch = patch;
a6c02c85 505 row[1] = AliHLTTPCTransform::GetLastRow( patch );
71d7c760 506 }
507 }
508 }
509
510 // Determine slice number to really use.
511 if ( slices.size()>1 )
512 {
513 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
514 "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
515 evtData.fEventID, evtData.fEventID );
516 unsigned maxCntSlice=0;
517 slIter = slices.begin();
518 slEnd = slices.end();
519 slCntIter = sliceCnts.begin();
520 while ( slIter != slEnd )
521 {
522 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
523 "Slice %lu found %lu times.", *slIter, *slCntIter );
524 if ( maxCntSlice<*slCntIter )
525 {
526 maxCntSlice = *slCntIter;
527 slice = *slIter;
528 }
529 slIter++;
530 slCntIter++;
531 }
532 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
533 "Using slice %lu.", slice );
534 }
5235c3e9 535 else if ( slices.size()>0 )
536 {
71d7c760 537 slice = *(slices.begin());
5235c3e9 538 }
539 else
540 {
541 slice = -1;
542 }
71d7c760 543
544 if ( vertexSlice != slice )
545 {
546 // multiple vertex blocks in event and we used the wrong one...
547 found = false;
548 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
549 {
550 iter = blocks+ndx;
96bda103 551 if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
71d7c760 552 {
a6c02c85 553 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
71d7c760 554 vertexIter = iter;
555 vSize = iter->fSize;
556 fVertex->Read( inPtrV );
557 break;
558 }
559 }
560 }
561
562 fTracker->InitSector( slice, row, fEta );
563 fTracker->SetVertex(fVertex);
564 mysize = 0;
565 // read in all hits
a6c02c85 566 std::vector<unsigned long> patchIndices;
567 std::vector<unsigned long>::iterator pIter, pEnd;
71d7c760 568 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
569 {
570 iter = blocks+ndx;
571
96bda103 572 if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
71d7c760 573 {
574 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
a6c02c85 575 pIter = patchIndices.begin();
576 pEnd = patchIndices.end();
577 while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
578 pIter++;
579 patchIndices.insert( pIter, ndx );
71d7c760 580 }
581 }
a6c02c85 582 pIter = patchIndices.begin();
583 pEnd = patchIndices.end();
584 while ( pIter!=pEnd )
585 {
586 ndx = *pIter;
587 iter = blocks+ndx;
588
589 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
590 inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
591
592 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits",
593 "Reading hits for slice %d - patch %d", slice, patch );
594 fTracker->ReadHits( inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints );
595 pIter++;
596 }
71d7c760 597
598 outPtr = (AliHLTTPCTrackletData*)(outBPtr);
437e8e54 599
738c049f 600 if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
437e8e54 601 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
602 fTracker->MainVertexTrackingA();
603 fTracker->MainVertexTrackingB();
604 fTracker->FillTracks();
738c049f 605 }
606 else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
437e8e54 607 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
608 fTracker->MainVertexTrackingA();
609 fTracker->MainVertexTrackingB();
610 fTracker->FillTracks();
611 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
612 fTracker->NonVertexTracking();
738c049f 613 }
614 else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
437e8e54 615 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
616 fTracker->NonVertexTracking();
617 fTracker->FillTracks();
738c049f 618 }
437e8e54 619
ecefc48a 620 UInt_t ntracks0 =0;
621 if(fpInterMerger){
622 AliHLTTPCMemHandler memory;
623 AliHLTTPCTrackSegmentData *trackdata0 =
624 (AliHLTTPCTrackSegmentData *) memory.Allocate(fTracker->GetTracks());
625 memory.TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
626 fpInterMerger->Reset();
627 fpInterMerger->Init(row,patch);
628 fpInterMerger->FillTracks(ntracks0,trackdata0);
629 fpInterMerger->Merge();
630 }
631 ntracks0=0;
5df0cbb9 632 AliHLTTPCTrackArray* pArray=fTracker->GetTracks();
633 mysize = pArray->WriteTracks( ntracks0, outPtr->fTracklets );
71d7c760 634 outPtr->fTrackletCnt = ntracks0;
ecefc48a 635
71d7c760 636 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks",
637 "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.",
638 ntracks0, slice, minPatch, maxPatch, row[0], row[1] );
639
055fed30 640 fTracker->Reset();
641
71d7c760 642 tSize += mysize+sizeof(AliHLTTPCTrackletData);
643 outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
644
8ede8717 645 AliHLTComponentBlockData bd;
71d7c760 646 FillBlockData( bd );
647 bd.fOffset = offset;
648 bd.fSize = tSize;
649 bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
650 outputBlocks.push_back( bd );
651
652#ifdef FORWARD_VERTEX_BLOCK
653 if ( vertexIter )
654 {
655 // Copy the descriptor block for the vertex information.
656 bd = *vertexIter;
657 outputBlocks.push_back( bd );
658 }
659#endif // FORWARD_VERTEX_BLOCK
660
661 size = tSize;
662 return 0;
663 }
664
669159ae 665int AliHLTTPCSliceTrackerComponent::Configure(const char* arguments)
666{
667 // see header file for class documentation
668 int iResult=0;
669 if (!arguments) return iResult;
670
671 TString allArgs=arguments;
672 TString argument;
673 int bMissingParam=0;
674 Bool_t bDoMerger=kTRUE;
675
676 TObjArray* pTokens=allArgs.Tokenize(" ");
677 if (pTokens) {
678 for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
679 argument=((TObjString*)pTokens->At(i))->GetString();
680 if (argument.IsNull()) continue;
681
682 if (argument.CompareTo("-disable-merger")==0) {
683 HLTInfo("Disabled Inter Merger");
684 bDoMerger = kFALSE;
685 continue;
686 }
687 else if (argument.CompareTo("-pp-run")==0) {
688 HLTInfo("Using Trackparameters for pp-run");
689 fDoPP = true;
690 continue;
691 }
692 else if (argument.CompareTo("-PbPb-run")==0) {
693 HLTInfo("Using Trackparameters for Pb-Pb-run");
694 fDoPbPb = true;
695 continue;
696 }
697 else if (argument.CompareTo("-nonvertextracking")==0) {
698 HLTInfo("Doing Nonvertex Tracking");
699 fnonvertextracking = kTRUE;
700 continue;
701 }
702 else if (argument.CompareTo("-mainvertextrackingoff")==0) {
703 HLTInfo("Mainvertex Tracking off");
704 fmainvertextracking = kFALSE;
705 continue;
706 }
707 else if (argument.CompareTo("-multiplicity")==0) {
708 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
709 HLTInfo("Multiplicity set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
710 fMultiplicity=((TObjString*)pTokens->At(i))->GetString().Atoi();
711 continue;
712 }
713 else if (argument.CompareTo("-bfield")==0) {
714 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
715 HLTInfo("Magnetic Field set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
716 fBField=((TObjString*)pTokens->At(i))->GetString().Atof();
717 continue;
718 }
719 else if (argument.CompareTo("-etarange")==0) {
720 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
721 HLTInfo("Etarange set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
722 fEta[1]=((TObjString*)pTokens->At(i))->GetString().Atof();
723 continue;
724 }
725 else if (argument.CompareTo("-etasegment")==0) {
726 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
727 HLTInfo("Number of Etasegment: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
728 fEtasegment=((TObjString*)pTokens->At(i))->GetString().Atoi();
729 continue;
730 }
731 else if (argument.CompareTo("-chi2cut")==0) {
732 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
733 HLTInfo("chi2cut set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
734 fHitChi2Cut=((TObjString*)pTokens->At(i))->GetString().Atof();
735 continue;
736 }
737 else if (argument.CompareTo("-rowscopetracklet")==0) {
738 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
739 HLTInfo("Number of row to look for next cluster for tracklet: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
740 fRowscopetracklet=((TObjString*)pTokens->At(i))->GetString().Atoi();
741 continue;
742 }
743 else if (argument.CompareTo("-rowscopetrack")==0) {
744 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
745 HLTInfo("Number of row to look for next cluster for track: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
746 fRowscopetrack=((TObjString*)pTokens->At(i))->GetString().Atoi();
747 continue;
748 }
749 else if (argument.CompareTo("-trackletlength")==0) {
750 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
751 HLTInfo("Minimum number of clusters on a Tracklet: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
752 fTrackletlength=((TObjString*)pTokens->At(i))->GetString().Atoi();
753 continue;
754 }
755 else if (argument.CompareTo("-tracklength")==0) {
756 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
757 HLTInfo("Minimum number of clusters on a Track: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
758 fTracklength=((TObjString*)pTokens->At(i))->GetString().Atoi();
759 continue;
760 }
761 else {
762 HLTError("unknown argument %s", argument.Data());
763 iResult=-EINVAL;
764 break;
765 }
766 }
767 delete pTokens;
768 }
769 if (bMissingParam) {
770 HLTError("missing parameter for argument %s", argument.Data());
771 iResult=-EINVAL;
772 }
773 if (fBField == 0.){
774 // parameter for B=0 T
775 fDoPP = kTRUE;
776 fnonvertextracking = kTRUE;
777 fmainvertextracking = kFALSE;
778 }
779
780 if (bDoMerger)
781 fpInterMerger = new AliHLTTPCInterMerger();
782 else
783 fpInterMerger = NULL;
784
785 SetTrackerParam(fDoPP,fDoPbPb,fMultiplicity,fBField,fEtasegment,fHitChi2Cut,fRowscopetracklet,fRowscopetrack,fTrackletlength,fTracklength);
786
787 return iResult;
788}
789
790int AliHLTTPCSliceTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
791{
792 // see header file for class documentation
793 int iResult=0;
794 const char* path="HLT/ConfigTPC/SliceTrackerComponent";
795 const char* defaultNotify="";
796 if (cdbEntry) {
797 path=cdbEntry;
798 defaultNotify=" (default)";
799 }
800 if (path) {
801 HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
802 AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
803 if (pEntry) {
804 TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
805 if (pString) {
806 HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
807 iResult=Configure(pString->GetString().Data());
808 } else {
809 HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
810 }
811 } else {
812 HLTError("can not fetch object \"%s\" from CDB", path);
813 }
814 }
815 return iResult;
816}
817
5df0cbb9 818void AliHLTTPCSliceTrackerComponent::SetTrackerParam1()
819{
e67b0680 820 // see header file for class documentation
5df0cbb9 821 SetTrackerParam( 10, 20, 5, 10, 2,2,
822 0, 1.31, 5, 100,
e6421c43 823 50, 100, 50, 0.1, 0.1);
5df0cbb9 824}
825
71d7c760 826