[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCClusterFinderComponent.cxx

// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Timm Steinbeck, Matthias Richter                      *
//* Developers:      Kenneth Aamodt <kenneth.aamodt@student.uib.no>        *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* Permission to use, copy, modify and distribute this software and its   *
//* documentation strictly for non-commercial purposes is hereby granted   *
//* without fee, provided that the above copyright notice appears in all   *
//* copies and that both the copyright notice and this permission notice   *
//* appear in the supporting documentation. The authors make no claims     *
//* about the suitability of this software for any purpose. It is          *
//* provided "as is" without express or implied warranty.                  *
//**************************************************************************

/** @file   AliHLTTPCClusterFinderComponent.cxx
    @author Kenneth Aamodt <kenneth.aamodt@student.uib.no>
    @date   
    @brief  The TPC cluster finder processing component
*/

#if __GNUC__>= 3
using namespace std;
#endif
#include "AliHLTTPCClusterFinderComponent.h"
#include "AliHLTTPCDigitReaderPacked.h"
#include "AliHLTTPCDigitReaderUnpacked.h"
#include "AliHLTTPCDigitReaderDecoder.h"
#include "AliHLTTPCClusterFinder.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCClusters.h"
#include "AliHLTTPCDefinitions.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"

#include <cstdlib>
#include <cerrno>
#include "TString.h"
#include "TObjString.h"
#include "TObjArray.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"

#include <sys/time.h>

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCClusterFinderComponent)

AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode)
  :
  fClusterFinder(NULL),
  fReader(NULL),
  fDeconvTime(kFALSE),
  fDeconvPad(kFALSE),
  fClusterDeconv(false),
  fXYClusterError(-1),
  fZClusterError(-1),
  fModeSwitch(mode),
  fUnsorted(1),
  fPatch(0),
  fGetActivePads(0),
  fFirstTimeBin(-1),
  fLastTimeBin(-1)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  if (fModeSwitch!=kClusterFinderPacked &&
      fModeSwitch!=kClusterFinderUnpacked &&
      fModeSwitch!=kClusterFinderDecoder) {
    HLTFatal("unknown digit reader type");
  }
}

AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
{
  // see header file for class documentation
}

// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process

const char* AliHLTTPCClusterFinderComponent::GetComponentID()
{
  // see header file for class documentation
  switch(fModeSwitch){
  case kClusterFinderPacked:
    return "TPCClusterFinderPacked";
    break;
  case kClusterFinderUnpacked: 	 
    return "TPCClusterFinderUnpacked"; 	 
    break;
  case kClusterFinderDecoder:
    return "TPCClusterFinderDecoder";
    break;
  }
  return "";
}

void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
  // 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:
    list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
    break;
  }
}

AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
{
  // see header file for class documentation
  return kAliHLTMultipleDataType;
}

int AliHLTTPCClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)

{
  // see header file for class documentation
  tgtList.clear();
  tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
  tgtList.push_back(kAliHLTDataTypeHwAddr16);
  return tgtList.size();
}

void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
  // see header file for class documentation
  // XXX TODO: Find more realistic values.  
  constBase = 0;
  switch(fModeSwitch){
  case 0:
    inputMultiplier = (6 * 0.4);
    break;
  case 1:
    inputMultiplier = 0.4;
    break;
  case 2:
    inputMultiplier = (6 * 0.4);
    break;
  }
}

AliHLTComponent* AliHLTTPCClusterFinderComponent::Spawn()
{
  // see header file for class documentation
  return new AliHLTTPCClusterFinderComponent(fModeSwitch);
}
	
