[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHWCFDataReverterComponent.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   AliHLTTPCHWCFDataReverterComponent.cxx
/// @author Kenneth Aamodt
/// @date   
/// @brief  Component for reverting data for the HW clusterfinder
///

// 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 "AliHLTTPCHWCFDataReverterComponent.h"
#include "AliHLTTPCDigitReader32Bit.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(AliHLTTPCHWCFDataReverterComponent)

  AliHLTTPCHWCFDataReverterComponent::AliHLTTPCHWCFDataReverterComponent()
    :
    fDigitReader(NULL),
    fRowPadVector(),
    fNumberOfPadsInRow(NULL),
    fFirstPadHigh(NULL),
    fNumberOfRows(0),
    fCurrentPatch(0),
    fFirstRow(0),
    fLastRow(0),
    fNTimeBins(0),
    fVectorInitialized(kFALSE),
    fMapping(NULL),
    fInterleave(kTRUE)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

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

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

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

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

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

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

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

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

  Int_t i = 0;
  Char_t* cpErr;

  while ( i < argc ) {      

    // -- number of timebins
    if ( !strcmp( argv[i], "-timebins" )) {
      fNTimeBins = strtoul( argv[i+1], &cpErr ,0);
      AliHLTTPCTransform::SetNTimeBins(fNTimeBins);
      if ( *cpErr ) {
	HLTError("Cannot convert ntimebins specifier '%s'.", argv[i+1]);
	return EINVAL;
      }
      i+=2;
      continue;
    }
    // -- number of timebins
    if ( !strcmp( argv[i], "-interleave-off" )) {
      fInterleave = kFALSE;
      i++;
      continue;
    }
     
    HLTError("HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );

    return EINVAL;
  }

  fDigitReader = new AliHLTTPCDigitReader32Bit();

  return 0;
}

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

Int_t AliHLTTPCHWCFDataReverterComponent::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 AliHLTTPCHWCFDataReverterComponent::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];
  fFirstPadHigh= new Int_t[fNumberOfRows];

  memset( fNumberOfPadsInRow, 0, sizeof(Int_t)*(fNumberOfRows));
  memset( fFirstPadHigh, 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();
      if(fFirstPadHigh[i] == 0){
	if(fMapping->GetHwAddress(i,j) > 2047){
	  fFirstPadHigh[i]=j;
	}
      }
      tmpPad->SetID(i,j);
      tmpPad->SetDataToDefault();
      tmpRow.push_back(tmpPad);
    }
    fRowPadVector.push_back(tmpRow);
  }
  fVectorInitialized=kTRUE;
}


