Fixing coding violations and getting rid of warnings.
[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONMansoTrackerFSMComponent.cxx
1 /**************************************************************************
2  * This file is property of and copyright by the ALICE HLT Project        * 
3  * All rights reserved.                                                   *
4  *                                                                        *
5  * Primary Authors:                                                       *
6  *   Artur Szostak <artursz@iafrica.com>                                  *
7  *   Indranil Das <indra.das@saha.ac.in>                                  *
8  *                                                                        *
9  * Permission to use, copy, modify and distribute this software and its   *
10  * documentation strictly for non-commercial purposes is hereby granted   *
11  * without fee, provided that the above copyright notice appears in all   *
12  * copies and that both the copyright notice and this permission notice   *
13  * appear in the supporting documentation. The authors make no claims     *
14  * about the suitability of this software for any purpose. It is          * 
15  * provided "as is" without express or implied warranty.                  *
16  **************************************************************************/
17
18 /* $Id$ */
19
20 ///
21 ///  @file   AliHLTMUONMansoTrackerFSMComponent.cxx
22 ///  @author Artur Szostak <artursz@iafrica.com>,
23 ///          Indranil Das <indra.das@saha.ac.in>
24 ///  @date   
25 ///  @brief  Implementation of AliHLTMUONMansoTrackerFSMComponent class.
26 ///
27
28 #include "AliHLTMUONMansoTrackerFSMComponent.h"
29 #include "AliHLTMUONConstants.h"
30 #include "AliHLTMUONUtils.h"
31 #include "AliHLTMUONMansoTrackerFSM.h"
32 #include "AliHLTMUONDataBlockReader.h"
33 #include "AliHLTMUONDataBlockWriter.h"
34 #include <cstdlib>
35 #include <cstring>
36 #include <cerrno>
37
38 ClassImp(AliHLTMUONMansoTrackerFSMComponent);
39
40
41 AliHLTMUONMansoTrackerFSMComponent::AliHLTMUONMansoTrackerFSMComponent() :
42         AliHLTProcessor(),
43         AliHLTMUONMansoTrackerFSMCallback(),
44         fTracker(NULL),
45         fTrackCount(0),
46         fBlock(NULL),
47         fWarnForUnexpecedBlock(false)
48 {
49         ///
50         /// Default constructor.
51         ///
52 }
53
54
55 AliHLTMUONMansoTrackerFSMComponent::~AliHLTMUONMansoTrackerFSMComponent()
56 {
57         ///
58         /// Default destructor.
59         ///
60         
61         assert( fTracker == NULL );
62 }
63
64
65 const char* AliHLTMUONMansoTrackerFSMComponent::GetComponentID()
66 {
67         ///
68         /// Inherited from AliHLTComponent. Returns the component ID.
69         ///
70         
71         return AliHLTMUONConstants::MansoTrackerFSMId();
72 }
73
74
75 void AliHLTMUONMansoTrackerFSMComponent::GetInputDataTypes(
76                 vector<AliHLTComponentDataType>& list
77         )
78 {
79         ///
80         /// Inherited from AliHLTProcessor. Returns the list of expected input data types.
81         ///
82         
83         assert( list.empty() );
84         list.push_back( AliHLTMUONConstants::TriggerRecordsBlockDataType() );
85         list.push_back( AliHLTMUONConstants::RecHitsBlockDataType() );
86 }
87
88
89 AliHLTComponentDataType AliHLTMUONMansoTrackerFSMComponent::GetOutputDataType()
90 {
91         ///
92         /// Inherited from AliHLTComponent. Returns the output data type.
93         ///
94         
95         return AliHLTMUONConstants::MansoTracksBlockDataType();
96 }
97
98
99 void AliHLTMUONMansoTrackerFSMComponent::GetOutputDataSize(
100                 unsigned long& constBase, double& inputMultiplier
101         )
102 {
103         ///
104         /// Inherited from AliHLTComponent. Returns an estimate of the expected output data size.
105         ///
106         
107         constBase = sizeof(AliHLTMUONMansoTracksBlockStruct);
108         inputMultiplier = 1;
109 }
110
111
112 AliHLTComponent* AliHLTMUONMansoTrackerFSMComponent::Spawn()
113 {
114         ///
115         /// Inherited from AliHLTComponent. Creates a new object instance.
116         ///
117         
118         return new AliHLTMUONMansoTrackerFSMComponent;
119 }
120
121
122 int AliHLTMUONMansoTrackerFSMComponent::DoInit(int argc, const char** argv)
123 {
124         ///
125         /// Inherited from AliHLTComponent.
126         /// Parses the command line parameters and initialises the component.
127         ///
128         
129         fTracker = new AliHLTMUONMansoTrackerFSM();
130         fTracker->SetCallback(this);
131         
132         fWarnForUnexpecedBlock = false;
133         
134         for (int i = 0; i < argc; i++)
135         {
136                 if (strcmp(argv[i], "-warn_on_unexpected_block") == 0)
137                         fWarnForUnexpecedBlock = true;
138         }
139         
140         return 0;
141 }
142
143
144 int AliHLTMUONMansoTrackerFSMComponent::DoDeinit()
145 {
146         ///
147         /// Inherited from AliHLTComponent. Performs a cleanup of the component.
148         ///
149         
150         if (fTracker != NULL)
151         {
152                 delete fTracker;
153                 fTracker = NULL;
154         }
155         return 0;
156 }
157
158
159 int AliHLTMUONMansoTrackerFSMComponent::DoEvent(
160                 const AliHLTComponentEventData& evtData,
161                 const AliHLTComponentBlockData* blocks,
162                 AliHLTComponentTriggerData& /*trigData*/,
163                 AliHLTUInt8_t* outputPtr,
164                 AliHLTUInt32_t& size,
165                 std::vector<AliHLTComponentBlockData>& outputBlocks
166         )
167 {
168         ///
169         /// Inherited from AliHLTProcessor. Processes the new event data.
170         ///
171         
172         Reset();
173         AliHLTUInt32_t specification = 0;  // Contains the output data block spec bits.
174         
175         AliHLTMUONMansoTracksBlockWriter block(outputPtr, size);
176         fBlock = &block;
177         
178         if (not block.InitCommonHeader())
179         {
180                 Logging(kHLTLogError,
181                         "AliHLTMUONMansoTrackerFSMComponent::DoEvent",
182                         "Buffer overflow",
183                         "The buffer is only %d bytes in size. We need a minimum of %d bytes.",
184                         size, sizeof(AliHLTMUONMansoTracksBlockWriter::HeaderType)
185                 );
186                 size = 0; // Important to tell framework that nothing was generated.
187                 return ENOBUFS;
188         }
189
190         // Loop over all input blocks in the event and add the ones that contain
191         // reconstructed hits into the hit buffers. The blocks containing trigger
192         // records are ignored for now and will be processed later.
193         for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
194         {
195                 if (blocks[n].fDataType == AliHLTMUONConstants::RecHitsBlockDataType())
196                 {
197                         specification |= blocks[n].fSpecification;
198                         
199                         AliHLTMUONRecHitsBlockReader inblock(blocks[n].fPtr, blocks[n].fSize);
200                         if (not inblock.BufferSizeOk())
201                         {
202                                 size_t headerSize = sizeof(AliHLTMUONRecHitsBlockReader::HeaderType);
203                                 if (blocks[n].fSize < headerSize)
204                                 {
205                                         HLTError("Received a reconstructed hits data block with a size of %d bytes,"
206                                                 " which is smaller than the minimum valid header size of %d bytes."
207                                                 " The block must be corrupt.",
208                                                 blocks[n].fSize, headerSize
209                                         );
210                                         continue;
211                                 }
212                                 
213                                 size_t expectedWidth = sizeof(AliHLTMUONRecHitsBlockReader::ElementType);
214                                 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
215                                 {
216                                         HLTError("Received a reconstructed hits data block with a record"
217                                                 " width of %d bytes, but the expected value is %d bytes."
218                                                 " The block might be corrupt.",
219                                                 blocks[n].fSize, headerSize
220                                         );
221                                         continue;
222                                 }
223                                 
224                                 HLTError("Received a reconstructed hits data block with a size of %d bytes,"
225                                         " but the block header claims the block should be %d bytes."
226                                         " The block might be corrupt.",
227                                         blocks[n].fSize, inblock.BytesUsed()
228                                 );
229                                 continue;
230                         }
231                         
232                         if (inblock.Nentries() != 0)
233                                 AddRecHits(blocks[n].fSpecification, inblock.GetArray(), inblock.Nentries());
234                         else
235                         {
236                                 Logging(kHLTLogDebug,
237                                         "AliHLTMUONMansoTrackerFSMComponent::DoEvent",
238                                         "Block empty",
239                                         "Received a reconstructed hits data block which contains no entries."
240                                 );
241                         }
242                 }
243                 else if (blocks[n].fDataType != AliHLTMUONConstants::TriggerRecordsBlockDataType())
244                 {
245                         // Log a message indicating that we got a data block that we
246                         // do not know how to handle.
247                         char id[kAliHLTComponentDataTypefIDsize+1];
248                         for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
249                                 id[i] = blocks[n].fDataType.fID[i];
250                         id[kAliHLTComponentDataTypefIDsize] = '\0';
251                         char origin[kAliHLTComponentDataTypefOriginSize+1];
252                         for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
253                                 origin[i] = blocks[n].fDataType.fOrigin[i];
254                         origin[kAliHLTComponentDataTypefOriginSize] = '\0';
255                         
256                         if (fWarnForUnexpecedBlock)
257                                 HLTWarning("Received a data block of a type we cannot handle: %s origin: %s",
258                                         static_cast<char*>(id), static_cast<char*>(origin)
259                                 );
260                         else
261                                 HLTDebug("Received a data block of a type we cannot handle: %s origin: %s",
262                                         static_cast<char*>(id), static_cast<char*>(origin)
263                                 );
264                 }
265         }
266   
267         // Again loop over all input blocks in the event, but this time look for
268         // the trigger record blocks and process these.
269         for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
270         {
271                 if (blocks[n].fDataType != AliHLTMUONConstants::TriggerRecordsBlockDataType())
272                         continue;
273                 
274                 AliHLTMUONTriggerRecordsBlockReader inblock(blocks[n].fPtr, blocks[n].fSize);
275                 if (not inblock.BufferSizeOk())
276                 {
277                         size_t headerSize = sizeof(AliHLTMUONTriggerRecordsBlockReader::HeaderType);
278                         if (blocks[n].fSize < headerSize)
279                         {
280                                 HLTError("Received a trigger records data block with a size of %d bytes,"
281                                         " which is smaller than the minimum valid header size of %d bytes."
282                                         " The block must be corrupt.",
283                                         blocks[n].fSize, headerSize
284                                 );
285                                 continue;
286                         }
287                         
288                         size_t expectedWidth = sizeof(AliHLTMUONTriggerRecordsBlockReader::ElementType);
289                         if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
290                         {
291                                 HLTError("Received a trigger records data block with a record"
292                                         " width of %d bytes, but the expected value is %d bytes."
293                                         " The block might be corrupt.",
294                                         blocks[n].fSize, headerSize
295                                 );
296                                 continue;
297                         }
298                         
299                         HLTError("Received a trigger records data block with a size of %d bytes,"
300                                 " but the block header claims the block should be %d bytes."
301                                 " The block might be corrupt.",
302                                 blocks[n].fSize, inblock.BytesUsed()
303                         );
304                         continue;
305                 }
306                 DebugTrace("Processing a trigger block with "
307                         << inblock.Nentries() << " entries."
308                 );
309                 
310                 specification |= blocks[n].fSpecification;
311                 
312                 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
313                 {
314                         fTracker->FindTrack(inblock[i]);
315                         
316                         // Reset the tracker so that we do not double count tracks.
317                         fTracker->Reset();
318                 }
319         }
320         
321         AliHLTComponentBlockData bd;
322         FillBlockData(bd);
323         bd.fPtr = outputPtr;
324         bd.fOffset = 0;
325         bd.fSize = block.BytesUsed();
326         bd.fDataType = AliHLTMUONConstants::MansoTracksBlockDataType();
327         bd.fSpecification = specification;
328         outputBlocks.push_back(bd);
329         size = block.BytesUsed();
330
331         return 0;
332 }
333
334
335 void AliHLTMUONMansoTrackerFSMComponent::Reset()
336 {
337         ///
338         /// Reset the track count and reconstructed hit data block arrays.
339         ///
340         
341         DebugTrace("Resetting AliHLTMUONMansoTrackerFSMComponent.");
342
343         //fTracker->Reset();  // Not necessary here because it is done after every FindTrack call.
344         fTrackCount = 0;
345         fBlock = NULL;  // Do not delete. Already done implicitly at the end of DoEvent.
346         for (int i = 0; i < 4; i++)
347         {
348                 fRecHitBlock[i].erase(fRecHitBlock[i].begin(), fRecHitBlock[i].end());
349         }
350 }
351
352
353 void AliHLTMUONMansoTrackerFSMComponent::AddRecHits(
354                 AliHLTUInt32_t specification,
355                 const AliHLTMUONRecHitStruct* recHits,
356                 AliHLTUInt32_t count
357         )
358 {
359         ///
360         /// Adds a new reconstructed hit data block to the internal list of blocks
361         /// for the tracker to process.
362         /// These lists will later be used when the tracker requests them through
363         /// the callback method 'RequestClusters'.
364         ///
365         
366         DebugTrace("AliHLTMUONMansoTrackerFSMComponent::AddRecHits called with specification = 0x"
367                  << std::hex << specification << std::dec << " and count = "
368                  << count << " rec hits."
369         );
370         
371         AliHLTUInt8_t chamberMap[20] = {
372                 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10
373         };
374         
375         // Identify the chamber the rec hits came from using the specifications field.
376         bool gotDataFromDDL[22];
377         AliHLTMUONUtils::UnpackSpecBits(specification, gotDataFromDDL);
378                 
379         AliHLTInt8_t chamber = -1;
380         for (int i = 0; i < 20; i++)
381         {
382                 if (not gotDataFromDDL[i]) continue;
383                 if (7 <= chamberMap[i] and chamberMap[i] <= 10)
384                 {
385                         if (chamber != -1 and chamber != chamberMap[i])
386                         {
387                                 Logging(kHLTLogError,
388                                         "AliHLTMUONMansoTrackerFSMComponent::AddRecHits",
389                                         "Invalid block",
390                                         "Received a data block with data from multiple chambers."
391                                           " This component cannot handle such a case."
392                                 );
393                                 return;
394                         }
395                         else
396                                 chamber = chamberMap[i];
397                 }
398                 else
399                 {
400                         Logging(kHLTLogError,
401                                 "AliHLTMUONMansoTrackerFSMComponent::AddRecHits",
402                                 "Invalid chamber",
403                                 "Received a data block with data from chamber %d"
404                                   " which is outside the expected range: [7..10].",
405                                 chamberMap[i]
406                         );
407                         return;
408                 }
409         }
410         
411         // Make sure we got one chamber number.
412         if (chamber < 7 or 10 < chamber)
413         {
414                 Logging(kHLTLogError,
415                         "AliHLTMUONMansoTrackerFSMComponent::AddRecHits",
416                         "Invalid block",
417                         "Received a reconstructed hit data block with a null specification."
418                          " Cannot know which chamber the data comes from."
419                 );
420                 return;
421         }
422         
423         DebugTrace("Added " << count << " reconstructed hits from chamber "
424                 << (int)chamber << " to the internal arrays."
425         );
426         
427         RecHitBlockInfo info;
428         info.fCount = count;
429         info.fData = recHits;
430         fRecHitBlock[chamber-7].push_back(info);
431 }
432
433
434 void AliHLTMUONMansoTrackerFSMComponent::RequestClusters(
435                 AliHLTMUONMansoTrackerFSM* tracker,
436                 AliHLTFloat32_t left, AliHLTFloat32_t right,
437                 AliHLTFloat32_t bottom, AliHLTFloat32_t top,
438                 AliHLTMUONChamberName chamber, const void* tag
439         )
440 {
441         ///
442         /// Inherited from AliHLTMUONMansoTrackerFSMCallback.
443         /// This is the call back method used by the tracker algorithm to request
444         /// clusters on a certain chamber.
445         ///
446
447         DebugTrace("AliHLTMUONMansoTracker::RequestClusters(chamber = " << chamber << ")");
448         void* ctag = const_cast<void*>(tag);
449         int chNo = -1;
450         std::vector<RecHitBlockInfo>* recHitsBlock = NULL;
451         switch (chamber)
452         {
453         case kChamber7:
454                 recHitsBlock = &fRecHitBlock[0];
455                 chNo = 7;
456                 break;
457
458         case kChamber8:
459                 recHitsBlock = &fRecHitBlock[1];
460                 chNo = 8;
461                 break;
462
463         case kChamber9:
464                 recHitsBlock = &fRecHitBlock[2];
465                 chNo = 9;
466                 break;
467
468         case kChamber10:
469                 recHitsBlock = &fRecHitBlock[3];
470                 chNo = 10;
471                 break;
472
473         default: return;
474         }
475         
476         DebugTrace("Returning requested hits for chamber " << chNo << ":");
477         for (AliHLTUInt32_t i = 0; i < recHitsBlock->size(); i++)
478         for (AliHLTUInt32_t j = 0; j < (*recHitsBlock)[i].fCount; j++)
479         {
480                 const AliHLTMUONRecHitStruct* hit = &((*recHitsBlock)[i].fData[j]);
481                 if (left < hit->fX and hit->fX < right and bottom < hit->fY and hit->fY < top)
482                         tracker->ReturnClusters(ctag, hit, 1);
483         }
484         DebugTrace("Done returning hits from chamber " << chNo << ".");
485         tracker->EndOfClusters(ctag);
486 }
487
488
489 void AliHLTMUONMansoTrackerFSMComponent::EndOfClusterRequests(
490                 AliHLTMUONMansoTrackerFSM* /*tracker*/
491         )
492 {
493         ///
494         /// Inherited from AliHLTMUONMansoTrackerFSMCallback.
495         /// Nothing special to do here.
496         ///
497         
498         DebugTrace("End of cluster requests.");
499 }
500
501
502 void AliHLTMUONMansoTrackerFSMComponent::FoundTrack(AliHLTMUONMansoTrackerFSM* tracker)
503 {
504         ///
505         /// Inherited from AliHLTMUONMansoTrackerFSMCallback.
506         /// This is the call back method used by the tracker algorithm to declare
507         /// that a new track has been found.
508         ///
509         
510         DebugTrace("AliHLTMUONMansoTrackerFSMComponent::FoundTrack()");
511         
512         AliHLTMUONMansoTracksBlockWriter* block =
513                 reinterpret_cast<AliHLTMUONMansoTracksBlockWriter*>(fBlock);
514         
515         AliHLTMUONMansoTrackStruct* track = block->AddEntry();
516         if (track == NULL)
517         {
518                 Logging(kHLTLogError,
519                         "AliHLTMUONMansoTrackerFSMComponent::FoundTrack",
520                         "Buffer overflow",
521                         "We have overflowed the output buffer for Manso track data."
522                           " The output buffer size is only %d bytes.",
523                         block->BufferSize()
524                 );
525                 return;
526         }
527  
528         fTrackCount++;
529         tracker->FillTrackData(*track);
530         DebugTrace("\tTrack data = " << *track);
531 }
532
533
534 void AliHLTMUONMansoTrackerFSMComponent::NoTrackFound(AliHLTMUONMansoTrackerFSM* /*tracker*/)
535 {
536         ///
537         /// Inherited from AliHLTMUONMansoTrackerFSMCallback.
538         /// Nothing special to do here.
539         ///
540         
541         DebugTrace("No track found.");
542 }
543