int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
{
  // see header file for class documentation
  if ( fClusterFinder )
    return EINPROGRESS;

  fClusterFinder = new AliHLTTPCClusterFinder();

  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){
    if(fDeconvPad==kTRUE || fDeconvTime==kTRUE){
      HLTWarning("Conflicting arguments: argument 'pp-run' will be ignored.");
    }
  }
  if(fClusterFinder->GetOccupancyLimit()!=1.0 && fUnsorted){
    HLTWarning("Argument 'occupancy-limit' is deprecated when doing unsorted data reading.");
  }
  if(fGetActivePads==kTRUE && fUnsorted==kFALSE){
    HLTWarning("Argument '-active-pads' only work with unsorted data reading. Active pads list will not be produced.");
  }
  

  // Choose reader
  if (fModeSwitch==kClusterFinderPacked) {
      HLTDebug("using AliHLTTPCDigitReaderPacked");
      fReader = new AliHLTTPCDigitReaderPacked();
      if(fUnsorted==1){	fReader->SetUnsorted(kTRUE); }
      fClusterFinder->SetReader(fReader);
  }
  else if(fModeSwitch==kClusterFinderUnpacked){ 	 
    HLTDebug("using AliHLTTPCDigitReaderUnpacked"); 	 
    fReader = new AliHLTTPCDigitReaderUnpacked(); 	 
    fClusterFinder->SetReader(fReader);
  }
  else if(fModeSwitch==kClusterFinderDecoder){
    HLTDebug("using AliHLTTPCDigitReaderDecoder");
    fReader = new AliHLTTPCDigitReaderDecoder();
    fClusterFinder->SetReader(fReader);
  }
  else{
    HLTFatal("No mode set for clusterfindercomponent");
  }

  if(fClusterDeconv){
    fClusterFinder->SetOccupancyLimit(1.0);
  }
  
  fClusterFinder->SetDeconv(fClusterDeconv);
  fClusterFinder->SetDeconvPad(fDeconvPad);
  fClusterFinder->SetDeconvTime(fDeconvPad);
  fClusterFinder->SetXYError( fXYClusterError );
  fClusterFinder->SetZError( fZClusterError );
  if ( (fXYClusterError>0) && (fZClusterError>0) ){
    fClusterFinder->SetCalcErr( false );
  }

  if(fFirstTimeBin>0){
    fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
  }
  if(fLastTimeBin>0 && fLastTimeBin>fFirstTimeBin && fLastTimeBin<=AliHLTTPCTransform::GetNTimeBins()){
    fClusterFinder->SetLastTimeBin(fLastTimeBin);
  }

  return 0;
}

int AliHLTTPCClusterFinderComponent::DoDeinit()
{
  // see header file for class documentation

  if ( fClusterFinder )
    delete fClusterFinder;
  fClusterFinder = NULL;
 
  if ( fReader )
    delete fReader;
  fReader = NULL;
    
  return 0;
}