int AliHLTTPCHWCFDataReverterComponent::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;

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

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

    if (iter->fSize<=sizeof(AliRawDataHeader)) {
      // forward empty DDLs
      outputBlocks.push_back(*iter);
      continue;
    }

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

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

    if(!fVectorInitialized){
      fCurrentPatch=patch;
      InitializePadArray();
    }

    //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 >= fNumberOfRows || row < 0){
	continue;
      }
      else if(pad >= fNumberOfPadsInRow[row] || pad < 0){
	continue;
      }  
	
      AliHLTTPCPad *tmpPad = fRowPadVector[row][pad];
      if (tmpPad){
	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 >= 0 && time+i < AliHLTTPCTransform::GetNTimeBins()){
	      if (tmpPad){
		tmpPad->SetDataSignal(time+i,bunchData[i]);
	      }
	    }
	  }
	}
      }
    }

    if( iter->fSize > sizeof(AliRawDataHeader )){
  
      AliHLTAltroEncoder *altroEncoder = new AliHLTAltroEncoder;
      altroEncoder->SetUse32BitFormat(kTRUE);
      Int_t ddlno=768;
      if (patch>1) ddlno+=72+4*slice+(patch-2);
      else ddlno+=2*slice+patch;
      altroEncoder->SetDDLid(ddlno);
      altroEncoder->SetSlice(slice);
      altroEncoder->SetPartition(patch);
      
      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(Int_t row = 0; row< fNumberOfRows;row++){

	if(fInterleave == kFALSE){
	  Int_t currentTime = 0;
	  Int_t bunchSize = 0;
	  for(Int_t ipad=0;ipad<fNumberOfPadsInRow[row];ipad++){
	    AliHLTTPCPad * pad = fRowPadVector[row][ipad];
	    if(pad->GetNAddedSignals() > 0){
	      while(pad->GetNextGoodSignal(currentTime, bunchSize)){
		for(Int_t i=bunchSize-1;i>=0;i--){
		  if (altroEncoder->AddSignal((AliHLTUInt16_t)(pad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
		    HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d Charge %d",
			       slice, patch, fMapping->GetHwAddress(row,ipad), row, ipad, currentTime+i, bunchSize,pad->GetDataSignal(currentTime+i));
		    break;
		  }
		}
	      }
	      altroEncoder->SetChannel(fMapping->GetHwAddress(row,ipad));
	      currentTime = 0;
	      bunchSize = 0;
	    }
	  }
	}
	else{
	  Int_t padHigh=fFirstPadHigh[row];
	  
	  Int_t padLowIndex=0;
	  Int_t padHighIndex= padHigh;
	  
	  while(padLowIndex < padHigh || padHighIndex < fNumberOfPadsInRow[row]){
	    Int_t currentTime = 0;
	    Int_t bunchSize = 0;
	    //add the data from low side
	    if(padLowIndex < padHigh){
	      AliHLTTPCPad * lowPad= fRowPadVector[row][padLowIndex];
	      if(lowPad->GetNAddedSignals()>0){
		while(lowPad->GetNextGoodSignal(currentTime, bunchSize)){
		  for(Int_t i=bunchSize-1;i>=0;i--){
		    if (altroEncoder->AddSignal((AliHLTUInt16_t)(lowPad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
		      HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d",
				 slice, patch, fMapping->GetHwAddress(row,padLowIndex), row, padLowIndex, currentTime+i, bunchSize);
		      break;
		    }
		  }
		}
		altroEncoder->SetChannel(fMapping->GetHwAddress(row,padLowIndex));
	      }
	    }
	    currentTime = 0;
	    bunchSize = 0;
	    //add the data from the high side
	    if(padHighIndex < fNumberOfPadsInRow[row]){
	      AliHLTTPCPad * highPad= fRowPadVector[row][padHighIndex];
	      if(highPad->GetNAddedSignals()>0){
		while(highPad->GetNextGoodSignal(currentTime, bunchSize)){
		  for(Int_t i=bunchSize-1;i>=0;i--){
		    if (altroEncoder->AddSignal((AliHLTUInt16_t)(highPad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
		      HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d",
				 slice, patch, fMapping->GetHwAddress(row,padHighIndex), row, padHighIndex, currentTime+i, bunchSize);
		      break;
		    }
		  }
		}
		altroEncoder->SetChannel(fMapping->GetHwAddress(row,padHighIndex));
	      }
	    }
	    padLowIndex++;
	    padHighIndex++;
	  }
	}
      }	
      
      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;
      }

      AliHLTComponentBlockData bd;
      FillBlockData( bd );
      bd.fOffset = 0;
      bd.fSize = sizeOfData;
      bd.fDataType = kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC;
      bd.fSpecification = iter->fSpecification;
      outputBlocks.push_back( bd );

      size+=sizeOfData;
    }
    fDigitReader->Reset();
  }
  
  if(iResult < 0) {
    fDigitReader->Reset();
    size=0;
  }
  HLTDebug("Total size of output is: %d ",size);
  return iResult;
}
Commit	Line	Data
5c15b943	1	// $Id$
	2	//**************************************************************************
	3	//* This file is property of and copyright by the ALICE HLT Project *
	4	//* ALICE Experiment at CERN, All rights reserved. *
	5	//* *
	6	//* Primary Authors: Kenneth Aamodt <Kenneth.Aamodt@student.uib.no> *
	7	//* for The ALICE HLT Project. *
	8	//* *
	9	//* Permission to use, copy, modify and distribute this software and its *
	10	//* documentation strictly for non-commercial purposes is hereby granted *
	11	//* without fee, provided that the above copyright notice appears in all *
	12	//* copies and that both the copyright notice and this permission notice *
	13	//* appear in the supporting documentation. The authors make no claims *
	14	//* about the suitability of this software for any purpose. It is *
	15	//* provided "as is" without express or implied warranty. *
	16	//**************************************************************************
	17
	18	/// @file AliHLTTPCHWCFDataReverterComponent.cxx
	19	/// @author Kenneth Aamodt
	20	/// @date
	21	/// @brief Component for reverting data for the HW clusterfinder
	22	///
