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

// $Id$

/**************************************************************************
 * 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 "AliHLTTPCMapping.h"
#include <cstdlib>
#include <cerrno>
#include <cassert>
#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),
    fSkipSendingZSData(kFALSE),
    fSendHWList(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" ) || !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" ) ||  !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], "-timebins" ) || !strcmp( argv[i], "ntimebins" ) || !strcmp( argv[i], "-ntimebins" )) {
      fNTimeBins = strtoul( argv[i+1], &cpErr ,0);
      AliHLTTPCTransform::SetNTimeBins(fNTimeBins);
      if(fEndTimeBin>AliHLTTPCTransform::GetNTimeBins()){
	fEndTimeBin = AliHLTTPCTransform::GetNTimeBins();
      }
      if ( *cpErr ) {
	HLTError("Cannot convert ntimebins specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }

    // -- first timebin
    if ( !strcmp( argv[i], "-start-timebin" ) || !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" ) || !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" ) || !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" ) || !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" ) || !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" ) || !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 pad sorting
    if ( !strcmp( argv[i], "-sort-pads" ) || !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;
    }

    // -- checking for skipZSdatashipping
    if ( !strcmp( argv[i], "-skip-sending-data" ) ) {
      fSkipSendingZSData = kTRUE;
      i++;
      continue;
    }

    // -- checking for hw address shipping
    if ( !strcmp( argv[i], "-send-hw-list" ) ) {
      fSendHWList = kTRUE;
      i++;
      continue;
    }
      
    Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
    return EINVAL;

  }

  if(fSkipSendingZSData == kTRUE && fSendHWList == kFALSE){
    HLTError("Component will have no output, check your configuration.");
  }
  

  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
  int iResult=0;
  if (!fDigitReader) return -ENODEV;

  AliHLTUInt32_t capacity=size;
  size=0;
  if (!IsDataEvent()) return 0;

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

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

  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 != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC)){
	continue;
      }

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

      if(!fVectorInitialized){
	fCurrentPatch=patch;
	InitializePadArray();
      }
      
      if(fDigitReader->InitBlock(iter->fPtr,iter->fSize,patch,slice)<0){
	HLTWarning("Decoder failed to initialize, event aborted.");
	continue;
      }
      AliHLTTPCMapping mapping(patch);

      int nTotalChannels=0;
      int nSkippedChannels=0;
      short lowestOccupancy=-1;
      float sumOccupancy=0;

      //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]);
	      }
	    }
	  }
	}

	nTotalChannels++;
	if (lowestOccupancy<0 || (unsigned short)lowestOccupancy>tmpPad->GetNAddedSignals())
	  lowestOccupancy=tmpPad->GetNAddedSignals();
	sumOccupancy+=tmpPad->GetNAddedSignals();

	if(tmpPad->GetNAddedSignals()>=(UInt_t)fMinimumNumberOfSignals){
	  tmpPad->ZeroSuppress(fNRMSThreshold, fSignalThreshold, fMinimumNumberOfSignals, fStartTimeBin, fEndTimeBin, fLeftTimeBin, fRightTimeBin, fValueBelowAverage, fSkipSendingZSData);
	  if(tmpPad->GetNAddedSignals()>0){
	    assert((int)mapping.GetRow(fDigitReader->GetAltroBlockHWaddr())==row);
	    assert((int)mapping.GetPad(fDigitReader->GetAltroBlockHWaddr())==pad);
	    fHwAddressList.push_back((AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr());
	  }
	} else {
	  nSkippedChannels++;
	}
      }
      if (nSkippedChannels>0) {
	HLTWarning("skipped %d of %d channels because of low occupancy: average %.2f, lowest %d, threshold %d",
		   nSkippedChannels, nTotalChannels, sumOccupancy/nTotalChannels, lowestOccupancy, fMinimumNumberOfSignals);
      }

      AliHLTUInt32_t dataOffsetBeforeHW=0;

      if(fSkipSendingZSData == kFALSE && iter->fSize>sizeof(AliRawDataHeader)) {
  
	AliHLTAltroEncoder *altroEncoder = new AliHLTAltroEncoder;
	altroEncoder->SetBuffer(outputPtr,capacity); //tests if one overwrite the buffer is done in the encoder

	// set CDH from the beginning of buffer
	altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,sizeof(AliRawDataHeader));

	UChar_t *RCUTrailer=NULL;
	Int_t RCUTrailerSize=fDigitReader->GetRCUTrailerSize();
	if (RCUTrailerSize<=0 || !fDigitReader->GetRCUTrailerData( RCUTrailer )) {
	  if(RCUTrailer==NULL){
	    HLTWarning("can not find RCU trailer for data block %s 0x%08x: skipping data block",
		       DataType2Text(iter->fDataType).c_str(), iter->fSpecification);
	    continue;
	  }
	}
	altroEncoder->SetRCUTrailer(RCUTrailer, RCUTrailerSize);

	for(unsigned int channel=0; channel<fHwAddressList.size(); channel++){
	  int row=mapping.GetRow(fHwAddressList[channel]);
	  int pad=mapping.GetPad(fHwAddressList[channel]);
	  if (true) {
	    AliHLTTPCPad * zeroSuppressedPad= fRowPadVector[row][pad];
	    Int_t currentTime=0;
	    Int_t bunchSize=0;
	    if(zeroSuppressedPad->GetNAddedSignals()>0){
	      while(zeroSuppressedPad->GetNextGoodSignal(currentTime, bunchSize)){
		for(Int_t i=0;i<bunchSize;i++){
		  if (altroEncoder->AddSignal((AliHLTUInt16_t)(zeroSuppressedPad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
		    // Matthias 01.10.2008: there is a problem with certain real data which produces the same
		    // bunch multiple times, needs investigation. I found an examplary case in run 53465
		    // (08000053465011.450.root) equipment 981.
		    // needs to be followed up.
		    // addon 02.10.2008 I just corrected a bug concerning the loop over the active channels.
		    // A double loop over all rows and pads also considered pads which had not even been
		    // filled, and thus not properly cleaned. Maybe the bug above is related to that.
		    HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d",
			       slice, patch, fHwAddressList[channel], row, pad, currentTime+i, bunchSize);
		    break;
		  }
		}
	      }
	      altroEncoder->SetChannel(fHwAddressList[channel]);
	    }
	  }
	}

	int sizeOfData=altroEncoder->SetLength();

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

	//Push back the zerosuppressed altro data to the output
	if(true/* condition was deprecated but keep for the sake of formatting*/){
	  AliHLTComponentBlockData bd;
	  FillBlockData( bd );
	  bd.fOffset = 0;
	  bd.fSize = sizeOfData;
	  bd.fDataType = kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC;
	  bd.fSpecification = iter->fSpecification;
	  outputBlocks.push_back( bd );
    
	  //Push back the list of hardware addresses to the output
	  dataOffsetBeforeHW=sizeOfData;
	}
      }

      AliHLTUInt32_t sizeOfHWArray = 0;
      if(fSendHWList == kTRUE){

	if(true/* condition was deprecated but keep for the sake of formatting*/){
	  sizeOfHWArray = fHwAddressList.size()*sizeof(AliHLTUInt16_t);
      
	  if(dataOffsetBeforeHW+sizeOfHWArray>capacity){
	    HLTWarning("Buffer too small too add the active channels: %d of %d byte(s) already used", dataOffsetBeforeHW + sizeOfHWArray, capacity);
	    iResult=-ENOSPC;
	    break;
	  }
      
	  AliHLTUInt16_t*outputHWPtr=(AliHLTUInt16_t*)(outputPtr+dataOffsetBeforeHW);
	  memcpy(outputHWPtr,&fHwAddressList[0],sizeOfHWArray);
	  AliHLTComponentBlockData bdHW;
	  FillBlockData( bdHW );
	  bdHW.fOffset = dataOffsetBeforeHW;
	  bdHW.fSize = sizeOfHWArray;
	  bdHW.fDataType = kAliHLTDataTypeHwAddr16|kAliHLTDataOriginTPC;
	  bdHW.fSpecification = iter->fSpecification;
	  outputBlocks.push_back( bdHW );
	}
      }
      size = dataOffsetBeforeHW+sizeOfHWArray;
      fDigitReader->Reset();
    }

  if (iResult<0) {
    fDigitReader->Reset();
    size=0;
  }

  return iResult;
}
Commit	Line	Data
10f165dc	1	// $Id$
10f165dc	2
afa4418c	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: Kenneth Aamodt <Kenneth.Aamodt@student.uib.no> *
	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	/** @file AliHLTTPCZeroSuppressionComponent.cxx
	20	@author Kenneth Aamodt
	21	@date
	22	@brief The TPC ZeroSuppression component
	23	*/
	24
	25	// see header file for class documentation //
	26	// or //
	27	// refer to README to build package //
	28	// or //
	29	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt //
	30
	31	#if __GNUC__>= 3
	32	using namespace std;
	33	#endif
	34	#include "AliHLTTPCZeroSuppressionComponent.h"
	35	#include "AliHLTTPCDigitReaderDecoder.h"
	36	#include "AliHLTTPCTransform.h"
	37	#include "AliHLTTPCDefinitions.h"