int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData, 
					      const AliHLTComponentBlockData* blocks, 
					      AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
					      AliHLTUInt32_t& size, 
					      vector<AliHLTComponentBlockData>& outputBlocks )
{
  // see header file for class documentation

  if(fReader == NULL){
    HLTFatal("Digit reader not initialized, aborting event.");
    size=0;
    return 0;    
  }

  if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){
    size=0;
    return 0;
  }

  //  == init iter (pointer to datablock)
  const AliHLTComponentBlockData* iter = NULL;
  unsigned long ndx;

  //  == OUTdatatype pointer
  AliHLTTPCClusterData* outPtr;

  AliHLTUInt8_t* outBPtr;
  UInt_t offset, mysize, nSize, tSize = 0;

  outBPtr = outputPtr;
  outPtr = (AliHLTTPCClusterData*)outBPtr;

  Int_t slice, patch;
  unsigned long maxPoints, realPoints = 0;

  for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
    {
      iter = blocks+ndx;
      mysize = 0;
      offset = tSize;


      if (fModeSwitch==0 || fModeSwitch==2) {
	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
		 evtData.fEventID, evtData.fEventID, 
		 DataType2Text( iter->fDataType).c_str(), 
		 DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());

	if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType &&
	    GetEventCount()<2) {
	  HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
		     DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
		     DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
	  }

	if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) &&
	     iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue;

      }
      else if(fModeSwitch==1){
	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
		 evtData.fEventID, evtData.fEventID, 
		 DataType2Text( iter->fDataType).c_str(), 
		 DataType2Text(AliHLTTPCDefinitions::fgkUnpackedRawDataType).c_str());

	if ( iter->fDataType != AliHLTTPCDefinitions::fgkUnpackedRawDataType ) continue;

      }

      slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
      patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );

      if(fUnsorted){
	fClusterFinder->SetUnsorted(fUnsorted);
	fClusterFinder->SetPatch(patch);
      }

      outPtr = (AliHLTTPCClusterData*)outBPtr;

      maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);

      fClusterFinder->InitSlice( slice, patch, maxPoints );
      fClusterFinder->SetOutputArray( (AliHLTTPCSpacePointData*)outPtr->fSpacePoints );
	
      if(fUnsorted){
      	if(fGetActivePads){
	  fClusterFinder->SetDoPadSelection(kTRUE);
	}	
	if(fDeconvTime){
	  fClusterFinder->ReadDataUnsortedDeconvoluteTime(iter->fPtr, iter->fSize);
	}
	else{
	  fClusterFinder->ReadDataUnsorted(iter->fPtr, iter->fSize);
	}

	fClusterFinder->FindClusters();
      }
      else{
	fClusterFinder->Read(iter->fPtr, iter->fSize );
	fClusterFinder->ProcessDigits();
      }

      realPoints = fClusterFinder->GetNumberOfClusters();
	
      outPtr->fSpacePointCnt = realPoints;
      nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
      mysize += nSize+sizeof(AliHLTTPCClusterData);

      Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints", 
	       "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
	       realPoints, slice, patch,AliHLTTPCTransform::GetFirstRow( patch ) , AliHLTTPCTransform::GetLastRow( patch ) );
      AliHLTComponentBlockData bd;
      FillBlockData( bd );
      bd.fOffset = offset;
      bd.fSize = mysize;
      bd.fSpecification = iter->fSpecification;
      bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
      outputBlocks.push_back( bd );
	
      tSize += mysize;
      outBPtr += mysize;
      outPtr = (AliHLTTPCClusterData*)outBPtr;
	

      if ( tSize > size )
	{
	  Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data", 
		   "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
		   tSize, size );
	  return -ENOSPC;
	}
	
      if(fUnsorted && fGetActivePads){
       Int_t maxNumberOfHW=(Int_t)((size-tSize)/sizeof(AliHLTUInt16_t)-1);
       AliHLTUInt16_t* outputHWPtr= (AliHLTUInt16_t*)(outputPtr+tSize);
       Int_t nHWAdd = fClusterFinder->FillHWAddressList(outputHWPtr, maxNumberOfHW);
      
       AliHLTComponentBlockData bdHW;
       FillBlockData( bdHW );
       bdHW.fOffset = tSize ;
       bdHW.fSize = nHWAdd*sizeof(AliHLTUInt16_t);
       bdHW.fSpecification = iter->fSpecification;
       bdHW.fDataType = kAliHLTDataTypeHwAddr16;
       outputBlocks.push_back( bdHW );
       
       tSize+=nHWAdd*sizeof(AliHLTUInt16_t);
      }
      fReader->Reset();
    }
    
  size = tSize;

  return 0;
}

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;
      }
      else if (argument.CompareTo("-deconvolute-pad")==0){
	HLTDebug("Switching on deconvolution in pad direction.");
	fDeconvPad = kTRUE;
      }
      else if (argument.CompareTo("-timebins")==0 || argument.CompareTo("timebins" )==0){
	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();
	HLTDebug("Kenneth fFirstTimeBin set to %d",fFirstTimeBin);
      }
      else if (argument.CompareTo("-last-timebin")==0){
	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	fLastTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
	HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
      }
      else if (argument.CompareTo("-sorted")) {
	fUnsorted=0;
	HLTDebug("Swithching unsorted off.");
      }
      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;
      }
      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;
	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.");
      }
      else if (argument.CompareTo("nsigma-threshold")==0){
	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
      }
      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;
}

int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
{
  // see header file for class documentation
  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()*/);
    if (pEntry) {
      TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
      if (pString) {
	HLTInfo("received configuration object: %s", pString->GetString().Data());
      } else {
	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
      }
    } else {
      HLTError("can not fetch object \"%s\" from CDB", path);
    }
  }
  return 0;
}
Commit	Line	Data
71d7c760	1	// $Id$
71d7c760	2
297174de	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	//**************************************************************************
71d7c760	19
96bda103	20	/** @file AliHLTTPCClusterFinderComponent.cxx
297174de	21	@author Kenneth Aamodt <kenneth.aamodt@student.uib.no>
de554e07	22	@date
	23	@brief The TPC cluster finder processing component
	24	*/
