- adjusting binning of pad histograms to make single pad cluster contribution and...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCSliceTrackerComponent.cxx
CommitLineData
71d7c760 1// $Id$
2
bd34e482 3//**************************************************************************
4//* This file is property of and copyright by the ALICE HLT Project *
5//* ALICE Experiment at CERN, All rights reserved. *
6//* *
7//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
8//* Timm Steinbeck <timm@kip.uni-heidelberg.de> *
9//* for The ALICE HLT Project. *
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//**************************************************************************
71d7c760 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 27using namespace std;
28#endif
29
b09247a2 30#include <climits>
71d7c760 31#include "AliHLTTPCSliceTrackerComponent.h"
a6c02c85 32#include "AliHLTTPCTransform.h"
33#include "AliHLTTPCConfMapper.h"
34#include "AliHLTTPCVertex.h"
a6c02c85 35#include "AliHLTTPCVertexData.h"
71d7c760 36#include "AliHLTTPCClusterDataFormat.h"
a6c02c85 37#include "AliHLTTPCTransform.h"
38#include "AliHLTTPCTrackSegmentData.h"
39#include "AliHLTTPCTrackArray.h"
71d7c760 40#include "AliHLTTPCTrackletDataFormat.h"
ecefc48a 41#include "AliHLTTPCInterMerger.h"
42#include "AliHLTTPCMemHandler.h"
5df0cbb9 43#include "AliHLTTPCDefinitions.h"
e8eee7af 44#include "AliHLTCommonCDBEntries.h"
669159ae 45#include "TString.h"
46#include "TObjString.h"
47#include "TObjArray.h"
48#include "AliCDBEntry.h"
49#include "AliCDBManager.h"
b1d702f1 50#include "AliCDBStorage.h"
75970b8d 51#include "TGeoGlobalMagField.h"
a7c32962 52//#include "AliHLTTPC.h"
5df0cbb9 53//#include <stdlib.h>
54//#include <cerrno>
71d7c760 55
5df0cbb9 56/** ROOT macro for the implementation of ROOT specific class methods */
71d7c760 57ClassImp(AliHLTTPCSliceTrackerComponent)
58
59AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
6235cd38 60 :
61 fTracker(NULL),
62 fVertex(NULL),
63 fDoNonVertex(false),
ecefc48a 64 fDoPP(false),
e6421c43 65 fDoPbPb(false),
6235cd38 66 fMultiplicity(4000),
91db0db2 67 fBField(0.5),
6235cd38 68 fnonvertextracking(kFALSE),
ecefc48a 69 fmainvertextracking(kTRUE),
e6421c43 70 fPhisegment(50),
71 fEtasegment(100),
72 fTrackletlength(3),
73 fTracklength(60),
74 fRowscopetracklet(6),
75 fRowscopetrack(6),
76 fMinPtFit(0),
77 fMaxangle(0.1745),
78 fGoodDist(5),
79 fHitChi2Cut(100),
80 fGoodHitChi2(5),
81 fTrackChi2Cut(50),
82 fMaxdist(50),
83 fMaxphi(0.1),
b0914d2e 84 fMaxeta(0.1),
85 fpInterMerger(NULL)
6235cd38 86{
87 // see header file for class documentation
88 // or
89 // refer to README to build package
90 // or
91 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
92 fEta[0] = 0.;
93 fEta[1] = 1.1;
94}
95
71d7c760 96AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
6235cd38 97{
5df0cbb9 98 // see header file for class documentation
6235cd38 99}
71d7c760 100
101// Public functions to implement AliHLTComponent's interface.
102// These functions are required for the registration process
103
104const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
6235cd38 105{
5df0cbb9 106 // see header file for class documentation
6235cd38 107
108 return "TPCSliceTracker";
109}
71d7c760 110
7bcd6cad 111void AliHLTTPCSliceTrackerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
6235cd38 112{
5df0cbb9 113 // see header file for class documentation
6235cd38 114 list.clear();
96bda103 115 list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
116 list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
6235cd38 117}
71d7c760 118
8ede8717 119AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
6235cd38 120{
5df0cbb9 121 // see header file for class documentation
96bda103 122 return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
6235cd38 123}
71d7c760 124
125void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
6235cd38 126{
5df0cbb9 127 // see header file for class documentation
6235cd38 128 // XXX TODO: Find more realistic values.
129 constBase = 0;
e6421c43 130 inputMultiplier = 1;
6235cd38 131}
71d7c760 132
133AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
6235cd38 134{
5df0cbb9 135 // see header file for class documentation
6235cd38 136 return new AliHLTTPCSliceTrackerComponent;
137}
71d7c760 138
6235cd38 139void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phiSegments, Int_t etaSegments,
71d7c760 140 Int_t trackletlength, Int_t tracklength,
141 Int_t rowscopetracklet, Int_t rowscopetrack,
6235cd38 142 Double_t minPtFit, Double_t maxangle,
71d7c760 143 Double_t goodDist, Double_t hitChi2Cut,
144 Double_t goodHitChi2, Double_t trackChi2Cut,
e6421c43 145 Int_t maxdist, Double_t maxphi,Double_t maxeta)
146{
5df0cbb9 147 // see header file for class documentation
71d7c760 148 //fTracker->SetClusterFinderParam( fXYClusterError, fZClusterError, kTRUE ); // ??
149 //Set parameters input to the tracker
150 //If no arguments are given, default parameters will be used
151
6235cd38 152 fTracker->SetNSegments(phiSegments,etaSegments);
153 fTracker->SetMaxDca(minPtFit);
71d7c760 154 // fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
738c049f 155
db16520a 156 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
738c049f 157
158 if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
159 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
160 fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
161
162 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
db16520a 163 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
738c049f 164 }
165 else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
166 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
167 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
168 fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
169 fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
170
171 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
172 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
db16520a 173 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
738c049f 174 }
175 else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
176 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
177 fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
178
179 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
db16520a 180 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
738c049f 181 }
71d7c760 182
738c049f 183 //fTracker->SetParamDone(true);
a7c32962 184 /* Matthias 13.12.2006
185 * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
186 * and has always been kTRUE.
187 * In order to remove the AliHLTTPC class (which is the old steering class for
188 * HLT (TPC) tracking) from the compilation, this function can not be activated
189 * again. We have to think about a more elegant way to specify the parameters
190 * anyway. The following line was surely for some testing, but was never active
191 * in a tested release.
192 */
a6c02c85 193 //AliHLTTPC::SetVertexFit( kFALSE );
71d7c760 194
195 fTracker->InitVolumes();
196 }
197
738c049f 198
e6421c43 199void AliHLTTPCSliceTrackerComponent::SetTrackerParam( Bool_t doPP, Bool_t doPbPb, Int_t multiplicity,
200 Double_t bField, Int_t etasegment, Double_t hitchi2cut,
201 Int_t rowscopetracklet, Int_t rowscopetrack,
202 Int_t trackletlength, Int_t tracklength )
203{
204 // see header file for class documentation
205 AliHLTTPCTransform::SetBField( bField );
206 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField );
207
208 if ( doPP )
209 {
210 //tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ??
211
72faff9f 212 SetTrackerParam( 50, 100, 3, 60,
8fd35beb 213 6, 6,
e6421c43 214 0, 0.1745, 5, 100,
215 5, 50, 50, 0.1, 0.1);
216 }
217 else if(doPbPb)
218 {
219 int mults[] = { 1000, 2000, 4000, 8000 };
220 int multCount = 4;
221 int closestMult = 0;
222 int i;
223 int multDist, tmpMultDist;
224 if ( multiplicity>mults[closestMult] )
225 multDist = multiplicity-mults[closestMult];
226 else
227 multDist = mults[closestMult]-multiplicity;
228 for ( i = 1; i < multCount; i++ )
71d7c760 229 {
e6421c43 230 if ( multiplicity>mults[i] )
231 tmpMultDist = multiplicity-mults[i];
232 else
233 tmpMultDist = mults[i]-multiplicity;
234 if ( tmpMultDist < multDist )
235 {
236 closestMult = i;
237 multDist = tmpMultDist;
238 }
71d7c760 239 }
e6421c43 240
241 double bfs[] = { 0.2, 0.4 };
242 int bfCount = 2;
243 int closestBf = 0;
244 double bfDist, tmpBFDist;
245 if ( bField>bfs[closestBf] )
246 bfDist = bField-bfs[closestBf];
247 else
248 bfDist = bfs[closestBf]-bField;
249 for ( i = 1; i < bfCount; i++ )
71d7c760 250 {
e6421c43 251 if ( bField>bfs[i] )
252 tmpBFDist = bField-bfs[i];
253 else
254 tmpBFDist = bfs[i]-bField;
255 if ( tmpBFDist < bfDist )
71d7c760 256 {
e6421c43 257 closestBf = i;
258 bfDist = tmpBFDist;
71d7c760 259 }
e6421c43 260 }
261
262 switch ( closestMult )
263 {
264 case 0: // 1000
265 switch ( closestBf )
71d7c760 266 {
e6421c43 267 case 0: // 0.2
268 SetTrackerParam( 50, 100, 3, 10,
269 2, 4,
270 0, 0.1745, 5, 100,
271 5, 50, 50, 0.1, 0.1);
272 break;
273 case 1: // 0.4
274 SetTrackerParam( 50, 100, 3, 10,
275 2, 4,
276 0, 0.1745, 5, 100,
277 5, 50, 50, 0.1, 0.1);
278 break;
71d7c760 279 }
e6421c43 280 break;
281 case 1: // 2000
282 switch ( closestBf )
71d7c760 283 {
e6421c43 284 case 0: // 0.2
285 SetTrackerParam( 50, 100, 3, 10,
286 2, 4,
287 0, 0.1745, 5, 30,
288 5, 20, 50, 0.1, 0.1);
289 break;
290 case 1: // 0.4
291 SetTrackerParam( 50, 100, 3, 10,
292 2, 5,
293 0, 0.1745, 5, 30,
294 5, 20, 50, 0.1, 0.1);
295 break;
296 }
297 break;
298 case 2: // 4000
299 switch ( closestBf )
300 {
301 case 0: // 0.2
302 SetTrackerParam( 50, 100, 3, 10,
303 2 , 10,
304 0, 0.1745, 5, 20,
305 5, 10 , 50, 0.1, 0.1);
306 break;
307 case 1: // 0.4
308 SetTrackerParam( 50, 100, 3, 10,
309 2, 10,
310 0, 0.1745, 5, 20,
311 5, 10, 50, 0.1, 0.1);
312 break;
313 }
314 break;
315 case 3: // 8000
316 switch ( closestBf )
317 {
318 case 0: // 0.2
319 SetTrackerParam( 50, 100, 3, 10,
320 3, 15,
321 0, 0.1745, 5, 10,
322 5, 5, 50, 0.1, 0.1);
323 break;
324 case 1: // 0.4
325 SetTrackerParam( 50, 100, 3, 10,
326 2, 15,
327 0, 0.1745, 5, 15,
328 5, 5, 50, 0.1, 0.1);
329 break;
71d7c760 330 }
e6421c43 331 break;
71d7c760 332 }
e6421c43 333 // Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
334 // AliHLTTPCTransform::SetBField( bfs[closestBf] );
335 // AliHLTTPCTransform::SetBField( bField );
336 // Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField );
71d7c760 337 }
e6421c43 338 else
339 {
340 SetTrackerParam( 50, etasegment, trackletlength, tracklength,
341 rowscopetracklet, rowscopetrack,
342 0, 0.1745, 5, hitchi2cut,
343 5, 50, 50, 0.1, 0.1);
344 }
345}
71d7c760 346
347int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv )
348 {
5df0cbb9 349 // see header file for class documentation
a6c02c85 350 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
a6c02c85 351
71d7c760 352 if ( fTracker || fVertex )
353 return EINPROGRESS;
a6c02c85 354 fTracker = new AliHLTTPCConfMapper();
355 fVertex = new AliHLTTPCVertex();
71d7c760 356 fEta[0] = 0.;
357 fEta[1] = 1.1;
358 fDoNonVertex = false;
a6c02c85 359 fMultiplicity = 4000;
e6421c43 360 fBField = 0.5;
a6c02c85 361 fDoPP = false;
e6421c43 362 fDoPbPb = false;
363 fPhisegment=50;
364 fEtasegment=100;
365 fTrackletlength=3;
366 fTracklength=60;
367 fRowscopetracklet=6;
368 fRowscopetrack=6;
369 fMinPtFit=0;
370 fMaxangle=0.1745;
371 fGoodDist=5;
372 fHitChi2Cut=100;
373 fGoodHitChi2=5;
374 fTrackChi2Cut=50;
375 fMaxdist=50;
376 fMaxphi=0.1;
377 fMaxeta=0.1;
669159ae 378 int iResult=0;
437e8e54 379
669159ae 380 TString configuration="";
381 TString argument="";
382 for (int i=0; i<argc && iResult>=0; i++) {
383 argument=argv[i];
384 if (!configuration.IsNull()) configuration+=" ";
385 configuration+=argument;
386 }
ecefc48a 387
669159ae 388 if (!configuration.IsNull()) {
389 iResult=Configure(configuration.Data());
390 } else {
391 iResult=Reconfigure(NULL, NULL);
392 }
393
394 return iResult;
71d7c760 395 }
396
397int AliHLTTPCSliceTrackerComponent::DoDeinit()
ecefc48a 398{
5df0cbb9 399 // see header file for class documentation
ecefc48a 400 if ( fTracker )
401 delete fTracker;
402 fTracker = NULL;
403 if ( fVertex )
404 delete fVertex;
405 fVertex = NULL;
406 if (fpInterMerger) {
407 delete fpInterMerger;
408 }
409 fpInterMerger=NULL;
410 return 0;
411}
71d7c760 412
8ede8717 413int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
5d2abf3b 414 AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
7bcd6cad 415 AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks )
bd34e482 416{
5df0cbb9 417 // see header file for class documentation
bd34e482 418 int iResult=0;
419 AliHLTUInt32_t capacity=size;
420 size=0;
421
b05e22cd 422 if (!IsDataEvent()) return 0;
423
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;
c9602aeb 433#ifdef FORWARD_VERTEX_BLOCK
8ede8717 434 const AliHLTComponentBlockData* vertexIter=NULL;
c9602aeb 435#endif
71d7c760 436 AliHLTTPCTrackletData* outPtr;
437 AliHLTUInt8_t* outBPtr;
c9602aeb 438 //AliHLTUInt32_t vSize = 0;
71d7c760 439 UInt_t offset=0, mysize, tSize = 0;
440 outBPtr = outputPtr;
5235c3e9 441 Int_t slice=-1, patch=-1, row[2];
71d7c760 442 Int_t minPatch=INT_MAX, maxPatch = 0;
443 offset = 0;
444 std::vector<Int_t> slices;
445 std::vector<Int_t>::iterator slIter, slEnd;
446 std::vector<unsigned> sliceCnts;
447 std::vector<unsigned>::iterator slCntIter;
5235c3e9 448 Int_t vertexSlice=-1;
71d7c760 449
450 // Find min/max rows used in total and find and read out vertex if it is present
451 // also determine correct slice number, if multiple slice numbers are present in event
452 // (which should not happen in the first place) we use the one that occurs the most times
453 row[0] = 0;
454 row[1] = 0;
455 bool found;
456 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
457 {
458 iter = blocks+ndx;
459
bd34e482 460 bool bIsClusterDataBlock=false;
461 bool bIsVertexDataBlock=false;
462 if(!(bIsClusterDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkClustersDataType)) &&
463 !(bIsVertexDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkVertexDataType))){
cb703d46 464 continue;
465 }
466
71d7c760 467 slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
bd34e482 468 if (slice<0 || slice>=AliHLTTPCTransform::GetNSlice()) {
469 HLTError("invalid slice number %d extracted from specification 0x%08lx, skipping block of type %s",
470 slice, iter->fSpecification, DataType2Text(iter->fDataType).c_str());
471 // just remember the error, if there are other valid blocks ignore the
472 // error, return code otherwise
473 iResult=-EBADF;
474 continue;
475 }
476 if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr( *iter )) {
477 // the code was not written for/ never used with multiple slices
478 // in one data block/ specification
479 HLTWarning("specification 0x%08lx indicates multiple slices in data block %s: never used before, please audit the code",
480 iter->fSpecification, DataType2Text(iter->fDataType).c_str());
481 }
71d7c760 482 found = false;
483 slIter = slices.begin();
484 slEnd = slices.end();
485 slCntIter = sliceCnts.begin();
486 while ( slIter != slEnd )
487 {
488 if ( *slIter == slice )
489 {
490 found = true;
491 break;
492 }
493 slIter++;
494 slCntIter++;
495 }
496 if ( !found )
497 {
498 slices.insert( slices.end(), slice );
499 sliceCnts.insert( sliceCnts.end(), 1 );
500 }
501 else
502 *slCntIter++;
503
bd34e482 504 if (bIsVertexDataBlock)
71d7c760 505 {
a6c02c85 506 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
c9602aeb 507#ifdef FORWARD_VERTEX_BLOCK
71d7c760 508 vertexIter = iter;
c9602aeb 509#endif
510 //vSize = iter->fSize;
71d7c760 511 fVertex->Read( inPtrV );
512 vertexSlice = slice;
513 }
bd34e482 514 if (bIsClusterDataBlock)
71d7c760 515 {
516 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
517 if ( minPatch>patch )
518 {
519 minPatch = patch;
a6c02c85 520 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
71d7c760 521 }
522 if ( maxPatch<patch )
523 {
524 maxPatch = patch;
a6c02c85 525 row[1] = AliHLTTPCTransform::GetLastRow( patch );
71d7c760 526 }
527 }
528 }
529
530 // Determine slice number to really use.
531 if ( slices.size()>1 )
532 {
533 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
534 "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
535 evtData.fEventID, evtData.fEventID );
536 unsigned maxCntSlice=0;
537 slIter = slices.begin();
538 slEnd = slices.end();
539 slCntIter = sliceCnts.begin();
540 while ( slIter != slEnd )
541 {
542 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
543 "Slice %lu found %lu times.", *slIter, *slCntIter );
544 if ( maxCntSlice<*slCntIter )
545 {
546 maxCntSlice = *slCntIter;
547 slice = *slIter;
548 }
549 slIter++;
550 slCntIter++;
551 }
552 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
553 "Using slice %lu.", slice );
554 }
5235c3e9 555 else if ( slices.size()>0 )
556 {
71d7c760 557 slice = *(slices.begin());
5235c3e9 558 }
559 else
560 {
bd34e482 561 // there is no sense in running the tracker without input, do not send an
562 // empty output block
563 return iResult;
5235c3e9 564 }
71d7c760 565
bd34e482 566 iResult=0;
567
71d7c760 568 if ( vertexSlice != slice )
569 {
570 // multiple vertex blocks in event and we used the wrong one...
571 found = false;
572 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
573 {
574 iter = blocks+ndx;
96bda103 575 if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
71d7c760 576 {
a6c02c85 577 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
c9602aeb 578#ifdef FORWARD_VERTEX_BLOCK
71d7c760 579 vertexIter = iter;
c9602aeb 580#endif
581 //vSize = iter->fSize;
71d7c760 582 fVertex->Read( inPtrV );
583 break;
584 }
585 }
586 }
587
588 fTracker->InitSector( slice, row, fEta );
589 fTracker->SetVertex(fVertex);
590 mysize = 0;
591 // read in all hits
a6c02c85 592 std::vector<unsigned long> patchIndices;
593 std::vector<unsigned long>::iterator pIter, pEnd;
71d7c760 594 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
595 {
596 iter = blocks+ndx;
597
96bda103 598 if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
71d7c760 599 {
600 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
a6c02c85 601 pIter = patchIndices.begin();
602 pEnd = patchIndices.end();
603 while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
604 pIter++;
605 patchIndices.insert( pIter, ndx );
71d7c760 606 }
607 }
a6c02c85 608 pIter = patchIndices.begin();
609 pEnd = patchIndices.end();
610 while ( pIter!=pEnd )
611 {
612 ndx = *pIter;
613 iter = blocks+ndx;
614
615 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
616 inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
617
618 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits",
619 "Reading hits for slice %d - patch %d", slice, patch );
2a31fa2a 620 //fTracker->ReadHits( inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints );
621 fTracker->ReadHitsChecked(inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints,iter->fSize );
a6c02c85 622 pIter++;
623 }
71d7c760 624
437e8e54 625
738c049f 626 if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
437e8e54 627 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
628 fTracker->MainVertexTrackingA();
629 fTracker->MainVertexTrackingB();
630 fTracker->FillTracks();
738c049f 631 }
632 else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
437e8e54 633 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
634 fTracker->MainVertexTrackingA();
635 fTracker->MainVertexTrackingB();
636 fTracker->FillTracks();
637 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
638 fTracker->NonVertexTracking();
738c049f 639 }
640 else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
437e8e54 641 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
642 fTracker->NonVertexTracking();
643 fTracker->FillTracks();
738c049f 644 }
437e8e54 645
ecefc48a 646 UInt_t ntracks0 =0;
647 if(fpInterMerger){
648 AliHLTTPCMemHandler memory;
649 AliHLTTPCTrackSegmentData *trackdata0 =
650 (AliHLTTPCTrackSegmentData *) memory.Allocate(fTracker->GetTracks());
651 memory.TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
652 fpInterMerger->Reset();
653 fpInterMerger->Init(row,patch);
654 fpInterMerger->FillTracks(ntracks0,trackdata0);
655 fpInterMerger->Merge();
656 }
657 ntracks0=0;
5df0cbb9 658 AliHLTTPCTrackArray* pArray=fTracker->GetTracks();
bd34e482 659 if (pArray->GetOutSize()+sizeof(AliHLTTPCTrackletData)<=capacity) {
660 outPtr = (AliHLTTPCTrackletData*)(outBPtr);
5df0cbb9 661 mysize = pArray->WriteTracks( ntracks0, outPtr->fTracklets );
71d7c760 662 outPtr->fTrackletCnt = ntracks0;
ecefc48a 663
8d262e30 664 // Matthias 2009-05-22
665 // Somehow the ConfMapFit uses a different sign convention for the magnetic field.
666 // In order to avoid conversions further upstream we change the sign here.
667 // The CM tracker is not the first priority any more as the CA tracker is
668 // going to be used for online TPC reconstruction. But CM tracker has to
669 // remain functional.
670 // Further investigation is ongoing
671 AliHLTTPCTrackSegmentData* segment=outPtr->fTracklets;
9ba081fd 672 for (unsigned int trackno=0; trackno<ntracks0; trackno++, segment++) {
8d262e30 673 segment->fCharge*=-1;
674 }
675
71d7c760 676 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks",
677 "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.",
678 ntracks0, slice, minPatch, maxPatch, row[0], row[1] );
679
055fed30 680 fTracker->Reset();
681
8ede8717 682 AliHLTComponentBlockData bd;
71d7c760 683 FillBlockData( bd );
684 bd.fOffset = offset;
bd34e482 685 bd.fSize = mysize+sizeof(AliHLTTPCTrackletData);
71d7c760 686 bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
687 outputBlocks.push_back( bd );
688
bd34e482 689 tSize += bd.fSize;
690 outBPtr += bd.fSize;
691 } else {
692 iResult=-ENOSPC;
693 }
694
71d7c760 695#ifdef FORWARD_VERTEX_BLOCK
696 if ( vertexIter )
697 {
698 // Copy the descriptor block for the vertex information.
699 bd = *vertexIter;
700 outputBlocks.push_back( bd );
701 }
702#endif // FORWARD_VERTEX_BLOCK
703
704 size = tSize;
bd34e482 705 return iResult;
71d7c760 706 }
707
669159ae 708int AliHLTTPCSliceTrackerComponent::Configure(const char* arguments)
709{
710 // see header file for class documentation
711 int iResult=0;
712 if (!arguments) return iResult;
713
75970b8d 714 // Check field
715 if (!TGeoGlobalMagField::Instance()) {
716 HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF");
717 return -ENODEV;
718 }
719
669159ae 720 TString allArgs=arguments;
721 TString argument;
722 int bMissingParam=0;
723 Bool_t bDoMerger=kTRUE;
724
725 TObjArray* pTokens=allArgs.Tokenize(" ");
726 if (pTokens) {
727 for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
728 argument=((TObjString*)pTokens->At(i))->GetString();
729 if (argument.IsNull()) continue;
730
731 if (argument.CompareTo("-disable-merger")==0) {
732 HLTInfo("Disabled Inter Merger");
733 bDoMerger = kFALSE;
734 continue;
735 }
736 else if (argument.CompareTo("-pp-run")==0) {
737 HLTInfo("Using Trackparameters for pp-run");
738 fDoPP = true;
739 continue;
740 }
741 else if (argument.CompareTo("-PbPb-run")==0) {
742 HLTInfo("Using Trackparameters for Pb-Pb-run");
743 fDoPbPb = true;
744 continue;
745 }
746 else if (argument.CompareTo("-nonvertextracking")==0) {
747 HLTInfo("Doing Nonvertex Tracking");
748 fnonvertextracking = kTRUE;
749 continue;
750 }
751 else if (argument.CompareTo("-mainvertextrackingoff")==0) {
752 HLTInfo("Mainvertex Tracking off");
753 fmainvertextracking = kFALSE;
754 continue;
755 }
756 else if (argument.CompareTo("-multiplicity")==0) {
757 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
758 HLTInfo("Multiplicity set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
759 fMultiplicity=((TObjString*)pTokens->At(i))->GetString().Atoi();
760 continue;
761 }
8d262e30 762 else if (argument.CompareTo("-solenoidBz")==0) {
669159ae 763 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
75970b8d 764 HLTWarning("parameter -solenoidBz deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField");
91db0db2 765 continue;
766 }
767 else if (argument.CompareTo("-bfield")==0) {
91db0db2 768 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
75970b8d 769 HLTWarning("parameter -bfield deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField");
669159ae 770 continue;
771 }
772 else if (argument.CompareTo("-etarange")==0) {
773 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
774 HLTInfo("Etarange set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
775 fEta[1]=((TObjString*)pTokens->At(i))->GetString().Atof();
776 continue;
777 }
778 else if (argument.CompareTo("-etasegment")==0) {
779 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
780 HLTInfo("Number of Etasegment: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
781 fEtasegment=((TObjString*)pTokens->At(i))->GetString().Atoi();
782 continue;
783 }
784 else if (argument.CompareTo("-chi2cut")==0) {
785 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
786 HLTInfo("chi2cut set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
787 fHitChi2Cut=((TObjString*)pTokens->At(i))->GetString().Atof();
788 continue;
789 }
790 else if (argument.CompareTo("-rowscopetracklet")==0) {
791 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
792 HLTInfo("Number of row to look for next cluster for tracklet: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
793 fRowscopetracklet=((TObjString*)pTokens->At(i))->GetString().Atoi();
794 continue;
795 }
796 else if (argument.CompareTo("-rowscopetrack")==0) {
797 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
798 HLTInfo("Number of row to look for next cluster for track: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
799 fRowscopetrack=((TObjString*)pTokens->At(i))->GetString().Atoi();
800 continue;
801 }
802 else if (argument.CompareTo("-trackletlength")==0) {
803 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
804 HLTInfo("Minimum number of clusters on a Tracklet: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
805 fTrackletlength=((TObjString*)pTokens->At(i))->GetString().Atoi();
806 continue;
807 }
808 else if (argument.CompareTo("-tracklength")==0) {
809 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
810 HLTInfo("Minimum number of clusters on a Track: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
811 fTracklength=((TObjString*)pTokens->At(i))->GetString().Atoi();
812 continue;
813 }
887a0bd9 814 else if (argument.CompareTo("-clusterZ")==0) {
815 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
816 HLTInfo("Minimum number of clusters on a Track: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
817 fTracker->SetClusterCutZ(((TObjString*)pTokens->At(i))->GetString().Atoi());
818 continue;
819 }
669159ae 820 else {
821 HLTError("unknown argument %s", argument.Data());
822 iResult=-EINVAL;
823 break;
824 }
825 }
826 delete pTokens;
827 }
828 if (bMissingParam) {
829 HLTError("missing parameter for argument %s", argument.Data());
830 iResult=-EINVAL;
831 }
75970b8d 832 fBField=GetBz()/10.0;
669159ae 833 if (fBField == 0.){
834 // parameter for B=0 T
835 fDoPP = kTRUE;
836 fnonvertextracking = kTRUE;
837 fmainvertextracking = kFALSE;
838 }
839
840 if (bDoMerger)
841 fpInterMerger = new AliHLTTPCInterMerger();
842 else
843 fpInterMerger = NULL;
844
845 SetTrackerParam(fDoPP,fDoPbPb,fMultiplicity,fBField,fEtasegment,fHitChi2Cut,fRowscopetracklet,fRowscopetrack,fTrackletlength,fTracklength);
846
847 return iResult;
848}
849
b1d702f1 850int AliHLTTPCSliceTrackerComponent::ReadPreprocessorValues(const char* modules)
851{
852 // see header file for class documentation
853
854 int iResult = 0;
855 TString str(modules);
856 if(str.Contains("HLT") || str.Contains("TPC") || str.Contains("GRP")){
857
75970b8d 858 const char* pathBField=NULL;
b1d702f1 859 if (pathBField) {
860
861 HLTInfo("reconfigure B-Field from entry %s, modules %s", pathBField,(modules!=NULL && modules[0]!=0)?modules:"<none>");
862 //AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField/*,GetRunNo()*/);
863
864 AliCDBPath path(pathBField);
865
866 AliCDBStorage *stor = AliCDBManager::Instance()->GetDefaultStorage();
867 Int_t version = stor->GetLatestVersion(pathBField, GetRunNo());
868 Int_t subVersion = stor->GetLatestSubVersion(pathBField, GetRunNo(), version);
869 AliCDBEntry *pEntry = stor->Get(path,GetRunNo(), version, subVersion);
870
871 HLTImportant("RunNo %d, Version %d, subversion %d", GetRunNo(), version, subVersion);
872
873 if (pEntry) {
874 TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
875 if (pString) {
876 HLTImportant("received configuration object string: \'%s\'", pString->GetString().Data());
877 iResult=Configure(pString->GetString().Data());
878 } else {
879 HLTError("configuration object \"%s\" has wrong type, required TObjString", pathBField);
880 }
881 } else {
882 HLTError("cannot fetch object \"%s\" from CDB", pathBField);
883 }
884 }
885 }
886 return iResult;
887}
888
669159ae 889int AliHLTTPCSliceTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
890{
891 // see header file for class documentation
b1d702f1 892
669159ae 893 int iResult=0;
894 const char* path="HLT/ConfigTPC/SliceTrackerComponent";
895 const char* defaultNotify="";
896 if (cdbEntry) {
897 path=cdbEntry;
898 defaultNotify=" (default)";
899 }
900 if (path) {
901 HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
902 AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
903 if (pEntry) {
904 TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
905 if (pString) {
906 HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
907 iResult=Configure(pString->GetString().Data());
908 } else {
909 HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
910 }
911 } else {
b1d702f1 912 HLTError("cannot fetch object \"%s\" from CDB", path);
669159ae 913 }
914 }
a67402b3 915
75970b8d 916 const char* pathBField=NULL;
a67402b3 917
918 if (pathBField) {
919 HLTInfo("reconfigure B-Field from entry %s, chain id %s", path,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
920 AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField/*,GetRunNo()*/);
921 if (pEntry) {
922 TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
923 if (pString) {
924 HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
925 iResult=Configure(pString->GetString().Data());
926 } else {
927 HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
928 }
929 } else {
b1d702f1 930 HLTError("cannot fetch object \"%s\" from CDB", path);
a67402b3 931 }
932 }
933
669159ae 934 return iResult;
b1d702f1 935
669159ae 936}
937
5df0cbb9 938void AliHLTTPCSliceTrackerComponent::SetTrackerParam1()
939{
e67b0680 940 // see header file for class documentation
5df0cbb9 941 SetTrackerParam( 10, 20, 5, 10, 2,2,
942 0, 1.31, 5, 100,
e6421c43 943 50, 100, 50, 0.1, 0.1);
5df0cbb9 944}
945
71d7c760 946