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

// $Id: AliHLTTPCHWClusterDecoderComponent.cxx 59611 2012-11-15 16:23:28Z sgorbuno $

//***************************************************************************
//* This file is property of and copyright by the ALICE HLT Project         *
//* ALICE Experiment at CERN, All rights reserved.                          *
//*                                                                         *
//* Primary Authors: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de *
//*                  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   AliHLTTPCHWClusterDecoderComponent.cxx
    @author Sergey Gorbunov
    @date   
    @brief 
*/

#include "AliHLTTPCHWClusterDecoderComponent.h"
#include "AliHLTTPCHWClusterMergerV1.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTCDHWrapper.h"
#include "AliHLTTPCRawCluster.h"
#include "AliHLTTPCHWCFEmulator.h"
#include "AliHLTTPCHWCFData.h"
#include "AliHLTErrorGuard.h"
#include "AliHLTTPCRawClustersDescriptor.h"

#include "AliCDBManager.h"
#include "AliCDBEntry.h"

#include "TMath.h"
#include "TObjString.h" 
#include <cstdlib>
#include <cerrno>
#include <sys/time.h>

using namespace std;

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

const char* AliHLTTPCHWClusterDecoderComponent::fgkOCDBEntry="HLT/ConfigTPC/TPCHWClusterDecoder";


AliHLTTPCHWClusterDecoderComponent::AliHLTTPCHWClusterDecoderComponent()
:
fpDecoder(NULL),
fpClusterMerger(NULL),
fDoMerge(1),
fBenchmark("HWClusterDecoder")
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt  

  fBenchmark.Reset();
  fBenchmark.SetTimer(0,"total");
}

AliHLTTPCHWClusterDecoderComponent::~AliHLTTPCHWClusterDecoderComponent()
{ 
  // destructor
  delete fpDecoder;
  delete fpClusterMerger;
}

const char* AliHLTTPCHWClusterDecoderComponent::GetComponentID() 
{ 
  // see header file for class documentation
  return "TPCHWClusterDecoder";
}


void AliHLTTPCHWClusterDecoderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) { 
  // see header file for class documentation

  list.clear(); 
  list.push_back( AliHLTTPCDefinitions::fgkHWClustersDataType | kAliHLTDataOriginTPC  );
  list.push_back( AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC );
}

AliHLTComponentDataType AliHLTTPCHWClusterDecoderComponent::GetOutputDataType() { 
  // see header file for class documentation

  return kAliHLTMultipleDataType;
}

int AliHLTTPCHWClusterDecoderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) { 
  // see header file for class documentation

  tgtList.clear();
  tgtList.push_back( AliHLTTPCDefinitions::fgkRawClustersDataType  | kAliHLTDataOriginTPC );
  tgtList.push_back( AliHLTTPCDefinitions::RawClustersDescriptorDataType() );
  tgtList.push_back( AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC );
  return tgtList.size();
}

void AliHLTTPCHWClusterDecoderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) { 
  // see header file for class documentation
  constBase = 0;
  inputMultiplier = 2.0;
}

AliHLTComponent* AliHLTTPCHWClusterDecoderComponent::Spawn() { 
  // see header file for class documentation

  return new AliHLTTPCHWClusterDecoderComponent();
}
	
int AliHLTTPCHWClusterDecoderComponent::DoInit( int argc, const char** argv ) 
{ 
  // see header file for class documentation
  
  int iResult=0;

  fpDecoder=new AliHLTTPCHWCFData;
  if (!fpDecoder) iResult=-ENOMEM;
  
  fDoMerge = 1;

  //!! if (iResult>=0) iResult = ConfigureFromCDBTObjString(fgkOCDBEntry);

  if (iResult>=0 && argc>0) iResult = ConfigureFromArgumentString(argc, argv);

  if ( iResult>=0 ) iResult = InitClusterMerger();  
  
  return iResult;
} // end DoInit()

