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

// $Id$

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
 *                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
 *                  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.                  *
 **************************************************************************/

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// a TPC cluster finder processing component for the HLT                     //
//                                                                           //
// 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 "AliHLTTPCRawDataUnpackerComponent.h"
#include "AliTPCRawStream.h"
#include "AliRawDataHeader.h"
#include "AliRawReaderMemory.h"
#include "AliHLTTPCDigitData.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCDefinitions.h"
#include <cstdlib>
#include <cerrno>

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCRawDataUnpackerComponent);

AliHLTTPCRawDataUnpackerComponent::AliHLTTPCRawDataUnpackerComponent()
  :
  fRawMemoryReader(NULL),
  fTPCRawStream(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
}

AliHLTTPCRawDataUnpackerComponent::~AliHLTTPCRawDataUnpackerComponent()
{
  // see header file for class documentation
}

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

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

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

AliHLTComponentDataType AliHLTTPCRawDataUnpackerComponent::GetOutputDataType()
{
  // see header file for class documentation
  return AliHLTTPCDefinitions::fgkUnpackedRawDataType;
}

void AliHLTTPCRawDataUnpackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
  // see header file for class documentation
  // XXX TODO: Find more realistic values.
  constBase = 0;
  inputMultiplier = 6.0;
}

AliHLTComponent* AliHLTTPCRawDataUnpackerComponent::Spawn()
{
  // see header file for class documentation
  return new AliHLTTPCRawDataUnpackerComponent;
}

int AliHLTTPCRawDataUnpackerComponent::DoInit( int argc, const char** argv )
{
  // see header file for class documentation
  if ( fRawMemoryReader || fTPCRawStream )
    return EINPROGRESS;

  int i = 0;
  //     const char* tableFileBaseDir = NULL;
  while ( i < argc )
    {
      // 	if ( !strcmp( argv[i], "table-dir" ) )
      // 	    {
      // 	    if ( i+1>=argc )
      // 		{
      // 		Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Missing Argument", "Missing -table-dir parameter");
      // 		return ENOTSUP;
      // 		}
      // 	    tableFileBaseDir = argv[i+1];
      // 	    i += 2;
      // 	    continue;
      // 	    }
      Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
      return EINVAL;
    }

  //     if ( !tableFileBaseDir )
  // 	{
  // 	Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Table file directory missing ", 
  // 		"Table file base directory has to be set using the -table-dir component parameter." );
  // 	return EINVAL;
  // 	}

  fRawMemoryReader = new AliRawReaderMemory;
  //fTPCRawStream = new AliTPCRawStream( fRawMemoryReader, tableFileBaseDir );
  fTPCRawStream = new AliTPCRawStream( fRawMemoryReader );
    
  return 0;
}

int AliHLTTPCRawDataUnpackerComponent::DoDeinit()
{
  // see header file for class documentation
  if ( fRawMemoryReader )
    delete fRawMemoryReader;
  fRawMemoryReader = NULL;
  if ( fTPCRawStream )
    delete fTPCRawStream;
  fTPCRawStream = NULL;
  return 0;
}

int AliHLTTPCRawDataUnpackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
					      AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
					      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
  // see header file for class documentation
  const AliHLTComponentBlockData* iter = NULL;
  unsigned long ndx;

  AliHLTUInt8_t* outBPtr;
  AliHLTTPCUnpackedRawData* outPtr;
  AliHLTTPCDigitRowData* currentRow;
  AliHLTTPCDigitData* currentDigit;
  unsigned long long outputSize = 0;
  unsigned long blockOutputSize = 0;
  unsigned long rowSize = 0;
  Int_t slice, patch, rows[2];
  outBPtr = outputPtr;
  outPtr = (AliHLTTPCUnpackedRawData*)outputPtr;
  currentRow = outPtr->fDigits;
  currentDigit = currentRow->fDigitData;
    
  Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Event received", 
	   "Event 0x%08LX (%Lu) received with %lu blocks. Output data size: %lu",
	   evtData.fEventID, evtData.fEventID, evtData.fBlockCnt, size);
  for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
    {
      iter = blocks+ndx;
      if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) )
	{
	  continue;
	}
      slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
      patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
      rows[0] = AliHLTTPCTransform::GetFirstRow( patch );
      rows[1] = AliHLTTPCTransform::GetLastRow( patch );
      blockOutputSize = 0;

      Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Input Raw Packed Data", 
	       "Input: Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
	       slice, patch, rows[0], rows[1] );

      fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
      bool readValue = true;
      readValue = fTPCRawStream->Next();
      int row = -1, oldRow = -1;
      Int_t rowOffset = 0;
      if ( patch >= 2 ) // Outer sector, patches 2, 3, 4, 5
	rowOffset = AliHLTTPCTransform::GetFirstRow( 2 );

      while ( readValue )
	{
	  row = fTPCRawStream->GetRow();
	  if ( row != oldRow )
	    {
	      if ( oldRow!=-1 && rowSize != sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData) )
		{
		  Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Size inconsistency", 
			   "Size inconsistency for row %d data: %lu != %lu (%lu digits).", oldRow, rowSize, 
			   sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData), currentRow->fNDigit );
		}
	      rowSize = 0;
	      if ( size < outputSize+sizeof(AliHLTTPCDigitRowData) )
		{
		  Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Too much data", 
			   "Output data too big, output memory full. Aborting event 0x%08lX (%lu)" , 
			   evtData.fEventID, evtData.fEventID );
		  return 0;
		}
	      currentRow = (AliHLTTPCDigitRowData*)(outBPtr+outputSize);
	      currentDigit = currentRow->fDigitData;
	      currentRow->fRow = row+rowOffset;
	      currentRow->fNDigit = 0;
	      oldRow = row;
	      outputSize += sizeof(AliHLTTPCDigitRowData);
	      blockOutputSize += sizeof(AliHLTTPCDigitRowData);
	      rowSize += sizeof(AliHLTTPCDigitRowData);
	    }
	  if ( size < outputSize+sizeof(AliHLTTPCDigitData) )
	    {
	      Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Too much data", 
		       "Output data too big, output memory full. Aborting event 0x%08lX (%lu)" , 
		       evtData.fEventID, evtData.fEventID );
	      return 0;
	    }
	  currentDigit->fCharge = fTPCRawStream->GetSignal();
	  currentDigit->fPad = fTPCRawStream->GetPad();
	  currentDigit->fTime = fTPCRawStream->GetTime();
	  currentRow->fNDigit++;
	  currentDigit++;
	  outputSize += sizeof(AliHLTTPCDigitData);
	  blockOutputSize += sizeof(AliHLTTPCDigitData);
	  rowSize += sizeof(AliHLTTPCDigitData);
	  readValue = fTPCRawStream->Next();
	}
      if ( oldRow!=-1 && rowSize != sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData) )
	{
	  Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Size inconsistency", 
		   "Size inconsistency for row %d data: %lu != %lu (%lu digits).", oldRow, rowSize, 
		   sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData), currentRow->fNDigit );
	}

      AliHLTComponentBlockData bd;
      FillBlockData( bd );
      bd.fOffset = outputSize-blockOutputSize;
      bd.fSize = blockOutputSize;
      bd.fSpecification = iter->fSpecification;
      Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Event received", 
	       "Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
	       evtData.fEventID, evtData.fEventID, ndx, blockOutputSize, outputSize-blockOutputSize );
      //AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
      outputBlocks.push_back( bd );
    }

    
  size = outputSize;
  return 0;
}
Commit	Line	Data
71d7c760	1	// $Id$
	2
	3	/**************************************************************************
9be2600f	4	* This file is property of and copyright by the ALICE HLT Project *
9be2600f	5	* ALICE Experiment at CERN, All rights reserved. *
71d7c760	6	* *
9be2600f	7	* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
	8	* Timm Steinbeck <timm@kip.uni-heidelberg.de> *
	9	* for The ALICE HLT Project. *
71d7c760	10	* *
	11	* Permission to use, copy, modify and distribute this software and its *
	12	* documentation strictly for non-commercial purposes is hereby granted *
	13	* without fee, provided that the above copyright notice appears in all *
	14	* copies and that both the copyright notice and this permission notice *
	15	* appear in the supporting documentation. The authors make no claims *
	16	* about the suitability of this software for any purpose. It is *
	17	* provided "as is" without express or implied warranty. *
	18	**************************************************************************/
	19
	20	///////////////////////////////////////////////////////////////////////////////
	21	// //
	22	// a TPC cluster finder processing component for the HLT //
	23	// //
e67b0680	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	// //
71d7c760	30	///////////////////////////////////////////////////////////////////////////////
71d7c760	31
e67b0680	32	#if __GNUC__>= 3
71d7c760	33	using namespace std;
	34	#endif
	35
	36	#include "AliHLTTPCRawDataUnpackerComponent.h"
	37	#include "AliTPCRawStream.h"
	38	#include "AliRawDataHeader.h"
	39	#include "AliRawReaderMemory.h"
a6c02c85	40	#include "AliHLTTPCDigitData.h"
a6c02c85	41	#include "AliHLTTPCTransform.h"
e67b0680	42	#include "AliHLTTPCDefinitions.h"
	43	#include <cstdlib>
	44	#include <cerrno>
