AliRoot Core  edcc906 (edcc906)
AliMUONTriggerDDLDecoderEventHandler.h
Go to the documentation of this file.
1 #ifndef ALIMUONTRIGGERDDLDECODEREVENTHANDLER_H
2 #define ALIMUONTRIGGERDDLDECODEREVENTHANDLER_H
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project *
5  * All rights reserved. *
6  * *
7  * Primary Authors: *
8  * Artur Szostak <artursz@iafrica.com> *
9  * *
10  * Permission to use, copy, modify and distribute this software and its *
11  * documentation strictly for non-commercial purposes is hereby granted *
12  * without fee, provided that the above copyright notice appears in all *
13  * copies and that both the copyright notice and this permission notice *
14  * appear in the supporting documentation. The authors make no claims *
15  * about the suitability of this software for any purpose. It is *
16  * provided "as is" without express or implied warranty. *
17  **************************************************************************/
18 
19 /* $Id$ */
20 
30 
31 #include <cassert>
32 #include <ostream>
33 #include <Rtypes.h>
34 
35 
36 // We use C binding for the structures because C is more uniform with its application
37 // binary interface (ABI) between compilers.
38 extern "C"
39 {
40 
41 // The following structures are the headers found in the DDL payload coming from
42 // the muon hardware trigger. The specification is given in ALICE-INT-2005-012
43 // (https://edms.cern.ch/file/591904/1/ALICE-INT-2005-012.pdf)
44 
47 {
48  UInt_t fL0R;
49  UInt_t fL1P;
50  UInt_t fL1S;
51  UInt_t fL2A;
52  UInt_t fL2R;
53  UInt_t fClk;
54  UInt_t fHold;
55  UInt_t fSpare;
56 };
57 
60 {
61  UInt_t fInput[4];
62  UInt_t fOutput;
63 };
64 
67 {
68  UInt_t fL0;
69  UInt_t fClk;
70  UInt_t fScaler[6];
71  UInt_t fHold;
72  UInt_t fSpare;
73 };
74 
77 {
78  UInt_t fDarcWord;
79  UInt_t fWord;
80  UInt_t fInput[2];
81  UInt_t fL0CountAndMask;
82 };
83 
86 {
87  UInt_t fClk;
88  UInt_t fScaler[8];
89  UInt_t fHold;
90 };
91 
92 
95 {
96  UInt_t fX2X1;
97  UInt_t fX4X3;
98  UInt_t fY2Y1;
99  UInt_t fY4Y3;
100  UInt_t fTriggerBits;
101 };
102 
105 {
106  UInt_t fL0;
107  UInt_t fHold;
108  UInt_t fClk;
109 
110  UInt_t fLPtNTrig;
111  UInt_t fHPtNTrig;
112 
113  UInt_t fLPtRTrig;
114  UInt_t fHPtRTrig;
115 
116  UInt_t fLPtLTrig;
117  UInt_t fHPtLTrig;
118 
119  UInt_t fLPtSTrig;
120  UInt_t fHPtSTrig;
121 
122  UInt_t fScaler[8*4];
123  UInt_t fEOS;
124  UInt_t fReset;
125 };
126 
127 } // extern "C"
128 
129 
140 {
141 public:
142 
147 
150  {
151  kNoError = 0,
152  kTooManyRegionals = 1,
153  kNoDarcHeader = 2,
154  kNoDarcScalars = 3,
155  kWrongEventType = 4,
156  kNoEndOfDarc = 5,
157  kBadEndOfDarc = 6,
158  kNoGlobalHeader = 7,
159  kNoGlobalScalars = 8,
160  kNoEndOfGlobal = 9,
161  kBadEndOfGlobal = 10,
162  kNoRegionalHeader = 11,
163  kNoRegionalScalars = 12,
164  kNoEndOfRegional = 13,
165  kBadEndOfRegional = 14,
166  kNoLocalStruct = 15,
167  kNoLocalScalars = 16,
168  kNoEndOfLocal = 17,
169  kBadEndOfLocal = 18,
170  kBufferTooBig = 19
171  };
172 
173  // The following methods should be overridden for specific processing to
174  // take place in your own event handler.
175 
182  void OnNewBuffer(const void* /*buffer*/, UInt_t /*bufferSize*/) {}
183 
192  void OnEndOfBuffer(const void* /*buffer*/, UInt_t /*bufferSize*/) {}
193 
204  UInt_t /*header*/,
205  const AliMUONDarcScalarsStruct* /*scalars*/,
206  const void* /*data*/
207  )
208  {
209  }
210 
220  const AliMUONGlobalHeaderStruct* /*header*/,
221  const AliMUONGlobalScalarsStruct* /*scalars*/,
222  const void* /*data*/
223  )
224  {
225  }
226 
238  const AliMUONRegionalHeaderStruct* /*regionalStruct*/,
239  const AliMUONRegionalScalarsStruct* /*scalars*/,
240  const void* /*data*/
241  )
242  {
243  }
244 
259  UInt_t /*num*/,
260  const AliMUONRegionalHeaderStruct* /*regionalStruct*/,
261  const AliMUONRegionalScalarsStruct* /*scalars*/,
262  const void* /*data*/
263  )
264  {
265  }
266 
280  const AliMUONRegionalHeaderStruct* /*regionalStruct*/,
281  const AliMUONRegionalScalarsStruct* /*scalars*/,
282  const void* /*data*/
283  )
284  {
285  }
286 
303  UInt_t /*num*/,
304  const AliMUONRegionalHeaderStruct* /*regionalStruct*/,
305  const AliMUONRegionalScalarsStruct* /*scalars*/,
306  const void* /*data*/
307  )
308  {
309  }
310 
321  const AliMUONLocalInfoStruct* /*localStruct*/,
322  const AliMUONLocalScalarsStruct* /*scalars*/
323  )
324  {
325  }
326 
340  UInt_t /*num*/,
341  const AliMUONLocalInfoStruct* /*localStruct*/,
342  const AliMUONLocalScalarsStruct* /*scalars*/
343  )
344  {
345  }
346 
347  // The following static methods are helper routines for decoding the
348  // DARC header bits.
349 
352  static UChar_t GetDarcEventType(UInt_t header) { return (UChar_t)(header >> 30) & 0x3; };
353 
356  static UChar_t GetDarcType(UInt_t header) { return (UChar_t)(header >> 24) & 0x7; }
357 
360  static UChar_t GetDarcSerialNb(UInt_t header) { return (UChar_t)(header >> 20) & 0xF; }
361 
364  static UChar_t GetDarcVersion(UInt_t header) { return (UChar_t)(header >> 12) & 0xFF; }
365 
368  static bool GetDarcVMETrig(UInt_t header) { return (header & 0x800); }
369 
372  static bool GetDarcGlobalFlag(UInt_t header) { return (header & 0x400); }
373 
376  static bool GetDarcCTPTrig(UInt_t header) { return (header & 0x200); }
377 
380  static bool GetDarcDAQFlag(UInt_t header) { return (header & 0x100); }
381 
384  static UChar_t GetDarcRegPattern(UInt_t header) { return (UChar_t)(header & 0xFF); }
385 
386  // The following static methods are helper routines for decoding the
387  // regional structure header bits.
388 
390  static UShort_t GetRegionalL0(const AliMUONRegionalHeaderStruct* header)
391  {
392  assert( header != NULL );
393  return (header->fL0CountAndMask >> 16) & 0xFFFF;
394  }
395 
397  static UShort_t GetRegionalMask(const AliMUONRegionalHeaderStruct* header)
398  {
399  assert( header != NULL );
400  return header->fL0CountAndMask & 0xFFFF;
401  }
402 
405  {
406  assert( header != NULL );
407  return (header->fWord & 0x80000000) != 0;
408  }
409 
411  static UChar_t GetRegionalResetNb(const AliMUONRegionalHeaderStruct* header)
412  {
413  assert( header != NULL );
414  return (UChar_t)(header->fWord >> 25) & 0x3F;
415  }
416 
418  static UChar_t GetRegionalSerialNb(const AliMUONRegionalHeaderStruct* header)
419  {
420  assert( header != NULL );
421  return (UChar_t)(header->fWord >> 20) & 0x1F;
422  }
423 
425  static UChar_t GetRegionalId(const AliMUONRegionalHeaderStruct* header)
426  {
427  assert( header != NULL );
428  return (UChar_t)(header->fWord >> 16) & 0x0F;
429  }
430 
432  static UChar_t GetRegionalVersion(const AliMUONRegionalHeaderStruct* header)
433  {
434  assert( header != NULL );
435  return (UChar_t)(header->fWord >> 8) & 0xFF;
436  }
437 
439  static UChar_t GetRegionalOutput(const AliMUONRegionalHeaderStruct* header)
440  {
441  assert( header != NULL );
442  return (UChar_t)(header->fWord & 0xFF);
443  }
444 
446  static UShort_t GetRegionalErrorBits(const AliMUONRegionalHeaderStruct* header)
447  {
448  assert( header != NULL );
449  return (UShort_t)(header->fDarcWord >> 22) & 0x3FF;
450  }
451 
454  {
455  assert( header != NULL );
456  return (UChar_t) (header->fDarcWord >> 19) & 0x7;
457  }
458 
461  {
462  assert( header != NULL );
463  return (header->fDarcWord & 0x8000) != 0;
464  }
465 
468  {
469  assert( header != NULL );
470  return (header->fDarcWord & 0x4000) != 0;
471  }
472 
475  {
476  assert( header != NULL );
477  return (header->fDarcWord & 0x2000) != 0;
478  }
479 
482  {
483  assert( header != NULL );
484  return (header->fDarcWord & 0x1000) != 0;
485  }
486 
489  {
490  assert( header != NULL );
491  return (header->fDarcWord & 0x800) != 0;
492  }
493 
496  {
497  assert( header != NULL );
498  return (header->fDarcWord & 0x400) != 0;
499  }
500 
503  {
504  assert( header != NULL );
505  return (header->fDarcWord & 0x200) != 0;
506  }
507 
510  {
511  assert( header != NULL );
512  return (header->fDarcWord & 0x100) != 0;
513  }
514 
517  {
518  assert( header != NULL );
519  return (UChar_t) (header->fDarcWord >> 4) & 0x4;
520  }
521 
523  static UChar_t GetRegionalBusy(const AliMUONRegionalHeaderStruct* header)
524  {
525  assert( header != NULL );
526  return (UChar_t) (header->fDarcWord) & 0x4;
527  }
528 
529  // The following static methods are helper routines for decoding the
530  // global header bits.
531 
534  static UChar_t GetGlobalOutput(const AliMUONGlobalHeaderStruct* header)
535  {
536  assert(header != NULL);
537  return header->fOutput & 0xFF;
538  }
539 
542  static UShort_t GetGlobalConfig(const AliMUONGlobalHeaderStruct* header)
543  {
544  assert(header != NULL);
545  return (header->fOutput >> 16) & 0xFFFF;
546  }
547 
548  // The following static methods are helper routines for decoding the
549  // local trigger structure and scalar bits.
550 
552  static UShort_t GetLocalX2(const AliMUONLocalInfoStruct* local)
553  {
554  assert(local != NULL);
555  return (local->fX2X1 >> 16) & 0xFFFF;
556  }
557 
559  static UShort_t GetLocalX1(const AliMUONLocalInfoStruct* local)
560  {
561  assert(local != NULL);
562  return (local->fX2X1) & 0xFFFF;
563  }
564 
566  static UShort_t GetLocalX4(const AliMUONLocalInfoStruct* local)
567  {
568  assert(local != NULL);
569  return (local->fX4X3 >> 16) & 0xFFFF;
570  }
571 
573  static UShort_t GetLocalX3(const AliMUONLocalInfoStruct* local)
574  {
575  assert(local != NULL);
576  return (local->fX4X3) & 0xFFFF;
577  }
578 
580  static UShort_t GetLocalY2(const AliMUONLocalInfoStruct* local)
581  {
582  assert(local != NULL);
583  return (local->fY2Y1 >> 16) & 0xFFFF;
584  }
585 
587  static UShort_t GetLocalY1(const AliMUONLocalInfoStruct* local)
588  {
589  assert(local != NULL);
590  return (local->fY2Y1) & 0xFFFF;
591  }
592 
594  static UShort_t GetLocalY4(const AliMUONLocalInfoStruct* local)
595  {
596  assert(local != NULL);
597  return (local->fY4Y3 >> 16) & 0xFFFF;
598  }
599 
601  static UShort_t GetLocalY3(const AliMUONLocalInfoStruct* local)
602  {
603  assert(local != NULL);
604  return (local->fY4Y3) & 0xFFFF;
605  }
606 
608  static UChar_t GetLocalId(const AliMUONLocalInfoStruct* local)
609  {
610  assert(local != NULL);
611  return local->fTriggerBits >> 19 & 0xF;
612  }
613 
615  static UChar_t GetLocalDec(const AliMUONLocalInfoStruct* local)
616  {
617  assert(local != NULL);
618  return local->fTriggerBits >> 15 & 0xF;
619  }
620 
622  static bool GetLocalTrigY(const AliMUONLocalInfoStruct* local)
623  {
624  assert(local != NULL);
625  return (local->fTriggerBits >> 14 & 0x1);
626  }
627 
629  static bool GetLocalTriggerY(const AliMUONLocalInfoStruct* local)
630  {
631  return not (GetLocalTrigY(local) and GetLocalYPos(local) == 15);
632  }
633 
635  static UChar_t GetLocalYPos(const AliMUONLocalInfoStruct* local)
636  {
637  assert(local != NULL);
638  return local->fTriggerBits >> 10 & 0xF;
639  }
640 
642  static bool GetLocalSXDev(const AliMUONLocalInfoStruct* local)
643  {
644  assert(local != NULL);
645  return (local->fTriggerBits >> 9 & 0x1);
646  }
647 
649  static UChar_t GetLocalXDev(const AliMUONLocalInfoStruct* local)
650  {
651  assert(local != NULL);
652  return local->fTriggerBits >> 5 & 0xF;
653  }
654 
656  static bool GetLocalTriggerX(const AliMUONLocalInfoStruct* local)
657  {
658  return not (GetLocalSXDev(local) and (GetLocalXDev(local) == 0)
659  and GetLocalXPos(local) == 0);
660  }
661 
663  static UChar_t GetLocalXPos(const AliMUONLocalInfoStruct* local)
664  {
665  assert(local != NULL);
666  return local->fTriggerBits & 0x1F;
667  }
668 
670  static UChar_t GetLocalLpt(const AliMUONLocalInfoStruct* local) {return (GetLocalDec(local) & 0x3);}
671 
673  static UChar_t GetLocalHpt(const AliMUONLocalInfoStruct* local) {return (GetLocalDec(local) >> 2) & 0x3;}
674 
676  static UShort_t GetLocalSwitch(const AliMUONLocalScalarsStruct* scalars)
677  {
678  assert(scalars != NULL);
679  return (scalars->fEOS >> 1) & 0x3FF;
680  }
681 
683  static UChar_t GetLocalComptXY(const AliMUONLocalScalarsStruct* scalars)
684  {
685  assert(scalars != NULL);
686  return scalars->fEOS & 0x1;
687  }
688 
690  static UShort_t GetLocalXY1(const AliMUONLocalScalarsStruct* scalars, UInt_t n)
691  {
692  assert(scalars != NULL and n < 16);
693  return (n % 2 == 1) ? (scalars->fScaler[(n/2)] & 0xFFFF)
694  : ((scalars->fScaler[(n/2)] >> 16) & 0xFFFF);
695  }
696 
698  static UShort_t GetLocalXY2(const AliMUONLocalScalarsStruct* scalars, UInt_t n)
699  {
700  assert(scalars != NULL and n < 16);
701  return (n % 2 == 1) ? (scalars->fScaler[8 + (n/2)] & 0xFFFF)
702  : ((scalars->fScaler[8 + (n/2)] >> 16) & 0xFFFF);
703  }
704 
706  static UShort_t GetLocalXY3(const AliMUONLocalScalarsStruct* scalars, UInt_t n)
707  {
708  assert(scalars != NULL and n < 16);
709  return (n % 2 == 1) ? (scalars->fScaler[8*2 + (n/2)] & 0xFFFF)
710  : ((scalars->fScaler[8*2 + (n/2)] >> 16) & 0xFFFF);
711  }
712 
714  static UShort_t GetLocalXY4(const AliMUONLocalScalarsStruct* scalars, UInt_t n)
715  {
716  assert(scalars != NULL and n < 16);
717  return (n % 2 == 1) ? (scalars->fScaler[8*3 + (n/2)] & 0xFFFF)
718  : ((scalars->fScaler[8*3 + (n/2)] >> 16) & 0xFFFF);
719  }
720 
734  void OnError(ErrorCode /*error*/, const void* /*location*/) {}
735 
740  static const char* ErrorCodeToString(ErrorCode code);
741 
746  static const char* ErrorCodeToMessage(ErrorCode code);
747 };
748 
749 //_____________________________________________________________________________
750 
752 {
757 
758  switch (code)
759  {
760  case kNoError: return "kNoError";
761  case kTooManyRegionals: return "kTooManyRegionals";
762  case kNoDarcHeader: return "kNoDarcHeader";
763  case kNoDarcScalars: return "kNoDarcScalars";
764  case kWrongEventType: return "kWrongEventType";
765  case kNoEndOfDarc: return "kNoEndOfDarc";
766  case kBadEndOfDarc: return "kBadEndOfDarc";
767  case kNoGlobalHeader: return "kNoGlobalHeader";
768  case kNoGlobalScalars: return "kNoGlobalScalars";
769  case kNoEndOfGlobal: return "kNoEndOfGlobal";
770  case kBadEndOfGlobal: return "kBadEndOfGlobal";
771  case kNoRegionalHeader: return "kNoRegionalHeader";
772  case kNoRegionalScalars: return "kNoRegionalScalars";
773  case kNoEndOfRegional: return "kNoEndOfRegional";
774  case kBadEndOfRegional: return "kBadEndOfRegional";
775  case kNoLocalStruct: return "kNoLocalStruct";
776  case kNoLocalScalars: return "kNoLocalScalars";
777  case kNoEndOfLocal: return "kNoEndOfLocal";
778  case kBadEndOfLocal: return "kBadEndOfLocal";
779  case kBufferTooBig: return "kBufferTooBig";
780  default: return "INVALID";
781  }
782 }
783 
784 
786 {
791 
792  switch (code)
793  {
794  case kNoError:
795  return "Decoding was successful.";
796  case kTooManyRegionals:
797  return "Too many regional card structures are expected in the DDL payload.";
798  case kNoDarcHeader:
799  return "The DARC header is missing. The DDL buffer is too short"
800  " to hold a DARC header.";
801  case kNoDarcScalars:
802  return "The DARC scalars are missing or corrupt."
803  " The DDL buffer is too short to contain them.";
804  case kWrongEventType:
805  return "Wrong event type obtained from the Darc header.";
806  case kNoEndOfDarc:
807  return "The DDL buffer is too short to contain an end of DARC"
808  " header key word.";
809  case kBadEndOfDarc:
810  return "End of DARC header key word is incorrect or corrupt.";
811  case kNoGlobalHeader:
812  return "The global header is missing. The DDL buffer is too"
813  " short to hold a global header.";
814  case kNoGlobalScalars:
815  return "The global scalars are missing or corrupt. The DDL"
816  " buffer is too short to contain them.";
817  case kNoEndOfGlobal:
818  return "The DDL buffer is too short to contain an end of global"
819  " header key word.";
820  case kBadEndOfGlobal:
821  return "End of global header key word is incorrect or corrupt.";
822  case kNoRegionalHeader:
823  return "The regional header is missing. The DDL buffer is too"
824  " short to hold another regional header.";
825  case kNoRegionalScalars:
826  return "The regional scalars are missing or corrupt. The DDL"
827  " buffer is too short to contain them.";
828  case kNoEndOfRegional:
829  return "The DDL buffer is too short to contain an end of regional"
830  " header key word.";
831  case kBadEndOfRegional:
832  return "End of regional header key word is incorrect or corrupt.";
833  case kNoLocalStruct:
834  return "The local structure is missing. The DDL buffer is too"
835  " short to hold another local structure.";
836  case kNoLocalScalars:
837  return "The local scalars are missing or corrupt. The DDL buffer"
838  " is too short to contain them.";
839  case kNoEndOfLocal:
840  return "The DDL buffer is too short to contain an end of local"
841  " structure key word.";
842  case kBadEndOfLocal:
843  return "End of local structure key word is incorrect or corrupt.";
844  case kBufferTooBig:
845  return "The DDL raw data is larger than indicated by the headers;"
846  " extra bytes are probably just garbage.";
847  default:
848  return "Unknown error code!";
849  }
850 }
851 
852 
853 inline std::ostream& operator << (std::ostream& os, AliMUONTriggerDDLDecoderEventHandler::ErrorCode code)
854 {
858 
860  return os;
861 }
862 
863 #endif // ALIMUONTRIGGERDDLDECODEREVENTHANDLER_H
static UShort_t GetLocalXY4(const AliMUONLocalScalarsStruct *scalars, UInt_t n)
Return XY4.
UInt_t fHPtNTrig
local high Pt no trigger
The optional DARC board scalars.
static UChar_t GetRegionalId(const AliMUONRegionalHeaderStruct *header)
Return Id.
static bool GetRegionalRamNotEmptyFlag(const AliMUONRegionalHeaderStruct *header)
Return RamNotEmptyFlag.
static UShort_t GetLocalY3(const AliMUONLocalInfoStruct *local)
Return Y3.
static bool GetRegionalL2AccStatus(const AliMUONRegionalHeaderStruct *header)
Return L2AccStatus.
static UChar_t GetLocalXPos(const AliMUONLocalInfoStruct *local)
Return Xpos.
UInt_t fHPtRTrig
local high Pt right trigger
void OnNewRegionalStruct(const AliMUONRegionalHeaderStruct *, const AliMUONRegionalScalarsStruct *, const void *)
ErrorCode
All the possible error codes from the parsing.
static bool GetRegionalDarcPhysFlag(const AliMUONRegionalHeaderStruct *header)
Return DarcPhysFlag.
The global input and output words just after the DARC header.
UInt_t fLPtRTrig
local low Pt right trigger
static UChar_t GetLocalXDev(const AliMUONLocalInfoStruct *local)
Get X deviation.
void OnEndOfRegionalStructV2(UInt_t, const AliMUONRegionalHeaderStruct *, const AliMUONRegionalScalarsStruct *, const void *)
static UChar_t GetLocalLpt(const AliMUONLocalInfoStruct *local)
Return LPT.
static UShort_t GetLocalXY3(const AliMUONLocalScalarsStruct *scalars, UInt_t n)
Return XY3.
static UShort_t GetLocalXY1(const AliMUONLocalScalarsStruct *scalars, UInt_t n)
Return XY1.
UInt_t fL0CountAndMask
L0 counter (16 bits) and local mask ("poids faible" 16 bits)
Local card trigger information.
Callback event handler class for the AliMUONTriggerDDLDecoder. This class is the base class defining ...
UInt_t fClk
Regional number of clock cycles.
static UChar_t GetRegionalResetNb(const AliMUONRegionalHeaderStruct *header)
Return ResetNb.
UInt_t fL0R
DARC L0 received and used.
static UChar_t GetLocalId(const AliMUONLocalInfoStruct *local)
Return Id.
void OnDarcHeader(UInt_t, const AliMUONDarcScalarsStruct *, const void *)
static const char * ErrorCodeToMessage(ErrorCode code)
UInt_t fY2Y1
16 bits Y2 position in 16 most significant bits and 16 bits of Y1 in least significant bits...
static UChar_t GetRegionalSerialNb(const AliMUONRegionalHeaderStruct *header)
Return SerialNb.
UInt_t fLPtSTrig
local low Pt straight trigger
void OnLocalStruct(const AliMUONLocalInfoStruct *, const AliMUONLocalScalarsStruct *)
static bool GetLocalTrigY(const AliMUONLocalInfoStruct *local)
Return TrigY.
UInt_t fHPtSTrig
local high Pt straight trigger
static UShort_t GetRegionalL0(const AliMUONRegionalHeaderStruct *header)
Return L0.
static UShort_t GetLocalX2(const AliMUONLocalInfoStruct *local)
Return X2.
void OnNewRegionalStructV2(UInt_t, const AliMUONRegionalHeaderStruct *, const AliMUONRegionalScalarsStruct *, const void *)
UInt_t fHPtLTrig
local high Pt left trigger
static bool GetRegionalRamNotFullFlag(const AliMUONRegionalHeaderStruct *header)
Return RamNotFullFlag.
static bool GetRegionalL0Status(const AliMUONRegionalHeaderStruct *header)
Return L0Status.
UInt_t fClk
Global number of clock cycles.
static bool GetLocalSXDev(const AliMUONLocalInfoStruct *local)
Get Sign of X deviation.
static const char * ErrorCodeToString(ErrorCode code)
UInt_t fY4Y3
16 bits Y4 position in 16 most significant bits and 16 bits of Y3 in least significant bits...
static UChar_t GetLocalDec(const AliMUONLocalInfoStruct *local)
Return Dec.
static UChar_t GetRegionalOutput(const AliMUONRegionalHeaderStruct *header)
Return Output.
UInt_t fX2X1
16 bits X2 position in 16 most significant bits and 16 bits of X1 in least significant bits...
std::ostream & operator<<(std::ostream &os, AliMUONTriggerDDLDecoderEventHandler::ErrorCode code)
static UShort_t GetLocalY4(const AliMUONLocalInfoStruct *local)
Return Y4.
static bool GetRegionalL1Status(const AliMUONRegionalHeaderStruct *header)
Return L1Status.
UInt_t fHold
Global number of hold (dead time)
static UShort_t GetLocalXY2(const AliMUONLocalScalarsStruct *scalars, UInt_t n)
Return XY2.
static UShort_t GetRegionalErrorBits(const AliMUONRegionalHeaderStruct *header)
Return ErrorBits.
static UChar_t GetRegionalFPGANumber(const AliMUONRegionalHeaderStruct *header)
Return FPGANumber.
UInt_t fL0
Global number of L0 triggers.
void OnGlobalHeader(const AliMUONGlobalHeaderStruct *, const AliMUONGlobalScalarsStruct *, const void *)
UInt_t fL0
local number of L0 triggers.
The optional global card scalars.
UInt_t fClk
local number of clock cycles
UInt_t fX4X3
16 bits X4 position in 16 most significant bits and 16 bits of X3 in least significant bits...
static UChar_t GetLocalComptXY(const AliMUONLocalScalarsStruct *scalars)
Return ComptXY.
static bool GetLocalTriggerY(const AliMUONLocalInfoStruct *local)
Return TriggerY.
static bool GetRegionalPhysFlag(const AliMUONRegionalHeaderStruct *header)
Return RegPhysFlag.
static UChar_t GetRegionalEventInRam(const AliMUONRegionalHeaderStruct *header)
Return EventInRam.
UInt_t fLPtNTrig
local low Pt no trigger
static UChar_t GetGlobalOutput(const AliMUONGlobalHeaderStruct *header)
void OnEndOfRegionalStruct(const AliMUONRegionalHeaderStruct *, const AliMUONRegionalScalarsStruct *, const void *)
static UChar_t GetRegionalBusy(const AliMUONRegionalHeaderStruct *header)
Return Busy.
static bool GetRegionalPresentFlag(const AliMUONRegionalHeaderStruct *header)
Return PresentFlag.
static bool GetLocalTriggerX(const AliMUONLocalInfoStruct *local)
Return TriggerX.
static UShort_t GetLocalX3(const AliMUONLocalInfoStruct *local)
Return X3.
static UShort_t GetLocalY2(const AliMUONLocalInfoStruct *local)
Return Y2.
static UShort_t GetLocalSwitch(const AliMUONLocalScalarsStruct *scalars)
Return switch.
static UShort_t GetLocalX4(const AliMUONLocalInfoStruct *local)
Return X4.
static bool GetRegionalL2RejStatus(const AliMUONRegionalHeaderStruct *header)
Return L2RejStatus.
static UChar_t GetLocalHpt(const AliMUONLocalInfoStruct *local)
Return HPT.
UInt_t fSpare
DARC Empty slot (for the moment)
UInt_t fLPtLTrig
local low Pt left trigger
static UShort_t GetGlobalConfig(const AliMUONGlobalHeaderStruct *header)
static UChar_t GetLocalYPos(const AliMUONLocalInfoStruct *local)
Return Upos.
static UChar_t GetRegionalVersion(const AliMUONRegionalHeaderStruct *header)
Return Version.
static UShort_t GetRegionalMask(const AliMUONRegionalHeaderStruct *header)
Return mask.
void OnLocalStructV2(UInt_t, const AliMUONLocalInfoStruct *, const AliMUONLocalScalarsStruct *)
static UShort_t GetLocalX1(const AliMUONLocalInfoStruct *local)
Return X1.
static UShort_t GetLocalY1(const AliMUONLocalInfoStruct *local)
Return Y1.
UInt_t fTriggerBits
Trigger bits and deviation.
UInt_t fEOS
contains switches conf. & flag for reading X (0) or Y (1) in fScaler