a38a7850	25
db16520a	26	#if __GNUC__>= 3
71d7c760	27	using namespace std;
71d7c760	28	#endif
71d7c760	29	#include "AliHLTTPCClusterFinderComponent.h"
a38a7850	30	#include "AliHLTTPCDigitReaderPacked.h"
a38a7850	31	#include "AliHLTTPCDigitReaderUnpacked.h"
8252a538	32	#include "AliHLTTPCDigitReaderDecoder.h"
a38a7850	33	#include "AliHLTTPCClusterFinder.h"
a6c02c85	34	#include "AliHLTTPCSpacePointData.h"
71d7c760	35	#include "AliHLTTPCClusterDataFormat.h"
a6c02c85	36	#include "AliHLTTPCTransform.h"
01f43166	37	#include "AliHLTTPCClusters.h"
e67b0680	38	#include "AliHLTTPCDefinitions.h"
c3cda394	39	#include "AliCDBEntry.h"
	40	#include "AliCDBManager.h"
	41
e67b0680	42	#include <cstdlib>
e67b0680	43	#include <cerrno>
ecefc48a	44	#include "TString.h"
c3cda394	45	#include "TObjString.h"
3f0fd8f1	46	#include "TObjArray.h"
	47	#include "AliCDBEntry.h"
	48	#include "AliCDBManager.h"
	49	#include "AliCDBStorage.h"
	50
01f43166	51	#include <sys/time.h>
71d7c760	52
c3cda394	53	/** ROOT macro for the implementation of ROOT specific class methods */
71d7c760	54	ClassImp(AliHLTTPCClusterFinderComponent)
71d7c760	55
8252a538	56	AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode)
74c73e5a	57	:
74c73e5a	58	fClusterFinder(NULL),
74c73e5a	59	fReader(NULL),
6b15c309	60	fDeconvTime(kFALSE),
	61	fDeconvPad(kFALSE),
	62	fClusterDeconv(false),
74c73e5a	63	fXYClusterError(-1),
2a083ac4	64	fZClusterError(-1),
8252a538	65	fModeSwitch(mode),
6b15c309	66	fUnsorted(1),
a1dbf058	67	fPatch(0),
6b15c309	68	fGetActivePads(0),
	69	fFirstTimeBin(-1),
	70	fLastTimeBin(-1)
74c73e5a	71	{
2a083ac4	72	// see header file for class documentation
	73	// or
	74	// refer to README to build package
	75	// or
	76	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
aca7e630	77	if (fModeSwitch!=kClusterFinderPacked &&
	78	fModeSwitch!=kClusterFinderUnpacked &&
	79	fModeSwitch!=kClusterFinderDecoder) {
	80	HLTFatal("unknown digit reader type");
	81	}
74c73e5a	82	}
74c73e5a	83
71d7c760	84	AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
7e99beb3	85	{
2a083ac4	86	// see header file for class documentation
7e99beb3	87	}
71d7c760	88
	89	// Public functions to implement AliHLTComponent's interface.
	90	// These functions are required for the registration process
	91
	92	const char* AliHLTTPCClusterFinderComponent::GetComponentID()
