Fixing coding violations and getting rid of warnings.
[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONUtils.h
CommitLineData
26a4668d 1#ifndef ALIHLTMUONUTILS_H
2#define ALIHLTMUONUTILS_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
6253e09b 8///
9/// @file AliHLTMUONUtils.h
10/// @author Artur Szostak <artursz@iafrica.com>
11/// @date
12/// @brief Class containing various dimuon HLT utility routines and macros.
13///
26a4668d 14
c8ec7c7e 15#include "AliHLTMUONDataTypes.h"
16
17// Forward declare structures.
18extern "C" {
90a74d7a 19struct AliHLTMUONTriggerRecordStruct;
c8ec7c7e 20struct AliHLTMUONTriggerRecordsBlockStruct;
21struct AliHLTMUONTrigRecsDebugBlockStruct;
22struct AliHLTMUONTriggerChannelsBlockStruct;
23struct AliHLTMUONRecHitsBlockStruct;
24struct AliHLTMUONClustersBlockStruct;
25struct AliHLTMUONChannelsBlockStruct;
90a74d7a 26struct AliHLTMUONMansoTrackStruct;
27struct AliHLTMUONMansoTracksBlockStruct;
28struct AliHLTMUONMansoCandidatesBlockStruct;
29struct AliHLTMUONTrackDecisionStruct;
30struct AliHLTMUONSinglesDecisionBlockStruct;
31struct AliHLTMUONPairDecisionStruct;
32struct AliHLTMUONPairsDecisionBlockStruct;
c8ec7c7e 33} // extern "C"
26a4668d 34
35/**
36 * AliHLTMUONUtils contains arbitrary utility methods to be used in various
37 * parts of the dimuon HLT system.
38 * These include methods to perform basic sanity checks on the integrity of
39 * data blocks.
40 */
41class AliHLTMUONUtils
42{
43public:
b727f838 44 /**
45 * This packs the given parameters into the bits of a word appropriate
46 * for AliHLTMUONTriggerRecordStruct::fFlags.
47 * @param sign The particle sign.
48 * @param hitset Flags to indicate if the corresponding fHits[i] elements
49 * was set/filled.
50 * @return Returns the 32 bit packed word.
51 */
52 static AliHLTUInt32_t PackTriggerRecordFlags(
e6357f88 53 AliHLTMUONParticleSign sign, const bool hitset[4]
b727f838 54 );
55
56 /**
57 * This unpacks the AliHLTMUONTriggerRecordStruct::fFlags bits into
58 * its component fields.
59 * @param flags The flags from an AliHLTMUONTriggerRecordStruct structure.
60 * @param sign Sets this to the particle sign.
61 * @param hitset Sets the array elements to indicate if the corresponding
62 * fHits[i] element was set/filled.
63 */
64 static void UnpackTriggerRecordFlags(
65 AliHLTUInt32_t flags, // [in]
66 AliHLTMUONParticleSign& sign, // [out]
67 bool hitset[4] // [out]
68 );
69
70 /**
71 * This packs the given parameters into the bits of a word appropriate
72 * for AliHLTMUONMansoTrackStruct::fFlags.
73 * @param sign The particle sign.
74 * @param hitset Flags to indicate if the corresponding fHits[i] elements
75 * was set/filled.
76 * @return Returns the 32 bit packed word.
77 */
78 static AliHLTUInt32_t PackMansoTrackFlags(
e6357f88 79 AliHLTMUONParticleSign sign, const bool hitset[4]
b727f838 80 )
81 {
82 return PackTriggerRecordFlags(sign, hitset);
83 }
84
85 /**
86 * This unpacks the AliHLTMUONMansoTrackStruct::fFlags bits into
87 * its component fields.
88 * @param flags The flags from an AliHLTMUONMansoTrackStruct structure.
89 * @param sign Sets this to the particle sign.
90 * @param hitset Sets the array elements to indicate if the corresponding
91 * fHits[i] element was set/filled.
92 */
93 static void UnpackMansoTrackFlags(
94 AliHLTUInt32_t flags, // [in]
95 AliHLTMUONParticleSign& sign, // [out]
96 bool hitset[4] // [out]
97 )
98 {
99 UnpackTriggerRecordFlags(flags, sign, hitset);
100 }
90a74d7a 101
102 /**
103 * This packs the given parameters into the bits of a word appropriate
104 * for AliHLTMUONTrackDecisionStruct::fTriggerBits.
105 * @param highPt Has the track passed the high pt cut.
106 * @param lowPt Has the track passed the low pt cut.
107 * @return Returns the 32 bit packed word.
108 */
109 static AliHLTUInt32_t PackTrackDecisionBits(bool highPt, bool lowPt);
110
111 /**
112 * This unpacks the AliHLTMUONTrackDecisionStruct::fTriggerBits bits into
113 * its component fields.
114 * @param bits The trigger bits from an AliHLTMUONTrackDecisionStruct
115 * structure.
116 * @param highPt Sets this to the value of the high pt cut bit.
117 * @param lowPt Sets this to the value of the low pt cut bit.
118 */
119 static void UnpackTrackDecisionBits(
120 AliHLTUInt32_t bits, // [in]
121 bool& highPt, // [out]
122 bool& lowPt // [out]
123 );
124
125 /**
126 * This packs the given parameters into the bits of a word appropriate
127 * for AliHLTMUONPairDecisionStruct::fTriggerBits.
128 *
129 * @param highMass Has the track pair passed the high invariant mass cut.
130 * @param lowMass Has the track pair passed the low invariant mass cut.
131 * @param unlike Does the track pair have unlike signs.
132 * @param highPtCount The number of tracks that passed the high pt cut
133 * in the pair.
134 * @param lowPtCount The number of tracks that passed the low pt cut
135 * in the pair.
136 * @return Returns the 32 bit packed word.
137 *
138 * Note: Must have highPtCount + lowPtCount <= 2 and unlike == true if
139 * highMass or lowMass is true.
140 */
141 static AliHLTUInt32_t PackPairDecisionBits(
142 bool highMass, bool lowMass, bool unlike,
143 AliHLTUInt8_t highPtCount, AliHLTUInt8_t lowPtCount
144 );
145
146 /**
147 * This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into
148 * its component fields.
149 * @param bits The trigger bits from an AliHLTMUONPairDecisionStruct
150 * structure.
151 * @param highMass Sets this to the value of the high invariant mass cut bit.
152 * @param lowMass Sets this to the value of the low invariant mass cut bit.
153 * @param unlike Sets this if the pair is unlike sign.
154 * @param highPtCount Sets this to the high pt count bits.
155 * @param lowPtCount Sets this to the low pt count bits.
156 */
157 static void UnpackPairDecisionBits(
158 AliHLTUInt32_t bits, // [in]
159 bool& highMass, // [out]
160 bool& lowMass, // [out]
161 bool& unlike, // [out]
162 AliHLTUInt8_t& highPtCount, // [out]
163 AliHLTUInt8_t& lowPtCount // [out]
164 );
e6357f88 165
166 /**
167 * This packs the given parameters into the 32bit Pub/Sub specification
168 * word in the data block descriptor.
169 *
170 * @param ddl The list of DDLs forming part of the readout. ddl[0]
171 * indicates DDL number 2560, ddl[1] is for DDL 2561 and so
172 * on up to ddl[19]. ddl[20] and ddl[21] will be for the
173 * trigger DDLs 2816 and 2817 respectively.
174 * @return Returns the 32 bit packed specification word.
175 */
176 static AliHLTUInt32_t PackSpecBits(
177 const bool ddl[22]
178 );
179
180 /**
181 * This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into
182 * its component fields.
183 * @param bits The Pub/Sub specification word from a data block descriptor.
184 * @param ddl The output list of DDLs forming part of the readout. ddl[0]
185 * indicates DDL number 2560, ddl[1] is for DDL 2561 and so
186 * on up to ddl[19]. ddl[20] and ddl[21] will be for the
187 * trigger DDLs 2816 and 2817 respectively.
188 */
189 static void UnpackSpecBits(
190 AliHLTUInt32_t bits, // [in]
191 bool ddl[22] // [out]
192 );
26a4668d 193
698c9498 194 /**
195 * These codes indicate the reason why a data block failed its
196 * validity check.
197 */
198 enum WhyNotValid
199 {
200 kNoReason,
201 kHeaderContainsWrongType,
9c234d7b 202 kHeaderContainsWrongRecordWidth
698c9498 203 };
204
26a4668d 205 /**
b727f838 206 * Methods used to check if the header information corresponds to the
207 * supposed type of the data block.
698c9498 208 * If the 'reason' parameter is not NULL then these methods will fill the
209 * memory pointed to by reason with a code describing of why the header
210 * is not valid, if and only if a problem is found with the data.
26a4668d 211 */
698c9498 212 static bool HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block, WhyNotValid* reason = NULL);
c8ec7c7e 213 static bool HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block);
214 static bool HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block);
b727f838 215 static bool HeaderOk(const AliHLTMUONRecHitsBlockStruct& block);
216 static bool HeaderOk(const AliHLTMUONClustersBlockStruct& block);
217 static bool HeaderOk(const AliHLTMUONChannelsBlockStruct& block);
90a74d7a 218 static bool HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block);
219 static bool HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block);
220 static bool HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block);
221 static bool HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block);
b727f838 222
223 /**
90a74d7a 224 * Methods used to check more extensively if the integrity of various
225 * types of data blocks are Ok and returns true in that case.
b727f838 226 * These can be slow and should generally only be used for debugging.
227 */
90a74d7a 228 static bool IntegrityOk(const AliHLTMUONTriggerRecordStruct& tr);
b727f838 229 static bool IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& block);
c8ec7c7e 230 static bool IntegrityOk(const AliHLTMUONTrigRecsDebugBlockStruct& block);
231 static bool IntegrityOk(const AliHLTMUONTriggerChannelsBlockStruct& block);
b727f838 232 static bool IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block);
233 static bool IntegrityOk(const AliHLTMUONClustersBlockStruct& block);
234 static bool IntegrityOk(const AliHLTMUONChannelsBlockStruct& block);
90a74d7a 235 static bool IntegrityOk(const AliHLTMUONMansoTrackStruct& track);
236 static bool IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block);
237 static bool IntegrityOk(const AliHLTMUONMansoCandidatesBlockStruct& block);
238 static bool IntegrityOk(const AliHLTMUONTrackDecisionStruct& decision);
239 static bool IntegrityOk(const AliHLTMUONSinglesDecisionBlockStruct& block);
240 static bool IntegrityOk(const AliHLTMUONPairDecisionStruct& decision);
241 static bool IntegrityOk(const AliHLTMUONPairsDecisionBlockStruct& block);
26a4668d 242
243private:
244 // Should never have to create or destroy this object.
245 AliHLTMUONUtils();
246 ~AliHLTMUONUtils();
247};
248
b727f838 249//_____________________________________________________________________________
250
251// Since c++ is missing a finally "keyword" we define one. Its usage is identical
252// to a try..finally statement in Java etc.. however, since it is officialy a macro
253// one must use the ( ) brackets instead of { }
254// If the compiler supports __finally use it otherwise make our own.
255#if defined(__BORLANDC__)
256# define finally(str) __finally{str}
257#else
258# define finally(code) \
259 catch(...) \
260 { \
261 code \
262 throw; \
263 }; \
264 code
265#endif // __BORLANDC__
266
267// If we do not already have them, then define logical operators that are easier
268// to read. 'and' = &&, 'or' = ||, 'not' = !
269#if ! defined(__GNUC__) && ! defined(__CINT__)
b12fe461 270// TODO: Should use iso646.h
b727f838 271# define and &&
272# define or ||
273# define not !
274#endif // __GNUC__ | __CINT__
275
276
277// Here we define the DebugTrace(message) macro for easy embedding of debug
278// information into the dimuon HLT code. Its usage is meant to be for generating
279// traces of the program which are only useful during full scale debugging.
280// Log messages should use the standard HLT logging mechanisms.
281// The output is only generated in programs compiled with the DEBUG directive
282// defined. Here is a usage example:
283//
284// // statements...
285// DebugTrace("some debug information.");
286// // statements...
287//
288// One can also use C++ ostream operators and manipulators like so:
289//
290// // statements...
291// int x, y;
b12fe461 292// DebugTrace("x = " << x << " and y = 0x" << std::hex << y );
b727f838 293// // statements...
294//
295#ifdef DEBUG
b4dfa1c8 296# include <iostream>
b727f838 297# define DebugTrace(message) {std::cout << message << std::endl;}
298#else // DEBUG
299# define DebugTrace(message)
300#endif // DEBUG
301
302
26a4668d 303#endif // ALIHLTMUONUTILS_H