Line data    Source code

       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   21 May 2007
      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           0 :         std::ios::fmtflags oldflags = stream.flags();
      69           0 :         stream  << "{fTrackId = " << trig.fTrackId << ", fTriggerBits = "
      70           0 :                 << std::showbase << std::hex << trig.fTriggerBits << std::dec
      71           0 :                 << ", fPt = " << trig.fPt
      72           0 :                 << "}";
      73           0 :         stream.flags(oldflags);
      74           0 :         return stream;
      75             : }
      76             : 
      77             : /**
      78             :  * Stream operator for usage with std::ostream classes which prints the
      79             :  * AliHLTMUONSinglesDecisionBlockStruct in the following format:
      80             :  *   {fHeader = xx, fNlowPt = yy, fNhighPt = zz, fDecision[] = [{..}, {..}, ...]}
      81             :  */
      82             : std::ostream& operator << (
      83             :                 std::ostream& stream,
      84             :                 const AliHLTMUONSinglesDecisionBlockStruct& block
      85             :         );
      86             : 
      87             : 
      88             : inline bool operator == (
      89             :                 const AliHLTMUONTrackDecisionStruct& a,
      90             :                 const AliHLTMUONTrackDecisionStruct& b
      91             :         )
      92             : {
      93           0 :         return a.fTrackId == b.fTrackId and a.fTriggerBits == b.fTriggerBits
      94           0 :                 and a.fPt == b.fPt;
      95             : }
      96             : 
      97             : inline bool operator != (
      98             :                 const AliHLTMUONTrackDecisionStruct& a,
      99             :                 const AliHLTMUONTrackDecisionStruct& b
     100             :         )
     101             : {
     102           0 :         return not operator == (a, b);
     103             : }
     104             : 
     105             : 
     106             : bool operator == (
     107             :                 const AliHLTMUONSinglesDecisionBlockStruct& a,
     108             :                 const AliHLTMUONSinglesDecisionBlockStruct& b
     109             :         );
     110             : 
     111             : inline bool operator != (
     112             :                 const AliHLTMUONSinglesDecisionBlockStruct& a,
     113             :                 const AliHLTMUONSinglesDecisionBlockStruct& b
     114             :         )
     115             : {
     116             :         return not operator == (a, b);
     117             : }
     118             : 
     119             : #endif // ALIHLTMUONSINGLESDECISIONBLOCKSTRUCT_H