Fixing coding violations and getting rid of warnings.
[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONUtils.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///
19 /// @file   AliHLTMUONUtils.cxx
20 /// @author Artur Szostak <artursz@iafrica.com>
21 /// @date   
22 /// @brief  Implementation of AliHLTMUONUtils utility routines.
23 ///
24
25 #include "AliHLTMUONUtils.h"
26 #include "AliHLTMUONConstants.h"
27 #include "AliHLTMUONTriggerRecordsBlockStruct.h"
28 #include "AliHLTMUONTrigRecsDebugBlockStruct.h"
29 #include "AliHLTMUONTriggerChannelsBlockStruct.h"
30 #include "AliHLTMUONRecHitsBlockStruct.h"
31 #include "AliHLTMUONClustersBlockStruct.h"
32 #include "AliHLTMUONChannelsBlockStruct.h"
33 #include "AliHLTMUONMansoTracksBlockStruct.h"
34 #include "AliHLTMUONMansoCandidatesBlockStruct.h"
35 #include "AliHLTMUONSinglesDecisionBlockStruct.h"
36 #include "AliHLTMUONPairsDecisionBlockStruct.h"
37 #include <cassert>
38
39
40 AliHLTUInt32_t AliHLTMUONUtils::PackTriggerRecordFlags(
41                 AliHLTMUONParticleSign sign, const bool hitset[4]
42         )
43 {
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         
53         AliHLTUInt32_t flags;
54         switch (sign)
55         {
56         case kSignMinus: flags = 0x80000000; break;
57         case kSignPlus:  flags = 0x40000000; break;
58         default:         flags = 0x00000000; break;
59         }
60
61         return flags | (hitset[0] ? 0x1 : 0) | (hitset[1] ? 0x2 : 0)
62                 | (hitset[2] ? 0x4 : 0) | (hitset[3] ? 0x8 : 0);
63 }
64
65
66 void AliHLTMUONUtils::UnpackTriggerRecordFlags(
67                 AliHLTUInt32_t flags, AliHLTMUONParticleSign& sign, bool hitset[4]
68         )
69 {
70         ///
71         /// This unpacks the AliHLTMUONTriggerRecordStruct::fFlags bits into
72         /// its component fields.
73         /// @param flags  The flags from an AliHLTMUONTriggerRecordStruct structure.
74         /// @param sign    Sets this to the particle sign.
75         /// @param hitset  Sets the array elements to indicate if the corresponding
76         ///                fHits[i] element was set/filled.
77         ///
78         
79         AliHLTUInt32_t signbits = flags & 0xC0000000;
80         switch (signbits)
81         {
82         case 0x80000000: sign = kSignMinus;   break;
83         case 0x40000000: sign = kSignPlus;    break;
84         default:         sign = kSignUnknown; break;
85         }
86         hitset[0] = (flags & 0x1) == 0x1;
87         hitset[1] = (flags & 0x2) == 0x2;
88         hitset[2] = (flags & 0x4) == 0x4;
89         hitset[3] = (flags & 0x8) == 0x8;
90 }
91
92
93 AliHLTUInt32_t AliHLTMUONUtils::PackTrackDecisionBits(bool highPt, bool lowPt)
94 {
95         ///
96         /// This packs the given parameters into the bits of a word appropriate
97         /// for AliHLTMUONTrackDecisionStruct::fTriggerBits.
98         /// @param highPt  Has the track passed the high pt cut.
99         /// @param lowPt   Has the track passed the low pt cut.
100         /// @return  Returns the 32 bit packed word.
101         ///
102         
103         return (highPt ? 0x2 : 0) | (lowPt ? 0x1 : 0);
104 }
105
106
107 void AliHLTMUONUtils::UnpackTrackDecisionBits(
108                 AliHLTUInt32_t bits, bool& highPt, bool& lowPt
109         )
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         
120         lowPt  = (bits & 0x1) == 1;
121         highPt = (bits & 0x2) == 1;
122 }
123
124
125 AliHLTUInt32_t AliHLTMUONUtils::PackPairDecisionBits(
126                 bool highMass, bool lowMass, bool unlike,
127                 AliHLTUInt8_t highPtCount, AliHLTUInt8_t lowPtCount
128         )
129 {
130         ///
131         /// This packs the given parameters into the bits of a word appropriate
132         /// for AliHLTMUONPairDecisionStruct::fTriggerBits.
133         ///
134         /// @param highMass Has the track pair passed the high invariant mass cut.
135         /// @param lowMass  Has the track pair passed the low invariant mass cut.
136         /// @param unlike   Does the track pair have unlike signs.
137         /// @param highPtCount The number of tracks that passed the high pt cut
138         ///                    in the pair.
139         /// @param lowPtCount  The number of tracks that passed the low pt cut
140         ///                    in the pair.
141         /// @return  Returns the 32 bit packed word.
142         ///
143         /// Note: Must have highPtCount + lowPtCount <= 2 and unlike == true if
144         /// highMass or lowMass is true.
145         ///
146         
147         assert( highPtCount + lowPtCount <= 2 );
148         // highMass and lowMass must be false if unlike is false:
149         assert( not unlike ? (highMass == false and lowMass == false) : true );
150         
151         return (highMass ? 0x40 : 0) | (lowMass ? 0x20 : 0) | (unlike ? 0x10 : 0)
152                 | ((highPtCount & 0x3) << 2) | (lowPtCount & 0x3);
153 }
154
155
156 void AliHLTMUONUtils::UnpackPairDecisionBits(
157                 AliHLTUInt32_t bits, bool& highMass, bool& lowMass, bool& unlike,
158                 AliHLTUInt8_t& highPtCount, AliHLTUInt8_t& lowPtCount
159         )
160 {
161         ///
162         /// This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into
163         /// its component fields.
164         /// @param bits  The trigger bits from an AliHLTMUONPairDecisionStruct
165         ///              structure.
166         /// @param highMass Sets this to the value of the high invariant mass cut bit.
167         /// @param lowMass  Sets this to the value of the low invariant mass cut bit.
168         /// @param unlike   Sets this if the pair is unlike sign.
169         /// @param highPtCount Sets this to the high pt count bits.
170         /// @param lowPtCount  Sets this to the low pt count bits.
171         ///
172         
173         highMass = (bits & 0x40) == 1;
174         lowMass  = (bits & 0x20) == 1;
175         unlike   = (bits & 0x10) == 1;
176         highPtCount = (bits & 0xC) >> 2;
177         lowPtCount = bits & 0x3;
178 }
179
180
181 AliHLTUInt32_t AliHLTMUONUtils::PackSpecBits(
182                 const bool ddl[22]
183         )
184 {
185         ///
186         /// This packs the given parameters into the 32bit Pub/Sub specification
187         /// word in the data block descriptor.
188         ///
189         /// @param ddl  The list of DDLs forming part of the readout. ddl[0]
190         ///             indicates DDL number 2560, ddl[1] is for DDL 2561 and so
191         ///             on up to ddl[19]. ddl[20] and ddl[21] will be for the
192         ///             trigger DDLs 2816 and 2817 respectively.
193         /// @return  Returns the 32 bit packed specification word.
194         ///
195         
196         // Pack the bits into the following format:
197         //   bit:   [        31 - 22        ][     21     ][     20     ][  19 - 0 ]
198         //   field: [ reserved, set to zero ][ TRGDDL2817 ][ TRGDDL2816 ][ TRKDDLS ]
199         // Meaning of field acronyms:
200         //   TRGDDL2816 - Trigger DDL number 2816.
201         //   TRGDDL2817 - Trigger DDL number 2817.
202         //   TRKDDLS - Tracking DDL flags where bit 0 will be for DDL number 2560,
203         //             bit 1 for DDL no. 2561 etc. up to bit 19 which is for DDL 2579.
204         AliHLTUInt32_t bits = 0;
205         for (int i = 0; i < 22; i++)
206                 bits |= (ddl[i] ? 0x1 : 0x0) << i;
207         return bits;
208 }
209
210
211 void AliHLTMUONUtils::UnpackSpecBits(
212                 AliHLTUInt32_t bits, bool ddl[22]
213         )
214 {
215         ///
216         /// This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into
217         /// its component fields.
218         /// @param bits  The Pub/Sub specification word from a data block descriptor.
219         /// @param ddl  The output list of DDLs forming part of the readout. ddl[0]
220         ///             indicates DDL number 2560, ddl[1] is for DDL 2561 and so
221         ///             on up to ddl[19]. ddl[20] and ddl[21] will be for the
222         ///             trigger DDLs 2816 and 2817 respectively.
223         ///
224         
225         // Perform the inverse operation of PackSpecBits.
226         for (int i = 0; i < 22; i++)
227                 ddl[i] = ((bits >> i) & 0x1) == 1;
228 }
229
230
231 bool AliHLTMUONUtils::HeaderOk(
232                 const AliHLTMUONTriggerRecordsBlockStruct& block,
233                 WhyNotValid* reason
234         )
235 {
236         ///
237         /// Methods used to check if the header information corresponds to the
238         /// supposed type of the data block.
239         /// If the 'reason' parameter is not NULL then these methods will fill the
240         /// memory pointed to by reason with a code describing of why the header
241         /// is not valid, if and only if a problem is found with the data.
242         ///
243          
244         // The block must have the correct type.
245         if (block.fHeader.fType != kTriggerRecordsDataBlock)
246         {
247                 if (reason != NULL) *reason = kHeaderContainsWrongType;
248                 return false;
249         }
250         
251         // The block's record width must be the correct size.
252         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTriggerRecordStruct))
253         {
254                 if (reason != NULL) *reason = kHeaderContainsWrongRecordWidth;
255                 return false;
256         }
257         
258         return true;
259 }
260
261
262 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
263 {
264         ///
265         /// Methods used to check if the header information corresponds to the
266         /// supposed type of the data block.
267         ///
268         
269         // The block must have the correct type.
270         if (block.fHeader.fType != kTrigRecsDebugDataBlock) return false;
271         // The block's record width must be the correct size.
272         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTrigRecInfoStruct))
273                 return false;
274         return true;
275 }
276
277
278 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block)
279 {
280         ///
281         /// Methods used to check if the header information corresponds to the
282         /// supposed type of the data block.
283         ///
284         
285         // The block must have the correct type.
286         if (block.fHeader.fType != kTriggerChannelsDataBlock) return false;
287         // The block's record width must be the correct size.
288         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTriggerChannelStruct))
289                 return false;
290         return true;
291 }
292
293
294 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONRecHitsBlockStruct& block)
295 {
296         ///
297         /// Methods used to check if the header information corresponds to the
298         /// supposed type of the data block.
299         ///
300         
301         // The block must have the correct type.
302         if (block.fHeader.fType != kRecHitsDataBlock) return false;
303         // The block's record width must be the correct size.
304         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONRecHitStruct))
305                 return false;
306         return true;
307 }
308
309
310 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONClustersBlockStruct& block)
311 {
312         ///
313         /// Methods used to check if the header information corresponds to the
314         /// supposed type of the data block.
315         ///
316         
317         // The block must have the correct type.
318         if (block.fHeader.fType != kClustersDataBlock) return false;
319         // The block's record width must be the correct size.
320         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONClusterStruct))
321                 return false;
322         return true;
323 }
324
325
326 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONChannelsBlockStruct& block)
327 {
328         ///
329         /// Methods used to check if the header information corresponds to the
330         /// supposed type of the data block.
331         ///
332         
333         // The block must have the correct type.
334         if (block.fHeader.fType != kChannelsDataBlock) return false;
335         // The block's record width must be the correct size.
336         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONChannelStruct))
337                 return false;
338         return true;
339 }
340
341
342 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block)
343 {
344         ///
345         /// Methods used to check if the header information corresponds to the
346         /// supposed type of the data block.
347         ///
348         
349         // The block must have the correct type.
350         if (block.fHeader.fType != kMansoTracksDataBlock) return false;
351         // The block's record width must be the correct size.
352         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONMansoTrackStruct))
353                 return false;
354         return true;
355 }
356
357
358 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block)
359 {
360         ///
361         /// Methods used to check if the header information corresponds to the
362         /// supposed type of the data block.
363         ///
364         
365         // The block must have the correct type.
366         if (block.fHeader.fType != kMansoCandidatesDataBlock) return false;
367         // The block's record width must be the correct size.
368         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONMansoCandidateStruct))
369                 return false;
370         return true;
371 }
372
373
374 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block)
375 {
376         ///
377         /// Methods used to check if the header information corresponds to the
378         /// supposed type of the data block.
379         ///
380         
381         // The block must have the correct type.
382         if (block.fHeader.fType != kSinglesDecisionDataBlock) return false;
383         // The block's record width must be the correct size.
384         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTrackDecisionStruct))
385                 return false;
386         return true;
387 }
388
389
390 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block)
391 {
392         ///
393         /// Methods used to check if the header information corresponds to the
394         /// supposed type of the data block.
395         ///
396         
397         // The block must have the correct type.
398         if (block.fHeader.fType != kPairsDecisionDataBlock) return false;
399         // The block's record width must be the correct size.
400         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONPairDecisionStruct))
401                 return false;
402         return true;
403 }
404
405
406 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordStruct& tr)
407 {
408         ///
409         /// Methods used to check more extensively if the integrity of various
410         /// types of data blocks are Ok and returns true in that case.
411         /// These can be slow and should generally only be used for debugging.
412         ///
413         
414         // Make sure that the reserved bits in the fFlags field are set
415         // to zero.
416         if ((tr.fFlags & 0x3FFFFFF0) != 0) return false;
417
418         // Make sure the sign is not invalid.
419         if ((tr.fFlags & 0xC0000000) == 3) return false;
420
421         // Check that fHit[i] is nil if the corresponding bit in the
422         // flags word is zero.
423         const AliHLTMUONRecHitStruct& nilhit
424                 = AliHLTMUONConstants::NilRecHitStruct();
425         if ((tr.fFlags & 0x1) == 0 and tr.fHit[0] != nilhit) return false;
426         if ((tr.fFlags & 0x2) == 0 and tr.fHit[1] != nilhit) return false;
427         if ((tr.fFlags & 0x4) == 0 and tr.fHit[2] != nilhit) return false;
428         if ((tr.fFlags & 0x8) == 0 and tr.fHit[3] != nilhit) return false;
429
430         return true;
431 }
432
433
434 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& block)
435 {
436         ///
437         /// Methods used to check more extensively if the integrity of various
438         /// types of data blocks are Ok and returns true in that case.
439         /// These can be slow and should generally only be used for debugging.
440         ///
441         
442         if (not HeaderOk(block)) return false;
443
444         // Check if any ID is duplicated.
445         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
446         {
447                 AliHLTInt32_t id = block.fTriggerRecord[i].fId;
448                 for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
449                 {
450                         if (id == block.fTriggerRecord[j].fId)
451                                 return false;
452                 }
453         }
454
455         // Check integrity of individual trigger records.
456         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
457         {
458                 if (not IntegrityOk(block.fTriggerRecord[i])) return false;
459         }
460
461         return true;
462 }
463
464
465 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
466 {
467         ///
468         /// Methods used to check more extensively if the integrity of various
469         /// types of data blocks are Ok and returns true in that case.
470         /// These can be slow and should generally only be used for debugging.
471         ///
472         
473         if (not HeaderOk(block)) return false;
474         return true;
475 }
476
477
478 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerChannelsBlockStruct& block)
479 {
480         ///
481         /// Methods used to check more extensively if the integrity of various
482         /// types of data blocks are Ok and returns true in that case.
483         /// These can be slow and should generally only be used for debugging.
484         ///
485         
486         if (not HeaderOk(block)) return false;
487         return true;
488 }
489
490
491 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block)
492 {
493         ///
494         /// Methods used to check more extensively if the integrity of various
495         /// types of data blocks are Ok and returns true in that case.
496         /// These can be slow and should generally only be used for debugging.
497         ///
498         
499         if (not HeaderOk(block)) return false;
500         return true;
501 }
502
503
504 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONClustersBlockStruct& block)
505 {
506         ///
507         /// Methods used to check more extensively if the integrity of various
508         /// types of data blocks are Ok and returns true in that case.
509         /// These can be slow and should generally only be used for debugging.
510         ///
511         
512         if (not HeaderOk(block)) return false;
513
514         // Check if any ID is duplicated.
515         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
516         {
517                 AliHLTInt32_t id = block.fCluster[i].fId;
518                 for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
519                 {
520                         if (id == block.fCluster[j].fId)
521                                 return false;
522                 }
523         }
524         
525         return true;
526 }
527
528
529 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONChannelsBlockStruct& block)
530 {
531         ///
532         /// Methods used to check more extensively if the integrity of various
533         /// types of data blocks are Ok and returns true in that case.
534         /// These can be slow and should generally only be used for debugging.
535         ///
536         
537         if (not HeaderOk(block)) return false;
538         return true;
539 }
540
541
542 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTrackStruct& track)
543 {
544         ///
545         /// Methods used to check more extensively if the integrity of various
546         /// types of data blocks are Ok and returns true in that case.
547         /// These can be slow and should generally only be used for debugging.
548         ///
549         
550         // Make sure that the reserved bits in the fFlags field are set
551         // to zero.
552         if ((track.fFlags & 0x3FFFFFF0) != 0) return false;
553
554         // Make sure the sign is not invalid.
555         if ((track.fFlags & 0xC0000000) == 0xC0000000) return false;
556
557         // Check that fHit[i] is nil if the corresponding bit in the
558         // flags word is zero.
559         const AliHLTMUONRecHitStruct& nilhit
560                 = AliHLTMUONConstants::NilRecHitStruct();
561         if ((track.fFlags & 0x1) == 0 and track.fHit[0] != nilhit) return false;
562         if ((track.fFlags & 0x2) == 0 and track.fHit[1] != nilhit) return false;
563         if ((track.fFlags & 0x4) == 0 and track.fHit[2] != nilhit) return false;
564         if ((track.fFlags & 0x8) == 0 and track.fHit[3] != nilhit) return false;
565         
566         return true;
567 }
568
569
570 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block)
571 {
572         ///
573         /// Methods used to check more extensively if the integrity of various
574         /// types of data blocks are Ok and returns true in that case.
575         /// These can be slow and should generally only be used for debugging.
576         ///
577         
578         if (not HeaderOk(block)) return false;
579
580         // Check if any ID is duplicated.
581         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
582         {
583                 AliHLTInt32_t id = block.fTrack[i].fId;
584                 for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
585                 {
586                         if (id == block.fTrack[j].fId)
587                                 return false;
588                 }
589         }
590
591         // Check that the tracks have integrity.
592         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
593         {
594                 if (not IntegrityOk(block.fTrack[i])) return false;
595         }
596
597         return true;
598 }
599
600
601 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoCandidatesBlockStruct& block)
602 {
603         ///
604         /// Methods used to check more extensively if the integrity of various
605         /// types of data blocks are Ok and returns true in that case.
606         /// These can be slow and should generally only be used for debugging.
607         ///
608         
609         if (not HeaderOk(block)) return false;
610
611         // Check that the tracks have integrity.
612         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
613         {
614                 if (not IntegrityOk(block.fCandidate[i].fTrack)) return false;
615         }
616         
617         return true;
618 }
619
620
621 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrackDecisionStruct& decision)
622 {
623         ///
624         /// Methods used to check more extensively if the integrity of various
625         /// types of data blocks are Ok and returns true in that case.
626         /// These can be slow and should generally only be used for debugging.
627         ///
628         
629         // Make sure that the reserved bits in the fTriggerBits field are set
630         // to zero.
631         if ((decision.fTriggerBits & 0xFFFFFFFC) != 0) return false;
632         return true;
633 }
634
635
636 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONSinglesDecisionBlockStruct& block)
637 {
638         ///
639         /// Methods used to check more extensively if the integrity of various
640         /// types of data blocks are Ok and returns true in that case.
641         /// These can be slow and should generally only be used for debugging.
642         ///
643         
644         if (not HeaderOk(block)) return false;
645
646         // Check that the trigger bits for each track have integrity.
647         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
648         {
649                 if (not IntegrityOk(block.fDecision[i])) return false;
650         }
651         
652         return true;
653 }
654
655
656 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONPairDecisionStruct& decision)
657 {
658         ///
659         /// Methods used to check more extensively if the integrity of various
660         /// types of data blocks are Ok and returns true in that case.
661         /// These can be slow and should generally only be used for debugging.
662         ///
663         
664         // Make sure that the reserved bits in the fTriggerBits field are set
665         // to zero.
666         if ((decision.fTriggerBits & 0xFFFFFF80) != 0) return false;
667         
668         // The high mass or low mass bits can only be set if unlike bit is set.
669         if ((decision.fTriggerBits & 0x00000010) == 0
670             and (decision.fTriggerBits & 0x00000060) != 0
671            )
672                 return false;
673         
674         // Neither the high pt (hipt) or low pt (lopt) count bits can be > 2.
675         // And the sum must not be > 2.
676         AliHLTUInt8_t lowPtCount = (decision.fTriggerBits & 0x00000003);
677         AliHLTUInt8_t highPtCount = (decision.fTriggerBits & 0x0000000C) >> 2;
678         if (lowPtCount + highPtCount > 2) return false;
679         
680         return true;
681 }
682
683
684 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONPairsDecisionBlockStruct& block)
685 {
686         ///
687         /// Methods used to check more extensively if the integrity of various
688         /// types of data blocks are Ok and returns true in that case.
689         /// These can be slow and should generally only be used for debugging.
690         ///
691         
692         if (not HeaderOk(block)) return false;
693
694         // Check that the trigger bits for each track pair have integrity.
695         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
696         {
697                 if (not IntegrityOk(block.fDecision[i])) return false;
698         }
699         
700         return true;
701 }