1. Output data compression in the clusterfinder component is removed because it doesn...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCClusterFinderComponent.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: Timm Steinbeck, Matthias Richter                      *
8 //* Developers:      Kenneth Aamodt <kenneth.aamodt@student.uib.no>        *
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   AliHLTTPCClusterFinderComponent.cxx
21     @author Kenneth Aamodt <kenneth.aamodt@student.uib.no>
22     @date   
23     @brief  The TPC cluster finder processing component
24 */
25
26 #if __GNUC__>= 3
27 using namespace std;
28 #endif
29 #include "AliHLTTPCClusterFinderComponent.h"
30 #include "AliHLTTPCDigitReaderPacked.h"
31 #include "AliHLTTPCDigitReaderUnpacked.h"
32 #include "AliHLTTPCDigitReaderDecoder.h"
33 #include "AliHLTTPCDigitReader32Bit.h"
34 #include "AliHLTTPCClusterFinder.h"
35 #include "AliHLTTPCSpacePointData.h"
36 #include "AliHLTTPCClusterDataFormat.h"
37 #include "AliHLTTPCTransform.h"
38 #include "AliHLTTPCClusters.h"
39 #include "AliHLTTPCDefinitions.h"
40 #include "AliCDBEntry.h"
41 #include "AliCDBManager.h"
42 #include "AliTPCcalibDB.h"
43 #include "AliTPCCalPad.h"
44 #include "AliTPCParam.h"
45 //#include "AliHLTTPCCAInputDataCompressorComponent.h"
46 //#include "AliHLTTPCCADef.h"
47
48 #include <cstdlib>
49 #include <cerrno>
50 #include "TString.h"
51 #include "TObjString.h"
52 #include "TObjArray.h"
53 #include "AliCDBEntry.h"
54 #include "AliCDBManager.h"
55 #include "AliCDBStorage.h"
56 #include "TGeoGlobalMagField.h"
57
58 #include <sys/time.h>
59
60 /** ROOT macro for the implementation of ROOT specific class methods */
61 ClassImp(AliHLTTPCClusterFinderComponent)
62
63 const char* AliHLTTPCClusterFinderComponent::fgkOCDBEntryPacked="HLT/ConfigTPC/TPCClusterFinderPacked";
64 const char* AliHLTTPCClusterFinderComponent::fgkOCDBEntryUnpacked="HLT/ConfigTPC/TPCClusterFinderUnpacked";
65 const char* AliHLTTPCClusterFinderComponent::fgkOCDBEntryDecoder="HLT/ConfigTPC/TPCClusterFinderDecoder";
66 const char* AliHLTTPCClusterFinderComponent::fgkOCDBEntry32Bit="HLT/ConfigTPC/TPCClusterFinder32Bit";
67
68 AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode)
69   :
70   fClusterFinder(NULL),
71   fReader(NULL),
72   fDeconvTime(kFALSE),
73   fDeconvPad(kFALSE),
74   fClusterDeconv(false),
75   fXYClusterError(-1),
76   fZClusterError(-1),
77   fModeSwitch(mode),
78   fUnsorted(1),
79   fPatch(0),
80   fGetActivePads(0),
81   fFirstTimeBin(-1),
82   fLastTimeBin(-1),
83   fDoMC(kFALSE),
84   fReleaseMemory( kFALSE )
85 {
86   // see header file for class documentation
87   // or
88   // refer to README to build package
89   // or
90   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
91   if (fModeSwitch!=kClusterFinderPacked &&
92       fModeSwitch!=kClusterFinderUnpacked &&
93       fModeSwitch!=kClusterFinderDecoder &&
94       fModeSwitch!=kClusterFinder32Bit) {
95     HLTFatal("unknown digit reader type");
96   }
97 }
98
99 AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
100 {
101   // see header file for class documentation
102 }
103
104 // Public functions to implement AliHLTComponent's interface.
105 // These functions are required for the registration process
106
107 const char* AliHLTTPCClusterFinderComponent::GetComponentID()
108 {
109   // see header file for class documentation
110   switch(fModeSwitch){
111   case kClusterFinderPacked:
112     return "TPCClusterFinderPacked";
113     break;
114   case kClusterFinderUnpacked:   
115     return "TPCClusterFinderUnpacked";   
116     break;
117   case kClusterFinderDecoder:
118     return "TPCClusterFinderDecoder";
119     break;
120   case kClusterFinder32Bit:
121     return "TPCClusterFinder32Bit";
122     break;
123   }
124   return "";
125 }
126
127 void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
128 {
129   // see header file for class documentation
130   list.clear(); 
131   switch(fModeSwitch){
132   case kClusterFinderPacked:
133     list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
134     break;
135   case kClusterFinderUnpacked:   
136     list.push_back( AliHLTTPCDefinitions::fgkUnpackedRawDataType );      
137     break;
138   case kClusterFinderDecoder:
139     list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
140     break;
141   case kClusterFinder32Bit:
142     list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
143     break;
144   }
145 }
146
147 AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
148 {
149   // see header file for class documentation
150   return kAliHLTMultipleDataType;
151 }
152
153 int AliHLTTPCClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
154
155 {
156   // see header file for class documentation
157   tgtList.clear();
158   tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
159   tgtList.push_back(kAliHLTDataTypeHwAddr16);
160   //tgtList.push_back(AliHLTTPCCADefinitions::fgkCompressedInputDataType);
161   return tgtList.size();
162 }
163
164 void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
165 {
166   // see header file for class documentation
167   // XXX TODO: Find more realistic values.  
168   constBase = 0;
169   switch(fModeSwitch){
170   case kClusterFinderPacked:
171     inputMultiplier = (6 * 0.4);
172     break;
173   case kClusterFinderUnpacked:
174     inputMultiplier = 0.4;
175     break;
176   case kClusterFinderDecoder:
177     inputMultiplier = (6 * 0.4);
178     break;
179   case kClusterFinder32Bit:
180     inputMultiplier = (6 * 0.4);
181     break;
182   }
183 }
184
185 AliHLTComponent* AliHLTTPCClusterFinderComponent::Spawn()
186 {
187   // see header file for class documentation
188   return new AliHLTTPCClusterFinderComponent(fModeSwitch);
189 }
190         
191 int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
192 {
193   // see header file for class documentation
194   if ( fClusterFinder )
195     return -EINPROGRESS;
196
197   //Test if the OCDB entries used by AliTPCTransform is availible
198   AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();  
199   //
200   if(!calib){
201     HLTError("AliTPCcalibDB does not exist");
202     return -ENOENT;
203   }
204   AliTPCCalPad * time0TPC = calib->GetPadTime0(); 
205   if(!time0TPC){
206     HLTError("OCDB entry TPC/Calib/PadTime0 (AliTPCcalibDB::GetPadTime0()) is not available.");
207     return -ENOENT;
208   }
209
210   AliTPCParam  * param    = calib->GetParameters();
211   if(!param){
212     HLTError("OCDB entry TPC/Calib/Parameters (AliTPCcalibDB::GetParameters()) is not available.");
213     return -ENOENT;
214   }
215
216   // Check field
217   if (!TGeoGlobalMagField::Instance()) {
218     HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF");
219     return -ENODEV;
220   }
221   calib->SetExBField(GetBz());
222
223   fClusterFinder = new AliHLTTPCClusterFinder();
224
225   // first configure the default
226   int iResult = 0;
227   switch(fModeSwitch){
228   case kClusterFinderPacked:
229     iResult=ConfigureFromCDBTObjString(fgkOCDBEntryPacked);
230     break;
231   case kClusterFinderUnpacked:   
232     iResult=ConfigureFromCDBTObjString(fgkOCDBEntryUnpacked);
233     break;
234   case kClusterFinderDecoder:
235     iResult=ConfigureFromCDBTObjString(fgkOCDBEntryDecoder);
236     break;
237   case kClusterFinder32Bit:
238     iResult=ConfigureFromCDBTObjString(fgkOCDBEntry32Bit);
239     break;
240   }
241
242   // configure from the command line parameters if specified
243   if (iResult>=0 && argc>0)
244     iResult=ConfigureFromArgumentString(argc, argv);
245   // return iResult;
246
247   /*
248   Int_t iResult=0;
249   TString configuration="";
250   TString argument="";
251   for (int i=0; i<argc && iResult>=0; i++) {
252     argument=argv[i];
253     if (!configuration.IsNull()) configuration+=" ";
254     configuration+=argument;
255   }
256   
257   if (!configuration.IsNull()) {
258     iResult=Configure(configuration.Data());
259   } else {
260     iResult=Reconfigure(NULL, NULL);
261   }
262   */
263
264   //Checking for conflicting arguments
265   if(fClusterDeconv){
266     if(fDeconvPad==kTRUE || fDeconvTime==kTRUE){
267       HLTWarning("Conflicting arguments: argument 'pp-run' will be ignored.");
268     }
269   }
270   if(fClusterFinder->GetOccupancyLimit()!=1.0 && fUnsorted){
271     HLTWarning("Argument 'occupancy-limit' is deprecated when doing unsorted data reading.");
272   }
273   if(fGetActivePads==kTRUE && fUnsorted==kFALSE){
274     HLTWarning("Argument '-active-pads' only work with unsorted data reading. Active pads list will not be produced.");
275   }
276   
277
278   // Choose reader
279   if (fModeSwitch==kClusterFinderPacked) {
280       HLTDebug("using AliHLTTPCDigitReaderPacked");
281       fReader = new AliHLTTPCDigitReaderPacked();
282       if(fUnsorted==1){ fReader->SetUnsorted(kTRUE); }
283       fClusterFinder->SetReader(fReader);
284   }
285   else if(fModeSwitch==kClusterFinderUnpacked){          
286     HLTDebug("using AliHLTTPCDigitReaderUnpacked");      
287     fReader = new AliHLTTPCDigitReaderUnpacked();        
288     if(fUnsorted==1){   fReader->SetUnsorted(kTRUE); }
289     fClusterFinder->SetReader(fReader);
290   } 
291   else if(fModeSwitch==kClusterFinderDecoder){
292     HLTDebug("using AliHLTTPCDigitReaderDecoder");
293     fReader = new AliHLTTPCDigitReaderDecoder();
294     fClusterFinder->SetReader(fReader);
295   }
296   else if(fModeSwitch==kClusterFinder32Bit){
297     HLTDebug("using AliHLTTPCDigitReader32Bit");
298     fReader = new AliHLTTPCDigitReader32Bit();
299     fClusterFinder->SetReader(fReader);
300     fClusterFinder->Set32BitFormat(kTRUE);
301   }
302   else{
303     HLTFatal("No mode set for clusterfindercomponent");
304   }
305
306   if(fClusterDeconv){
307     fClusterFinder->SetOccupancyLimit(1.0);
308   }
309   
310   fClusterFinder->SetDeconv(fClusterDeconv);
311   fClusterFinder->SetDeconvPad(fDeconvPad);
312   fClusterFinder->SetDeconvTime(fDeconvPad);
313   fClusterFinder->SetXYError( fXYClusterError );
314   fClusterFinder->SetZError( fZClusterError );
315   if ( (fXYClusterError>0) && (fZClusterError>0) ){
316     fClusterFinder->SetCalcErr( false );
317   }
318
319   if(fFirstTimeBin>0){
320     fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
321   }
322   if(fLastTimeBin>0 && fLastTimeBin>fFirstTimeBin && fLastTimeBin<=AliHLTTPCTransform::GetNTimeBins()){
323     fClusterFinder->SetLastTimeBin(fLastTimeBin);
324   }
325
326   return iResult;
327 }
328
329 int AliHLTTPCClusterFinderComponent::DoDeinit()
330 {
331   // see header file for class documentation
332
333   if ( fClusterFinder )
334     delete fClusterFinder;
335   fClusterFinder = NULL;
336  
337   if ( fReader )
338     delete fReader;
339   fReader = NULL;
340     
341   return 0;
342 }
343
344 int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData, 
345                                               const AliHLTComponentBlockData* blocks, 
346                                               AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
347                                               AliHLTUInt32_t& size, 
348                                               vector<AliHLTComponentBlockData>& outputBlocks )
349 {
350   // see header file for class documentation
351   int iResult=0;
352
353   if(fReader == NULL){
354     HLTFatal("Digit reader not initialized, skipping HLT TPC cluster reconstruction.");
355     size=0;
356     return -ENODEV;    
357   }
358
359   if(!IsDataEvent()){
360     size=0;
361     return 0;
362   }
363
364   //  == init iter (pointer to datablock)
365   const AliHLTComponentBlockData* iter = NULL;
366   unsigned long ndx;
367
368   //  == OUTdatatype pointer
369   AliHLTTPCClusterData* outPtr;
370
371   AliHLTUInt8_t* outBPtr;
372   UInt_t offset, mysize, nSize, tSize = 0;
373
374   outBPtr = outputPtr;
375   outPtr = (AliHLTTPCClusterData*)outBPtr;
376
377   Int_t slice, patch;
378   unsigned long maxPoints, realPoints = 0;
379
380   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
381     {
382       iter = blocks+ndx;
383       mysize = 0;
384       offset = tSize;
385
386       // Kenneth 16. July 2009
387       // 32 byte is the size of the common data header (CDH)
388       // this is introduced as a protection of empty files
389       // normally when running with file publisher where 
390       // Timms script is used to create the missing files
391       if(iter->fSize <= 32){
392         continue;
393       }
394
395
396       if (fModeSwitch==0 || fModeSwitch==2 || fModeSwitch==3) {
397         HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
398                  evtData.fEventID, evtData.fEventID, 
399                  DataType2Text( iter->fDataType).c_str(), 
400                  DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
401
402         if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType &&
403             GetEventCount()<2) {
404           HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
405                      DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
406                      DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
407           }
408
409         if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) &&
410              iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue;
411
412       }
413       else if(fModeSwitch==1){
414         HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
415                  evtData.fEventID, evtData.fEventID, 
416                  DataType2Text( iter->fDataType).c_str(), 
417                  DataType2Text(AliHLTTPCDefinitions::fgkUnpackedRawDataType).c_str());
418
419         if ( iter->fDataType != AliHLTTPCDefinitions::fgkUnpackedRawDataType ) continue;
420
421       }
422
423       slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
424       patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
425
426       if(fUnsorted){
427         fClusterFinder->SetUnsorted(fUnsorted);
428         fClusterFinder->SetPatch(patch);
429       }
430
431       outPtr = (AliHLTTPCClusterData*)outBPtr;
432
433       maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
434
435       fClusterFinder->InitSlice( slice, patch, maxPoints );
436       fClusterFinder->SetOutputArray( (AliHLTTPCSpacePointData*)outPtr->fSpacePoints );
437         
438       if(fUnsorted){
439         if(fGetActivePads){
440           fClusterFinder->SetDoPadSelection(kTRUE);
441         }       
442         if(fDeconvTime){
443           fClusterFinder->ReadDataUnsortedDeconvoluteTime(iter->fPtr, iter->fSize);
444         }
445         else{
446           fClusterFinder->ReadDataUnsorted(iter->fPtr, iter->fSize);
447         }
448
449         fClusterFinder->FindClusters();
450       }
451       else{
452         fClusterFinder->Read(iter->fPtr, iter->fSize );
453         fClusterFinder->ProcessDigits();
454       }
455       fReader->Reset();
456
457       realPoints = fClusterFinder->GetNumberOfClusters();
458         
459       outPtr->fSpacePointCnt = realPoints;
460       nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
461       mysize += nSize+sizeof(AliHLTTPCClusterData);
462
463       Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints", 
464                "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
465                realPoints, slice, patch,AliHLTTPCTransform::GetFirstRow( patch ) , AliHLTTPCTransform::GetLastRow( patch ) );
466       AliHLTComponentBlockData bd;
467       FillBlockData( bd );
468       bd.fOffset = offset;
469       bd.fSize = mysize;
470       bd.fSpecification = iter->fSpecification;
471       bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
472       outputBlocks.push_back( bd );
473         
474       tSize += mysize;
475       outBPtr += mysize;
476       outPtr = (AliHLTTPCClusterData*)outBPtr;
477         
478
479       if ( tSize > size )
480         {
481           Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data", 
482                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
483                    tSize, size );
484           iResult=-ENOSPC;
485           break;
486         }
487         
488       if(fUnsorted && fGetActivePads){
489        Int_t maxNumberOfHW=(Int_t)((size-tSize)/sizeof(AliHLTUInt16_t)-1);
490        AliHLTUInt16_t* outputHWPtr= (AliHLTUInt16_t*)(outputPtr+tSize);
491        Int_t nHWAdd = fClusterFinder->FillHWAddressList(outputHWPtr, maxNumberOfHW);
492       
493        AliHLTComponentBlockData bdHW;
494        FillBlockData( bdHW );
495        bdHW.fOffset = tSize ;
496        bdHW.fSize = nHWAdd*sizeof(AliHLTUInt16_t);
497        bdHW.fSpecification = iter->fSpecification;
498        bdHW.fDataType = kAliHLTDataTypeHwAddr16;
499        outputBlocks.push_back( bdHW );
500        
501        tSize+=nHWAdd*sizeof(AliHLTUInt16_t);
502       }
503
504       /*
505       { // compressed output for the CA tracker 
506
507         AliHLTUInt32_t dSize = 0;       
508
509         int ret = AliHLTTPCCAInputDataCompressorComponent::Compress(  (AliHLTTPCClusterData*)( outputPtr + bd.fOffset ),
510                                                                       size - tSize,
511                                                                       outputPtr+tSize,
512                                                                       dSize );
513         
514         if ( ret!=0 || tSize + dSize > size )
515           {
516             Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data", 
517                      "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
518                      tSize + dSize, size );
519             iResult=-ENOSPC;
520             break;
521           }
522         
523         AliHLTComponentBlockData bdCompressed;
524         FillBlockData( bdCompressed );
525         bdCompressed.fOffset = tSize ;
526         bdCompressed.fSize = dSize;
527         bdCompressed.fSpecification = iter->fSpecification;
528         bdCompressed.fDataType = AliHLTTPCCADefinitions::fgkCompressedInputDataType;
529         outputBlocks.push_back( bdCompressed );
530         
531         tSize += dSize;
532         outBPtr += dSize;
533         outPtr = (AliHLTTPCClusterData*)outBPtr;        
534       }
535       */
536
537       if(fDoMC){
538         Int_t maxNumberOfClusterMCInfo = (Int_t)((size-tSize)/sizeof(AliHLTTPCClusterFinder::ClusterMCInfo)-1);
539         AliHLTTPCClusterFinder::ClusterMCInfo* outputMCInfo= (AliHLTTPCClusterFinder::ClusterMCInfo*)(outputPtr+tSize);
540         Int_t nMCInfo = fClusterFinder->FillOutputMCInfo(outputMCInfo, maxNumberOfClusterMCInfo);
541         
542         AliHLTComponentBlockData bdMCInfo;
543         FillBlockData( bdMCInfo );
544         bdMCInfo.fOffset = tSize ;
545         bdMCInfo.fSize = nMCInfo*sizeof(AliHLTTPCClusterFinder::ClusterMCInfo);
546         bdMCInfo.fSpecification = iter->fSpecification;
547         bdMCInfo.fDataType = AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo;
548         outputBlocks.push_back( bdMCInfo );
549         
550         tSize+=nMCInfo*sizeof(AliHLTTPCClusterFinder::ClusterMCInfo);
551
552       }
553     }
554
555   if (iResult>=0)
556     size = tSize;
557
558   return iResult;
559 }
560
561 int AliHLTTPCClusterFinderComponent::ScanConfigurationArgument(int argc, const char** argv){
562
563   // see header file for class documentation
564
565   if (argc<=0) return 0;
566   int i=0;
567   TString argument=argv[i];
568
569   if (argument.CompareTo("-solenoidBz")==0){
570     if (++i>=argc) return -EPROTO;
571     HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz());
572     return 2;
573   }
574
575   if (argument.CompareTo("-update-calibdb")==0 || argument.CompareTo("-update-transform")==0 ){
576     if(fClusterFinder->UpdateCalibDB()){
577       HLTDebug("CalibDB and offline transform successfully updated.");
578     }
579     else{
580       HLTError("CalibDB could not be updated.");
581     }
582     return 1;
583   }
584
585   if (argument.CompareTo("-deconvolute-time")==0){
586     HLTDebug("Switching on deconvolution in time direction.");
587     fDeconvTime = kTRUE;
588     fClusterFinder->SetDeconvTime(fDeconvTime);
589     return 1;
590   }
591
592   if (argument.CompareTo("-deconvolute-pad")==0){
593     HLTDebug("Switching on deconvolution in pad direction.");
594     fDeconvPad = kTRUE;
595     fClusterFinder->SetDeconvPad(fDeconvPad);
596     return 1;
597   }
598
599   if (argument.CompareTo("-timebins")==0 || argument.CompareTo("timebins" )==0){
600     HLTWarning("Argument %s is depreciated after moving to the offline AliTPCTransform class for xyz calculations.",argument.Data());
601     /*
602       if (++i>=argc) return -EPROTO;
603       argument=argv[i];
604       AliHLTTPCTransform::SetNTimeBins(argument.Atoi());
605       fClusterFinder->UpdateLastTimeBin();
606       HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
607       return 2;
608     */
609     if(argument.CompareTo("timebins")==0){
610       HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
611     }
612     return 2;
613   }
614   
615   if (argument.CompareTo("-first-timebin")==0){
616     if (++i>=argc) return -EPROTO;
617     argument=argv[i];
618     fFirstTimeBin = argument.Atoi();
619     if(fFirstTimeBin>=0){
620       HLTDebug("fFirstTimeBin set to %d",fFirstTimeBin);
621       fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
622     }
623     else{
624       HLTError("-first-timebin specifier is negative: %d",fFirstTimeBin);
625     }
626     return 2;
627   }
628
629   if (argument.CompareTo("-last-timebin")==0){
630     if (++i>=argc) return -EPROTO;
631     argument=argv[i];
632     fLastTimeBin = argument.Atoi();
633     if(fLastTimeBin<AliHLTTPCTransform::GetNTimeBins()){
634       HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
635     }
636     else{
637       HLTError("fLastTimeBins is too big: %d. Maximum: %d",fLastTimeBin,AliHLTTPCTransform::GetNTimeBins());
638     }
639     return 2;
640   }
641  
642   if (argument.CompareTo("-sorted")==0) {
643     fUnsorted=0;
644     HLTDebug("Swithching unsorted off.");
645     fClusterFinder->SetUnsorted(0);
646     return 1;
647   } 
648   
649   if (argument.CompareTo("-do-mc")==0) {
650     fDoMC=kTRUE;
651     fClusterFinder->SetDoMC(fDoMC);
652     HLTDebug("Setting fDoMC to true.");
653     return 1;
654   }
655   if (argument.CompareTo("-release-memory")==0) {
656     fReleaseMemory=kTRUE;
657     fClusterFinder->SetReleaseMemory( fReleaseMemory );
658     HLTDebug("Setting fReleaseMemory to true.");
659     return 1;
660   }
661
662   if (argument.CompareTo("-active-pads")==0 || argument.CompareTo("activepads")==0){
663     if(argument.CompareTo("activepads" )==0){
664       HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'activepads'");
665     }
666     HLTDebug("Switching on ActivePads");
667     fGetActivePads = 1;
668     fClusterFinder->SetDoPadSelection(kTRUE);
669     return 1;
670   }
671
672   if (argument.CompareTo("-occupancy-limit")==0 || argument.CompareTo("occupancy-limit")==0){
673     if(argument.CompareTo("occupancy-limit" )==0){
674       HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
675     }
676     if (++i>=argc) return -EPROTO;
677     argument=argv[i];
678     fClusterFinder->SetOccupancyLimit(argument.Atof());
679     HLTDebug("Occupancy limit set to occulimit %f", argument.Atof());
680     return 2;
681   }
682
683   if (argument.CompareTo("rawreadermode")==0){
684     if (++i>=argc) return -EPROTO;
685     HLTWarning("Argument 'rawreadermode' is deprecated");
686     return 2;
687   }
688   
689   if (argument.CompareTo("pp-run")==0){
690     HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
691     fClusterDeconv = false;
692     return 1;
693   }
694
695   if (argument.CompareTo("adc-threshold" )==0){
696     if (++i>=argc) return -EPROTO;
697     HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
698     return 2;
699   } 
700   
701   if (argument.CompareTo("oldrcuformat" )==0){
702     if (++i>=argc) return -EPROTO;
703     HLTWarning("Argument 'oldrcuformat' is deprecated.");
704     return 2;
705   }
706   
707   if (argument.CompareTo("unsorted" )==0 || argument.CompareTo("-unsorted" )==0){
708     HLTWarning("Argument is obsolete, unsorted reading is default.");
709     //    fClusterFinder->SetUnsorted(1);
710     return 1;
711   }
712   if (argument.CompareTo("nsigma-threshold")==0){
713     if (++i>=argc) return -EPROTO;
714     HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
715     return 2;
716   }
717
718   // unknown argument
719   return -EINVAL;
720 }
721
722 int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
723 {  
724   // see header file for class documentation
725
726   const char* entry=cdbEntry;
727   if (!entry || entry[0]==0){
728     switch(fModeSwitch){
729     case kClusterFinderPacked:
730       entry=fgkOCDBEntryPacked;
731       break;
732     case kClusterFinderUnpacked:         
733       entry=fgkOCDBEntryUnpacked;
734       break;
735     case kClusterFinderDecoder:
736       entry=fgkOCDBEntryDecoder;
737       break;
738     case kClusterFinder32Bit:
739       entry=fgkOCDBEntry32Bit;
740       break;
741     }
742   }
743
744   return ConfigureFromCDBTObjString(entry);
745
746   /*
747   int iResult=0;
748   
749   const char* path="HLT/ConfigTPC/ClusterFinderComponent";
750   if (cdbEntry) path=cdbEntry;
751   if (path) {
752     HLTInfo("reconfigure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
753     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);//,GetRunNo());
754     if (pEntry) {
755       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
756       if (pString) {
757         HLTInfo("received configuration object: %s", pString->GetString().Data());
758         iResult = Configure(pString->GetString().Data());
759       } else {
760         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
761       }
762     } else {
763       HLTError("can not fetch object \"%s\" from CDB", path);
764     }
765   }
766   return iResult;
767   */
768 }
769
770 int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){
771   // see header file for class documentation
772   int iResult=0;
773   if (!arguments) return iResult;
774   
775   TString allArgs=arguments;
776   TString argument;
777   int bMissingParam=0;
778
779   TObjArray* pTokens=allArgs.Tokenize(" ");
780   if (pTokens) {
781     
782     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
783       argument=((TObjString*)pTokens->At(i))->GetString();
784
785       if (argument.IsNull()) continue;
786       
787       // -- deconvolute-time option
788       if (argument.CompareTo("-deconvolute-time")==0){
789         HLTDebug("Switching on deconvolution in time direction.");
790         fDeconvTime = kTRUE;
791         fClusterFinder->SetDeconvTime(fDeconvTime);
792       }
793       else if (argument.CompareTo("-deconvolute-pad")==0){
794         HLTDebug("Switching on deconvolution in pad direction.");
795         fDeconvPad = kTRUE;
796         fClusterFinder->SetDeconvPad(fDeconvPad);
797       }
798       else if (argument.CompareTo("-timebins")==0 || argument.CompareTo("timebins" )==0){
799         HLTWarning("Argument %s is depreciated after moving to the offline AliTPCTransform class for xyz calculations.",argument.Data());
800         /*
801         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
802         AliHLTTPCTransform::SetNTimeBins(((TObjString*)pTokens->At(i))->GetString().Atoi());
803         fClusterFinder->UpdateLastTimeBin();
804         HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
805         */
806         if(argument.CompareTo("timebins")==0){
807           HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
808         }
809         
810       }
811       else if (argument.CompareTo("-first-timebin")==0){
812         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
813         fFirstTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
814         if(fFirstTimeBin>=0){
815           HLTDebug("fFirstTimeBin set to %d",fFirstTimeBin);
816           fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
817         }
818         else{
819           HLTError("-first-timebin specifier is negative: %d",fFirstTimeBin);
820         }
821       }
822       else if (argument.CompareTo("-last-timebin")==0){
823         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
824         fLastTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
825         if(fLastTimeBin<AliHLTTPCTransform::GetNTimeBins()){
826           HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
827         }
828         else{
829           HLTError("fLastTimeBins is too big: %d. Maximum: %d",fLastTimeBin,AliHLTTPCTransform::GetNTimeBins());
830         }
831       }
832       else if (argument.CompareTo("-sorted")==0) {
833         fUnsorted=0;
834         HLTDebug("Swithching unsorted off.");
835         fClusterFinder->SetUnsorted(0);
836       }
837       else if (argument.CompareTo("-do-mc")==0) {
838         fDoMC=kTRUE;
839         fClusterFinder->SetDoMC(fDoMC);
840         HLTInfo("Setting fDoMC to true.");
841       }
842       else if (argument.CompareTo("-release-memory")==0) {
843         fReleaseMemory = kTRUE;
844         fClusterFinder->SetReleaseMemory( kTRUE );
845         HLTInfo("Setting fReleaseMemory to true.");
846       }
847       else if (argument.CompareTo("-active-pads")==0 || argument.CompareTo("activepads")==0){
848         if(argument.CompareTo("activepads" )==0){
849           HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'activepads'");
850         }
851         HLTDebug("Switching on ActivePads");
852         fGetActivePads = 1;
853         fClusterFinder->SetDoPadSelection(kTRUE);
854       }
855       else if (argument.CompareTo("-occupancy-limit")==0 || argument.CompareTo("occupancy-limit")==0){
856         if(argument.CompareTo("occupancy-limit" )==0){
857           HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
858         }
859         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
860         fClusterFinder->SetOccupancyLimit(((TObjString*)pTokens->At(i))->GetString().Atof());
861         HLTDebug("Occupancy limit set to occulimit %f", ((TObjString*)pTokens->At(i))->GetString().Atof());
862       }
863       else if (argument.CompareTo("rawreadermode")==0){
864         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
865         HLTWarning("Argument 'rawreadermode' is deprecated");      
866       }
867       else if (argument.CompareTo("pp-run")==0){
868         HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
869         fClusterDeconv = false;
870       }
871       else if (argument.CompareTo("adc-threshold" )==0){
872         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
873         HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
874       }
875       else if (argument.CompareTo("oldrcuformat" )==0){
876         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
877         HLTWarning("Argument 'oldrcuformat' is deprecated.");
878       }
879       else if (argument.CompareTo("unsorted" )==0){
880         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
881         HLTDebug("Using unsorted reading.");
882         fClusterFinder->SetUnsorted(1);
883       }
884       else if (argument.CompareTo("nsigma-threshold")==0){
885         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
886         HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
887       }
888       else if (argument.CompareTo("-update-calibdb")==0){
889         fClusterFinder->UpdateCalibDB();
890       }
891       else {
892         HLTError("unknown argument %s", argument.Data());
893         iResult=-EINVAL;
894         break;
895       }
896     }
897     delete pTokens;
898   }
899   if (bMissingParam) {
900     HLTError("missing parameter for argument %s", argument.Data());
901     iResult=-EINVAL;
902   }
903   return iResult;
904 }
905