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 typedef signed char AliHLTInt8_t;
  37 typedef signed int AliHLTInt32_t;
  38 typedef float AliHLTFloat32_t;
  39 typedef double AliHLTFloat64_t;
  40
  41 /**
  42  * The common internal dimuon HLT data block header.
  43  * These headers help to identify the data block when it is written to disk and
  44  * helps to check the integrity of the data blocks in the system.
  45  */
  46 struct AliHLTMUONDataBlockHeader
  47 {
  48         AliHLTUInt16_t fType; // The type of the data block. Must contain a value
  49                               // defined by AliHLTMUONDataBlockType.
  50         AliHLTUInt16_t fRecordWidth; // The number of bytes each record uses.
  51         AliHLTUInt32_t fNrecords; // Number of records in this data block.
  52 };
  53
  54 } // extern "C"
  55
  56
  57 /**
  58  * The sign of a particle.
  59  */
  60 enum AliHLTMUONParticleSign
  61 {
  62         kSignMinus   = -1,
  63         kSignUnknown = 0,
  64         kSignPlus    = 1
  65 };
  66
  67 /**
  68  * The chamber names of the dimuon spectrometer.
  69  */
  70 enum AliHLTMUONChamberName
  71 {
  72         kChamber1 = 0,
  73         kChamber2 = 1,
  74         kChamber3 = 2,
  75         kChamber4 = 3,
  76         kChamber5 = 4,
  77         kChamber6 = 5,
  78         kChamber7 = 6,
  79         kChamber8 = 7,
  80         kChamber9 = 8,
  81         kChamber10 = 9,
  82         kChamber11 = 10,
  83         kChamber12 = 11,
  84         kChamber13 = 12,
  85         kChamber14 = 13
  86 };
  87
  88 /**
  89  * The internal data block type codes.
  90  */
  91 enum AliHLTMUONDataBlockType
  92 {
  93         kUnknownDataBlock = 0,
  94         kTriggerRecordsDataBlock = 1000,
  95         kTrigRecsDebugDataBlock = 1001,
  96         kTriggerChannelsDataBlock = 1002,
  97         kRecHitsDataBlock = 2000,
  98         kClustersDataBlock = 2001,
  99         kChannelsDataBlock = 2002,
 100         kMansoTracksDataBlock = 3000,
 101         kMansoRoIDataBlock = 3001,
 102         kMansoTrialsDataBlock = 3002,
 103         kDecisionDataBlock = 4000,
 104         kDecisionDebugDataBlock = 4001
 105 };
 106
 107
 108 /**
 109  * Stream operator to be able to print AliHLTMUONParticleSign with human
 110  * readable names to some stream object like cout (standard output).
 111  */
 112 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONParticleSign sign)
 113 {
 114         switch (sign)
 115         {
 116         case kSignMinus:   stream << "kSignMinus";   break;
 117         case kSignUnknown: stream << "kSignUnknown"; break;
 118         case kSignPlus:    stream << "kSignPlus";    break;
 119         default:           stream << "INVALID";
 120         }
 121         return stream;
 122 }
 123
 124 /**
 125  * Stream operator to be able to print AliHLTMUONChamberName with human
 126  * readable names to some stream object like cout (standard output).
 127  */
 128 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONChamberName chamber)
 129 {
 130         switch (chamber)
 131         {
 132         case kChamber1:  stream << "kChamber1";  break;
 133         case kChamber2:  stream << "kChamber2";  break;
 134         case kChamber3:  stream << "kChamber3";  break;
 135         case kChamber4:  stream << "kChamber4";  break;
 136         case kChamber5:  stream << "kChamber5";  break;
 137         case kChamber6:  stream << "kChamber6";  break;
 138         case kChamber7:  stream << "kChamber7";  break;
 139         case kChamber8:  stream << "kChamber8";  break;
 140         case kChamber9:  stream << "kChamber9";  break;
 141         case kChamber10: stream << "kChamber10"; break;
 142         case kChamber11: stream << "kChamber11"; break;
 143         case kChamber12: stream << "kChamber12"; break;
 144         case kChamber13: stream << "kChamber13"; break;
 145         case kChamber14: stream << "kChamber14"; break;
 146         default:         stream << "INVALID";
 147         }
 148         return stream;
 149 }
 150
 151 /**
 152  * Stream operator to be able to print AliHLTMUONDataBlockType with human
 153  * readable names to some stream object like cout (standard output).
 154  */
 155 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONDataBlockType type)
 156 {
 157         switch (type)
 158         {
 159         case kUnknownDataBlock:         stream << "kUnknownDataBlock";         break;
 160         case kTriggerRecordsDataBlock:  stream << "kTriggerRecordsDataBlock";  break;
 161         case kTrigRecsDebugDataBlock:   stream << "kTrigRecsDebugDataBlock";   break;
 162         case kTriggerChannelsDataBlock: stream << "kTriggerChannelsDataBlock"; break;
 163         case kRecHitsDataBlock:         stream << "kRecHitsDataBlock";         break;
 164         case kClustersDataBlock:        stream << "kClustersDataBlock";        break;
 165         case kChannelsDataBlock:        stream << "kChannelsDataBlock";        break;
 166         case kMansoTracksDataBlock:     stream << "kMansoTracksDataBlock";     break;
 167         case kMansoRoIDataBlock:        stream << "kMansoRoIDataBlock";        break;
 168         case kMansoTrialsDataBlock:     stream << "kMansoTrialsDataBlock";     break;
 169         case kDecisionDataBlock:        stream << "kDecisionDataBlock";        break;
 170         case kDecisionDebugDataBlock:   stream << "kDecisionDebugDataBlock";   break;
 171         default:                        stream << "INVALID";
 172         }
 173         return stream;
 174 }
 175
 176 /**
 177  * Stream operator for usage with std::ostream classes which prints the common
 178  * data block header in the following format:
 179  *  {fType = xx, fRecordWidth = yy, fNrecords = zz}
 180  */
 181 inline std::ostream& operator << (
 182                 std::ostream& stream, const AliHLTMUONDataBlockHeader& header
 183         )
 184 {
 185         stream  << "{fType = " << AliHLTMUONDataBlockType(header.fType)
 186                 << ", fRecordWidth = " << header.fRecordWidth
 187                 << ", fNrecords = " << header.fNrecords << "}";
 188         return stream;
 189 }
 190
 191
 192 inline bool operator == (
 193                 const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
 194         )
 195 {
 196         return a.fType == b.fType and a.fRecordWidth == b.fRecordWidth
 197                 and a.fNrecords == b.fNrecords;
 198 }
 199
 200 inline bool operator != (
 201                 const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
 202         )
 203 {
 204         return not operator == (a, b);
 205 }
 206
 207 #endif // ALIHLTMUONDATATYPES_H