7e99beb3	93	{
2a083ac4	94	// see header file for class documentation
8252a538	95	switch(fModeSwitch){
2efb85be	96	case kClusterFinderPacked:
8252a538	97	return "TPCClusterFinderPacked";
8252a538	98	break;
d1dbb3c1	99	case kClusterFinderUnpacked:
	100	return "TPCClusterFinderUnpacked";
	101	break;
2efb85be	102	case kClusterFinderDecoder:
8252a538	103	return "TPCClusterFinderDecoder";
	104	break;
	105	}
b0914d2e	106	return "";
7e99beb3	107	}
71d7c760	108
8ede8717	109	void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
7e99beb3	110	{
2a083ac4	111	// see header file for class documentation
7e99beb3	112	list.clear();
8252a538	113	switch(fModeSwitch){
2efb85be	114	case kClusterFinderPacked:
8252a538	115	list.push_back( kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC );
8252a538	116	break;
d1dbb3c1	117	case kClusterFinderUnpacked:
	118	list.push_back( AliHLTTPCDefinitions::fgkUnpackedRawDataType );
	119	break;
2efb85be	120	case kClusterFinderDecoder:
8252a538	121	list.push_back( kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC );
	122	break;
	123	}
7e99beb3	124	}
71d7c760	125
8ede8717	126	AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
7e99beb3	127	{
2a083ac4	128	// see header file for class documentation
64defa03	129	return kAliHLTMultipleDataType;
	130	}
	131
	132	int AliHLTTPCClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
	133
	134	{
	135	// see header file for class documentation
	136	tgtList.clear();
	137	tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
2fdb1ae7	138	tgtList.push_back(kAliHLTDataTypeHwAddr16);
64defa03	139	return tgtList.size();
7e99beb3	140	}
71d7c760	141
71d7c760	142	void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
7e99beb3	143	{
2a083ac4	144	// see header file for class documentation
7e99beb3	145	// XXX TODO: Find more realistic values.
7e99beb3	146	constBase = 0;
8252a538	147	switch(fModeSwitch){
	148	case 0:
	149	inputMultiplier = (6 * 0.4);
	150	break;
	151	case 1:
	152	inputMultiplier = 0.4;
	153	break;
	154	case 2:
	155	inputMultiplier = (6 * 0.4);
	156	break;
	157	}
7e99beb3	158	}
71d7c760	159
71d7c760	160	AliHLTComponent* AliHLTTPCClusterFinderComponent::Spawn()
7e99beb3	161	{
2a083ac4	162	// see header file for class documentation
8252a538	163	return new AliHLTTPCClusterFinderComponent(fModeSwitch);
7e99beb3	164	}
71d7c760	165
71d7c760	166	int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
7e99beb3	167	{
2a083ac4	168	// see header file for class documentation
7e99beb3	169	if ( fClusterFinder )
	170	return EINPROGRESS;
	171
	172	fClusterFinder = new AliHLTTPCClusterFinder();
	173
3f0fd8f1	174	Int_t iResult=0;
	175	TString configuration="";
	176	TString argument="";
	177	for (int i=0; i<argc && iResult>=0; i++) {
	178	argument=argv[i];
	179	if (!configuration.IsNull()) configuration+=" ";
	180	configuration+=argument;
	181	}
	182
	183	if (!configuration.IsNull()) {
	184	iResult=Configure(configuration.Data());
	185	} else {
	186	iResult=Reconfigure(NULL, NULL);
7e99beb3	187	}
db16520a	188
6b15c309	189	//Checking for conflicting arguments
	190	if(fClusterDeconv){
	191	if(fDeconvPad==kTRUE \|\| fDeconvTime==kTRUE){
	192	HLTWarning("Conflicting arguments: argument 'pp-run' will be ignored.");
	193	}
	194	}
3f0fd8f1	195	if(fClusterFinder->GetOccupancyLimit()!=1.0 && fUnsorted){
6b15c309	196	HLTWarning("Argument 'occupancy-limit' is deprecated when doing unsorted data reading.");
	197	}
	198	if(fGetActivePads==kTRUE && fUnsorted==kFALSE){
	199	HLTWarning("Argument '-active-pads' only work with unsorted data reading. Active pads list will not be produced.");
	200	}
	201
	202
7e99beb3	203	// Choose reader
51b88d1e	204	if (fModeSwitch==kClusterFinderPacked) {
f44e97dc	205	HLTDebug("using AliHLTTPCDigitReaderPacked");
7e99beb3	206	fReader = new AliHLTTPCDigitReaderPacked();
a912b63b	207	if(fUnsorted==1){ fReader->SetUnsorted(kTRUE); }
7e99beb3	208	fClusterFinder->SetReader(fReader);
7e99beb3	209	}
8e3c15c4	210	else if(fModeSwitch==kClusterFinderUnpacked){
	211	HLTDebug("using AliHLTTPCDigitReaderUnpacked");
	212	fReader = new AliHLTTPCDigitReaderUnpacked();
	213	fClusterFinder->SetReader(fReader);
	214	}
2efb85be	215	else if(fModeSwitch==kClusterFinderDecoder){
51b88d1e	216	HLTDebug("using AliHLTTPCDigitReaderDecoder");
8252a538	217	fReader = new AliHLTTPCDigitReaderDecoder();
	218	fClusterFinder->SetReader(fReader);
	219	}
	220	else{
	221	HLTFatal("No mode set for clusterfindercomponent");
	222	}
3f0fd8f1	223
3f0fd8f1	224	if(fClusterDeconv){
7e99beb3	225	fClusterFinder->SetOccupancyLimit(1.0);
3f0fd8f1	226	}
6b15c309	227
	228	fClusterFinder->SetDeconv(fClusterDeconv);
	229	fClusterFinder->SetDeconvPad(fDeconvPad);
	230	fClusterFinder->SetDeconvTime(fDeconvPad);
7e99beb3	231	fClusterFinder->SetXYError( fXYClusterError );
7e99beb3	232	fClusterFinder->SetZError( fZClusterError );
6b15c309	233	if ( (fXYClusterError>0) && (fZClusterError>0) ){
7e99beb3	234	fClusterFinder->SetCalcErr( false );
6b15c309	235	}
6b15c309	236
	237	if(fFirstTimeBin>0){
	238	fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
	239	}
	240	if(fLastTimeBin>0 && fLastTimeBin>fFirstTimeBin && fLastTimeBin<=AliHLTTPCTransform::GetNTimeBins()){
	241	fClusterFinder->SetLastTimeBin(fLastTimeBin);
	242	}
01f43166	243
7e99beb3	244	return 0;
7e99beb3	245	}
71d7c760	246
71d7c760	247	int AliHLTTPCClusterFinderComponent::DoDeinit()
7e99beb3	248	{
2a083ac4	249	// see header file for class documentation
a38a7850	250
7e99beb3	251	if ( fClusterFinder )
	252	delete fClusterFinder;
	253	fClusterFinder = NULL;
a38a7850	254
7e99beb3	255	if ( fReader )
	256	delete fReader;
	257	fReader = NULL;
a38a7850	258
7e99beb3	259	return 0;
7e99beb3	260	}
71d7c760	261
8ede8717	262	int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData,
8ede8717	263	const AliHLTComponentBlockData* blocks,
5d2abf3b	264	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
a38a7850	265	AliHLTUInt32_t& size,
8ede8717	266	vector<AliHLTComponentBlockData>& outputBlocks )
7e99beb3	267	{
2a083ac4	268	// see header file for class documentation
db16520a	269
a912b63b	270	if(fReader == NULL){
	271	HLTFatal("Digit reader not initialized, aborting event.");
	272	size=0;
	273	return 0;
	274	}
	275
0e588049	276	if(GetFirstInputBlock( kAliHLTDataTypeSOR ) \|\| GetFirstInputBlock( kAliHLTDataTypeEOR )){
	277	size=0;
	278	return 0;
	279	}
	280
7e99beb3	281	// == init iter (pointer to datablock)
	282	const AliHLTComponentBlockData* iter = NULL;
	283	unsigned long ndx;
a38a7850	284
7e99beb3	285	// == OUTdatatype pointer
7e99beb3	286	AliHLTTPCClusterData* outPtr;
a38a7850	287
7e99beb3	288	AliHLTUInt8_t* outBPtr;
7e99beb3	289	UInt_t offset, mysize, nSize, tSize = 0;
a38a7850	290
7e99beb3	291	outBPtr = outputPtr;
7e99beb3	292	outPtr = (AliHLTTPCClusterData*)outBPtr;
a38a7850	293
a912b63b	294	Int_t slice, patch;
7e99beb3	295	unsigned long maxPoints, realPoints = 0;
a38a7850	296
7e99beb3	297	for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
	298	{
	299	iter = blocks+ndx;
	300	mysize = 0;
	301	offset = tSize;
a38a7850	302
a38a7850	303
8252a538	304	if (fModeSwitch==0 \|\| fModeSwitch==2) {
f69743b7	305	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	306	evtData.fEventID, evtData.fEventID,
	307	DataType2Text( iter->fDataType).c_str(),
	308	DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
a38a7850	309
f69743b7	310	if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType &&
	311	GetEventCount()<2) {
	312	HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
	313	DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
	314	DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	315	}
	316
	317	if ( iter->fDataType != (kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC) &&
	318	iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue;
a38a7850	319
7e99beb3	320	}
8252a538	321	else if(fModeSwitch==1){
f69743b7	322	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	323	evtData.fEventID, evtData.fEventID,
	324	DataType2Text( iter->fDataType).c_str(),
	325	DataType2Text(AliHLTTPCDefinitions::fgkUnpackedRawDataType).c_str());
aca7e630	326
	327	if ( iter->fDataType != AliHLTTPCDefinitions::fgkUnpackedRawDataType ) continue;
	328
7e99beb3	329	}
5863c71a	330
7e99beb3	331	slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
7e99beb3	332	patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
8252a538	333
aff6e981	334	if(fUnsorted){
8252a538	335	fClusterFinder->SetUnsorted(fUnsorted);
8252a538	336	fClusterFinder->SetPatch(patch);
aff6e981	337	}
aff6e981	338
7e99beb3	339	outPtr = (AliHLTTPCClusterData*)outBPtr;
a38a7850	340
7e99beb3	341	maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
db16520a	342
a912b63b	343	fClusterFinder->InitSlice( slice, patch, maxPoints );
e83e889b	344	fClusterFinder->SetOutputArray( (AliHLTTPCSpacePointData*)outPtr->fSpacePoints );
01f43166	345
01f43166	346	if(fUnsorted){
2fdb1ae7	347	if(fGetActivePads){
2fdb1ae7	348	fClusterFinder->SetDoPadSelection(kTRUE);
a912b63b	349	}
6b15c309	350	if(fDeconvTime){
	351	fClusterFinder->ReadDataUnsortedDeconvoluteTime(iter->fPtr, iter->fSize);
	352	}
	353	else{
	354	fClusterFinder->ReadDataUnsorted(iter->fPtr, iter->fSize);
	355	}
01f43166	356
01f43166	357	fClusterFinder->FindClusters();
	358	}
	359	else{
	360	fClusterFinder->Read(iter->fPtr, iter->fSize );
	361	fClusterFinder->ProcessDigits();
	362	}
a912b63b	363
7e99beb3	364	realPoints = fClusterFinder->GetNumberOfClusters();
71d7c760	365
7e99beb3	366	outPtr->fSpacePointCnt = realPoints;
	367	nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
	368	mysize += nSize+sizeof(AliHLTTPCClusterData);
74511e22	369
74511e22	370	Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints",
7e99beb3	371	"Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
a912b63b	372	realPoints, slice, patch,AliHLTTPCTransform::GetFirstRow( patch ) , AliHLTTPCTransform::GetLastRow( patch ) );
7e99beb3	373	AliHLTComponentBlockData bd;
	374	FillBlockData( bd );
	375	bd.fOffset = offset;
	376	bd.fSize = mysize;
	377	bd.fSpecification = iter->fSpecification;
