X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FTPCLib%2FAliHLTTPCClusterFinderComponent.cxx;h=8f3ef5f4a8e4610b41b6d8c5035cd7aa29577745;hb=d29671e275a36330eeac8d13c6cf4bc9dc709f2d;hp=38594685ea2896295acc8173e03d3871b615f8d0;hpb=aca7e6302b0bbb199dd53c9fe5f55b00838369f7;p=u%2Fmrichter%2FAliRoot.git

diff --git a/HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx b/HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx
index 38594685ea2..8f3ef5f4a8e 100644
--- a/HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx
+++ b/HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx
@@ -27,22 +27,37 @@
 using namespace std;
 #endif
 #include "AliHLTTPCClusterFinderComponent.h"
-#include "AliHLTTPCDigitReaderPacked.h"
 #include "AliHLTTPCDigitReaderUnpacked.h"
-#include "AliHLTTPCDigitReaderDecoder.h"
+#include "AliHLTTPCDigitReader32Bit.h"
 #include "AliHLTTPCClusterFinder.h"
 #include "AliHLTTPCSpacePointData.h"
 #include "AliHLTTPCClusterDataFormat.h"
 #include "AliHLTTPCTransform.h"
 #include "AliHLTTPCClusters.h"
 #include "AliHLTTPCDefinitions.h"
+#include "AliGRPObject.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
+#include "AliTPCcalibDB.h"
+#include "AliTPCCalPad.h"
+#include "AliTPCParam.h"
+#include "AliTPCTransform.h"
+#include "AliHLTTPCClusterMCData.h"
+
+//#include "AliHLTTPCCAInputDataCompressorComponent.h"
+//#include "AliHLTTPCCADef.h"
 
 #include <cstdlib>
 #include <cerrno>
 #include "TString.h"
 #include "TObjString.h"
+#include "TObjArray.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "TGeoGlobalMagField.h"
+#include "AliGeomManager.h"
+
 #include <sys/time.h>
 
 /** ROOT macro for the implementation of ROOT specific class methods */
@@ -53,6 +68,7 @@ AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode)
   fClusterFinder(NULL),
   fReader(NULL),
   fDeconvTime(kFALSE),
+  fTS(0),
   fDeconvPad(kFALSE),
   fClusterDeconv(false),
   fXYClusterError(-1),
@@ -62,7 +78,10 @@ AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode)
   fPatch(0),
   fGetActivePads(0),
   fFirstTimeBin(-1),
-  fLastTimeBin(-1)
+  fLastTimeBin(-1),
+  fDoMC(kFALSE),
+  fReleaseMemory( kFALSE ),
+  fBenchmark("TPCClusterFinder")
 {
   // see header file for class documentation
   // or
@@ -71,7 +90,8 @@ AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode)
   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
   if (fModeSwitch!=kClusterFinderPacked &&
       fModeSwitch!=kClusterFinderUnpacked &&
-      fModeSwitch!=kClusterFinderDecoder) {
+      fModeSwitch!=kClusterFinderDecoder &&
+      fModeSwitch!=kClusterFinder32Bit) {
     HLTFatal("unknown digit reader type");
   }
 }
@@ -97,6 +117,9 @@ const char* AliHLTTPCClusterFinderComponent::GetComponentID()
   case kClusterFinderDecoder:
     return "TPCClusterFinderDecoder";
     break;
+  case kClusterFinder32Bit:
+    return "TPCClusterFinder32Bit";
+    break;
   }
   return "";
 }
@@ -106,13 +129,12 @@ void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentD
   // see header file for class documentation
   list.clear(); 
   switch(fModeSwitch){
-  case kClusterFinderPacked:
-    list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
-    break;
   case kClusterFinderUnpacked: 	 
     list.push_back( AliHLTTPCDefinitions::fgkUnpackedRawDataType ); 	 
     break;
-  case kClusterFinderDecoder:
+  case kClusterFinderDecoder: // deprecated, falling back to 32bit reader
+  case kClusterFinderPacked: // deprecated, falling back to 32bit reader
+  case kClusterFinder32Bit:
     list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
     break;
   }
@@ -131,6 +153,7 @@ int AliHLTTPCClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeL
   tgtList.clear();
   tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
   tgtList.push_back(kAliHLTDataTypeHwAddr16);
+  //tgtList.push_back(AliHLTTPCCADefinitions::fgkCompressedInputDataType);
   return tgtList.size();
 }
 
@@ -140,13 +163,12 @@ void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBas
   // XXX TODO: Find more realistic values.  
   constBase = 0;
   switch(fModeSwitch){
-  case 0:
-    inputMultiplier = (6 * 0.4);
-    break;
-  case 1:
+  case kClusterFinderUnpacked:
     inputMultiplier = 0.4;
     break;
-  case 2:
+  case kClusterFinderDecoder: // deprecated, falling back to 32bit reader
+  case kClusterFinderPacked: // deprecated, falling back to 32bit reader
+  case kClusterFinder32Bit:
     inputMultiplier = (6 * 0.4);
     break;
   }
