3 /**************************************************************************
4 * This file is property of and copyright by the ALICE HLT Project *
5 * ALICE Experiment at CERN, All rights reserved. *
7 * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
8 * Timm Steinbeck <timm@kip.uni-heidelberg.de> *
9 * for The ALICE HLT Project. *
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 **************************************************************************/
20 /** @file AliHLTTPCSliceTrackerComponent.cxx
21 @author Timm Steinbeck, Matthias Richter
23 @brief The TPC conformal mapping tracker component.
30 #include "AliHLTTPCSliceTrackerComponent.h"
31 #include "AliHLTTPCTransform.h"
32 #include "AliHLTTPCConfMapper.h"
33 #include "AliHLTTPCVertex.h"
34 #include "AliHLTTPCVertexData.h"
35 #include "AliHLTTPCClusterDataFormat.h"
36 #include "AliHLTTPCTransform.h"
37 #include "AliHLTTPCTrackSegmentData.h"
38 #include "AliHLTTPCTrackArray.h"
39 #include "AliHLTTPCTrackletDataFormat.h"
40 #include "AliHLTTPCInterMerger.h"
41 #include "AliHLTTPCMemHandler.h"
42 #include "AliHLTTPCDefinitions.h"
43 //#include "AliHLTTPC.h"
47 // this is a global object used for automatic component registration, do not use this
48 AliHLTTPCSliceTrackerComponent gAliHLTTPCSliceTrackerComponent;
50 /** ROOT macro for the implementation of ROOT specific class methods */
51 ClassImp(AliHLTTPCSliceTrackerComponent)
53 AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
61 // BEGINN ############################################## MODIFIY JMT
62 fnonvertextracking(kFALSE),
63 fmainvertextracking(kTRUE),
64 // END ################################################# MODIFIY JMT
67 // see header file for class documentation
69 // refer to README to build package
71 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
76 AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent& src)
84 // BEGINN ############################################## MODIFIY JMT
85 fnonvertextracking(kFALSE),
86 fmainvertextracking(kTRUE),
87 // END ################################################# MODIFIY JMT
90 // see header file for class documentation
91 HLTFatal("copy constructor untested");
94 AliHLTTPCSliceTrackerComponent& AliHLTTPCSliceTrackerComponent::operator=(const AliHLTTPCSliceTrackerComponent& src)
96 // see header file for class documentation
97 HLTFatal("assignment operator untested");
101 AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
103 // see header file for class documentation
106 // Public functions to implement AliHLTComponent's interface.
107 // These functions are required for the registration process
109 const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
111 // see header file for class documentation
113 return "TPCSliceTracker";
116 void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
118 // see header file for class documentation
120 list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
121 list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
124 AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
126 // see header file for class documentation
127 return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
130 void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
132 // see header file for class documentation
133 // XXX TODO: Find more realistic values.
135 inputMultiplier = 0.2;
138 AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
140 // see header file for class documentation
141 return new AliHLTTPCSliceTrackerComponent;
144 void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phiSegments, Int_t etaSegments,
145 Int_t trackletlength, Int_t tracklength,
146 Int_t rowscopetracklet, Int_t rowscopetrack,
147 Double_t minPtFit, Double_t maxangle,
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 )
152 // see header file for class documentation
153 //fTracker->SetClusterFinderParam( fXYClusterError, fZClusterError, kTRUE ); // ??
154 //Set parameters input to the tracker
155 //If no arguments are given, default parameters will be used
157 fTracker->SetNSegments(phiSegments,etaSegments);
158 fTracker->SetMaxDca(minPtFit);
159 // fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
161 // BEGINN ############################################## MODIFIY JMT
163 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
165 if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
166 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
167 fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
169 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
170 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
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);
178 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
179 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
180 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
182 else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
183 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
184 fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
186 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
187 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
190 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexConstraints);
191 fTracker->SetTrackletCuts(maxangle,goodDist,vertexConstraints);
193 if( vertexConstraints )
194 fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
196 fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
198 // END ################################################# MODIFIY JMT
200 //fTracker->SetParamDone(true);
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.
210 //AliHLTTPC::SetVertexFit( kFALSE );
212 fTracker->InitVolumes();
215 void AliHLTTPCSliceTrackerComponent::SetTrackerParam( bool doPP, int multiplicity, double bField )
217 AliHLTTPCTransform::SetBField( bField );
218 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField );
222 //tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ??
223 /* the old setup used during TPC
224 SetTrackerParam( 50, 100, 3, 10,
227 5, 50, 50, 0.1, 0.1, kTRUE);
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
249 int mults[] = { 1000, 2000, 4000, 8000 };
253 int multDist, tmpMultDist;
254 if ( multiplicity>mults[closestMult] )
255 multDist = multiplicity-mults[closestMult];
257 multDist = mults[closestMult]-multiplicity;
258 for ( i = 1; i < multCount; i++ )
260 if ( multiplicity>mults[i] )
261 tmpMultDist = multiplicity-mults[i];
263 tmpMultDist = mults[i]-multiplicity;
264 if ( tmpMultDist < multDist )
267 multDist = tmpMultDist;
271 double bfs[] = { 0.2, 0.4 };
274 double bfDist, tmpBFDist;
275 if ( bField>bfs[closestBf] )
276 bfDist = bField-bfs[closestBf];
278 bfDist = bfs[closestBf]-bField;
279 for ( i = 1; i < bfCount; i++ )
282 tmpBFDist = bField-bfs[i];
284 tmpBFDist = bfs[i]-bField;
285 if ( tmpBFDist < bfDist )
292 switch ( closestMult )
298 SetTrackerParam( 50, 100, 3, 10,
301 5, 50, 50, 0.1, 0.1, kTRUE );
304 SetTrackerParam( 50, 100, 3, 10,
307 5, 50, 50, 0.1, 0.1, kTRUE );
315 SetTrackerParam( 50, 100, 3, 10,
318 5, 20, 50, 0.1, 0.1, kTRUE );
321 SetTrackerParam( 50, 100, 3, 10,
324 5, 20, 50, 0.1, 0.1, kTRUE );
332 SetTrackerParam( 50, 100, 3, 10,
335 5, 10 , 50, 0.1, 0.1, kTRUE );
338 SetTrackerParam( 50, 100, 3, 10,
341 5, 10, 50, 0.1, 0.1, kTRUE );
349 SetTrackerParam( 50, 100, 3, 10,
352 5, 5, 50, 0.1, 0.1, kTRUE );
355 SetTrackerParam( 50, 100, 3, 10,
358 5, 5, 50, 0.1, 0.1, kTRUE );
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 );
372 int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv )
374 // see header file for class documentation
375 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
377 if ( fTracker || fVertex )
379 fTracker = new AliHLTTPCConfMapper();
380 fVertex = new AliHLTTPCVertex();
383 fDoNonVertex = false;
384 Bool_t bDoMerger=kTRUE;
385 fMultiplicity = 4000;
393 if ( !strcmp( argv[i], "disable-merger" ) ){
399 if ( !strcmp( argv[i], "pp-run" ) )
405 if ( !strcmp( argv[i], "multiplicity" ) )
409 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Missing event multiplicity specifier." );
412 fMultiplicity = strtoul( argv[i+1], &cpErr, 0 );
415 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert event multiplicity specifier '%s'.", argv[i+1] );
421 if ( !strcmp( argv[i], "bfield" ) )
425 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing B-field", "Missing B-field specifier." );
428 fBField = strtod( argv[i+1], &cpErr );
431 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert B-field specifier '%s'.", argv[i+1] );
438 // BEGINN ############################################## MODIFIY JMT
439 if ( !strcmp( argv[i], "nonvertextracking" ) ){
440 fnonvertextracking = kTRUE;
445 if ( !strcmp( argv[i], "mainvertextrackingoff" ) ){
446 fmainvertextracking = kFALSE;
451 if ( !strcmp( argv[i], "etarange" ) ){
453 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Missing Eta-range specifiers." );
456 fEta[1] = strtod( argv[i+1], &cpErr );
458 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Cannot convert Eta-range specifier '%s'.", argv[i+1] );
465 // END ################################################# MODIFIY JMT
466 Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
469 // #### -B0-CHANGE-START == JMT
471 // parameter for B=0 T
473 fnonvertextracking = kTRUE;
474 fmainvertextracking = kFALSE;
476 // #### -B0-CHANGE-END == JMT
479 fpInterMerger = new AliHLTTPCInterMerger();
481 SetTrackerParam( fDoPP, fMultiplicity, fBField );
485 int AliHLTTPCSliceTrackerComponent::DoDeinit()
487 // see header file for class documentation
495 delete fpInterMerger;
501 int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
502 AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
503 AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
505 // see header file for class documentation
506 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "DoEvent()" );
507 if ( evtData.fBlockCnt<=0 )
509 Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" );
512 const AliHLTComponentBlockData* iter = NULL;
514 AliHLTTPCClusterData* inPtrSP;
515 AliHLTTPCVertexData* inPtrV = NULL;
516 const AliHLTComponentBlockData* vertexIter=NULL;
517 AliHLTTPCTrackletData* outPtr;
518 AliHLTUInt8_t* outBPtr;
519 AliHLTUInt32_t vSize = 0;
520 UInt_t offset=0, mysize, tSize = 0;
522 Int_t slice=-1, patch=-1, row[2];
523 Int_t minPatch=INT_MAX, maxPatch = 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;
529 Int_t vertexSlice=-1;
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
537 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
541 slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
543 slIter = slices.begin();
544 slEnd = slices.end();
545 slCntIter = sliceCnts.begin();
546 while ( slIter != slEnd )
548 if ( *slIter == slice )
558 slices.insert( slices.end(), slice );
559 sliceCnts.insert( sliceCnts.end(), 1 );
564 if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
566 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
569 fVertex->Read( inPtrV );
572 if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
574 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
575 if ( minPatch>patch )
578 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
580 if ( maxPatch<patch )
583 row[1] = AliHLTTPCTransform::GetLastRow( patch );
588 // Determine slice number to really use.
589 if ( slices.size()>1 )
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 )
600 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
601 "Slice %lu found %lu times.", *slIter, *slCntIter );
602 if ( maxCntSlice<*slCntIter )
604 maxCntSlice = *slCntIter;
610 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
611 "Using slice %lu.", slice );
613 else if ( slices.size()>0 )
615 slice = *(slices.begin());
622 if ( vertexSlice != slice )
624 // multiple vertex blocks in event and we used the wrong one...
626 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
629 if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
631 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
634 fVertex->Read( inPtrV );
640 fTracker->InitSector( slice, row, fEta );
641 fTracker->SetVertex(fVertex);
644 std::vector<unsigned long> patchIndices;
645 std::vector<unsigned long>::iterator pIter, pEnd;
646 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
650 if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
652 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
653 pIter = patchIndices.begin();
654 pEnd = patchIndices.end();
655 while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
657 patchIndices.insert( pIter, ndx );
660 pIter = patchIndices.begin();
661 pEnd = patchIndices.end();
662 while ( pIter!=pEnd )
667 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
668 inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
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 );
676 outPtr = (AliHLTTPCTrackletData*)(outBPtr);
677 // BEGINN ############################################## MODIFIY JMT
679 fTracker->SetPointers();
680 if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
681 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
682 fTracker->MainVertexTrackingA();
683 fTracker->MainVertexTrackingB();
684 fTracker->FillTracks();
686 else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
687 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
688 fTracker->MainVertexTrackingA();
689 fTracker->MainVertexTrackingB();
690 fTracker->FillTracks();
691 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
692 fTracker->NonVertexTracking();
694 else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
695 Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
696 fTracker->NonVertexTracking();
697 fTracker->FillTracks();
700 fTracker->MainVertexTracking_a();
701 fTracker->MainVertexTracking_b();
702 fTracker->FillTracks();
705 fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
707 // END ################################################# MODIFIY JMT
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();
721 AliHLTTPCTrackArray* pArray=fTracker->GetTracks();
722 mysize = pArray->WriteTracks( ntracks0, outPtr->fTracklets );
723 outPtr->fTrackletCnt = ntracks0;
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] );
729 tSize += mysize+sizeof(AliHLTTPCTrackletData);
730 outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
732 AliHLTComponentBlockData bd;
736 bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
737 outputBlocks.push_back( bd );
739 #ifdef FORWARD_VERTEX_BLOCK
742 // Copy the descriptor block for the vertex information.
744 outputBlocks.push_back( bd );
746 #endif // FORWARD_VERTEX_BLOCK
752 void AliHLTTPCSliceTrackerComponent::SetTrackerParam1()
754 SetTrackerParam( 10, 20, 5, 10, 2,2,
756 50, 100, 50, 0.1, 0.1,