]> git.uio.no Git - u/mrichter/AliRoot.git/blob - HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
Update master to aliroot
[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCATrackerComponent.cxx
1 // @(#) $Id$
2 // **************************************************************************
3 // This file is property of and copyright by the ALICE HLT Project          *
4 // ALICE Experiment at CERN, All rights reserved.                           *
5 //                                                                          *
6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 //                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
8 //                  for The ALICE HLT Project.                              *
9 //                                                                          *
10 // Permission to use, copy, modify and distribute this software and its     *
11 // documentation strictly for non-commercial purposes is hereby granted     *
12 // without fee, provided that the above copyright notice appears in all     *
13 // copies and that both the copyright notice and this permission notice     *
14 // appear in the supporting documentation. The authors make no claims       *
15 // about the suitability of this software for any purpose. It is            *
16 // provided "as is" without express or implied warranty.                    *
17 //                                                                          *
18 //***************************************************************************
19
20
21 ///////////////////////////////////////////////////////////////////////////////
22 //                                                                           //
23 // a TPC tracker processing component for the HLT based on CA by Ivan Kisel  //
24 //                                                                           //
25 ///////////////////////////////////////////////////////////////////////////////
26
27 #if __GNUC__>= 3
28 using namespace std;
29 #endif
30
31 #include "AliHLTTPCCATrackerComponent.h"
32 #include "AliHLTTPCTransform.h"
33 #include "AliHLTTPCCATrackerFramework.h"
34 #include "AliHLTTPCCAParam.h"
35 #include "AliHLTTPCCATrackConvertor.h"
36 #include "AliHLTArray.h"
37
38 #include "AliHLTTPCSpacePointData.h"
39 #include "AliHLTTPCClusterDataFormat.h"
40 #include "AliHLTTPCCACompressedInputData.h"
41 #include "AliHLTTPCTransform.h"
42 #include "AliHLTTPCDefinitions.h"
43 #include "AliExternalTrackParam.h"
44 #include "TMath.h"
45 #include "AliCDBEntry.h"
46 #include "AliCDBManager.h"
47 #include "TObjString.h"
48 #include "TObjArray.h"
49 #include "AliHLTTPCCASliceOutput.h"
50 #include "AliHLTTPCCAClusterData.h"
51
52 const AliHLTComponentDataType AliHLTTPCCADefinitions::fgkTrackletsDataType = AliHLTComponentDataTypeInitializer( "CATRACKL", kAliHLTDataOriginTPC );
53
54 /** ROOT macro for the implementation of ROOT specific class methods */
55 ClassImp( AliHLTTPCCATrackerComponent )
56
57   AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
58   :
59   fTracker( NULL ),
60   fClusterData( NULL ),
61   fMinSlice( 0 ),
62   fSliceCount( fgkNSlices ),
63   fSolenoidBz( 0 ),
64   fMinNTrackClusters( 30 ),
65   fMinTrackPt(0.2),
66   fClusterZCut( 500. ),
67   fNeighboursSearchArea( 0 ), 
68   fClusterErrorCorrectionY(0), 
69   fClusterErrorCorrectionZ(0),
70   fBenchmark("CATracker"), 
71   fAllowGPU( 0),
72   fGPUHelperThreads(-1),
73   fCPUTrackers(0),
74   fGlobalTracking(0),
75   fGPUDeviceNum(-1),
76   fGPULibrary("")
77 {
78   // see header file for class documentation
79   // or
80   // refer to README to build package
81   // or
82   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
83   for( int i=0; i<fgkNSlices; i++ ){
84     fSliceOutput[i] = NULL;
85   }
86 }
87
88 AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent( const AliHLTTPCCATrackerComponent& )
89   :
90 AliHLTProcessor(),
91   fTracker( NULL ),
92   fClusterData( NULL ),
93   fMinSlice( 0 ),
94   fSliceCount( fgkNSlices ),
95   fSolenoidBz( 0 ),
96   fMinNTrackClusters( 30 ),
97   fMinTrackPt( 0.2 ),
98   fClusterZCut( 500. ),
99   fNeighboursSearchArea(0),
100   fClusterErrorCorrectionY(0), 
101   fClusterErrorCorrectionZ(0),
102   fBenchmark("CATracker"),
103   fAllowGPU( 0),
104   fGPUHelperThreads(-1),
105   fCPUTrackers(0),
106   fGlobalTracking(0),
107   fGPUDeviceNum(-1),
108   fGPULibrary("")
109 {
110   // see header file for class documentation
111   for( int i=0; i<fgkNSlices; i++ ){
112     fSliceOutput[i] = NULL;
113   }
114   HLTFatal( "copy constructor untested" );
115 }
116
117 AliHLTTPCCATrackerComponent& AliHLTTPCCATrackerComponent::operator=( const AliHLTTPCCATrackerComponent& )
118 {
119   // see header file for class documentation
120   for( int i=0; i<fgkNSlices; i++ ){
121     fSliceOutput[i] = NULL;
122   }
123   HLTFatal( "assignment operator untested" );
124   return *this;
125 }
126
127 AliHLTTPCCATrackerComponent::~AliHLTTPCCATrackerComponent()
128 {
129   // see header file for class documentation
130   if (fTracker) delete fTracker;
131   if (fClusterData) delete[] fClusterData;
132 }
133
134 //
135 // Public functions to implement AliHLTComponent's interface.
136 // These functions are required for the registration process
137 //
138
139 const char* AliHLTTPCCATrackerComponent::GetComponentID()
140 {
141   // see header file for class documentation
142   return "TPCCATracker";
143 }
144
145 void AliHLTTPCCATrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list )
146 {
147   // see header file for class documentation
148   list.clear();
149   list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
150   list.push_back( AliHLTTPCCADefinitions::fgkCompressedInputDataType );
151 }
152
153 AliHLTComponentDataType AliHLTTPCCATrackerComponent::GetOutputDataType()
154 {
155   // see header file for class documentation
156   return AliHLTTPCCADefinitions::fgkTrackletsDataType;
157 }
158
159 void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
160 {
161   // define guess for the output data size
162   constBase = 1200;       // minimum size
163   inputMultiplier = 0.6; // size relative to input
164 }
165
166 AliHLTComponent* AliHLTTPCCATrackerComponent::Spawn()
167 {
168   // see header file for class documentation
169   return new AliHLTTPCCATrackerComponent;
170 }
171
172 void AliHLTTPCCATrackerComponent::SetDefaultConfiguration()
173 {
174   // Set default configuration for the CA tracker component
175   // Some parameters can be later overwritten from the OCDB
176
177   fSolenoidBz = -5.00668;
178   fMinNTrackClusters = 30;
179   fMinTrackPt = 0.2;
180   fClusterZCut = 500.;
181   fNeighboursSearchArea = 0;
182   fClusterErrorCorrectionY = 0;
183   fClusterErrorCorrectionZ = 0;
184   fBenchmark.Reset();
185   fBenchmark.SetTimer(0,"total");
186   fBenchmark.SetTimer(1,"reco");
187 }
188
189 int AliHLTTPCCATrackerComponent::ReadConfigurationString(  const char* arguments )
190 {
191   // Set configuration parameters for the CA tracker component from the string
192
193   int iResult = 0;
194   if ( !arguments ) return iResult;
195
196   TString allArgs = arguments;
197   TString argument;
198   int bMissingParam = 0;
199
200   TObjArray* pTokens = allArgs.Tokenize( " " );
201
202   int nArgs =  pTokens ? pTokens->GetEntries() : 0;
203
204   for ( int i = 0; i < nArgs; i++ ) {
205     argument = ( ( TObjString* )pTokens->At( i ) )->GetString();
206     if ( argument.IsNull() ) continue;
207
208     if ( argument.CompareTo( "-solenoidBz" ) == 0 ) {
209       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
210       HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz());
211       continue;
212     }
213
214     if ( argument.CompareTo( "-minNClustersOnTrack" ) == 0 ) {
215       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
216       fMinNTrackClusters = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
217       HLTInfo( "minNClustersOnTrack set to: %d", fMinNTrackClusters );
218       continue;
219     }
220
221     if ( argument.CompareTo( "-minTrackPt" ) == 0 ) {
222       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
223       fMinTrackPt = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
224       HLTInfo( "minTrackPt set to: %f", fMinTrackPt );
225       continue;
226     }
227
228     if ( argument.CompareTo( "-clusterZCut" ) == 0 ) {
229       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
230       fClusterZCut = TMath::Abs( ( ( TObjString* )pTokens->At( i ) )->GetString().Atof() );
231       HLTInfo( "ClusterZCut set to: %f", fClusterZCut );
232       continue;
233     }
234
235     if ( argument.CompareTo( "-neighboursSearchArea" ) == 0 ) {
236       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
237       fNeighboursSearchArea = TMath::Abs( ( ( TObjString* )pTokens->At( i ) )->GetString().Atof() );
238       HLTInfo( "NeighboursSearchArea set to: %f", fNeighboursSearchArea );
239       continue;
240     }
241
242     if ( argument.CompareTo( "-errorCorrectionY" ) == 0 ) {
243       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
244       fClusterErrorCorrectionY = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
245       HLTInfo( "Cluster Y error correction factor set to: %f", fClusterErrorCorrectionY );
246       continue;
247     }
248
249     if ( argument.CompareTo( "-errorCorrectionZ" ) == 0 ) {
250       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
251       fClusterErrorCorrectionZ = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
252       HLTInfo( "Cluster Z error correction factor set to: %f", fClusterErrorCorrectionZ );
253       continue;
254     }
255
256     if (argument.CompareTo( "-allowGPU" ) == 0) {
257       fAllowGPU = 1;
258       HLTImportant( "Will try to run tracker on GPU" );
259       continue;
260     }
261
262     if (argument.CompareTo( "-GlobalTracking" ) == 0) {
263       fGlobalTracking = 1;
264       HLTImportant( "Global Tracking Activated" );
265       continue;
266     }
267
268     if ( argument.CompareTo( "-GPUHelperThreads" ) == 0 ) {
269       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
270       fGPUHelperThreads = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
271       HLTInfo( "Number of GPU Helper Threads set to: %d", fGPUHelperThreads );
272       continue;
273     }
274
275     if ( argument.CompareTo( "-CPUTrackers" ) == 0 ) {
276       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
277       fCPUTrackers = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
278       HLTInfo( "Number of CPU Trackers set to: %d", fCPUTrackers );
279       continue;
280     }
281
282     if ( argument.CompareTo( "-GPUDeviceNum" ) == 0 ) {
283       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
284       fGPUDeviceNum = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
285       HLTInfo( "Using GPU Device Number %d", fGPUDeviceNum );
286       continue;
287     }
288
289     if ( argument.CompareTo( "-GPULibrary" ) == 0 ) {
290       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
291       fGPULibrary = ( ( TObjString* )pTokens->At( i ) )->GetString();
292       continue;
293     }
294         
295         HLTError( "Unknown option \"%s\"", argument.Data() );
296     iResult = -EINVAL;
297   }
298   delete pTokens;
299
300   if ( bMissingParam ) {
301     HLTError( "Specifier missed for parameter \"%s\"", argument.Data() );
302     iResult = -EINVAL;
303   }
304
305   return iResult;
306 }
307
308
309 int AliHLTTPCCATrackerComponent::ReadCDBEntry( const char* cdbEntry, const char* chainId )
310 {
311   // see header file for class documentation
312
313   const char* defaultNotify = "";
314
315   if ( !cdbEntry ) {
316     cdbEntry = "HLT/ConfigTPC/TPCCATracker";
317     defaultNotify = " (default)";
318     chainId = 0;
319   }
320
321   HLTInfo( "configure from entry \"%s\"%s, chain id %s", cdbEntry, defaultNotify, ( chainId != NULL && chainId[0] != 0 ) ? chainId : "<none>" );
322   AliCDBEntry *pEntry = AliCDBManager::Instance()->Get( cdbEntry );//,GetRunNo());
323
324   if ( !pEntry ) {
325     HLTError( "cannot fetch object \"%s\" from CDB", cdbEntry );
326     return -EINVAL;
327   }
328
329   TObjString* pString = dynamic_cast<TObjString*>( pEntry->GetObject() );
330
331   if ( !pString ) {
332     HLTError( "configuration object \"%s\" has wrong type, required TObjString", cdbEntry );
333     return -EINVAL;
334   }
335
336   HLTInfo( "received configuration object string: \"%s\"", pString->GetString().Data() );
337
338   return  ReadConfigurationString( pString->GetString().Data() );
339 }
340
341
342 int AliHLTTPCCATrackerComponent::Configure( const char* cdbEntry, const char* chainId, const char *commandLine )
343 {
344   // Configure the component
345   // There are few levels of configuration,
346   // parameters which are set on one step can be overwritten on the next step
347
348   //* read hard-coded values
349   SetDefaultConfiguration();
350
351   //* read the default CDB entry
352   int iResult1 = ReadCDBEntry( NULL, chainId );
353
354   //* read magnetic field
355   fSolenoidBz = GetBz();
356
357   //* read the actual CDB entry if required
358   int iResult2 = ( cdbEntry ) ? ReadCDBEntry( cdbEntry, chainId ) : 0;
359
360   //* read extra parameters from input (if they are)
361   int iResult3 = 0;
362
363   if ( commandLine && commandLine[0] != '\0' ) {
364     HLTInfo( "received configuration string from HLT framework: \"%s\"", commandLine );
365     iResult3 = ReadConfigurationString( commandLine );
366   }
367
368   if (fTracker) ConfigureSlices();
369
370   return iResult1 ? iResult1 : ( iResult2 ? iResult2 :  iResult3  );
371 }
372
373 void AliHLTTPCCATrackerComponent::ConfigureSlices()
374 {
375   // Initialize the tracker slices
376   for (int slice = 0;slice < fgkNSlices;slice++)
377   {
378     int iSec = slice;
379     float inRmin = 83.65;
380     //    float inRmax = 133.3;
381     //    float outRmin = 133.5;
382     float outRmax = 247.7;
383     float plusZmin = 0.0529937;
384     float plusZmax = 249.778;
385     float minusZmin = -249.645;
386     float minusZmax = -0.0799937;
387     float dalpha = 0.349066;
388     float alpha = 0.174533 + dalpha * iSec;
389
390     bool zPlus = ( iSec < 18 );
391     float zMin =  zPlus ? plusZmin : minusZmin;
392     float zMax =  zPlus ? plusZmax : minusZmax;
393     //TPCZmin = -249.645, ZMax = 249.778
394     //    float rMin =  inRmin;
395     //    float rMax =  outRmax;
396     int nRows = AliHLTTPCTransform::GetNRows();
397
398     float padPitch = 0.4;
399     float sigmaZ = 0.228808;
400
401     float *rowX = new float [nRows];
402     for ( int irow = 0; irow < nRows; irow++ ) {
403       rowX[irow] = AliHLTTPCTransform::Row2X( irow );
404     }
405
406     AliHLTTPCCAParam param;
407
408     param.Initialize( iSec, nRows, rowX, alpha, dalpha,
409       inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );
410     param.SetHitPickUpFactor( 2 );
411     if( fNeighboursSearchArea>0 ) param.SetNeighboursSearchArea( fNeighboursSearchArea );
412     if( fClusterErrorCorrectionY>1.e-4 ) param.SetClusterError2CorrectionY( fClusterErrorCorrectionY*fClusterErrorCorrectionY );
413     if( fClusterErrorCorrectionZ>1.e-4 ) param.SetClusterError2CorrectionZ( fClusterErrorCorrectionZ*fClusterErrorCorrectionZ );
414     param.SetMinNTrackClusters( fMinNTrackClusters );
415     param.SetMinTrackPt( fMinTrackPt );
416
417     param.Update();
418     fTracker->InitializeSliceParam( slice, param );
419     delete[] rowX;
420   }
421 }
422
423 int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
424 {
425   if ( fTracker ) return EINPROGRESS;
426
427   // Configure the CA tracker component
428   TString arguments = "";
429   for ( int i = 0; i < argc; i++ ) {
430     if ( !arguments.IsNull() ) arguments += " ";
431     arguments += argv[i];
432   }
433
434   int retVal = Configure( NULL, NULL, arguments.Data() );
435   if (retVal == 0)
436   {
437     fMinSlice = 0;
438     fSliceCount = fgkNSlices;
439     //Create tracker instance and set parameters
440     fTracker = new AliHLTTPCCATrackerFramework(fAllowGPU, fGPULibrary, fGPUDeviceNum);
441     if ( fAllowGPU && fTracker->GetGPUStatus() < 2 ) {
442       HLTError("GPU Tracker requested but unavailable, aborting.");
443       return -ENODEV;
444     }
445     fClusterData = new AliHLTTPCCAClusterData[fgkNSlices];
446     if (fGPUHelperThreads != -1)
447     {
448       char cc[256] = "HelperThreads";
449       fTracker->SetGPUTrackerOption(cc, fGPUHelperThreads);
450     }
451     {
452       char cc[256] = "CPUTrackers";
453       fTracker->SetGPUTrackerOption(cc, fCPUTrackers);
454       char cc2[256] = "SlicesPerCPUTracker";
455       fTracker->SetGPUTrackerOption(cc2, 1);
456     }
457     if (fGlobalTracking)
458     {
459       char cc[256] = "GlobalTracking";
460       fTracker->SetGPUTrackerOption(cc, 1);
461     }
462
463     ConfigureSlices();
464   }
465
466   return(retVal);
467 }
468
469 int AliHLTTPCCATrackerComponent::DoDeinit()
470 {
471   // see header file for class documentation
472   if (fTracker) delete fTracker;
473   fTracker = NULL;
474   if (fClusterData) delete[] fClusterData;
475   fClusterData = NULL;
476   return 0;
477 }
478
479 int AliHLTTPCCATrackerComponent::Reconfigure( const char* cdbEntry, const char* chainId )
480 {
481   // Reconfigure the component from OCDB .
482   return Configure( cdbEntry, chainId, NULL );
483 }
484
485 int AliHLTTPCCATrackerComponent::DoEvent
486   (
487   const AliHLTComponentEventData& evtData,
488   const AliHLTComponentBlockData* blocks,
489   AliHLTComponentTriggerData& /*trigData*/,
490   AliHLTUInt8_t* outputPtr,
491   AliHLTUInt32_t& size,
492   vector<AliHLTComponentBlockData>& outputBlocks )
493 {
494   //* process event
495   if (!fTracker)
496   {
497     HLTError( "CATracker not initialized properly" );
498     return -ENOENT;
499   }
500
501   AliHLTUInt32_t maxBufferSize = size;
502   size = 0; // output size
503
504   if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) ) {
505     return 0;
506   }
507
508   fBenchmark.StartNewEvent();
509   fBenchmark.Start(0);
510
511   //Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "CA::DoEvent()" );
512   if ( evtData.fBlockCnt <= 0 ) {
513     HLTWarning( "no blocks in event" );
514     return 0;
515   }
516
517   const AliHLTComponentBlockData* iter = NULL;
518   unsigned long ndx;
519
520   // min and max patch numbers and row numbers
521   int sliceminPatch[fgkNSlices];
522   int slicemaxPatch[fgkNSlices];
523   for (int i = 0;i < fSliceCount;i++)
524   {
525     sliceminPatch[i] = 100;
526     slicemaxPatch[i] = -1;
527   }
528
529   //Prepare everything for all slices
530
531   for (int islice = 0;islice < fSliceCount;islice++)
532   {
533     int slice = fMinSlice + islice;
534
535     // total n Hits
536     int nClustersTotal = 0;
537
538     // sort patches
539     std::vector<unsigned long> patchIndices;
540
541     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) {
542       iter = blocks + ndx;
543       if ( slice != AliHLTTPCDefinitions::GetMinSliceNr( *iter ) ) continue;
544       if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType ){
545         AliHLTTPCClusterData* inPtrSP = ( AliHLTTPCClusterData* )( iter->fPtr );
546         nClustersTotal += inPtrSP->fSpacePointCnt;
547         fBenchmark.AddInput(iter->fSize);
548       } else 
549         if ( iter->fDataType == AliHLTTPCCADefinitions::fgkCompressedInputDataType){
550           fBenchmark.AddInput(iter->fSize);
551           const AliHLTUInt8_t * inPtr =  (const AliHLTUInt8_t *)iter->fPtr;
552           while( inPtr< ((const AliHLTUInt8_t *) iter->fPtr) + iter->fSize ){
553             AliHLTTPCCACompressedClusterRow *row = (AliHLTTPCCACompressedClusterRow*)inPtr;
554             nClustersTotal+= row->fNClusters;    
555             inPtr = (const AliHLTUInt8_t *)(row->fClusters+row->fNClusters);
556           }
557         }
558         else continue;
559
560         int patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
561         if ( sliceminPatch[islice] > patch ) {
562           sliceminPatch[islice] = patch;
563         }
564         if ( slicemaxPatch[islice] < patch ) {
565           slicemaxPatch[islice] = patch;
566         }
567         std::vector<unsigned long>::iterator pIter = patchIndices.begin();
568         while ( pIter != patchIndices.end() && AliHLTTPCDefinitions::GetMinPatchNr( blocks[*pIter] ) < patch ) {
569           pIter++;
570         }
571         patchIndices.insert( pIter, ndx );
572     }
573
574
575     // pass event to CA Tracker
576
577
578     Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reading hits",
579       "Total %d hits to read for slice %d", nClustersTotal, slice );
580
581     if (nClustersTotal > 500000)
582     {
583       HLTWarning( "Too many clusters in tracker input: Slice %d, Number of Clusters %d, slice not included in tracking", slice, nClustersTotal );
584       fClusterData[islice].StartReading( slice, 0 );
585     }
586     else
587     {
588       fClusterData[islice].StartReading( slice, nClustersTotal );
589
590       for ( std::vector<unsigned long>::iterator pIter = patchIndices.begin(); pIter != patchIndices.end(); pIter++ ) {
591         ndx = *pIter;
592         iter = blocks + ndx;
593         int patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
594         int nPatchClust = 0;
595
596         if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType ) {
597           AliHLTTPCCAClusterData::Data* pCluster = &fClusterData[islice].Clusters()[fClusterData[islice].NumberOfClusters()];
598           AliHLTTPCClusterData* inPtrSP = ( AliHLTTPCClusterData* )( iter->fPtr );
599           nPatchClust = inPtrSP->fSpacePointCnt;
600           const AliHLTTPCSpacePointData* pLastSpacePoint = &inPtrSP->fSpacePoints[inPtrSP->fSpacePointCnt];
601           for ( const AliHLTTPCSpacePointData* pSpacePoint = inPtrSP->fSpacePoints; pSpacePoint < pLastSpacePoint; pSpacePoint++ ) {
602             if ( pSpacePoint->fZ > fClusterZCut || pSpacePoint->fZ < -fClusterZCut) continue;
603             pCluster->fId = pSpacePoint->fID;
604             pCluster->fRow = pSpacePoint->fPadRow;
605             pCluster->fX = pSpacePoint->fX;
606             pCluster->fY = pSpacePoint->fY;
607             pCluster->fZ = pSpacePoint->fZ;
608             pCluster->fAmp = pSpacePoint->fCharge;
609             pCluster++;
610           }
611           fClusterData[islice].SetNumberOfClusters(pCluster - fClusterData[islice].Clusters());
612         }
613         else if ( iter->fDataType == AliHLTTPCCADefinitions::fgkCompressedInputDataType)
614         {
615           const AliHLTUInt8_t * inPtr = (const AliHLTUInt8_t *)iter->fPtr;
616           nPatchClust=0;
617           while( inPtr< ((const AliHLTUInt8_t *)iter->fPtr) + iter->fSize ){
618             AliHLTTPCCACompressedClusterRow *row = (AliHLTTPCCACompressedClusterRow*)inPtr;
619             UInt_t id = row->fSlicePatchRowID;
620             UInt_t jslice = id>>10;    
621             UInt_t jpatch = (id>>6) & 0x7;
622             UInt_t jrow   =  id     & 0x3F;     
623             jrow+= AliHLTTPCTransform::GetFirstRow( jpatch );
624             Double_t rowX = AliHLTTPCTransform::Row2X( jrow );
625             //cout<<"Read row: s "<<jslice<<" p "<<jpatch<<" r "<<jrow<<" x "<<row->fX<<" nclu "<<row->fNClusters<<" :"<<endl;
626             if( jrow > 159 ) {
627               HLTError( "Wrong TPC cluster with row number %d received", jrow );
628               continue;
629             }
630             for ( unsigned int i = 0; i < row->fNClusters; i++ ) {
631               AliHLTTPCCACompressedCluster *c = &( row->fClusters[i] );
632
633               UInt_t ix0 = c->fP0 >>24;
634               UInt_t ix1 = c->fP1 >>24;
635               Double_t x = (ix1<<8) + ix0;
636               Double_t y = c->fP0 & 0x00FFFFFF;
637               Double_t z = c->fP1 & 0x00FFFFFF;
638               x = (x - 32768.)*1.e-4 + rowX;
639               y = (y - 8388608.)*1.e-4;
640               z = (z - 8388608.)*1.e-4;
641
642               UInt_t cluId = AliHLTTPCSpacePointData::GetID( jslice, jpatch, nPatchClust );
643               //cout<<"clu "<<i<<": "<<x<<" "<<y<<" "<<z<<" "<<cluId<<endl;
644               if ( CAMath::Abs( z ) <= fClusterZCut){
645                 fClusterData[islice].ReadCluster( cluId, jrow, x, y, z, 0 );
646               }
647               nPatchClust++;      
648             }
649             inPtr = (const AliHLTUInt8_t *)(row->fClusters+row->fNClusters);
650           }
651         }
652         Logging( kHLTLogInfo, "HLT::TPCCATracker::DoEvent", "Reading hits",
653           "Read %d hits for slice %d - patch %d", nPatchClust, slice, patch );
654       }
655     }
656   }
657
658   //Prepare Output
659   AliHLTTPCCASliceOutput::outputControlStruct outputControl;
660   outputControl.fEndOfSpace = 0;
661   outputControl.fOutputPtr =  (char*) outputPtr;
662   outputControl.fOutputMaxSize = maxBufferSize;
663   fTracker->SetOutputControl(&outputControl);
664
665   memset(fSliceOutput, 0, fSliceCount * sizeof(AliHLTTPCCASliceOutput*));
666
667   // reconstruct the event
668   fBenchmark.Start(1);
669   fTracker->ProcessSlices(fMinSlice, fSliceCount, fClusterData, fSliceOutput);
670   fBenchmark.Stop(1);
671
672   int ret = 0;
673   unsigned int mySize = 0;
674   int ntracks = 0;
675   int error = 0;
676
677   for (int islice = 0;islice < fSliceCount;islice++)
678   {
679     if (slicemaxPatch[islice] == -1) continue;
680     int slice = fMinSlice + islice;
681
682     if( outputControl.fEndOfSpace ){
683       HLTWarning( "Output buffer size exceeded (buffer size %d, required size %d), tracks are not stored", maxBufferSize, mySize );
684       ret = -ENOSPC;
685       error = 1;
686       break;     
687     }
688
689     if (fSliceOutput[islice])
690     {
691       // write reconstructed tracks
692       Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct", "%d tracks found for slice %d", fSliceOutput[islice]->NTracks(), slice );
693
694       mySize += fSliceOutput[islice]->Size();
695       ntracks += fSliceOutput[islice]->NTracks();    
696     }
697     else
698     {
699       HLTWarning( "Error during Tracking, no tracks stored" );
700       mySize = 0;
701       ret = -ENOSPC;
702       ntracks = 0;
703       error = 1;
704       break;
705     }
706   }
707
708   size = 0;
709   if (error == 0)
710   {
711     for (int islice = 0;islice < fSliceCount && fSliceOutput[islice];islice++)
712     {
713       int slice = fMinSlice + islice;
714
715       mySize = fSliceOutput[islice]->Size();
716       if (mySize > 0)
717       {
718         AliHLTComponentBlockData bd;
719         FillBlockData( bd );
720         bd.fOffset = ((char*) fSliceOutput[islice] - (char*) outputPtr);
721         bd.fSize = mySize;
722         bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, sliceminPatch[islice], slicemaxPatch[islice] );
723         bd.fDataType = GetOutputDataType();
724         outputBlocks.push_back( bd );
725         size += mySize;
726         fBenchmark.AddOutput(bd.fSize);
727       }
728     }
729   }
730
731   //No longer needed
732
733   fBenchmark.Stop(0);
734
735   // Set log level to "Warning" for on-line system monitoring
736
737   //Min and Max Patch are taken for first slice processed...
738
739   fBenchmark.SetName(Form("CATracker"));
740
741   HLTInfo(fBenchmark.GetStatistics());
742   //No longer needed
743
744   return ret;
745 }
746
747