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

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: 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   AliHLTTPCZeroSuppressionComponent.cxx
    @author Kenneth Aamodt
    @date   
    @brief  The TPC ZeroSuppression component
*/

// 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 __GNUC__>= 3
using namespace std;
#endif
#include "AliHLTTPCZeroSuppressionComponent.h"
#include "AliHLTTPCDigitReaderDecoder.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTTPCDigitData.h"
#include <cstdlib>
#include <cerrno>
#include "TString.h"
#include <sys/time.h>
#include "AliHLTAltroEncoder.h"
#include "AliRawDataHeader.h"

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

AliHLTTPCZeroSuppressionComponent::AliHLTTPCZeroSuppressionComponent()
    :
    fDigitReader(NULL),
    fRowPadVector(),
    fNumberOfPadsInRow(NULL),
    fNumberOfRows(0),
    fCurrentPatch(0),
    fFirstRow(0),
    fLastRow(0),
    fStartTimeBin(0),
    fEndTimeBin(AliHLTTPCTransform::GetNTimeBins()),
    fNTimeBins(0),
    fNRMSThreshold(0),
    fSignalThreshold(0),
    fMinimumNumberOfSignals(AliHLTTPCTransform::GetNTimeBins()/2),
    fOldRCUFormat(0),
    fSortPads(0),
    fVectorInitialized(kFALSE),
    fValueBelowAverage(5),
    fLeftTimeBin(5),
    fRightTimeBin(5),
    fGetActivePads(kFALSE),
    fHwAddressList()
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTTPCZeroSuppressionComponent::~AliHLTTPCZeroSuppressionComponent()
{
  // see header file for class documentation
  if(fVectorInitialized){
    DeInitializePadArray();
  }
  if(fNumberOfPadsInRow){
    delete [] fNumberOfPadsInRow;
    fNumberOfPadsInRow=NULL;
  }
  if(fDigitReader){
    delete fDigitReader;
    fDigitReader=NULL;
  }
}

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

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

void AliHLTTPCZeroSuppressionComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
  // see header file for class documentation
  list.clear(); 
  list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
}

AliHLTComponentDataType AliHLTTPCZeroSuppressionComponent::GetOutputDataType()
{
  // see header file for class documentation
  return kAliHLTMultipleDataType;
  //return kAliHLTDataTypeDDLRaw;
  //  return AliHLTTPCDefinitions::fgkUnpackedRawDataType;
}

int AliHLTTPCZeroSuppressionComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
{
  // see header file for class documentation
  tgtList.clear();
  tgtList.push_back(kAliHLTDataTypeDDLRaw);
  tgtList.push_back(kAliHLTDataTypeHwAddr16);
  return tgtList.size();
}

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

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

  Int_t i = 0;
  Char_t* cpErr;

  while ( i < argc ) {      

    // -- zero suppression threshold
    if ( !strcmp( argv[i], "signal-threshold" ) ) {
      fSignalThreshold = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ) {
	HLTError("Cannot convert signal-threshold specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- checking for nsigma-threshold, used in 2007 December run in ZeroSuppression
    if ( !strcmp( argv[i], "rms-threshold" ) ) {
      fNRMSThreshold = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ){
	HLTError("Cannot convert rms-threshold specifier '%s'. Must be integer", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- number of timebins
    if ( !strcmp( argv[i], "ntimebins" ) ) {
      fNTimeBins = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ) {
	HLTError("Cannot convert ntimebins specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- first timebin
    if ( !strcmp( argv[i], "start-timebin" ) ) {
      fStartTimeBin = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ) {
	HLTError("Cannot convert start-timebin specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- last timebin
    if ( !strcmp( argv[i], "end-timebin" ) ) {
      if(strtoul( argv[i+1], &cpErr ,0)<=(UInt_t)AliHLTTPCTransform::GetNTimeBins()){
	fEndTimeBin = strtoul( argv[i+1], &cpErr ,0);
      }
      if ( *cpErr ) {
	HLTError("Cannot convert end-timebin specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- timebins to keep left of signal
    if ( !strcmp( argv[i], "timebin-left" ) ) {
      fLeftTimeBin = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ) {
	HLTError("Cannot convert timebin-left specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- timebin to keep right of signal
    if ( !strcmp( argv[i], "timebin-right" ) ) {
      fRightTimeBin = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ) {
	HLTError("Cannot convert timebin-right specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- value below average to subtract
    if ( !strcmp( argv[i], "value-below-average" ) ) {
      fValueBelowAverage = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ) {
	HLTError("Cannot convert value-below-average specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- pad occupancy limit
    if ( !strcmp( argv[i], "occupancy-limit" ) ) {
      fMinimumNumberOfSignals = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ) {
	HLTError("Cannot convert occupancy-limit specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- checking for rcu format
    if ( !strcmp( argv[i], "oldrcuformat" ) ) {
      fOldRCUFormat = 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;
      }
      i+=2;
      continue;
    }

    // -- checking for rcu format
    if ( !strcmp( argv[i], "sort-pads" ) ) {
      fSortPads = strtoul( argv[i+1], &cpErr ,0);
      if ( *cpErr ){
	HLTError("Cannot convert sort-pads specifier '%s'. Should  be 0(off) or 1(on), must be integer", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }
      
    Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
    return EINVAL;

  }

  HLTDebug("using AliHLTTPCDigitReaderDecoder");
  fDigitReader = new AliHLTTPCDigitReaderDecoder();

  fHwAddressList.clear();

  return 0;
}

int AliHLTTPCZeroSuppressionComponent::DoDeinit()
{
  // see header file for class documentation
  return 0;
}

Int_t AliHLTTPCZeroSuppressionComponent::DeInitializePadArray()
{
  // see header file for class documentation
  if(fVectorInitialized){
    for(Int_t i=0;i<fNumberOfRows;i++){
      for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
	delete fRowPadVector[i][j];
	fRowPadVector[i][j]=NULL;
      }
      fRowPadVector[i].clear();
    }
    fRowPadVector.clear();
  }
  return 1;
} 

void AliHLTTPCZeroSuppressionComponent::InitializePadArray(){
  // see header file for class documentation
  if(fCurrentPatch>5){
    HLTFatal("Patch is not set");
    return;
  }

  fFirstRow = AliHLTTPCTransform::GetFirstRow(fCurrentPatch);
  fLastRow = AliHLTTPCTransform::GetLastRow(fCurrentPatch);

  fNumberOfRows=fLastRow-fFirstRow+1;
  fNumberOfPadsInRow= new Int_t[fNumberOfRows];

  memset( fNumberOfPadsInRow, 0, sizeof(Int_t)*(fNumberOfRows));

  for(Int_t i=0;i<fNumberOfRows;i++){
    fNumberOfPadsInRow[i]=AliHLTTPCTransform::GetNPads(i+fFirstRow);
    AliHLTTPCPadVector tmpRow;
    for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
      AliHLTTPCPad *tmpPad = new AliHLTTPCPad();
      tmpPad->SetID(i,j);
      tmpRow.push_back(tmpPad);
    }
    fRowPadVector.push_back(tmpRow);
  }
  fVectorInitialized=kTRUE;
}


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

  //  HLTInfo("Entered DoEvent in AliHLTTPCZeroSuppressionComponent");

  //  == init iter (pointer to datablock)
  const AliHLTComponentBlockData* iter = NULL;
  unsigned long ndx;
  //  HLTInfo("Number of blocks: ",evtData.fBlockCnt);

  Bool_t wasInput = 0;

  fHwAddressList.clear();
  //reading the data
  for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
    {
      iter = blocks+ndx;
      
      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;
      }

      wasInput = 1;

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

      if(!fVectorInitialized){
	fCurrentPatch=patch;
	InitializePadArray();
      }
      
      fDigitReader->InitBlock(iter->fPtr,iter->fSize,patch,slice);

      //Here the reading of the data and the zerosuppression takes place
      while(fDigitReader->NextChannel()){//Pad
	Int_t row=fDigitReader->GetRow();
	Int_t pad=fDigitReader->GetPad();
	if(row==1000 || pad==1000){
	  continue;
	}
	if(row>=fNumberOfRows||row<0){
	  continue;
	}
	else if(pad>=fNumberOfPadsInRow[row]||pad<0){
	    continue;
	}  
	
	AliHLTTPCPad *tmpPad = fRowPadVector[row][pad];
	tmpPad->SetDataToDefault();
	
	//reading data to pad
	while(fDigitReader->NextBunch()){
	  const UInt_t *bunchData= fDigitReader->GetSignals();
	  Int_t time=fDigitReader->GetTime();
	  for(Int_t i=0;i<fDigitReader->GetBunchSize();i++){
	    if(bunchData[i]>0){// disregarding 0 data.
	      if(time+i>=fStartTimeBin && time+i<=fEndTimeBin){
		tmpPad->SetDataSignal(time+i,bunchData[i]);
	      }
	    }
	  }
	}
	if(tmpPad->GetNAddedSignals()>=(UInt_t)fMinimumNumberOfSignals){
	  fHwAddressList.push_back((AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr());
	  tmpPad->ZeroSuppress(fNRMSThreshold, fSignalThreshold, fMinimumNumberOfSignals, fStartTimeBin, fEndTimeBin, fLeftTimeBin, fRightTimeBin, fValueBelowAverage);
	}
      }
    }

  //  HLTDebug("Max number of signals: %d",size/sizeof(Int_t));

  if(wasInput>0){
  //if(wasInput && fHwAddressList.size()>0){
  
    AliHLTAltroEncoder altroEncoder;
    altroEncoder.SetBuffer(outputPtr,size); //tests if one overwrite the buffer is done in the encoder

    // TODO: read the CDH from the data input
    AliRawDataHeader cdh;
    altroEncoder.SetCDH((AliHLTUInt8_t*)&cdh,32);
    for(Int_t row=0;row<fNumberOfRows;row++){
      for(Int_t pad=0;pad<fNumberOfPadsInRow[row];pad++){
	AliHLTTPCPad * zeroSuppressedPad= fRowPadVector[row][pad];
	Int_t currentTime=0;
	Int_t bunchSize=0;
	if(zeroSuppressedPad->GetNAddedSignals()>0){
	  while(zeroSuppressedPad->GetNextGoodSignal(currentTime, bunchSize,0)){
	    for(Int_t i=0;i<bunchSize;i++){
	      altroEncoder.AddSignal(zeroSuppressedPad->GetDataSignal(currentTime+i), currentTime+i);
	    }
	  }
	  altroEncoder.SetChannel(fDigitReader->GetAltroBlockHWaddr(row, pad));
	}
      }
    }

    // TODO: read the RCU trailer from the data input
    AliHLTUInt8_t dummyTrailer=0;
    altroEncoder.SetRCUTrailer(&dummyTrailer, sizeof(dummyTrailer));
    int sizeOfData=altroEncoder.SetLength();

    if (sizeOfData<0) {
      HLTError("data encoding failed");
      return sizeOfData;
    }
    if(sizeOfData>(int)size){
      HLTWarning("Buffer too small too add the altrodata: %d of %d byte(s) already used", sizeOfData, size);
      return -ENOSPC;
    }

    //Push back the zerosuppressed altro data to the output
    AliHLTComponentBlockData bd;
    FillBlockData( bd );
    bd.fOffset = 0;
    bd.fSize = sizeOfData;
    bd.fDataType = kAliHLTDataTypeDDLRaw;
    bd.fSpecification = iter->fSpecification;
    Logging( kHLTLogDebug, "HLT::TPCZeroSuppressionComponent::DoEvent", "Event received", 
	     "Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
	     evtData.fEventID, evtData.fEventID, ndx,size ,0);
    outputBlocks.push_back( bd );

    //Push back the list of hardware addresses to the output
    AliHLTUInt32_t dataOffsetBeforeHW=sizeOfData;
    AliHLTUInt32_t sizeOfHWArray=fHwAddressList.size()*sizeof(AliHLTUInt16_t);

    if(dataOffsetBeforeHW+sizeOfHWArray>size){
      HLTWarning("Buffer too small too add the active channels: %d of %d byte(s) already used", dataOffsetBeforeHW + sizeOfHWArray, size);
      return -ENOSPC;
    }

    AliHLTUInt16_t*outputHWPtr=(AliHLTUInt16_t*)(outputPtr+dataOffsetBeforeHW);
    outputHWPtr = &fHwAddressList[0];
    AliHLTComponentBlockData bdHW;
    FillBlockData( bdHW );
    bdHW.fOffset = dataOffsetBeforeHW;
    bdHW.fSize = sizeOfHWArray;
    bdHW.fDataType = kAliHLTDataTypeHwAddr16;
    bdHW.fSpecification = iter->fSpecification;
    Logging( kHLTLogDebug, "HLT::TPCZeroSuppressionComponent::DoEvent", "Event received", 
	     "Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
	     evtData.fEventID, evtData.fEventID, ndx,size ,0);
    outputBlocks.push_back( bdHW );
    
    size = dataOffsetBeforeHW+sizeOfHWArray;

  } else {
    size=0;
  }
  return 0;
}
Commit	Line	Data
afa4418c	1	/**************************************************************************
	2	* This file is property of and copyright by the ALICE HLT Project *
	3	* ALICE Experiment at CERN, All rights reserved. *
	4	* *
	5	* Primary Authors: Kenneth Aamodt <Kenneth.Aamodt@student.uib.no> *
	6	* for The ALICE HLT Project. *
	7	* *
	8	* Permission to use, copy, modify and distribute this software and its *
	9	* documentation strictly for non-commercial purposes is hereby granted *
	10	* without fee, provided that the above copyright notice appears in all *
	11	* copies and that both the copyright notice and this permission notice *
	12	* appear in the supporting documentation. The authors make no claims *
	13	* about the suitability of this software for any purpose. It is *
	14	* provided "as is" without express or implied warranty. *
	15	**************************************************************************/
	16
	17	/** @file AliHLTTPCZeroSuppressionComponent.cxx
	18	@author Kenneth Aamodt
	19	@date
	20	@brief The TPC ZeroSuppression component
	21	*/
	22
	23	// see header file for class documentation //
	24	// or //
	25	// refer to README to build package //
	26	// or //
	27	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt //
	28
	29	#if __GNUC__>= 3
	30	using namespace std;
	31	#endif
	32	#include "AliHLTTPCZeroSuppressionComponent.h"
	33	#include "AliHLTTPCDigitReaderDecoder.h"
	34	#include "AliHLTTPCTransform.h"
	35	#include "AliHLTTPCDefinitions.h"
afa4418c	36	#include "AliHLTTPCDigitData.h"
	37	#include <cstdlib>
	38	#include <cerrno>
	39	#include "TString.h"
	40	#include <sys/time.h>
092a1374	41	#include "AliHLTAltroEncoder.h"
092a1374	42	#include "AliRawDataHeader.h"
a74855c2	43
afa4418c	44	/** ROOT macro for the implementation of ROOT specific class methods */
	45	ClassImp(AliHLTTPCZeroSuppressionComponent)
	46
	47	AliHLTTPCZeroSuppressionComponent::AliHLTTPCZeroSuppressionComponent()
	48	:
a74855c2	49	fDigitReader(NULL),
	50	fRowPadVector(),
	51	fNumberOfPadsInRow(NULL),
	52	fNumberOfRows(0),
	53	fCurrentPatch(0),
	54	fFirstRow(0),
	55	fLastRow(0),
afa4418c	56	fStartTimeBin(0),
afa4418c	57	fEndTimeBin(AliHLTTPCTransform::GetNTimeBins()),
a74855c2	58	fNTimeBins(0),
afa4418c	59	fNRMSThreshold(0),
	60	fSignalThreshold(0),
	61	fMinimumNumberOfSignals(AliHLTTPCTransform::GetNTimeBins()/2),
	62	fOldRCUFormat(0),
	63	fSortPads(0),
afa4418c	64	fVectorInitialized(kFALSE),
afa4418c	65	fValueBelowAverage(5),
afa4418c	66	fLeftTimeBin(5),
a74855c2	67	fRightTimeBin(5),
	68	fGetActivePads(kFALSE),
	69	fHwAddressList()
afa4418c	70	{
	71	// see header file for class documentation
	72	// or
	73	// refer to README to build package
	74	// or
	75	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	76	}
	77
	78	AliHLTTPCZeroSuppressionComponent::~AliHLTTPCZeroSuppressionComponent()
	79	{
	80	// see header file for class documentation
	81	if(fVectorInitialized){
	82	DeInitializePadArray();
	83	}
	84	if(fNumberOfPadsInRow){
	85	delete [] fNumberOfPadsInRow;
	86	fNumberOfPadsInRow=NULL;
	87	}
9b4f7f90	88	if(fDigitReader){
	89	delete fDigitReader;
	90	fDigitReader=NULL;
	91	}
afa4418c	92	}
	93
	94	// Public functions to implement AliHLTComponent's interface.
	95	// These functions are required for the registration process
	96
	97	const char* AliHLTTPCZeroSuppressionComponent::GetComponentID()
	98	{
	99	// see header file for class documentation
	100	return "TPCZeroSuppression";
	101	}
	102
	103	void AliHLTTPCZeroSuppressionComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
	104	{
	105	// see header file for class documentation
	106	list.clear();
	107	list.push_back( kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC );
	108	}
	109
	110	AliHLTComponentDataType AliHLTTPCZeroSuppressionComponent::GetOutputDataType()
	111	{
	112	// see header file for class documentation
092a1374	113	return kAliHLTMultipleDataType;
	114	//return kAliHLTDataTypeDDLRaw;
	115	// return AliHLTTPCDefinitions::fgkUnpackedRawDataType;
afa4418c	116	}
	117
	118	int AliHLTTPCZeroSuppressionComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
	119	{
	120	// see header file for class documentation
	121	tgtList.clear();
092a1374	122	tgtList.push_back(kAliHLTDataTypeDDLRaw);
092a1374	123	tgtList.push_back(kAliHLTDataTypeHwAddr16);
afa4418c	124	return tgtList.size();
	125	}
	126
	127	void AliHLTTPCZeroSuppressionComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
	128	{
	129	// see header file for class documentation
	130	constBase=0;
a74855c2	131	inputMultiplier=2.0;
afa4418c	132	}
	133
	134	AliHLTComponent* AliHLTTPCZeroSuppressionComponent::Spawn()
	135	{
	136	// see header file for class documentation
	137	return new AliHLTTPCZeroSuppressionComponent();
	138	}
	139
	140	int AliHLTTPCZeroSuppressionComponent::DoInit( int argc, const char** argv )
	141	{
	142	// see header file for class documentation
	143
	144	Int_t i = 0;
	145	Char_t* cpErr;
	146
	147	while ( i < argc ) {
	148
	149	// -- zero suppression threshold
	150	if ( !strcmp( argv[i], "signal-threshold" ) ) {
	151	fSignalThreshold = strtoul( argv[i+1], &cpErr ,0);
	152	if ( *cpErr ) {
	153	HLTError("Cannot convert signal-threshold specifier '%s'.", argv[i+1]);
	154	return EINVAL;
	155	}
	156	i+=2;
	157	continue;
	158	}
	159
	160	// -- checking for nsigma-threshold, used in 2007 December run in ZeroSuppression
	161	if ( !strcmp( argv[i], "rms-threshold" ) ) {
	162	fNRMSThreshold = strtoul( argv[i+1], &cpErr ,0);
	163	if ( *cpErr ){
	164	HLTError("Cannot convert rms-threshold specifier '%s'. Must be integer", argv[i+1]);
	165	return EINVAL;
	166	}
	167	i+=2;
	168	continue;
	169	}
	170
	171	// -- number of timebins
	172	if ( !strcmp( argv[i], "ntimebins" ) ) {
	173	fNTimeBins = strtoul( argv[i+1], &cpErr ,0);
	174	if ( *cpErr ) {
	175	HLTError("Cannot convert ntimebins specifier '%s'.", argv[i+1]);
	176	return EINVAL;
	177	}
	178	i+=2;
	179	continue;
	180	}
	181
	182	// -- first timebin
	183	if ( !strcmp( argv[i], "start-timebin" ) ) {
	184	fStartTimeBin = strtoul( argv[i+1], &cpErr ,0);
	185	if ( *cpErr ) {
	186	HLTError("Cannot convert start-timebin specifier '%s'.", argv[i+1]);
	187	return EINVAL;
	188	}
	189	i+=2;
	190	continue;
	191	}
	192
	193	// -- last timebin
	194	if ( !strcmp( argv[i], "end-timebin" ) ) {
a74855c2	195	if(strtoul( argv[i+1], &cpErr ,0)<=(UInt_t)AliHLTTPCTransform::GetNTimeBins()){
	196	fEndTimeBin = strtoul( argv[i+1], &cpErr ,0);
	197	}
afa4418c	198	if ( *cpErr ) {
	199	HLTError("Cannot convert end-timebin specifier '%s'.", argv[i+1]);
	200	return EINVAL;
	201	}
	202	i+=2;
	203	continue;
	204	}
	205
	206	// -- timebins to keep left of signal
	207	if ( !strcmp( argv[i], "timebin-left" ) ) {
	208	fLeftTimeBin = strtoul( argv[i+1], &cpErr ,0);
	209	if ( *cpErr ) {
	210	HLTError("Cannot convert timebin-left specifier '%s'.", argv[i+1]);
	211	return EINVAL;
	212	}
	213	i+=2;
	214	continue;
	215	}
	216
	217	// -- timebin to keep right of signal
	218	if ( !strcmp( argv[i], "timebin-right" ) ) {
	219	fRightTimeBin = strtoul( argv[i+1], &cpErr ,0);
	220	if ( *cpErr ) {
	221	HLTError("Cannot convert timebin-right specifier '%s'.", argv[i+1]);
	222	return EINVAL;
	223	}
	224	i+=2;
	225	continue;
	226	}
	227
	228	// -- value below average to subtract
	229	if ( !strcmp( argv[i], "value-below-average" ) ) {
	230	fValueBelowAverage = strtoul( argv[i+1], &cpErr ,0);
	231	if ( *cpErr ) {
	232	HLTError("Cannot convert value-below-average specifier '%s'.", argv[i+1]);
	233	return EINVAL;
	234	}
	235	i+=2;
	236	continue;
	237	}
	238
	239	// -- pad occupancy limit
	240	if ( !strcmp( argv[i], "occupancy-limit" ) ) {
	241	fMinimumNumberOfSignals = strtoul( argv[i+1], &cpErr ,0);
	242	if ( *cpErr ) {
	243	HLTError("Cannot convert occupancy-limit specifier '%s'.", argv[i+1]);
	244	return EINVAL;
	245	}
	246	i+=2;
	247	continue;
	248	}
	249
	250	// -- checking for rcu format
	251	if ( !strcmp( argv[i], "oldrcuformat" ) ) {
	252	fOldRCUFormat = strtoul( argv[i+1], &cpErr ,0);
	253	if ( *cpErr ){
	254	HLTError("Cannot convert oldrcuformat specifier '%s'. Should be 0(off) or 1(on), must be integer", argv[i+1]);
	255	return EINVAL;
	256	}
	257	i+=2;
	258	continue;
	259	}
	260
	261	// -- checking for rcu format
262	if ( !strcmp( argv[i], "sort-pads" ) ) {
263	fSortPads = strtoul( argv[i+1], &cpErr ,0);
264	if ( *cpErr ){
265	HLTError("Cannot convert sort-pads specifier '%s'. Should be 0(off) or 1(on), must be integer", argv[i+1]);
266	return EINVAL;
267	}
268	i+=2;
269	continue;
270	}
271
272	Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
273	return EINVAL;
274
275	}
276
277	HLTDebug("using AliHLTTPCDigitReaderDecoder");
278	fDigitReader = new AliHLTTPCDigitReaderDecoder();
279
a74855c2	280	fHwAddressList.clear();
a74855c2	281
afa4418c	282	return 0;
	283	}
	284
	285	int AliHLTTPCZeroSuppressionComponent::DoDeinit()
	286	{
	287	// see header file for class documentation
afa4418c	288	return 0;
	289	}
	290
	291	Int_t AliHLTTPCZeroSuppressionComponent::DeInitializePadArray()
	292	{
	293	// see header file for class documentation
	294	if(fVectorInitialized){
	295	for(Int_t i=0;i<fNumberOfRows;i++){
	296	for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
	297	delete fRowPadVector[i][j];
	298	fRowPadVector[i][j]=NULL;
	299	}
	300	fRowPadVector[i].clear();
	301	}
	302	fRowPadVector.clear();
	303	}
afa4418c	304	return 1;
	305	}
	306
	307	void AliHLTTPCZeroSuppressionComponent::InitializePadArray(){
	308	// see header file for class documentation
a74855c2	309	if(fCurrentPatch>5){
afa4418c	310	HLTFatal("Patch is not set");
	311	return;
	312	}
	313
	314	fFirstRow = AliHLTTPCTransform::GetFirstRow(fCurrentPatch);
	315	fLastRow = AliHLTTPCTransform::GetLastRow(fCurrentPatch);
	316
	317	fNumberOfRows=fLastRow-fFirstRow+1;
a74855c2	318	fNumberOfPadsInRow= new Int_t[fNumberOfRows];
afa4418c	319
	320	memset( fNumberOfPadsInRow, 0, sizeof(Int_t)*(fNumberOfRows));
	321
	322	for(Int_t i=0;i<fNumberOfRows;i++){
	323	fNumberOfPadsInRow[i]=AliHLTTPCTransform::GetNPads(i+fFirstRow);
	324	AliHLTTPCPadVector tmpRow;
	325	for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
	326	AliHLTTPCPad *tmpPad = new AliHLTTPCPad();
	327	tmpPad->SetID(i,j);
	328	tmpRow.push_back(tmpPad);
	329	}
	330	fRowPadVector.push_back(tmpRow);
	331	}
	332	fVectorInitialized=kTRUE;
	333	}
	334
	335
	336	int AliHLTTPCZeroSuppressionComponent::DoEvent( const AliHLTComponentEventData& evtData,
	337	const AliHLTComponentBlockData* blocks,
	338	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
	339	AliHLTUInt32_t& size,
	340	vector<AliHLTComponentBlockData>& outputBlocks )
	341	{
	342	// see header file for class documentation
	343
a74855c2	344	// HLTInfo("Entered DoEvent in AliHLTTPCZeroSuppressionComponent");
afa4418c	345
	346	// == init iter (pointer to datablock)
	347	const AliHLTComponentBlockData* iter = NULL;
	348	unsigned long ndx;
	349	// HLTInfo("Number of blocks: ",evtData.fBlockCnt);
	350
a74855c2	351	Bool_t wasInput = 0;
	352
	353	fHwAddressList.clear();
afa4418c	354	//reading the data
	355	for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
	356	{
	357	iter = blocks+ndx;
	358
	359	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	360	evtData.fEventID, evtData.fEventID,
	361	DataType2Text( iter->fDataType).c_str(),
	362	DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	363
	364	if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType &&
	365	GetEventCount()<2) {
	366	HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
	367	DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
	368	DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	369	}
	370
	371	if ( iter->fDataType != (kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC) &&
	372	iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ){
	373	continue;
	374	}
	375
a74855c2	376	wasInput = 1;
afa4418c	377
	378	UInt_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
	379	UInt_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
	380
	381	if(!fVectorInitialized){
	382	fCurrentPatch=patch;
	383	InitializePadArray();
	384	}
	385
afa4418c	386	fDigitReader->InitBlock(iter->fPtr,iter->fSize,patch,slice);
9b4f7f90	387
afa4418c	388	//Here the reading of the data and the zerosuppression takes place
afa4418c	389	while(fDigitReader->NextChannel()){//Pad
a74855c2	390	Int_t row=fDigitReader->GetRow();
a74855c2	391	Int_t pad=fDigitReader->GetPad();
9b4f7f90	392	if(row==1000 \|\| pad==1000){
	393	continue;
	394	}
a74855c2	395	if(row>=fNumberOfRows\|\|row<0){
9b4f7f90	396	continue;
9b4f7f90	397	}
a74855c2	398	else if(pad>=fNumberOfPadsInRow[row]\|\|pad<0){
9b4f7f90	399	continue;
9b4f7f90	400	}
9b4f7f90	401
a74855c2	402	AliHLTTPCPad *tmpPad = fRowPadVector[row][pad];
	403	tmpPad->SetDataToDefault();
	404
afa4418c	405	//reading data to pad
	406	while(fDigitReader->NextBunch()){
	407	const UInt_t *bunchData= fDigitReader->GetSignals();
a74855c2	408	Int_t time=fDigitReader->GetTime();
afa4418c	409	for(Int_t i=0;i<fDigitReader->GetBunchSize();i++){
	410	if(bunchData[i]>0){// disregarding 0 data.
	411	if(time+i>=fStartTimeBin && time+i<=fEndTimeBin){
afa4418c	412	tmpPad->SetDataSignal(time+i,bunchData[i]);
	413	}
	414	}
	415	}
	416	}
a74855c2	417	if(tmpPad->GetNAddedSignals()>=(UInt_t)fMinimumNumberOfSignals){
092a1374	418	fHwAddressList.push_back((AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr());
afa4418c	419	tmpPad->ZeroSuppress(fNRMSThreshold, fSignalThreshold, fMinimumNumberOfSignals, fStartTimeBin, fEndTimeBin, fLeftTimeBin, fRightTimeBin, fValueBelowAverage);
afa4418c	420	}
	421	}
	422	}
9b4f7f90	423
092a1374	424	// HLTDebug("Max number of signals: %d",size/sizeof(Int_t));
092a1374	425
2fdb1ae7	426	if(wasInput>0){
	427	//if(wasInput && fHwAddressList.size()>0){
	428
092a1374	429	AliHLTAltroEncoder altroEncoder;
	430	altroEncoder.SetBuffer(outputPtr,size); //tests if one overwrite the buffer is done in the encoder
	431
	432	// TODO: read the CDH from the data input
	433	AliRawDataHeader cdh;
	434	altroEncoder.SetCDH((AliHLTUInt8_t*)&cdh,32);
	435	for(Int_t row=0;row<fNumberOfRows;row++){
	436	for(Int_t pad=0;pad<fNumberOfPadsInRow[row];pad++){
	437	AliHLTTPCPad * zeroSuppressedPad= fRowPadVector[row][pad];
	438	Int_t currentTime=0;
	439	Int_t bunchSize=0;
	440	if(zeroSuppressedPad->GetNAddedSignals()>0){
	441	while(zeroSuppressedPad->GetNextGoodSignal(currentTime, bunchSize,0)){
	442	for(Int_t i=0;i<bunchSize;i++){
	443	altroEncoder.AddSignal(zeroSuppressedPad->GetDataSignal(currentTime+i), currentTime+i);
	444	}
	445	}
	446	altroEncoder.SetChannel(fDigitReader->GetAltroBlockHWaddr(row, pad));
afa4418c	447	}
afa4418c	448	}
afa4418c	449	}
afa4418c	450
092a1374	451	// TODO: read the RCU trailer from the data input
	452	AliHLTUInt8_t dummyTrailer=0;
	453	altroEncoder.SetRCUTrailer(&dummyTrailer, sizeof(dummyTrailer));
	454	int sizeOfData=altroEncoder.SetLength();
	455
	456	if (sizeOfData<0) {
	457	HLTError("data encoding failed");
	458	return sizeOfData;
	459	}
	460	if(sizeOfData>(int)size){
	461	HLTWarning("Buffer too small too add the altrodata: %d of %d byte(s) already used", sizeOfData, size);
	462	return -ENOSPC;
	463	}
a74855c2	464
092a1374	465	//Push back the zerosuppressed altro data to the output
a74855c2	466	AliHLTComponentBlockData bd;
a74855c2	467	FillBlockData( bd );
092a1374	468	bd.fOffset = 0;
	469	bd.fSize = sizeOfData;
	470	bd.fDataType = kAliHLTDataTypeDDLRaw;
a74855c2	471	bd.fSpecification = iter->fSpecification;
	472	Logging( kHLTLogDebug, "HLT::TPCZeroSuppressionComponent::DoEvent", "Event received",
	473	"Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
092a1374	474	evtData.fEventID, evtData.fEventID, ndx,size ,0);
a74855c2	475	outputBlocks.push_back( bd );
092a1374	476
	477	//Push back the list of hardware addresses to the output
	478	AliHLTUInt32_t dataOffsetBeforeHW=sizeOfData;
	479	AliHLTUInt32_t sizeOfHWArray=fHwAddressList.size()*sizeof(AliHLTUInt16_t);
	480
	481	if(dataOffsetBeforeHW+sizeOfHWArray>size){
	482	HLTWarning("Buffer too small too add the active channels: %d of %d byte(s) already used", dataOffsetBeforeHW + sizeOfHWArray, size);
	483	return -ENOSPC;
	484	}
	485
	486	AliHLTUInt16_toutputHWPtr=(AliHLTUInt16_t)(outputPtr+dataOffsetBeforeHW);
	487	outputHWPtr = &fHwAddressList[0];
	488	AliHLTComponentBlockData bdHW;
	489	FillBlockData( bdHW );
	490	bdHW.fOffset = dataOffsetBeforeHW;
	491	bdHW.fSize = sizeOfHWArray;
	492	bdHW.fDataType = kAliHLTDataTypeHwAddr16;
	493	bdHW.fSpecification = iter->fSpecification;
	494	Logging( kHLTLogDebug, "HLT::TPCZeroSuppressionComponent::DoEvent", "Event received",
	495	"Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
	496	evtData.fEventID, evtData.fEventID, ndx,size ,0);
	497	outputBlocks.push_back( bdHW );
	498
	499	size = dataOffsetBeforeHW+sizeOfHWArray;
	500
2fdb1ae7	501	} else {
2fdb1ae7	502	size=0;
a74855c2	503	}
afa4418c	504	return 0;
afa4418c	505	}