afa4418c	38	#include "AliHLTTPCDigitData.h"
5cccaefd	39	#include "AliHLTTPCMapping.h"
afa4418c	40	#include <cstdlib>
afa4418c	41	#include <cerrno>
5cccaefd	42	#include <cassert>
afa4418c	43	#include "TString.h"
afa4418c	44	#include <sys/time.h>
092a1374	45	#include "AliHLTAltroEncoder.h"
092a1374	46	#include "AliRawDataHeader.h"
a74855c2	47
afa4418c	48	/** ROOT macro for the implementation of ROOT specific class methods */
	49	ClassImp(AliHLTTPCZeroSuppressionComponent)
	50
	51	AliHLTTPCZeroSuppressionComponent::AliHLTTPCZeroSuppressionComponent()
	52	:
a74855c2	53	fDigitReader(NULL),
	54	fRowPadVector(),
	55	fNumberOfPadsInRow(NULL),
	56	fNumberOfRows(0),
	57	fCurrentPatch(0),
	58	fFirstRow(0),
	59	fLastRow(0),
afa4418c	60	fStartTimeBin(0),
afa4418c	61	fEndTimeBin(AliHLTTPCTransform::GetNTimeBins()),
a74855c2	62	fNTimeBins(0),
afa4418c	63	fNRMSThreshold(0),
	64	fSignalThreshold(0),
	65	fMinimumNumberOfSignals(AliHLTTPCTransform::GetNTimeBins()/2),
	66	fOldRCUFormat(0),
	67	fSortPads(0),