int AliHLTTPCHWClusterDecoderComponent::DoDeinit() { 
  // see header file for class documentation   
  if (!fpDecoder) delete fpDecoder;
  fpDecoder=NULL;
  delete fpClusterMerger;
  fpClusterMerger = NULL;
  return 0;
}

int AliHLTTPCHWClusterDecoderComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) { 
  // see header file for class documentation

  fDoMerge = 1;
  int iResult = 0;
  //!! iResult = ConfigureFromCDBTObjString(fgkOCDBEntry);
  if ( iResult>=0 ) iResult = InitClusterMerger();  
  return iResult;
}

int AliHLTTPCHWClusterDecoderComponent::ScanConfigurationArgument(int argc, const char** argv){

  // see header file for class documentation

  if (argc<=0) return 0;
  int i=0;
  TString argument=argv[i];

  if (argument.CompareTo("-do-merge")==0){
    fDoMerge = 1;
    return 1;
  }

  if (argument.CompareTo("-do-not-merge")==0){
    fDoMerge = 0;
    return 1;
  }

  // unknown argument
  return -EINVAL;
}

int AliHLTTPCHWClusterDecoderComponent::InitClusterMerger()
{
  //
  // init merger
  //
  int iResult = 0;
  if ( fDoMerge && !fpClusterMerger) {
    fpClusterMerger = new AliHLTTPCHWClusterMergerV1;
    if( !fpClusterMerger ) iResult=-ENOMEM;
    else iResult = fpClusterMerger->Init();
    if( iResult<0 ){
      HLTError("Can not initialise cluster merger");
      delete fpClusterMerger;
      fpClusterMerger = 0;
    }
  }
  return iResult;
}

void AliHLTTPCHWClusterDecoderComponent::GetOCDBObjectDescription( TMap* const targetMap)
{
  // Get a list of OCDB object description needed for the particular component
  if (!targetMap) return;
  
  // OCDB entries for component arguments

  //!! targetMap->Add(new TObjString(fgkOCDBEntry), new TObjString("component argument for HW cluster decoder"));  
}


