[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONMansoTrackerComponent.cxx

/**************************************************************************
 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/* $Id$ */

/**
 *  @file   AliHLTMUONMansoTrackerComponent.cxx
 *  @author Artur Szostak <artursz@iafrica.com>
 *  @date   
 *  @brief  Implementation of AliHLTMUONMansoTrackerComponent class.
 */

#include "AliHLTMUONMansoTrackerComponent.h"
#include "Util/AliHLTMUONRecPoint.h"
#include <stdlib.h>
#include <errno.h>

namespace
{
	// this is a global object used for automatic component registration, do not use this
	AliHLTMUONMansoTrackerComponent gAliHLTMUONMansoTrackerComponent;
}


ClassImp(AliHLTMUONMansoTrackerComponent);


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

AliHLTMUONMansoTrackerComponent::~AliHLTMUONMansoTrackerComponent()
    {
    }

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

void AliHLTMUONMansoTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
    {
      /* in order to be backward compatible we have to keep the old code, at
       * least for a while. Remember to use the new const kAliHLTVoidDataType
       * if you are using a more recent AliRoot version (from Jan 07)
       list.push_back(kAliHLTAnyDataType); // We do not have any requirements for our input data type(s).
      */

      AliHLTComponentDataType dt = 
	{ sizeof(AliHLTComponentDataType),
	  {'*','*','*','*','*','*','*','\0'},
	  {'*','*','*','\0'}};
       list.push_back(dt);
    }

AliHLTComponentDataType AliHLTMUONMansoTrackerComponent::GetOutputDataType()
    {
      /* in order to be backward compatible we have to keep the old code, at
       * least for a while. Remember to use the new const kAliHLTVoidDataType
       * if you are using a more recent AliRoot version (from Jan 07)
      return kAliHLTVoidDataType;
      */
      AliHLTComponentDataType dt = 
	{ sizeof(AliHLTComponentDataType),
	  {'\0','\0','\0','0','\0','\0','\0','\0'},
	  {'\0','\0','\0','\0'}};
      return dt;
    }

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


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

int AliHLTMUONMansoTrackerComponent::DoInit( int argc, const char** argv )
    {
    // perform initialization. We check whether our relative output size is specified in the arguments.
    fOutputPercentage = 100;
						
    fTracker = new AliHLTMUONMansoTracker();

    Logging(kHLTLogInfo, "dHLT", "Tracking", "hitrec, DoInit");
    if (argc==0 && argv==NULL) {
      // this is just to get rid of the warning "unused parameter"
    }

    int i = 0;
    char* cpErr;
    while ( i < argc )
      {
	Logging( kHLTLogDebug, "AliHLTMUONMansoTrackerComponent::DoInit", "Arguments", "argv[%d] == %s", i, argv[i] );
	if ( !strcmp( argv[i], "output_percentage" ) )
	    {
	    if ( i+1>=argc )
		{
		Logging(kHLTLogError, "AliHLTMUONMansoTrackerComponent::DoInit", "Missing Argument", "Missing output_percentage parameter");
		return ENOTSUP;
		}
	    Logging( kHLTLogDebug, "AliHLTMUONMansoTrackerComponent::DoInit", "Arguments", "argv[%d+1] == %s", i, argv[i+1] );
	    fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
	    if ( *cpErr )
		{
		  Logging(kHLTLogError, "AliHLTMUONMansoTrackerComponent::DoInit", "Wrong Argument", "Cannot convert output_percentage parameter '%s'", argv[i+1] );
		  return EINVAL;
		}
	    Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoInit", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
	    i += 2;
	    continue;
	    }
	Logging(kHLTLogError, "AliHLTMUONMansoTrackerComponent::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
	return EINVAL;
      }// while loop
    return 0;
    }

int AliHLTMUONMansoTrackerComponent::DoDeinit()
{
  if(fTracker)
    delete fTracker;
  return 0;
}

int AliHLTMUONMansoTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
				      AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
				      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
  Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
  // Process an event
  unsigned long totalSize = 0;
  AliHLTUInt32_t maxTracksPerEvent = 1024;

  fTracker->Reset();
  fTracker->SetTrackOutputBuffer((AliHLTMUONTrackPoints*)outputPtr,maxTracksPerEvent);
  
//  cout<<"BlockSize :"<<evtData.fBlockCnt<<" size :"<<outputBlocks.size()<<endl;
  // Loop over all input blocks in the event
  for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
    {
      // Align the beginning of this  block to the required value.
//       if ( totalSize % kAliHLTBlockAlignment )
// 	totalSize += kAliHLTBlockAlignment-(totalSize % kAliHLTBlockAlignment);

      if ( totalSize > size )
	break;
      // Determine the size we should use for the output for this block (the input block's size times the relative output size)
      unsigned long mySize = (blocks[n].fSize * fOutputPercentage) / 100;
      Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "mySize set (1)", "mySize == %lu B - blocks[%lu].fSize == %lu - fOutputPercentage == %lu - totalSize == %lu", 
	       mySize, n, blocks[n].fSize, fOutputPercentage, totalSize );

      Int_t noftrigData,nofhitData;
      if(n== (evtData.fBlockCnt - 1)){// for trigger
	UInt_t trigDataSize;
	memcpy(&trigDataSize,blocks[n].fPtr,sizeof(UInt_t));
//	cout<<"trigDataSize :"<<trigDataSize<<endl;
	UInt_t trigOffSet;
	memcpy(&trigOffSet,(UInt_t*)blocks[n].fPtr + 1,sizeof(UInt_t));
//	cout<<"trigOffSet :"<<trigOffSet<<endl;
	noftrigData = (trigDataSize -  sizeof(UInt_t))*sizeof(AliHLTUInt32_t)/sizeof(AliHLTMUONCoreTriggerRecord) ;
	fTrigData = new AliHLTMUONCoreTriggerRecord[noftrigData];

	for(Int_t i=0;i<noftrigData;i++){
	  AliHLTMUONCoreTriggerRecord record;
	  memcpy(&record,(UInt_t*)blocks[n].fPtr + 2 + i*(sizeof(AliHLTMUONCoreTriggerRecord))/4,sizeof(AliHLTMUONCoreTriggerRecord));
	  fTrigData[i] = record;

//	  cout<<" Sign : "<<fTrigData[i].fSign
//	      <<" Pt : "<<fTrigData[i].fPt
//	      <<"\t X1:"<<fTrigData[i].fStation1impact.X()<<" Y1 :"<<fTrigData[i].fStation1impact.Y()
//	      <<"\t X2:"<<fTrigData[i].fStation2impact.X()<<" Y2 :"<<fTrigData[i].fStation2impact.Y()
//	      << endl;
	}// for
	
	fTracker->FindTracks(fTrigData,noftrigData);
//	cout<<"Nof tracks found :"<<fTracker->TrackCount()<<endl;
//	cout<<"Z7 : "<<AliHLTMUONCoreMansoTracker::GetZ7()<<endl;

      }else{ // for hitrec
	UInt_t hitDataSize;
	memcpy(&hitDataSize,blocks[n].fPtr,sizeof(UInt_t));
//	cout<<"hitDataSize :"<<hitDataSize<<endl;
	nofhitData = hitDataSize*sizeof(AliHLTUInt32_t)/sizeof(AliHLTMUONCorePoint) ;
	
	Int_t chamber = n + 6;
	AliHLTMUONRecPoint *recHit = new AliHLTMUONRecPoint[nofhitData];
	for(Int_t i=0;i<nofhitData;i++){
	  AliHLTMUONCorePoint point;
	  memcpy(&point,(UInt_t*)blocks[n].fPtr + 1 + i*(sizeof(AliHLTMUONCorePoint))/4,sizeof(AliHLTMUONCorePoint));
//	  cout <<"chamber :"<<chamber<<"\tX : "<<point.X()<<"\t Y : "<<point.Y()<< endl;
	  recHit[i].fX = point.X();
	  recHit[i].fY = point.Y();
	}// for
	
	fTracker->AddRecHits(chamber,recHit,nofhitData);

      }// hit or trig condn
      

      //for(Int_t itrig = 0 ; itrig < nofTrigData ; itrig++){
      
      //}


	// Check how much space we have left and adapt this output block's size accordingly.
// 	if ( totalSize + mySize > size )
// 	    mySize = size-totalSize;
// 	Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "mySize set (2)", "mySize == %lu B - totalSize == %lu - size == %lu", 
// 		 mySize, totalSize, size );
// 	if ( mySize<=0 )
// 	    continue; // No room left to write a further block.
// 	// Now copy the input block
// 	unsigned long copied = 0;
// 	// First copy all full multiples of the input block
// 	while ( copied+blocks[n].fSize <= mySize )
// 	    {
// 	    Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B", 
// 		     blocks[n].fSize, copied, totalSize );
// 	    memcpy( outputPtr+totalSize+copied, blocks[n].fPtr, blocks[n].fSize );
// 	    copied += blocks[n].fSize;
// 	    }
// 	// And the copy the remaining fragment of the block
// 	Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B", 
// 		 mySize-copied, copied, totalSize );
// 	memcpy( outputPtr+totalSize+copied, blocks[n].fPtr, mySize-copied );
// 	Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "Copied", "Copied: %lu B - totalSize: %lu B", 
// 		 copied, totalSize );
// 	// Fill a block data structure for our output block.
// 	AliHLTComponentBlockData ob;
// 	// Let the structure be filled with the default values.
// 	// This takes care of setting the shared memory and data type values to default values,
// 	// so that they can be filled in by the calling code.
// 	FillBlockData( ob );
// 	// This block's start (offset) is after all other blocks written so far
// 	ob.fOffset = totalSize;
// 	// the size of this block's data.
// 	ob.fSize = mySize;
// 	// The specification of the data is copied from the input block.
// 	ob.fSpecification = blocks[n].fSpecification;
// 	// The data type is set automatically to the component's specified output data type.
// 	// Place this block into the list of output blocks
// 	outputBlocks.push_back( ob );
// 	// Increase the total amount of data written so far to our output memory
// 	totalSize += mySize;
    }
    // Finally we set the total size of output memory we consumed.
    size = totalSize;
    return 0;
}
Commit	Line	Data
b0201cbe	1	/**************************************************************************
	2	* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	/**
	19	* @file AliHLTMUONMansoTrackerComponent.cxx
b92524d0	20	* @author Artur Szostak <artursz@iafrica.com>
b0201cbe	21	* @date
	22	* @brief Implementation of AliHLTMUONMansoTrackerComponent class.
	23	*/
	24
	25	#include "AliHLTMUONMansoTrackerComponent.h"
	26	#include "Util/AliHLTMUONRecPoint.h"
	27	#include <stdlib.h>
	28	#include <errno.h>
	29
	30	namespace
	31	{
	32	// this is a global object used for automatic component registration, do not use this
	33	AliHLTMUONMansoTrackerComponent gAliHLTMUONMansoTrackerComponent;
	34	}
	35
	36
	37	ClassImp(AliHLTMUONMansoTrackerComponent);
	38
	39
	40	AliHLTMUONMansoTrackerComponent::AliHLTMUONMansoTrackerComponent()
	41	:
	42	fOutputPercentage(100) // By default we copy to the output exactly what we got as input
	43	{
	44	}
	45
	46	AliHLTMUONMansoTrackerComponent::~AliHLTMUONMansoTrackerComponent()
	47	{
	48	}
	49
	50	const char* AliHLTMUONMansoTrackerComponent::GetComponentID()
	51	{
	52	return "tracking"; // The ID of this component
	53	}
	54
	55	void AliHLTMUONMansoTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
	56	{
	57	/* in order to be backward compatible we have to keep the old code, at
	58	* least for a while. Remember to use the new const kAliHLTVoidDataType
	59	* if you are using a more recent AliRoot version (from Jan 07)
	60	list.push_back(kAliHLTAnyDataType); // We do not have any requirements for our input data type(s).
	61	*/
	62
	63	AliHLTComponentDataType dt =
	64	{ sizeof(AliHLTComponentDataType),
	65	{'','','','','','','*','\0'},
	66	{'','','*','\0'}};
	67	list.push_back(dt);
	68	}
	69
	70	AliHLTComponentDataType AliHLTMUONMansoTrackerComponent::GetOutputDataType()
	71	{
	72	/* in order to be backward compatible we have to keep the old code, at
	73	* least for a while. Remember to use the new const kAliHLTVoidDataType
	74	* if you are using a more recent AliRoot version (from Jan 07)
	75	return kAliHLTVoidDataType;
	76	*/
	77	AliHLTComponentDataType dt =
	78	{ sizeof(AliHLTComponentDataType),
	79	{'\0','\0','\0','0','\0','\0','\0','\0'},
	80	{'\0','\0','\0','\0'}};
	81	return dt;
	82	}
	83
	84	void AliHLTMUONMansoTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
