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