Adding output data type of rootifier component to the constants class.
[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONConstants.h
1 #ifndef ALIHLTMUONCONSTANTS_H
2 #define ALIHLTMUONCONSTANTS_H
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * All rights reserved.                                                   *
6  *                                                                        *
7  * Primary Authors:                                                       *
8  *   Indranil Das <indra.das@saha.ac.in>                                  *
9  *   Artur Szostak <artursz@iafrica.com>                                  *
10  *                                                                        *
11  * Permission to use, copy, modify and distribute this software and its   *
12  * documentation strictly for non-commercial purposes is hereby granted   *
13  * without fee, provided that the above copyright notice appears in all   *
14  * copies and that both the copyright notice and this permission notice   *
15  * appear in the supporting documentation. The authors make no claims     *
16  * about the suitability of this software for any purpose. It is          * 
17  * provided "as is" without express or implied warranty.                  *
18  **************************************************************************/
19
20 /* $Id$ */
21
22 /**
23  * @file   AliHLTMUONConstants.h
24  * @author Indranil Das <indra.das@saha.ac.in>,
25  *         Artur Szostak <artursz@iafrica.com>
26  * @date   
27  * @brief  Class containing various dimuon HLT constants used in the system.
28  */
29
30 #include "TObject.h"
31
32 // Forward declare structures.
33 extern "C" {
34 struct AliHLTComponentDataType;
35 struct AliHLTMUONTriggerRecordStruct;
36 struct AliHLTMUONTrigRecInfoStruct;
37 struct AliHLTMUONRecHitStruct;
38 struct AliHLTMUONChannelStruct;
39 struct AliHLTMUONClusterStruct;
40 struct AliHLTMUONMansoTrackStruct;
41 struct AliHLTMUONMansoRoIStruct;
42 struct AliHLTMUONMansoCandidateStruct;
43 struct AliHLTMUONTrackDecisionStruct;
44 struct AliHLTMUONPairDecisionStruct;
45 } // extern "C"
46
47 /**
48  * AliHLTMUONConstants contains a list of global dimuon HLT specific constants
49  * and constant structures used in the system.
50  * Static methods are provided to access these values.
51  */
52 class AliHLTMUONConstants
53 {
54 public:
55
56         static const AliHLTMUONTriggerRecordStruct& NilTriggerRecordStruct()
57         {
58                 return fgkNilTriggerRecordStruct;
59         }
60
61         static const AliHLTMUONTrigRecInfoStruct& NilTrigRecInfoStruct()
62         {
63                 return fgkNilTrigRecInfoStruct;
64         }
65
66         static const AliHLTMUONRecHitStruct& NilRecHitStruct()
67         {
68                 return fgkNilRecHitStruct;
69         }
70
71         static const AliHLTMUONChannelStruct& NilChannelStruct()
72         {
73                 return fgkNilChannelStruct;
74         }
75
76         static const AliHLTMUONClusterStruct& NilClusterStruct()
77         {
78                 return fgkNilClusterStruct;
79         }
80
81         static const AliHLTMUONMansoTrackStruct& NilMansoTrackStruct()
82         {
83                 return fgkNilMansoTrackStruct;
84         }
85
86         static const AliHLTMUONMansoRoIStruct& NilMansoRoIStruct()
87         {
88                 return fgkNilMansoRoIStruct;
89         }
90
91         static const AliHLTMUONMansoCandidateStruct& NilMansoCandidateStruct()
92         {
93                 return fgkNilMansoCandidateStruct;
94         }
95
96         static const AliHLTMUONTrackDecisionStruct& NilTrackDecisionStruct()
97         {
98                 return fgkNilTrackDecisionStruct;
99         }
100
101         static const AliHLTMUONPairDecisionStruct& NilPairDecisionStruct()
102         {
103                 return fgkNilPairDecisionStruct;
104         }
105
106         // Returns the raw data type for MUON DDLs. To figure out if the DDL format
107         // will be for a tracking DDL or trigger DDL one needs to also check the
108         // sepcification word of the input data block. If one of the first 20 least
109         // significant bits are set then it is a tracker DDL otherwise if it is
110         // the 21st or 22nd bit then it is from the muon trigger.
111         static const AliHLTComponentDataType& DDLRawDataType()
112         {
113                 return fgkDDLRawDataType;
114         }
115
116         static const AliHLTComponentDataType& TriggerRecordsBlockDataType()
117         {
118                 return fgkTriggerRecordsBlockDataType;
119         }
120
121         static const AliHLTComponentDataType& TrigRecsDebugBlockDataType()
122         {
123                 return fgkTrigRecsDebugBlockDataType;
124         }
125
126         static const AliHLTComponentDataType& RecHitsBlockDataType()
127         {
128                 return fgkRecHitsBlockDataType;
129         }
130
131         static const AliHLTComponentDataType& ClusterBlockDataType()
132         {
133                 return fgkClusterBlockDataType;
134         }
135
136         static const AliHLTComponentDataType& ChannelBlockDataType()
137         {
138                 return fgkChannelBlockDataType;
139         }
140
141         static const AliHLTComponentDataType& MansoTracksBlockDataType()
142         {
143                 return fgkMansoTracksBlockDataType;
144         }
145
146         static const AliHLTComponentDataType& MansoCandidatesBlockDataType()
147         {
148                 return fgkMansoCandidatesBlockDataType;
149         }
150
151         static const AliHLTComponentDataType& SinglesDecisionBlockDataType()
152         {
153                 return fgkSinglesDecisionBlockDataType;
154         }
155
156         static const AliHLTComponentDataType& PairsDecisionBlockDataType()
157         {
158                 return fgkPairsDecisionBlockDataType;
159         }
160
161         static const AliHLTComponentDataType& RootifiedEventDataType()
162         {
163                 return fgkRootifiedEventDataType;
164         }
165
166         static const AliHLTComponentDataType& ESDDataType()
167         {
168                 return fgkESDDataType;
169         }
170
171         static const AliHLTComponentDataType& ClusterStoreDataType()
172         {
173                 return fgkClusterStoreDataType;
174         }
175
176         static const AliHLTComponentDataType& HistogramDataType()
177         {
178                 return fgkHistogramDataType;
179         }
180         
181         static const char* RecHitsSourceId()
182         {
183                 return fgkRecHitsSourceId;
184         }
185         
186         static const char* TriggerRecordsSourceId()
187         {
188                 return fgkTriggerRecordsSourceId;
189         }
190         
191         static const char* TracksSourceId()
192         {
193                 return fgkTracksSourceId;
194         }
195         
196         static const char* DigitPublisherId()
197         {
198                 return fgkDigitPublisherId;
199         }
200         
201         static const char* TriggerReconstructorId()
202         {
203                 return fgkTriggerReconstructorId;
204         }
205         
206         static const char* HitReconstructorId()
207         {
208                 return fgkHitReconstructorId;
209         }
210         
211         static const char* MansoTrackerFSMId()
212         {
213                 return fgkMansoTrackerFSMId;
214         }
215         
216         static const char* DecisionComponentId()
217         {
218                 return fgkDecisionComponentId;
219         }
220         
221         static const char* ESDMakerId()
222         {
223                 return fgkESDMakerId;
224         }
225         
226         static const char* RootifierComponentId()
227         {
228                 return fgkRootifierComponentId;
229         }
230         
231         static const char* EmptyEventFilterComponentId()
232         {
233                 return fgkEmptyEventFilterComponentId;
234         }
235         
236         static const char* DataCheckerComponentId()
237         {
238                 return fgkDataCheckerComponentId;
239         }
240         
241         static const char* ClusterFinderId()
242         {
243                 return fgkClusterFinderId;
244         }
245         
246         static const char* RawDataHistogrammerId()
247         {
248                 return fgkRawDataHistogrammerId;
249         }
250         
251         static const char* TriggerReconstructorCDBPath()
252         {
253                 return fgkTriggerReconstructorCDBPath;
254         }
255         
256         static const char* HitReconstructorCDBPath()
257         {
258                 return fgkHitReconstructorCDBPath;
259         }
260         
261         static const char* MansoTrackerFSMCDBPath()
262         {
263                 return fgkMansoTrackerFSMCDBPath;
264         }
265         
266         static const char* DecisionComponentCDBPath()
267         {
268                 return fgkDecisionComponentCDBPath;
269         }
270         
271         static double DefaultNonBendingReso() { return 0.01; }
272         
273         static double DefaultBendingReso() { return 0.144; }
274
275 private:
276
277         // Should never have to create, destroy or copy this object.
278         AliHLTMUONConstants() {}
279         AliHLTMUONConstants(const AliHLTMUONConstants& obj);
280         virtual ~AliHLTMUONConstants() {}
281         AliHLTMUONConstants& operator = (const AliHLTMUONConstants& obj);
282         
283         
284         // The following are null/nil structures that can also be used as sentinels:
285         static const AliHLTMUONTriggerRecordStruct fgkNilTriggerRecordStruct; // Nil trigger record.
286         static const AliHLTMUONTrigRecInfoStruct fgkNilTrigRecInfoStruct; // Nil trigger record debug information.
287         static const AliHLTMUONRecHitStruct fgkNilRecHitStruct; // Nil reconstructed hit.
288         static const AliHLTMUONChannelStruct fgkNilChannelStruct; // Nil tracking chamber channel.
289         static const AliHLTMUONClusterStruct fgkNilClusterStruct; // Nil tracking chamber cluster.
290         static const AliHLTMUONMansoTrackStruct fgkNilMansoTrackStruct; // Nil manso track.
291         static const AliHLTMUONMansoRoIStruct fgkNilMansoRoIStruct; // Nil manso region of interest.
292         static const AliHLTMUONMansoCandidateStruct fgkNilMansoCandidateStruct; // Nil manso candidate track.
293         static const AliHLTMUONTrackDecisionStruct fgkNilTrackDecisionStruct; // Nil decision for single track.
294         static const AliHLTMUONPairDecisionStruct fgkNilPairDecisionStruct; // Nil decision for track pair.
295
296         // HLT component input and output data block types:
297         static const AliHLTComponentDataType fgkDDLRawDataType; // DDL packed data block type from dimuon spectrometer.
298         static const AliHLTComponentDataType fgkTriggerRecordsBlockDataType; // Trigger records block type generated by trigger DDL translation components.
299         static const AliHLTComponentDataType fgkTrigRecsDebugBlockDataType; // Debugging information block type generated by trigger DDL translation components.
300         static const AliHLTComponentDataType fgkRecHitsBlockDataType; // Reconstructed hits block type generated by hit reconstruction components.
301         static const AliHLTComponentDataType fgkClusterBlockDataType; // Debugging information block type for reconstructed hit clusters.
302         static const AliHLTComponentDataType fgkChannelBlockDataType; // Debugging information block type for channels corresponding to clusters.
303         static const AliHLTComponentDataType fgkMansoTracksBlockDataType; // Manso tracks block type generated by Manso tracker components.
304         static const AliHLTComponentDataType fgkMansoCandidatesBlockDataType; // Debugging information about a track candidate generated by the Manso algorithm.
305         static const AliHLTComponentDataType fgkSinglesDecisionBlockDataType; // Trigger decision block type for single track decisions.
306         static const AliHLTComponentDataType fgkPairsDecisionBlockDataType; // Trigger decision block type for pairs of particles.
307         static const AliHLTComponentDataType fgkRootifiedEventDataType; // An AliHLTMUONEvent ROOT object.
308         static const AliHLTComponentDataType fgkESDDataType; // The ESD data type with origin equal to MUON.
309         static const AliHLTComponentDataType fgkClusterStoreDataType; // Offline algorithm cluster store object.
310         static const AliHLTComponentDataType fgkHistogramDataType; // TH1/2/3 histogram type.
311         
312         // Component ID names:
313         static const char* fgkRecHitsSourceId; // Name of source component for reconstructed hits for debugging.
314         static const char* fgkTriggerRecordsSourceId; // Name of source component for trigger records for debugging.
315         static const char* fgkTracksSourceId; // Name of source component for tracks for debugging.
316         static const char* fgkDigitPublisherId; // Component name for publishing DDL streams from digits.
317         static const char* fgkTriggerReconstructorId; // Trigger record reconstructor component name.
318         static const char* fgkHitReconstructorId; // Centre of gravity cluster finder component name.
319         static const char* fgkMansoTrackerFSMId; // Manso tracker FSM implementation component name.
320         static const char* fgkDecisionComponentId; // dHLT decision component name.
321         static const char* fgkESDMakerId; // Name of ESD maker component which converts dHLT data to AliESDEvent classes.
322         static const char* fgkRootifierComponentId; // The name of the event filter debugging component.
323         static const char* fgkEmptyEventFilterComponentId; // The name of the event filter debugging component.
324         static const char* fgkDataCheckerComponentId; // Name of data checking component for debugging.
325         static const char* fgkClusterFinderId; // Name of cluster finder implementing offline algorithms.
326         static const char* fgkRawDataHistogrammerId; // Raw data histogrammer component name.
327         
328         // CDB path entries to configuration information.
329         static const char* fgkTriggerReconstructorCDBPath; // Path to CDB entry for the trigger reconstruction component.
330         static const char* fgkHitReconstructorCDBPath; // Path to CDB entry for the hit reconstruction component.
331         static const char* fgkMansoTrackerFSMCDBPath; // Path to CDB entry for the Manso FSM tracker component.
332         static const char* fgkDecisionComponentCDBPath; // Path to CDB entry for trigger decision component.
333         
334         ClassDef(AliHLTMUONConstants, 0);  // Interface class to dHLT constants.
335 };
336
337 #endif // ALIHLTMUONCONSTANTS_H