The DumpEvent methods should be protected, not private, because classes need to inher...
[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONHitReconstructorComponent.cxx
CommitLineData
b0201cbe 1/**************************************************************************
960d54ad 2 * This file is property of and copyright by the ALICE HLT Project *
3 * All rights reserved. *
b0201cbe 4 * *
960d54ad 5 * Primary Authors: *
6 * Indranil Das <indra.das@saha.ac.in> *
b0201cbe 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 *
960d54ad 13 * about the suitability of this software for any purpose. It is *
b0201cbe 14 * provided "as is" without express or implied warranty. *
15 **************************************************************************/
16
17/* $Id$ */
18
baff881d 19///*
20//
21// The HitRec Component is designed to deal the rawdata inputfiles to findout the
22// the reconstructed hits. The output is send to the output block for further
23// processing.
24//
25// Author : Indranil Das ( indra.das@saha.ac.in || indra.ehep@gmail.com )
26//
27//*/
b0201cbe 28
960d54ad 29#include "AliHLTMUONRecHitsBlockStruct.h"
b0201cbe 30#include "AliHLTMUONHitReconstructorComponent.h"
b12fe461 31#include "AliHLTMUONHitReconstructor.h"
960d54ad 32#include "AliHLTMUONConstants.h"
5ff5f960 33#include "AliHLTMUONDataBlockWriter.h"
b0201cbe 34#include "AliHLTLogging.h"
35#include "AliHLTSystem.h"
36#include "AliHLTDefinitions.h"
29486e5a 37#include <cstdlib>
38#include <cerrno>
39#include <cassert>
b0201cbe 40
41namespace
42{
43 // The global object used for automatic component registration,
44 // Note DO NOT use this component for calculation!
45 AliHLTMUONHitReconstructorComponent gAliHLTMUONHitReconstructorComponent;
46}
47
b0201cbe 48ClassImp(AliHLTMUONHitReconstructorComponent)
49
50
29486e5a 51AliHLTMUONHitReconstructorComponent::AliHLTMUONHitReconstructorComponent() :
52 fHitRec(NULL),
53 fDDLDir(""),
54 fDDL(0),
55 fReaderType(false),
56 fWarnForUnexpecedBlock(false)
b0201cbe 57{
b0201cbe 58}
59
960d54ad 60
b0201cbe 61AliHLTMUONHitReconstructorComponent::~AliHLTMUONHitReconstructorComponent()
62{
960d54ad 63}
b0201cbe 64
960d54ad 65const char* AliHLTMUONHitReconstructorComponent::GetComponentID()
66{
29486e5a 67 return AliHLTMUONConstants::HitReconstructorId();
b0201cbe 68}
69
b0201cbe 70
960d54ad 71void AliHLTMUONHitReconstructorComponent::GetInputDataTypes( std::vector<AliHLTComponentDataType>& list)
72{
29486e5a 73 list.clear();
74 list.push_back( AliHLTMUONConstants::TrackingDDLRawDataType() );
960d54ad 75}
b0201cbe 76
b0201cbe 77
960d54ad 78AliHLTComponentDataType AliHLTMUONHitReconstructorComponent::GetOutputDataType()
79{
29486e5a 80 return AliHLTMUONConstants::RecHitsBlockDataType();
960d54ad 81}
b0201cbe 82
b0201cbe 83
960d54ad 84void AliHLTMUONHitReconstructorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
85{
13f09bc1 86 constBase = sizeof(AliHLTMUONRecHitsBlockWriter::HeaderType);
29486e5a 87 inputMultiplier = 1;
960d54ad 88}
b0201cbe 89
b0201cbe 90
960d54ad 91// Spawn function, return new instance of this class
92AliHLTComponent* AliHLTMUONHitReconstructorComponent::Spawn()
93{
29486e5a 94 return new AliHLTMUONHitReconstructorComponent;
960d54ad 95}
b0201cbe 96
b0201cbe 97
29486e5a 98int AliHLTMUONHitReconstructorComponent::DoInit(int argc, const char** argv)
960d54ad 99{
100 // perform initialization. We check whether our relative output size is specified in the arguments.
101
102 HLTInfo("Initialising DHLT HitReconstruction Component");
b0201cbe 103
960d54ad 104 fHitRec = new AliHLTMUONHitReconstructor();
29486e5a 105 fWarnForUnexpecedBlock = false;
b0201cbe 106
960d54ad 107 // this is to get rid of the warning "unused parameter"
108 if (argc==0 && argv==NULL) {
109 HLTError("Arguments missing", " no arguments" );
110 }
b0201cbe 111
960d54ad 112 char lutFileName[500],buspatchFileName[500];
b0201cbe 113
960d54ad 114 int i = 0;
115 char* cpErr;
116 while ( i < argc )
117 {
118 HLTDebug("argv[%d] == %s", i, argv[i] );
119
b8d467da 120 if ( !strcmp( argv[i], "-lut" ) ) {
960d54ad 121 if ( argc <= i+1 ) {
122 HLTError("LookupTable filename not specified" );
123 return EINVAL; /* Invalid argument */
124 }
125
126 sprintf(lutFileName,"%s",argv[i+1]);
127
128 i += 2;
129 continue;
130 }// lut argument
131
132
b8d467da 133 if ( !strcmp( argv[i], "-ddl" ) ) {
960d54ad 134 if ( argc <= i+1 ) {
135 HLTError("DDL number not specified" );
136 return EINVAL; /* Invalid argument */
137 }
138
b8d467da 139 unsigned long num = strtoul( argv[i+1], &cpErr, 0 );
140 if (cpErr == NULL or *cpErr != '\0')
960d54ad 141 {
142 HLTError("Cannot convert '%s' to DDL Number ", argv[i+1] );
143 return EINVAL;
144 }
b8d467da 145 if (num < 13 or 20 < num)
146 {
147 HLTError("The DDL number must be in the range [13..20].");
148 return EINVAL;
149 }
150 fDDL = num - 1;
960d54ad 151
152 i += 2;
153 continue;
154 }// ddl argument
155
156
b8d467da 157 if ( !strcmp( argv[i], "-rawdir" ) ) {
960d54ad 158 if ( argc <= i+1 ) {
159 HLTError("DDL directory not specified" );
160 return EINVAL; /* Invalid argument */
161 }
162
163 fDDLDir = argv[i+1] ;
164
165 i += 2;
166 continue;
167 }// ddl directory argument
168
169
b8d467da 170 if ( !strcmp( argv[i], "-buspatchmap" ) ) {
960d54ad 171 if ( argc <= i+1 ) {
172 HLTError("Buspatch filename not specified" );
173 return EINVAL; /* Invalid argument */
174 }
175
176 sprintf(buspatchFileName,"%s",argv[i+1]);
177
178 i += 2;
179 continue;
180 }// buspatch argument
181
b8d467da 182 if ( !strcmp( argv[i], "-rawreader" ) ) {
960d54ad 183 fReaderType = true; // true when using rawreader for standalone it is set to false.
184 i += 1;
185 continue;
186 }
29486e5a 187
188 if ( !strcmp( argv[i], "-warn_on_unexpected_block" ) ) {
189 fWarnForUnexpecedBlock = true;
190 i++;
191 continue;
192 }
960d54ad 193
194 HLTError("Unknown option '%s'", argv[i] );
195 return EINVAL;
196
197 }//while loop
198
199 int lutline = fHitRec->GetLutLine(fDDL);
baff881d 200 AliHLTMUONHitReconstructor::DHLTLut* lookupTable = new AliHLTMUONHitReconstructor::DHLTLut[lutline];
960d54ad 201 if(!ReadLookUpTable(lookupTable,lutFileName)){
202 HLTError("Failed to read lut, lut cannot be read, DoInit");
b0201cbe 203 return ENOENT ; /* No such file or directory */
204 }else{
960d54ad 205
b0201cbe 206 BusToDetElem busToDetElem;
960d54ad 207 BusToDDL busToDDL;
208 if(!ReadBusPatchToDetElemFile(busToDetElem,busToDDL,buspatchFileName)){
209 HLTError("Failed to read buspatchmap, buspatchmap cannot be read, DoInit");
b0201cbe 210 return ENOENT ; /* No such file or directory */
211 }
960d54ad 212
b0201cbe 213 fHitRec->SetBusToDetMap(busToDetElem);
960d54ad 214 fHitRec->SetBusToDDLMap(busToDDL);
215 fHitRec->LoadLookUpTable(lookupTable,fDDL);
216
b0201cbe 217 }// reading lut
218
960d54ad 219 delete []lookupTable;
220
221 HLTInfo("Initialisation of DHLT HitReconstruction Component is done");
222
b0201cbe 223 return 0;
224}
225
960d54ad 226
227int AliHLTMUONHitReconstructorComponent::DoDeinit()
228{
b0201cbe 229 if(fHitRec)
230 delete fHitRec;
960d54ad 231
232 HLTInfo(" Deinitialising DHLT HitReconstruction Component");
233
b0201cbe 234 return 0;
235}
236
b0201cbe 237
960d54ad 238int AliHLTMUONHitReconstructorComponent::DoEvent(
239 const AliHLTComponentEventData& evtData,
b8d467da 240 const AliHLTComponentBlockData* blocks,
241 AliHLTComponentTriggerData& /*trigData*/,
242 AliHLTUInt8_t* outputPtr,
960d54ad 243 AliHLTUInt32_t& size,
244 std::vector<AliHLTComponentBlockData>& outputBlocks
245 )
246{
29486e5a 247 // Process an event
248 unsigned long totalSize = 0; // Amount of memory currently consumed in bytes.
b0201cbe 249
29486e5a 250 HLTDebug("Processing event %llu with %u input data blocks.",
251 evtData.fEventID, evtData.fBlockCnt
252 );
253
254 // Loop over all input blocks in the event
255 for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
5ff5f960 256 {
29486e5a 257#ifdef __DEBUG
258 char id[kAliHLTComponentDataTypefIDsize+1];
259 for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
260 id[i] = blocks[n].fDataType.fID[i];
261 id[kAliHLTComponentDataTypefIDsize] = '\0';
262 char origin[kAliHLTComponentDataTypefOriginSize+1];
263 for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
264 origin[i] = blocks[n].fDataType.fOrigin[i];
265 origin[kAliHLTComponentDataTypefOriginSize] = '\0';
266#endif // __DEBUG
267 HLTDebug("Handling block: %u, with fDataType.fID = '%s',"
268 " fDataType.fID = '%s', fPtr = %p and fSize = %u bytes.",
269 n, static_cast<char*>(id), static_cast<char*>(origin),
270 blocks[n].fPtr, blocks[n].fSize
5ff5f960 271 );
29486e5a 272
273 if (blocks[n].fDataType != AliHLTMUONConstants::TrackingDDLRawDataType())
274 {
275 // Log a message indicating that we got a data block that we
276 // do not know how to handle.
277 char id[kAliHLTComponentDataTypefIDsize+1];
278 for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
279 id[i] = blocks[n].fDataType.fID[i];
280 id[kAliHLTComponentDataTypefIDsize] = '\0';
281 char origin[kAliHLTComponentDataTypefOriginSize+1];
282 for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
283 origin[i] = blocks[n].fDataType.fOrigin[i];
284 origin[kAliHLTComponentDataTypefOriginSize] = '\0';
285
286 if (fWarnForUnexpecedBlock)
d42549e3 287 HLTWarning("Received a data block of a type we cannot handle: '%s' origin: '%s'",
29486e5a 288 static_cast<char*>(id), static_cast<char*>(origin)
289 );
290 else
d42549e3 291 HLTDebug("Received a data block of a type we cannot handle: '%s' origin: '%s'",
29486e5a 292 static_cast<char*>(id), static_cast<char*>(origin)
293 );
294
295 continue;
296 }
297
298 // Create a new output data block and initialise the header.
299 AliHLTMUONRecHitsBlockWriter block(outputPtr+totalSize, size-totalSize);
300 if (not block.InitCommonHeader())
301 {
302 HLTError("There is not enough space in the output buffer for the new data block.",
303 " We require at least %u bytes, but have %u bytes left.",
304 sizeof(AliHLTMUONRecHitsBlockWriter::HeaderType),
305 block.BufferSize()
306 );
307 break;
308 }
309
310 AliHLTUInt32_t totalDDLSize = blocks[n].fSize / sizeof(AliHLTUInt32_t);
311 AliHLTUInt32_t ddlRawDataSize = totalDDLSize - fHitRec->GetkDDLHeaderSize();
312 AliHLTUInt32_t* buffer = reinterpret_cast<AliHLTUInt32_t*>(blocks[n].fPtr)
313 + fHitRec->GetkDDLHeaderSize();
314 AliHLTUInt32_t nofHit = block.MaxNumberOfEntries();
315
316 HLTDebug("=========== Dumping DDL payload buffer ==========");
317 for (AliHLTUInt32_t j = 0; j < totalDDLSize; j++)
318 HLTDebug("buffer[%d] : %x",j,buffer[j]);
319 HLTDebug("================== End of dump =================");
320
321 if (not fHitRec->Run(buffer, ddlRawDataSize, block.GetArray(), nofHit))
322 {
323 HLTError("Error while processing of hit reconstruction algorithm.");
324 size = totalSize; // Must tell the framework how much buffer space was used.
325 return EIO;
326 }
327
328 // nofHit should now contain the number of reconstructed hits actually found
329 // and filled into the output data block, so we can set this number.
330 assert( nofHit <= block.MaxNumberOfEntries() );
331 block.SetNumberOfEntries(nofHit);
332
333 HLTDebug("Number of reconstructed hits found is %d", nofHit);
334
335 // Fill a block data structure for our output block.
336 AliHLTComponentBlockData bd;
337 FillBlockData(bd);
338 bd.fPtr = outputPtr;
339 // This block's start (offset) is after all other blocks written so far.
340 bd.fOffset = totalSize;
341 bd.fSize = block.BytesUsed();
342 bd.fDataType = AliHLTMUONConstants::RecHitsBlockDataType();
343 bd.fSpecification = blocks[n].fSpecification;
344 outputBlocks.push_back(bd);
345
346 // Increase the total amount of data written so far to our output memory
347 totalSize += block.BytesUsed();
5ff5f960 348 }
29486e5a 349 // Finally we set the total size of output memory we consumed.
350 size = totalSize;
351
352 return 0;
b0201cbe 353}
354
355
960d54ad 356bool AliHLTMUONHitReconstructorComponent::ReadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookupTable, const char* lutpath)
b0201cbe 357{
960d54ad 358 if (fDDL < AliHLTMUONHitReconstructor::GetkDDLOffSet() ||
359 fDDL >= AliHLTMUONHitReconstructor::GetkDDLOffSet() + AliHLTMUONHitReconstructor::GetkNofDDL()){
360 HLTError("DDL number is out of range");
361 return false;
362 }
363
364 int lutLine = fHitRec->GetLutLine(fDDL);
365
366 FILE* fin = fopen(lutpath, "r");
367 if (fin == NULL){
368 HLTError("Failed to open file: %s",lutpath);
369 return false;
370 }
371
372 for(int i=0;i<lutLine;i++){
373 fscanf(
374 fin,
375 "%d\t%d\t%d\t%f\t%f\t%f\t%d\t%d\n",
376 &lookupTable[i].fIdManuChannel,
377 &lookupTable[i].fIX,
378 &lookupTable[i].fIY,
379 &lookupTable[i].fRealX,
380 &lookupTable[i].fRealY,
381 &lookupTable[i].fRealZ,
382 &lookupTable[i].fPcbZone,
383 &lookupTable[i].fPlane
384 );
385 }
386
387 fclose(fin);
388 return true;
b0201cbe 389}
390
b0201cbe 391
960d54ad 392bool AliHLTMUONHitReconstructorComponent::ReadBusPatchToDetElemFile(BusToDetElem& busToDetElem, BusToDDL& busToDDL, const char* buspatchmappath)
b0201cbe 393{
960d54ad 394 char getLine[80];
395 char temp;
396 int detElem, minBusPatch, maxBusPatch, ddl;
397
398 FILE* fin = fopen(buspatchmappath, "r");
399 if (fin == NULL){
400 HLTError("Failed to open file: %s",buspatchmappath);
401 return false;
402 }
403
404 while (feof(fin)==0){
405 fgets(getLine,80,fin);
406 sscanf(getLine, "%d\t%d %c %d\t%d", &detElem, &minBusPatch, &temp, &maxBusPatch,&ddl);
407 if (detElem >= 700 && detElem <= 1025){
408
409 for(int i = minBusPatch; i <= maxBusPatch; i++){
410 busToDetElem[i] = detElem;
411 busToDDL[i] = ddl;
412 }//for loop
413 } // detElem condn
414 } // while loop for file
415
416 fclose(fin);
417 return true;
b0201cbe 418}