@@ -162,194 +184,79 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
 {
   // see header file for class documentation
   if ( fClusterFinder )
-    return EINPROGRESS;
-
-  fClusterFinder = new AliHLTTPCClusterFinder();
-
-  Float_t occulimit = 1.0;
-
-  Int_t i = 0;
-  Char_t* cpErr;
-
-  while ( i < argc ) {      
-
-    // -- deconvolute-time option
-    if ( !strcmp( argv[i], "-deconvolute-time" ) ) {
-      fDeconvTime = kTRUE;
-      i++;
-      continue;
-    }
-
-    // -- deconvolute-pad option
-    if ( !strcmp( argv[i], "-deconvolute-pad" ) ) {
-      fDeconvPad = kTRUE;
-      i++;
-      continue;
-    }
-
-    // -- number of timebins (default 1024)
-    if (!strcmp( argv[i], "-timebins") || !strcmp( argv[i], "timebins" )){
-      TString parameter(argv[i+1]);
-      parameter.Remove(TString::kLeading, ' '); // remove all blanks
-      if (parameter.IsDigit()) {
-	AliHLTTPCTransform::SetNTimeBins(parameter.Atoi());
-	HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
-	fClusterFinder->UpdateLastTimeBin();
-      } else {
-	HLTError("Cannot timebin specifier '%s'.", argv[i+1]);
-	return EINVAL;
-      }
-      if(!strcmp( argv[i], "timebins")){
-	HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
-      }
-      i+=2;
-      continue;
-    }
-
-    // -first-timebin (default 0)
-    if ( !strcmp( argv[i], "-first-timebin" ) ) {
-      TString parameter(argv[i+1]);
-      parameter.Remove(TString::kLeading, ' '); // remove all blanks
-      if (parameter.IsDigit()){
-	fFirstTimeBin=parameter.Atoi();
-	HLTDebug("fFirstTimeBin set to %d",fFirstTimeBin);
-      } 
-      else {
-	HLTError("Cannot -first-timebin specifier '%s'. Not a number.", argv[i+1]);
-	return EINVAL;
-      }
-      i+=2;
-      continue;
-    }
-
-    // -last-timebin (default 1024)
-    if ( !strcmp( argv[i], "-last-timebin" ) ) {
-      TString parameter(argv[i+1]);
-      parameter.Remove(TString::kLeading, ' '); // remove all blanks
-      if (parameter.IsDigit()){
-	fLastTimeBin=parameter.Atoi();
-	HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
-      } 
-      else {
-	HLTError("Cannot -last-timebin specifier '%s'. Not a number.", argv[i+1]);
-	return EINVAL;
-      }
-      i+=2;
-      continue;
-    }
-
-    // --  unsorted option
-    if ( !strcmp( argv[i], "-sorted" ) ) {
-      fUnsorted=0;
-      i++;
-      continue;
-    }
-
-      
-    // -- checking for active pads, used in 2007 December run
-    if ( !strcmp( argv[i], "-active-pads" ) || !strcmp( argv[i], "activepads" ) ) {
-      if(!strcmp( argv[i], "activepads" )){
-	HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'active-pads'");
-      }
-      fGetActivePads = strtoul( argv[i+1], &cpErr ,0);
-      if ( *cpErr ){
-	HLTError("Cannot convert activepads specifier '%s'. Should  be 0(off) or 1(on), must be integer", argv[i+1]);
-	return EINVAL;
-      }
-      i+=2;
-      continue;
-    }
-
-    // -- pad occupancy limit
-    if ( !strcmp( argv[i], "-occupancy-limit" ) || !strcmp( argv[i], "occupancy-limit" ) ) {
-      if(!strcmp( argv[i], "occupancy-limit" )){
-	HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
-      }
-      occulimit = strtod( argv[i+1], &cpErr);
-      if ( *cpErr ) {
-	HLTError("Cannot convert occupancy specifier '%s'.", argv[i+1]);
-	return EINVAL;
-      }
-      if(fModeSwitch!=kClusterFinderPacked){
-	HLTWarning("Argument '-occupancy-limit' is only used with -sorted set and with the TPCClusterFinderPacked , argument is deprecated");
-      }
-      i+=2;
-      continue;
-    }
-
-    // -- raw reader mode option
-    if ( !strcmp( argv[i], "rawreadermode" ) ) {
-      if ( argc <= i+1 ) {
-	Logging( kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Missing rawreadermode", "Raw Reader Mode not specified. rawreadermode is no longer a valid argument and will be deprecated even if rawreadermode is specified." );
-	return ENOTSUP;
-      }
+    return -EINPROGRESS;
+
+  //Test if the OCDB entries used by AliTPCTransform is availible
+  AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();  
+  //
+  if(!calib){
+    HLTError("AliTPCcalibDB does not exist");
+    return -ENOENT;
+  }
 
-      HLTWarning("Argument 'rawreadermode' is deprecated");      
+  fTS = calib->GetTransform();
 
-      i += 2;
-      continue;
-    }
+  calib->SetRun(GetRunNo());
+  calib->UpdateRunInformations(GetRunNo());
+  AliTPCCalPad * time0TPC = calib->GetPadTime0(); 
+  if(!time0TPC){
+    HLTError("OCDB entry TPC/Calib/PadTime0 (AliTPCcalibDB::GetPadTime0()) is not available.");
+    return -ENOENT;
+  }
 
-    // -- pp-run option
-    if ( !strcmp( argv[i], "pp-run") ) {
-      HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
-      fClusterDeconv = false;
-      i++;
-      continue;
-    }
+  AliTPCParam  * param    = calib->GetParameters();
+  if(!param){
+    HLTError("OCDB entry TPC/Calib/Parameters (AliTPCcalibDB::GetParameters()) is not available.");
+    return -ENOENT;
+  }
 
-    // -- zero suppression threshold
-    if ( !strcmp( argv[i], "adc-threshold" ) ) {
-      strtoul( argv[i+1], &cpErr ,0);
-      if ( *cpErr ) {
-	HLTError("Cannot convert threshold specifier '%s'.", argv[i+1]);
-	return EINVAL;
-      }
-      HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
-      i+=2;
-      continue;
-    }
+  // Check field
+  if (!TGeoGlobalMagField::Instance()) {
+    HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF");
+    return -ENODEV;
+  }
+  calib->SetExBField(GetBz());
 
-    // -- checking for rcu format
-    if ( !strcmp( argv[i], "oldrcuformat" ) ) {
-      strtoul( argv[i+1], &cpErr ,0);
-      if ( *cpErr ){
-	HLTError("Cannot convert oldrcuformat specifier '%s'. Should  be 0(off) or 1(on), must be integer", argv[i+1]);
-	return EINVAL;
-      }
-      HLTWarning("Argument 'oldrcuformat' is deprecated.");
-      i+=2;
-      continue;
-    }
-      
-    // -- checking for unsorted clusterfinding (default 1)
-    if ( !strcmp( argv[i], "unsorted" ) ) {
-      fUnsorted = strtoul( argv[i+1], &cpErr ,0);
-      if ( *cpErr ){
-	HLTError("Cannot convert unsorted specifier '%s'. Should  be 0(off) or 1(on), must be integer", argv[i+1]);
-	return EINVAL;
-      }
-      HLTWarning("Argument 'unsorted' is old and does not follow the new argument naming convention. A change has been made, and the clusterfinder will read the data unsorted by default. For sorted reading, please use '-sorted' as argument. (unsorted 0 will do the same job, but please change anyway.)");
-      i+=2;
-      continue;
-    }
+  if(!AliGeomManager::GetGeometry()){
+    AliGeomManager::LoadGeometry();
+  }
 
-    // -- checking for nsigma-threshold, used in 2007 December run in ZeroSuppression
-    if ( !strcmp( argv[i], "nsigma-threshold" ) ) {
-      strtoul( argv[i+1], &cpErr ,0);
-      if ( *cpErr ){
-	HLTError("Cannot convert nsigma-threshold specifier '%s'. Must be integer", argv[i+1]);
-	return EINVAL;
-      }
-      i+=2;
-      HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
-      continue;
-    }
+  fClusterFinder = new AliHLTTPCClusterFinder();
 
-    Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
-    return EINVAL;
+  TObject* pOCDBEntry=LoadAndExtractOCDBObject("GRP/GRP/Data");
+  AliGRPObject* pGRP=pOCDBEntry?dynamic_cast<AliGRPObject*>(pOCDBEntry):NULL;
+  TString beamType;
+  if (pGRP) {
+    beamType=pGRP->GetBeamType();
+  }
 
+  // first configure the default
+  int iResult = 0;
+  TString cdbPath="HLT/ConfigTPC/";
+  cdbPath+=GetComponentID();
+  iResult=ConfigureFromCDBTObjString(cdbPath, beamType.Data());
+
+  // configure from the command line parameters if specified
+  if (iResult>=0 && argc>0)
+    iResult=ConfigureFromArgumentString(argc, argv);
+  // return iResult;
+
+  /*
+  Int_t iResult=0;
+  TString configuration="";
+  TString argument="";
+  for (int i=0; i<argc && iResult>=0; i++) {
+    argument=argv[i];
+    if (!configuration.IsNull()) configuration+=" ";
+    configuration+=argument;
+  }
+  
+  if (!configuration.IsNull()) {
+    iResult=Configure(configuration.Data());
+  } else {
+    iResult=Reconfigure(NULL, NULL);
   }
+  */
 
   //Checking for conflicting arguments
   if(fClusterDeconv){
@@ -357,7 +264,7 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
       HLTWarning("Conflicting arguments: argument 'pp-run' will be ignored.");
     }
   }
-  if(occulimit!=1.0 && fUnsorted){
+  if(fClusterFinder->GetOccupancyLimit()!=1.0 && fUnsorted){
     HLTWarning("Argument 'occupancy-limit' is deprecated when doing unsorted data reading.");
   }
   if(fGetActivePads==kTRUE && fUnsorted==kFALSE){
@@ -367,30 +274,33 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
 
   // Choose reader
   if (fModeSwitch==kClusterFinderPacked) {
-      HLTDebug("using AliHLTTPCDigitReaderPacked");
-      fReader = new AliHLTTPCDigitReaderPacked();
-      if(fUnsorted==1){	fReader->SetUnsorted(kTRUE); }
-      fClusterFinder->SetReader(fReader);
+      HLTWarning("AliHLTTPCDigitReaderPacked is deprecated, falling back to AliHLTTPCDigitReader32Bit");
   }
-  else if(fModeSwitch==kClusterFinderUnpacked){ 	 
+  else if(fModeSwitch==kClusterFinderDecoder){
+    HLTWarning("AliHLTTPCDigitReaderPacked is deprecated, falling back to AliHLTTPCDigitReader32Bit");
+  }
+  
+  if(fModeSwitch==kClusterFinderUnpacked){ 	 
     HLTDebug("using AliHLTTPCDigitReaderUnpacked"); 	 
     fReader = new AliHLTTPCDigitReaderUnpacked(); 	 
+    if(fUnsorted==1){	fReader->SetUnsorted(kTRUE); }
     fClusterFinder->SetReader(fReader);
-  }
-  else if(fModeSwitch==kClusterFinderDecoder){
-    HLTDebug("using AliHLTTPCDigitReaderDecoder");
-    fReader = new AliHLTTPCDigitReaderDecoder();
+  } 
+  else if(fModeSwitch==kClusterFinder32Bit ||
+	  fModeSwitch==kClusterFinderPacked ||
+	  fModeSwitch==kClusterFinderDecoder){
+    HLTDebug("using AliHLTTPCDigitReader32Bit");
+    fReader = new AliHLTTPCDigitReader32Bit();
     fClusterFinder->SetReader(fReader);
+    fClusterFinder->Set32BitFormat(kTRUE);
   }
   else{
     HLTFatal("No mode set for clusterfindercomponent");
   }
-  // if pp-run use occupancy limit else set to 1. ==> use all 
-  if ( !fClusterDeconv )
-    fClusterFinder->SetOccupancyLimit(occulimit);
-  else 
+
+  if(fClusterDeconv){
     fClusterFinder->SetOccupancyLimit(1.0);
-      
+  }
   
   fClusterFinder->SetDeconv(fClusterDeconv);
   fClusterFinder->SetDeconvPad(fDeconvPad);
@@ -407,8 +317,11 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
   if(fLastTimeBin>0 && fLastTimeBin>fFirstTimeBin && fLastTimeBin<=AliHLTTPCTransform::GetNTimeBins()){
     fClusterFinder->SetLastTimeBin(fLastTimeBin);
   }
+  fBenchmark.Reset();
+  fBenchmark.SetTimer(0,"total");
+  fBenchmark.SetTimer(1,"reco");
 
-  return 0;
+  return iResult;
 }
 
 int AliHLTTPCClusterFinderComponent::DoDeinit()
@@ -433,18 +346,31 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
 					      vector<AliHLTComponentBlockData>& outputBlocks )
 {
   // see header file for class documentation
+  int iResult=0;
+  //SG!!!
+  //fDeconvTime = kTRUE;
+  //fClusterFinder->SetDeconvTime(fDeconvTime);
+  // fDeconvPad = kTRUE;
+  //fClusterFinder->SetDeconvPad(fDeconvPad);
+    
+  
+  fTS->SetCurrentTimeStamp(GetTimeStamp());
+  //fTS->SetCurrentTimeStamp(0);
 
   if(fReader == NULL){
-    HLTFatal("Digit reader not initialized, aborting event.");
+    HLTFatal("Digit reader not initialized, skipping HLT TPC cluster reconstruction.");
     size=0;
-    return 0;    
+    return -ENODEV;    
   }
 
-  if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){
+  if(!IsDataEvent()){
     size=0;
     return 0;
   }
 
+  fBenchmark.StartNewEvent();
+  fBenchmark.Start(0);
+
   //  == init iter (pointer to datablock)
   const AliHLTComponentBlockData* iter = NULL;
   unsigned long ndx;
@@ -467,8 +393,17 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
       mysize = 0;
       offset = tSize;
 
+      // Kenneth 16. July 2009
+      // 32 byte is the size of the common data header (CDH)
+      // this is introduced as a protection of empty files
+      // normally when running with file publisher where 
+      // Timms script is used to create the missing files
+      if(iter->fSize <= 32){
+	continue;
+      }
+
 
-      if (fModeSwitch==0 || fModeSwitch==2) {
+      if (fModeSwitch==0 || fModeSwitch==2 || fModeSwitch==3) {
 	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 		 evtData.fEventID, evtData.fEventID, 
 		 DataType2Text( iter->fDataType).c_str(), 
@@ -495,6 +430,8 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
 
       }
 
+      fBenchmark.AddInput(iter->fSize);
+
       slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
       patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 
@@ -510,6 +447,8 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
       fClusterFinder->InitSlice( slice, patch, maxPoints );
       fClusterFinder->SetOutputArray( (AliHLTTPCSpacePointData*)outPtr->fSpacePoints );
 	
+      fBenchmark.Start(1);
+
       if(fUnsorted){
       	if(fGetActivePads){
 	  fClusterFinder->SetDoPadSelection(kTRUE);
@@ -527,6 +466,9 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
 	fClusterFinder->Read(iter->fPtr, iter->fSize );
 	fClusterFinder->ProcessDigits();
       }
+      fBenchmark.Stop(1);
+
+      fReader->Reset();
 
       realPoints = fClusterFinder->GetNumberOfClusters();
 	
@@ -544,7 +486,9 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
       bd.fSpecification = iter->fSpecification;
       bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
       outputBlocks.push_back( bd );
-	
+
+      fBenchmark.AddOutput(bd.fSize);
+
       tSize += mysize;
       outBPtr += mysize;
       outPtr = (AliHLTTPCClusterData*)outBPtr;
@@ -555,7 +499,8 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
 	  Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data", 
 		   "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
 		   tSize, size );
-	  return -ENOSPC;
+	  iResult=-ENOSPC;
+	  break;
 	}
 	
       if(fUnsorted && fGetActivePads){
@@ -563,10 +508,6 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
        AliHLTUInt16_t* outputHWPtr= (AliHLTUInt16_t*)(outputPtr+tSize);
        Int_t nHWAdd = fClusterFinder->FillHWAddressList(outputHWPtr, maxNumberOfHW);
       
-       //cout<<"Number of hardwareaddresses: "<<nHWAdd<<endl;
-       for(AliHLTUInt16_t test=0;test<nHWAdd;test++){
-	 //cout<<"The HW address is: "<<(AliHLTUInt16_t)outputHWPtr[test]<<endl;
-       }
        AliHLTComponentBlockData bdHW;
        FillBlockData( bdHW );
        bdHW.fOffset = tSize ;
@@ -575,28 +516,258 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
        bdHW.fDataType = kAliHLTDataTypeHwAddr16;
        outputBlocks.push_back( bdHW );
        
+       fBenchmark.AddOutput(bdHW.fSize);
        tSize+=nHWAdd*sizeof(AliHLTUInt16_t);
       }
-      fReader->Reset();
+
+      /*
+      { // compressed output for the CA tracker	
+
+	AliHLTUInt32_t dSize = 0;	
+
+	int ret = AliHLTTPCCAInputDataCompressorComponent::Compress(  (AliHLTTPCClusterData*)( outputPtr + bd.fOffset ),
+								      size - tSize,
+								      outputPtr+tSize,
+								      dSize );
+	
+	if ( ret!=0 || tSize + dSize > size )
+	  {
+	    Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data", 
+		     "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
+		     tSize + dSize, size );
+	    iResult=-ENOSPC;
+	    break;
+	  }
+	
+ 	AliHLTComponentBlockData bdCompressed;
+	FillBlockData( bdCompressed );
+	bdCompressed.fOffset = tSize ;
+	bdCompressed.fSize = dSize;
+	bdCompressed.fSpecification = iter->fSpecification;
+	bdCompressed.fDataType = AliHLTTPCCADefinitions::fgkCompressedInputDataType;
+	outputBlocks.push_back( bdCompressed );
+	
+	tSize += dSize;
+	outBPtr += dSize;
+	outPtr = (AliHLTTPCClusterData*)outBPtr;	
+      }
+      */
+
+      if(fDoMC){
+	Int_t maxNumberOfClusterMCInfo = (Int_t)((size-tSize-sizeof(AliHLTTPCClusterMCData))/sizeof(AliHLTTPCClusterMCLabel)-1);
+	if( maxNumberOfClusterMCInfo>0 ){
+	  AliHLTTPCClusterMCData* outputMCInfo= (AliHLTTPCClusterMCData*)(outputPtr+tSize);
+	  outputMCInfo->fCount = fClusterFinder->FillOutputMCInfo(outputMCInfo->fLabels, maxNumberOfClusterMCInfo);
+	  
+	  AliHLTComponentBlockData bdMCInfo;
+	  FillBlockData( bdMCInfo );
+	  bdMCInfo.fOffset = tSize;
+	  bdMCInfo.fSize = sizeof(AliHLTTPCClusterMCData)+outputMCInfo->fCount*sizeof(AliHLTTPCClusterMCLabel);
+	  bdMCInfo.fSpecification = iter->fSpecification;
+	  bdMCInfo.fDataType = AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo;
+	  outputBlocks.push_back( bdMCInfo );
+	  fBenchmark.AddOutput(bdMCInfo.fSize);
+	  tSize+=bdMCInfo.fSize;
+	}
+      }
     }
-    
-  size = tSize;
 
-  return 0;
+  if (iResult>=0)
+    size = tSize;
+
+  fBenchmark.Stop(0);  
+  HLTInfo(fBenchmark.GetStatistics());
+  return iResult;
 }
 
-int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
-{
+int AliHLTTPCClusterFinderComponent::ScanConfigurationArgument(int argc, const char** argv){
+
   // see header file for class documentation
-  const char* path="HLT/ConfigTPC";
+
+  if (argc<=0) return 0;
+  int i=0;
+  TString argument=argv[i];
+
+  if (argument.CompareTo("-solenoidBz")==0){
+    if (++i>=argc) return -EPROTO;
+    HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz());
+    return 2;
+  }
+
+  if (argument.CompareTo("-update-calibdb")==0 || argument.CompareTo("-update-transform")==0 ){
+    if(fClusterFinder->UpdateCalibDB()){
+      HLTDebug("CalibDB and offline transform successfully updated.");
+    }
+    else{
+      HLTError("CalibDB could not be updated.");
+    }
+    return 1;
+  }
+
+  if (argument.CompareTo("-deconvolute-time")==0){
+    HLTDebug("Switching on deconvolution in time direction.");
+    fDeconvTime = kTRUE;
+    fClusterFinder->SetDeconvTime(fDeconvTime);
+    return 1;
+  }
+
+  if (argument.CompareTo("-deconvolute-pad")==0){
+    HLTDebug("Switching on deconvolution in pad direction.");
+    fDeconvPad = kTRUE;
+    fClusterFinder->SetDeconvPad(fDeconvPad);
+    return 1;
+  }
+
+  if (argument.CompareTo("-timebins")==0 || argument.CompareTo("timebins" )==0){
+    HLTWarning("Argument %s is depreciated after moving to the offline AliTPCTransform class for xyz calculations.",argument.Data());
+    /*
+      if (++i>=argc) return -EPROTO;
+      argument=argv[i];
+      AliHLTTPCTransform::SetNTimeBins(argument.Atoi());
+      fClusterFinder->UpdateLastTimeBin();
+      HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
+      return 2;
+    */
+    if(argument.CompareTo("timebins")==0){
+      HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
+    }
+    return 2;
+  }
+  
+  if (argument.CompareTo("-first-timebin")==0){
+    if (++i>=argc) return -EPROTO;
+    argument=argv[i];
+    fFirstTimeBin = argument.Atoi();
+    if(fFirstTimeBin>=0){
+      HLTDebug("fFirstTimeBin set to %d",fFirstTimeBin);
+      fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
+    }
+    else{
+      HLTError("-first-timebin specifier is negative: %d",fFirstTimeBin);
+    }
+    return 2;
+  }
+
+  if (argument.CompareTo("-last-timebin")==0){
+    if (++i>=argc) return -EPROTO;
+    argument=argv[i];
+    fLastTimeBin = argument.Atoi();
+    if(fLastTimeBin<AliHLTTPCTransform::GetNTimeBins()){
+      HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
+    }
+    else{
+      HLTError("fLastTimeBins is too big: %d. Maximum: %d",fLastTimeBin,AliHLTTPCTransform::GetNTimeBins());
+    }
+    return 2;
+  }
+ 
+  if (argument.CompareTo("-sorted")==0) {
+    fUnsorted=0;
+    HLTDebug("Swithching unsorted off.");
+    fClusterFinder->SetUnsorted(0);
+    return 1;
+  } 
+  
+  if (argument.CompareTo("-do-mc")==0) {
+    fDoMC=kTRUE;
+    fClusterFinder->SetDoMC(fDoMC);
+    HLTDebug("Setting fDoMC to true.");
+    return 1;
+  }
+  if (argument.CompareTo("-release-memory")==0) {
+    fReleaseMemory=kTRUE;
+    fClusterFinder->SetReleaseMemory( fReleaseMemory );
+    HLTDebug("Setting fReleaseMemory to true.");
+    return 1;
+  }
+
+  if (argument.CompareTo("-active-pads")==0 || argument.CompareTo("activepads")==0){
+    if(argument.CompareTo("activepads" )==0){
+      HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'activepads'");
+    }
+    HLTDebug("Switching on ActivePads");
+    fGetActivePads = 1;
+    fClusterFinder->SetDoPadSelection(kTRUE);
+    return 1;
+  }
+
+  if (argument.CompareTo("-occupancy-limit")==0 || argument.CompareTo("occupancy-limit")==0){
+    if(argument.CompareTo("occupancy-limit" )==0){
+      HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
+    }
+    if (++i>=argc) return -EPROTO;
+    argument=argv[i];
+    fClusterFinder->SetOccupancyLimit(argument.Atof());
+    HLTDebug("Occupancy limit set to occulimit %f", argument.Atof());
+    return 2;
+  }
+
+  if (argument.CompareTo("rawreadermode")==0){
+    if (++i>=argc) return -EPROTO;
+    HLTWarning("Argument 'rawreadermode' is deprecated");
+    return 2;
+  }
+  
+  if (argument.CompareTo("pp-run")==0){
+    HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
+    fClusterDeconv = false;
+    return 1;
+  }
+
+  if (argument.CompareTo("adc-threshold" )==0){
+    if (++i>=argc) return -EPROTO;
+    HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
+    return 2;
+  } 
+  
+  if (argument.CompareTo("oldrcuformat" )==0){
+    if (++i>=argc) return -EPROTO;
+    HLTWarning("Argument 'oldrcuformat' is deprecated.");
+    return 2;
+  }
+  
+  if (argument.CompareTo("unsorted" )==0 || argument.CompareTo("-unsorted" )==0){
+    HLTWarning("Argument is obsolete, unsorted reading is default.");
+    //    fClusterFinder->SetUnsorted(1);
+    return 1;
+  }
+  if (argument.CompareTo("nsigma-threshold")==0){
+    if (++i>=argc) return -EPROTO;
+    HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
+    return 2;
+  }
+
+  // unknown argument
+  return -EINVAL;
+}
+
+int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
+{  
+  // see header file for class documentation
+
+  TString cdbPath;
+  if (cdbEntry) {
+    cdbPath=cdbEntry;
+  } else {
+    cdbPath="HLT/ConfigTPC/";
+    cdbPath+=GetComponentID();
+  }
+
+  return ConfigureFromCDBTObjString(cdbPath.Data());
+
+  /*
+  int iResult=0;
+  
+  const char* path="HLT/ConfigTPC/ClusterFinderComponent";
   if (cdbEntry) path=cdbEntry;
   if (path) {
     HLTInfo("reconfigure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
-    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
+    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);//,GetRunNo());
     if (pEntry) {
       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
       if (pString) {
 	HLTInfo("received configuration object: %s", pString->GetString().Data());
+	iResult = Configure(pString->GetString().Data());
       } else {
 	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
       }
@@ -604,5 +775,193 @@ int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const cha
       HLTError("can not fetch object \"%s\" from CDB", path);
     }
   }
-  return 0;
+  return iResult;
+  */
+}
+
+int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){
+  // see header file for class documentation
+  int iResult=0;
+  if (!arguments) return iResult;
+  
+  TString allArgs=arguments;
+  TString argument;
+  int bMissingParam=0;
+
+  TObjArray* pTokens=allArgs.Tokenize(" ");
+  if (pTokens) {
+    
+    for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
+      argument=((TObjString*)pTokens->At(i))->GetString();
+
+      if (argument.IsNull()) continue;
+      
+      // -- deconvolute-time option
+      if (argument.CompareTo("-deconvolute-time")==0){
+	HLTDebug("Switching on deconvolution in time direction.");
+	fDeconvTime = kTRUE;
+	fClusterFinder->SetDeconvTime(fDeconvTime);
+      }
+      else if (argument.CompareTo("-deconvolute-pad")==0){
+	HLTDebug("Switching on deconvolution in pad direction.");
+	fDeconvPad = kTRUE;
+	fClusterFinder->SetDeconvPad(fDeconvPad);
+      }
+      else if (argument.CompareTo("-timebins")==0 || argument.CompareTo("timebins" )==0){
+	HLTWarning("Argument %s is depreciated after moving to the offline AliTPCTransform class for xyz calculations.",argument.Data());
+	/*
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	AliHLTTPCTransform::SetNTimeBins(((TObjString*)pTokens->At(i))->GetString().Atoi());
+	fClusterFinder->UpdateLastTimeBin();
+	HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
+	*/
+	if(argument.CompareTo("timebins")==0){
+	  HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
+	}
+	
+      }
+      else if (argument.CompareTo("-first-timebin")==0){
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	fFirstTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+	if(fFirstTimeBin>=0){
+	  HLTDebug("fFirstTimeBin set to %d",fFirstTimeBin);
+	  fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
+	}
+	else{
+	  HLTError("-first-timebin specifier is negative: %d",fFirstTimeBin);
+	}
+      }
+      else if (argument.CompareTo("-last-timebin")==0){
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	fLastTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+	if(fLastTimeBin<AliHLTTPCTransform::GetNTimeBins()){
+	  HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
+	}
+	else{
+	  HLTError("fLastTimeBins is too big: %d. Maximum: %d",fLastTimeBin,AliHLTTPCTransform::GetNTimeBins());
+	}
+      }
+      else if (argument.CompareTo("-sorted")==0) {
+	fUnsorted=0;
+	HLTDebug("Swithching unsorted off.");
+	fClusterFinder->SetUnsorted(0);
+      }
+      else if (argument.CompareTo("-do-mc")==0) {
+	fDoMC=kTRUE;
+	fClusterFinder->SetDoMC(fDoMC);
+	HLTInfo("Setting fDoMC to true.");
+      }
+      else if (argument.CompareTo("-release-memory")==0) {
+	fReleaseMemory = kTRUE;
+	fClusterFinder->SetReleaseMemory( kTRUE );
+	HLTInfo("Setting fReleaseMemory to true.");
+      }
+      else if (argument.CompareTo("-active-pads")==0 || argument.CompareTo("activepads")==0){
+	if(argument.CompareTo("activepads" )==0){
+	  HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'activepads'");
+	}
+	HLTDebug("Switching on ActivePads");
+	fGetActivePads = 1;
+	fClusterFinder->SetDoPadSelection(kTRUE);
+      }
+      else if (argument.CompareTo("-occupancy-limit")==0 || argument.CompareTo("occupancy-limit")==0){
+	if(argument.CompareTo("occupancy-limit" )==0){
+	  HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
+	}
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	fClusterFinder->SetOccupancyLimit(((TObjString*)pTokens->At(i))->GetString().Atof());
+	HLTDebug("Occupancy limit set to occulimit %f", ((TObjString*)pTokens->At(i))->GetString().Atof());
+      }
+      else if (argument.CompareTo("rawreadermode")==0){
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	HLTWarning("Argument 'rawreadermode' is deprecated");      
+      }
+      else if (argument.CompareTo("pp-run")==0){
+	HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
+	fClusterDeconv = false;
+      }
+      else if (argument.CompareTo("adc-threshold" )==0){
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
+      }
+      else if (argument.CompareTo("oldrcuformat" )==0){
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	HLTWarning("Argument 'oldrcuformat' is deprecated.");
+      }
+      else if (argument.CompareTo("unsorted" )==0){
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	HLTDebug("Using unsorted reading.");
+	fClusterFinder->SetUnsorted(1);
+      }
+      else if (argument.CompareTo("nsigma-threshold")==0){
+	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+	HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
+      }
+      else if (argument.CompareTo("-update-calibdb")==0){
+	fClusterFinder->UpdateCalibDB();
+      }
+      else {
+	HLTError("unknown argument %s", argument.Data());
+	iResult=-EINVAL;
+	break;
+      }
+    }
+    delete pTokens;
+  }
+  if (bMissingParam) {
+    HLTError("missing parameter for argument %s", argument.Data());
+    iResult=-EINVAL;
+  }
+  return iResult;
+}
+
+void AliHLTTPCClusterFinderComponent::GetOCDBObjectDescription( TMap* const targetMap){
+// Get a list of OCDB object description needed for the particular component
+  
+  if (!targetMap) return;
+  
+  // OCDB entries for component arguments
+  switch(fModeSwitch){
+  case kClusterFinderPacked:
+    // deprecated but kept for a short while to support porting to release
+    targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderPacked"),   new TObjString("component arguments, empty at the moment"));
+    break;
+  case kClusterFinderUnpacked:
+    targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderUnpacked"), new TObjString("component arguments, empty at the moment"));
+    break;
+  case kClusterFinderDecoder:
+    // deprecated but kept for a short while to support porting to release
+    targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderDecoder"),  new TObjString("component arguments, empty at the moment"));
+    break;
+  case kClusterFinder32Bit: 
+    targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinder32Bit"),    new TObjString("component arguments, empty at the moment"));
+    break;
+  }
+  
+  // OCDB entries to be fetched by the TAXI (access via the AliTPCcalibDB class)
+  targetMap->Add(new TObjString("TPC/Calib/Parameters"),    new TObjString("unknown content"));
+  targetMap->Add(new TObjString("TPC/Calib/TimeDrift"),     new TObjString("drift velocity calibration"));
+  targetMap->Add(new TObjString("TPC/Calib/Temperature"),   new TObjString("temperature map"));
+  targetMap->Add(new TObjString("TPC/Calib/PadGainFactor"), new TObjString("gain factor pad by pad"));
+  targetMap->Add(new TObjString("TPC/Calib/ClusterParam"),  new TObjString("cluster parameters"));
+  
+  // OCDB entries needed to be fetched by the Pendolino
+  targetMap->Add(new TObjString("TPC/Calib/AltroConfig"), new TObjString("contains the altro config, e.g. info about the L0 trigger timing"));
+  targetMap->Add(new TObjString("GRP/CTP/CTPtiming"),     new TObjString("content used in the cluster coordinate transformation in relation to the L0 trigger timing"));
+
+  // OCDB entries necessary for replaying data on the HLT cluster
+  targetMap->Add(new TObjString("GRP/GRP/Data"), new TObjString("contains magnetic field info"));  
+ 
+  // OCDB entries needed to suppress fatals/errors/warnings during reconstruction
+  targetMap->Add(new TObjString("TPC/Calib/PadTime0"),    new TObjString("time0 offset pad by pad"));
+  targetMap->Add(new TObjString("TPC/Calib/PadNoise"),    new TObjString("pad noise values"));
+  targetMap->Add(new TObjString("TPC/Calib/Pedestals"),   new TObjString("pedestal info"));
+  targetMap->Add(new TObjString("TPC/Calib/Pulser"),      new TObjString("pulser info"));
+  targetMap->Add(new TObjString("TPC/Calib/CE"),          new TObjString("CE laser calibration result"));
+  targetMap->Add(new TObjString("TPC/Calib/Raw"),         new TObjString("unknown content"));
+  targetMap->Add(new TObjString("TPC/Calib/QA"),          new TObjString("not important"));
+  targetMap->Add(new TObjString("TPC/Calib/Mapping"),     new TObjString("unknown content"));
+  targetMap->Add(new TObjString("TPC/Calib/Goofie"),      new TObjString("Goofie values, not used at the moment (05.03.2010)"));
+  targetMap->Add(new TObjString("TPC/Calib/HighVoltage"), new TObjString("high voltage values, not used"));
+  targetMap->Add(new TObjString("TPC/Calib/Ref"),         new TObjString("unknown content"));
 }