Using common loading methods for CDB entries that take care of missing subversion...
[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONDataTypes.h
1 #ifndef ALIHLTMUONDATATYPES_H
2 #define ALIHLTMUONDATATYPES_H
3 /**************************************************************************
4  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Author: The ALICE Off-line Project.                                    *
7  * Contributors are mentioned in the code where appropriate.              *
8  *                                                                        *
9  * Permission to use, copy, modify and distribute this software and its   *
10  * documentation strictly for non-commercial purposes is hereby granted   *
11  * without fee, provided that the above copyright notice appears in all   *
12  * copies and that both the copyright notice and this permission notice   *
13  * appear in the supporting documentation. The authors make no claims     *
14  * about the suitability of this software for any purpose. It is          *
15  * provided "as is" without express or implied warranty.                  *
16  **************************************************************************/
17
18 // $Id$
19
20 /**
21  * @file   AliHLTMUONDataTypes.h
22  * @author Artur Szostak <artursz@iafrica.com>
23  * @date   18 May 2007
24  * @brief  Declaration of basic data types used in HLT/MUON module.
25  *
26  * The types and structs are defined with C linkage since C generally gives us
27  * more binary compatibility between compilers.
28  */
29
30 #include "AliHLTDataTypes.h"
31 #include <ostream>
32
33 extern "C"
34 {
35
36 /**
37  * The common internal dimuon HLT data block header.
38  * These headers help to identify the data block when it is written to disk and
39  * helps to check the integrity of the data blocks in the system.
40  */
41 struct AliHLTMUONDataBlockHeader
42 {
43         AliHLTUInt16_t fType; // The type of the data block. Must contain a value
44                               // defined by AliHLTMUONDataBlockType.
45         AliHLTUInt16_t fRecordWidth; // The number of bytes each record uses. 
46         AliHLTUInt32_t fNrecords; // Number of records in this data block.
47 };
48
49 /**
50  * The field structure of a single row of the AliHLTMUONHitReconstructor component's
51  * lookup table.
52  */
53 struct AliHLTMUONHitRecoLutRow
54 {
55         AliHLTInt32_t fDetElemId;  // The detector element ID of the pad.
56         AliHLTInt32_t fIX, fIY;    // The X,Y number of the pad.
57         AliHLTFloat32_t fRealX, fRealY, fRealZ;  // The real coordinate of the pad.
58         AliHLTFloat32_t fHalfPadSize; // half padsize in X for bending and Y for nonbending
59         AliHLTFloat32_t fPadSizeXY; // padsize in Y for bending plane and X for nonbending
60         AliHLTInt32_t fPlane;  // The plane and PCB zone ID numbers.
61         AliHLTFloat32_t fPed, fSigma, fA0, fA1; // Calibration values
62         AliHLTInt32_t fThres, fSat; //Calibration values
63 };
64
65 /**
66  * The field structure of a single row of the AliHLTMUONTriggerReconstructor component's
67  * lookup table.
68  */
69 struct AliHLTMUONTriggerRecoLutRow
70 {
71         AliHLTUInt32_t fIdFlags;  /// The chamber and detector element identifier packed in AliHLTMUONRecHitStruct::fFlags format.
72         AliHLTFloat32_t fX;  // Global X coordinate of channel.
73         AliHLTFloat32_t fY;  // Global Y coordinate of channel.
74         AliHLTFloat32_t fZ;  // Global Z coordinate of channel.
75 };
76
77 /**
78  * The lookup table structure for the AliHLTMUONTriggerReconstructor component.
79  * The LUT is used for translating from channel addresses to geometrical positions
80  * and other relevant information of the strips in the trigger chambers.
81  */
82 struct AliHLTMUONTriggerRecoLookupTable
83 {
84         // The dimentions of the LUT are as follows:
85         // [trigger crate ID][local board ID][chamber][cathode - X/Y][bit set in bit pattern]
86         // - The trigger crate ID comes form the regional headers in the DDL payload.
87         // - Local board ID numbers come from the local trigger structures in the
88         //   DDL payload.
89         // - The chamber is for chambers 11 to 14 coded as [0..3], 0 for chamber 11,
90         //   1 for chamber 12 etc.
91         // - The cathode 0 is for the X trigger strips (bending plane) and 1 is
92         //   for the Y strips (non-bending plane).
93         // - The "bit set in pattern" indicates the bit number that was set in
94         //   the strip patterns found in the local structures of the DDL payload.
95         AliHLTMUONTriggerRecoLutRow fRow[16][16][4][2][16];
96 };
97
98 } // extern "C"
99
100
101 /**
102  * The sign/charge of a particle.
103  */
104 enum AliHLTMUONParticleSign
105 {
106         kSignMinus   = -1,
107         kSignUnknown = 0,
108         kSignPlus    = 1
109 };
110
111 /**
112  * The chamber names of the dimuon spectrometer.
113  */
114 enum AliHLTMUONChamberName
115 {
116         kUnknownChamber = -1,
117         kChamber1 = 0,
118         kChamber2 = 1,
119         kChamber3 = 2,
120         kChamber4 = 3,
121         kChamber5 = 4,
122         kChamber6 = 5,
123         kChamber7 = 6,
124         kChamber8 = 7,
125         kChamber9 = 8,
126         kChamber10 = 9,
127         kChamber11 = 10,
128         kChamber12 = 11,
129         kChamber13 = 12,
130         kChamber14 = 13
131 };
132
133 /**
134  * The internal data block type codes.
135  */
136 enum AliHLTMUONDataBlockType
137 {
138         kUnknownDataBlock = 0,
139         kTriggerRecordsDataBlock = 1000,
140         kTrigRecsDebugDataBlock = 1001,
141         kRecHitsDataBlock = 2000,
142         kClustersDataBlock = 2001,
143         kChannelsDataBlock = 2002,
144         kMansoTracksDataBlock = 3000,
145         kMansoCandidatesDataBlock = 3001,
146         kTracksDataBlock = 3100,
147         kSinglesDecisionDataBlock = 4000,
148         kPairsDecisionDataBlock = 4001
149 };
150
151
152 /**
153  * Stream operator to be able to print AliHLTMUONParticleSign with human
154  * readable names to some stream object like cout (standard output).
155  */
156 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONParticleSign sign)
157 {
158         switch (sign)
159         {
160         case kSignMinus:   stream << "kSignMinus";   break;
161         case kSignUnknown: stream << "kSignUnknown"; break;
162         case kSignPlus:    stream << "kSignPlus";    break;
163         default:           stream << "INVALID";
164         }
165         return stream;
166 }
167
168 /**
169  * Stream operator to be able to print AliHLTMUONChamberName with human
170  * readable names to some stream object like cout (standard output).
171  */
172 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONChamberName chamber)
173 {
174         switch (chamber)
175         {
176         case kUnknownChamber:  stream << "kUnknownChamber";  break;
177         case kChamber1:        stream << "kChamber1";        break;
178         case kChamber2:        stream << "kChamber2";        break;
179         case kChamber3:        stream << "kChamber3";        break;
180         case kChamber4:        stream << "kChamber4";        break;
181         case kChamber5:        stream << "kChamber5";        break;
182         case kChamber6:        stream << "kChamber6";        break;
183         case kChamber7:        stream << "kChamber7";        break;
184         case kChamber8:        stream << "kChamber8";        break;
185         case kChamber9:        stream << "kChamber9";        break;
186         case kChamber10:       stream << "kChamber10";       break;
187         case kChamber11:       stream << "kChamber11";       break;
188         case kChamber12:       stream << "kChamber12";       break;
189         case kChamber13:       stream << "kChamber13";       break;
190         case kChamber14:       stream << "kChamber14";       break;
191         default:               stream << "INVALID";
192         }
193         return stream;
194 }
195
196 /**
197  * Stream operator to be able to print AliHLTMUONDataBlockType with human
198  * readable names to some stream object like cout (standard output).
199  */
200 inline std::ostream& operator << (std::ostream& stream, AliHLTMUONDataBlockType type)
201 {
202         switch (type)
203         {
204         case kUnknownDataBlock:         stream << "kUnknownDataBlock";         break;
205         case kTriggerRecordsDataBlock:  stream << "kTriggerRecordsDataBlock";  break;
206         case kTrigRecsDebugDataBlock:   stream << "kTrigRecsDebugDataBlock";   break;
207         case kRecHitsDataBlock:         stream << "kRecHitsDataBlock";         break;
208         case kClustersDataBlock:        stream << "kClustersDataBlock";        break;
209         case kChannelsDataBlock:        stream << "kChannelsDataBlock";        break;
210         case kMansoTracksDataBlock:     stream << "kMansoTracksDataBlock";     break;
211         case kMansoCandidatesDataBlock: stream << "kMansoCandidatesDataBlock"; break;
212         case kTracksDataBlock:          stream << "kTracksDataBlock";          break;
213         case kSinglesDecisionDataBlock: stream << "kSinglesDecisionDataBlock"; break;
214         case kPairsDecisionDataBlock:   stream << "kPairsDecisionDataBlock";   break;
215         default:                        stream << "INVALID";
216         }
217         return stream;
218 }
219
220 /**
221  * Stream operator for usage with std::ostream classes which prints the common
222  * data block header in the following format:
223  *  {fType = xx, fRecordWidth = yy, fNrecords = zz}
224  */
225 inline std::ostream& operator << (
226                 std::ostream& stream, const AliHLTMUONDataBlockHeader& header
227         )
228 {
229         stream  << "{fType = " << AliHLTMUONDataBlockType(header.fType)
230                 << ", fRecordWidth = " << header.fRecordWidth
231                 << ", fNrecords = " << header.fNrecords << "}";
232         return stream;
233 }
234
235
236 inline bool operator == (
237                 const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
238         )
239 {
240         return a.fType == b.fType and a.fRecordWidth == b.fRecordWidth
241                 and a.fNrecords == b.fNrecords;
242 }
243
244 inline bool operator != (
245                 const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
246         )
247 {
248         return not operator == (a, b);
249 }
250
251 #endif // ALIHLTMUONDATATYPES_H