71d7c760	45
672f8b8c	46	/** ROOT macro for the implementation of ROOT specific class methods */
e67b0680	47	ClassImp(AliHLTTPCRawDataUnpackerComponent);
71d7c760	48
71d7c760	49	AliHLTTPCRawDataUnpackerComponent::AliHLTTPCRawDataUnpackerComponent()
e419b223	50	:
	51	fRawMemoryReader(NULL),
	52	fTPCRawStream(NULL)
	53	{
e67b0680	54	// see header file for class documentation
	55	// or
	56	// refer to README to build package
	57	// or
	58	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
e419b223	59	}
e419b223	60
71d7c760	61	AliHLTTPCRawDataUnpackerComponent::~AliHLTTPCRawDataUnpackerComponent()
e419b223	62	{
e67b0680	63	// see header file for class documentation
e419b223	64	}
71d7c760	65
	66	// Public functions to implement AliHLTComponent's interface.
	67	// These functions are required for the registration process
	68
	69	const char* AliHLTTPCRawDataUnpackerComponent::GetComponentID()
e67b0680	70	{
	71	// see header file for class documentation
	72	return "TPCRawDataUnpacker";
	73	}
71d7c760	74
8ede8717	75	void AliHLTTPCRawDataUnpackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
e67b0680	76	{
	77	// see header file for class documentation
	78	list.clear();
5dcd324a	79	list.push_back( kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC );
e67b0680	80	}
71d7c760	81
8ede8717	82	AliHLTComponentDataType AliHLTTPCRawDataUnpackerComponent::GetOutputDataType()
e67b0680	83	{
	84	// see header file for class documentation
	85	return AliHLTTPCDefinitions::fgkUnpackedRawDataType;
	86	}
71d7c760	87
71d7c760	88	void AliHLTTPCRawDataUnpackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
e67b0680	89	{
	90	// see header file for class documentation
	91	// XXX TODO: Find more realistic values.
	92	constBase = 0;
	93	inputMultiplier = 6.0;
	94	}
71d7c760	95
71d7c760	96	AliHLTComponent* AliHLTTPCRawDataUnpackerComponent::Spawn()
e67b0680	97	{
	98	// see header file for class documentation
	99	return new AliHLTTPCRawDataUnpackerComponent;
	100	}
	101
71d7c760	102	int AliHLTTPCRawDataUnpackerComponent::DoInit( int argc, const char** argv )
e67b0680	103	{
	104	// see header file for class documentation
	105	if ( fRawMemoryReader \|\| fTPCRawStream )
	106	return EINPROGRESS;
71d7c760	107
e67b0680	108	int i = 0;
	109	// const char* tableFileBaseDir = NULL;
	110	while ( i < argc )
	111	{
	112	// if ( !strcmp( argv[i], "table-dir" ) )
	113	// {
	114	// if ( i+1>=argc )
	115	// {
	116	// Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Missing Argument", "Missing -table-dir parameter");
	117	// return ENOTSUP;
	118	// }
	119	// tableFileBaseDir = argv[i+1];
	120	// i += 2;
	121	// continue;
	122	// }
	123	Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
	124	return EINVAL;
	125	}
71d7c760	126
e67b0680	127	// if ( !tableFileBaseDir )
	128	// {
	129	// Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Table file directory missing ",
	130	// "Table file base directory has to be set using the -table-dir component parameter." );
	131	// return EINVAL;
	132	// }
71d7c760	133
e67b0680	134	fRawMemoryReader = new AliRawReaderMemory;
	135	//fTPCRawStream = new AliTPCRawStream( fRawMemoryReader, tableFileBaseDir );
	136	fTPCRawStream = new AliTPCRawStream( fRawMemoryReader );
71d7c760	137
e67b0680	138	return 0;
e67b0680	139	}
71d7c760	140
71d7c760	141	int AliHLTTPCRawDataUnpackerComponent::DoDeinit()
e67b0680	142	{
	143	// see header file for class documentation
	144	if ( fRawMemoryReader )
	145	delete fRawMemoryReader;
	146	fRawMemoryReader = NULL;
	147	if ( fTPCRawStream )
	148	delete fTPCRawStream;
	149	fTPCRawStream = NULL;
	150	return 0;
	151	}
