HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.h

   1 #ifndef ALIHLTMUONSINGLESDECISIONBLOCKSTRUCT_H
   2 #define ALIHLTMUONSINGLESDECISIONBLOCKSTRUCT_H
   3 /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 /**
   9  * @file   AliHLTMUONSinglesDecisionBlockStruct.h
  10  * @author Artur Szostak <artursz@iafrica.com>
  11  * @date
  12  * @brief  Definition of internal dimuon HLT trigger decision data structure
  13  *         containing decision information for single tracks.
  14  *
  15  * The structures are defined with C linkage since C generally gives us more
  16  * binary compatibility between compilers.
  17  */
  18
  19 #include "AliHLTMUONDataTypes.h"
  20
  21 extern "C"
  22 {
  23
  24 /**
  25  * Structure contains information about the trigger decision for a single track.
  26  */
  27 struct AliHLTMUONTrackDecisionStruct
  28 {
  29         AliHLTInt32_t fTrackId; // The ID number of the track we are referring to.
  30                                 // This could also be a trigger record ID.
  31
  32         // The trigger bits have the following meaning:
  33         // bit:  [31 --- 2][  1 ][  0 ]
  34         // field: reserved  hipt  lopt
  35         // Reserved bits should be set to zero.
  36         // hipt == passed high pt cut. lopt == passed low pt cut.
  37         AliHLTUInt32_t fTriggerBits;
  38
  39         AliHLTFloat32_t fPt; // The calculated transverse momentum of the track in (GeV/c).
  40 };
  41
  42 /**
  43  * AliHLTMUONSinglesDecisionBlockStruct defines the format of the internal
  44  * dimuon HLT decision data block for individual tracks.
  45  */
  46 struct AliHLTMUONSinglesDecisionBlockStruct
  47 {
  48         AliHLTMUONDataBlockHeader fHeader; // Common data block header.
  49         AliHLTUInt32_t fNlowPt;  // Number of low pt triggers.
  50         AliHLTUInt32_t fNhighPt; // Number of high pt triggers.
  51
  52         // Array of decisions for individual tracks.
  53         //AliHLTMUONTrackDecisionStruct fDecision[/*fHeader.fNrecords*/];
  54 };
  55
  56 } // extern "C"
  57
  58
  59 /**
  60  * Stream operator for usage with std::ostream classes which prints the
  61  * trigger decision information for individual tracks in the following format:
  62  *  {fTrackId = xx, fTriggerBits = 0xYY}
  63  */
  64 inline std::ostream& operator << (
  65                 std::ostream& stream, const AliHLTMUONTrackDecisionStruct& trig
  66         )
  67 {
  68         stream  << "{fTrackId = " << trig.fTrackId << ", fTriggerBits = "
  69                 << std::showbase << std::hex << trig.fTriggerBits << std::dec
  70                 << ", fPt = " << trig.fPt
  71                 << "}";
  72         return stream;
  73 }
  74
  75 /**
  76  * Stream operator for usage with std::ostream classes which prints the
  77  * AliHLTMUONSinglesDecisionBlockStruct in the following format:
  78  *   {fHeader = xx, fNlowPt = yy, fNhighPt = zz, fDecision[] = [{..}, {..}, ...]}
  79  */
  80 std::ostream& operator << (
  81                 std::ostream& stream,
  82                 const AliHLTMUONSinglesDecisionBlockStruct& block
  83         );
  84
  85
  86 inline bool operator == (
  87                 const AliHLTMUONTrackDecisionStruct& a,
  88                 const AliHLTMUONTrackDecisionStruct& b
  89         )
  90 {
  91         return a.fTrackId == b.fTrackId and a.fTriggerBits == b.fTriggerBits
  92                 and a.fPt == b.fPt;
  93 }
  94
  95 inline bool operator != (
  96                 const AliHLTMUONTrackDecisionStruct& a,
  97                 const AliHLTMUONTrackDecisionStruct& b
  98         )
  99 {
 100         return not operator == (a, b);
 101 }
 102
 103
 104 bool operator == (
 105                 const AliHLTMUONSinglesDecisionBlockStruct& a,
 106                 const AliHLTMUONSinglesDecisionBlockStruct& b
 107         );
 108
 109 inline bool operator != (
 110                 const AliHLTMUONSinglesDecisionBlockStruct& a,
 111                 const AliHLTMUONSinglesDecisionBlockStruct& b
 112         )
 113 {
 114         return not operator == (a, b);
 115 }
 116
 117 #endif // ALIHLTMUONSINGLESDECISIONBLOCKSTRUCT_H