a912b63b	23
	24	// see header file for class documentation //
	25	// or //
	26	// refer to README to build package //
	27	// or //
	28	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt //
	29
	30	#if __GNUC__>= 3
	31	using namespace std;
	32	#endif
	33	#include "AliHLTTPCHWCFDataReverterComponent.h"
5c15b943	34	#include "AliHLTTPCDigitReader32Bit.h"
a912b63b	35	#include "AliHLTTPCTransform.h"
	36	#include "AliHLTTPCDefinitions.h"
	37	#include "AliHLTTPCDigitData.h"
	38	#include "AliHLTTPCMapping.h"
	39	#include <cstdlib>
	40	#include <cerrno>
	41	#include <cassert>
	42	#include "TString.h"
	43	#include <sys/time.h>
	44	#include "AliHLTAltroEncoder.h"
	45	#include "AliRawDataHeader.h"
	46
	47	/** ROOT macro for the implementation of ROOT specific class methods */
	48	ClassImp(AliHLTTPCHWCFDataReverterComponent)
	49
	50	AliHLTTPCHWCFDataReverterComponent::AliHLTTPCHWCFDataReverterComponent()
	51	:
	52	fDigitReader(NULL),
	53	fRowPadVector(),
	54	fNumberOfPadsInRow(NULL),
	55	fFirstPadHigh(NULL),
	56	fNumberOfRows(0),
	57	fCurrentPatch(0),
	58	fFirstRow(0),
	59	fLastRow(0),
	60	fNTimeBins(0),
	61	fVectorInitialized(kFALSE),
