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