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