[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDClusterizerComponent.cxx

// $Id$

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
 *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
 *          for The ALICE Off-line 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   AliHLTTRDClusterizerComponent.cxx
    @author Timm Steinbeck, Matthias Richter
    @date   
    @brief  A TRDClusterizer processing component for the HLT. */

#if __GNUC__ >= 3
using namespace std;
#endif

#include "AliHLTTRDClusterizerComponent.h"
#include "AliHLTTRDDefinitions.h"

#include "AliCDBManager.h"
#include "AliTRDclusterizerV1HLT.h"
#include "AliRawReaderMemory.h"

#include "TTree.h"
#include "TBranch.h"

#include <cstdlib>
#include <cerrno>
#include <string>

// this is a global object used for automatic component registration, do not use this
AliHLTTRDClusterizerComponent gAliHLTTRDClusterizerComponent;

ClassImp(AliHLTTRDClusterizerComponent)
    
  AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent()
{
  fOutputPercentage = 100; // By default we copy to the output exactly what we got as input
  
}

AliHLTTRDClusterizerComponent::~AliHLTTRDClusterizerComponent()
{
}

const char* AliHLTTRDClusterizerComponent::GetComponentID()
{
  return "TRDClusterizer"; // The ID of this component
}

void AliHLTTRDClusterizerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
{
  list.clear(); // We do not have any requirements for our input data type(s).
  list.push_back( AliHLTTRDDefinitions::gkDDLRawDataType );
}

AliHLTComponent_DataType AliHLTTRDClusterizerComponent::GetOutputDataType()
{
  return AliHLTTRDDefinitions::gkClusterDataType;
}

void AliHLTTRDClusterizerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
  constBase = 0;
  inputMultiplier = ((double)fOutputPercentage)/100.0;
}


// Spawn function, return new instance of this class
AliHLTComponent* AliHLTTRDClusterizerComponent::Spawn()
{
  return new AliHLTTRDClusterizerComponent;
};

int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
{
  // perform initialization. We check whether our relative output size is specified in the arguments.
  fOutputPercentage = 100;
  Int_t fRawDataVersion = 2;
  int i = 0;
  char* cpErr;
  while ( i < argc )
    {
      Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoInit", "Arguments", "argv[%d] == %s", i, argv[i] );
      if ( !strcmp( argv[i], "output_percentage" ) )
	{
	  if ( i+1>=argc )
	    {
	      Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing output_percentage parameter");
	      return ENOTSUP;
	    }
	  Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoInit", "Arguments", "argv[%d+1] == %s", i, argv[i+1] );
	  fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
	  if ( *cpErr )
	    {
	      Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Wrong Argument", "Cannot convert output_percentage parameter '%s'", argv[i+1] );
	      return EINVAL;
	    }
	  Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
	  i += 2;
	  continue;
	}

      if ( strcmp( argv[i], "-cdb" ) == 0)
	{
	  if ( i+1 >= argc )
	    {
	      Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing -cdb argument");
	      return ENOTSUP;	      
	    }
	  fStrorageDBpath = argv[i+1];
	  Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "DB storage set", "DB storage is %s", fStrorageDBpath.c_str() );	  
	  i += 2;
	  continue;
	}      

      if ( strcmp( argv[i], "-rawver" ) == 0)
	{
	  if ( i+1 >= argc )
	    {
	      Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing -rawver argument");
	      return ENOTSUP;	      
	    }
	  fRawDataVersion = atoi( argv[i+1] );
	  Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "Raw Data", "Version is %d", fRawDataVersion );	  
	  i += 2;
	  continue;
	}      

      Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
      return EINVAL;
    }

  cdb = AliCDBManager::Instance();
  if (!cdb)
    {
      Logging(kHLTLogError, "HLT::TRDCalibration::DoInit", "Could not get CDB instance", "cdb 0x%x", cdb);
    }
  else
    {
      cdb->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
      cdb->SetDefaultStorage(fStrorageDBpath.c_str());
      Logging(kHLTLogDebug, "HLT::TRDCalibration::DoInit", "CDB instance", "cdb 0x%x", cdb);
    }

  rmem = new AliRawReaderMemory;
  clusterizer = new AliTRDclusterizerV1HLT("TRDCclusterizer", "TRDCclusterizer");
  clusterizer->SetRawDataVersion(fRawDataVersion);
  clusterizer->InitClusterTree();
  return 0;
}

int AliHLTTRDClusterizerComponent::DoDeinit()
{
  delete rmem;
  rmem = 0;
  delete clusterizer;
  clusterizer = 0;
  return 0;

  if (cdb)
    {
      Logging( kHLTLogDebug, "HLT::TRDCalibration::DoDeinit", "destroy", "cdb");
      cdb->Destroy();
      cdb = 0;
    }
}

