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