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

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors:                                                       *
 *   Indranil Das <indra.das@saha.ac.in>                                  *
 *                                                                        *
 * 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   AliHLTMUONTriggerReconstructorComponent.cxx
    @author Indranil Das
    @date   
    @brief  A processing component for the dHLT TrigRec. */

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

#include "AliHLTSystem.h"
#include "AliHLTMUONTriggerReconstructorComponent.h"
#include "AliHLTDefinitions.h"
#include <stdlib.h>
#include <errno.h>

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

ClassImp(AliHLTMUONTriggerReconstructorComponent)
    
AliHLTMUONTriggerReconstructorComponent::AliHLTMUONTriggerReconstructorComponent()
  :
  fOutputPercentage(100), // By default we copy to the output exactly what we got as input
  fDDLDir(""),
  fDDL(0),
  fTrigRec(NULL)
    {
    }

AliHLTMUONTriggerReconstructorComponent::~AliHLTMUONTriggerReconstructorComponent()
    {
    }

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

void AliHLTMUONTriggerReconstructorComponent::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).
      */

      list.clear();
      list.push_back( AliHLTMUONConstants::TriggerDDLRawDataType() );
    }

AliHLTComponentDataType AliHLTMUONTriggerReconstructorComponent::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;
      */
      return AliHLTMUONConstants::TriggerRecordsBlockDataType();
    }

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


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

