ALIROOT-5433 Transition to CDHv3 in HLT
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHWCFDataReverterComponent.cxx
CommitLineData
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
a912b63b 30#include "AliHLTTPCHWCFDataReverterComponent.h"
5c15b943 31#include "AliHLTTPCDigitReader32Bit.h"
a912b63b 32#include "AliHLTTPCTransform.h"
33#include "AliHLTTPCDefinitions.h"
34#include "AliHLTTPCDigitData.h"
35#include "AliHLTTPCMapping.h"
36#include <cstdlib>
37#include <cerrno>
38#include <cassert>
39#include "TString.h"
40#include <sys/time.h>
41#include "AliHLTAltroEncoder.h"
16e6f752 42#include "AliHLTCDHWrapper.h"
a912b63b 43
d5cf9283 44using namespace std;
45
a912b63b 46/** ROOT macro for the implementation of ROOT specific class methods */
47ClassImp(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),
8e69f9ad 61 fMapping(NULL),
62 fInterleave(kTRUE)
a912b63b 63{
64 // see header file for class documentation
65 // or
66 // refer to README to build package
67 // or
68 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
69}
70
71AliHLTTPCHWCFDataReverterComponent::~AliHLTTPCHWCFDataReverterComponent()
72{
73 // see header file for class documentation
74 if(fVectorInitialized){
75 DeInitializePadArray();
76 }
77 if(fNumberOfPadsInRow){
78 delete [] fNumberOfPadsInRow;
79 fNumberOfPadsInRow=NULL;
80 }
81 if(fFirstPadHigh){
82 delete [] fFirstPadHigh;
83 fFirstPadHigh=NULL;
84 }
85 if(fDigitReader){
86 delete fDigitReader;
87 fDigitReader=NULL;
88 }
89 if(fMapping){
90 delete fMapping;
91 fMapping = NULL;
92 }
93}
94
95// Public functions to implement AliHLTComponent's interface.
96// These functions are required for the registration process
97
98const char* AliHLTTPCHWCFDataReverterComponent::GetComponentID()
99{
100 // see header file for class documentation
101 return "TPCHWCFDataReverter";
102}
103
104void AliHLTTPCHWCFDataReverterComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
105{
106 // see header file for class documentation
107 list.clear();
108 list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
109}
110
111AliHLTComponentDataType AliHLTTPCHWCFDataReverterComponent::GetOutputDataType()
112{
113 // see header file for class documentation
114 return kAliHLTDataTypeDDLRaw;
115}
116
117int AliHLTTPCHWCFDataReverterComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
118{
119 // see header file for class documentation
120 tgtList.clear();
121 tgtList.push_back(kAliHLTDataTypeDDLRaw);
122 return tgtList.size();
123}
124
125void AliHLTTPCHWCFDataReverterComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
126{
127 // see header file for class documentation
128 constBase=0;
129 inputMultiplier=1.0;
130}
131
132AliHLTComponent* AliHLTTPCHWCFDataReverterComponent::Spawn()
133{
134 // see header file for class documentation
135 return new AliHLTTPCHWCFDataReverterComponent();
136}
137
138int AliHLTTPCHWCFDataReverterComponent::DoInit( int argc, const char** argv )
139{
140 // see header file for class documentation
141
142 Int_t i = 0;
143 Char_t* cpErr;
144
145 while ( i < argc ) {
146
147 // -- number of timebins
148 if ( !strcmp( argv[i], "-timebins" )) {
149 fNTimeBins = strtoul( argv[i+1], &cpErr ,0);
150 AliHLTTPCTransform::SetNTimeBins(fNTimeBins);
151 if ( *cpErr ) {
152 HLTError("Cannot convert ntimebins specifier '%s'.", argv[i+1]);
153 return EINVAL;
154 }
155 i+=2;
156 continue;
157 }
8e69f9ad 158 // -- number of timebins
159 if ( !strcmp( argv[i], "-interleave-off" )) {
160 fInterleave = kFALSE;
161 i++;
162 continue;
163 }
a912b63b 164
165 HLTError("HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
166
167 return EINVAL;
168 }
169
5c15b943 170 fDigitReader = new AliHLTTPCDigitReader32Bit();
a912b63b 171
172 return 0;
173}
174
175int AliHLTTPCHWCFDataReverterComponent::DoDeinit()
176{
177 // see header file for class documentation
178 return 0;
179}
180
181Int_t AliHLTTPCHWCFDataReverterComponent::DeInitializePadArray()
182{
183 // see header file for class documentation
184 if(fVectorInitialized){
185 for(Int_t i=0;i<fNumberOfRows;i++){
186 for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
187 delete fRowPadVector[i][j];
188 fRowPadVector[i][j]=NULL;
189 }
190 fRowPadVector[i].clear();
191 }
192 fRowPadVector.clear();
193 }
194 return 1;
195}
196
197void AliHLTTPCHWCFDataReverterComponent::InitializePadArray(){
198 // see header file for class documentation
199 if(fCurrentPatch>5){
200 HLTFatal("Patch is not set");
201 return;
202 }
203
204 fFirstRow = AliHLTTPCTransform::GetFirstRow(fCurrentPatch);
205 fLastRow = AliHLTTPCTransform::GetLastRow(fCurrentPatch);
206
207 fNumberOfRows=fLastRow-fFirstRow+1;
208 fNumberOfPadsInRow= new Int_t[fNumberOfRows];
209 fFirstPadHigh= new Int_t[fNumberOfRows];
210
211 memset( fNumberOfPadsInRow, 0, sizeof(Int_t)*(fNumberOfRows));
212 memset( fFirstPadHigh, 0, sizeof(Int_t)*(fNumberOfRows));
213
214 for(Int_t i=0;i<fNumberOfRows;i++){
215 fNumberOfPadsInRow[i]=AliHLTTPCTransform::GetNPads(i+fFirstRow);
216 AliHLTTPCPadVector tmpRow;
217 for(Int_t j=0;j<fNumberOfPadsInRow[i];j++){
218 AliHLTTPCPad *tmpPad = new AliHLTTPCPad();
8e69f9ad 219 if(fFirstPadHigh[i] == 0){
a912b63b 220 if(fMapping->GetHwAddress(i,j) > 2047){
221 fFirstPadHigh[i]=j;
222 }
223 }
224 tmpPad->SetID(i,j);
8e69f9ad 225 tmpPad->SetDataToDefault();
a912b63b 226 tmpRow.push_back(tmpPad);
227 }
228 fRowPadVector.push_back(tmpRow);
229 }
230 fVectorInitialized=kTRUE;
231}
232
233
234int AliHLTTPCHWCFDataReverterComponent::DoEvent( const AliHLTComponentEventData& evtData,
235 const AliHLTComponentBlockData* blocks,
236 AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
237 AliHLTUInt32_t& size,
238 vector<AliHLTComponentBlockData>& outputBlocks )
239{
240 // see header file for class documentation
241 int iResult=0;
242 if (!fDigitReader) return -ENODEV;
243
244 AliHLTUInt32_t capacity=size;
245 size=0;
246 if (!IsDataEvent()) return 0;
247
248 // == init iter (pointer to datablock)
249 const AliHLTComponentBlockData* iter = NULL;
250 unsigned long ndx;
251
252 //reading the data
253 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ){
254
255 iter = blocks+ndx;
256
257 HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
258 evtData.fEventID, evtData.fEventID,
259 DataType2Text( iter->fDataType).c_str(),
260 DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
261
262 if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC)){
263 continue;
264 }
265
16e6f752 266 AliHLTCDHWrapper header(iter->fPtr);
267 if (iter->fSize<=header.GetHeaderSize()) {
a912b63b 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
16e6f752 322 if( iter->fSize > header.GetHeaderSize()){
a912b63b 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
16e6f752 336 altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,header.GetHeaderSize());
a912b63b 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;
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 }
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 }
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 }
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}