64defa03	378	bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
7e99beb3	379	outputBlocks.push_back( bd );
71d7c760	380
7e99beb3	381	tSize += mysize;
	382	outBPtr += mysize;
	383	outPtr = (AliHLTTPCClusterData*)outBPtr;
71d7c760	384
b1c46961	385
7e99beb3	386	if ( tSize > size )
	387	{
	388	Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data",
	389	"Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
	390	tSize, size );
5863c71a	391	return -ENOSPC;
71d7c760	392	}
2fdb1ae7	393
	394	if(fUnsorted && fGetActivePads){
	395	Int_t maxNumberOfHW=(Int_t)((size-tSize)/sizeof(AliHLTUInt16_t)-1);
	396	AliHLTUInt16_t* outputHWPtr= (AliHLTUInt16_t*)(outputPtr+tSize);
	397	Int_t nHWAdd = fClusterFinder->FillHWAddressList(outputHWPtr, maxNumberOfHW);
	398
2fdb1ae7	399	AliHLTComponentBlockData bdHW;
	400	FillBlockData( bdHW );
	401	bdHW.fOffset = tSize ;
	402	bdHW.fSize = nHWAdd*sizeof(AliHLTUInt16_t);
	403	bdHW.fSpecification = iter->fSpecification;
	404	bdHW.fDataType = kAliHLTDataTypeHwAddr16;
	405	outputBlocks.push_back( bdHW );
	406
	407	tSize+=nHWAdd*sizeof(AliHLTUInt16_t);
	408	}