afa4418c	68	fVectorInitialized(kFALSE),
afa4418c	69	fValueBelowAverage(5),
afa4418c	70	fLeftTimeBin(5),
a74855c2	71	fRightTimeBin(5),
a74855c2	72	fGetActivePads(kFALSE),
3789100d	73	fSkipSendingZSData(kFALSE),
3789100d	74	fSendHWList(kFALSE),
a74855c2	75	fHwAddressList()
afa4418c	76	{
	77	// see header file for class documentation
	78	// or
	79	// refer to README to build package
	80	// or
	81	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	82	}
	83
	84	AliHLTTPCZeroSuppressionComponent::~AliHLTTPCZeroSuppressionComponent()
	85	{
	86	// see header file for class documentation
	87	if(fVectorInitialized){
	88	DeInitializePadArray();
	89	}
	90	if(fNumberOfPadsInRow){
	91	delete [] fNumberOfPadsInRow;
	92	fNumberOfPadsInRow=NULL;
	93	}
9b4f7f90	94	if(fDigitReader){
	95	delete fDigitReader;
	96	fDigitReader=NULL;
	97	}
afa4418c	98	}
	99
	100	// Public functions to implement AliHLTComponent's interface.
	101	// These functions are required for the registration process
	102
	103	const char* AliHLTTPCZeroSuppressionComponent::GetComponentID()
	104	{
	105	// see header file for class documentation
	106	return "TPCZeroSuppression";
	107	}
	108
	109	void AliHLTTPCZeroSuppressionComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
	110	{
	111	// see header file for class documentation
	112	list.clear();
	113	list.push_back( kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC );
	114	}
	115
	116	AliHLTComponentDataType AliHLTTPCZeroSuppressionComponent::GetOutputDataType()
	117	{
	118	// see header file for class documentation
092a1374	119	return kAliHLTMultipleDataType;
	120	//return kAliHLTDataTypeDDLRaw;
	121	// return AliHLTTPCDefinitions::fgkUnpackedRawDataType;
afa4418c	122	}
	123
	124	int AliHLTTPCZeroSuppressionComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
	125	{
	126	// see header file for class documentation
	127	tgtList.clear();
092a1374	128	tgtList.push_back(kAliHLTDataTypeDDLRaw);
092a1374	129	tgtList.push_back(kAliHLTDataTypeHwAddr16);
afa4418c	130	return tgtList.size();
	131	}
	132
	133	void AliHLTTPCZeroSuppressionComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
	134	{
	135	// see header file for class documentation
	136	constBase=0;
a74855c2	137	inputMultiplier=2.0;
afa4418c	138	}
	139
	140	AliHLTComponent* AliHLTTPCZeroSuppressionComponent::Spawn()
	141	{
	142	// see header file for class documentation
	143	return new AliHLTTPCZeroSuppressionComponent();
	144	}
	145
	146	int AliHLTTPCZeroSuppressionComponent::DoInit( int argc, const char** argv )
	147	{
	148	// see header file for class documentation
	149
	150	Int_t i = 0;
	151	Char_t* cpErr;
	152
	153	while ( i < argc ) {
	154
	155	// -- zero suppression threshold
3789100d	156	if ( !strcmp( argv[i], "-signal-threshold" ) \|\| !strcmp( argv[i], "signal-threshold" ) ) {
afa4418c	157	fSignalThreshold = strtoul( argv[i+1], &cpErr ,0);
	158	if ( *cpErr ) {
	159	HLTError("Cannot convert signal-threshold specifier '%s'.", argv[i+1]);
	160	return EINVAL;
	161	}
	162	i+=2;
	163	continue;
	164	}
	165
	166	// -- checking for nsigma-threshold, used in 2007 December run in ZeroSuppression
3789100d	167	if ( !strcmp( argv[i], "-rms-threshold" ) \|\| !strcmp( argv[i], "rms-threshold" ) ) {
afa4418c	168	fNRMSThreshold = strtoul( argv[i+1], &cpErr ,0);
	169	if ( *cpErr ){
	170	HLTError("Cannot convert rms-threshold specifier '%s'. Must be integer", argv[i+1]);
	171	return EINVAL;
	172	}
	173	i+=2;
	174	continue;
	175	}
	176
	177	// -- number of timebins
fec96a66	178	if ( !strcmp( argv[i], "-timebins" ) \|\| !strcmp( argv[i], "ntimebins" ) \|\| !strcmp( argv[i], "-ntimebins" )) {
afa4418c	179	fNTimeBins = strtoul( argv[i+1], &cpErr ,0);
fec96a66	180	AliHLTTPCTransform::SetNTimeBins(fNTimeBins);
	181	if(fEndTimeBin>AliHLTTPCTransform::GetNTimeBins()){
	182	fEndTimeBin = AliHLTTPCTransform::GetNTimeBins();
	183	}
afa4418c	184	if ( *cpErr ) {
	185	HLTError("Cannot convert ntimebins specifier '%s'.", argv[i+1]);
	186	return EINVAL;
	187	}
	188	i+=2;
	189	continue;
	190	}
	191
	192	// -- first timebin
3789100d	193	if ( !strcmp( argv[i], "-start-timebin" ) \|\| !strcmp( argv[i], "start-timebin" ) ) {
afa4418c	194	fStartTimeBin = strtoul( argv[i+1], &cpErr ,0);
	195	if ( *cpErr ) {
	196	HLTError("Cannot convert start-timebin specifier '%s'.", argv[i+1]);
	197	return EINVAL;
	198	}
	199	i+=2;
	200	continue;
	201	}
	202
	203	// -- last timebin
3789100d	204	if ( !strcmp( argv[i], "-end-timebin" ) \|\| !strcmp( argv[i], "end-timebin" ) ) {
a74855c2	205	if(strtoul( argv[i+1], &cpErr ,0)<=(UInt_t)AliHLTTPCTransform::GetNTimeBins()){
	206	fEndTimeBin = strtoul( argv[i+1], &cpErr ,0);
	207	}
afa4418c	208	if ( *cpErr ) {
	209	HLTError("Cannot convert end-timebin specifier '%s'.", argv[i+1]);
	210	return EINVAL;
	211	}
	212	i+=2;
	213	continue;
	214	}
	215
	216	// -- timebins to keep left of signal
3789100d	217	if ( !strcmp( argv[i], "-timebin-left" ) \|\| !strcmp( argv[i], "timebin-left" ) ) {
afa4418c	218	fLeftTimeBin = strtoul( argv[i+1], &cpErr ,0);
	219	if ( *cpErr ) {
	220	HLTError("Cannot convert timebin-left specifier '%s'.", argv[i+1]);
	221	return EINVAL;
	222	}
	223	i+=2;
	224	continue;
	225	}
	226
	227	// -- timebin to keep right of signal
3789100d	228	if ( !strcmp( argv[i], "-timebin-right" ) \|\| !strcmp( argv[i], "timebin-right" ) ) {
afa4418c	229	fRightTimeBin = strtoul( argv[i+1], &cpErr ,0);
	230	if ( *cpErr ) {
	231	HLTError("Cannot convert timebin-right specifier '%s'.", argv[i+1]);
	232	return EINVAL;
	233	}
	234	i+=2;
	235	continue;
	236	}
	237
	238	// -- value below average to subtract
3789100d	239	if ( !strcmp( argv[i], "-value-below-average" ) \|\| !strcmp( argv[i], "value-below-average" ) ) {
afa4418c	240	fValueBelowAverage = strtoul( argv[i+1], &cpErr ,0);
	241	if ( *cpErr ) {
	242	HLTError("Cannot convert value-below-average specifier '%s'.", argv[i+1]);
	243	return EINVAL;
	244	}
	245	i+=2;
	246	continue;
	247	}
	248
	249	// -- pad occupancy limit
3789100d	250	if ( !strcmp( argv[i], "-occupancy-limit" ) \|\| !strcmp( argv[i], "occupancy-limit" ) ) {
afa4418c	251	fMinimumNumberOfSignals = strtoul( argv[i+1], &cpErr ,0);
	252	if ( *cpErr ) {
	253	HLTError("Cannot convert occupancy-limit specifier '%s'.", argv[i+1]);
	254	return EINVAL;
	255	}
	256	i+=2;
	257	continue;
	258	}
	259
	260	// -- checking for rcu format
	261	if ( !strcmp( argv[i], "oldrcuformat" ) ) {
	262	fOldRCUFormat = strtoul( argv[i+1], &cpErr ,0);
	263	if ( *cpErr ){
	264	HLTError("Cannot convert oldrcuformat specifier '%s'. Should be 0(off) or 1(on), must be integer", argv[i+1]);
	265	return EINVAL;
	266	}
	267	i+=2;
	268	continue;
	269	}
	270
3789100d	271	// -- checking for pad sorting
3789100d	272	if ( !strcmp( argv[i], "-sort-pads" ) \|\| !strcmp( argv[i], "sort-pads" ) ) {
afa4418c	273	fSortPads = strtoul( argv[i+1], &cpErr ,0);
	274	if ( *cpErr ){
	275	HLTError("Cannot convert sort-pads specifier '%s'. Should be 0(off) or 1(on), must be integer", argv[i+1]);
	276	return EINVAL;
	277	}
	278	i+=2;
	279	continue;
	280	}
3789100d	281
	282	// -- checking for skipZSdatashipping
	283	if ( !strcmp( argv[i], "-skip-sending-data" ) ) {
	284	fSkipSendingZSData = kTRUE;
436467f5	285	i++;
436467f5	286	continue;
3789100d	287	}
	288
	289	// -- checking for hw address shipping
	290	if ( !strcmp( argv[i], "-send-hw-list" ) ) {
	291	fSendHWList = kTRUE;
436467f5	292	i++;
436467f5	293	continue;
3789100d	294	}
afa4418c	295
	296	Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
	297	return EINVAL;
	298
	299	}
	300
3789100d	301	if(fSkipSendingZSData == kTRUE && fSendHWList == kFALSE){
	302	HLTError("Component will have no output, check your configuration.");
	303	}
fec96a66	304
3789100d	305
afa4418c	306	HLTDebug("using AliHLTTPCDigitReaderDecoder");
	307	fDigitReader = new AliHLTTPCDigitReaderDecoder();
	308
a74855c2	309	fHwAddressList.clear();
a74855c2	310
afa4418c	311	return 0;
	312	}
	313
	314	int AliHLTTPCZeroSuppressionComponent::DoDeinit()
	315	{
	316	// see header file for class documentation
afa4418c	317	return 0;
	318	}
	319
	320	Int_t AliHLTTPCZeroSuppressionComponent::DeInitializePadArray()
	321	{
	322	// see header file for class documentation
	323	if(fVectorInitialized){
	324	for(Int_t i=0;i<fNumberOfRows;i++){
	325	for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
	326	delete fRowPadVector[i][j];
	327	fRowPadVector[i][j]=NULL;
	328	}
	329	fRowPadVector[i].clear();
	330	}
	331	fRowPadVector.clear();
	332	}
