]>
Commit | Line | Data |
---|---|---|
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 | ||
1d8ae082 | 6 | // $Id$ |
26a4668d | 7 | |
6253e09b | 8 | /// |
9 | /// @file AliHLTMUONUtils.h | |
10 | /// @author Artur Szostak <artursz@iafrica.com> | |
dba14d7d | 11 | /// @date 17 May 2007 |
6253e09b | 12 | /// @brief Class containing various dimuon HLT utility routines and macros. |
13 | /// | |
26a4668d | 14 | |
33b1e2f2 | 15 | #include "TObject.h" |
c8ec7c7e | 16 | #include "AliHLTMUONDataTypes.h" |
878cb83d | 17 | #include <ostream> |
c8ec7c7e | 18 | |
19 | // Forward declare structures. | |
20 | extern "C" { | |
90a74d7a | 21 | struct AliHLTMUONTriggerRecordStruct; |
c8ec7c7e | 22 | struct AliHLTMUONTriggerRecordsBlockStruct; |
dba14d7d | 23 | struct AliHLTMUONTrigRecInfoStruct; |
c8ec7c7e | 24 | struct AliHLTMUONTrigRecsDebugBlockStruct; |
a090ff22 | 25 | struct AliHLTMUONRecHitStruct; |
c8ec7c7e | 26 | struct AliHLTMUONRecHitsBlockStruct; |
dba14d7d | 27 | struct AliHLTMUONClusterStruct; |
c8ec7c7e | 28 | struct AliHLTMUONClustersBlockStruct; |
dba14d7d | 29 | struct AliHLTMUONChannelStruct; |
c8ec7c7e | 30 | struct AliHLTMUONChannelsBlockStruct; |
90a74d7a | 31 | struct AliHLTMUONMansoTrackStruct; |
32 | struct AliHLTMUONMansoTracksBlockStruct; | |
dba14d7d | 33 | struct AliHLTMUONMansoCandidateStruct; |
90a74d7a | 34 | struct AliHLTMUONMansoCandidatesBlockStruct; |
35 | struct AliHLTMUONTrackDecisionStruct; | |
36 | struct AliHLTMUONSinglesDecisionBlockStruct; | |
37 | struct AliHLTMUONPairDecisionStruct; | |
38 | struct AliHLTMUONPairsDecisionBlockStruct; | |
c8ec7c7e | 39 | } // extern "C" |
26a4668d | 40 | |
41 | /** | |
42 | * AliHLTMUONUtils contains arbitrary utility methods to be used in various | |
43 | * parts of the dimuon HLT system. | |
44 | * These include methods to perform basic sanity checks on the integrity of | |
45 | * data blocks. | |
46 | */ | |
47 | class AliHLTMUONUtils | |
48 | { | |
49 | public: | |
b727f838 | 50 | /** |
51 | * This packs the given parameters into the bits of a word appropriate | |
52 | * for AliHLTMUONTriggerRecordStruct::fFlags. | |
53 | * @param sign The particle sign. | |
54 | * @param hitset Flags to indicate if the corresponding fHits[i] elements | |
55 | * was set/filled. | |
56 | * @return Returns the 32 bit packed word. | |
57 | */ | |
58 | static AliHLTUInt32_t PackTriggerRecordFlags( | |
e6357f88 | 59 | AliHLTMUONParticleSign sign, const bool hitset[4] |
b727f838 | 60 | ); |
61 | ||
62 | /** | |
63 | * This unpacks the AliHLTMUONTriggerRecordStruct::fFlags bits into | |
64 | * its component fields. | |
65 | * @param flags The flags from an AliHLTMUONTriggerRecordStruct structure. | |
66 | * @param sign Sets this to the particle sign. | |
67 | * @param hitset Sets the array elements to indicate if the corresponding | |
68 | * fHits[i] element was set/filled. | |
69 | */ | |
70 | static void UnpackTriggerRecordFlags( | |
71 | AliHLTUInt32_t flags, // [in] | |
72 | AliHLTMUONParticleSign& sign, // [out] | |
73 | bool hitset[4] // [out] | |
74 | ); | |
a090ff22 | 75 | |
76 | /** | |
77 | * This packs the given parameters into the bits of a word appropriate | |
78 | * for AliHLTMUONRecHitStruct::fFlags. | |
79 | * @param chamber The chamber number in the range [0..13]. | |
80 | * @param detElemId Detector element ID number. | |
81 | * @return Returns the 32 bit packed word. | |
82 | */ | |
83 | static AliHLTUInt32_t PackRecHitFlags( | |
84 | AliHLTUInt8_t chamber, AliHLTUInt16_t detElemId | |
85 | ); | |
86 | ||
87 | /** | |
88 | * This unpacks the AliHLTMUONRecHitStruct::fFlags bits into | |
89 | * its component fields. | |
90 | * [in] @param flags The flags from an AliHLTMUONRecHitStruct structure. | |
91 | * [out] @param chamber Sets the chamber number in the range [0..13]. | |
92 | * [out] @param detElemId Sets the detector element ID number. | |
93 | */ | |
94 | static void UnpackRecHitFlags( | |
95 | AliHLTUInt32_t flags, // [in] | |
96 | AliHLTUInt8_t& chamber, // [out] | |
97 | AliHLTUInt16_t& detElemId // [out] | |
98 | ); | |
b727f838 | 99 | |
462e3880 | 100 | /** |
101 | * Returns the detector element ID from the flags bits. | |
102 | * [in] @param flags The flags from an AliHLTMUONRecHitStruct structure. | |
103 | */ | |
104 | static AliHLTUInt16_t GetDetElemIdFromFlags(AliHLTUInt32_t flags) | |
105 | { | |
106 | return flags & 0xFFF; | |
107 | } | |
108 | ||
b727f838 | 109 | /** |
110 | * This packs the given parameters into the bits of a word appropriate | |
111 | * for AliHLTMUONMansoTrackStruct::fFlags. | |
112 | * @param sign The particle sign. | |
113 | * @param hitset Flags to indicate if the corresponding fHits[i] elements | |
114 | * was set/filled. | |
115 | * @return Returns the 32 bit packed word. | |
116 | */ | |
117 | static AliHLTUInt32_t PackMansoTrackFlags( | |
e6357f88 | 118 | AliHLTMUONParticleSign sign, const bool hitset[4] |
b727f838 | 119 | ) |
120 | { | |
121 | return PackTriggerRecordFlags(sign, hitset); | |
122 | } | |
123 | ||
124 | /** | |
125 | * This unpacks the AliHLTMUONMansoTrackStruct::fFlags bits into | |
126 | * its component fields. | |
127 | * @param flags The flags from an AliHLTMUONMansoTrackStruct structure. | |
128 | * @param sign Sets this to the particle sign. | |
129 | * @param hitset Sets the array elements to indicate if the corresponding | |
130 | * fHits[i] element was set/filled. | |
131 | */ | |
132 | static void UnpackMansoTrackFlags( | |
133 | AliHLTUInt32_t flags, // [in] | |
134 | AliHLTMUONParticleSign& sign, // [out] | |
135 | bool hitset[4] // [out] | |
136 | ) | |
137 | { | |
138 | UnpackTriggerRecordFlags(flags, sign, hitset); | |
139 | } | |
90a74d7a | 140 | |
141 | /** | |
142 | * This packs the given parameters into the bits of a word appropriate | |
143 | * for AliHLTMUONTrackDecisionStruct::fTriggerBits. | |
144 | * @param highPt Has the track passed the high pt cut. | |
145 | * @param lowPt Has the track passed the low pt cut. | |
146 | * @return Returns the 32 bit packed word. | |
147 | */ | |
148 | static AliHLTUInt32_t PackTrackDecisionBits(bool highPt, bool lowPt); | |
149 | ||
150 | /** | |
151 | * This unpacks the AliHLTMUONTrackDecisionStruct::fTriggerBits bits into | |
152 | * its component fields. | |
153 | * @param bits The trigger bits from an AliHLTMUONTrackDecisionStruct | |
154 | * structure. | |
155 | * @param highPt Sets this to the value of the high pt cut bit. | |
156 | * @param lowPt Sets this to the value of the low pt cut bit. | |
157 | */ | |
158 | static void UnpackTrackDecisionBits( | |
159 | AliHLTUInt32_t bits, // [in] | |
160 | bool& highPt, // [out] | |
161 | bool& lowPt // [out] | |
162 | ); | |
163 | ||
164 | /** | |
165 | * This packs the given parameters into the bits of a word appropriate | |
166 | * for AliHLTMUONPairDecisionStruct::fTriggerBits. | |
167 | * | |
168 | * @param highMass Has the track pair passed the high invariant mass cut. | |
169 | * @param lowMass Has the track pair passed the low invariant mass cut. | |
170 | * @param unlike Does the track pair have unlike signs. | |
171 | * @param highPtCount The number of tracks that passed the high pt cut | |
172 | * in the pair. | |
173 | * @param lowPtCount The number of tracks that passed the low pt cut | |
174 | * in the pair. | |
175 | * @return Returns the 32 bit packed word. | |
176 | * | |
177 | * Note: Must have highPtCount + lowPtCount <= 2 and unlike == true if | |
178 | * highMass or lowMass is true. | |
179 | */ | |
180 | static AliHLTUInt32_t PackPairDecisionBits( | |
181 | bool highMass, bool lowMass, bool unlike, | |
182 | AliHLTUInt8_t highPtCount, AliHLTUInt8_t lowPtCount | |
183 | ); | |
184 | ||
185 | /** | |
186 | * This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into | |
187 | * its component fields. | |
188 | * @param bits The trigger bits from an AliHLTMUONPairDecisionStruct | |
189 | * structure. | |
190 | * @param highMass Sets this to the value of the high invariant mass cut bit. | |
191 | * @param lowMass Sets this to the value of the low invariant mass cut bit. | |
192 | * @param unlike Sets this if the pair is unlike sign. | |
193 | * @param highPtCount Sets this to the high pt count bits. | |
194 | * @param lowPtCount Sets this to the low pt count bits. | |
195 | */ | |
196 | static void UnpackPairDecisionBits( | |
197 | AliHLTUInt32_t bits, // [in] | |
198 | bool& highMass, // [out] | |
199 | bool& lowMass, // [out] | |
200 | bool& unlike, // [out] | |
201 | AliHLTUInt8_t& highPtCount, // [out] | |
202 | AliHLTUInt8_t& lowPtCount // [out] | |
203 | ); | |
e6357f88 | 204 | |
205 | /** | |
206 | * This packs the given parameters into the 32bit Pub/Sub specification | |
207 | * word in the data block descriptor. | |
208 | * | |
209 | * @param ddl The list of DDLs forming part of the readout. ddl[0] | |
210 | * indicates DDL number 2560, ddl[1] is for DDL 2561 and so | |
211 | * on up to ddl[19]. ddl[20] and ddl[21] will be for the | |
212 | * trigger DDLs 2816 and 2817 respectively. | |
213 | * @return Returns the 32 bit packed specification word. | |
214 | */ | |
215 | static AliHLTUInt32_t PackSpecBits( | |
216 | const bool ddl[22] | |
217 | ); | |
218 | ||
219 | /** | |
220 | * This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into | |
221 | * its component fields. | |
222 | * @param bits The Pub/Sub specification word from a data block descriptor. | |
223 | * @param ddl The output list of DDLs forming part of the readout. ddl[0] | |
224 | * indicates DDL number 2560, ddl[1] is for DDL 2561 and so | |
225 | * on up to ddl[19]. ddl[20] and ddl[21] will be for the | |
226 | * trigger DDLs 2816 and 2817 respectively. | |
227 | */ | |
228 | static void UnpackSpecBits( | |
229 | AliHLTUInt32_t bits, // [in] | |
230 | bool ddl[22] // [out] | |
231 | ); | |
26a4668d | 232 | |
86b774d9 | 233 | /** |
234 | * This method converts the DDL number for the muon spectrometer in the | |
235 | * range [0..21] to the equipment ID number. | |
236 | * @param ddlNo The DDL number in the range [0..21]. | |
237 | * @return Returns the equipment ID number or -1 if ddlNo was invalid. | |
238 | */ | |
239 | static AliHLTInt32_t DDLNumberToEquipId(AliHLTInt32_t ddlNo); | |
240 | ||
241 | /** | |
242 | * This method converts the equipment ID number for a muon spectrometer | |
243 | * DDL to the DDL number in the range [0..21]. | |
244 | * @param id The equipment ID of the DDL. | |
245 | * @return Returns the DDL number in the range [0..21] or -1 if the | |
246 | * equipment ID was invalid. | |
247 | */ | |
248 | static AliHLTInt32_t EquipIdToDDLNumber(AliHLTInt32_t id); | |
249 | ||
250 | /** | |
251 | * This method converts a 32 bit data block specification for a MUON-HLT | |
252 | * data block into its corresponding DDL equipment ID number. | |
253 | * It is assumed that the specification is for a data block comming from | |
254 | * a single DDL source. If more than one DDL contributed to the data block | |
255 | * then -1 is returned. | |
256 | * @param spec The 32 bit specification for a data block. | |
257 | * @return Returns the equipment ID corresponding to the specification | |
258 | * or -1 if the specification was invalid. | |
259 | */ | |
260 | static AliHLTInt32_t SpecToEquipId(AliHLTUInt32_t spec); | |
261 | ||
262 | /** | |
263 | * This method converts a equipment ID number for a DDL into its corresponding | |
264 | * 32 bit data block specification for the MUON-HLT. | |
265 | * @param id The equipment ID number of the DDL. | |
266 | * @return Returns the 32 bit data block specification or 0x0 if the | |
267 | * equipment ID was invalid. | |
268 | */ | |
269 | static AliHLTUInt32_t EquipIdToSpec(AliHLTInt32_t id); | |
270 | ||
271 | /** | |
272 | * This method converts a 32 bit data block specification for a MUON-HLT | |
273 | * data block into its corresponding DDL number in the range [0..21]. | |
274 | * It is assumed that the specification is for a data block comming from | |
275 | * a single DDL source. If more than one DDL contributed to the data block | |
276 | * then -1 is returned. | |
277 | * @param spec The 32 bit specification for a data block. | |
278 | * @return Returns the corresponding DDL number for the specification | |
279 | * or -1 if the specification was invalid. | |
280 | */ | |
281 | static AliHLTInt32_t SpecToDDLNumber(AliHLTUInt32_t spec); | |
282 | ||
283 | /** | |
284 | * This method converts a DDL number in the range [0..21] into its | |
285 | * corresponding 32 bit data block specification for the MUON-HLT. | |
286 | * @param ddlNo The equipment ID number of the DDL. | |
287 | * @return Returns the 32 bit data block specification or 0x0 if the | |
288 | * DDL number was invalid (out of range). | |
289 | */ | |
290 | static AliHLTUInt32_t DDLNumberToSpec(AliHLTInt32_t ddlNo); | |
291 | ||
668eee9f | 292 | /** |
293 | * Returns true if the given specification was for a single trigger DDL. | |
294 | */ | |
295 | static bool IsTriggerDDL(AliHLTUInt32_t spec) | |
296 | { | |
297 | AliHLTInt32_t ddl = SpecToDDLNumber(spec); | |
298 | return (20 <= ddl and ddl <= 21); | |
299 | } | |
300 | ||
301 | /** | |
302 | * Returns true if the given specification was for a single tracker DDL. | |
303 | */ | |
304 | static bool IsTrackerDDL(AliHLTUInt32_t spec) | |
305 | { | |
306 | AliHLTInt32_t ddl = SpecToDDLNumber(spec); | |
307 | return (0 <= ddl and ddl <= 19); | |
308 | } | |
dba14d7d | 309 | |
310 | /** | |
311 | * Returns true if the given specification is in principle valid. | |
312 | * It checks if the bits that should be zero are indeed zero. | |
313 | */ | |
314 | static bool IsSpecValid(AliHLTUInt32_t spec) | |
315 | { | |
8fc88a5c | 316 | AliHLTUInt32_t mask = ~AliHLTUInt32_t((1 << 22) - 1); // First 22 bits indicate DDL number. |
dba14d7d | 317 | return (spec & mask) == 0x0; |
318 | } | |
319 | ||
320 | /** | |
321 | * Returns true if the data specification indicates the data block contains | |
322 | * information generated from a trigger DDL or data fragments thereof. | |
323 | */ | |
324 | static bool ContainsDataFromTrigger(AliHLTUInt32_t spec) | |
325 | { | |
8fc88a5c | 326 | AliHLTUInt32_t mask = AliHLTUInt32_t((1 << 22) - 1) & ~AliHLTUInt32_t((1 << 20) - 1); |
dba14d7d | 327 | return (spec & mask) != 0x0; |
328 | } | |
329 | ||
330 | /** | |
331 | * Returns true if the data specification indicates the data block contains | |
332 | * information generated from a tracker DDL or data fragments thereof. | |
333 | */ | |
334 | static bool ContainsDataFromTracker(AliHLTUInt32_t spec) | |
335 | { | |
8fc88a5c | 336 | AliHLTUInt32_t mask = AliHLTUInt32_t((1 << 20) - 1); |
dba14d7d | 337 | return (spec & mask) != 0x0; |
338 | } | |
f68b4e0e | 339 | |
340 | /** | |
887a669c | 341 | * Parses the string containing the type name of a dHLT data block and |
342 | * returns the corresponding AliHLTMUONDataBlockType value. | |
343 | * \param type The string containing the type name. | |
344 | * \returns The data block type or kUnknownDataBlock if the type name | |
345 | * is invalid. | |
346 | */ | |
f68b4e0e | 347 | static AliHLTMUONDataBlockType ParseCommandLineTypeString(const char* type); |
dba14d7d | 348 | |
887a669c | 349 | /** |
350 | * Converts a type ID to a type string to be used for the dHLT FilePublisher | |
351 | * component configuration parameters for example. | |
352 | */ | |
353 | static const char* DataBlockTypeToString(AliHLTMUONDataBlockType type); | |
354 | ||
698c9498 | 355 | /** |
356 | * These codes indicate the reason why a data block failed its | |
357 | * validity check. | |
358 | */ | |
359 | enum WhyNotValid | |
360 | { | |
878cb83d | 361 | kNoReason, ///< There was no reason for failure. |
362 | kHeaderContainsWrongType, ///< The common header contains an incorrect type ID. | |
363 | kHeaderContainsWrongRecordWidth, ///< The common header contains an incorrect data record width. | |
dba14d7d | 364 | kInvalidIdValue, ///< The structure identifier does not have a valid value. |
365 | kInvalidTriggerIdValue, ///< The trigger structure identifier does not have a valid value. | |
366 | kInvalidTrackIdValue, ///< The track structure identifier does not have a valid value. | |
878cb83d | 367 | kReservedBitsNotZero, ///< Reserved bits have not been set to zero. |
368 | kParticleSignBitsNotValid, ///< The particle sign bits are not a valid value. | |
369 | kHitNotMarkedAsNil, ///< A hit was marked as not found, but the corresponding hit structure was not set to nil. | |
dba14d7d | 370 | kInvalidDetElementNumber, ///< An invalid detector element ID was found. |
a090ff22 | 371 | kInvalidChamberNumber, ///< An invalid chamber number was found. |
dba14d7d | 372 | kHitIsNil, ///< The hit cannot be set to a nil value. |
66622a82 | 373 | kInvalidChannelCountB, ///< The number of channels in the bending plane indicated is zero or outside the valid range. |
374 | kInvalidChannelCountNB, ///< The number of channels in the non-bending plane indicated is zero or outside the valid range. | |
375 | kInvalidChargeB, ///< The charge for the bending plane does not have a valid value. | |
376 | kInvalidChargeNB, ///< The charge for the non-bending plane does not have a valid value. | |
dba14d7d | 377 | kInvalidBusPatchId, ///< The bus patch ID is outside the valid range. |
378 | kInvalidManuId, ///< The MANU ID is outside the valid range. | |
379 | kInvalidChannelAddress, ///< The MANU channel address is outside the valid range. | |
380 | kInvalidSignal, ///< The ADC signal value is outside the valid range. | |
381 | kDataWordDifferent, ///< The raw data word is different from the unpacked values. | |
382 | kChiSquareInvalid, ///< The chi squared value must be a positive value or -1 indicating a fitting error. | |
383 | kMomentumVectorNotZero, ///< The chi sqaured value is set to -1, but momentum vector not zero. | |
384 | kRoiRadiusInvalid, ///< The region of interest radius is invalid. | |
385 | kHitNotWithinRoi, ///< A tracks hit is not within the corresponding region of interest. | |
878cb83d | 386 | kPtValueNotValid, ///< The pT value is not positive nor -1 indicating an invalid value. |
878cb83d | 387 | kPairTrackIdsAreIdentical, ///< The track IDs of the track pair are identical. |
388 | kMassValueNotValid, ///< The invariant mass value is not positive nor -1 indicating an invalid value. | |
389 | kLowPtCountInvalid, ///< The low pT trigger count is greater than 2, which is invalid. | |
dba14d7d | 390 | kHighPtCountInvalid, ///< The high pT trigger count is greater than 2, which is invalid. |
391 | kFoundDuplicateIDs, ///< Found duplicate identifiers, but they should all be unique. | |
392 | kFoundDuplicateHits, ///< Found duplicate hits. | |
393 | kFoundDuplicateTriggers ///< Found duplicate trigger decisions. | |
698c9498 | 394 | }; |
878cb83d | 395 | |
396 | /** | |
397 | * This method converts the WhyNotValid enumeration to a string representation. | |
398 | */ | |
399 | static const char* FailureReasonToString(WhyNotValid reason); | |
400 | ||
401 | /** | |
402 | * This method returns a string containing a user readable message explaining | |
403 | * the reason for failure described by the WhyNotValid enumeration. | |
404 | */ | |
405 | static const char* FailureReasonToMessage(WhyNotValid reason); | |
698c9498 | 406 | |
dba14d7d | 407 | /** |
408 | * Method used to check if the header information corresponds to the | |
409 | * supposed type of the trigger records data block. | |
410 | * This method will return either kHeaderContainsWrongType or | |
411 | * kHeaderContainsWrongRecordWidth as the reason code. | |
412 | * [in] \param block The data block to check. | |
413 | * [out] \param reason If this is not NULL, then the variable pointed to | |
414 | * by this pointer will be filled with the reason code describing why | |
415 | * the header is not valid, if and only if a problem is found with | |
416 | * the data. | |
417 | * \returns true if there is no problem with the header and false otherwise. | |
418 | */ | |
419 | static bool HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block, WhyNotValid* reason = NULL) | |
420 | { | |
421 | AliHLTUInt32_t count = 1; | |
422 | return HeaderOk(block, reason, count); | |
423 | } | |
424 | ||
425 | /** | |
426 | * Method used to check if the header information corresponds to the | |
427 | * supposed type of the trigger debug information data block. | |
428 | * This method will return either kHeaderContainsWrongType or | |
429 | * kHeaderContainsWrongRecordWidth as the reason code. | |
430 | * [in] \param block The data block to check. | |
431 | * [out] \param reason If this is not NULL, then the variable pointed to | |
432 | * by this pointer will be filled with the reason code describing why | |
433 | * the header is not valid, if and only if a problem is found with | |
434 | * the data. | |
435 | * \returns true if there is no problem with the header and false otherwise. | |
436 | */ | |
437 | static bool HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block, WhyNotValid* reason = NULL) | |
438 | { | |
439 | AliHLTUInt32_t count = 1; | |
440 | return HeaderOk(block, reason, count); | |
441 | } | |
442 | ||
dba14d7d | 443 | /** |
444 | * Method used to check if the header information corresponds to the | |
445 | * supposed type of the reconstructed hits data block. | |
446 | * This method will return either kHeaderContainsWrongType or | |
447 | * kHeaderContainsWrongRecordWidth as the reason code. | |
448 | * [in] \param block The data block to check. | |
449 | * [out] \param reason If this is not NULL, then the variable pointed to | |
450 | * by this pointer will be filled with the reason code describing why | |
451 | * the header is not valid, if and only if a problem is found with | |
452 | * the data. | |
453 | * \returns true if there is no problem with the header and false otherwise. | |
454 | */ | |
455 | static bool HeaderOk(const AliHLTMUONRecHitsBlockStruct& block, WhyNotValid* reason = NULL) | |
456 | { | |
457 | AliHLTUInt32_t count = 1; | |
458 | return HeaderOk(block, reason, count); | |
459 | } | |
460 | ||
461 | /** | |
462 | * Method used to check if the header information corresponds to the | |
463 | * supposed type of the clusters data block. | |
464 | * This method will return either kHeaderContainsWrongType or | |
465 | * kHeaderContainsWrongRecordWidth as the reason code. | |
466 | * [in] \param block The data block to check. | |
467 | * [out] \param reason If this is not NULL, then the variable pointed to | |
468 | * by this pointer will be filled with the reason code describing why | |
469 | * the header is not valid, if and only if a problem is found with | |
470 | * the data. | |
471 | * \returns true if there is no problem with the header and false otherwise. | |
472 | */ | |
473 | static bool HeaderOk(const AliHLTMUONClustersBlockStruct& block, WhyNotValid* reason = NULL) | |
474 | { | |
475 | AliHLTUInt32_t count = 1; | |
476 | return HeaderOk(block, reason, count); | |
477 | } | |
478 | ||
479 | /** | |
480 | * Method used to check if the header information corresponds to the | |
481 | * supposed type of the channels data block. | |
482 | * This method will return either kHeaderContainsWrongType or | |
483 | * kHeaderContainsWrongRecordWidth as the reason code. | |
484 | * [in] \param block The data block to check. | |
485 | * [out] \param reason If this is not NULL, then the variable pointed to | |
486 | * by this pointer will be filled with the reason code describing why | |
487 | * the header is not valid, if and only if a problem is found with | |
488 | * the data. | |
489 | * \returns true if there is no problem with the header and false otherwise. | |
490 | */ | |
491 | static bool HeaderOk(const AliHLTMUONChannelsBlockStruct& block, WhyNotValid* reason = NULL) | |
492 | { | |
493 | AliHLTUInt32_t count = 1; | |
494 | return HeaderOk(block, reason, count); | |
495 | } | |
496 | ||
497 | /** | |
498 | * Method used to check if the header information corresponds to the | |
499 | * supposed type of the Manso tracks data block. | |
500 | * This method will return either kHeaderContainsWrongType or | |
501 | * kHeaderContainsWrongRecordWidth as the reason code. | |
502 | * [in] \param block The data block to check. | |
503 | * [out] \param reason If this is not NULL, then the variable pointed to | |
504 | * by this pointer will be filled with the reason code describing why | |
505 | * the header is not valid, if and only if a problem is found with | |
506 | * the data. | |
507 | * \returns true if there is no problem with the header and false otherwise. | |
508 | */ | |
509 | static bool HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block, WhyNotValid* reason = NULL) | |
510 | { | |
511 | AliHLTUInt32_t count = 1; | |
512 | return HeaderOk(block, reason, count); | |
513 | } | |
514 | ||
515 | /** | |
516 | * Method used to check if the header information corresponds to the | |
517 | * supposed type of the Manso candidates data block. | |
518 | * This method will return either kHeaderContainsWrongType or | |
519 | * kHeaderContainsWrongRecordWidth as the reason code. | |
520 | * [in] \param block The data block to check. | |
521 | * [out] \param reason If this is not NULL, then the variable pointed to | |
522 | * by this pointer will be filled with the reason code describing why | |
523 | * the header is not valid, if and only if a problem is found with | |
524 | * the data. | |
525 | * \returns true if there is no problem with the header and false otherwise. | |
526 | */ | |
527 | static bool HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block, WhyNotValid* reason = NULL) | |
528 | { | |
529 | AliHLTUInt32_t count = 1; | |
530 | return HeaderOk(block, reason, count); | |
531 | } | |
532 | ||
533 | /** | |
534 | * Method used to check if the header information corresponds to the | |
535 | * supposed type of the single tracks dHLT trigger decision data block. | |
536 | * This method will return either kHeaderContainsWrongType or | |
537 | * kHeaderContainsWrongRecordWidth as the reason code. | |
538 | * [in] \param block The data block to check. | |
539 | * [out] \param reason If this is not NULL, then the variable pointed to | |
540 | * by this pointer will be filled with the reason code describing why | |
541 | * the header is not valid, if and only if a problem is found with | |
542 | * the data. | |
543 | * \returns true if there is no problem with the header and false otherwise. | |
544 | */ | |
545 | static bool HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block, WhyNotValid* reason = NULL) | |
546 | { | |
547 | AliHLTUInt32_t count = 1; | |
548 | return HeaderOk(block, reason, count); | |
549 | } | |
550 | ||
551 | /** | |
552 | * Method used to check if the header information corresponds to the | |
553 | * supposed type of the track pairs dHLT trigger decision data block. | |
554 | * This method will return either kHeaderContainsWrongType or | |
555 | * kHeaderContainsWrongRecordWidth as the reason code. | |
556 | * [in] \param block The data block to check. | |
557 | * [out] \param reason If this is not NULL, then the variable pointed to | |
558 | * by this pointer will be filled with the reason code describing why | |
559 | * the header is not valid, if and only if a problem is found with | |
560 | * the data. | |
561 | * \returns true if there is no problem with the header and false otherwise. | |
562 | */ | |
563 | static bool HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block, WhyNotValid* reason = NULL) | |
564 | { | |
565 | AliHLTUInt32_t count = 1; | |
566 | return HeaderOk(block, reason, count); | |
567 | } | |
568 | ||
26a4668d | 569 | /** |
b727f838 | 570 | * Methods used to check if the header information corresponds to the |
571 | * supposed type of the data block. | |
dba14d7d | 572 | * If the 'reason' parameter should point to an array which will store |
573 | * the reason codes indicating the problems with the data block. | |
574 | * The 'reasonCount' parameter should initialy contain the number of | |
575 | * elements that can be stored in reason. When the method exits it will | |
576 | * store the number of elements in the 'reason' array actually filled. | |
577 | */ | |
578 | static bool HeaderOk( | |
579 | const AliHLTMUONTriggerRecordsBlockStruct& block, | |
580 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
581 | ); | |
582 | ||
583 | static bool HeaderOk( | |
584 | const AliHLTMUONTrigRecsDebugBlockStruct& block, | |
585 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
586 | ); | |
587 | ||
588 | static bool HeaderOk( | |
589 | const AliHLTMUONRecHitsBlockStruct& block, | |
590 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
591 | ); | |
592 | ||
593 | static bool HeaderOk( | |
594 | const AliHLTMUONClustersBlockStruct& block, | |
595 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
596 | ); | |
597 | ||
598 | static bool HeaderOk( | |
599 | const AliHLTMUONChannelsBlockStruct& block, | |
600 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
601 | ); | |
602 | ||
603 | static bool HeaderOk( | |
604 | const AliHLTMUONMansoTracksBlockStruct& block, | |
605 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
606 | ); | |
607 | ||
608 | static bool HeaderOk( | |
609 | const AliHLTMUONMansoCandidatesBlockStruct& block, | |
610 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
611 | ); | |
612 | ||
613 | static bool HeaderOk( | |
614 | const AliHLTMUONSinglesDecisionBlockStruct& block, | |
615 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
616 | ); | |
617 | ||
618 | static bool HeaderOk( | |
619 | const AliHLTMUONPairsDecisionBlockStruct& block, | |
620 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
621 | ); | |
622 | ||
623 | /** | |
624 | * This method is used to check more extensively if the integrity of the | |
625 | * trigger record structure is OK and returns true in that case. | |
626 | * [in] \param tr The trigger record structure to check. | |
627 | * [out] \param reason If this is not NULL, then it will be filled with | |
628 | * the reason code describing why the structure is not valid, if and | |
629 | * only if a problem is found with the data. | |
630 | * \returns true if there is no problem with the structure and false otherwise. | |
631 | */ | |
632 | static bool IntegrityOk( | |
633 | const AliHLTMUONTriggerRecordStruct& tr, | |
634 | WhyNotValid* reason = NULL | |
635 | ) | |
636 | { | |
637 | AliHLTUInt32_t count = 1; | |
638 | return IntegrityOk(tr, reason, count); | |
639 | } | |
640 | ||
641 | /** | |
642 | * This method is used to check more extensively if the integrity of the | |
643 | * dHLT raw internal data block is OK and returns true in that case. | |
644 | * [in] \param block The trigger record data block to check. | |
645 | * [out] \param reason If this is not NULL, then it will be filled with | |
646 | * the reason code describing why the data block is not valid, if and | |
647 | * only if a problem is found with the data. | |
648 | * [out] \param recordNum If this is not NULL, then it will be filled with | |
649 | * the number of the trigger record that had a problem. This value will | |
650 | * only contain a valid value if the method RecordNumberWasSet(*reason) | |
651 | * returns true. Thus, 'reason' must be set. | |
652 | * \returns true if there is no problem with the data and false otherwise. | |
653 | */ | |
654 | static bool IntegrityOk( | |
655 | const AliHLTMUONTriggerRecordsBlockStruct& block, | |
656 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL | |
657 | ) | |
658 | { | |
659 | AliHLTUInt32_t count = 1; | |
660 | return IntegrityOk(block, reason, recordNum, count); | |
661 | } | |
662 | ||
663 | /** | |
664 | * This method is used to check more extensively if the integrity of the | |
665 | * trigger record debug information structure is OK and returns true in that case. | |
666 | * [in] \param trigInfo The trigger record debug information structure to check. | |
667 | * [out] \param reason If this is not NULL, then it will be filled with | |
668 | * the reason code describing why the structure is not valid, if and | |
669 | * only if a problem is found with the data. | |
670 | * \returns true if there is no problem with the structure and false otherwise. | |
671 | */ | |
672 | static bool IntegrityOk( | |
673 | const AliHLTMUONTrigRecInfoStruct& trigInfo, | |
674 | WhyNotValid* reason = NULL | |
675 | ) | |
676 | { | |
677 | AliHLTUInt32_t count = 1; | |
678 | return IntegrityOk(trigInfo, reason, count); | |
679 | } | |
680 | ||
681 | /** | |
682 | * This method is used to check more extensively if the integrity of the | |
683 | * dHLT raw internal data block is OK and returns true in that case. | |
684 | * [in] \param block The trigger record debugging information data block to check. | |
685 | * [out] \param reason If this is not NULL, then it will be filled with | |
686 | * the reason code describing why the data block is not valid, if and | |
687 | * only if a problem is found with the data. | |
688 | * [out] \param recordNum If this is not NULL, then it will be filled with | |
689 | * the number of the trigger record debug information structure that had | |
690 | * a problem. This value will only contain a valid value if the method | |
691 | * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. | |
692 | * \returns true if there is no problem with the data and false otherwise. | |
693 | */ | |
694 | static bool IntegrityOk( | |
695 | const AliHLTMUONTrigRecsDebugBlockStruct& block, | |
696 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL | |
697 | ) | |
698 | { | |
699 | AliHLTUInt32_t count = 1; | |
700 | return IntegrityOk(block, reason, recordNum, count); | |
701 | } | |
702 | ||
a090ff22 | 703 | /** |
704 | * This method is used to check more extensively if the integrity of the | |
705 | * reconstructed hit structure is OK and returns true in that case. | |
706 | * [in] \param hit The reconstructed hit structure to check. | |
707 | * [out] \param reason If this is not NULL, then it will be filled with | |
708 | * the reason code describing why the structure is not valid, if and | |
709 | * only if a problem is found with the data. | |
710 | * \returns true if there is no problem with the data and false otherwise. | |
711 | */ | |
712 | static bool IntegrityOk( | |
713 | const AliHLTMUONRecHitStruct& hit, | |
714 | WhyNotValid* reason = NULL | |
715 | ) | |
716 | { | |
717 | AliHLTUInt32_t count = 1; | |
718 | return IntegrityOk(hit, reason, count); | |
719 | } | |
dba14d7d | 720 | |
721 | /** | |
722 | * This method is used to check more extensively if the integrity of the | |
723 | * dHLT raw internal data block is OK and returns true in that case. | |
724 | * [in] \param block The reconstructed hits data block to check. | |
725 | * [out] \param reason If this is not NULL, then it will be filled with | |
726 | * the reason code describing why the data block is not valid, if and | |
727 | * only if a problem is found with the data. | |
a090ff22 | 728 | * [out] \param recordNum If this is not NULL, then it will be filled with |
729 | * the number of the cluster structure that had a problem. This value | |
730 | * will only contain a valid value if the method | |
731 | * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. | |
dba14d7d | 732 | * \returns true if there is no problem with the data and false otherwise. |
733 | */ | |
734 | static bool IntegrityOk( | |
735 | const AliHLTMUONRecHitsBlockStruct& block, | |
a090ff22 | 736 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL |
dba14d7d | 737 | ) |
738 | { | |
739 | AliHLTUInt32_t count = 1; | |
a090ff22 | 740 | return IntegrityOk(block, reason, recordNum, count); |
dba14d7d | 741 | } |
742 | ||
743 | /** | |
744 | * This method is used to check more extensively if the integrity of the | |
745 | * cluster data structure is OK and returns true in that case. | |
746 | * [in] \param cluster The cluster structure to check. | |
747 | * [out] \param reason If this is not NULL, then it will be filled with | |
748 | * the reason code describing why the structure is not valid, if and | |
749 | * only if a problem is found with the data. | |
750 | * \returns true if there is no problem with the data and false otherwise. | |
751 | */ | |
752 | static bool IntegrityOk( | |
753 | const AliHLTMUONClusterStruct& cluster, | |
754 | WhyNotValid* reason = NULL | |
755 | ) | |
756 | { | |
757 | AliHLTUInt32_t count = 1; | |
758 | return IntegrityOk(cluster, reason, count); | |
759 | } | |
760 | ||
761 | /** | |
762 | * This method is used to check more extensively if the integrity of the | |
763 | * dHLT raw internal data block is OK and returns true in that case. | |
764 | * [in] \param block The clusters data block to check. | |
765 | * [out] \param reason If this is not NULL, then it will be filled with | |
766 | * the reason code describing why the data block is not valid, if and | |
767 | * only if a problem is found with the data. | |
768 | * [out] \param recordNum If this is not NULL, then it will be filled with | |
769 | * the number of the cluster structure that had a problem. This value | |
770 | * will only contain a valid value if the method | |
771 | * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. | |
772 | * \returns true if there is no problem with the data and false otherwise. | |
773 | */ | |
774 | static bool IntegrityOk( | |
775 | const AliHLTMUONClustersBlockStruct& block, | |
776 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL | |
777 | ) | |
778 | { | |
779 | AliHLTUInt32_t count = 1; | |
780 | return IntegrityOk(block, reason, recordNum, count); | |
781 | } | |
782 | ||
783 | /** | |
784 | * This method is used to check more extensively if the integrity of the | |
785 | * channel data structure is OK and returns true in that case. | |
786 | * [in] \param cluster The channel structure to check. | |
787 | * [out] \param reason If this is not NULL, then it will be filled with | |
788 | * the reason code describing why the structure is not valid, if and | |
789 | * only if a problem is found with the data. | |
790 | * \returns true if there is no problem with the data and false otherwise. | |
791 | */ | |
792 | static bool IntegrityOk( | |
793 | const AliHLTMUONChannelStruct& channel, | |
794 | WhyNotValid* reason = NULL | |
795 | ) | |
796 | { | |
797 | AliHLTUInt32_t count = 1; | |
798 | return IntegrityOk(channel, reason, count); | |
799 | } | |
800 | ||
801 | /** | |
802 | * This method is used to check more extensively if the integrity of the | |
803 | * dHLT raw internal data block is OK and returns true in that case. | |
804 | * [in] \param block The ADC channels data block to check. | |
805 | * [out] \param reason If this is not NULL, then it will be filled with | |
806 | * the reason code describing why the data block is not valid, if and | |
807 | * only if a problem is found with the data. | |
808 | * [out] \param recordNum If this is not NULL, then it will be filled with | |
809 | * the number of the channel structure that had a problem. This value | |
810 | * will only contain a valid value if the method | |
811 | * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. | |
812 | * \returns true if there is no problem with the data and false otherwise. | |
813 | */ | |
814 | static bool IntegrityOk( | |
815 | const AliHLTMUONChannelsBlockStruct& block, | |
816 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL | |
817 | ) | |
818 | { | |
819 | AliHLTUInt32_t count = 1; | |
820 | return IntegrityOk(block, reason, recordNum, count); | |
821 | } | |
822 | ||
823 | /** | |
824 | * This method is used to check more extensively if the integrity of the | |
825 | * Manso track structure is OK and returns true in that case. | |
826 | * [in] \param track The Manso track structure to check. | |
827 | * [out] \param reason If this is not NULL, then it will be filled with | |
828 | * the reason code describing why the structure is not valid, if and | |
829 | * only if a problem is found with the data. | |
830 | * \returns true if there is no problem with the structure and false otherwise. | |
831 | */ | |
832 | static bool IntegrityOk( | |
833 | const AliHLTMUONMansoTrackStruct& track, | |
834 | WhyNotValid* reason = NULL | |
835 | ) | |
836 | { | |
837 | AliHLTUInt32_t count = 1; | |
838 | return IntegrityOk(track, reason, count); | |
839 | } | |
840 | ||
841 | /** | |
842 | * This method is used to check more extensively if the integrity of the | |
843 | * dHLT raw internal data block is OK and returns true in that case. | |
844 | * [in] \param block The Manso track data block to check. | |
845 | * [out] \param reason If this is not NULL, then it will be filled with | |
846 | * the reason code describing why the data block is not valid, if and | |
847 | * only if a problem is found with the data. | |
848 | * [out] \param recordNum If this is not NULL, then it will be filled with | |
849 | * the number of the Manso track structure that had a problem. | |
850 | * This value will only contain a valid value if the method | |
851 | * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. | |
852 | * \returns true if there is no problem with the data and false otherwise. | |
853 | */ | |
854 | static bool IntegrityOk( | |
855 | const AliHLTMUONMansoTracksBlockStruct& block, | |
856 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL | |
857 | ) | |
858 | { | |
859 | AliHLTUInt32_t count = 1; | |
860 | return IntegrityOk(block, reason, recordNum, count); | |
861 | } | |
862 | ||
863 | /** | |
864 | * This method is used to check more extensively if the integrity of the | |
865 | * Manso track candidate structure is OK and returns true in that case. | |
866 | * [in] \param candidate The Manso track candidate structure to check. | |
867 | * [out] \param reason If this is not NULL, then it will be filled with | |
868 | * the reason code describing why the structure is not valid, if and | |
869 | * only if a problem is found with the data. | |
870 | * \returns true if there is no problem with the structure and false otherwise. | |
871 | */ | |
872 | static bool IntegrityOk( | |
873 | const AliHLTMUONMansoCandidateStruct& candidate, | |
874 | WhyNotValid* reason = NULL | |
875 | ) | |
876 | { | |
877 | AliHLTUInt32_t count = 1; | |
878 | return IntegrityOk(candidate, reason, count); | |
879 | } | |
880 | ||
881 | /** | |
882 | * This method is used to check more extensively if the integrity of the | |
883 | * dHLT raw internal data block is OK and returns true in that case. | |
884 | * [in] \param block The Manso track candidate data block to check. | |
885 | * [out] \param reason If this is not NULL, then it will be filled with | |
886 | * the reason code describing why the data block is not valid, if and | |
887 | * only if a problem is found with the data. | |
888 | * [out] \param recordNum If this is not NULL, then it will be filled with | |
889 | * the number of the Manso track candidate structure that had a problem. | |
890 | * This value will only contain a valid value if the method | |
891 | * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. | |
892 | * \returns true if there is no problem with the data and false otherwise. | |
893 | */ | |
894 | static bool IntegrityOk( | |
895 | const AliHLTMUONMansoCandidatesBlockStruct& block, | |
896 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL | |
897 | ) | |
898 | { | |
899 | AliHLTUInt32_t count = 1; | |
900 | return IntegrityOk(block, reason, recordNum, count); | |
901 | } | |
902 | ||
903 | /** | |
904 | * This method is used to check more extensively if the integrity of the | |
905 | * single track trigger decision structure is OK and returns true in that case. | |
906 | * [in] \param decision The trigger decision structure to check. | |
907 | * [out] \param reason If this is not NULL, then it will be filled with | |
908 | * the reason code describing why the structure is not valid, if and | |
909 | * only if a problem is found with the data. | |
910 | * \returns true if there is no problem with the structure and false otherwise. | |
911 | */ | |
912 | static bool IntegrityOk( | |
913 | const AliHLTMUONTrackDecisionStruct& decision, | |
914 | WhyNotValid* reason = NULL | |
915 | ) | |
916 | { | |
917 | AliHLTUInt32_t count = 1; | |
918 | return IntegrityOk(decision, reason, count); | |
919 | } | |
920 | ||
921 | /** | |
922 | * This method is used to check more extensively if the integrity of the | |
923 | * dHLT raw internal data block is OK and returns true in that case. | |
924 | * [in] \param block The single track trigger decision data block to check. | |
925 | * [out] \param reason If this is not NULL, then it will be filled with | |
926 | * the reason code describing why the data block is not valid, if and | |
927 | * only if a problem is found with the data. | |
928 | * [out] \param recordNum If this is not NULL, then it will be filled with | |
929 | * the number of the single track trigger decision structure that had | |
930 | * a problem. This value will only contain a valid value if the method | |
931 | * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. | |
932 | * \returns true if there is no problem with the data and false otherwise. | |
933 | */ | |
934 | static bool IntegrityOk( | |
935 | const AliHLTMUONSinglesDecisionBlockStruct& block, | |
936 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL | |
937 | ) | |
938 | { | |
939 | AliHLTUInt32_t count = 1; | |
940 | return IntegrityOk(block, reason, recordNum, count); | |
941 | } | |
942 | ||
943 | /** | |
944 | * This method is used to check more extensively if the integrity of the | |
945 | * track pair trigger decision structure is OK and returns true in that case. | |
946 | * [in] \param decision The trigger decision structure to check. | |
947 | * [out] \param reason If this is not NULL, then it will be filled with | |
948 | * the reason code describing why the structure is not valid, if and | |
949 | * only if a problem is found with the data. | |
950 | * \returns true if there is no problem with the structure and false otherwise. | |
951 | */ | |
952 | static bool IntegrityOk( | |
953 | const AliHLTMUONPairDecisionStruct& decision, | |
954 | WhyNotValid* reason = NULL | |
955 | ) | |
956 | { | |
957 | AliHLTUInt32_t count = 1; | |
958 | return IntegrityOk(decision, reason, count); | |
959 | } | |
960 | ||
961 | /** | |
962 | * This method is used to check more extensively if the integrity of the | |
963 | * dHLT raw internal data block is OK and returns true in that case. | |
964 | * [in] \param block The track pair trigger decision data block to check. | |
965 | * [out] \param reason If this is not NULL, then it will be filled with | |
966 | * the reason code describing why the data block is not valid, if and | |
967 | * only if a problem is found with the data. | |
968 | * [out] \param recordNum If this is not NULL, then it will be filled with | |
969 | * the number of the track pairs trigger decision structure that had | |
970 | * a problem. This value will only contain a valid value if the method | |
971 | * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. | |
972 | * \returns true if there is no problem with the data and false otherwise. | |
973 | */ | |
974 | static bool IntegrityOk( | |
975 | const AliHLTMUONPairsDecisionBlockStruct& block, | |
976 | WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL | |
977 | ) | |
978 | { | |
979 | AliHLTUInt32_t count = 1; | |
980 | return IntegrityOk(block, reason, recordNum, count); | |
981 | } | |
b727f838 | 982 | |
983 | /** | |
90a74d7a | 984 | * Methods used to check more extensively if the integrity of various |
985 | * types of data blocks are Ok and returns true in that case. | |
b727f838 | 986 | * These can be slow and should generally only be used for debugging. |
dba14d7d | 987 | * The methods are able to return multiple reasons for the problems related |
988 | * to the data block under test. | |
b727f838 | 989 | */ |
dba14d7d | 990 | static bool IntegrityOk( |
991 | const AliHLTMUONTriggerRecordStruct& tr, | |
992 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
993 | ); | |
878cb83d | 994 | |
995 | static bool IntegrityOk( | |
996 | const AliHLTMUONTriggerRecordsBlockStruct& block, | |
dba14d7d | 997 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, |
998 | AliHLTUInt32_t& reasonCount | |
999 | ); | |
1000 | ||
1001 | static bool IntegrityOk( | |
1002 | const AliHLTMUONTrigRecInfoStruct& trigInfo, | |
1003 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
1004 | ); | |
1005 | ||
1006 | static bool IntegrityOk( | |
1007 | const AliHLTMUONTrigRecsDebugBlockStruct& block, | |
1008 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, | |
1009 | AliHLTUInt32_t& reasonCount | |
1010 | ); | |
1011 | ||
1012 | static bool IntegrityOk( | |
a090ff22 | 1013 | const AliHLTMUONRecHitStruct& hit, |
dba14d7d | 1014 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount |
a090ff22 | 1015 | ); |
1016 | ||
1017 | static bool IntegrityOk( | |
1018 | const AliHLTMUONRecHitsBlockStruct& block, | |
1019 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, | |
1020 | AliHLTUInt32_t& reasonCount | |
dba14d7d | 1021 | ); |
1022 | ||
1023 | static bool IntegrityOk( | |
1024 | const AliHLTMUONClusterStruct& cluster, | |
1025 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
1026 | ); | |
1027 | ||
1028 | static bool IntegrityOk( | |
1029 | const AliHLTMUONClustersBlockStruct& block, | |
1030 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, | |
1031 | AliHLTUInt32_t& reasonCount | |
1032 | ); | |
1033 | ||
1034 | static bool IntegrityOk( | |
1035 | const AliHLTMUONChannelStruct& channel, | |
1036 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
1037 | ); | |
1038 | ||
1039 | static bool IntegrityOk( | |
1040 | const AliHLTMUONChannelsBlockStruct& block, | |
1041 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, | |
1042 | AliHLTUInt32_t& reasonCount | |
1043 | ); | |
1044 | ||
1045 | static bool IntegrityOk( | |
1046 | const AliHLTMUONMansoTrackStruct& track, | |
1047 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
878cb83d | 1048 | ); |
878cb83d | 1049 | |
1050 | static bool IntegrityOk( | |
1051 | const AliHLTMUONMansoTracksBlockStruct& block, | |
dba14d7d | 1052 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, |
1053 | AliHLTUInt32_t& reasonCount | |
1054 | ); | |
1055 | ||
1056 | static bool IntegrityOk( | |
1057 | const AliHLTMUONMansoCandidateStruct& candidate, | |
1058 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
878cb83d | 1059 | ); |
1060 | ||
1061 | static bool IntegrityOk( | |
1062 | const AliHLTMUONMansoCandidatesBlockStruct& block, | |
dba14d7d | 1063 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, |
1064 | AliHLTUInt32_t& reasonCount | |
878cb83d | 1065 | ); |
1066 | ||
dba14d7d | 1067 | static bool IntegrityOk( |
1068 | const AliHLTMUONTrackDecisionStruct& decision, | |
1069 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
1070 | ); | |
878cb83d | 1071 | |
1072 | static bool IntegrityOk( | |
1073 | const AliHLTMUONSinglesDecisionBlockStruct& block, | |
dba14d7d | 1074 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, |
1075 | AliHLTUInt32_t& reasonCount | |
878cb83d | 1076 | ); |
1077 | ||
dba14d7d | 1078 | static bool IntegrityOk( |
1079 | const AliHLTMUONPairDecisionStruct& decision, | |
1080 | WhyNotValid* reason, AliHLTUInt32_t& reasonCount | |
1081 | ); | |
878cb83d | 1082 | |
1083 | static bool IntegrityOk( | |
1084 | const AliHLTMUONPairsDecisionBlockStruct& block, | |
dba14d7d | 1085 | WhyNotValid* reason, AliHLTUInt32_t* recordNum, |
1086 | AliHLTUInt32_t& reasonCount | |
878cb83d | 1087 | ); |
dba14d7d | 1088 | |
1089 | /** | |
1090 | * Returns true if the \em recordNum in the corresponding IntegrityOk method | |
1091 | * would have been set, if it returned false and a reason was set. | |
1092 | * This helper method makes it easy to test if the \em recordNum parameter | |
1093 | * is filled with a valid value or not. | |
1094 | */ | |
1095 | static bool RecordNumberWasSet(WhyNotValid reason); | |
26a4668d | 1096 | |
1097 | private: | |
213499f0 | 1098 | |
33b1e2f2 | 1099 | // Should never have to create, copy or destroy this object. |
213499f0 | 1100 | AliHLTMUONUtils() {} |
33b1e2f2 | 1101 | AliHLTMUONUtils(const AliHLTMUONUtils& obj); |
213499f0 | 1102 | virtual ~AliHLTMUONUtils() {} |
33b1e2f2 | 1103 | AliHLTMUONUtils& operator = (const AliHLTMUONUtils& obj); |
1104 | ||
1105 | ClassDef(AliHLTMUONUtils, 0); // Interface for helpful dHLT utility methods. | |
26a4668d | 1106 | }; |
1107 | ||
b727f838 | 1108 | //_____________________________________________________________________________ |
1109 | ||
878cb83d | 1110 | inline std::ostream& operator << (std::ostream& stream, AliHLTMUONUtils::WhyNotValid reason) |
1111 | { | |
1112 | /// Stream operator for the WhyNotValid enumeration for usage with | |
1113 | /// std::ostream classes. Allows usages such as: | |
1114 | /// AliHLTMUONUtils::WhyNotValid r; std::cout << r; | |
1115 | ||
1116 | stream << AliHLTMUONUtils::FailureReasonToString(reason); | |
1117 | return stream; | |
1118 | } | |
1119 | ||
1120 | //_____________________________________________________________________________ | |
1121 | ||
b727f838 | 1122 | // Since c++ is missing a finally "keyword" we define one. Its usage is identical |
1123 | // to a try..finally statement in Java etc.. however, since it is officialy a macro | |
1124 | // one must use the ( ) brackets instead of { } | |
1125 | // If the compiler supports __finally use it otherwise make our own. | |
1126 | #if defined(__BORLANDC__) | |
1127 | # define finally(str) __finally{str} | |
1128 | #else | |
1129 | # define finally(code) \ | |
1130 | catch(...) \ | |
1131 | { \ | |
1132 | code \ | |
1133 | throw; \ | |
1134 | }; \ | |
1135 | code | |
1136 | #endif // __BORLANDC__ | |
1137 | ||
b727f838 | 1138 | // Here we define the DebugTrace(message) macro for easy embedding of debug |
1139 | // information into the dimuon HLT code. Its usage is meant to be for generating | |
1140 | // traces of the program which are only useful during full scale debugging. | |
1141 | // Log messages should use the standard HLT logging mechanisms. | |
69fe8695 | 1142 | // The output is only generated in programs compiled with the DEBUGTRACE directive |
b727f838 | 1143 | // defined. Here is a usage example: |
1144 | // | |
1145 | // // statements... | |
1146 | // DebugTrace("some debug information."); | |
1147 | // // statements... | |
1148 | // | |
1149 | // One can also use C++ ostream operators and manipulators like so: | |
1150 | // | |
1151 | // // statements... | |
1152 | // int x, y; | |
b12fe461 | 1153 | // DebugTrace("x = " << x << " and y = 0x" << std::hex << y ); |
b727f838 | 1154 | // // statements... |
1155 | // | |
69fe8695 | 1156 | #ifdef DEBUGTRACE |
b4dfa1c8 | 1157 | # include <iostream> |
b727f838 | 1158 | # define DebugTrace(message) {std::cout << message << std::endl;} |
1159 | #else // DEBUG | |
1160 | # define DebugTrace(message) | |
1161 | #endif // DEBUG | |
1162 | ||
1163 | ||
26a4668d | 1164 | #endif // ALIHLTMUONUTILS_H |