5863c71a	409	fReader->Reset();
71d7c760	410	}
7e99beb3	411
7e99beb3	412	size = tSize;
71d7c760	413
7e99beb3	414	return 0;
7e99beb3	415	}
c3cda394	416
3f0fd8f1	417	int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){
	418	// see header file for class documentation
	419	int iResult=0;
	420	if (!arguments) return iResult;
	421
	422	TString allArgs=arguments;
	423	TString argument;
	424	int bMissingParam=0;
	425
	426	TObjArray* pTokens=allArgs.Tokenize(" ");
	427	if (pTokens) {
	428
	429	for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
	430	argument=((TObjString*)pTokens->At(i))->GetString();
	431
	432	if (argument.IsNull()) continue;
	433
	434
	435	// -- deconvolute-time option
	436	if (argument.CompareTo("-deconvolute-time")==0){
	437	HLTDebug("Switching on deconvolution in time direction.");
	438	fDeconvTime = kTRUE;
	439	}
	440	else if (argument.CompareTo("-deconvolute-pad")==0){
	441	HLTDebug("Switching on deconvolution in pad direction.");
	442	fDeconvPad = kTRUE;
	443	}
	444	else if (argument.CompareTo("-timebins")==0 \|\| argument.CompareTo("timebins" )==0){
	445	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	446	AliHLTTPCTransform::SetNTimeBins(((TObjString*)pTokens->At(i))->GetString().Atoi());
	447	fClusterFinder->UpdateLastTimeBin();
	448	HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
	449	if(argument.CompareTo("timebins")==0){
	450	HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
	451	}
	452	}
	453	else if (argument.CompareTo("-first-timebin")==0){
	454	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	455	fFirstTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
	456	HLTDebug("Kenneth fFirstTimeBin set to %d",fFirstTimeBin);
	457	}
	458	else if (argument.CompareTo("-last-timebin")==0){
	459	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	460	fLastTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
	461	HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
	462	}
	463	else if (argument.CompareTo("-sorted")) {
	464	fUnsorted=0;
	465	HLTDebug("Swithching unsorted off.");
	466	}
	467	else if (argument.CompareTo("-active-pads")==0 \|\| argument.CompareTo("activepads")==0){
	468	if(argument.CompareTo("activepads" )==0){
	469	HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'activepads'");
	470	}
	471	HLTDebug("Switching on ActivePads");
	472	fGetActivePads = 1;
	473	}
	474	else if (argument.CompareTo("-occupancy-limit")==0 \|\|argument.CompareTo("occupancy-limit")==0){
	475	if(argument.CompareTo("occupancy-limit" )==0){
	476	HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
	477	}
	478	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	479	fClusterFinder->SetOccupancyLimit(((TObjString*)pTokens->At(i))->GetString().Atof());
	480	HLTDebug("Occupancy limit set to occulimit %f", ((TObjString*)pTokens->At(i))->GetString().Atof());
481	}
482	else if (argument.CompareTo("rawreadermode")==0){
483	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
484	HLTWarning("Argument 'rawreadermode' is deprecated");
485	}
486	else if (argument.CompareTo("pp-run")==0){
487	HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
488	fClusterDeconv = false;
489	}
490	else if (argument.CompareTo("adc-threshold" )==0){
491	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
492	HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
493	}
494	else if (argument.CompareTo("oldrcuformat" )==0){
495	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
496	HLTWarning("Argument 'oldrcuformat' is deprecated.");
497	}
498	else if (argument.CompareTo("unsorted" )==0){
499	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
500	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.");
501	}
502	else if (argument.CompareTo("nsigma-threshold")==0){
503	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
504	HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
505	}
506	else {
507	HLTError("unknown argument %s", argument.Data());
508	iResult=-EINVAL;
509	break;
510	}
511	}
512	delete pTokens;
513	}
514	if (bMissingParam) {
515	HLTError("missing parameter for argument %s", argument.Data());
516	iResult=-EINVAL;
517	}
518	return iResult;
519	}
520
c3cda394	521	int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
	522	{
	523	// see header file for class documentation
3f0fd8f1	524	const char* path="HLT/ConfigTPC/ClusterFinderComponent";
c3cda394	525	if (cdbEntry) path=cdbEntry;
	526	if (path) {
	527	HLTInfo("reconfigure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
	528	AliCDBEntry pEntry = AliCDBManager::Instance()->Get(path/,GetRunNo()*/);
	529	if (pEntry) {
	530	TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
	531	if (pString) {
	532	HLTInfo("received configuration object: %s", pString->GetString().Data());
	533	} else {
	534	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
	535	}
	536	} else {
	537	HLTError("can not fetch object \"%s\" from CDB", path);
	538	}
	539	}
b0914d2e	540	return 0;
c3cda394	541	}