int AliHLTMUONTriggerReconstructorComponent::DoInit( int argc, const char** argv )
{
    // perform initialization. We check whether our relative output size is specified in the arguments.
      
      fTrigRec = new AliHLTMUONTriggerReconstructor();
      
      HLTInfo("dHLT trigrec");
      if (argc==0 && argv==NULL) {
	Logging( kHLTLogError, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Arguments missing", " no arguments" );
	// this is just to get rid of the warning "unused parameter"
      }

      //Int_t i = 0;
      char lutFileName[500], ddlDir[500];

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

	  if ( !strcmp( argv[i], "lut" ) ) {
	    if ( argc <= i+1 ) {
	      Logging( kHLTLogError, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Missing LookupTable filename", "LookupTable filename not specified" );
	      return EINVAL; /* Invalid argument */ 
	    }
	    
	    sprintf(lutFileName,"%s",argv[i+1]);
	    
	    i += 2;
	    continue;
	  }// lut argument
	  
	  
	  if ( !strcmp( argv[i], "ddl" ) ) {
	    if ( argc <= i+1 ) {
	      Logging( kHLTLogError, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Missing DDL argument", "DDL number not specified" );
	      HLTError("AliHLTMUONTriggerReconstructorComponent::DoInit : DDL number is not specified ");
	      return EINVAL;  /* Invalid argument */
	    }
	    
	    fDDL = atoi(argv[i+1]);
	    
	    i += 2;
	    continue;
	  }// ddl argument
	  

	  if ( !strcmp( argv[i], "rawdir" ) ) {
	    if ( argc <= i+1 ) {
	      Logging( kHLTLogError, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Missing DDL directory", "DDL directory not specified" );
	      HLTError("AliHLTMUONTriggerReconstructorComponent::DoInit : DDL directory is not specified ");
	      return EINVAL;  /* Invalid argument */
	    }
	    
	    fDDLDir = argv[i+1] ;
	    
	    i += 2;
	    continue;
	  }// ddl directory argument

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

    int lutline = fTrigRec->GetLutLine();
    AliHLTMUONHitReconstructor::DHLTLut* lookupTable = new AliHLTMUONHitReconstructor::DHLTLut[lutline];
    if(!ReadLookUpTable(lookupTable,lutFileName)){
      Logging(kHLTLogInfo, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Failed to read lut", "lut cannot be read, DoInit");
      return ENOENT ; /* No such file or directory */
    }else{
      
      fTrigRec->LoadLookUpTable(lookupTable,fDDL);
      
    }// reading lut

    delete []lookupTable;

    return 0;
}

int AliHLTMUONTriggerReconstructorComponent::DoDeinit()
    {
      if(fTrigRec)
	delete fTrigRec;
      HLTInfo("dHLT trigrec");
      return 0;
  
    return 0;
    }

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

    // Loop over all input blocks in the event
    for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
      {

	if ( totalSize > size )
	    break;

	int totalDDLSize = blocks[n].fSize/4;
	int  ddlRawDataSize = totalDDLSize - AliHLTMUONTriggerReconstructor::GetkDDLHeaderSize();
	//cout<<"ddlRawDataSize :"<<ddlRawDataSize<<endl;
	int *buffer = (int *)((int *)blocks[n].fPtr + AliHLTMUONTriggerReconstructor::GetkDDLHeaderSize()) ;
	
	AliHLTMUONTriggerRecordStruct trigRecord[300];
	int nofTrigRec = 300;
	
 	if(! (fTrigRec->Run(buffer,&ddlRawDataSize,trigRecord,&nofTrigRec))){
	  HLTError("ERROR In Processing of TrigRec Algo ");
	  return EIO;
	}

// 	if(! (fTrigRec->Run((int)evtData.fEventID,fDDL,trigRecord,&nofTrigRec))){
// 	  HLTError("ERROR In Processing of TrigRec Algo ");
// 	  return EIO;
//	}
	
	unsigned long mySize = sizeof(AliHLTMUONTriggerRecordStruct)*nofTrigRec;
    
//	cout<<"nofHit "<<nofHit<<endl;
// 	for(int i=0;i<nofHit;i++)
// 	  cout<<"\t 0 : recHit["<<i<<"].fX :"<<recHit[i].fX
// 	      <<"  recHit["<<i<<"].fY :"<<recHit[i].fY
// 	      <<"  recHit["<<i<<"].fZ :"<<recHit[i].fZ
// 	      <<"  recHit["<<i<<"].fDetElemId :"<<recHit[i].fDetElemId
// 	      <<endl;

	//unsigned long mySize = (blocks[n].fSize * fOutputPercentage) / 100;

	Logging( kHLTLogInfo, "HLT::MUONTrigRec::DoEvent", "mySize set (1)", "mySize == %lu B - blocks[%lu].fSize == %lu - fOutputPercentage == %lu", 
		 mySize, n, blocks[n].fSize, fOutputPercentage );

	// Check how much space we have left and adapt this output block's size accordingly.
	if ( totalSize + mySize > size )
	    mySize = size-totalSize;

	Logging( kHLTLogInfo, "HLT::MUONTrigRec::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

	// And the copy the remaining fragment of the block
	Logging( kHLTLogInfo, "1 : HLT::MUONTrigRec::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B", 
		 mySize-copied, copied, totalSize );
	//memcpy( outputPtr+totalSize+copied, blocks[n].fPtr, mySize-copied );
	memcpy( outputPtr+totalSize+copied, &trigRecord[0], mySize);
	Logging( kHLTLogInfo, "HLT::MUONTrigRec::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;
    }

bool AliHLTMUONTriggerReconstructorComponent::ReadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookupTable, const char* lutpath)
{
  if (fDDL < AliHLTMUONTriggerReconstructor::GetkDDLOffSet() ||
      fDDL >= AliHLTMUONTriggerReconstructor::GetkDDLOffSet() + AliHLTMUONTriggerReconstructor::GetkNofDDL()){
    HLTError("DDL number is out of range");
    return false;
  }
  
  int lutLine = fTrigRec->GetLutLine();
  
  FILE* fin = fopen(lutpath, "r");
  if (fin == NULL){
    HLTError("Failed to open file: %s",lutpath);
    return false;
  }
  
  for(int i=0;i<lutLine;i++){
    fscanf(
	   fin,
	   "%d\t%d\t%d\t%f\t%f\t%f\t%d\t%d\n",
	   &lookupTable[i].fIdManuChannel,
	   &lookupTable[i].fIX,
	   &lookupTable[i].fIY,
	   &lookupTable[i].fRealX,
	   &lookupTable[i].fRealY,
	   &lookupTable[i].fRealZ,
	   &lookupTable[i].fPlane,
	   &lookupTable[i].fPcbZone
	   );
  }
  
  fclose(fin);
  return true;
}

// implement this as well.
Commit	Line	Data
6efe69e7	1	/**************************************************************************
	2	* This file is property of and copyright by the ALICE HLT Project *
	3	* All rights reserved. *
	4	* *
	5	* Primary Authors: *
	6	* Indranil Das <indra.das@saha.ac.in> *
	7	* *
	8	* Permission to use, copy, modify and distribute this software and its *
	9	* documentation strictly for non-commercial purposes is hereby granted *
	10	* without fee, provided that the above copyright notice appears in all *
	11	* copies and that both the copyright notice and this permission notice *
	12	* appear in the supporting documentation. The authors make no claims *
	13	* about the suitability of this software for any purpose. It is *
	14	* provided "as is" without express or implied warranty. *
	15	**************************************************************************/
	16
	17	/* $Id$ */
	18
	19	/** @file AliHLTMUONTriggerReconstructorComponent.cxx
	20	@author Indranil Das
	21	@date
	22	@brief A processing component for the dHLT TrigRec. */
	23
	24	#if __GNUC__ >= 3
	25	using namespace std;
	26	#endif
	27
	28	#include "AliHLTSystem.h"
	29	#include "AliHLTMUONTriggerReconstructorComponent.h"
	30	#include "AliHLTDefinitions.h"
	31	#include <stdlib.h>
	32	#include <errno.h>
	33
	34	// this is a global object used for automatic component registration, do not use this
	35	AliHLTMUONTriggerReconstructorComponent gAliHLTMUONTriggerReconstructorComponent;
	36
	37	ClassImp(AliHLTMUONTriggerReconstructorComponent)
	38
	39	AliHLTMUONTriggerReconstructorComponent::AliHLTMUONTriggerReconstructorComponent()
	40	:
	41	fOutputPercentage(100), // By default we copy to the output exactly what we got as input
	42	fDDLDir(""),
	43	fDDL(0),
	44	fTrigRec(NULL)
	45	{
	46	}
	47
	48	AliHLTMUONTriggerReconstructorComponent::~AliHLTMUONTriggerReconstructorComponent()
	49	{
	50	}
	51
	52	const char* AliHLTMUONTriggerReconstructorComponent::GetComponentID()
	53	{
	54	return "MUONTrigRec"; // The ID of this component
	55	}
	56
	57	void AliHLTMUONTriggerReconstructorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
	58	{
	59	/* in order to be backward compatible we have to keep the old code, at
	60	* least for a while. Remember to use the new const kAliHLTVoidDataType
	61	* if you are using a more recent AliRoot version (from Jan 07)
	62	list.push_back(kAliHLTAnyDataType); // We do not have any requirements for our input data type(s).
	63	*/
	64
65	list.clear();
66	list.push_back( AliHLTMUONConstants::TriggerDDLRawDataType() );
67	}
68
69	AliHLTComponentDataType AliHLTMUONTriggerReconstructorComponent::GetOutputDataType()
70	{
71	/* in order to be backward compatible we have to keep the old code, at
72	* least for a while. Remember to use the new const kAliHLTVoidDataType
73	* if you are using a more recent AliRoot version (from Jan 07)
74	return kAliHLTVoidDataType;
75	*/
76	return AliHLTMUONConstants::TriggerRecordsBlockDataType();
77	}
78
79	void AliHLTMUONTriggerReconstructorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
80	{
81	constBase = 0;
82	inputMultiplier = ((double)fOutputPercentage)/100.0;
83	}
84
85
86
87	// Spawn function, return new instance of this class
88	AliHLTComponent* AliHLTMUONTriggerReconstructorComponent::Spawn()
89	{
90	return new AliHLTMUONTriggerReconstructorComponent;
91	}
92
93	int AliHLTMUONTriggerReconstructorComponent::DoInit( int argc, const char** argv )
94	{
95	// perform initialization. We check whether our relative output size is specified in the arguments.
96
97	fTrigRec = new AliHLTMUONTriggerReconstructor();
98
99	HLTInfo("dHLT trigrec");
100	if (argc==0 && argv==NULL) {
101	Logging( kHLTLogError, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Arguments missing", " no arguments" );
102	// this is just to get rid of the warning "unused parameter"
103	}
104
105	//Int_t i = 0;
106	char lutFileName[500], ddlDir[500];
107
108	fOutputPercentage = 100;
109	int i = 0;
110	char* cpErr;
111	while ( i < argc )
112	{
113	Logging( kHLTLogDebug, "HLT::MUONTrigRec::DoInit", "Arguments", "argv[%d] == %s", i, argv[i] );
114	if ( !strcmp( argv[i], "output_percentage" ) )
115	{
116	if ( i+1>=argc )
117	{
118	Logging(kHLTLogError, "HLT::MUONTrigRec::DoInit", "Missing Argument", "Missing output_percentage parameter");
119	return ENOTSUP;
120	}
121	Logging( kHLTLogDebug, "HLT::MUONTrigRec::DoInit", "Arguments", "argv[%d+1] == %s", i, argv[i+1] );
122	fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
123	if ( *cpErr )
124	{
125	Logging(kHLTLogError, "HLT::MUONTrigRec::DoInit", "Wrong Argument", "Cannot convert output_percentage parameter '%s'", argv[i+1] );
126	return EINVAL;
127	}
128	Logging( kHLTLogInfo, "HLT::MUONTrigRec::DoInit", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
129	i += 2;
130	continue;
131	}
132
133
134	if ( !strcmp( argv[i], "lut" ) ) {
135	if ( argc <= i+1 ) {
136	Logging( kHLTLogError, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Missing LookupTable filename", "LookupTable filename not specified" );
137	return EINVAL; /* Invalid argument */
138	}
139
140	sprintf(lutFileName,"%s",argv[i+1]);
141
142	i += 2;
143	continue;
144	}// lut argument
145
146
147	if ( !strcmp( argv[i], "ddl" ) ) {
148	if ( argc <= i+1 ) {
149	Logging( kHLTLogError, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Missing DDL argument", "DDL number not specified" );
150	HLTError("AliHLTMUONTriggerReconstructorComponent::DoInit : DDL number is not specified ");
151	return EINVAL; /* Invalid argument */
152	}
153
154	fDDL = atoi(argv[i+1]);
155
156	i += 2;
157	continue;
158	}// ddl argument
159
160
161	if ( !strcmp( argv[i], "rawdir" ) ) {
162	if ( argc <= i+1 ) {
163	Logging( kHLTLogError, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Missing DDL directory", "DDL directory not specified" );
164	HLTError("AliHLTMUONTriggerReconstructorComponent::DoInit : DDL directory is not specified ");
165	return EINVAL; /* Invalid argument */
166	}
167
168	fDDLDir = argv[i+1] ;
169
170	i += 2;
171	continue;
172	}// ddl directory argument
173
174	Logging(kHLTLogError, "HLT::MUONTrigRec::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
175	return EINVAL;
176
177	}//while loop
178
179	int lutline = fTrigRec->GetLutLine();
180	AliHLTMUONHitReconstructor::DHLTLut* lookupTable = new AliHLTMUONHitReconstructor::DHLTLut[lutline];
181	if(!ReadLookUpTable(lookupTable,lutFileName)){
182	Logging(kHLTLogInfo, "AliHLTMUONTriggerReconstructorComponent::DoInit", "Failed to read lut", "lut cannot be read, DoInit");
183	return ENOENT ; /* No such file or directory */
184	}else{
185
186	fTrigRec->LoadLookUpTable(lookupTable,fDDL);
187
188	}// reading lut
189
190	delete []lookupTable;
191
192	return 0;
193	}
194
195	int AliHLTMUONTriggerReconstructorComponent::DoDeinit()
196	{
197	if(fTrigRec)
198	delete fTrigRec;
199	HLTInfo("dHLT trigrec");
200	return 0;
201
202	return 0;
203	}
204
205	int AliHLTMUONTriggerReconstructorComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
206	AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
207	AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
208	{
209	// Process an event
210	unsigned long totalSize = 0;
211	Logging( kHLTLogInfo, "HLT::MUONTrigRec::DoEvent", "Output percentage set", "Output percentage set to %lu %% and totalSize %lu", fOutputPercentage,totalSize );
212
213	// Loop over all input blocks in the event
214	for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
215	{
216
217	if ( totalSize > size )
218	break;
219
220	int totalDDLSize = blocks[n].fSize/4;
221	int ddlRawDataSize = totalDDLSize - AliHLTMUONTriggerReconstructor::GetkDDLHeaderSize();
222	//cout<<"ddlRawDataSize :"<<ddlRawDataSize<<endl;
223	int buffer = (int )((int *)blocks[n].fPtr + AliHLTMUONTriggerReconstructor::GetkDDLHeaderSize()) ;
224
225	AliHLTMUONTriggerRecordStruct trigRecord[300];
226	int nofTrigRec = 300;
227
228	if(! (fTrigRec->Run(buffer,&ddlRawDataSize,trigRecord,&nofTrigRec))){
229	HLTError("ERROR In Processing of TrigRec Algo ");
230	return EIO;
231	}
232
233	// if(! (fTrigRec->Run((int)evtData.fEventID,fDDL,trigRecord,&nofTrigRec))){
234	// HLTError("ERROR In Processing of TrigRec Algo ");
235	// return EIO;
236	// }
237
238	unsigned long mySize = sizeof(AliHLTMUONTriggerRecordStruct)*nofTrigRec;
239
240	// cout<<"nofHit "<<nofHit<<endl;
241	// for(int i=0;i<nofHit;i++)
242	// cout<<"\t 0 : recHit["<<i<<"].fX :"<<recHit[i].fX
243	// <<" recHit["<<i<<"].fY :"<<recHit[i].fY
244	// <<" recHit["<<i<<"].fZ :"<<recHit[i].fZ
245	// <<" recHit["<<i<<"].fDetElemId :"<<recHit[i].fDetElemId
246	// <<endl;
247
248	//unsigned long mySize = (blocks[n].fSize * fOutputPercentage) / 100;
249
250	Logging( kHLTLogInfo, "HLT::MUONTrigRec::DoEvent", "mySize set (1)", "mySize == %lu B - blocks[%lu].fSize == %lu - fOutputPercentage == %lu",
251	mySize, n, blocks[n].fSize, fOutputPercentage );
252
253	// Check how much space we have left and adapt this output block's size accordingly.
254	if ( totalSize + mySize > size )
255	mySize = size-totalSize;
256
257	Logging( kHLTLogInfo, "HLT::MUONTrigRec::DoEvent", "mySize set (2)", "mySize == %lu B - totalSize == %lu - size == %lu",
258	mySize, totalSize, size );
259
260	if ( mySize<=0 )
261	continue; // No room left to write a further block.
262
263	// Now copy the input block
264	unsigned long copied = 0;
265	// First copy all full multiples of the input block
266
267	// And the copy the remaining fragment of the block
268	Logging( kHLTLogInfo, "1 : HLT::MUONTrigRec::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B",
269	mySize-copied, copied, totalSize );
270	//memcpy( outputPtr+totalSize+copied, blocks[n].fPtr, mySize-copied );
271	memcpy( outputPtr+totalSize+copied, &trigRecord[0], mySize);
272	Logging( kHLTLogInfo, "HLT::MUONTrigRec::DoEvent", "Copied", "Copied: %lu B - totalSize: %lu B",
273	copied, totalSize );
274	// Fill a block data structure for our output block.
275	AliHLTComponentBlockData ob;
276	// Let the structure be filled with the default values.
277	// This takes care of setting the shared memory and data type values to default values,
278	// so that they can be filled in by the calling code.
279	FillBlockData( ob );
280	// This block's start (offset) is after all other blocks written so far
281	ob.fOffset = totalSize;
282	// the size of this block's data.
283	ob.fSize = mySize;
284	// The specification of the data is copied from the input block.
285	ob.fSpecification = blocks[n].fSpecification;
286	// The data type is set automatically to the component's specified output data type.
287	// Place this block into the list of output blocks
288	outputBlocks.push_back( ob );
289	// Increase the total amount of data written so far to our output memory
290	totalSize += mySize;
291	}
292	// Finally we set the total size of output memory we consumed.
293	size = totalSize;
294
295	return 0;
296	}
297
298	bool AliHLTMUONTriggerReconstructorComponent::ReadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookupTable, const char* lutpath)
299	{
300	if (fDDL < AliHLTMUONTriggerReconstructor::GetkDDLOffSet() \|\|
301	fDDL >= AliHLTMUONTriggerReconstructor::GetkDDLOffSet() + AliHLTMUONTriggerReconstructor::GetkNofDDL()){
302	HLTError("DDL number is out of range");
303	return false;
304	}
305
306	int lutLine = fTrigRec->GetLutLine();
307
308	FILE* fin = fopen(lutpath, "r");
309	if (fin == NULL){
310	HLTError("Failed to open file: %s",lutpath);
311	return false;
312	}
313
314	for(int i=0;i<lutLine;i++){
315	fscanf(
316	fin,
317	"%d\t%d\t%d\t%f\t%f\t%f\t%d\t%d\n",
318	&lookupTable[i].fIdManuChannel,
319	&lookupTable[i].fIX,
320	&lookupTable[i].fIY,
321	&lookupTable[i].fRealX,
322	&lookupTable[i].fRealY,
323	&lookupTable[i].fRealZ,
324	&lookupTable[i].fPlane,
325	&lookupTable[i].fPcbZone
326	);
327	}
328
329	fclose(fin);
330	return true;
331	}
332
333	// implement this as well.
334