- adjusting binning of pad histograms to make single pad cluster contribution and...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCSliceTrackerComponent.cxx
1 // $Id$
2
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 //**************************************************************************
19
20 /** @file   AliHLTTPCSliceTrackerComponent.cxx
21     @author Timm Steinbeck, Matthias Richter
22     @date   
23     @brief  The TPC conformal mapping tracker component.
24 */
25
26 #if __GNUC__>= 3
27 using namespace std;
28 #endif
29
30 #include <climits>
31 #include "AliHLTTPCSliceTrackerComponent.h"
32 #include "AliHLTTPCTransform.h"
33 #include "AliHLTTPCConfMapper.h"
34 #include "AliHLTTPCVertex.h"
35 #include "AliHLTTPCVertexData.h"
36 #include "AliHLTTPCClusterDataFormat.h"
37 #include "AliHLTTPCTransform.h"
38 #include "AliHLTTPCTrackSegmentData.h"
39 #include "AliHLTTPCTrackArray.h"
40 #include "AliHLTTPCTrackletDataFormat.h"
41 #include "AliHLTTPCInterMerger.h"
42 #include "AliHLTTPCMemHandler.h"
43 #include "AliHLTTPCDefinitions.h"
44 #include "AliHLTCommonCDBEntries.h"
45 #include "TString.h"
46 #include "TObjString.h"
47 #include "TObjArray.h"
48 #include "AliCDBEntry.h"
49 #include "AliCDBManager.h"
50 #include "AliCDBStorage.h"
51 #include "TGeoGlobalMagField.h"
52 //#include "AliHLTTPC.h"
53 //#include <stdlib.h>
54 //#include <cerrno>
55
56 /** ROOT macro for the implementation of ROOT specific class methods */
57 ClassImp(AliHLTTPCSliceTrackerComponent)
58
59 AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
60   :
61   fTracker(NULL),
62   fVertex(NULL),
63   fDoNonVertex(false),
64   fDoPP(false),
65   fDoPbPb(false),
66   fMultiplicity(4000),
67   fBField(0.5),
68   fnonvertextracking(kFALSE),
69   fmainvertextracking(kTRUE),
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),
84   fMaxeta(0.1),
85   fpInterMerger(NULL)
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
96 AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
97 {
98   // see header file for class documentation
99 }
100
101 // Public functions to implement AliHLTComponent's interface.
102 // These functions are required for the registration process
103
104 const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
105 {
106   // see header file for class documentation
107
108   return "TPCSliceTracker";
109 }
110
111 void AliHLTTPCSliceTrackerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
112 {
113   // see header file for class documentation
114   list.clear();
115   list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
116   list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
117 }
118
119 AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
120 {
121   // see header file for class documentation
122   return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
123 }
124
125 void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
126 {
127   // see header file for class documentation
128   // XXX TODO: Find more realistic values.
129   constBase = 0;
130   inputMultiplier = 1;
131 }
132
133 AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
134 {
135   // see header file for class documentation
136   return new AliHLTTPCSliceTrackerComponent;
137 }
138
139 void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phiSegments, Int_t etaSegments,
140                                    Int_t trackletlength, Int_t tracklength,
141                                    Int_t rowscopetracklet, Int_t rowscopetrack,
142                                    Double_t minPtFit, Double_t maxangle,
143                                    Double_t goodDist, Double_t hitChi2Cut,
144                                    Double_t goodHitChi2, Double_t trackChi2Cut,
145                                    Int_t maxdist, Double_t maxphi,Double_t maxeta)
146 {
147   // see header file for class documentation
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     
152     fTracker->SetNSegments(phiSegments,etaSegments);
153     fTracker->SetMaxDca(minPtFit);
154     //   fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
155
156     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
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);    
163         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
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);     
173         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
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);
180         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
181     }
182     
183     //fTracker->SetParamDone(true);
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      */
193     //AliHLTTPC::SetVertexFit( kFALSE );
194     
195     fTracker->InitVolumes();
196     }
197
198
199 void 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       
212       SetTrackerParam( 50, 100, 3, 60,
213                        6, 6,
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++ )
229         {
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             }
239         }
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++ )
250         {
251           if ( bField>bfs[i] )
252             tmpBFDist = bField-bfs[i];
253           else
254             tmpBFDist = bfs[i]-bField;
255           if ( tmpBFDist < bfDist )
256             {
257               closestBf = i;
258               bfDist = tmpBFDist;
259             }
260         }
261       
262       switch ( closestMult )
263         {
264         case 0: // 1000
265           switch ( closestBf )
266             {
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;
279             }
280           break;
281         case 1: // 2000
282           switch ( closestBf )
283             {
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;
330             }
331           break;
332         }
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 );
337     }
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 }
346         
347 int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv )
348     {
349   // see header file for class documentation
350     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
351
352     if ( fTracker || fVertex )
353         return EINPROGRESS;
354     fTracker = new AliHLTTPCConfMapper();
355     fVertex = new AliHLTTPCVertex();
356     fEta[0] = 0.;
357     fEta[1] = 1.1;
358     fDoNonVertex = false;
359     fMultiplicity = 4000;
360     fBField = 0.5;
361     fDoPP = false;
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;
378     int iResult=0;
379         
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     }
387
388     if (!configuration.IsNull()) {
389       iResult=Configure(configuration.Data());
390     } else {
391       iResult=Reconfigure(NULL, NULL);
392     }
393     
394     return iResult;
395     }
396
397 int AliHLTTPCSliceTrackerComponent::DoDeinit()
398 {
399   // see header file for class documentation
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 }
412
413 int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
414                                               AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
415                                               AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks )
416 {
417   // see header file for class documentation
418   int iResult=0;
419   AliHLTUInt32_t capacity=size;
420   size=0;
421
422   if (!IsDataEvent()) return 0;
423
424     if ( evtData.fBlockCnt<=0 )
425       {
426         Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" );
427         return 0;
428       }
429     const AliHLTComponentBlockData* iter = NULL;
430     unsigned long ndx;
431     AliHLTTPCClusterData* inPtrSP;
432     AliHLTTPCVertexData* inPtrV = NULL;
433 #ifdef FORWARD_VERTEX_BLOCK
434     const AliHLTComponentBlockData* vertexIter=NULL;
435 #endif
436     AliHLTTPCTrackletData* outPtr;
437     AliHLTUInt8_t* outBPtr;
438     //AliHLTUInt32_t vSize = 0;
439     UInt_t offset=0, mysize, tSize = 0;
440     outBPtr = outputPtr;
441     Int_t slice=-1, patch=-1, row[2];
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;
448     Int_t vertexSlice=-1;
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
460         bool bIsClusterDataBlock=false;
461         bool bIsVertexDataBlock=false;
462         if(!(bIsClusterDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkClustersDataType)) &&
463            !(bIsVertexDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkVertexDataType))){
464           continue;
465         }
466
467         slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
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         }
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
504         if (bIsVertexDataBlock)
505             {
506             inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
507 #ifdef FORWARD_VERTEX_BLOCK
508             vertexIter = iter;
509 #endif
510             //vSize = iter->fSize;
511             fVertex->Read( inPtrV );
512             vertexSlice = slice;
513             }
514         if (bIsClusterDataBlock)
515             {
516             patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
517             if ( minPatch>patch )
518                 {
519                 minPatch = patch;
520                 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
521                 }
522             if ( maxPatch<patch )
523                 {
524                 maxPatch = patch;
525                 row[1] = AliHLTTPCTransform::GetLastRow( patch );
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         }
555     else if ( slices.size()>0 )
556       {
557         slice = *(slices.begin());
558       }
559     else
560       {
561         // there is no sense in running the tracker without input, do not send an
562         // empty output block
563         return iResult;
564       }
565     
566     iResult=0;
567
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;
575             if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
576                 {
577                 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
578 #ifdef FORWARD_VERTEX_BLOCK
579                 vertexIter = iter;
580 #endif
581                 //vSize = iter->fSize;
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
592     std::vector<unsigned long> patchIndices;
593     std::vector<unsigned long>::iterator pIter, pEnd;
594     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
595         {
596         iter = blocks+ndx;
597
598         if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
599             {
600             patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
601             pIter = patchIndices.begin();
602             pEnd = patchIndices.end();
603             while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
604                 pIter++;
605             patchIndices.insert( pIter, ndx );
606             }
607         }
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 );
620         //fTracker->ReadHits( inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints );
621         fTracker->ReadHitsChecked(inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints,iter->fSize );
622         pIter++;
623         }
624
625
626     if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){ 
627       Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
628       fTracker->MainVertexTrackingA();
629       fTracker->MainVertexTrackingB();
630       fTracker->FillTracks();
631     }
632     else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){     
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();
639     }
640     else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
641       Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
642       fTracker->NonVertexTracking();    
643       fTracker->FillTracks();   
644     }
645
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;
658     AliHLTTPCTrackArray* pArray=fTracker->GetTracks();
659     if (pArray->GetOutSize()+sizeof(AliHLTTPCTrackletData)<=capacity) {
660     outPtr = (AliHLTTPCTrackletData*)(outBPtr);
661     mysize = pArray->WriteTracks( ntracks0, outPtr->fTracklets );
662     outPtr->fTrackletCnt = ntracks0;
663
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;
672     for (unsigned int trackno=0; trackno<ntracks0; trackno++, segment++) {
673       segment->fCharge*=-1;
674     }
675
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
680     fTracker->Reset();
681
682     AliHLTComponentBlockData bd;
683     FillBlockData( bd );
684     bd.fOffset = offset;
685     bd.fSize = mysize+sizeof(AliHLTTPCTrackletData);
686     bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
687     outputBlocks.push_back( bd );
688
689     tSize += bd.fSize;
690     outBPtr += bd.fSize;
691     } else {
692       iResult=-ENOSPC;
693     }
694
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;
705     return iResult;
706     }
707
708 int AliHLTTPCSliceTrackerComponent::Configure(const char* arguments)
709 {
710   // see header file for class documentation
711   int iResult=0;
712   if (!arguments) return iResult;
713   
714   // Check field
715   if (!TGeoGlobalMagField::Instance()) {
716     HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF");
717     return -ENODEV;
718   }
719
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       } 
762       else if (argument.CompareTo("-solenoidBz")==0) {
763         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
764         HLTWarning("parameter -solenoidBz deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField");
765         continue;
766       } 
767       else if (argument.CompareTo("-bfield")==0) {
768         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
769         HLTWarning("parameter -bfield deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField");
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       }
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       }
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   }
832   fBField=GetBz()/10.0;
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
850 int 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   
858     const char* pathBField=NULL;
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
889 int AliHLTTPCSliceTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
890 {
891   // see header file for class documentation
892
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 {
912       HLTError("cannot fetch object \"%s\" from CDB", path);
913     }
914   }
915
916   const char* pathBField=NULL;
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 {
930       HLTError("cannot fetch object \"%s\" from CDB", path);
931     }
932   }
933   
934   return iResult;
935
936 }
937
938 void AliHLTTPCSliceTrackerComponent::SetTrackerParam1()
939 {
940   // see header file for class documentation
941   SetTrackerParam( 10, 20, 5, 10, 2,2,
942                    0, 1.31, 5, 100,
943                    50, 100, 50, 0.1, 0.1);
944 }
945
946