The multiplier for data volume estimation was too low.
[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONTriggerReconstructorComponent.cxx
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  Implementation of the trigger DDL reconstructor component. */
23
24 #include "AliHLTMUONTriggerReconstructorComponent.h"
25 #include "AliHLTMUONTriggerReconstructor.h"
26 #include "AliHLTMUONHitReconstructor.h"
27 #include "AliHLTMUONConstants.h"
28 #include "AliHLTMUONDataBlockWriter.h"
29 #include <cstdlib>
30 #include <cerrno>
31 #include <cassert>
32
33 namespace
34 {
35         // This is a global object used for automatic component registration,
36         // do not use this for calculation.
37         AliHLTMUONTriggerReconstructorComponent gAliHLTMUONTriggerReconstructorComponent;
38
39 } // end of namespace
40
41
42 ClassImp(AliHLTMUONTriggerReconstructorComponent)
43     
44     
45 AliHLTMUONTriggerReconstructorComponent::AliHLTMUONTriggerReconstructorComponent() :
46         fTrigRec(NULL),
47         fDDLDir(""),
48         fDDL(0),
49         fWarnForUnexpecedBlock(false),
50         fSuppressPartialTrigs(false)
51 {
52 }
53
54
55 AliHLTMUONTriggerReconstructorComponent::~AliHLTMUONTriggerReconstructorComponent()
56 {
57 }
58
59
60 const char* AliHLTMUONTriggerReconstructorComponent::GetComponentID()
61 {
62         return AliHLTMUONConstants::TriggerReconstructorId();
63 }
64
65
66 void AliHLTMUONTriggerReconstructorComponent::GetInputDataTypes( std::vector<AliHLTComponentDataType>& list)
67 {
68         list.clear();
69         list.push_back( AliHLTMUONConstants::TriggerDDLRawDataType() );
70 }
71
72
73 AliHLTComponentDataType AliHLTMUONTriggerReconstructorComponent::GetOutputDataType()
74 {
75         return AliHLTMUONConstants::TriggerRecordsBlockDataType();
76 }
77
78
79 void AliHLTMUONTriggerReconstructorComponent::GetOutputDataSize(
80                 unsigned long& constBase, double& inputMultiplier
81         )
82 {
83         constBase = sizeof(AliHLTMUONTriggerRecordsBlockWriter::HeaderType);
84         inputMultiplier = 4;
85 }
86
87
88 AliHLTComponent* AliHLTMUONTriggerReconstructorComponent::Spawn()
89 {
90         return new AliHLTMUONTriggerReconstructorComponent;
91 }
92
93
94 int AliHLTMUONTriggerReconstructorComponent::DoInit(int argc, const char** argv)
95 {
96   // perform initialization. We check whether our relative output size is
97   // specified in the arguments.
98   
99   HLTInfo("Initialising DHLT Trigger Record Component");
100
101   fWarnForUnexpecedBlock = false;
102   fSuppressPartialTrigs = false;
103   fTrigRec = new AliHLTMUONTriggerReconstructor();
104       
105   // this is just to get rid of the warning "unused parameter"
106   if (argc==0 && argv==NULL) {
107     HLTError("Arguments missing, no arguments" );
108   }
109
110   char lutFileName[500],reglocFileName[500];
111
112   int i = 0;
113   char* cpErr;
114   while ( i < argc )
115     {
116       HLTDebug("argv[%d] == %s", i, argv[i] );
117       
118       if ( !strcmp( argv[i], "lut" ) ) {
119         if ( argc <= i+1 ) {
120           HLTError("LookupTable filename not specified" );
121           return EINVAL; /* Invalid argument */ 
122         }
123         
124         sprintf(lutFileName,"%s",argv[i+1]);
125         
126         i += 2;
127         continue;
128       }// lut argument
129       
130       if ( !strcmp( argv[i], "ddl" ) ) {
131         if ( argc <= i+1 ) {
132           HLTError("DDL number not specified" );
133           return EINVAL;  /* Invalid argument */
134         }
135
136         fDDL = strtoul( argv[i+1], &cpErr, 0 );
137         if ( *cpErr )
138           {
139             HLTError("Cannot convert '%s' to DDL Number ", argv[i+1] );
140             return EINVAL;
141           }
142         //fDDL = atoi(argv[i+1]);
143         
144         i += 2;
145         continue;
146       }// ddl argument
147           
148       if ( !strcmp( argv[i], "rawdir" ) ) {
149         if ( argc <= i+1 ) {
150           HLTError("DDL directory not specified" );
151           return EINVAL;  /* Invalid argument */
152         }
153
154         fDDLDir = argv[i+1] ;
155         i += 2;
156         continue;
157       }// ddl directory argument
158
159       if ( !strcmp( argv[i], "reglocmap" ) ) {
160         if ( argc <= i+1 ) {
161           HLTError("Regional to Local Card mapping  filename not specified" );
162           return EINVAL; /* Invalid argument */
163         }
164
165         sprintf(reglocFileName,"%s",argv[i+1]);
166
167         i += 2;
168         continue;
169       }// regtolocalmap argument
170           
171       if ( !strcmp( argv[i], "-warn_on_unexpected_block" ) ) {
172         fWarnForUnexpecedBlock = true;
173         i++;
174         continue;
175       }
176           
177       if ( !strcmp( argv[i], "-suppress_partial_triggers" ) ) {
178         fSuppressPartialTrigs = true;
179         i++;
180         continue;
181       }
182
183       HLTError("Unknown option '%s'", argv[i] );
184       return EINVAL;
185           
186     }//while loop
187
188     int lutline = fTrigRec->GetLutLine();
189     AliHLTMUONHitReconstructor::DHLTLut* lookupTable = new AliHLTMUONHitReconstructor::DHLTLut[lutline];
190     if(!ReadLookUpTable(lookupTable,lutFileName)){
191       HLTError("Failed to read lut, lut cannot be read");
192       return ENOENT ; /* No such file or directory */
193     }else{
194       
195       fTrigRec->LoadLookUpTable(lookupTable,fDDL+AliHLTMUONTriggerReconstructor::GetkDDLOffSet());
196
197       AliHLTMUONTriggerReconstructor::RegToLoc regToLocMap[128]; // 16(locCard)*8(regCard)
198       if(!ReadRegToLocMap(regToLocMap,reglocFileName)){
199         HLTError("Failed to read RegToLocMap file");
200         return ENOENT ; /* No such file or directory */
201       }
202
203       if(!(fTrigRec->SetRegToLocCardMap(regToLocMap))){
204         HLTError("Failed to assign RegToLocMap to TrigRec Class due to memory problem");
205         return ENOMEM ; /*cannot allocate memory*/
206       }
207       
208     }// reading lut
209
210     delete []lookupTable;
211
212     HLTInfo("Initialisation of DHLT Trigger Record Component is done");
213
214     return 0;
215 }
216
217
218 int AliHLTMUONTriggerReconstructorComponent::DoDeinit()
219 {
220         HLTInfo("Deinitialising DHLT Trigger Record Component");
221
222         if(fTrigRec)
223         {
224                 delete fTrigRec;
225                 fTrigRec = NULL;
226         }
227         return 0;
228 }
229
230
231 int AliHLTMUONTriggerReconstructorComponent::DoEvent(
232                 const AliHLTComponentEventData& evtData,
233                 const AliHLTComponentBlockData* blocks, 
234                 AliHLTComponentTriggerData& trigData,
235                 AliHLTUInt8_t* outputPtr, 
236                 AliHLTUInt32_t& size,
237                 std::vector<AliHLTComponentBlockData>& outputBlocks
238         )
239 {
240         // Process an event
241         unsigned long totalSize = 0; // Amount of memory currently consumed in bytes.
242
243         HLTDebug("Processing event %llu with %u input data blocks.",
244                 evtData.fEventID, evtData.fBlockCnt
245         );
246         
247         // Loop over all input blocks in the event and run the trigger DDL
248         // reconstruction algorithm on the raw data.
249         for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
250         {
251 #ifdef __DEBUG
252                 char id[kAliHLTComponentDataTypefIDsize+1];
253                 for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
254                         id[i] = blocks[n].fDataType.fID[i];
255                 id[kAliHLTComponentDataTypefIDsize] = '\0';
256                 char origin[kAliHLTComponentDataTypefOriginSize+1];
257                 for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
258                         origin[i] = blocks[n].fDataType.fOrigin[i];
259                 origin[kAliHLTComponentDataTypefOriginSize] = '\0';
260 #endif // __DEBUG
261                 HLTDebug("Handling block: %u, with fDataType.fID = '%s',"
262                           " fDataType.fID = '%s', fPtr = %p and fSize = %u bytes.",
263                         n, static_cast<char*>(id), static_cast<char*>(origin),
264                         blocks[n].fPtr, blocks[n].fSize
265                 );
266
267                 if (blocks[n].fDataType != AliHLTMUONConstants::TriggerDDLRawDataType())
268                 {
269                         // Log a message indicating that we got a data block that we
270                         // do not know how to handle.
271                         char id[kAliHLTComponentDataTypefIDsize+1];
272                         for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
273                                 id[i] = blocks[n].fDataType.fID[i];
274                         id[kAliHLTComponentDataTypefIDsize] = '\0';
275                         char origin[kAliHLTComponentDataTypefOriginSize+1];
276                         for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
277                                 origin[i] = blocks[n].fDataType.fOrigin[i];
278                         origin[kAliHLTComponentDataTypefOriginSize] = '\0';
279                         
280                         if (fWarnForUnexpecedBlock)
281                                 HLTWarning("Received a data block of a type we can not handle: %s origin %s",
282                                         static_cast<char*>(id), static_cast<char*>(origin)
283                                 );
284                         else
285                                 HLTDebug("Received a data block of a type we can not handle: %s origin %s",
286                                         static_cast<char*>(id), static_cast<char*>(origin)
287                                 );
288                         
289                         continue;
290                 }
291                 
292                 // Create a new output data block and initialise the header.
293                 AliHLTMUONTriggerRecordsBlockWriter block(outputPtr+totalSize, size-totalSize);
294                 if (not block.InitCommonHeader())
295                 {
296                         HLTError("There is not enough space in the output buffer for the new data block.",
297                                  " We require at least %u bytes, but have %u bytes left.",
298                                 sizeof(AliHLTMUONTriggerRecordsBlockWriter::HeaderType),
299                                 block.BufferSize()
300                         );
301                         break;
302                 }
303
304                 AliHLTUInt32_t totalDDLSize = blocks[n].fSize / sizeof(AliHLTUInt32_t);
305                 AliHLTUInt32_t ddlRawDataSize = totalDDLSize - fTrigRec->GetkDDLHeaderSize();
306                 AliHLTUInt32_t* buffer = reinterpret_cast<AliHLTUInt32_t*>(blocks[n].fPtr)
307                         + fTrigRec->GetkDDLHeaderSize();
308                 AliHLTUInt32_t nofTrigRec = block.MaxNumberOfEntries();
309
310                 bool runOk = fTrigRec->Run(
311                                 buffer, ddlRawDataSize,
312                                 block.GetArray(), nofTrigRec,
313                                 fSuppressPartialTrigs
314                         );
315                 if (not runOk)
316                 {
317                         HLTError("Error while processing of trigger DDL reconstruction algorithm.");
318                         size = totalSize; // Must tell the framework how much buffer space was used.
319                         return EIO;
320                 }
321                 
322                 // nofTrigRec should now contain the number of triggers actually found
323                 // and filled into the output data block, so we can set this number.
324                 assert( nofTrigRec <= block.MaxNumberOfEntries() );
325                 block.SetNumberOfEntries(nofTrigRec);
326                 
327                 HLTDebug("Number of trigger records found is %d", nofTrigRec);
328                 
329                 // Fill a block data structure for our output block.
330                 AliHLTComponentBlockData bd;
331                 FillBlockData(bd);
332                 bd.fPtr = outputPtr;
333                 // This block's start (offset) is after all other blocks written so far.
334                 bd.fOffset = totalSize;
335                 bd.fSize = block.BytesUsed();
336                 bd.fDataType = AliHLTMUONConstants::TriggerRecordsBlockDataType();
337                 bd.fSpecification = blocks[n].fSpecification;
338                 outputBlocks.push_back(bd);
339                 
340                 HLTDebug("Created a new output data block at fPtr = %p,"
341                           " with fOffset = %u (0x%.X) and fSize = %u bytes.", 
342                         bd.fPtr, bd.fOffset, bd.fOffset, bd.fSize
343                 );
344                 
345                 // Increase the total amount of data written so far to our output memory.
346                 totalSize += block.BytesUsed();
347         }
348         
349         // Finally we set the total size of output memory we consumed.
350         size = totalSize;
351         return 0;
352 }
353
354
355 bool AliHLTMUONTriggerReconstructorComponent::ReadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookupTable, const char* lutpath)
356 {
357   if (fDDL < 0 || fDDL >= 2){
358     HLTError("DDL number is out of range");
359     return false;
360   }
361   
362   int lutLine = fTrigRec->GetLutLine();
363   
364   FILE* fin = fopen(lutpath, "r");
365   if (fin == NULL){
366     HLTError("Failed to open file: %s",lutpath);
367     return false;
368   }
369   
370   for(int i=0;i<lutLine;i++){
371     fscanf(
372            fin,
373            "%d\t%d\t%d\t%f\t%f\t%f\t%d\t%d\n",
374            &lookupTable[i].fIdManuChannel,
375            &lookupTable[i].fIX,
376            &lookupTable[i].fIY,
377            &lookupTable[i].fRealX,
378            &lookupTable[i].fRealY,
379            &lookupTable[i].fRealZ,
380            &lookupTable[i].fPcbZone,
381            &lookupTable[i].fPlane
382            );
383   }
384   
385   fclose(fin);
386   return true;
387 }
388
389
390 bool AliHLTMUONTriggerReconstructorComponent::ReadRegToLocMap(AliHLTMUONTriggerReconstructor::RegToLoc* regToLocMap,const char* reglocFileName)
391 {
392   int iTrigDDL,iReg,iLoc,locId,switchWord,detElemId[4];
393   int index;
394
395   memset(regToLocMap,-1,128*sizeof(AliHLTMUONTriggerReconstructor::RegToLoc));
396
397   char s[100];
398   ifstream fin(reglocFileName);
399   
400   if(!fin){
401     HLTError("Failed to open file %s",reglocFileName);
402     return false;
403   }
404
405   while(fin.getline(s,100)){
406     sscanf(s,"%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d",
407            &iTrigDDL,&iReg,&iLoc,&locId,&switchWord,&detElemId[0],&detElemId[1],&detElemId[2],&detElemId[3]);
408     if(iTrigDDL==fDDL){
409       index = iReg*16 + iLoc;
410       regToLocMap[index].fTrigDDL = iTrigDDL ; 
411       regToLocMap[index].fRegId = iReg ;
412       regToLocMap[index].fLoc = iLoc ;
413       regToLocMap[index].fLocId = locId ;  
414       regToLocMap[index].fSwitch = switchWord ;
415       for(int idet = 0; idet<4; idet++)
416         regToLocMap[index].fDetElemId[idet] = detElemId[idet] ;
417     }// if matches with fDDL
418   }//file loop
419   
420   fin.close();
421   return true;
422 }