HLT/MUON/OfflineInterface/AliHLTMUONTriggerRecordsSource.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  *                                                                        *
   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 /**
  20  * @file   AliHLTMUONTriggerRecordsSource.cxx
  21  * @author Artur Szostak <artursz@iafrica.com>
  22  * @date
  23  * @brief  Implementation of the AliHLTMUONTriggerRecordsSource component.
  24  */
  25
  26 #include "AliHLTMUONTriggerRecordsSource.h"
  27 #include "AliHLTMUONConstants.h"
  28 #include "AliHLTMUONUtils.h"
  29 #include "AliHLTMUONDataBlockWriter.h"
  30 #include "AliHLTMUONCalculations.h"
  31 #include "AliMUONMCDataInterface.h"
  32 #include "AliMUONDataInterface.h"
  33 #include "AliMUONHit.h"
  34 #include "AliMUONRawCluster.h"
  35 #include "AliMUONConstants.h"
  36 #include "AliMUONVClusterStore.h"
  37 #include "AliMUONVHitStore.h"
  38 #include "mapping/AliMpCDB.h"
  39 #include "mapping/AliMpDDLStore.h"
  40 #include "mapping/AliMpLocalBoard.h"
  41 #include "mapping/AliMpTriggerCrate.h"
  42 #include "mapping/AliMpDEManager.h"
  43 #include "mapping/AliMpDetElement.h"
  44 #include "AliLog.h"
  45 #include "TClonesArray.h"
  46 #include <cstdlib>
  47 #include <cstdio>
  48 #include <cerrno>
  49 #include <cassert>
  50 #include <new>
  51
  52 namespace
  53 {
  54
  55         //TODO: The following method should be in MUON/mapping
  56         Int_t FindDDLOfDetElement(Int_t detElemId)
  57         {
  58                 // Find what the DDL ID number is for a detector element from
  59                 // trigger chambers 11 to 14. We first have to find the local
  60                 // board associated with the detector element and then we can
  61                 // associate that local board to the trigger crate which has
  62                 // the DDL number specified.
  63                 AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
  64                 if (ddlStore == NULL) return -1;
  65                 Int_t ddl = -1, boardIndex = 1;
  66                 do
  67                 {
  68                         AliMpLocalBoard* board = ddlStore->GetLocalBoard(boardIndex++);
  69                         if (board == NULL) break;
  70                         if (board->HasDEId(detElemId))
  71                         {
  72                                 AliMpTriggerCrate* crate = ddlStore->GetTriggerCrate(board->GetCrate());
  73                                 if (crate == NULL) continue;
  74                                 ddl = crate->GetDdlId();
  75                                 break;
  76                         }
  77                 }
  78                 while (ddl == -1);
  79                 return ddl;
  80         }
  81
  82 }
  83
  84
  85 ClassImp(AliHLTMUONTriggerRecordsSource);
  86
  87
  88 AliHLTMUONTriggerRecordsSource::AliHLTMUONTriggerRecordsSource() :
  89         AliHLTOfflineDataSource(),
  90         fMCDataInterface(NULL),
  91         fDataInterface(NULL),
  92         fBuildFromHits(false),
  93         fSelection(kWholePlane),
  94         fCurrentEventIndex(0)
  95 {
  96         ///
  97         /// Default constructor.
  98         ///
  99 }
 100
 101
 102 AliHLTMUONTriggerRecordsSource::~AliHLTMUONTriggerRecordsSource()
 103 {
 104         ///
 105         /// Default destructor.
 106         ///
 107
 108         assert( fMCDataInterface == NULL );
 109         assert( fDataInterface == NULL );
 110 }
 111
 112
 113 int AliHLTMUONTriggerRecordsSource::DoInit(int argc, const char** argv)
 114 {
 115         ///
 116         /// Inherited from AliHLTComponent.
 117         /// Parses the command line parameters and initialises the component.
 118         ///
 119
 120         assert( fMCDataInterface == NULL );
 121         assert( fDataInterface == NULL );
 122
 123         // Parse the command line arguments:
 124         bool hitdata = false;
 125         bool simdata = false;
 126         bool recdata = false;
 127         fCurrentEventIndex = 0;
 128         bool firstEventSet = false;
 129         bool eventNumLitSet = false;
 130
 131         for (int i = 0; i < argc; i++)
 132         {
 133                 if (strcmp(argv[i], "-hitdata") == 0)
 134                 {
 135                         hitdata = true;
 136                 }
 137                 else if (strcmp(argv[i], "-simdata") == 0)
 138                 {
 139                         simdata = true;
 140                 }
 141                 else if (strcmp(argv[i], "-recdata") == 0)
 142                 {
 143                         recdata = true;
 144                 }
 145                 else if (strcmp(argv[i], "-plane") == 0)
 146                 {
 147                         i++;
 148                         if (i >= argc)
 149                         {
 150                                 Logging(kHLTLogError,
 151                                         "AliHLTMUONTriggerRecordsSource::DoInit",
 152                                         "Missing parameter",
 153                                         "Expected one of 'left', 'right' or 'all' after '-plane'."
 154                                 );
 155                                 return EINVAL;
 156                         }
 157                         if (strcmp(argv[i], "left") == 0)
 158                                 fSelection = kLeftPlane;
 159                         else if (strcmp(argv[i], "right") == 0)
 160                                 fSelection = kRightPlane;
 161                         else if (strcmp(argv[i], "all") == 0)
 162                                 fSelection = kWholePlane;
 163                         else
 164                         {
 165                                 Logging(kHLTLogError,
 166                                         "AliHLTMUONTriggerRecordsSource::DoInit",
 167                                         "Invalid parameter",
 168                                         "The parameter '%s' is invalid and must be one of 'left',"
 169                                           " 'right' or 'all'.",
 170                                         argv[i]
 171                                 );
 172                                 return EINVAL;
 173                         }
 174                 }
 175                 else if (strcmp(argv[i], "-firstevent") == 0)
 176                 {
 177                         if (eventNumLitSet)
 178                         {
 179                                 HLTWarning("The -firstevent flag is overridden by a"
 180                                         " previous use of -event_number_literal."
 181                                 );
 182                         }
 183                         i++;
 184                         if (i >= argc)
 185                         {
 186                                 HLTError("Expected a positive number after -firstevent.");
 187                                 return EINVAL;
 188                         }
 189                         char* end = "";
 190                         long num = strtol(argv[i], &end, 0);
 191                         if (*end != '\0' or num < 0) // Check if the conversion is OK.
 192                         {
 193                                 HLTError(Form(
 194                                         "Expected a positive number after -firstevent"
 195                                         " but got: %s", argv[i]
 196                                 ));
 197                                 return EINVAL;
 198                         }
 199                         fCurrentEventIndex = Int_t(num);
 200                         firstEventSet = true;
 201                 }
 202                 else if (strcmp(argv[i], "-event_number_literal") == 0)
 203                 {
 204                         if (firstEventSet)
 205                         {
 206                                 HLTWarning("The -event_number_literal option will"
 207                                         " override -firstevent."
 208                                 );
 209                         }
 210                         fCurrentEventIndex = -1;
 211                         eventNumLitSet = true;
 212                 }
 213                 else
 214                 {
 215                         Logging(kHLTLogError,
 216                                 "AliHLTMUONTriggerRecordsSource::DoInit",
 217                                 "Unknown argument",
 218                                 "The argument '%s' is invalid.",
 219                                 argv[i]
 220                         );
 221                         return EINVAL;
 222                 }
 223         }
 224
 225         // Check that one and only one of the the -hitdata, -simdata or
 226         // -recdata parameters was specified on the command line.
 227         if ((not hitdata and not simdata and not recdata) or
 228             (not hitdata and simdata and recdata) or
 229             (hitdata and not simdata and recdata) or
 230             (hitdata and simdata and not recdata) or
 231             (hitdata and simdata and recdata)
 232            )
 233         {
 234                 Logging(kHLTLogError,
 235                         "AliHLTMUONTriggerRecordsSource::DoInit",
 236                         "Missing arguments",
 237                         "Must have one and only one of -hitdata, -simdata or -recdata specified."
 238                 );
 239                 return EINVAL;
 240         }
 241
 242         // Must load the mapping data for AliMpTriggerCrate::GetDdlId()  //TODO AliMpTriggerCrate => AliMpDetElement
 243         // to return useful information later on.
 244         AliMpCDB::LoadDDLStore();
 245
 246         // Now we can initialise the data interface objects and loaders.
 247         fBuildFromHits = hitdata;
 248         if (hitdata or simdata)
 249         {
 250                 const char* message = fBuildFromHits ?
 251                         "Loading simulated GEANT hits with AliMUONMCDataInterface."
 252                         : "Loading simulated local trigger objects with AliMUONMCDataInterface.";
 253
 254                 Logging(kHLTLogDebug, "AliHLTMUONTriggerRecordsSource::DoInit",
 255                         "Data interface", message
 256                 );
 257
 258                 try
 259                 {
 260                         fMCDataInterface = new AliMUONMCDataInterface("galice.root");
 261                 }
 262                 catch (const std::bad_alloc&)
 263                 {
 264                         Logging(kHLTLogError,
 265                                 "AliHLTMUONTriggerRecordsSource::DoInit",
 266                                 "Out of memory",
 267                                 "Not enough memory to allocate AliMUONMCDataInterface."
 268                         );
 269                         return ENOMEM;
 270                 }
 271         }
 272         else if (recdata)
 273         {
 274                 Logging(kHLTLogDebug,
 275                         "AliHLTMUONTriggerRecordsSource::DoInit",
 276                         "Data interface",
 277                         "Loading reconstructed local trigger objects with AliMUONDataInterface."
 278                 );
 279
 280                 try
 281                 {
 282                         fDataInterface = new AliMUONDataInterface("galice.root");
 283                 }
 284                 catch (const std::bad_alloc&)
 285                 {
 286                         Logging(kHLTLogError,
 287                                 "AliHLTMUONTriggerRecordsSource::DoInit",
 288                                 "Out of memory",
 289                                 "Not enough memory to allocate AliMUONDataInterface."
 290                         );
 291                         return ENOMEM;
 292                 }
 293         }
 294
 295         // Check that the fCurrentEventIndex number falls within the correct range.
 296         UInt_t maxevent = 0;
 297         if (fMCDataInterface != NULL)
 298                 maxevent = UInt_t(fMCDataInterface->NumberOfEvents());
 299         else if (fDataInterface != NULL)
 300                 maxevent = UInt_t(fDataInterface->NumberOfEvents());
 301         if (fCurrentEventIndex != -1 and UInt_t(fCurrentEventIndex) >= maxevent and maxevent != 0)
 302         {
 303                 fCurrentEventIndex = 0;
 304                 HLTWarning(Form("The selected first event number (%d) was larger than"
 305                         " the available number of events (%d). Resetting the event"
 306                         " counter to zero.", fCurrentEventIndex, maxevent
 307                 ));
 308         }
 309
 310         return 0;
 311 }
 312
 313
 314 int AliHLTMUONTriggerRecordsSource::DoDeinit()
 315 {
 316         ///
 317         /// Inherited from AliHLTComponent. Performs a cleanup of the component.
 318         ///
 319
 320         if (fMCDataInterface != NULL)
 321         {
 322                 delete fMCDataInterface;
 323                 fMCDataInterface = NULL;
 324         }
 325         if (fDataInterface != NULL)
 326         {
 327                 delete fDataInterface;
 328                 fDataInterface = NULL;
 329         }
 330         return 0;
 331 }
 332
 333
 334 const char* AliHLTMUONTriggerRecordsSource::GetComponentID()
 335 {
 336         ///
 337         /// Inherited from AliHLTComponent. Returns the component ID.
 338         ///
 339
 340         return AliHLTMUONConstants::TriggerRecordsSourceId();
 341 }
 342
 343
 344 AliHLTComponentDataType AliHLTMUONTriggerRecordsSource::GetOutputDataType()
 345 {
 346         ///
 347         /// Inherited from AliHLTComponent. Returns the output data type.
 348         ///
 349
 350         return AliHLTMUONConstants::TriggerRecordsBlockDataType();
 351 }
 352
 353
 354 void AliHLTMUONTriggerRecordsSource::GetOutputDataSize(
 355                 unsigned long& constBase, double& inputMultiplier
 356         )
 357 {
 358         ///
 359         /// Inherited from AliHLTComponent. Returns an estimate of the expected output data size.
 360         ///
 361
 362         constBase = sizeof(AliHLTMUONTriggerRecordsBlockStruct) +
 363                 sizeof(AliHLTMUONTriggerRecordStruct) * AliMUONConstants::NTriggerCircuit();
 364         inputMultiplier = 0;
 365 }
 366
 367
 368 AliHLTComponent* AliHLTMUONTriggerRecordsSource::Spawn()
 369 {
 370         ///
 371         /// Inherited from AliHLTComponent. Creates a new object instance.
 372         ///
 373
 374         return new AliHLTMUONTriggerRecordsSource();
 375 }
 376
 377
 378 int AliHLTMUONTriggerRecordsSource::GetEvent(
 379                 const AliHLTComponentEventData& evtData,
 380                 AliHLTComponentTriggerData& /*trigData*/,
 381                 AliHLTUInt8_t* outputPtr,
 382                 AliHLTUInt32_t& size,
 383                 vector<AliHLTComponentBlockData>& outputBlocks
 384         )
 385 {
 386         ///
 387         /// Inherited from AliHLTOfflineDataSource. Creates new event data blocks.
 388         ///
 389
 390         assert( fMCDataInterface != NULL or fDataInterface != NULL );
 391
 392         AliHLTInt32_t trigRecId = 0;
 393
 394         // Check the size of the event descriptor structure.
 395         if (evtData.fStructSize < sizeof(AliHLTComponentEventData))
 396         {
 397                 Logging(kHLTLogError,
 398                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 399                         "Invalid event descriptor",
 400                         "The event descriptor (AliHLTComponentEventData) size is"
 401                           " smaller than expected. It claims to be %d bytes, but"
 402                           " we expect it to be %d bytes.",
 403                         evtData.fStructSize,
 404                         sizeof(AliHLTComponentEventData)
 405                 );
 406                 size = 0; // Important to tell framework that nothing was generated.
 407                 return EINVAL;
 408         }
 409
 410         // Use the fEventID as the event number to load if fCurrentEventIndex == -1,
 411         // check it and load that event with the runloader.
 412         // If fCurrentEventIndex is a positive number then us it instead and
 413         // increment it.
 414         UInt_t eventnumber = UInt_t(evtData.fEventID);
 415         UInt_t maxevent = fMCDataInterface != NULL ?
 416                 UInt_t(fMCDataInterface->NumberOfEvents())
 417                 : UInt_t(fDataInterface->NumberOfEvents());
 418         if (fCurrentEventIndex != -1)
 419         {
 420                 eventnumber = UInt_t(fCurrentEventIndex);
 421                 fCurrentEventIndex++;
 422                 if (UInt_t(fCurrentEventIndex) >= maxevent)
 423                         fCurrentEventIndex = 0;
 424         }
 425         if ( eventnumber >= maxevent )
 426         {
 427                 Logging(kHLTLogError,
 428                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 429                         "Bad event ID",
 430                         "The event number (%d) is larger than the available number"
 431                           " of events on file (%d).",
 432                         eventnumber,
 433                         maxevent
 434                 );
 435                 size = 0; // Important to tell framework that nothing was generated.
 436                 return EINVAL;
 437         }
 438
 439         // Create and initialise a new data block.
 440         AliHLTMUONTriggerRecordsBlockWriter block(outputPtr, size);
 441         if (not block.InitCommonHeader())
 442         {
 443                 Logging(kHLTLogError,
 444                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 445                         "Buffer too small",
 446                         "There is not enough buffer space to create a new data block."
 447                           " We require at least %d bytes but the buffer is only %d bytes.",
 448                         sizeof(AliHLTMUONTriggerRecordsBlockWriter::HeaderType),
 449                         block.BufferSize()
 450                 );
 451                 size = 0; // Important to tell framework that nothing was generated.
 452                 return ENOBUFS;
 453         }
 454
 455         // Initialise the DDL list containing the DDLs which contributed to the
 456         // data block. These are required to create the specification word later.
 457         bool ddlList[22];
 458         for (Int_t i = 0; i < 22; i++)
 459                 ddlList[i] = false;
 460
 461         if (fMCDataInterface != NULL and fBuildFromHits)
 462         {
 463                 Logging(kHLTLogDebug,
 464                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 465                         "Filling triggers",
 466                         "Filling data block with trigger records from GEANT hits for event %d.",
 467                         eventnumber
 468                 );
 469
 470                 // Loop over all tracks, extract the hits from chambers 11 to 14 and
 471                 // create trigger records from them to write to the data block.
 472                 Int_t ntracks = fMCDataInterface->NumberOfTracks(eventnumber);
 473                 for (Int_t i = 0; i < ntracks; ++i)
 474                 {
 475                         AliMUONHit* hit11 = NULL;
 476                         AliMUONHit* hit12 = NULL;
 477                         AliMUONHit* hit13 = NULL;
 478                         AliMUONHit* hit14 = NULL;
 479                         Int_t ddl11 = -1;
 480                         Int_t ddl12 = -1;
 481                         Int_t ddl13 = -1;
 482                         Int_t ddl14 = -1;
 483
 484                         AliMUONVHitStore* hitStore = fMCDataInterface->HitStore(eventnumber,i);
 485                         AliMUONHit* hit;
 486                         TIter next(hitStore->CreateIterator());
 487                         while ( ( hit = static_cast<AliMUONHit*>(next()) ) )
 488                         {
 489                                 // Select only hits on trigger chambers.
 490                                 if (hit->Chamber() <= AliMUONConstants::NTrackingCh()) continue;
 491
 492                                 // Only select hits from the given part of the plane
 493                                 if (fSelection == kLeftPlane and not (hit->Xref() < 0)) continue;
 494                                 if (fSelection == kRightPlane and not (hit->Xref() >= 0)) continue;
 495
 496                                 // Workout which DDL this hit should be readout of.
 497                                 Int_t ddl = FindDDLOfDetElement(hit->DetElemId());
 498                                 if (not (0 <= ddl and ddl < 22))
 499                                 {
 500                                         ddl = -1;
 501                                         Logging(kHLTLogError,
 502                                                 "AliHLTMUONTriggerRecordsSource::GetEvent",
 503                                                 "No DDL ID",
 504                                                 "Could not find the DDL ID from which readout would take place."
 505                                         );
 506                                 }
 507
 508                                 switch (hit->Chamber())
 509                                 {
 510                                 case 11: hit11 = hit; ddl11 = ddl; break;
 511                                 case 12: hit12 = hit; ddl12 = ddl; break;
 512                                 case 13: hit13 = hit; ddl13 = ddl; break;
 513                                 case 14: hit14 = hit; ddl14 = ddl; break;
 514                                 default: break;
 515                                 }
 516                         }
 517
 518                         // Check that there are at least 3 of 4 hits on the trigger chambers.
 519                         Int_t hitCount = 0;
 520                         if (hit11 != NULL) hitCount++;
 521                         if (hit12 != NULL) hitCount++;
 522                         if (hit13 != NULL) hitCount++;
 523                         if (hit14 != NULL) hitCount++;
 524                         if (hitCount < 3) continue;
 525
 526                         AliHLTMUONTriggerRecordStruct* trigRec = block.AddEntry();
 527                         if (trigRec == NULL)
 528                         {
 529                                 Logging(kHLTLogError,
 530                                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 531                                         "Buffer overflow",
 532                                         "There is not enough buffer space to add more trigger records."
 533                                           " We overflowed the buffer which is only %d bytes.",
 534                                         block.BufferSize()
 535                                 );
 536                                 size = 0; // Important to tell framework that nothing was generated.
 537                                 return ENOBUFS;
 538                         }
 539
 540                         // Fill the new trigger record with the hit information.
 541                         bool hitset[4] = {false, false, false, false};
 542                         AliHLTFloat32_t x1 = 0, y1 = 0, y2 = 0, z1 = 0, z2 = 0;
 543                         if (hit11 != NULL)
 544                         {
 545                                 trigRec->fHit[0].fX = hit11->Xref();
 546                                 trigRec->fHit[0].fY = hit11->Yref();
 547                                 trigRec->fHit[0].fZ = hit11->Zref();
 548                                 hitset[0] = true;
 549                                 x1 = hit11->Xref();
 550                                 y1 = hit11->Yref();
 551                                 z1 = hit11->Zref();
 552                         }
 553                         if (hit12 != NULL)
 554                         {
 555                                 trigRec->fHit[1].fX = hit12->Xref();
 556                                 trigRec->fHit[1].fY = hit12->Yref();
 557                                 trigRec->fHit[1].fZ = hit12->Zref();
 558                                 hitset[1] = true;
 559                                 x1 = hit12->Xref();
 560                                 y1 = hit12->Yref();
 561                                 z1 = hit12->Zref();
 562                         }
 563                         if (hit13 != NULL)
 564                         {
 565                                 trigRec->fHit[2].fX = hit13->Xref();
 566                                 trigRec->fHit[2].fY = hit13->Yref();
 567                                 trigRec->fHit[2].fZ = hit13->Zref();
 568                                 hitset[2] = true;
 569                                 y2 = hit13->Yref();
 570                                 z2 = hit13->Zref();
 571                         }
 572                         if (hit14 != NULL)
 573                         {
 574                                 trigRec->fHit[3].fX = hit14->Xref();
 575                                 trigRec->fHit[3].fY = hit14->Yref();
 576                                 trigRec->fHit[3].fZ = hit14->Zref();
 577                                 hitset[3] = true;
 578                                 y2 = hit14->Yref();
 579                                 z2 = hit14->Zref();
 580                         }
 581
 582                         bool calculated = AliHLTMUONCalculations::ComputeMomentum(x1, y1, y2, z1, z2);
 583                         if (not calculated)
 584                                 Logging(kHLTLogDebug,
 585                                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 586                                         "Calculation failure",
 587                                         "Something went wrong when calculating the momentum from"
 588                                           " x1 = %f, y1 = %f, y2 = %f, z1 = %f, z2 = %f.",
 589                                         x1, y1, y2, z1, z2
 590                                 );
 591
 592                         trigRec->fId = trigRecId++;
 593                         trigRec->fFlags = AliHLTMUONUtils::PackTriggerRecordFlags(
 594                                         AliHLTMUONCalculations::Sign(), hitset
 595                                 );
 596                         trigRec->fPx = AliHLTMUONCalculations::Px();
 597                         trigRec->fPy = AliHLTMUONCalculations::Py();
 598                         trigRec->fPz = AliHLTMUONCalculations::Pz();
 599
 600                         // Mark the DDLs over which this trigger record would be readout.
 601                         if (ddl11 != -1) ddlList[ddl11] = true;
 602                         if (ddl12 != -1) ddlList[ddl12] = true;
 603                         if (ddl13 != -1) ddlList[ddl13] = true;
 604                         if (ddl14 != -1) ddlList[ddl14] = true;
 605                 }
 606         }
 607         else if (fMCDataInterface != NULL and not fBuildFromHits)
 608         {
 609                 Logging(kHLTLogDebug,
 610                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 611                         "Filling triggers",
 612                         "Filling data block with simulated local triggers for event %d.",
 613                         eventnumber
 614                 );
 615
 616                 AliFatal("Sorry, -simdata option not yet implemented!");
 617                 // TODO
 618         }
 619         else if (fDataInterface != NULL)
 620         {
 621                 Logging(kHLTLogDebug,
 622                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 623                         "Filling triggers",
 624                         "Filling data block with reconstructed local triggers for event %d.",
 625                         eventnumber
 626                 );
 627                 // TODO
 628                 AliFatal("Sorry, -recdata option not yet implemented!");
 629         }
 630         else
 631         {
 632                 Logging(kHLTLogError,
 633                         "AliHLTMUONTriggerRecordsSource::GetEvent",
 634                         "Missing data interface",
 635                         "Neither AliMUONDataInterface nor AliMUONMCDataInterface were created."
 636                 );
 637                 size = 0; // Important to tell framework that nothing was generated.
 638                 return EFAULT;
 639         }
 640
 641         AliHLTComponentBlockData bd;
 642         FillBlockData(bd);
 643         bd.fPtr = outputPtr;
 644         bd.fOffset = 0;
 645         bd.fSize = block.BytesUsed();
 646         bd.fDataType = AliHLTMUONConstants::TriggerRecordsBlockDataType();
 647         bd.fSpecification = AliHLTMUONUtils::PackSpecBits(ddlList);
 648         outputBlocks.push_back(bd);
 649         size = block.BytesUsed();
 650
 651         return 0;
 652 }