Cleanup of documentation and code.
[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 #include <new>
38
39 ClassImp(AliHLTMUONMansoTrackerFSMComponent);
40
41
42 AliHLTMUONMansoTrackerFSMComponent::AliHLTMUONMansoTrackerFSMComponent() :
43         AliHLTProcessor(),
44         AliHLTMUONMansoTrackerFSMCallback(),
45         fTracker(NULL),
46         fTrackCount(0),
47         fBlock(NULL),
48         fRecHitBlockArraySize(0),
49         fWarnForUnexpecedBlock(false)
50 {
51         ///
52         /// Default constructor.
53         ///
54         
55         for (Int_t i = 0; i < 4; i++)
56         {
57                 fRecHitBlockCount[i] = 0;
58                 fRecHitBlock[i] = NULL;
59         }
60 }
61
62
63 AliHLTMUONMansoTrackerFSMComponent::~AliHLTMUONMansoTrackerFSMComponent()
64 {
65         ///
66         /// Default destructor.
67         ///
68         
69         // Should never have the following 2 pointers non-NULL since DoDeinit
70         // should have been called before, but handle this case anyway.
71         if (fTracker != NULL) delete fTracker;
72         
73         // Remember that only fRecHitBlock[0] stores the pointer to the allocated
74         // memory. The other pointers are just reletive to this.
75         if (fRecHitBlock[0] != NULL) delete [] fRecHitBlock[0];
76 }
77
78
79 const char* AliHLTMUONMansoTrackerFSMComponent::GetComponentID()
80 {
81         ///
82         /// Inherited from AliHLTComponent. Returns the component ID.
83         ///
84         
85         return AliHLTMUONConstants::MansoTrackerFSMId();
86 }
87
88
89 void AliHLTMUONMansoTrackerFSMComponent::GetInputDataTypes(
90                 vector<AliHLTComponentDataType>& list
91         )
92 {
93         ///
94         /// Inherited from AliHLTProcessor. Returns the list of expected input data types.
95         ///
96         
97         assert( list.empty() );
98         list.push_back( AliHLTMUONConstants::TriggerRecordsBlockDataType() );
99         list.push_back( AliHLTMUONConstants::RecHitsBlockDataType() );
100 }
101
102
103 AliHLTComponentDataType AliHLTMUONMansoTrackerFSMComponent::GetOutputDataType()
104 {
105         ///
106         /// Inherited from AliHLTComponent. Returns the output data type.
107         ///
108         
109         return AliHLTMUONConstants::MansoTracksBlockDataType();
110 }
111
112
113 void AliHLTMUONMansoTrackerFSMComponent::GetOutputDataSize(
114                 unsigned long& constBase, double& inputMultiplier
115         )
116 {
117         ///
118         /// Inherited from AliHLTComponent. Returns an estimate of the expected output data size.
119         ///
120         
121         constBase = sizeof(AliHLTMUONMansoTracksBlockStruct);
122         inputMultiplier = 1;
123 }
124
125
126 AliHLTComponent* AliHLTMUONMansoTrackerFSMComponent::Spawn()
127 {
128         ///
129         /// Inherited from AliHLTComponent. Creates a new object instance.
130         ///
131         
132         return new AliHLTMUONMansoTrackerFSMComponent;
133 }
134
135
136 int AliHLTMUONMansoTrackerFSMComponent::DoInit(int argc, const char** argv)
137 {
138         ///
139         /// Inherited from AliHLTComponent.
140         /// Parses the command line parameters and initialises the component.
141         ///
142         
143         HLTInfo("Initialising dHLT manso tracker FSM component.");
144         
145         // Just in case for whatever reason we still have some of the internal
146         // object allocated previously still hanging around delete them now.
147         FreeMemory();
148         
149         try
150         {
151                 fTracker = new AliHLTMUONMansoTrackerFSM();
152         }
153         catch (const std::bad_alloc&)
154         {
155                 HLTError("Could not allocate more memory for the tracker component.");
156                 return -ENOMEM;
157         }
158         fTracker->SetCallback(this);
159         
160         fWarnForUnexpecedBlock = false;
161         
162         for (int i = 0; i < argc; i++)
163         {
164                 if (strcmp(argv[i], "-warn_on_unexpected_block") == 0)
165                 {
166                         fWarnForUnexpecedBlock = true;
167                         continue;
168                 }
169
170                 HLTError("Unknown option '%s'.", argv[i]);
171                 FreeMemory(); // Make sure we cleanup to avoid partial initialisation.
172                 return -EINVAL;
173         }
174         
175         const int initArraySize = 10;
176         // Allocate some initial memory for the reconstructed hit arrays.
177         try
178         {
179                 fRecHitBlock[0] = new AliRecHitBlockInfo[initArraySize*4];
180         }
181         catch (const std::bad_alloc&)
182         {
183                 HLTError("Could not allocate more memory for the reconstructed hit arrays.");
184                 FreeMemory(); // Make sure we cleanup to avoid partial initialisation.
185                 return -ENOMEM;
186         }
187         // Only set the arrays' size once we have successfully allocated the memory for the arrays.
188         fRecHitBlockArraySize = initArraySize;
189         // Now we need to set the pointers fRecHitBlock[i] {i>0} relative to fRecHitBlock[0].
190         for (Int_t i = 1; i < 4; i++)
191         {
192                 fRecHitBlock[i] = fRecHitBlock[i-1] + fRecHitBlockArraySize;
193         }
194         // And reset the number of records actually stored in the arrays.
195         for (Int_t i = 0; i < 4; i++)
196         {
197                 fRecHitBlockCount[i] = 0;
198         }
199         
200         return 0;
201 }
202
203
204 int AliHLTMUONMansoTrackerFSMComponent::DoDeinit()
205 {
206         ///
207         /// Inherited from AliHLTComponent. Performs a cleanup of the component.
208         ///
209         
210         HLTInfo("Deinitialising dHLT manso tracker FSM component.");
211         FreeMemory();
212         return 0;
213 }
214
215
216 int AliHLTMUONMansoTrackerFSMComponent::DoEvent(
217                 const AliHLTComponentEventData& evtData,
218                 const AliHLTComponentBlockData* blocks,
219                 AliHLTComponentTriggerData& /*trigData*/,
220                 AliHLTUInt8_t* outputPtr,
221                 AliHLTUInt32_t& size,
222                 std::vector<AliHLTComponentBlockData>& outputBlocks
223         )
224 {
225         ///
226         /// Inherited from AliHLTProcessor. Processes the new event data.
227         ///
228         
229         Reset();
230         AliHLTUInt32_t specification = 0;  // Contains the output data block spec bits.
231         
232         // Resize the rec hit arrays if we possibly will need more space.
233         // To guarantee that they will not overflow we need to make sure each
234         // array is at least as big as the number of input data blocks.
235         if (fRecHitBlockArraySize < evtData.fBlockCnt)
236         {
237                 // Release the old memory block and allocate more memory.
238                 if (fRecHitBlock[0] != NULL)
239                 {
240                         delete [] fRecHitBlock[0];
241                 }
242                 
243                 // Reset the number of records actually stored in the arrays.
244                 for (Int_t i = 0; i < 4; i++)
245                 {
246                         fRecHitBlockCount[i] = 0;
247                 }
248                 
249                 try
250                 {
251                         fRecHitBlock[0] = new AliRecHitBlockInfo[evtData.fBlockCnt*4];
252                 }
253                 catch (const std::bad_alloc&)
254                 {
255                         HLTError("Could not allocate more memory for the reconstructed hit arrays.");
256                         // Ok so now we need to clear all the pointers because we actually
257                         // deleted the memory.
258                         fRecHitBlockArraySize = 0;
259                         for (Int_t i = 0; i < 4; i++)
260                         {
261                                 fRecHitBlock[i] = NULL;
262                         }
263                         return -ENOMEM;
264                 }
265                 // Only set the arrays' size once we have successfully allocated the memory for the arrays.
266                 fRecHitBlockArraySize = evtData.fBlockCnt;
267                 // Now we need to set the pointers fRecHitBlock[i] {i>0} relative to fRecHitBlock[0].
268                 for (Int_t i = 1; i < 4; i++)
269                 {
270                         fRecHitBlock[i] = fRecHitBlock[i-1] + fRecHitBlockArraySize;
271                 }
272         }
273         
274         AliHLTMUONMansoTracksBlockWriter block(outputPtr, size);
275         fBlock = &block;
276         
277         if (not block.InitCommonHeader())
278         {
279                 Logging(kHLTLogError,
280                         "AliHLTMUONMansoTrackerFSMComponent::DoEvent",
281                         "Buffer overflow",
282                         "The buffer is only %d bytes in size. We need a minimum of %d bytes.",
283                         size, sizeof(AliHLTMUONMansoTracksBlockWriter::HeaderType)
284                 );
285                 size = 0; // Important to tell framework that nothing was generated.
286                 return -ENOBUFS;
287         }
288
289         // Loop over all input blocks in the event and add the ones that contain
290         // reconstructed hits into the hit buffers. The blocks containing trigger
291         // records are ignored for now and will be processed later.
292         for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
293         {
294                 HLTDebug("Handling block: %u, with fDataType = '%s', fPtr = %p and fSize = %u bytes.",
295                         n, DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fPtr, blocks[n].fSize
296                 );
297                 
298                 if (blocks[n].fDataType == AliHLTMUONConstants::RecHitsBlockDataType())
299                 {
300                         specification |= blocks[n].fSpecification;
301                         
302                         AliHLTMUONRecHitsBlockReader inblock(blocks[n].fPtr, blocks[n].fSize);
303                         if (not inblock.BufferSizeOk())
304                         {
305                                 size_t headerSize = sizeof(AliHLTMUONRecHitsBlockReader::HeaderType);
306                                 if (blocks[n].fSize < headerSize)
307                                 {
308                                         HLTError("Received a reconstructed hits data block with a size of %d bytes,"
309                                                 " which is smaller than the minimum valid header size of %d bytes."
310                                                 " The block must be corrupt.",
311                                                 blocks[n].fSize, headerSize
312                                         );
313                                         continue;
314                                 }
315                                 
316                                 size_t expectedWidth = sizeof(AliHLTMUONRecHitsBlockReader::ElementType);
317                                 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
318                                 {
319                                         HLTError("Received a reconstructed hits data block with a record"
320                                                 " width of %d bytes, but the expected value is %d bytes."
321                                                 " The block might be corrupt.",
322                                                 inblock.CommonBlockHeader().fRecordWidth, expectedWidth
323                                         );
324                                         continue;
325                                 }
326                                 
327                                 HLTError("Received a reconstructed hits data block with a size of %d bytes,"
328                                         " but the block header claims the block should be %d bytes."
329                                         " The block might be corrupt.",
330                                         blocks[n].fSize, inblock.BytesUsed()
331                                 );
332                                 continue;
333                         }
334                         
335                         if (inblock.Nentries() != 0)
336                                 AddRecHits(blocks[n].fSpecification, inblock.GetArray(), inblock.Nentries());
337                         else
338                         {
339                                 Logging(kHLTLogDebug,
340                                         "AliHLTMUONMansoTrackerFSMComponent::DoEvent",
341                                         "Block empty",
342                                         "Received a reconstructed hits data block which contains no entries."
343                                 );
344                         }
345                 }
346                 else if (blocks[n].fDataType != AliHLTMUONConstants::TriggerRecordsBlockDataType())
347                 {
348                         // Log a message indicating that we got a data block that we
349                         // do not know how to handle.
350                         if (fWarnForUnexpecedBlock)
351                                 HLTWarning("Received a data block of a type we cannot handle: '%s', spec: 0x%X",
352                                         DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fSpecification
353                                 );
354                         else
355                                 HLTDebug("Received a data block of a type we cannot handle: '%s', spec: 0x%X",
356                                         DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fSpecification
357                                 );
358                 }
359         }
360   
361         // Again loop over all input blocks in the event, but this time look for
362         // the trigger record blocks and process these.
363         for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
364         {
365                 if (blocks[n].fDataType != AliHLTMUONConstants::TriggerRecordsBlockDataType())
366                         continue;
367                 
368                 AliHLTMUONTriggerRecordsBlockReader inblock(blocks[n].fPtr, blocks[n].fSize);
369                 if (not inblock.BufferSizeOk())
370                 {
371                         size_t headerSize = sizeof(AliHLTMUONTriggerRecordsBlockReader::HeaderType);
372                         if (blocks[n].fSize < headerSize)
373                         {
374                                 HLTError("Received a trigger records data block with a size of %d bytes,"
375                                         " which is smaller than the minimum valid header size of %d bytes."
376                                         " The block must be corrupt.",
377                                         blocks[n].fSize, headerSize
378                                 );
379                                 continue;
380                         }
381                         
382                         size_t expectedWidth = sizeof(AliHLTMUONTriggerRecordsBlockReader::ElementType);
383                         if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
384                         {
385                                 HLTError("Received a trigger records data block with a record"
386                                         " width of %d bytes, but the expected value is %d bytes."
387                                         " The block might be corrupt.",
388                                         inblock.CommonBlockHeader().fRecordWidth, expectedWidth
389                                 );
390                                 continue;
391                         }
392                         
393                         HLTError("Received a trigger records data block with a size of %d bytes,"
394                                 " but the block header claims the block should be %d bytes."
395                                 " The block might be corrupt.",
396                                 blocks[n].fSize, inblock.BytesUsed()
397                         );
398                         continue;
399                 }
400                 DebugTrace("Processing a trigger block with "
401                         << inblock.Nentries() << " entries."
402                 );
403                 
404                 specification |= blocks[n].fSpecification;
405                 
406                 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
407                 {
408                         fTracker->FindTrack(inblock[i]);
409                         
410                         // Reset the tracker so that we do not double count tracks.
411                         fTracker->Reset();
412                 }
413         }
414         
415         AliHLTComponentBlockData bd;
416         FillBlockData(bd);
417         bd.fPtr = outputPtr;
418         bd.fOffset = 0;
419         bd.fSize = block.BytesUsed();
420         bd.fDataType = AliHLTMUONConstants::MansoTracksBlockDataType();
421         bd.fSpecification = specification;
422         outputBlocks.push_back(bd);
423         size = block.BytesUsed();
424
425         return 0;
426 }
427
428
429 void AliHLTMUONMansoTrackerFSMComponent::Reset()
430 {
431         ///
432         /// Reset the track count and reconstructed hit data block arrays.
433         ///
434         
435         DebugTrace("Resetting AliHLTMUONMansoTrackerFSMComponent.");
436
437         //fTracker->Reset();  // Not necessary here because it is done after every FindTrack call.
438         fTrackCount = 0;
439         fBlock = NULL;  // Do not delete. Already done implicitly at the end of DoEvent.
440         for (int i = 0; i < 4; i++)
441         {
442                 fRecHitBlockCount[i] = 0;
443         }
444 }
445
446
447 void AliHLTMUONMansoTrackerFSMComponent::FreeMemory()
448 {
449         /// Deletes any objects and arrays allocated by this component and releases
450         /// the memory used. This is called as a helper routine by the init and deinit
451         /// methods. If some or all of the object pointers are already NULL then
452         /// nothing is done for those. This method guarantees that all the relevant
453         /// pointers will be NULL after returning from this method.
454
455         if (fTracker != NULL)
456         {
457                 delete fTracker;
458                 fTracker = NULL;
459         }
460         
461         // Remember that only fRecHitBlock[0] stores the pointer to the allocated memory.
462         // The other pointers are just reletive to this.
463         if (fRecHitBlock[0] != NULL)
464                 delete [] fRecHitBlock[0];
465         
466         fRecHitBlockArraySize = 0;
467         for (Int_t i = 0; i < 4; i++)
468         {
469                 fRecHitBlockCount[i] = 0;
470                 fRecHitBlock[i] = NULL;
471         }
472 }
473
474
475 void AliHLTMUONMansoTrackerFSMComponent::AddRecHits(
476                 AliHLTUInt32_t specification,
477                 const AliHLTMUONRecHitStruct* recHits,
478                 AliHLTUInt32_t count
479         )
480 {
481         ///
482         /// Adds a new reconstructed hit data block to the internal list of blocks
483         /// for the tracker to process.
484         /// These lists will later be used when the tracker requests them through
485         /// the callback method 'RequestClusters'.
486         ///
487         
488         DebugTrace("AliHLTMUONMansoTrackerFSMComponent::AddRecHits called with specification = 0x"
489                  << std::hex << specification << std::dec << " and count = "
490                  << count << " rec hits."
491         );
492         
493         AliHLTUInt8_t chamberMap[20] = {
494                 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10
495         };
496         
497         // Identify the chamber the rec hits came from using the specifications field.
498         bool gotDataFromDDL[22];
499         AliHLTMUONUtils::UnpackSpecBits(specification, gotDataFromDDL);
500                 
501         AliHLTInt8_t chamber = -1;
502         for (int i = 0; i < 20; i++)
503         {
504                 if (not gotDataFromDDL[i]) continue;
505                 if (7 <= chamberMap[i] and chamberMap[i] <= 10)
506                 {
507                         if (chamber != -1 and chamber != chamberMap[i])
508                         {
509                                 Logging(kHLTLogError,
510                                         "AliHLTMUONMansoTrackerFSMComponent::AddRecHits",
511                                         "Invalid block",
512                                         "Received a data block with data from multiple chambers."
513                                           " This component cannot handle such a case."
514                                 );
515                                 return;
516                         }
517                         else
518                                 chamber = chamberMap[i];
519                 }
520                 else
521                 {
522                         Logging(kHLTLogError,
523                                 "AliHLTMUONMansoTrackerFSMComponent::AddRecHits",
524                                 "Invalid chamber",
525                                 "Received a data block with data from chamber %d"
526                                   " which is outside the expected range: [7..10].",
527                                 chamberMap[i]
528                         );
529                         return;
530                 }
531         }
532         
533         // Make sure we got one chamber number.
534         if (chamber < 7 or 10 < chamber)
535         {
536                 Logging(kHLTLogError,
537                         "AliHLTMUONMansoTrackerFSMComponent::AddRecHits",
538                         "Invalid block",
539                         "Received a reconstructed hit data block with a null specification."
540                          " Cannot know which chamber the data comes from."
541                 );
542                 return;
543         }
544         
545         DebugTrace("Added " << count << " reconstructed hits from chamber "
546                 << (int)chamber << " to the internal arrays."
547         );
548         
549         assert( fRecHitBlockCount[chamber-7] < fRecHitBlockArraySize );
550         AliRecHitBlockInfo info(count, recHits);
551         fRecHitBlock[chamber-7][fRecHitBlockCount[chamber-7]] = info;
552         fRecHitBlockCount[chamber-7]++;
553 }
554
555
556 void AliHLTMUONMansoTrackerFSMComponent::RequestClusters(
557                 AliHLTMUONMansoTrackerFSM* tracker,
558                 AliHLTFloat32_t left, AliHLTFloat32_t right,
559                 AliHLTFloat32_t bottom, AliHLTFloat32_t top,
560                 AliHLTMUONChamberName chamber, const void* tag
561         )
562 {
563         ///
564         /// Inherited from AliHLTMUONMansoTrackerFSMCallback.
565         /// This is the call back method used by the tracker algorithm to request
566         /// clusters on a certain chamber.
567         ///
568
569         DebugTrace("AliHLTMUONMansoTracker::RequestClusters(chamber = " << chamber << ")");
570         void* ctag = const_cast<void*>(tag);
571         int chNo = -1;
572         AliHLTUInt32_t recHitsCount = 0;
573         AliRecHitBlockInfo* recHitsBlock = NULL;
574         switch (chamber)
575         {
576         case kChamber7:
577                 recHitsCount = fRecHitBlockCount[0];
578                 recHitsBlock = fRecHitBlock[0];
579                 chNo = 7;
580                 break;
581
582         case kChamber8:
583                 recHitsCount = fRecHitBlockCount[1];
584                 recHitsBlock = fRecHitBlock[1];
585                 chNo = 8;
586                 break;
587
588         case kChamber9:
589                 recHitsCount = fRecHitBlockCount[2];
590                 recHitsBlock = fRecHitBlock[2];
591                 chNo = 9;
592                 break;
593
594         case kChamber10:
595                 recHitsCount = fRecHitBlockCount[3];
596                 recHitsBlock = fRecHitBlock[3];
597                 chNo = 10;
598                 break;
599
600         default: return;
601         }
602         
603         DebugTrace("Returning requested hits for chamber " << chNo << ":");
604         for (AliHLTUInt32_t i = 0; i < recHitsCount; i++)
605         for (AliHLTUInt32_t j = 0; j < recHitsBlock[i].Count(); j++)
606         {
607                 const AliHLTMUONRecHitStruct* hit = &(recHitsBlock[i].Data()[j]);
608                 if (left < hit->fX and hit->fX < right and bottom < hit->fY and hit->fY < top)
609                         tracker->ReturnClusters(ctag, hit, 1);
610         }
611         DebugTrace("Done returning hits from chamber " << chNo << ".");
612         tracker->EndOfClusters(ctag);
613 }
614
615
616 void AliHLTMUONMansoTrackerFSMComponent::EndOfClusterRequests(
617                 AliHLTMUONMansoTrackerFSM* /*tracker*/
618         )
619 {
620         ///
621         /// Inherited from AliHLTMUONMansoTrackerFSMCallback.
622         /// Nothing special to do here.
623         ///
624         
625         DebugTrace("End of cluster requests.");
626 }
627
628
629 void AliHLTMUONMansoTrackerFSMComponent::FoundTrack(AliHLTMUONMansoTrackerFSM* tracker)
630 {
631         ///
632         /// Inherited from AliHLTMUONMansoTrackerFSMCallback.
633         /// This is the call back method used by the tracker algorithm to declare
634         /// that a new track has been found.
635         ///
636         
637         DebugTrace("AliHLTMUONMansoTrackerFSMComponent::FoundTrack()");
638         
639         AliHLTMUONMansoTracksBlockWriter* block =
640                 reinterpret_cast<AliHLTMUONMansoTracksBlockWriter*>(fBlock);
641         
642         AliHLTMUONMansoTrackStruct* track = block->AddEntry();
643         if (track == NULL)
644         {
645                 Logging(kHLTLogError,
646                         "AliHLTMUONMansoTrackerFSMComponent::FoundTrack",
647                         "Buffer overflow",
648                         "We have overflowed the output buffer for Manso track data."
649                           " The output buffer size is only %d bytes.",
650                         block->BufferSize()
651                 );
652                 return;
653         }
654  
655         fTrackCount++;
656         tracker->FillTrackData(*track);
657         DebugTrace("\tTrack data = " << *track);
658 }
659
660
661 void AliHLTMUONMansoTrackerFSMComponent::NoTrackFound(AliHLTMUONMansoTrackerFSM* /*tracker*/)
662 {
663         ///
664         /// Inherited from AliHLTMUONMansoTrackerFSMCallback.
665         /// Nothing special to do here.
666         ///
667         
668         DebugTrace("No track found.");
669 }
670