int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
					    AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
					    AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
{
  Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
  Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "BLOCKS", "NofBlocks %lu", evtData.fBlockCnt );
  // Process an event
  unsigned long totalSize = 0;
  AliHLTUInt32_t fDblock_Specification = 0;

  // Loop over all input blocks in the event
  for ( unsigned long i = 0; i < evtData.fBlockCnt; i++ )
    {
      char tmp1[14], tmp2[14];
      DataType2Text( blocks[i].fDataType, tmp1 );
      DataType2Text( AliHLTTRDDefinitions::gkDDLRawDataType, tmp2 );      
      Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoEvent", "Event received", 
	       "Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	       evtData.fEventID, evtData.fEventID, tmp1, tmp2 );

      if ( blocks[i].fDataType != AliHLTTRDDefinitions::gkDDLRawDataType ) 
	{
 	  Logging (kHLTLogError, "HLT::TRDClusterizer::DoEvent", "COMPARE FAILED", "type=%d is type=%d",
 		   blocks[i].fDataType, AliHLTTRDDefinitions::gkDDLRawDataType);
	  continue;
	}
      fDblock_Specification = blocks[i].fSpecification;
      unsigned long blockSize = blocks[i].fSize;
      totalSize += blockSize;
    }

  void *memBufIn = calloc(totalSize, 1);
  AliHLTUInt8_t *pBuf = (AliHLTUInt8_t *)memBufIn;
  if (memBufIn == NULL)
    {
      Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "MEMORY", "Unable to allocate %lu bytes", totalSize);
      return -1;
    }

  // Make the memory continuous
  unsigned long copied = 0;
  for ( unsigned long i = 0; i < evtData.fBlockCnt; i++ )
    {
      if ( blocks[i].fDataType != AliHLTTRDDefinitions::gkDDLRawDataType ) 
	continue;

      void *pos = (void*)(pBuf + copied);
      void *copyret = memcpy(pos, blocks[i].fPtr, blocks[i].fSize);
      if (copyret < 0)
	{
	  Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "MEMORY", "Unable to copy %lu bytes", blocks[i].fSize);
	  return -1;
	}
      copied += blocks[i].fSize;
    }

  Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COPY STATS", "total=%lu copied=%lu", totalSize, copied);

  rmem->Reset();
  rmem->SetMemory((UChar_t*)memBufIn, totalSize);
  //rmem->Reset();
  Bool_t ihead = rmem->ReadHeader();
  if (ihead == kTRUE)
    {
      Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "HEADER", "Header read successfully");
    }
  else
    {
      Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "HEADER", "Header read ERROR");
      //return -1; -- not FATAL
    }

  clusterizer->ResetTree();
  Bool_t ireadD = clusterizer->ReadDigits(rmem);
  if (ireadD == kTRUE)
    {
      Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "DIGITS", "Digits read successfully");
    }
  else
    {
      Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "DIGITS", "Digits read ERROR");
      return -1;
    }

  Bool_t iclustered = clusterizer->MakeClusters();
  if (iclustered == kTRUE)
    {
      Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "CLUSTERS", "Clustered successfully");
    }
  else
    {
      Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "CLUSTERS", "Clustering ERROR");
      return -1;
    }

  free(memBufIn);

  UInt_t memBufOutSize = 0;
  //   void *memBufOut = clusterizer->WriteClustersToMemory(memBufOut, memBufOutSize);
  Int_t iNclusters = clusterizer->GetNclusters();
  Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COUNT", "N of Clusters = %d", iNclusters);

  // put the tree into output blocks of TObjArrays
  TTree *fcTree = clusterizer->GetClusterTree();
  TList *lt = (TList*)fcTree->GetListOfBranches();
  TIter it(lt);
  it.Reset();
  TBranch *tb = 0;
  while ((tb = (TBranch*)it.Next()) != 0)
    {
      TObjArray *clusters = 0;
      tb->SetAddress(&clusters);
      for (Int_t icb = 0; icb < tb->GetEntries(); icb++)
	{
	  tb->GetEntry(icb);
	  PushBack(clusters, AliHLTTRDDefinitions::gkClusterDataType, fDblock_Specification);
	}
    }

  return 0;
}
Commit	Line	Data
0af7cb2e	1	// $Id$
	2
	3	/**************************************************************************
	4	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* *
	6	* Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
	7	* Timm Steinbeck <timm@kip.uni-heidelberg.de> *
	8	* for The ALICE Off-line 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 AliHLTTRDClusterizerComponent.cxx
	20	@author Timm Steinbeck, Matthias Richter
	21	@date
	22	@brief A TRDClusterizer processing component for the HLT. */
	23
	24	#if __GNUC__ >= 3
	25	using namespace std;
	26	#endif
	27
	28	#include "AliHLTTRDClusterizerComponent.h"
	29	#include "AliHLTTRDDefinitions.h"
	30
	31	#include "AliCDBManager.h"
	32	#include "AliTRDclusterizerV1HLT.h"
	33	#include "AliRawReaderMemory.h"
	34
	35	#include "TTree.h"
	36	#include "TBranch.h"
	37
	38	#include <cstdlib>
	39	#include <cerrno>
	40	#include <string>
	41
	42	// this is a global object used for automatic component registration, do not use this
	43	AliHLTTRDClusterizerComponent gAliHLTTRDClusterizerComponent;
	44
	45	ClassImp(AliHLTTRDClusterizerComponent)
	46
	47	AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent()
	48	{
	49	fOutputPercentage = 100; // By default we copy to the output exactly what we got as input
	50
	51	}
	52
	53	AliHLTTRDClusterizerComponent::~AliHLTTRDClusterizerComponent()
	54	{
	55	}
	56
	57	const char* AliHLTTRDClusterizerComponent::GetComponentID()
	58	{
	59	return "TRDClusterizer"; // The ID of this component
	60	}
	61
	62	void AliHLTTRDClusterizerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
	63	{
	64	list.clear(); // We do not have any requirements for our input data type(s).
65	list.push_back( AliHLTTRDDefinitions::gkDDLRawDataType );
66	}
67
68	AliHLTComponent_DataType AliHLTTRDClusterizerComponent::GetOutputDataType()
69	{
70	return AliHLTTRDDefinitions::gkClusterDataType;
71	}
72
73	void AliHLTTRDClusterizerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
74	{
75	constBase = 0;
76	inputMultiplier = ((double)fOutputPercentage)/100.0;
77	}
78
79
80
81	// Spawn function, return new instance of this class
82	AliHLTComponent* AliHLTTRDClusterizerComponent::Spawn()
83	{
84	return new AliHLTTRDClusterizerComponent;
85	};
86
87	int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
88	{
89	// perform initialization. We check whether our relative output size is specified in the arguments.
90	fOutputPercentage = 100;
91	Int_t fRawDataVersion = 2;
92	int i = 0;
93	char* cpErr;
94	while ( i < argc )
95	{
96	Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoInit", "Arguments", "argv[%d] == %s", i, argv[i] );
97	if ( !strcmp( argv[i], "output_percentage" ) )
98	{
99	if ( i+1>=argc )
100	{
101	Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing output_percentage parameter");
102	return ENOTSUP;
103	}
104	Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoInit", "Arguments", "argv[%d+1] == %s", i, argv[i+1] );
105	fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
106	if ( *cpErr )
107	{
108	Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Wrong Argument", "Cannot convert output_percentage parameter '%s'", argv[i+1] );
109	return EINVAL;
110	}
111	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
112	i += 2;
113	continue;
114	}
115
116	if ( strcmp( argv[i], "-cdb" ) == 0)
117	{
118	if ( i+1 >= argc )
119	{
120	Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing -cdb argument");
121	return ENOTSUP;
122	}
123	fStrorageDBpath = argv[i+1];
124	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "DB storage set", "DB storage is %s", fStrorageDBpath.c_str() );
125	i += 2;
126	continue;
127	}
128
129	if ( strcmp( argv[i], "-rawver" ) == 0)
130	{
131	if ( i+1 >= argc )
132	{
133	Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing -rawver argument");
134	return ENOTSUP;
135	}
136	fRawDataVersion = atoi( argv[i+1] );
137	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "Raw Data", "Version is %d", fRawDataVersion );
138	i += 2;
139	continue;
140	}
141
142	Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
143	return EINVAL;
144	}
145
146	cdb = AliCDBManager::Instance();
147	if (!cdb)
148	{
149	Logging(kHLTLogError, "HLT::TRDCalibration::DoInit", "Could not get CDB instance", "cdb 0x%x", cdb);
150	}
151	else
152	{
153	cdb->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
154	cdb->SetDefaultStorage(fStrorageDBpath.c_str());
155	Logging(kHLTLogDebug, "HLT::TRDCalibration::DoInit", "CDB instance", "cdb 0x%x", cdb);
156	}
157
158	rmem = new AliRawReaderMemory;
159	clusterizer = new AliTRDclusterizerV1HLT("TRDCclusterizer", "TRDCclusterizer");
160	clusterizer->SetRawDataVersion(fRawDataVersion);
161	clusterizer->InitClusterTree();
162	return 0;
163	}
164
165	int AliHLTTRDClusterizerComponent::DoDeinit()
166	{
167	delete rmem;
168	rmem = 0;
169	delete clusterizer;
170	clusterizer = 0;
171	return 0;
172
173	if (cdb)
174	{
175	Logging( kHLTLogDebug, "HLT::TRDCalibration::DoDeinit", "destroy", "cdb");
176	cdb->Destroy();
177	cdb = 0;
178	}
179	}
180
181	int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,
182	AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
183	AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
184	{
185	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
186	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "BLOCKS", "NofBlocks %lu", evtData.fBlockCnt );
187	// Process an event
188	unsigned long totalSize = 0;
189	AliHLTUInt32_t fDblock_Specification = 0;
190
191	// Loop over all input blocks in the event
192	for ( unsigned long i = 0; i < evtData.fBlockCnt; i++ )
193	{
194	char tmp1[14], tmp2[14];
195	DataType2Text( blocks[i].fDataType, tmp1 );
196	DataType2Text( AliHLTTRDDefinitions::gkDDLRawDataType, tmp2 );
197	Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoEvent", "Event received",
198	"Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
199	evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
200
201	if ( blocks[i].fDataType != AliHLTTRDDefinitions::gkDDLRawDataType )
202	{
203	Logging (kHLTLogError, "HLT::TRDClusterizer::DoEvent", "COMPARE FAILED", "type=%d is type=%d",
204	blocks[i].fDataType, AliHLTTRDDefinitions::gkDDLRawDataType);
205	continue;
206	}
207	fDblock_Specification = blocks[i].fSpecification;
208	unsigned long blockSize = blocks[i].fSize;
209	totalSize += blockSize;
210	}
211
212	void *memBufIn = calloc(totalSize, 1);
213	AliHLTUInt8_t pBuf = (AliHLTUInt8_t )memBufIn;
214	if (memBufIn == NULL)
215	{
216	Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "MEMORY", "Unable to allocate %lu bytes", totalSize);
217	return -1;
218	}
219
220	// Make the memory continuous
221	unsigned long copied = 0;
222	for ( unsigned long i = 0; i < evtData.fBlockCnt; i++ )
223	{
224	if ( blocks[i].fDataType != AliHLTTRDDefinitions::gkDDLRawDataType )
225	continue;
226
227	void pos = (void)(pBuf + copied);
228	void *copyret = memcpy(pos, blocks[i].fPtr, blocks[i].fSize);
229	if (copyret < 0)
230	{
231	Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "MEMORY", "Unable to copy %lu bytes", blocks[i].fSize);
232	return -1;
233	}
234	copied += blocks[i].fSize;
235	}
236
237	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COPY STATS", "total=%lu copied=%lu", totalSize, copied);
238
239	rmem->Reset();
240	rmem->SetMemory((UChar_t*)memBufIn, totalSize);
241	//rmem->Reset();
242	Bool_t ihead = rmem->ReadHeader();
243	if (ihead == kTRUE)
244	{
245	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "HEADER", "Header read successfully");
246	}
247	else
248	{
249	Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "HEADER", "Header read ERROR");
250	//return -1; -- not FATAL
251	}
252
253	clusterizer->ResetTree();
254	Bool_t ireadD = clusterizer->ReadDigits(rmem);
255	if (ireadD == kTRUE)
256	{
257	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "DIGITS", "Digits read successfully");
258	}
259	else
260	{
261	Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "DIGITS", "Digits read ERROR");
262	return -1;
263	}
264
265	Bool_t iclustered = clusterizer->MakeClusters();
266	if (iclustered == kTRUE)
267	{
268	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "CLUSTERS", "Clustered successfully");
269	}
270	else
271	{
272	Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "CLUSTERS", "Clustering ERROR");
273	return -1;
274	}
275
276	free(memBufIn);
277
278	UInt_t memBufOutSize = 0;
279	// void *memBufOut = clusterizer->WriteClustersToMemory(memBufOut, memBufOutSize);
280	Int_t iNclusters = clusterizer->GetNclusters();
281	Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COUNT", "N of Clusters = %d", iNclusters);
282
283	// put the tree into output blocks of TObjArrays
284	TTree *fcTree = clusterizer->GetClusterTree();
285	TList lt = (TList)fcTree->GetListOfBranches();
286	TIter it(lt);
287	it.Reset();
288	TBranch *tb = 0;
289	while ((tb = (TBranch*)it.Next()) != 0)
290	{
291	TObjArray *clusters = 0;
292	tb->SetAddress(&clusters);
293	for (Int_t icb = 0; icb < tb->GetEntries(); icb++)
294	{
295	tb->GetEntry(icb);
296	PushBack(clusters, AliHLTTRDDefinitions::gkClusterDataType, fDblock_Specification);
297	}
298	}
299
300	return 0;
301	}