Adding internal HLT data blocks for debugging information from the trigger chambers.
[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
34
35 AliHLTUInt32_t AliHLTMUONUtils::PackTriggerRecordFlags(
36                 AliHLTMUONParticleSign sign, bool hitset[4]
37         )
38 {
39         AliHLTUInt32_t flags;
40         switch (sign)
41         {
42         case kSignMinus: flags = 0x80000000; break;
43         case kSignPlus:  flags = 0x40000000; break;
44         default:         flags = 0x00000000; break;
45         }
46
47         return flags | (hitset[0] ? 0x1 : 0) | (hitset[1] ? 0x2 : 0)
48                 | (hitset[2] ? 0x4 : 0) | (hitset[3] ? 0x8 : 0);
49 }
50
51
52 void AliHLTMUONUtils::UnpackTriggerRecordFlags(
53                 AliHLTUInt32_t flags, // [in]
54                 AliHLTMUONParticleSign& sign, // [out]
55                 bool hitset[4] // [out]
56         )
57 {
58         AliHLTUInt32_t signbits = flags & 0xC0000000;
59         switch (signbits)
60         {
61         case 0x80000000: sign = kSignMinus;   break;
62         case 0x40000000: sign = kSignPlus;    break;
63         default:         sign = kSignUnknown; break;
64         }
65         hitset[0] = (flags & 0x1) == 1;
66         hitset[1] = (flags & 0x2) == 1;
67         hitset[2] = (flags & 0x4) == 1;
68         hitset[3] = (flags & 0x8) == 1;
69 }
70
71
72 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block)
73 {
74         // The block must have the correct type.
75         if (block.fHeader.fType != kTriggerRecordsDataBlock) return false;
76         // The block's record widths must be the correct size.
77         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTriggerRecordStruct))
78                 return false;
79         return true;
80 }
81
82 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
83 {
84         // The block must have the correct type.
85         if (block.fHeader.fType != kTrigRecsDebugDataBlock) return false;
86         // The block's record widths must be the correct size.
87         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTrigRecInfoStruct))
88                 return false;
89         return true;
90 }
91
92 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block)
93 {
94         // The block must have the correct type.
95         if (block.fHeader.fType != kTriggerChannelsDataBlock) return false;
96         // The block's record widths must be the correct size.
97         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTriggerChannelStruct))
98                 return false;
99         return true;
100 }
101
102 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONRecHitsBlockStruct& block)
103 {
104         // The block must have the correct type.
105         if (block.fHeader.fType != kRecHitsDataBlock) return false;
106         // The block's record widths must be the correct size.
107         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONRecHitStruct))
108                 return false;
109         return true;
110 }
111
112 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONClustersBlockStruct& block)
113 {
114         // The block must have the correct type.
115         if (block.fHeader.fType != kClustersDataBlock) return false;
116         // The block's record widths must be the correct size.
117         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONClusterStruct))
118                 return false;
119         return true;
120 }
121
122 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONChannelsBlockStruct& block)
123 {
124         // The block must have the correct type.
125         if (block.fHeader.fType != kChannelsDataBlock) return false;
126         // The block's record widths must be the correct size.
127         if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONChannelStruct))
128                 return false;
129         return true;
130 }
131
132
133 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& block)
134 {
135         if (not HeaderOk(block)) return false;
136
137         // Check if any ID is duplicated.
138         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
139         {
140                 AliHLTUInt32_t id = block.fTriggerRecord[i].fId;
141                 for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
142                 {
143                         if (id == block.fTriggerRecord[j].fId)
144                                 return false;
145                 }
146         }
147
148         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
149         {
150                 const AliHLTMUONTriggerRecordStruct& tr = block.fTriggerRecord[i];
151
152                 // Make sure that the reserved bits in the fFlags field are set
153                 // to zero.
154                 if ((tr.fFlags & 0x3FFFFFF0) != 0) return false;
155
156                 // Make sure the sign is not invalid.
157                 if ((tr.fFlags & 0xC0000000) == 3) return false;
158
159                 // Check that fHit[i] is nil if the corresponding bit in the
160                 // flags word is zero.
161                 const AliHLTMUONRecHitStruct& nilhit
162                         = AliHLTMUONConstants::NilRecHitStruct();
163                 if ((tr.fFlags & 0x1) == 0 and tr.fHit[0] != nilhit) return false;
164                 if ((tr.fFlags & 0x2) == 0 and tr.fHit[1] != nilhit) return false;
165                 if ((tr.fFlags & 0x4) == 0 and tr.fHit[2] != nilhit) return false;
166                 if ((tr.fFlags & 0x8) == 0 and tr.fHit[3] != nilhit) return false;
167         }
168
169         return true;
170 }
171
172 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
173 {
174         if (not HeaderOk(block)) return false;
175         return true;
176 }
177
178 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerChannelsBlockStruct& block)
179 {
180         if (not HeaderOk(block)) return false;
181         return true;
182 }
183
184 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block)
185 {
186         if (not HeaderOk(block)) return false;
187         return true;
188 }
189
190
191 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONClustersBlockStruct& block)
192 {
193         if (not HeaderOk(block)) return false;
194
195         // Check if any ID is duplicated.
196         for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
197         {
198                 AliHLTUInt32_t id = block.fCluster[i].fId;
199                 for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
200                 {
201                         if (id == block.fCluster[j].fId)
202                                 return false;
203                 }
204         }
205         
206         return true;
207 }
208
209 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONChannelsBlockStruct& block)
210 {
211         if (not HeaderOk(block)) return false;
212         return true;
213 }