8e69f9ad	62	fMapping(NULL),
8e69f9ad	63	fInterleave(kTRUE)
a912b63b	64	{
	65	// see header file for class documentation
	66	// or
	67	// refer to README to build package
	68	// or
	69	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	70	}
	71
	72	AliHLTTPCHWCFDataReverterComponent::~AliHLTTPCHWCFDataReverterComponent()
	73	{
	74	// see header file for class documentation
	75	if(fVectorInitialized){
	76	DeInitializePadArray();
	77	}
	78	if(fNumberOfPadsInRow){
	79	delete [] fNumberOfPadsInRow;
	80	fNumberOfPadsInRow=NULL;
	81	}
	82	if(fFirstPadHigh){
	83	delete [] fFirstPadHigh;
	84	fFirstPadHigh=NULL;
	85	}
	86	if(fDigitReader){
	87	delete fDigitReader;
	88	fDigitReader=NULL;
	89	}
	90	if(fMapping){
	91	delete fMapping;
	92	fMapping = NULL;
	93	}
	94	}
	95
	96	// Public functions to implement AliHLTComponent's interface.
	97	// These functions are required for the registration process
	98
	99	const char* AliHLTTPCHWCFDataReverterComponent::GetComponentID()
	100	{
	101	// see header file for class documentation
	102	return "TPCHWCFDataReverter";
	103	}
	104
	105	void AliHLTTPCHWCFDataReverterComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
	106	{
	107	// see header file for class documentation
	108	list.clear();
	109	list.push_back( kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC );
	110	}
	111
	112	AliHLTComponentDataType AliHLTTPCHWCFDataReverterComponent::GetOutputDataType()
	113	{
	114	// see header file for class documentation
	115	return kAliHLTDataTypeDDLRaw;
	116	}
	117
	118	int AliHLTTPCHWCFDataReverterComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
	119	{
	120	// see header file for class documentation
	121	tgtList.clear();
	122	tgtList.push_back(kAliHLTDataTypeDDLRaw);
	123	return tgtList.size();
	124	}
	125
	126	void AliHLTTPCHWCFDataReverterComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
	127	{
128	// see header file for class documentation
129	constBase=0;
130	inputMultiplier=1.0;
131	}
132
133	AliHLTComponent* AliHLTTPCHWCFDataReverterComponent::Spawn()
134	{
135	// see header file for class documentation
136	return new AliHLTTPCHWCFDataReverterComponent();
137	}
138
139	int AliHLTTPCHWCFDataReverterComponent::DoInit( int argc, const char** argv )
140	{
141	// see header file for class documentation
142
143	Int_t i = 0;
144	Char_t* cpErr;
145
146	while ( i < argc ) {
147
148	// -- number of timebins
149	if ( !strcmp( argv[i], "-timebins" )) {
150	fNTimeBins = strtoul( argv[i+1], &cpErr ,0);
151	AliHLTTPCTransform::SetNTimeBins(fNTimeBins);
152	if ( *cpErr ) {
153	HLTError("Cannot convert ntimebins specifier '%s'.", argv[i+1]);
154	return EINVAL;
155	}
156	i+=2;
157	continue;
158	}
8e69f9ad	159	// -- number of timebins
	160	if ( !strcmp( argv[i], "-interleave-off" )) {
	161	fInterleave = kFALSE;
	162	i++;
	163	continue;
	164	}
a912b63b	165
	166	HLTError("HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
	167
	168	return EINVAL;
	169	}
	170
5c15b943	171	fDigitReader = new AliHLTTPCDigitReader32Bit();
a912b63b	172
	173	return 0;
	174	}
	175
	176	int AliHLTTPCHWCFDataReverterComponent::DoDeinit()
	177	{
	178	// see header file for class documentation
	179	return 0;
	180	}
	181
	182	Int_t AliHLTTPCHWCFDataReverterComponent::DeInitializePadArray()
	183	{
	184	// see header file for class documentation
	185	if(fVectorInitialized){
	186	for(Int_t i=0;i<fNumberOfRows;i++){
	187	for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
	188	delete fRowPadVector[i][j];
	189	fRowPadVector[i][j]=NULL;
	190	}
	191	fRowPadVector[i].clear();
	192	}
	193	fRowPadVector.clear();
	194	}
	195	return 1;
	196	}
	197
	198	void AliHLTTPCHWCFDataReverterComponent::InitializePadArray(){
	199	// see header file for class documentation
	200	if(fCurrentPatch>5){
	201	HLTFatal("Patch is not set");
	202	return;
	203	}
	204
	205	fFirstRow = AliHLTTPCTransform::GetFirstRow(fCurrentPatch);
	206	fLastRow = AliHLTTPCTransform::GetLastRow(fCurrentPatch);
	207
	208	fNumberOfRows=fLastRow-fFirstRow+1;
	209	fNumberOfPadsInRow= new Int_t[fNumberOfRows];
	210	fFirstPadHigh= new Int_t[fNumberOfRows];
	211
	212	memset( fNumberOfPadsInRow, 0, sizeof(Int_t)*(fNumberOfRows));
	213	memset( fFirstPadHigh, 0, sizeof(Int_t)*(fNumberOfRows));
	214
	215	for(Int_t i=0;i<fNumberOfRows;i++){
	216	fNumberOfPadsInRow[i]=AliHLTTPCTransform::GetNPads(i+fFirstRow);
	217	AliHLTTPCPadVector tmpRow;
	218	for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
	219	AliHLTTPCPad *tmpPad = new AliHLTTPCPad();
8e69f9ad	220	if(fFirstPadHigh[i] == 0){
a912b63b	221	if(fMapping->GetHwAddress(i,j) > 2047){
	222	fFirstPadHigh[i]=j;
	223	}
	224	}
	225	tmpPad->SetID(i,j);
8e69f9ad	226	tmpPad->SetDataToDefault();
a912b63b	227	tmpRow.push_back(tmpPad);
	228	}
	229	fRowPadVector.push_back(tmpRow);
	230	}
	231	fVectorInitialized=kTRUE;
	232	}
	233
	234
	235	int AliHLTTPCHWCFDataReverterComponent::DoEvent( const AliHLTComponentEventData& evtData,
	236	const AliHLTComponentBlockData* blocks,
	237	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
	238	AliHLTUInt32_t& size,
	239	vector<AliHLTComponentBlockData>& outputBlocks )
	240	{
	241	// see header file for class documentation
	242	int iResult=0;
	243	if (!fDigitReader) return -ENODEV;
	244
	245	AliHLTUInt32_t capacity=size;
	246	size=0;
	247	if (!IsDataEvent()) return 0;
	248
	249	// == init iter (pointer to datablock)
	250	const AliHLTComponentBlockData* iter = NULL;
	251	unsigned long ndx;
	252
	253	//reading the data
	254	for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ){
	255
	256	iter = blocks+ndx;
	257
	258	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	259	evtData.fEventID, evtData.fEventID,
	260	DataType2Text( iter->fDataType).c_str(),
	261	DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	262
	263	if ( iter->fDataType != (kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC)){
	264	continue;
	265	}
	266
	267	if (iter->fSize<=sizeof(AliRawDataHeader)) {
	268	// forward empty DDLs
	269	outputBlocks.push_back(*iter);
	270	continue;
	271	}
	272
	273	UInt_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
	274	UInt_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
	275
	276	if(fDigitReader->InitBlock(iter->fPtr,iter->fSize,patch,slice)<0){
	277	HLTWarning("Decoder failed to initialize, event aborted.");
	278	continue;
	279	}
	280
	281	fMapping = new AliHLTTPCMapping(patch);
	282
	283	if(!fVectorInitialized){
	284	fCurrentPatch=patch;
	285	InitializePadArray();
	286	}
	287
	288	//Here the reading of the data and the zerosuppression takes place
	289	while(fDigitReader->NextChannel()){//Pad
	290
291	Int_t row=fDigitReader->GetRow();
292	Int_t pad=fDigitReader->GetPad();
293
294	if(row >= fNumberOfRows \|\| row < 0){
295	continue;
296	}
297	else if(pad >= fNumberOfPadsInRow[row] \|\| pad < 0){
298	continue;
299	}
300
301	AliHLTTPCPad *tmpPad = fRowPadVector[row][pad];
302	if (tmpPad){
303	tmpPad->SetDataToDefault();
304	}
305
306	//reading data to pad
307	while(fDigitReader->NextBunch()){
308	const UInt_t *bunchData= fDigitReader->GetSignals();
309	Int_t time=fDigitReader->GetTime();
310	for(Int_t i=0;i<fDigitReader->GetBunchSize();i++){
311	if(bunchData[i]>0){// disregarding 0 data.
312	if(time+i >= 0 && time+i < AliHLTTPCTransform::GetNTimeBins()){
313	if (tmpPad){
314	tmpPad->SetDataSignal(time+i,bunchData[i]);
315	}
316	}
317	}
318	}
319	}
320	}
321
322	if( iter->fSize > sizeof(AliRawDataHeader )){
323
324	AliHLTAltroEncoder *altroEncoder = new AliHLTAltroEncoder;
8e69f9ad	325	altroEncoder->SetUse32BitFormat(kTRUE);
	326	Int_t ddlno=768;
	327	if (patch>1) ddlno+=72+4*slice+(patch-2);
	328	else ddlno+=2*slice+patch;
	329	altroEncoder->SetDDLid(ddlno);
	330	altroEncoder->SetSlice(slice);
	331	altroEncoder->SetPartition(patch);
	332
a912b63b	333	altroEncoder->SetBuffer(outputPtr,capacity); //tests if one overwrite the buffer is done in the encoder
	334
	335	// set CDH from the beginning of buffer
	336	altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,sizeof(AliRawDataHeader));
	337
	338	UChar_t *RCUTrailer=NULL;
	339	Int_t RCUTrailerSize=fDigitReader->GetRCUTrailerSize();
	340	if (RCUTrailerSize<=0 \|\| !fDigitReader->GetRCUTrailerData( RCUTrailer )) {
	341	if(RCUTrailer==NULL){
	342	HLTWarning("can not find RCU trailer for data block %s 0x%08x: skipping data block",
	343	DataType2Text(iter->fDataType).c_str(), iter->fSpecification);
	344	continue;
	345	}
	346	}
	347	altroEncoder->SetRCUTrailer(RCUTrailer, RCUTrailerSize);
	348
	349	for(Int_t row = 0; row< fNumberOfRows;row++){
a912b63b	350
8e69f9ad	351	if(fInterleave == kFALSE){
a912b63b	352	Int_t currentTime = 0;
a912b63b	353	Int_t bunchSize = 0;
8e69f9ad	354	for(Int_t ipad=0;ipad<fNumberOfPadsInRow[row];ipad++){
	355	AliHLTTPCPad * pad = fRowPadVector[row][ipad];
	356	if(pad->GetNAddedSignals() > 0){
	357	while(pad->GetNextGoodSignal(currentTime, bunchSize)){
	358	for(Int_t i=bunchSize-1;i>=0;i--){
	359	if (altroEncoder->AddSignal((AliHLTUInt16_t)(pad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
	360	HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d Charge %d",
	361	slice, patch, fMapping->GetHwAddress(row,ipad), row, ipad, currentTime+i, bunchSize,pad->GetDataSignal(currentTime+i));
	362	break;
	363	}
a912b63b	364	}
a912b63b	365	}
8e69f9ad	366	altroEncoder->SetChannel(fMapping->GetHwAddress(row,ipad));
	367	currentTime = 0;
	368	bunchSize = 0;
a912b63b	369	}
a912b63b	370	}
8e69f9ad	371	}
	372	else{
	373	Int_t padHigh=fFirstPadHigh[row];
	374
	375	Int_t padLowIndex=0;
	376	Int_t padHighIndex= padHigh;
	377
	378	while(padLowIndex < padHigh \|\| padHighIndex < fNumberOfPadsInRow[row]){
	379	Int_t currentTime = 0;
	380	Int_t bunchSize = 0;
	381	//add the data from low side
	382	if(padLowIndex < padHigh){
	383	AliHLTTPCPad * lowPad= fRowPadVector[row][padLowIndex];
	384	if(lowPad->GetNAddedSignals()>0){
	385	while(lowPad->GetNextGoodSignal(currentTime, bunchSize)){
	386	for(Int_t i=bunchSize-1;i>=0;i--){
	387	if (altroEncoder->AddSignal((AliHLTUInt16_t)(lowPad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
	388	HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d",
	389	slice, patch, fMapping->GetHwAddress(row,padLowIndex), row, padLowIndex, currentTime+i, bunchSize);
	390	break;
	391	}
	392	}
a912b63b	393	}
8e69f9ad	394	altroEncoder->SetChannel(fMapping->GetHwAddress(row,padLowIndex));
a912b63b	395	}
a912b63b	396	}
8e69f9ad	397	currentTime = 0;
	398	bunchSize = 0;
	399	//add the data from the high side
	400	if(padHighIndex < fNumberOfPadsInRow[row]){
	401	AliHLTTPCPad * highPad= fRowPadVector[row][padHighIndex];
	402	if(highPad->GetNAddedSignals()>0){
	403	while(highPad->GetNextGoodSignal(currentTime, bunchSize)){
	404	for(Int_t i=bunchSize-1;i>=0;i--){
	405	if (altroEncoder->AddSignal((AliHLTUInt16_t)(highPad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
	406	HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d",
	407	slice, patch, fMapping->GetHwAddress(row,padHighIndex), row, padHighIndex, currentTime+i, bunchSize);
	408	break;
	409	}
	410	}
	411	}
866de50e	412	altroEncoder->SetChannel(fMapping->GetHwAddress(row,padHighIndex));
8e69f9ad	413	}
8e69f9ad	414	}
	415	padLowIndex++;
	416	padHighIndex++;
a912b63b	417	}
a912b63b	418	}
8e69f9ad	419	}
8e69f9ad	420
a912b63b	421	int sizeOfData=altroEncoder->SetLength();
8e69f9ad	422
a912b63b	423
	424	if (sizeOfData<0) {
	425	HLTError("data encoding failed");
	426	iResult=sizeOfData;
	427	break;
	428	}
	429	if(sizeOfData>(int)capacity){
	430	HLTWarning("Buffer too small too add the altrodata: %d of %d byte(s) already used", sizeOfData, capacity);
	431	iResult=-ENOSPC;
	432	break;
	433	}
	434
	435	AliHLTComponentBlockData bd;
	436	FillBlockData( bd );
	437	bd.fOffset = 0;
	438	bd.fSize = sizeOfData;
	439	bd.fDataType = kAliHLTDataTypeDDLRaw\|kAliHLTDataOriginTPC;
	440	bd.fSpecification = iter->fSpecification;
	441	outputBlocks.push_back( bd );
	442
	443	size+=sizeOfData;
	444	}
	445	fDigitReader->Reset();
	446	}
	447
	448	if(iResult < 0) {
	449	fDigitReader->Reset();
	450	size=0;
	451	}
	452	HLTDebug("Total size of output is: %d ",size);
	453	return iResult;
	454	}