afa4418c	333	return 1;
	334	}
	335
	336	void AliHLTTPCZeroSuppressionComponent::InitializePadArray(){
	337	// see header file for class documentation
a74855c2	338	if(fCurrentPatch>5){
afa4418c	339	HLTFatal("Patch is not set");
	340	return;
	341	}
	342
	343	fFirstRow = AliHLTTPCTransform::GetFirstRow(fCurrentPatch);
	344	fLastRow = AliHLTTPCTransform::GetLastRow(fCurrentPatch);
	345
	346	fNumberOfRows=fLastRow-fFirstRow+1;
a74855c2	347	fNumberOfPadsInRow= new Int_t[fNumberOfRows];
afa4418c	348
	349	memset( fNumberOfPadsInRow, 0, sizeof(Int_t)*(fNumberOfRows));
	350
	351	for(Int_t i=0;i<fNumberOfRows;i++){
	352	fNumberOfPadsInRow[i]=AliHLTTPCTransform::GetNPads(i+fFirstRow);
	353	AliHLTTPCPadVector tmpRow;
	354	for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
	355	AliHLTTPCPad *tmpPad = new AliHLTTPCPad();
	356	tmpPad->SetID(i,j);
	357	tmpRow.push_back(tmpPad);
	358	}
	359	fRowPadVector.push_back(tmpRow);
	360	}
	361	fVectorInitialized=kTRUE;
	362	}
	363
	364
	365	int AliHLTTPCZeroSuppressionComponent::DoEvent( const AliHLTComponentEventData& evtData,
	366	const AliHLTComponentBlockData* blocks,
	367	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
	368	AliHLTUInt32_t& size,
	369	vector<AliHLTComponentBlockData>& outputBlocks )
	370	{
	371	// see header file for class documentation
5cccaefd	372	int iResult=0;
	373	if (!fDigitReader) return -ENODEV;
	374
	375	AliHLTUInt32_t capacity=size;
	376	size=0;
	377	if (!IsDataEvent()) return 0;
afa4418c	378
a74855c2	379	// HLTInfo("Entered DoEvent in AliHLTTPCZeroSuppressionComponent");
afa4418c	380
	381	// == init iter (pointer to datablock)
	382	const AliHLTComponentBlockData* iter = NULL;
	383	unsigned long ndx;
	384	// HLTInfo("Number of blocks: ",evtData.fBlockCnt);
	385
a74855c2	386	fHwAddressList.clear();
afa4418c	387	//reading the data
	388	for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
	389	{
	390	iter = blocks+ndx;
	391
	392	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	393	evtData.fEventID, evtData.fEventID,
	394	DataType2Text( iter->fDataType).c_str(),
	395	DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	396
5cccaefd	397	if ( iter->fDataType != (kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC)){
afa4418c	398	continue;
	399	}
	400
afa4418c	401	UInt_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
	402	UInt_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
	403
	404	if(!fVectorInitialized){
	405	fCurrentPatch=patch;
	406	InitializePadArray();
	407	}
	408
436467f5	409	if(fDigitReader->InitBlock(iter->fPtr,iter->fSize,patch,slice)<0){
	410	HLTWarning("Decoder failed to initialize, event aborted.");
	411	continue;
	412	}
5cccaefd	413	AliHLTTPCMapping mapping(patch);
436467f5	414
5cccaefd	415	int nTotalChannels=0;
	416	int nSkippedChannels=0;
	417	short lowestOccupancy=-1;
	418	float sumOccupancy=0;
9b4f7f90	419
afa4418c	420	//Here the reading of the data and the zerosuppression takes place
afa4418c	421	while(fDigitReader->NextChannel()){//Pad
a74855c2	422	Int_t row=fDigitReader->GetRow();
a74855c2	423	Int_t pad=fDigitReader->GetPad();
9b4f7f90	424	if(row==1000 \|\| pad==1000){
	425	continue;
	426	}
a74855c2	427	if(row>=fNumberOfRows\|\|row<0){
9b4f7f90	428	continue;
9b4f7f90	429	}
a74855c2	430	else if(pad>=fNumberOfPadsInRow[row]\|\|pad<0){
436467f5	431	continue;
9b4f7f90	432	}
9b4f7f90	433
a74855c2	434	AliHLTTPCPad *tmpPad = fRowPadVector[row][pad];
a74855c2	435	tmpPad->SetDataToDefault();
74b8bf74	436
afa4418c	437	//reading data to pad
	438	while(fDigitReader->NextBunch()){
	439	const UInt_t *bunchData= fDigitReader->GetSignals();
a74855c2	440	Int_t time=fDigitReader->GetTime();
afa4418c	441	for(Int_t i=0;i<fDigitReader->GetBunchSize();i++){
	442	if(bunchData[i]>0){// disregarding 0 data.
	443	if(time+i>=fStartTimeBin && time+i<=fEndTimeBin){
afa4418c	444	tmpPad->SetDataSignal(time+i,bunchData[i]);
	445	}
	446	}
	447	}
	448	}
5cccaefd	449
	450	nTotalChannels++;
	451	if (lowestOccupancy<0 \|\| (unsigned short)lowestOccupancy>tmpPad->GetNAddedSignals())
	452	lowestOccupancy=tmpPad->GetNAddedSignals();
	453	sumOccupancy+=tmpPad->GetNAddedSignals();
	454
a74855c2	455	if(tmpPad->GetNAddedSignals()>=(UInt_t)fMinimumNumberOfSignals){
74b8bf74	456	tmpPad->ZeroSuppress(fNRMSThreshold, fSignalThreshold, fMinimumNumberOfSignals, fStartTimeBin, fEndTimeBin, fLeftTimeBin, fRightTimeBin, fValueBelowAverage, fSkipSendingZSData);
436467f5	457	if(tmpPad->GetNAddedSignals()>0){
5cccaefd	458	assert((int)mapping.GetRow(fDigitReader->GetAltroBlockHWaddr())==row);
5cccaefd	459	assert((int)mapping.GetPad(fDigitReader->GetAltroBlockHWaddr())==pad);
436467f5	460	fHwAddressList.push_back((AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr());
436467f5	461	}
5cccaefd	462	} else {
5cccaefd	463	nSkippedChannels++;
afa4418c	464	}
afa4418c	465	}
5cccaefd	466	if (nSkippedChannels>0) {
	467	HLTWarning("skipped %d of %d channels because of low occupancy: average %.2f, lowest %d, threshold %d",
	468	nSkippedChannels, nTotalChannels, sumOccupancy/nTotalChannels, lowestOccupancy, fMinimumNumberOfSignals);
	469	}
092a1374	470
5cccaefd	471	AliHLTUInt32_t dataOffsetBeforeHW=0;
	472
	473	if(fSkipSendingZSData == kFALSE && iter->fSize>sizeof(AliRawDataHeader)) {
2fdb1ae7	474
436467f5	475	AliHLTAltroEncoder *altroEncoder = new AliHLTAltroEncoder;
5cccaefd	476	altroEncoder->SetBuffer(outputPtr,capacity); //tests if one overwrite the buffer is done in the encoder
	477
	478	// set CDH from the beginning of buffer
	479	altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,sizeof(AliRawDataHeader));
436467f5	480
	481	UChar_t *RCUTrailer=NULL;
	482	Int_t RCUTrailerSize=fDigitReader->GetRCUTrailerSize();
436467f5	483	if (RCUTrailerSize<=0 \|\| !fDigitReader->GetRCUTrailerData( RCUTrailer )) {
	484	if(RCUTrailer==NULL){
	485	HLTWarning("can not find RCU trailer for data block %s 0x%08x: skipping data block",
	486	DataType2Text(iter->fDataType).c_str(), iter->fSpecification);
	487	continue;
092a1374	488	}
afa4418c	489	}
436467f5	490	altroEncoder->SetRCUTrailer(RCUTrailer, RCUTrailerSize);
436467f5	491
5cccaefd	492	for(unsigned int channel=0; channel<fHwAddressList.size(); channel++){
	493	int row=mapping.GetRow(fHwAddressList[channel]);
	494	int pad=mapping.GetPad(fHwAddressList[channel]);
	495	if (true) {
436467f5	496	AliHLTTPCPad * zeroSuppressedPad= fRowPadVector[row][pad];
	497	Int_t currentTime=0;
	498	Int_t bunchSize=0;
	499	if(zeroSuppressedPad->GetNAddedSignals()>0){
	500	while(zeroSuppressedPad->GetNextGoodSignal(currentTime, bunchSize)){
	501	for(Int_t i=0;i<bunchSize;i++){
5cccaefd	502	if (altroEncoder->AddSignal((AliHLTUInt16_t)(zeroSuppressedPad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
	503	// Matthias 01.10.2008: there is a problem with certain real data which produces the same
	504	// bunch multiple times, needs investigation. I found an examplary case in run 53465
	505	// (08000053465011.450.root) equipment 981.
	506	// needs to be followed up.
	507	// addon 02.10.2008 I just corrected a bug concerning the loop over the active channels.
	508	// A double loop over all rows and pads also considered pads which had not even been
	509	// filled, and thus not properly cleaned. Maybe the bug above is related to that.
	510	HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d",
	511	slice, patch, fHwAddressList[channel], row, pad, currentTime+i, bunchSize);
	512	break;
	513	}
436467f5	514	}
436467f5	515	}
5cccaefd	516	altroEncoder->SetChannel(fHwAddressList[channel]);
436467f5	517	}
	518	}
	519	}
092a1374	520
436467f5	521	int sizeOfData=altroEncoder->SetLength();
092a1374	522
436467f5	523	if (sizeOfData<0) {
436467f5	524	HLTError("data encoding failed");
5cccaefd	525	iResult=sizeOfData;
5cccaefd	526	break;
436467f5	527	}
5cccaefd	528	if(sizeOfData>(int)capacity){
	529	HLTWarning("Buffer too small too add the altrodata: %d of %d byte(s) already used", sizeOfData, capacity);
	530	iResult=-ENOSPC;
	531	break;
436467f5	532	}
3789100d	533
436467f5	534	//Push back the zerosuppressed altro data to the output
5cccaefd	535	if(true/* condition was deprecated but keep for the sake of formatting*/){
436467f5	536	AliHLTComponentBlockData bd;
	537	FillBlockData( bd );
	538	bd.fOffset = 0;
	539	bd.fSize = sizeOfData;
	540	bd.fDataType = kAliHLTDataTypeDDLRaw\|kAliHLTDataOriginTPC;
	541	bd.fSpecification = iter->fSpecification;
436467f5	542	outputBlocks.push_back( bd );
3789100d	543
436467f5	544	//Push back the list of hardware addresses to the output
	545	dataOffsetBeforeHW=sizeOfData;
	546	}
5cccaefd	547	}
092a1374	548
5cccaefd	549	AliHLTUInt32_t sizeOfHWArray = 0;
5cccaefd	550	if(fSendHWList == kTRUE){
3789100d	551
5cccaefd	552	if(true/* condition was deprecated but keep for the sake of formatting*/){
436467f5	553	sizeOfHWArray = fHwAddressList.size()*sizeof(AliHLTUInt16_t);
3789100d	554
5cccaefd	555	if(dataOffsetBeforeHW+sizeOfHWArray>capacity){
	556	HLTWarning("Buffer too small too add the active channels: %d of %d byte(s) already used", dataOffsetBeforeHW + sizeOfHWArray, capacity);
	557	iResult=-ENOSPC;
	558	break;
436467f5	559	}
3789100d	560
436467f5	561	AliHLTUInt16_toutputHWPtr=(AliHLTUInt16_t)(outputPtr+dataOffsetBeforeHW);
	562	memcpy(outputHWPtr,&fHwAddressList[0],sizeOfHWArray);
	563	AliHLTComponentBlockData bdHW;
	564	FillBlockData( bdHW );
	565	bdHW.fOffset = dataOffsetBeforeHW;
	566	bdHW.fSize = sizeOfHWArray;
5cccaefd	567	bdHW.fDataType = kAliHLTDataTypeHwAddr16\|kAliHLTDataOriginTPC;
436467f5	568	bdHW.fSpecification = iter->fSpecification;
436467f5	569	outputBlocks.push_back( bdHW );
436467f5	570	}
436467f5	571	}
5cccaefd	572	size = dataOffsetBeforeHW+sizeOfHWArray;
436467f5	573	fDigitReader->Reset();
3789100d	574	}
092a1374	575
5cccaefd	576	if (iResult<0) {
	577	fDigitReader->Reset();
	578	size=0;
	579	}
	580
	581	return iResult;
afa4418c	582	}