int AliHLTTPCHWClusterDecoderComponent::DoEvent(const AliHLTComponentEventData& evtData, 
					          const AliHLTComponentBlockData* blocks, 
					          AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
					          AliHLTUInt32_t& size, 
					          vector<AliHLTComponentBlockData>& outputBlocks ){
  // see header file for class documentation
 
  UInt_t maxOutSize = size;
  size = 0;
  int iResult = 0;
  if(!IsDataEvent()) return 0;

  if (!fpDecoder) return -ENODEV;

  fBenchmark.StartNewEvent();
  fBenchmark.Start(0);
  
  AliHLTUInt8_t* origOutputPtr = outputPtr;
  UInt_t origOutputBlocksSize = outputBlocks.size();

  bool isInputPresent = kFALSE;

  for( unsigned long ndx=0; ndx<evtData.fBlockCnt; ndx++ ){
     
    const AliHLTComponentBlockData *iter   = blocks+ndx;
    
    fBenchmark.AddInput(iter->fSize);
    
    HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	     evtData.fEventID, evtData.fEventID, 
	     DataType2Text( iter->fDataType).c_str(), 
	     DataType2Text(AliHLTTPCDefinitions::fgkHWClustersDataType).c_str());                       
 
    if(iter->fDataType == (AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC) ){
      // simply forward MC labels
      
      if( size+iter->fSize > maxOutSize ){
	HLTWarning( "Output buffer (%db) is too small, required %db", maxOutSize, size+iter->fSize);
	iResult  = -ENOSPC;
	break;
      }

      memcpy( outputPtr, iter->fPtr, iter->fSize );
      
      AliHLTComponentBlockData bd;
      FillBlockData( bd );
      bd.fOffset = size;
      bd.fSize = iter->fSize;      
      bd.fSpecification = iter->fSpecification;     
      bd.fDataType = iter->fDataType;
      outputBlocks.push_back( bd );           
      size   += bd.fSize;
      outputPtr += bd.fSize;
      fBenchmark.AddOutput(bd.fSize);    
      continue;
    }

    if( iter->fDataType == (AliHLTTPCDefinitions::fgkHWClustersDataType | kAliHLTDataOriginTPC) ){

      isInputPresent = 1;

      HLTDebug("minSlice: %d, minPartition: %d", AliHLTTPCDefinitions::GetMinSliceNr(*iter), AliHLTTPCDefinitions::GetMinPatchNr(*iter));     
      
      long maxRawClusters = ((long)maxOutSize-size-sizeof(AliHLTTPCRawClusterData))/sizeof(AliHLTTPCRawCluster);
       
      if( maxRawClusters<=0 ) {
	HLTWarning("No more space to add raw clusters, exiting!");
	iResult  = -ENOSPC;
	continue;
      }       

      // copy raw cluster data from input
	 
      AliHLTTPCRawClusterData* outputRaw= (AliHLTTPCRawClusterData*)(outputPtr);
       
      outputRaw->fVersion = 0;
      outputRaw->fCount = 0;
      
      AliHLTUInt32_t *buffer = (AliHLTUInt32_t*)iter->fPtr;
      AliHLTCDHWrapper header(buffer);
     
      // skip the first 8 32-bit CDH words
      buffer += header.GetHeaderSize()/sizeof(AliHLTUInt32_t);
      UInt_t bufferSize32 = ((Int_t)iter->fSize - header.GetHeaderSize() )/sizeof(AliHLTUInt32_t);
      
      if (fpDecoder->Init(reinterpret_cast<AliHLTUInt8_t*>(buffer), bufferSize32*sizeof(AliHLTUInt32_t))>=0 && fpDecoder->CheckVersion()>=0) {
	
	for (AliHLTTPCHWCFData::iterator cl=fpDecoder->begin(); cl!=fpDecoder->end(); ++cl) {
	     
	  if(outputRaw->fCount>=maxRawClusters){
	    HLTWarning("No more space to add clusters, exiting!");
	    iResult  = -ENOSPC;
	    break;
	  }
	  AliHLTTPCRawCluster &c = outputRaw->fClusters[outputRaw->fCount];	  
	  c.SetPadRow(cl.GetPadRow());
	  c.SetCharge(cl.GetCharge());
	  c.SetPad(cl.GetPad());  
	  c.SetTime(cl.GetTime());
	  c.SetSigmaY2(cl.GetSigmaY2());
	  c.SetSigmaZ2(cl.GetSigmaZ2());
	  c.SetQMax(cl.GetQMax());	  
	  outputRaw->fCount++;
	}	
      }
      // fill into HLT output data
      AliHLTComponentBlockData bdRawClusters;
      FillBlockData( bdRawClusters );
      bdRawClusters.fOffset = size;	
      bdRawClusters.fSize = sizeof(AliHLTTPCRawClusterData)+outputRaw->fCount*sizeof(AliHLTTPCRawCluster);
      bdRawClusters.fSpecification = iter->fSpecification;
      bdRawClusters.fDataType = AliHLTTPCDefinitions::fgkRawClustersDataType | kAliHLTDataOriginTPC;
      outputBlocks.push_back( bdRawClusters );
      fBenchmark.AddOutput(bdRawClusters.fSize);
      size   += bdRawClusters.fSize;
      outputPtr += bdRawClusters.fSize;
    }

  } // end of loop over data blocks  

  AliHLTTPCRawClustersDescriptor desc; 
  desc.SetMergedClustersFlag(0);

  if( fDoMerge && fpClusterMerger ){
    fpClusterMerger->Clear();
    fpClusterMerger->SetDataPointer(origOutputPtr);
    for( UInt_t i=origOutputBlocksSize; i<outputBlocks.size(); i++){
      fpClusterMerger->SetDataBlock(&(outputBlocks[i]));
    }
    int nMerged = fpClusterMerger->Merge();
    fpClusterMerger->Clear();
    desc.SetMergedClustersFlag(1);
    HLTInfo("Merged %d clusters",nMerged);   
  }

  // Write header block 
  if( isInputPresent ){
    AliHLTComponent_BlockData bd;
    FillBlockData(bd);
    bd.fOffset        = size;
    bd.fSize          = sizeof(AliHLTTPCRawClustersDescriptor);
    bd.fDataType      = AliHLTTPCDefinitions::RawClustersDescriptorDataType();
    if( maxOutSize < size + bd.fSize ){
	HLTWarning( "Output buffer (%db) is too small, required %db", maxOutSize, size+bd.fSize);
	iResult  = -ENOSPC;
	return iResult;
    }    
    *(AliHLTTPCRawClustersDescriptor*)(outputPtr ) = desc;
    outputBlocks.push_back(bd);
    size += bd.fSize;
    outputPtr += bd.fSize;
    fBenchmark.AddOutput(bd.fSize);    
    HLTBenchmark("header data block of size %d", bd.fSize);
  }
  fBenchmark.Stop(0);
  HLTInfo(fBenchmark.GetStatistics());
  
  return iResult;
} // end DoEvent()