71d7c760	152
8ede8717	153	int AliHLTTPCRawDataUnpackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
5d2abf3b	154	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
8ede8717	155	AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
e67b0680	156	{
	157	// see header file for class documentation
	158	const AliHLTComponentBlockData* iter = NULL;
	159	unsigned long ndx;
71d7c760	160
e67b0680	161	AliHLTUInt8_t* outBPtr;
	162	AliHLTTPCUnpackedRawData* outPtr;
	163	AliHLTTPCDigitRowData* currentRow;
	164	AliHLTTPCDigitData* currentDigit;
	165	unsigned long long outputSize = 0;
	166	unsigned long blockOutputSize = 0;
	167	unsigned long rowSize = 0;
	168	Int_t slice, patch, rows[2];
	169	outBPtr = outputPtr;
	170	outPtr = (AliHLTTPCUnpackedRawData*)outputPtr;
	171	currentRow = outPtr->fDigits;
	172	currentDigit = currentRow->fDigitData;
a6c02c85	173
e67b0680	174	Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Event received",
	175	"Event 0x%08LX (%Lu) received with %lu blocks. Output data size: %lu",
	176	evtData.fEventID, evtData.fEventID, evtData.fBlockCnt, size);
	177	for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
	178	{
	179	iter = blocks+ndx;
5dcd324a	180	if ( iter->fDataType != (kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC) )
71d7c760	181	{
e67b0680	182	continue;
	183	}
	184	slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
	185	patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
	186	rows[0] = AliHLTTPCTransform::GetFirstRow( patch );
	187	rows[1] = AliHLTTPCTransform::GetLastRow( patch );
	188	blockOutputSize = 0;
71d7c760	189
e67b0680	190	Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Input Raw Packed Data",
	191	"Input: Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
	192	slice, patch, rows[0], rows[1] );
a6c02c85	193
e67b0680	194	fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
	195	bool readValue = true;
	196	readValue = fTPCRawStream->Next();
	197	int row = -1, oldRow = -1;
	198	Int_t rowOffset = 0;
	199	if ( patch >= 2 ) // Outer sector, patches 2, 3, 4, 5
	200	rowOffset = AliHLTTPCTransform::GetFirstRow( 2 );
71d7c760	201
e67b0680	202	while ( readValue )
	203	{
	204	row = fTPCRawStream->GetRow();
	205	if ( row != oldRow )
71d7c760	206	{
e67b0680	207	if ( oldRow!=-1 && rowSize != sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData) )
71d7c760	208	{
e67b0680	209	Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Size inconsistency",
	210	"Size inconsistency for row %d data: %lu != %lu (%lu digits).", oldRow, rowSize,
	211	sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData), currentRow->fNDigit );
71d7c760	212	}
e67b0680	213	rowSize = 0;
e67b0680	214	if ( size < outputSize+sizeof(AliHLTTPCDigitRowData) )
71d7c760	215	{
e67b0680	216	Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Too much data",
	217	"Output data too big, output memory full. Aborting event 0x%08lX (%lu)" ,
	218	evtData.fEventID, evtData.fEventID );
	219	return 0;
71d7c760	220	}
e67b0680	221	currentRow = (AliHLTTPCDigitRowData*)(outBPtr+outputSize);
	222	currentDigit = currentRow->fDigitData;
	223	currentRow->fRow = row+rowOffset;
	224	currentRow->fNDigit = 0;
	225	oldRow = row;
	226	outputSize += sizeof(AliHLTTPCDigitRowData);
	227	blockOutputSize += sizeof(AliHLTTPCDigitRowData);
	228	rowSize += sizeof(AliHLTTPCDigitRowData);
71d7c760	229	}
e67b0680	230	if ( size < outputSize+sizeof(AliHLTTPCDigitData) )
71d7c760	231	{
e67b0680	232	Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Too much data",
	233	"Output data too big, output memory full. Aborting event 0x%08lX (%lu)" ,
	234	evtData.fEventID, evtData.fEventID );
	235	return 0;
71d7c760	236	}
e67b0680	237	currentDigit->fCharge = fTPCRawStream->GetSignal();
	238	currentDigit->fPad = fTPCRawStream->GetPad();
	239	currentDigit->fTime = fTPCRawStream->GetTime();
	240	currentRow->fNDigit++;
	241	currentDigit++;
	242	outputSize += sizeof(AliHLTTPCDigitData);
	243	blockOutputSize += sizeof(AliHLTTPCDigitData);
	244	rowSize += sizeof(AliHLTTPCDigitData);
	245	readValue = fTPCRawStream->Next();
	246	}
	247	if ( oldRow!=-1 && rowSize != sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData) )
	248	{
	249	Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Size inconsistency",
	250	"Size inconsistency for row %d data: %lu != %lu (%lu digits).", oldRow, rowSize,
	251	sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData), currentRow->fNDigit );
71d7c760	252	}
71d7c760	253
e67b0680	254	AliHLTComponentBlockData bd;
	255	FillBlockData( bd );
	256	bd.fOffset = outputSize-blockOutputSize;
	257	bd.fSize = blockOutputSize;
	258	bd.fSpecification = iter->fSpecification;
	259	Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Event received",
	260	"Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
	261	evtData.fEventID, evtData.fEventID, ndx, blockOutputSize, outputSize-blockOutputSize );
	262	//AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
	263	outputBlocks.push_back( bd );
71d7c760	264	}
71d7c760	265
e67b0680	266
	267	size = outputSize;
	268	return 0;
	269	}
	270
71d7c760	271