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
  46 #include <cstdlib>
  47 #include <cerrno>
  48 #include "TString.h"
  49 #include "TObjString.h"
  50 #include "TObjArray.h"
  51 #include "AliCDBEntry.h"
  52 #include "AliCDBManager.h"
  53 #include "AliCDBStorage.h"
  54
  55 #include <sys/time.h>
  56
  57 /** ROOT macro for the implementation of ROOT specific class methods */
  58 ClassImp(AliHLTTPCClusterFinderComponent)
  59
  60 AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode)
  61   :
  62   fClusterFinder(NULL),
  63   fReader(NULL),
  64   fDeconvTime(kFALSE),
  65   fDeconvPad(kFALSE),
  66   fClusterDeconv(false),
  67   fXYClusterError(-1),
  68   fZClusterError(-1),
  69   fModeSwitch(mode),
  70   fUnsorted(1),
  71   fPatch(0),
  72   fGetActivePads(0),
  73   fFirstTimeBin(-1),
  74   fLastTimeBin(-1),
  75   fDoMC(kFALSE)
  76 {
  77   // see header file for class documentation
  78   // or
  79   // refer to README to build package
  80   // or
  81   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  82   if (fModeSwitch!=kClusterFinderPacked &&
  83       fModeSwitch!=kClusterFinderUnpacked &&
  84       fModeSwitch!=kClusterFinderDecoder &&
  85       fModeSwitch!=kClusterFinder32Bit) {
  86     HLTFatal("unknown digit reader type");
  87   }
  88 }
  89
  90 AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
  91 {
  92   // see header file for class documentation
  93 }
  94
  95 // Public functions to implement AliHLTComponent's interface.
  96 // These functions are required for the registration process
  97
  98 const char* AliHLTTPCClusterFinderComponent::GetComponentID()
  99 {
 100   // see header file for class documentation
 101   switch(fModeSwitch){
 102   case kClusterFinderPacked:
 103     return "TPCClusterFinderPacked";
 104     break;
 105   case kClusterFinderUnpacked:
 106     return "TPCClusterFinderUnpacked";
 107     break;
 108   case kClusterFinderDecoder:
 109     return "TPCClusterFinderDecoder";
 110     break;
 111   case kClusterFinder32Bit:
 112     return "TPCClusterFinder32Bit";
 113     break;
 114   }
 115   return "";
 116 }
 117
 118 void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
 119 {
 120   // see header file for class documentation
 121   list.clear();
 122   switch(fModeSwitch){
 123   case kClusterFinderPacked:
 124     list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
 125     break;
 126   case kClusterFinderUnpacked:
 127     list.push_back( AliHLTTPCDefinitions::fgkUnpackedRawDataType );
 128     break;
 129   case kClusterFinderDecoder:
 130     list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
 131     break;
 132   case kClusterFinder32Bit:
 133     list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
 134     break;
 135   }
 136 }
 137
 138 AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
 139 {
 140   // see header file for class documentation
 141   return kAliHLTMultipleDataType;
 142 }
 143
 144 int AliHLTTPCClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
 145
 146 {
 147   // see header file for class documentation
 148   tgtList.clear();
 149   tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
 150   tgtList.push_back(kAliHLTDataTypeHwAddr16);
 151   return tgtList.size();
 152 }
 153
 154 void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 155 {
 156   // see header file for class documentation
 157   // XXX TODO: Find more realistic values.
 158   constBase = 0;
 159   switch(fModeSwitch){
 160   case kClusterFinderPacked:
 161     inputMultiplier = (6 * 0.4);
 162     break;
 163   case kClusterFinderUnpacked:
 164     inputMultiplier = 0.4;
 165     break;
 166   case kClusterFinderDecoder:
 167     inputMultiplier = (6 * 0.4);
 168     break;
 169   case kClusterFinder32Bit:
 170     inputMultiplier = (6 * 0.4);
 171     break;
 172   }
 173 }
 174
 175 AliHLTComponent* AliHLTTPCClusterFinderComponent::Spawn()
 176 {
 177   // see header file for class documentation
 178   return new AliHLTTPCClusterFinderComponent(fModeSwitch);
 179 }
 180
 181 int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
 182 {
 183   // see header file for class documentation
 184   if ( fClusterFinder )
 185     return EINPROGRESS;
 186
 187   //Test if the OCDB entries used by AliTPCTransform is availible
 188   AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
 189   //
 190   AliTPCCalPad * time0TPC = calib->GetPadTime0();
 191   if(!time0TPC){
 192     HLTError("OCDB entry TPC/Calib/PadTime0 (AliTPCcalibDB::GetPadTime0()) is not available.");
 193     return -ENOENT;
 194   }
 195
 196   AliTPCParam  * param    = calib->GetParameters();
 197   if(!param){
 198     HLTError("OCDB entry TPC/Calib/Parameters (AliTPCcalibDB::GetParameters()) is not available.");
 199     return -ENOENT;
 200   }
 201
 202
 203   fClusterFinder = new AliHLTTPCClusterFinder();
 204
 205   Int_t iResult=0;
 206   TString configuration="";
 207   TString argument="";
 208   for (int i=0; i<argc && iResult>=0; i++) {
 209     argument=argv[i];
 210     if (!configuration.IsNull()) configuration+=" ";
 211     configuration+=argument;
 212   }
 213
 214   if (!configuration.IsNull()) {
 215     iResult=Configure(configuration.Data());
 216   } else {
 217     iResult=Reconfigure(NULL, NULL);
 218   }
 219
 220   //Checking for conflicting arguments
 221   if(fClusterDeconv){
 222     if(fDeconvPad==kTRUE || fDeconvTime==kTRUE){
 223       HLTWarning("Conflicting arguments: argument 'pp-run' will be ignored.");
 224     }
 225   }
 226   if(fClusterFinder->GetOccupancyLimit()!=1.0 && fUnsorted){
 227     HLTWarning("Argument 'occupancy-limit' is deprecated when doing unsorted data reading.");
 228   }
 229   if(fGetActivePads==kTRUE && fUnsorted==kFALSE){
 230     HLTWarning("Argument '-active-pads' only work with unsorted data reading. Active pads list will not be produced.");
 231   }
 232
 233
 234   // Choose reader
 235   if (fModeSwitch==kClusterFinderPacked) {
 236       HLTDebug("using AliHLTTPCDigitReaderPacked");
 237       fReader = new AliHLTTPCDigitReaderPacked();
 238       if(fUnsorted==1){ fReader->SetUnsorted(kTRUE); }
 239       fClusterFinder->SetReader(fReader);
 240   }
 241   else if(fModeSwitch==kClusterFinderUnpacked){
 242     HLTDebug("using AliHLTTPCDigitReaderUnpacked");
 243     fReader = new AliHLTTPCDigitReaderUnpacked();
 244     if(fUnsorted==1){   fReader->SetUnsorted(kTRUE); }
 245     fClusterFinder->SetReader(fReader);
 246   }
 247   else if(fModeSwitch==kClusterFinderDecoder){
 248     HLTDebug("using AliHLTTPCDigitReaderDecoder");
 249     fReader = new AliHLTTPCDigitReaderDecoder();
 250     fClusterFinder->SetReader(fReader);
 251   }
 252   else if(fModeSwitch==kClusterFinder32Bit){
 253     HLTDebug("using AliHLTTPCDigitReader32Bit");
 254     fReader = new AliHLTTPCDigitReader32Bit();
 255     fClusterFinder->SetReader(fReader);
 256     fClusterFinder->Set32BitFormat(kTRUE);
 257   }
 258   else{
 259     HLTFatal("No mode set for clusterfindercomponent");
 260   }
 261
 262   if(fClusterDeconv){
 263     fClusterFinder->SetOccupancyLimit(1.0);
 264   }
 265
 266   fClusterFinder->SetDeconv(fClusterDeconv);
 267   fClusterFinder->SetDeconvPad(fDeconvPad);
 268   fClusterFinder->SetDeconvTime(fDeconvPad);
 269   fClusterFinder->SetXYError( fXYClusterError );
 270   fClusterFinder->SetZError( fZClusterError );
 271   if ( (fXYClusterError>0) && (fZClusterError>0) ){
 272     fClusterFinder->SetCalcErr( false );
 273   }
 274
 275   if(fFirstTimeBin>0){
 276     fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
 277   }
 278   if(fLastTimeBin>0 && fLastTimeBin>fFirstTimeBin && fLastTimeBin<=AliHLTTPCTransform::GetNTimeBins()){
 279     fClusterFinder->SetLastTimeBin(fLastTimeBin);
 280   }
 281
 282   return 0;
 283 }
 284
 285 int AliHLTTPCClusterFinderComponent::DoDeinit()
 286 {
 287   // see header file for class documentation
 288
 289   if ( fClusterFinder )
 290     delete fClusterFinder;
 291   fClusterFinder = NULL;
 292
 293   if ( fReader )
 294     delete fReader;
 295   fReader = NULL;
 296
 297   return 0;
 298 }
 299
 300 int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData,
 301                                               const AliHLTComponentBlockData* blocks,
 302                                               AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
 303                                               AliHLTUInt32_t& size,
 304                                               vector<AliHLTComponentBlockData>& outputBlocks )
 305 {
 306   // see header file for class documentation
 307   int iResult=0;
 308
 309   if(fReader == NULL){
 310     HLTFatal("Digit reader not initialized, skipping HLT TPC cluster reconstruction.");
 311     size=0;
 312     return 0;
 313   }
 314
 315   if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){
 316     size=0;
 317     return 0;
 318   }
 319
 320   //  == init iter (pointer to datablock)
 321   const AliHLTComponentBlockData* iter = NULL;
 322   unsigned long ndx;
 323
 324   //  == OUTdatatype pointer
 325   AliHLTTPCClusterData* outPtr;
 326
 327   AliHLTUInt8_t* outBPtr;
 328   UInt_t offset, mysize, nSize, tSize = 0;
 329
 330   outBPtr = outputPtr;
 331   outPtr = (AliHLTTPCClusterData*)outBPtr;
 332
 333   Int_t slice, patch;
 334   unsigned long maxPoints, realPoints = 0;
 335
 336   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 337     {
 338       iter = blocks+ndx;
 339       mysize = 0;
 340       offset = tSize;
 341
 342       // Kenneth 16. July 2009
 343       // 32 byte is the size of the common data header (CDH)
 344       // this is introduced as a protection of empty files
 345       // normally when running with file publisher where
 346       // Timms script is used to create the missing files
 347       if(iter->fSize <= 32){
 348         continue;
 349       }
 350
 351
 352       if (fModeSwitch==0 || fModeSwitch==2 || fModeSwitch==3) {
 353         HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 354                  evtData.fEventID, evtData.fEventID,
 355                  DataType2Text( iter->fDataType).c_str(),
 356                  DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
 357
 358         if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType &&
 359             GetEventCount()<2) {
 360           HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
 361                      DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
 362                      DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
 363           }
 364
 365         if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) &&
 366              iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue;
 367
 368       }
 369       else if(fModeSwitch==1){
 370         HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 371                  evtData.fEventID, evtData.fEventID,
 372                  DataType2Text( iter->fDataType).c_str(),
 373                  DataType2Text(AliHLTTPCDefinitions::fgkUnpackedRawDataType).c_str());
 374
 375         if ( iter->fDataType != AliHLTTPCDefinitions::fgkUnpackedRawDataType ) continue;
 376
 377       }
 378
 379       slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 380       patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 381
 382       if(fUnsorted){
 383         fClusterFinder->SetUnsorted(fUnsorted);
 384         fClusterFinder->SetPatch(patch);
 385       }
 386
 387       outPtr = (AliHLTTPCClusterData*)outBPtr;
 388
 389       maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
 390
 391       fClusterFinder->InitSlice( slice, patch, maxPoints );
 392       fClusterFinder->SetOutputArray( (AliHLTTPCSpacePointData*)outPtr->fSpacePoints );
 393
 394       if(fUnsorted){
 395         if(fGetActivePads){
 396           fClusterFinder->SetDoPadSelection(kTRUE);
 397         }
 398         if(fDeconvTime){
 399           fClusterFinder->ReadDataUnsortedDeconvoluteTime(iter->fPtr, iter->fSize);
 400         }
 401         else{
 402           fClusterFinder->ReadDataUnsorted(iter->fPtr, iter->fSize);
 403         }
 404
 405         fClusterFinder->FindClusters();
 406       }
 407       else{
 408         fClusterFinder->Read(iter->fPtr, iter->fSize );
 409         fClusterFinder->ProcessDigits();
 410       }
 411       fReader->Reset();
 412
 413       realPoints = fClusterFinder->GetNumberOfClusters();
 414
 415       outPtr->fSpacePointCnt = realPoints;
 416       nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
 417       mysize += nSize+sizeof(AliHLTTPCClusterData);
 418
 419       Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints",
 420                "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
 421                realPoints, slice, patch,AliHLTTPCTransform::GetFirstRow( patch ) , AliHLTTPCTransform::GetLastRow( patch ) );
 422       AliHLTComponentBlockData bd;
 423       FillBlockData( bd );
 424       bd.fOffset = offset;
 425       bd.fSize = mysize;
 426       bd.fSpecification = iter->fSpecification;
 427       bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
 428       outputBlocks.push_back( bd );
 429
 430       tSize += mysize;
 431       outBPtr += mysize;
 432       outPtr = (AliHLTTPCClusterData*)outBPtr;
 433
 434
 435       if ( tSize > size )
 436         {
 437           Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data",
 438                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
 439                    tSize, size );
 440           iResult=-ENOSPC;
 441           break;
 442         }
 443
 444       if(fUnsorted && fGetActivePads){
 445        Int_t maxNumberOfHW=(Int_t)((size-tSize)/sizeof(AliHLTUInt16_t)-1);
 446        AliHLTUInt16_t* outputHWPtr= (AliHLTUInt16_t*)(outputPtr+tSize);
 447        Int_t nHWAdd = fClusterFinder->FillHWAddressList(outputHWPtr, maxNumberOfHW);
 448
 449        AliHLTComponentBlockData bdHW;
 450        FillBlockData( bdHW );
 451        bdHW.fOffset = tSize ;
 452        bdHW.fSize = nHWAdd*sizeof(AliHLTUInt16_t);
 453        bdHW.fSpecification = iter->fSpecification;
 454        bdHW.fDataType = kAliHLTDataTypeHwAddr16;
 455        outputBlocks.push_back( bdHW );
 456
 457        tSize+=nHWAdd*sizeof(AliHLTUInt16_t);
 458       }
 459
 460       if(fDoMC){
 461         Int_t maxNumberOfClusterMCInfo = (Int_t)((size-tSize)/sizeof(AliHLTTPCClusterFinder::ClusterMCInfo)-1);
 462         AliHLTTPCClusterFinder::ClusterMCInfo* outputMCInfo= (AliHLTTPCClusterFinder::ClusterMCInfo*)(outputPtr+tSize);
 463         Int_t nMCInfo = fClusterFinder->FillOutputMCInfo(outputMCInfo, maxNumberOfClusterMCInfo);
 464
 465         AliHLTComponentBlockData bdMCInfo;
 466         FillBlockData( bdMCInfo );
 467         bdMCInfo.fOffset = tSize ;
 468         bdMCInfo.fSize = nMCInfo*sizeof(AliHLTTPCClusterFinder::ClusterMCInfo);
 469         bdMCInfo.fSpecification = iter->fSpecification;
 470         bdMCInfo.fDataType = AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo;
 471         outputBlocks.push_back( bdMCInfo );
 472
 473         tSize+=nMCInfo*sizeof(AliHLTTPCClusterFinder::ClusterMCInfo);
 474
 475       }
 476     }
 477
 478   if (iResult>=0)
 479     size = tSize;
 480
 481   return iResult;
 482 }
 483
 484 int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){
 485   // see header file for class documentation
 486   int iResult=0;
 487   if (!arguments) return iResult;
 488
 489   TString allArgs=arguments;
 490   TString argument;
 491   int bMissingParam=0;
 492
 493   TObjArray* pTokens=allArgs.Tokenize(" ");
 494   if (pTokens) {
 495
 496     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
 497       argument=((TObjString*)pTokens->At(i))->GetString();
 498
 499       if (argument.IsNull()) continue;
 500
 501       // -- deconvolute-time option
 502       if (argument.CompareTo("-deconvolute-time")==0){
 503         HLTDebug("Switching on deconvolution in time direction.");
 504         fDeconvTime = kTRUE;
 505         fClusterFinder->SetDeconvTime(fDeconvTime);
 506       }
 507       else if (argument.CompareTo("-deconvolute-pad")==0){
 508         HLTDebug("Switching on deconvolution in pad direction.");
 509         fDeconvPad = kTRUE;
 510         fClusterFinder->SetDeconvPad(fDeconvPad);
 511       }
 512       else if (argument.CompareTo("-timebins")==0 || argument.CompareTo("timebins" )==0){
 513         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 514         AliHLTTPCTransform::SetNTimeBins(((TObjString*)pTokens->At(i))->GetString().Atoi());
 515         fClusterFinder->UpdateLastTimeBin();
 516         HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
 517         if(argument.CompareTo("timebins")==0){
 518           HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
 519         }
 520       }
 521       else if (argument.CompareTo("-first-timebin")==0){
 522         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 523         fFirstTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
 524         if(fFirstTimeBin>=0){
 525           HLTDebug("fFirstTimeBin set to %d",fFirstTimeBin);
 526           fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
 527         }
 528         else{
 529           HLTError("-first-timebin specifier is negative: %d",fFirstTimeBin);
 530         }
 531       }
 532       else if (argument.CompareTo("-last-timebin")==0){
 533         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 534         fLastTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
 535         if(fLastTimeBin<AliHLTTPCTransform::GetNTimeBins()){
 536           HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
 537         }
 538         else{
 539           HLTError("fLastTimeBins is too big: %d. Maximum: %d",fLastTimeBin,AliHLTTPCTransform::GetNTimeBins());
 540         }
 541       }
 542       else if (argument.CompareTo("-sorted")==0) {
 543         fUnsorted=0;
 544         HLTDebug("Swithching unsorted off.");
 545         fClusterFinder->SetUnsorted(0);
 546       }
 547       else if (argument.CompareTo("-do-mc")==0) {
 548         fDoMC=kTRUE;
 549         fClusterFinder->SetDoMC(fDoMC);
 550         HLTInfo("Setting fDoMC to true.");
 551       }
 552       else if (argument.CompareTo("-active-pads")==0 || argument.CompareTo("activepads")==0){
 553         if(argument.CompareTo("activepads" )==0){
 554           HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'activepads'");
 555         }
 556         HLTDebug("Switching on ActivePads");
 557         fGetActivePads = 1;
 558         fClusterFinder->SetDoPadSelection(kTRUE);
 559       }
 560       else if (argument.CompareTo("-occupancy-limit")==0 || argument.CompareTo("occupancy-limit")==0){
 561         if(argument.CompareTo("occupancy-limit" )==0){
 562           HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
 563         }
 564         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 565         fClusterFinder->SetOccupancyLimit(((TObjString*)pTokens->At(i))->GetString().Atof());
 566         HLTDebug("Occupancy limit set to occulimit %f", ((TObjString*)pTokens->At(i))->GetString().Atof());
 567       }
 568       else if (argument.CompareTo("rawreadermode")==0){
 569         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 570         HLTWarning("Argument 'rawreadermode' is deprecated");
 571       }
 572       else if (argument.CompareTo("pp-run")==0){
 573         HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
 574         fClusterDeconv = false;
 575       }
 576       else if (argument.CompareTo("adc-threshold" )==0){
 577         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 578         HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
 579       }
 580       else if (argument.CompareTo("oldrcuformat" )==0){
 581         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 582         HLTWarning("Argument 'oldrcuformat' is deprecated.");
 583       }
 584       else if (argument.CompareTo("unsorted" )==0){
 585         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 586         HLTDebug("Using unsorted reading.");
 587         fClusterFinder->SetUnsorted(1);
 588       }
 589       else if (argument.CompareTo("nsigma-threshold")==0){
 590         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 591         HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
 592       }
 593       else {
 594         HLTError("unknown argument %s", argument.Data());
 595         iResult=-EINVAL;
 596         break;
 597       }
 598     }
 599     delete pTokens;
 600   }
 601   if (bMissingParam) {
 602     HLTError("missing parameter for argument %s", argument.Data());
 603     iResult=-EINVAL;
 604   }
 605   return iResult;
 606 }
 607
 608 int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
 609 {
 610
 611   int iResult=0;
 612   // see header file for class documentation
 613   const char* path="HLT/ConfigTPC/ClusterFinderComponent";
 614   if (cdbEntry) path=cdbEntry;
 615   if (path) {
 616     HLTInfo("reconfigure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
 617     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
 618     if (pEntry) {
 619       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
 620       if (pString) {
 621         HLTInfo("received configuration object: %s", pString->GetString().Data());
 622         iResult = Configure(pString->GetString().Data());
 623       } else {
 624         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
 625       }
 626     } else {
 627       HLTError("can not fetch object \"%s\" from CDB", path);
 628     }
 629   }
 630   return iResult;
 631 }