void AliHLTTPCHWClusterDecoderComponent::PrintDebug(AliHLTUInt32_t *buffer, Int_t size){
// see header file for class documentation 

  HLTInfo("The size is: %d", size);
  for(Int_t n32bit=0; n32bit<size; n32bit++){
    
    AliHLTUInt8_t *wordPtr = reinterpret_cast<AliHLTUInt8_t*>(&buffer[n32bit]);
    //    cout << "word ptr initialized"<<endl;
    for(Int_t w=3;w>=0;w--){
      //     cout <<"accessing word"<<endl;
      AliHLTUInt8_t word = wordPtr[w];
      //     cout<< "word was accessed"<<endl; 
      for(int n=7; n>=0; n--){
	//print the byte values
	if((((word>>n)<<7)&0x80) != 0){
	  printf("1");
	}
	else{
	  printf("0");
	}
      }
      printf("  ");
    }
    printf("\n");
  }
} // end of PrintDebug
Commit	Line	Data
ca761b13	1	// $Id: AliHLTTPCHWClusterDecoderComponent.cxx 59611 2012-11-15 16:23:28Z sgorbuno $
	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: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de *
	8	//* for The ALICE HLT Project. *
	9	//* *
	10	//* Permission to use, copy, modify and distribute this software and its *
	11	//* documentation strictly for non-commercial purposes is hereby granted *
	12	//* without fee, provided that the above copyright notice appears in all *
	13	//* copies and that both the copyright notice and this permission notice *
	14	//* appear in the supporting documentation. The authors make no claims *
	15	//* about the suitability of this software for any purpose. It is *
	16	//* provided "as is" without express or implied warranty. *
	17	//***************************************************************************
	18
	19
	20	/** @file AliHLTTPCHWClusterDecoderComponent.cxx
	21	@author Sergey Gorbunov
	22	@date
	23	@brief
	24	*/
	25
	26	#include "AliHLTTPCHWClusterDecoderComponent.h"
	27	#include "AliHLTTPCHWClusterMergerV1.h"
	28	#include "AliHLTTPCTransform.h"
	29	#include "AliHLTTPCDefinitions.h"
	30	#include "AliHLTTPCSpacePointData.h"
	31	#include "AliHLTTPCClusterDataFormat.h"
16e6f752	32	#include "AliHLTCDHWrapper.h"
ca761b13	33	#include "AliHLTTPCRawCluster.h"
	34	#include "AliHLTTPCHWCFEmulator.h"
	35	#include "AliHLTTPCHWCFData.h"
	36	#include "AliHLTErrorGuard.h"