85	{
86	constBase = 0;
87	inputMultiplier = ((double)fOutputPercentage)/100.0;
88	}
89
90
91
92	// Spawn function, return new instance of this class
93	AliHLTComponent* AliHLTMUONMansoTrackerComponent::Spawn()
94	{
95	return new AliHLTMUONMansoTrackerComponent;
96	}
97
98	int AliHLTMUONMansoTrackerComponent::DoInit( int argc, const char** argv )
99	{
100	// perform initialization. We check whether our relative output size is specified in the arguments.
101	fOutputPercentage = 100;
102
103	fTracker = new AliHLTMUONMansoTracker();
104
105	Logging(kHLTLogInfo, "dHLT", "Tracking", "hitrec, DoInit");
106	if (argc==0 && argv==NULL) {
107	// this is just to get rid of the warning "unused parameter"
108	}
109
110	int i = 0;
111	char* cpErr;
112	while ( i < argc )
113	{
114	Logging( kHLTLogDebug, "AliHLTMUONMansoTrackerComponent::DoInit", "Arguments", "argv[%d] == %s", i, argv[i] );
115	if ( !strcmp( argv[i], "output_percentage" ) )
116	{
117	if ( i+1>=argc )
118	{
119	Logging(kHLTLogError, "AliHLTMUONMansoTrackerComponent::DoInit", "Missing Argument", "Missing output_percentage parameter");
120	return ENOTSUP;
121	}
122	Logging( kHLTLogDebug, "AliHLTMUONMansoTrackerComponent::DoInit", "Arguments", "argv[%d+1] == %s", i, argv[i+1] );
123	fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
124	if ( *cpErr )
125	{
126	Logging(kHLTLogError, "AliHLTMUONMansoTrackerComponent::DoInit", "Wrong Argument", "Cannot convert output_percentage parameter '%s'", argv[i+1] );
127	return EINVAL;
128	}
129	Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoInit", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
130	i += 2;
131	continue;
132	}
133	Logging(kHLTLogError, "AliHLTMUONMansoTrackerComponent::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
134	return EINVAL;
135	}// while loop
136	return 0;
137	}
138
139	int AliHLTMUONMansoTrackerComponent::DoDeinit()
140	{
141	if(fTracker)
142	delete fTracker;
143	return 0;
144	}
145
146	int AliHLTMUONMansoTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
147	AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
148	AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
149	{
150	Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
151	// Process an event
152	unsigned long totalSize = 0;
153	AliHLTUInt32_t maxTracksPerEvent = 1024;
154
155	fTracker->Reset();
156	fTracker->SetTrackOutputBuffer((AliHLTMUONTrackPoints*)outputPtr,maxTracksPerEvent);
157
158	// cout<<"BlockSize :"<<evtData.fBlockCnt<<" size :"<<outputBlocks.size()<<endl;
159	// Loop over all input blocks in the event
160	for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
161	{
162	// Align the beginning of this block to the required value.
163	// if ( totalSize % kAliHLTBlockAlignment )
164	// totalSize += kAliHLTBlockAlignment-(totalSize % kAliHLTBlockAlignment);
165
166	if ( totalSize > size )
167	break;
168	// Determine the size we should use for the output for this block (the input block's size times the relative output size)
169	unsigned long mySize = (blocks[n].fSize * fOutputPercentage) / 100;
170	Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "mySize set (1)", "mySize == %lu B - blocks[%lu].fSize == %lu - fOutputPercentage == %lu - totalSize == %lu",
171	mySize, n, blocks[n].fSize, fOutputPercentage, totalSize );
172
173	Int_t noftrigData,nofhitData;
174	if(n== (evtData.fBlockCnt - 1)){// for trigger
175	UInt_t trigDataSize;
176	memcpy(&trigDataSize,blocks[n].fPtr,sizeof(UInt_t));
177	// cout<<"trigDataSize :"<<trigDataSize<<endl;
178	UInt_t trigOffSet;
179	memcpy(&trigOffSet,(UInt_t*)blocks[n].fPtr + 1,sizeof(UInt_t));
180	// cout<<"trigOffSet :"<<trigOffSet<<endl;
181	noftrigData = (trigDataSize - sizeof(UInt_t))*sizeof(AliHLTUInt32_t)/sizeof(AliHLTMUONCoreTriggerRecord) ;
182	fTrigData = new AliHLTMUONCoreTriggerRecord[noftrigData];
183
184	for(Int_t i=0;i<noftrigData;i++){
185	AliHLTMUONCoreTriggerRecord record;
186	memcpy(&record,(UInt_t)blocks[n].fPtr + 2 + i(sizeof(AliHLTMUONCoreTriggerRecord))/4,sizeof(AliHLTMUONCoreTriggerRecord));
187	fTrigData[i] = record;
188
189	// cout<<" Sign : "<<fTrigData[i].fSign
190	// <<" Pt : "<<fTrigData[i].fPt
191	// <<"\t X1:"<<fTrigData[i].fStation1impact.X()<<" Y1 :"<<fTrigData[i].fStation1impact.Y()
192	// <<"\t X2:"<<fTrigData[i].fStation2impact.X()<<" Y2 :"<<fTrigData[i].fStation2impact.Y()
193	// << endl;
194	}// for
195
196	fTracker->FindTracks(fTrigData,noftrigData);
197	// cout<<"Nof tracks found :"<<fTracker->TrackCount()<<endl;
198	// cout<<"Z7 : "<<AliHLTMUONCoreMansoTracker::GetZ7()<<endl;
199
200	}else{ // for hitrec
201	UInt_t hitDataSize;
202	memcpy(&hitDataSize,blocks[n].fPtr,sizeof(UInt_t));
203	// cout<<"hitDataSize :"<<hitDataSize<<endl;
204	nofhitData = hitDataSize*sizeof(AliHLTUInt32_t)/sizeof(AliHLTMUONCorePoint) ;
205
206	Int_t chamber = n + 6;
207	AliHLTMUONRecPoint *recHit = new AliHLTMUONRecPoint[nofhitData];
208	for(Int_t i=0;i<nofhitData;i++){
209	AliHLTMUONCorePoint point;
210	memcpy(&point,(UInt_t)blocks[n].fPtr + 1 + i(sizeof(AliHLTMUONCorePoint))/4,sizeof(AliHLTMUONCorePoint));
211	// cout <<"chamber :"<<chamber<<"\tX : "<<point.X()<<"\t Y : "<<point.Y()<< endl;
212	recHit[i].fX = point.X();
213	recHit[i].fY = point.Y();
214	}// for
215
216	fTracker->AddRecHits(chamber,recHit,nofhitData);
217
218	}// hit or trig condn
219
220
221	//for(Int_t itrig = 0 ; itrig < nofTrigData ; itrig++){
222
223	//}
224
225
226	// Check how much space we have left and adapt this output block's size accordingly.
227	// if ( totalSize + mySize > size )
228	// mySize = size-totalSize;
229	// Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "mySize set (2)", "mySize == %lu B - totalSize == %lu - size == %lu",
230	// mySize, totalSize, size );
231	// if ( mySize<=0 )
232	// continue; // No room left to write a further block.
233	// // Now copy the input block
234	// unsigned long copied = 0;
235	// // First copy all full multiples of the input block
236	// while ( copied+blocks[n].fSize <= mySize )
237	// {
238	// Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B",
239	// blocks[n].fSize, copied, totalSize );
240	// memcpy( outputPtr+totalSize+copied, blocks[n].fPtr, blocks[n].fSize );
241	// copied += blocks[n].fSize;
242	// }
243	// // And the copy the remaining fragment of the block
244	// Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B",
245	// mySize-copied, copied, totalSize );
246	// memcpy( outputPtr+totalSize+copied, blocks[n].fPtr, mySize-copied );
247	// Logging( kHLTLogInfo, "AliHLTMUONMansoTrackerComponent::DoEvent", "Copied", "Copied: %lu B - totalSize: %lu B",
248	// copied, totalSize );
249	// // Fill a block data structure for our output block.
250	// AliHLTComponentBlockData ob;
251	// // Let the structure be filled with the default values.
252	// // This takes care of setting the shared memory and data type values to default values,
253	// // so that they can be filled in by the calling code.
254	// FillBlockData( ob );
255	// // This block's start (offset) is after all other blocks written so far
256	// ob.fOffset = totalSize;
257	// // the size of this block's data.
258	// ob.fSize = mySize;
259	// // The specification of the data is copied from the input block.
260	// ob.fSpecification = blocks[n].fSpecification;
261	// // The data type is set automatically to the component's specified output data type.
262	// // Place this block into the list of output blocks
263	// outputBlocks.push_back( ob );
264	// // Increase the total amount of data written so far to our output memory
265	// totalSize += mySize;
266	}
267	// Finally we set the total size of output memory we consumed.
268	size = totalSize;
269	return 0;
270	}