[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHWCFDataReverterComponent.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   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 "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(AliHLTTPCHWCFDataReverterComponent)

  AliHLTTPCHWCFDataReverterComponent::AliHLTTPCHWCFDataReverterComponent()
    :
    fDigitReader(NULL),
    fRowPadVector(),
    fNumberOfPadsInRow(NULL),
    fFirstPadHigh(NULL),
    fNumberOfRows(0),
    fCurrentPatch(0),
    fFirstRow(0),
    fLastRow(0),
    fNTimeBins(0),
    fVectorInitialized(kFALSE),
    fMapping(NULL)
{
  // 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;
    }
     
    HLTError("HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );

    return EINVAL;
  }

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

  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);
      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->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++){
	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];
	    while(lowPad->GetNextGoodSignal(currentTime, bunchSize)){
	      for(Int_t i=0;i<bunchSize;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];
	    while(highPad->GetNextGoodSignal(currentTime, bunchSize)){
	      for(Int_t i=0;i<bunchSize;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++;
	}
      }
	
      altroEncoder->Revert40BitWords(sizeof(AliRawDataHeader),RCUTrailerSize);

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