3ba734d3	37	#include "AliHLTTPCRawClustersDescriptor.h"
ca761b13	38
	39	#include "AliCDBManager.h"
	40	#include "AliCDBEntry.h"
	41
	42	#include "TMath.h"
	43	#include "TObjString.h"
	44	#include <cstdlib>
	45	#include <cerrno>
	46	#include <sys/time.h>
	47
	48	using namespace std;
	49
	50	ClassImp(AliHLTTPCHWClusterDecoderComponent) //ROOT macro for the implementation of ROOT specific class methods
	51
	52	const char* AliHLTTPCHWClusterDecoderComponent::fgkOCDBEntry="HLT/ConfigTPC/TPCHWClusterDecoder";
	53
	54
	55	AliHLTTPCHWClusterDecoderComponent::AliHLTTPCHWClusterDecoderComponent()
	56	:
	57	fpDecoder(NULL),
	58	fpClusterMerger(NULL),
	59	fDoMerge(1),
	60	fBenchmark("HWClusterDecoder")
	61	{
	62	// see header file for class documentation
	63	// or
	64	// refer to README to build package
	65	// or
	66	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	67
	68	fBenchmark.Reset();
	69	fBenchmark.SetTimer(0,"total");
	70	}
	71
	72	AliHLTTPCHWClusterDecoderComponent::~AliHLTTPCHWClusterDecoderComponent()
	73	{
	74	// destructor
	75	delete fpDecoder;
	76	delete fpClusterMerger;
	77	}
	78
	79	const char* AliHLTTPCHWClusterDecoderComponent::GetComponentID()
	80	{
	81	// see header file for class documentation
	82	return "TPCHWClusterDecoder";
	83	}
	84
	85
	86
	87	void AliHLTTPCHWClusterDecoderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
	88	// see header file for class documentation
	89
	90	list.clear();
	91	list.push_back( AliHLTTPCDefinitions::fgkHWClustersDataType \| kAliHLTDataOriginTPC );
	92	list.push_back( AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo \| kAliHLTDataOriginTPC );
	93	}
	94
	95	AliHLTComponentDataType AliHLTTPCHWClusterDecoderComponent::GetOutputDataType() {
	96	// see header file for class documentation
	97
	98	return kAliHLTMultipleDataType;
	99	}
	100
	101	int AliHLTTPCHWClusterDecoderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) {
102	// see header file for class documentation
103
104	tgtList.clear();
105	tgtList.push_back( AliHLTTPCDefinitions::fgkRawClustersDataType \| kAliHLTDataOriginTPC );
3ba734d3	106	tgtList.push_back( AliHLTTPCDefinitions::RawClustersDescriptorDataType() );
ca761b13	107	tgtList.push_back( AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo \| kAliHLTDataOriginTPC );
	108	return tgtList.size();
	109	}
	110
	111	void AliHLTTPCHWClusterDecoderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
	112	// see header file for class documentation
	113	constBase = 0;
	114	inputMultiplier = 2.0;
	115	}
	116
	117	AliHLTComponent* AliHLTTPCHWClusterDecoderComponent::Spawn() {
	118	// see header file for class documentation
	119
	120	return new AliHLTTPCHWClusterDecoderComponent();
	121	}
	122
	123	int AliHLTTPCHWClusterDecoderComponent::DoInit( int argc, const char** argv )
	124	{
	125	// see header file for class documentation
	126
	127	int iResult=0;
	128
	129	fpDecoder=new AliHLTTPCHWCFData;
	130	if (!fpDecoder) iResult=-ENOMEM;
	131
	132	fDoMerge = 1;
	133
e43f6920	134	//!! if (iResult>=0) iResult = ConfigureFromCDBTObjString(fgkOCDBEntry);
ca761b13	135
	136	if (iResult>=0 && argc>0) iResult = ConfigureFromArgumentString(argc, argv);
	137
	138	if ( iResult>=0 ) iResult = InitClusterMerger();
	139
	140	return iResult;
	141	} // end DoInit()
	142
	143	int AliHLTTPCHWClusterDecoderComponent::DoDeinit() {
	144	// see header file for class documentation
	145	if (!fpDecoder) delete fpDecoder;
	146	fpDecoder=NULL;
	147	delete fpClusterMerger;
	148	fpClusterMerger = NULL;
	149	return 0;
	150	}
	151
	152	int AliHLTTPCHWClusterDecoderComponent::Reconfigure(const char* /cdbEntry/, const char* /chainId/) {
	153	// see header file for class documentation
	154
	155	fDoMerge = 1;
e43f6920	156	int iResult = 0;
e43f6920	157	//!! iResult = ConfigureFromCDBTObjString(fgkOCDBEntry);
ca761b13	158	if ( iResult>=0 ) iResult = InitClusterMerger();
	159	return iResult;
	160	}
	161
	162	int AliHLTTPCHWClusterDecoderComponent::ScanConfigurationArgument(int argc, const char** argv){
	163
	164	// see header file for class documentation
	165
	166	if (argc<=0) return 0;
	167	int i=0;
	168	TString argument=argv[i];
	169
	170	if (argument.CompareTo("-do-merge")==0){
	171	fDoMerge = 1;
	172	return 1;
	173	}
	174
	175	if (argument.CompareTo("-do-not-merge")==0){
	176	fDoMerge = 0;
	177	return 1;
	178	}
	179
	180	// unknown argument
	181	return -EINVAL;
	182	}
	183
	184	int AliHLTTPCHWClusterDecoderComponent::InitClusterMerger()
	185	{
	186	//
	187	// init merger
	188	//
	189	int iResult = 0;
	190	if ( fDoMerge && !fpClusterMerger) {
	191	fpClusterMerger = new AliHLTTPCHWClusterMergerV1;
	192	if( !fpClusterMerger ) iResult=-ENOMEM;
	193	else iResult = fpClusterMerger->Init();
	194	if( iResult<0 ){
	195	HLTError("Can not initialise cluster merger");
	196	delete fpClusterMerger;
	197	fpClusterMerger = 0;
	198	}
	199	}
	200	return iResult;
	201	}
	202
	203	void AliHLTTPCHWClusterDecoderComponent::GetOCDBObjectDescription( TMap* const targetMap)
	204	{
	205	// Get a list of OCDB object description needed for the particular component
	206	if (!targetMap) return;
	207
	208	// OCDB entries for component arguments
	209
e43f6920	210	//!! targetMap->Add(new TObjString(fgkOCDBEntry), new TObjString("component argument for HW cluster decoder"));
ca761b13	211	}
	212
	213
	214	int AliHLTTPCHWClusterDecoderComponent::DoEvent(const AliHLTComponentEventData& evtData,
	215	const AliHLTComponentBlockData* blocks,
	216	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
	217	AliHLTUInt32_t& size,
	218	vector<AliHLTComponentBlockData>& outputBlocks ){
	219	// see header file for class documentation
	220
	221	UInt_t maxOutSize = size;
	222	size = 0;
	223	int iResult = 0;
	224	if(!IsDataEvent()) return 0;
	225
	226	if (!fpDecoder) return -ENODEV;
	227
	228	fBenchmark.StartNewEvent();
	229	fBenchmark.Start(0);
	230
e43f6920	231	AliHLTUInt8_t* origOutputPtr = outputPtr;
e43f6920	232	UInt_t origOutputBlocksSize = outputBlocks.size();
ca761b13	233
3ba734d3	234	bool isInputPresent = kFALSE;
3ba734d3	235
ca761b13	236	for( unsigned long ndx=0; ndx<evtData.fBlockCnt; ndx++ ){
	237
	238	const AliHLTComponentBlockData *iter = blocks+ndx;
	239
	240	fBenchmark.AddInput(iter->fSize);
	241
	242	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	243	evtData.fEventID, evtData.fEventID,
	244	DataType2Text( iter->fDataType).c_str(),
	245	DataType2Text(AliHLTTPCDefinitions::fgkHWClustersDataType).c_str());
	246
	247	if(iter->fDataType == (AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo \| kAliHLTDataOriginTPC) ){
	248	// simply forward MC labels
	249
	250	if( size+iter->fSize > maxOutSize ){
	251	HLTWarning( "Output buffer (%db) is too small, required %db", maxOutSize, size+iter->fSize);
	252	iResult = -ENOSPC;
	253	break;
	254	}
	255
	256	memcpy( outputPtr, iter->fPtr, iter->fSize );
	257
	258	AliHLTComponentBlockData bd;
	259	FillBlockData( bd );
	260	bd.fOffset = size;
e43f6920	261	bd.fSize = iter->fSize;
ca761b13	262	bd.fSpecification = iter->fSpecification;
	263	bd.fDataType = iter->fDataType;
	264	outputBlocks.push_back( bd );
	265	size += bd.fSize;
	266	outputPtr += bd.fSize;
	267	fBenchmark.AddOutput(bd.fSize);
	268	continue;
	269	}
	270
	271	if( iter->fDataType == (AliHLTTPCDefinitions::fgkHWClustersDataType \| kAliHLTDataOriginTPC) ){
3ba734d3	272
	273	isInputPresent = 1;
	274
	275	HLTDebug("minSlice: %d, minPartition: %d", AliHLTTPCDefinitions::GetMinSliceNr(iter), AliHLTTPCDefinitions::GetMinPatchNr(iter));
ca761b13	276
	277	long maxRawClusters = ((long)maxOutSize-size-sizeof(AliHLTTPCRawClusterData))/sizeof(AliHLTTPCRawCluster);
	278
	279	if( maxRawClusters<=0 ) {
	280	HLTWarning("No more space to add raw clusters, exiting!");
	281	iResult = -ENOSPC;
	282	continue;
	283	}
	284
	285	// copy raw cluster data from input
	286
	287	AliHLTTPCRawClusterData* outputRaw= (AliHLTTPCRawClusterData*)(outputPtr);
	288
	289	outputRaw->fVersion = 0;
	290	outputRaw->fCount = 0;
	291
16e6f752	292	AliHLTUInt32_t buffer = (AliHLTUInt32_t)iter->fPtr;
16e6f752	293	AliHLTCDHWrapper header(buffer);
ca761b13	294
ca761b13	295	// skip the first 8 32-bit CDH words
16e6f752	296	buffer += header.GetHeaderSize()/sizeof(AliHLTUInt32_t);
16e6f752	297	UInt_t bufferSize32 = ((Int_t)iter->fSize - header.GetHeaderSize() )/sizeof(AliHLTUInt32_t);
ca761b13	298
	299	if (fpDecoder->Init(reinterpret_cast<AliHLTUInt8_t>(buffer), bufferSize32sizeof(AliHLTUInt32_t))>=0 && fpDecoder->CheckVersion()>=0) {
	300
	301	for (AliHLTTPCHWCFData::iterator cl=fpDecoder->begin(); cl!=fpDecoder->end(); ++cl) {
	302
	303	if(outputRaw->fCount>=maxRawClusters){
	304	HLTWarning("No more space to add clusters, exiting!");
	305	iResult = -ENOSPC;
	306	break;
	307	}
	308	AliHLTTPCRawCluster &c = outputRaw->fClusters[outputRaw->fCount];
	309	c.SetPadRow(cl.GetPadRow());
	310	c.SetCharge(cl.GetCharge());
	311	c.SetPad(cl.GetPad());
	312	c.SetTime(cl.GetTime());
	313	c.SetSigmaY2(cl.GetSigmaY2());
	314	c.SetSigmaZ2(cl.GetSigmaZ2());
	315	c.SetQMax(cl.GetQMax());
	316	outputRaw->fCount++;
	317	}
639db614	318	}
	319	// fill into HLT output data
	320	AliHLTComponentBlockData bdRawClusters;
	321	FillBlockData( bdRawClusters );
	322	bdRawClusters.fOffset = size;
	323	bdRawClusters.fSize = sizeof(AliHLTTPCRawClusterData)+outputRaw->fCount*sizeof(AliHLTTPCRawCluster);
	324	bdRawClusters.fSpecification = iter->fSpecification;
	325	bdRawClusters.fDataType = AliHLTTPCDefinitions::fgkRawClustersDataType \| kAliHLTDataOriginTPC;
	326	outputBlocks.push_back( bdRawClusters );
	327	fBenchmark.AddOutput(bdRawClusters.fSize);
	328	size += bdRawClusters.fSize;
	329	outputPtr += bdRawClusters.fSize;
ca761b13	330	}
	331
	332	} // end of loop over data blocks
	333
