When Pt is bad defined (ex. no field), the multiple scattering effect is calculated...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCZeroSuppressionComponent.cxx
CommitLineData
10f165dc 1// $Id$
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
32using 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>
41#include <cerrno>
5cccaefd 42#include <cassert>
afa4418c 43#include "TString.h"
44#include <sys/time.h>
092a1374 45#include "AliHLTAltroEncoder.h"
46#include "AliRawDataHeader.h"
a74855c2 47
afa4418c 48/** ROOT macro for the implementation of ROOT specific class methods */
49ClassImp(AliHLTTPCZeroSuppressionComponent)
50
51AliHLTTPCZeroSuppressionComponent::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),
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),
70 fLeftTimeBin(5),
a74855c2 71 fRightTimeBin(5),
72 fGetActivePads(kFALSE),
3789100d 73 fSkipSendingZSData(kFALSE),
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
84AliHLTTPCZeroSuppressionComponent::~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
103const char* AliHLTTPCZeroSuppressionComponent::GetComponentID()
104{
105 // see header file for class documentation
106 return "TPCZeroSuppression";
107}
108
109void AliHLTTPCZeroSuppressionComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
110{
111 // see header file for class documentation
112 list.clear();
113 list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
114}
115
116AliHLTComponentDataType AliHLTTPCZeroSuppressionComponent::GetOutputDataType()
117{
118 // see header file for class documentation
092a1374 119 return kAliHLTMultipleDataType;
120 //return kAliHLTDataTypeDDLRaw;
121 // return AliHLTTPCDefinitions::fgkUnpackedRawDataType;
afa4418c 122}
123
124int AliHLTTPCZeroSuppressionComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
125{
126 // see header file for class documentation
127 tgtList.clear();
092a1374 128 tgtList.push_back(kAliHLTDataTypeDDLRaw);
129 tgtList.push_back(kAliHLTDataTypeHwAddr16);
afa4418c 130 return tgtList.size();
131}
132
133void 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
140AliHLTComponent* AliHLTTPCZeroSuppressionComponent::Spawn()
141{
142 // see header file for class documentation
143 return new AliHLTTPCZeroSuppressionComponent();
144}
145
146int 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
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++;
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++;
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();
310
afa4418c 311 return 0;
312}
313
314int AliHLTTPCZeroSuppressionComponent::DoDeinit()
315{
316 // see header file for class documentation
afa4418c 317 return 0;
318}
319
320Int_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
336void 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
365int 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
6b277aa1 401 if (iter->fSize<=sizeof(AliRawDataHeader)) {
402 // forward empty DDLs and create empty HW list
403 outputBlocks.push_back(*iter);
404 if(fSendHWList == kTRUE){
405 AliHLTComponentBlockData bd;
406 FillBlockData( bd );
407 bd.fOffset = 0;
408 bd.fSize = 0;
409 bd.fDataType = kAliHLTDataTypeHwAddr16|kAliHLTDataOriginTPC;
410 bd.fSpecification = iter->fSpecification;
411 outputBlocks.push_back( bd );
412 }
413 continue;
414 }
415
afa4418c 416 UInt_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
417 UInt_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
418
6b277aa1 419 if(!fVectorInitialized && !fSkipSendingZSData){
afa4418c 420 fCurrentPatch=patch;
421 InitializePadArray();
422 }
423
436467f5 424 if(fDigitReader->InitBlock(iter->fPtr,iter->fSize,patch,slice)<0){
425 HLTWarning("Decoder failed to initialize, event aborted.");
426 continue;
427 }
5cccaefd 428 AliHLTTPCMapping mapping(patch);
436467f5 429
5cccaefd 430 int nTotalChannels=0;
431 int nSkippedChannels=0;
432 short lowestOccupancy=-1;
433 float sumOccupancy=0;
9b4f7f90 434
afa4418c 435 //Here the reading of the data and the zerosuppression takes place
436 while(fDigitReader->NextChannel()){//Pad
1d7dab5e 437 int sumSignals=0;
438 int maxSignal=0;
439 int nofSignals=0;
a74855c2 440 Int_t row=fDigitReader->GetRow();
441 Int_t pad=fDigitReader->GetPad();
9b4f7f90 442 if(row==1000 || pad==1000){
443 continue;
444 }
9d5f00ad 445 if(!fSkipSendingZSData && (row>=fNumberOfRows||row<0)){
9b4f7f90 446 continue;
447 }
9d5f00ad 448 else if(!fSkipSendingZSData && (pad>=fNumberOfPadsInRow[row]||pad<0)){
436467f5 449 continue;
9b4f7f90 450 }
9b4f7f90 451
1d7dab5e 452 AliHLTTPCPad *tmpPad = NULL;
453 if (!fSkipSendingZSData) tmpPad=fRowPadVector[row][pad];
454 if (tmpPad) tmpPad->SetDataToDefault();
74b8bf74 455
afa4418c 456 //reading data to pad
457 while(fDigitReader->NextBunch()){
458 const UInt_t *bunchData= fDigitReader->GetSignals();
a74855c2 459 Int_t time=fDigitReader->GetTime();
afa4418c 460 for(Int_t i=0;i<fDigitReader->GetBunchSize();i++){
461 if(bunchData[i]>0){// disregarding 0 data.
462 if(time+i>=fStartTimeBin && time+i<=fEndTimeBin){
1d7dab5e 463 if (tmpPad) tmpPad->SetDataSignal(time+i,bunchData[i]);
464 sumSignals+=bunchData[i];
465 if (maxSignal<(int)bunchData[i]) maxSignal=bunchData[i];
466 nofSignals++;
afa4418c 467 }
468 }
469 }
470 }
5cccaefd 471
472 nTotalChannels++;
1d7dab5e 473 if (lowestOccupancy<0 || lowestOccupancy>nofSignals)
474 lowestOccupancy=nofSignals;
475 sumOccupancy+=nofSignals;
5cccaefd 476
1d7dab5e 477 if(nofSignals>=fMinimumNumberOfSignals){
478 if (tmpPad) {
74b8bf74 479 tmpPad->ZeroSuppress(fNRMSThreshold, fSignalThreshold, fMinimumNumberOfSignals, fStartTimeBin, fEndTimeBin, fLeftTimeBin, fRightTimeBin, fValueBelowAverage, fSkipSendingZSData);
436467f5 480 if(tmpPad->GetNAddedSignals()>0){
5cccaefd 481 assert((int)mapping.GetRow(fDigitReader->GetAltroBlockHWaddr())==row);
482 assert((int)mapping.GetPad(fDigitReader->GetAltroBlockHWaddr())==pad);
436467f5 483 fHwAddressList.push_back((AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr());
484 }
1d7dab5e 485 } else {
486 assert(fSkipSendingZSData);
487 if (nofSignals>0 && maxSignal>(sumSignals/nofSignals)+fSignalThreshold) {
488 fHwAddressList.push_back((AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr());
489 }
490 }
5cccaefd 491 } else {
492 nSkippedChannels++;
afa4418c 493 }
494 }
5cccaefd 495 if (nSkippedChannels>0) {
496 HLTWarning("skipped %d of %d channels because of low occupancy: average %.2f, lowest %d, threshold %d",
497 nSkippedChannels, nTotalChannels, sumOccupancy/nTotalChannels, lowestOccupancy, fMinimumNumberOfSignals);
498 }
092a1374 499
5cccaefd 500 AliHLTUInt32_t dataOffsetBeforeHW=0;
501
502 if(fSkipSendingZSData == kFALSE && iter->fSize>sizeof(AliRawDataHeader)) {
2fdb1ae7 503
436467f5 504 AliHLTAltroEncoder *altroEncoder = new AliHLTAltroEncoder;
5cccaefd 505 altroEncoder->SetBuffer(outputPtr,capacity); //tests if one overwrite the buffer is done in the encoder
506
507 // set CDH from the beginning of buffer
508 altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,sizeof(AliRawDataHeader));
436467f5 509
510 UChar_t *RCUTrailer=NULL;
511 Int_t RCUTrailerSize=fDigitReader->GetRCUTrailerSize();
436467f5 512 if (RCUTrailerSize<=0 || !fDigitReader->GetRCUTrailerData( RCUTrailer )) {
513 if(RCUTrailer==NULL){
514 HLTWarning("can not find RCU trailer for data block %s 0x%08x: skipping data block",
515 DataType2Text(iter->fDataType).c_str(), iter->fSpecification);
516 continue;
092a1374 517 }
afa4418c 518 }
436467f5 519 altroEncoder->SetRCUTrailer(RCUTrailer, RCUTrailerSize);
520
5cccaefd 521 for(unsigned int channel=0; channel<fHwAddressList.size(); channel++){
522 int row=mapping.GetRow(fHwAddressList[channel]);
523 int pad=mapping.GetPad(fHwAddressList[channel]);
524 if (true) {
436467f5 525 AliHLTTPCPad * zeroSuppressedPad= fRowPadVector[row][pad];
526 Int_t currentTime=0;
527 Int_t bunchSize=0;
528 if(zeroSuppressedPad->GetNAddedSignals()>0){
529 while(zeroSuppressedPad->GetNextGoodSignal(currentTime, bunchSize)){
530 for(Int_t i=0;i<bunchSize;i++){
5cccaefd 531 if (altroEncoder->AddSignal((AliHLTUInt16_t)(zeroSuppressedPad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i))<0) {
532 // Matthias 01.10.2008: there is a problem with certain real data which produces the same
533 // bunch multiple times, needs investigation. I found an examplary case in run 53465
534 // (08000053465011.450.root) equipment 981.
535 // needs to be followed up.
536 // addon 02.10.2008 I just corrected a bug concerning the loop over the active channels.
537 // A double loop over all rows and pads also considered pads which had not even been
538 // filled, and thus not properly cleaned. Maybe the bug above is related to that.
539 HLTWarning("can not add channel: slice %d, partition %d, hw address %d, row %d, pad %d, time %d, bunch size %d",
540 slice, patch, fHwAddressList[channel], row, pad, currentTime+i, bunchSize);
541 break;
542 }
436467f5 543 }
544 }
5cccaefd 545 altroEncoder->SetChannel(fHwAddressList[channel]);
436467f5 546 }
547 }
548 }
092a1374 549
436467f5 550 int sizeOfData=altroEncoder->SetLength();
092a1374 551
436467f5 552 if (sizeOfData<0) {
553 HLTError("data encoding failed");
5cccaefd 554 iResult=sizeOfData;
555 break;
436467f5 556 }
5cccaefd 557 if(sizeOfData>(int)capacity){
558 HLTWarning("Buffer too small too add the altrodata: %d of %d byte(s) already used", sizeOfData, capacity);
559 iResult=-ENOSPC;
560 break;
436467f5 561 }
3789100d 562
436467f5 563 //Push back the zerosuppressed altro data to the output
5cccaefd 564 if(true/* condition was deprecated but keep for the sake of formatting*/){
436467f5 565 AliHLTComponentBlockData bd;
566 FillBlockData( bd );
567 bd.fOffset = 0;
568 bd.fSize = sizeOfData;
569 bd.fDataType = kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC;
570 bd.fSpecification = iter->fSpecification;
436467f5 571 outputBlocks.push_back( bd );
3789100d 572
436467f5 573 //Push back the list of hardware addresses to the output
574 dataOffsetBeforeHW=sizeOfData;
575 }
5cccaefd 576 }
092a1374 577
5cccaefd 578 AliHLTUInt32_t sizeOfHWArray = 0;
579 if(fSendHWList == kTRUE){
3789100d 580
5cccaefd 581 if(true/* condition was deprecated but keep for the sake of formatting*/){
436467f5 582 sizeOfHWArray = fHwAddressList.size()*sizeof(AliHLTUInt16_t);
3789100d 583
5cccaefd 584 if(dataOffsetBeforeHW+sizeOfHWArray>capacity){
585 HLTWarning("Buffer too small too add the active channels: %d of %d byte(s) already used", dataOffsetBeforeHW + sizeOfHWArray, capacity);
586 iResult=-ENOSPC;
587 break;
436467f5 588 }
3789100d 589
436467f5 590 AliHLTUInt16_t*outputHWPtr=(AliHLTUInt16_t*)(outputPtr+dataOffsetBeforeHW);
591 memcpy(outputHWPtr,&fHwAddressList[0],sizeOfHWArray);
592 AliHLTComponentBlockData bdHW;
593 FillBlockData( bdHW );
594 bdHW.fOffset = dataOffsetBeforeHW;
595 bdHW.fSize = sizeOfHWArray;
5cccaefd 596 bdHW.fDataType = kAliHLTDataTypeHwAddr16|kAliHLTDataOriginTPC;
436467f5 597 bdHW.fSpecification = iter->fSpecification;
436467f5 598 outputBlocks.push_back( bdHW );
599 }
436467f5 600 }
5cccaefd 601 size = dataOffsetBeforeHW+sizeOfHWArray;
436467f5 602 fDigitReader->Reset();
3789100d 603 }
092a1374 604
5cccaefd 605 if (iResult<0) {
606 fDigitReader->Reset();
607 size=0;
608 }
609
610 return iResult;
afa4418c 611}