HLT/MUON/AliHLTMUONDataTypes.h

   1 #ifndef ALIHLTMUONDATATYPES_H
   2 #define ALIHLTMUONDATATYPES_H
   3 /**************************************************************************
   4  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Author: The ALICE Off-line Project.                                    *
   7  * Contributors are mentioned in the code where appropriate.              *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 /* $Id$ */
  19
  20 /**
  21  * @file   AliHLTMUONDataTypes.h
  22  * @author Artur Szostak <artursz@iafrica.com>
  23  * @date
  24  * @brief  Declaration of basic data types used in HLT/MUON module.
  25  *
  26  * The types and structs are defined with C linkage since C generally gives us
  27  * more binary compatibility between compilers.
  28  */
  29
  30 #include "AliHLTDataTypes.h"
  31 #include <ostream>
  32
  33 extern "C"
  34 {
  35
  36 /**
  37  * The common internal dimuon HLT data block header.
  38  * These headers help to identify the data block when it is written to disk and
  39  * helps to check the integrity of the data blocks in the system.
  40  */
  41 struct AliHLTMUONDataBlockHeader
  42 {
  43         AliHLTUInt16_t fType; // The type of the data block. Must contain a value
  44                               // defined by AliHLTMUONDataBlockType.
  45         AliHLTUInt16_t fRecordWidth; // The number of bytes each record uses.
  46         AliHLTUInt32_t fNrecords; // Number of records in this data block.
  47 };
  48
  49 } // extern "C"
  50
  51
  52 /**
  53  * The sign/charge of a particle.
  54  */
  55 enum AliHLTMUONParticleSign
  56 {
  57         kSignMinus   = -1,
  58         kSignUnknown = 0,
  59         kSignPlus    = 1
  60 };
  61
  62 /**
  63  * The chamber names of the dimuon spectrometer.
  64  */
  65 enum AliHLTMUONChamberName
  66 {
  67         kUnknownChamber = -1,
  68         kChamber1 = 0,
  69         kChamber2 = 1,
  70         kChamber3 = 2,
  71         kChamber4 = 3,
  72         kChamber5 = 4,
  73         kChamber6 = 5,
  74         kChamber7 = 6,
  75         kChamber8 = 7,
  76         kChamber9 = 8,
  77         kChamber10 = 9,
  78         kChamber11 = 10,
  79         kChamber12 = 11,
  80         kChamber13 = 12,
  81         kChamber14 = 13
  82 };
  83
  84 /**
  85  * The internal data block type codes.
  86  */
  87 enum AliHLTMUONDataBlockType
  88 {
  89         kUnknownDataBlock = 0,
  90         kTriggerRecordsDataBlock = 1000,
  91         kTrigRecsDebugDataBlock = 1001,
  92         kTriggerChannelsDataBlock = 1002,
  93         kRecHitsDataBlock = 2000,
  94         kClustersDataBlock = 2001,
  95         kChannelsDataBlock = 2002,
  96         kMansoTracksDataBlock = 3000,
  97         kMansoCandidatesDataBlock = 3001,
  98         kSinglesDecisionDataBlock = 4000,
  99         kPairsDecisionDataBlock = 4001
 100 };
 101
 102
 103 /**
 104  * Stream operator to be able to print AliHLTMUONParticleSign with human
 105  * readable names to some stream object like cout (standard output).
 106  */
 107 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONParticleSign sign)
 108 {
 109         switch (sign)
 110         {
 111         case kSignMinus:   stream << "kSignMinus";   break;
 112         case kSignUnknown: stream << "kSignUnknown"; break;
 113         case kSignPlus:    stream << "kSignPlus";    break;
 114         default:           stream << "INVALID";
 115         }
 116         return stream;
 117 }
 118
 119 /**
 120  * Stream operator to be able to print AliHLTMUONChamberName with human
 121  * readable names to some stream object like cout (standard output).
 122  */
 123 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONChamberName chamber)
 124 {
 125         switch (chamber)
 126         {
 127         case kUnknownChamber:  stream << "kUnknownChamber";  break;
 128         case kChamber1:        stream << "kChamber1";        break;
 129         case kChamber2:        stream << "kChamber2";        break;
 130         case kChamber3:        stream << "kChamber3";        break;
 131         case kChamber4:        stream << "kChamber4";        break;
 132         case kChamber5:        stream << "kChamber5";        break;
 133         case kChamber6:        stream << "kChamber6";        break;
 134         case kChamber7:        stream << "kChamber7";        break;
 135         case kChamber8:        stream << "kChamber8";        break;
 136         case kChamber9:        stream << "kChamber9";        break;
 137         case kChamber10:       stream << "kChamber10";       break;
 138         case kChamber11:       stream << "kChamber11";       break;
 139         case kChamber12:       stream << "kChamber12";       break;
 140         case kChamber13:       stream << "kChamber13";       break;
 141         case kChamber14:       stream << "kChamber14";       break;
 142         default:               stream << "INVALID";
 143         }
 144         return stream;
 145 }
 146
 147 /**
 148  * Stream operator to be able to print AliHLTMUONDataBlockType with human
 149  * readable names to some stream object like cout (standard output).
 150  */
 151 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONDataBlockType type)
 152 {
 153         switch (type)
 154         {
 155         case kUnknownDataBlock:         stream << "kUnknownDataBlock";         break;
 156         case kTriggerRecordsDataBlock:  stream << "kTriggerRecordsDataBlock";  break;
 157         case kTrigRecsDebugDataBlock:   stream << "kTrigRecsDebugDataBlock";   break;
 158         case kTriggerChannelsDataBlock: stream << "kTriggerChannelsDataBlock"; break;
 159         case kRecHitsDataBlock:         stream << "kRecHitsDataBlock";         break;
 160         case kClustersDataBlock:        stream << "kClustersDataBlock";        break;
 161         case kChannelsDataBlock:        stream << "kChannelsDataBlock";        break;
 162         case kMansoTracksDataBlock:     stream << "kMansoTracksDataBlock";     break;
 163         case kMansoCandidatesDataBlock: stream << "kMansoCandidatesDataBlock"; break;
 164         case kSinglesDecisionDataBlock: stream << "kSinglesDecisionDataBlock"; break;
 165         case kPairsDecisionDataBlock:   stream << "kPairsDecisionDataBlock";   break;
 166         default:                        stream << "INVALID";
 167         }
 168         return stream;
 169 }
 170
 171 /**
 172  * Stream operator for usage with std::ostream classes which prints the common
 173  * data block header in the following format:
 174  *  {fType = xx, fRecordWidth = yy, fNrecords = zz}
 175  */
 176 inline std::ostream& operator << (
 177                 std::ostream& stream, const AliHLTMUONDataBlockHeader& header
 178         )
 179 {
 180         stream  << "{fType = " << AliHLTMUONDataBlockType(header.fType)
 181                 << ", fRecordWidth = " << header.fRecordWidth
 182                 << ", fNrecords = " << header.fNrecords << "}";
 183         return stream;
 184 }
 185
 186
 187 inline bool operator == (
 188                 const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
 189         )
 190 {
 191         return a.fType == b.fType and a.fRecordWidth == b.fRecordWidth
 192                 and a.fNrecords == b.fNrecords;
 193 }
 194
 195 inline bool operator != (
 196                 const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
 197         )
 198 {
 199         return not operator == (a, b);
 200 }
 201
 202 #endif // ALIHLTMUONDATATYPES_H