3ba734d3	334	AliHLTTPCRawClustersDescriptor desc;
	335	desc.SetMergedClustersFlag(0);
	336
ca761b13	337	if( fDoMerge && fpClusterMerger ){
ca761b13	338	fpClusterMerger->Clear();
e43f6920	339	fpClusterMerger->SetDataPointer(origOutputPtr);
e43f6920	340	for( UInt_t i=origOutputBlocksSize; i<outputBlocks.size(); i++){
ca761b13	341	fpClusterMerger->SetDataBlock(&(outputBlocks[i]));
	342	}
	343	int nMerged = fpClusterMerger->Merge();
	344	fpClusterMerger->Clear();
3ba734d3	345	desc.SetMergedClustersFlag(1);
ca761b13	346	HLTInfo("Merged %d clusters",nMerged);
ca761b13	347	}
3ba734d3	348
	349	// Write header block
	350	if( isInputPresent ){
	351	AliHLTComponent_BlockData bd;
	352	FillBlockData(bd);
	353	bd.fOffset = size;
	354	bd.fSize = sizeof(AliHLTTPCRawClustersDescriptor);
	355	bd.fDataType = AliHLTTPCDefinitions::RawClustersDescriptorDataType();
	356	if( maxOutSize < size + bd.fSize ){
	357	HLTWarning( "Output buffer (%db) is too small, required %db", maxOutSize, size+bd.fSize);
	358	iResult = -ENOSPC;
	359	return iResult;
	360	}
	361	(AliHLTTPCRawClustersDescriptor)(outputPtr ) = desc;
	362	outputBlocks.push_back(bd);
	363	size += bd.fSize;
	364	outputPtr += bd.fSize;
	365	fBenchmark.AddOutput(bd.fSize);
	366	HLTBenchmark("header data block of size %d", bd.fSize);
	367	}
ca761b13	368	fBenchmark.Stop(0);
	369	HLTInfo(fBenchmark.GetStatistics());
	370
	371	return iResult;
	372	} // end DoEvent()
	373
	374
	375
	376	void AliHLTTPCHWClusterDecoderComponent::PrintDebug(AliHLTUInt32_t *buffer, Int_t size){
	377	// see header file for class documentation
	378
	379	HLTInfo("The size is: %d", size);
	380	for(Int_t n32bit=0; n32bit<size; n32bit++){
	381
	382	AliHLTUInt8_t wordPtr = reinterpret_cast<AliHLTUInt8_t>(&buffer[n32bit]);
	383	// cout << "word ptr initialized"<<endl;
	384	for(Int_t w=3;w>=0;w--){
	385	// cout <<"accessing word"<<endl;
	386	AliHLTUInt8_t word = wordPtr[w];
	387	// cout<< "word was accessed"<<endl;
	388	for(int n=7; n>=0; n--){
	389	//print the byte values
	390	if((((word>>n)<<7)&0x80) != 0){
	391	printf("1");
	392	}
	393	else{
	394	printf("0");
	395	}
	396	}
	397	printf(" ");
	398	}
	399	printf("\n");
	400	}
	401	} // end of PrintDebug
	402