ALIROOT-5433 Transition to CDHv3 in HLT
[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONConstants.cxx
1 /**************************************************************************
2  * This file is property of and copyright by the ALICE HLT Project        *
3  * All rights reserved.                                                   *
4  *                                                                        *
5  * Primary Authors:                                                       *
6  *   Indranil Das <indra.das@saha.ac.in>                                  *
7  *   Artur Szostak <artursz@iafrica.com>                                  *
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   AliHLTMUONConstants.cxx
22  * @author Indranil Das <indra.das@saha.ac.in>,
23  *         Artur Szostak <artursz@iafrica.com>
24  * @date   17 May 2007
25  * @brief  Definitions of the various dimuon HLT constants.
26  */
27
28 #include "AliHLTMUONConstants.h"
29 #include "AliHLTMUONTriggerRecordsBlockStruct.h"
30 #include "AliHLTMUONTrigRecsDebugBlockStruct.h"
31 #include "AliHLTMUONRecHitsBlockStruct.h"
32 #include "AliHLTMUONClustersBlockStruct.h"
33 #include "AliHLTMUONChannelsBlockStruct.h"
34 #include "AliHLTMUONMansoTracksBlockStruct.h"
35 #include "AliHLTMUONMansoCandidatesBlockStruct.h"
36 #include "AliHLTMUONTracksBlockStruct.h"
37 #include "AliHLTMUONSinglesDecisionBlockStruct.h"
38 #include "AliHLTMUONPairsDecisionBlockStruct.h"
39
40 ClassImp(AliHLTMUONConstants);
41
42
43 const AliHLTMUONTriggerRecordStruct& AliHLTMUONConstants::NilTriggerRecordStruct()
44 {
45         // Returns a nil trigger record structure.
46         static const AliHLTMUONTriggerRecordStruct nilTriggerRecordStruct = {
47                 0, 0, 0, 0, 0,
48                 {
49                         AliHLTMUONConstants::NilRecHitStruct(),
50                         AliHLTMUONConstants::NilRecHitStruct(),
51                         AliHLTMUONConstants::NilRecHitStruct(),
52                         AliHLTMUONConstants::NilRecHitStruct()
53                 }
54         };
55         return nilTriggerRecordStruct;
56 }
57
58
59 const AliHLTMUONTrigRecInfoStruct& AliHLTMUONConstants::NilTrigRecInfoStruct()
60 {
61         // Returns a nil trigger record debug information structure.
62         static const AliHLTMUONTrigRecInfoStruct nilTrigRecInfoStruct = {
63                 0, {0, 0, 0, 0}, 0, 0,
64                 {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}
65         };
66         return nilTrigRecInfoStruct;
67 }
68
69
70 const AliHLTMUONRecHitStruct& AliHLTMUONConstants::NilRecHitStruct()
71 {
72         // Returns a nil reconstructed hit structure.
73         static const AliHLTMUONRecHitStruct nilRecHitStruct = {0, 0, 0, 0};
74         return nilRecHitStruct;
75 }
76
77
78 const AliHLTMUONChannelStruct& AliHLTMUONConstants::NilChannelStruct()
79 {
80         // Returns a nil tracking chamber channel structure.
81         static const AliHLTMUONChannelStruct nilChannelStruct = {0, 0, 0, 0, 0, 0};
82         return nilChannelStruct;
83 }
84
85
86 const AliHLTMUONClusterStruct& AliHLTMUONConstants::NilClusterStruct()
87 {
88         // Returns a nil tracking chamber cluster.
89         static const AliHLTMUONClusterStruct nilClusterStruct = {
90                 0, AliHLTMUONConstants::NilRecHitStruct(), 0, 0, 0, 0, 0
91         };
92         return nilClusterStruct;
93 }
94
95
96 const AliHLTMUONMansoTrackStruct& AliHLTMUONConstants::NilMansoTrackStruct()
97 {
98         // Returns a nil Manso track structure.
99         static const AliHLTMUONMansoTrackStruct nilMansoTrackStruct = {
100                 0, 0, 0, 0, 0, 0, 0,
101                 {
102                         AliHLTMUONConstants::NilRecHitStruct(),
103                         AliHLTMUONConstants::NilRecHitStruct(),
104                         AliHLTMUONConstants::NilRecHitStruct(),
105                         AliHLTMUONConstants::NilRecHitStruct()
106                 }
107         };
108         return nilMansoTrackStruct;
109 }
110
111
112 const AliHLTMUONMansoRoIStruct& AliHLTMUONConstants::NilMansoRoIStruct()
113 {
114         // Returns a nil Manso region of interest structure.
115         static const AliHLTMUONMansoRoIStruct nilMansoRoIStruct = {0, 0, 0, 0};
116         return nilMansoRoIStruct;
117 }
118
119
120 const AliHLTMUONMansoCandidateStruct& AliHLTMUONConstants::NilMansoCandidateStruct()
121 {
122         // Returns a nil Manso candidate track structure.
123         static const AliHLTMUONMansoCandidateStruct nilMansoCandidateStruct = {
124                 AliHLTMUONConstants::NilMansoTrackStruct(),
125                 {
126                         AliHLTMUONConstants::NilMansoRoIStruct(),
127                         AliHLTMUONConstants::NilMansoRoIStruct(),
128                         AliHLTMUONConstants::NilMansoRoIStruct(),
129                         AliHLTMUONConstants::NilMansoRoIStruct()
130                 },
131                 0, 0
132         };
133         return nilMansoCandidateStruct;
134 }
135
136
137 const AliHLTMUONTrackStruct& AliHLTMUONConstants::NilTrackStruct()
138 {
139         // Returns a nil track structure.
140         static const AliHLTMUONTrackStruct nilTrackStruct = {
141                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
142                 {
143                         AliHLTMUONConstants::NilRecHitStruct(),
144                         AliHLTMUONConstants::NilRecHitStruct(),
145                         AliHLTMUONConstants::NilRecHitStruct(),
146                         AliHLTMUONConstants::NilRecHitStruct(),
147                         AliHLTMUONConstants::NilRecHitStruct(),
148                         AliHLTMUONConstants::NilRecHitStruct(),
149                         AliHLTMUONConstants::NilRecHitStruct(),
150                         AliHLTMUONConstants::NilRecHitStruct(),
151                         AliHLTMUONConstants::NilRecHitStruct(),
152                         AliHLTMUONConstants::NilRecHitStruct(),
153                         AliHLTMUONConstants::NilRecHitStruct(),
154                         AliHLTMUONConstants::NilRecHitStruct(),
155                         AliHLTMUONConstants::NilRecHitStruct(),
156                         AliHLTMUONConstants::NilRecHitStruct(),
157                         AliHLTMUONConstants::NilRecHitStruct(),
158                         AliHLTMUONConstants::NilRecHitStruct()
159                 }
160         };
161         return nilTrackStruct;
162 }
163
164
165 const AliHLTMUONTrackDecisionStruct& AliHLTMUONConstants::NilTrackDecisionStruct()
166 {
167         // Returns a nil decision structure for single track.
168         static const AliHLTMUONTrackDecisionStruct nilTrackDecisionStruct = {0, 0, 0};
169         return nilTrackDecisionStruct;
170 }
171
172
173 const AliHLTMUONPairDecisionStruct& AliHLTMUONConstants::NilPairDecisionStruct()
174 {
175         // Returns a nil decision structure for track pair.
176         static const AliHLTMUONPairDecisionStruct nilPairDecisionStruct = {0, 0, 0, 0};
177         return nilPairDecisionStruct;
178 }
179
180
181 const AliHLTComponentDataType& AliHLTMUONConstants::DDLRawDataType()
182 {
183         // Returns the raw data type for MUON DDLs.
184         static const AliHLTComponentDataType ddlRawDataType = AliHLTComponentDataTypeInitializer(kAliHLTDataTypeDDLRaw.fID, kAliHLTDataOriginMUON);
185         return ddlRawDataType;
186 }
187
188
189 const AliHLTComponentDataType& AliHLTMUONConstants::TriggerRecordsBlockDataType()
190 {
191         // Returns a trigger records block type generated by trigger DDL translation components.
192         static const AliHLTComponentDataType triggerRecordsBlockDataType = AliHLTComponentDataTypeInitializer("TRIGRECS", kAliHLTDataOriginMUON);
193         return triggerRecordsBlockDataType;
194 }
195
196
197 const AliHLTComponentDataType& AliHLTMUONConstants::TrigRecsDebugBlockDataType()
198 {
199         // Returns a debugging information block type generated by trigger DDL translation components.
200         static const AliHLTComponentDataType trigRecsDebugBlockDataType = AliHLTComponentDataTypeInitializer("TRIGRDBG", kAliHLTDataOriginMUON);
201         return trigRecsDebugBlockDataType;
202 }
203
204
205 const AliHLTComponentDataType& AliHLTMUONConstants::RecHitsBlockDataType()
206 {
207         // Returns a reconstructed hits block type generated by hit reconstruction components.
208         static const AliHLTComponentDataType recHitsBlockDataType = AliHLTComponentDataTypeInitializer("RECHITS ", kAliHLTDataOriginMUON);
209         return recHitsBlockDataType;
210 }
211
212
213 const AliHLTComponentDataType& AliHLTMUONConstants::ClusterBlockDataType()
214 {
215         // Returns a debugging information block type for reconstructed hit clusters.
216         static const AliHLTComponentDataType clusterBlockDataType = AliHLTComponentDataTypeInitializer("CLUSTERS", kAliHLTDataOriginMUON);
217         return clusterBlockDataType;
218 }
219
220
221 const AliHLTComponentDataType& AliHLTMUONConstants::ChannelBlockDataType()
222 {
223         // Returns a debugging information block type for channels corresponding to clusters.
224         static const AliHLTComponentDataType channelBlockDataType = AliHLTComponentDataTypeInitializer("CHANNELS", kAliHLTDataOriginMUON);
225         return channelBlockDataType;
226 }
227
228
229 const AliHLTComponentDataType& AliHLTMUONConstants::MansoTracksBlockDataType()
230 {
231         // Returns a Manso tracks block type generated by Manso tracker components.
232         static const AliHLTComponentDataType mansoTracksBlockDataType = AliHLTComponentDataTypeInitializer("MANTRACK", kAliHLTDataOriginMUON);
233         return mansoTracksBlockDataType;
234 }
235
236
237 const AliHLTComponentDataType& AliHLTMUONConstants::MansoCandidatesBlockDataType()
238 {
239         // Returns a data type for debugging information data blocks about track candidates generated by the Manso algorithm.
240         static const AliHLTComponentDataType mansoCandidatesBlockDataType = AliHLTComponentDataTypeInitializer("MNCANDID", kAliHLTDataOriginMUON);
241         return mansoCandidatesBlockDataType;
242 }
243
244
245 const AliHLTComponentDataType& AliHLTMUONConstants::TracksBlockDataType()
246 {
247         // Returns a full tracks block type generated by the tracker components.
248         static const AliHLTComponentDataType tracksBlockDataType = AliHLTComponentDataTypeInitializer("TRACKS  ", kAliHLTDataOriginMUON);
249         return tracksBlockDataType;
250 }
251
252
253 const AliHLTComponentDataType& AliHLTMUONConstants::SinglesDecisionBlockDataType()
254 {
255         // Returns a trigger decision block type for single track decisions.
256         static const AliHLTComponentDataType singlesDecisionBlockDataType = AliHLTComponentDataTypeInitializer("DECIDSIN", kAliHLTDataOriginMUON);
257         return singlesDecisionBlockDataType;
258 }
259
260
261 const AliHLTComponentDataType& AliHLTMUONConstants::PairsDecisionBlockDataType()
262 {
263         // Returns a trigger decision block type for pairs of particles.
264         static const AliHLTComponentDataType pairsDecisionBlockDataType = AliHLTComponentDataTypeInitializer("DECIDPAR", kAliHLTDataOriginMUON);
265         return pairsDecisionBlockDataType;
266 }
267
268
269 const AliHLTComponentDataType& AliHLTMUONConstants::RootifiedEventDataType()
270 {
271         // Returns an AliHLTMUONEvent ROOT object data type.
272         static const AliHLTComponentDataType rootifiedEventDataType = AliHLTComponentDataTypeInitializer("ROOTEVNT", kAliHLTDataOriginMUON);
273         return rootifiedEventDataType;
274 }
275
276
277 const AliHLTComponentDataType& AliHLTMUONConstants::ESDDataType()
278 {
279         // Returns the ESD data type with origin equal to MUON.
280         static const AliHLTComponentDataType esdDataType = AliHLTComponentDataTypeInitializer(kAliHLTDataTypeESDObject.fID, kAliHLTDataOriginMUON);
281         return esdDataType;
282 }
283
284
285 const AliHLTComponentDataType& AliHLTMUONConstants::ClusterStoreDataType()
286 {
287         // Returns the offline algorithm's cluster store object type.
288         static const AliHLTComponentDataType clusterStoreDataType = AliHLTComponentDataTypeInitializer("CLUSTORE", kAliHLTDataOriginMUON);
289         return clusterStoreDataType;
290 }
291
292
293 const AliHLTComponentDataType& AliHLTMUONConstants::HistogramDataType()
294 {
295         // Returns the TH1/2/3 histogram data type.
296         static const AliHLTComponentDataType histogramDataType = AliHLTComponentDataTypeInitializer("ROOTHIST", kAliHLTDataOriginMUON);
297         return histogramDataType;
298 }
299
300
301 const char* AliHLTMUONConstants::RecHitsSourceId()
302 {
303         // Returns the name of source component for reconstructed hits for debugging.
304         static const char* recHitsSourceId = "MUONRecHitsSource";
305         return recHitsSourceId;
306 }
307
308
309 const char* AliHLTMUONConstants::TriggerRecordsSourceId()
310 {
311         // Returns the name of source component for trigger records for debugging.
312         static const char* triggerRecordsSourceId = "MUONTriggerRecordsSource";
313         return triggerRecordsSourceId;
314 }
315
316
317 const char* AliHLTMUONConstants::TracksSourceId()
318 {
319         // Returns the name of source component for tracks for debugging.
320         static const char* tracksSourceId = "MUONTracksSource";
321         return tracksSourceId;
322 }
323
324
325 const char* AliHLTMUONConstants::DigitPublisherId()
326 {
327         // Returns the component name for publishing DDL streams from digits.
328         static const char* digitPublisherId = "MUONDigitPublisher";
329         return digitPublisherId;
330 }
331
332 const char* AliHLTMUONConstants::TriggerReconstructorId()
333 {
334         // Returns the trigger record reconstructor component name.
335         static const char* triggerReconstructorId = "MUONTriggerReconstructor";
336         return triggerReconstructorId;
337 }
338
339
340 const char* AliHLTMUONConstants::HitReconstructorId()
341 {
342         // Returns the centre of gravity cluster finder component name.
343         static const char* hitReconstructorId = "MUONHitReconstructor";
344         return hitReconstructorId;
345 }
346
347
348 const char* AliHLTMUONConstants::MansoTrackerFSMId()
349 {
350         // Returns the Manso tracker FSM implementation component name.
351         static const char* mansoTrackerFSMId = "MUONMansoTrackerFSM";
352         return mansoTrackerFSMId;
353 }
354
355
356 const char* AliHLTMUONConstants::FullTrackerId()
357 {
358         // Returns the full tracker implementation component name.
359         static const char* fullTrackerId = "MUONFullTracker";
360         return fullTrackerId;
361 }
362
363
364 const char* AliHLTMUONConstants::DecisionComponentId()
365 {
366         // Returns the dHLT decision component name.
367         static const char* decisionComponentId = "MUONDecisionComponent";
368         return decisionComponentId;
369 }
370
371
372 const char* AliHLTMUONConstants::ESDMakerId()
373 {
374         // Returns the name of ESD maker component which converts dHLT data to AliESDEvent classes. 
375         static const char* esdMakerId = "MUONESDMaker";
376         return esdMakerId;
377 }
378
379
380 const char* AliHLTMUONConstants::RootifierComponentId()
381 {
382         // Returns the name of the event filter debugging component.
383         static const char* rootifierComponentId = "MUONRootifier";
384         return rootifierComponentId;
385 }
386
387
388 const char* AliHLTMUONConstants::EmptyEventFilterComponentId()
389 {
390         // Returns the name of the event filter debugging component.
391         static const char* emptyEventFilterComponentId = "MUONEmptyEventFilter";
392         return emptyEventFilterComponentId;
393 }
394
395
396 const char* AliHLTMUONConstants::DataCheckerComponentId()
397 {
398         // Returns the name of data checking component for debugging.
399         static const char* dataCheckerComponentId = "MUONDataChecker";
400         return dataCheckerComponentId;
401 }
402
403
404 const char* AliHLTMUONConstants::ClusterFinderId()
405 {
406         // Returns the name of cluster finder implementing offline algorithms.
407         static const char* clusterFinderId = "MUONClusterFinder";
408         return clusterFinderId;
409 }
410
411
412 const char* AliHLTMUONConstants::RawDataHistogrammerId()
413 {
414         // Returns the raw data histogrammer component name.
415         static const char* rawDataHistogrammerId = "MUONRawDataHistogrammer";
416         return rawDataHistogrammerId;
417 }
418
419
420 const char* AliHLTMUONConstants::ClusterHistogrammerId()
421 {
422         // Returns the cluster data histogrammer component name.
423         static const char* clusterHistogrammerId = "MUONClusterHistogrammer";
424         return clusterHistogrammerId;
425 }
426
427
428 const char* AliHLTMUONConstants::TriggerReconstructorCDBPath()
429 {
430         // Returns the path to the CDB entry for the trigger reconstruction component.
431         static const char* triggerReconstructorCDBPath = "HLT/ConfigMUON/TriggerReconstructor";
432         return triggerReconstructorCDBPath;
433 }
434
435
436 const char* AliHLTMUONConstants::HitReconstructorCDBPath()
437 {
438         // Returns the path to the CDB entry for the hit reconstruction component.
439         static const char* hitReconstructorCDBPath = "HLT/ConfigMUON/HitReconstructor";
440         return hitReconstructorCDBPath;
441 }
442
443
444 const char* AliHLTMUONConstants::MansoTrackerFSMCDBPath()
445 {
446         // Returns the path to the CDB entry for the Manso FSM tracker component.
447         static const char* mansoTrackerFSMCDBPath = "HLT/ConfigMUON/MansoTrackerFSM";
448         return mansoTrackerFSMCDBPath;
449 }
450
451
452 const char* AliHLTMUONConstants::DecisionComponentCDBPath()
453 {
454         // Returns the path to the CDB entry for trigger decision component.
455         static const char* decisionComponentCDBPath = "HLT/ConfigMUON/DecisionComponent";
456         return decisionComponentCDBPath;
457 }
458
459
460 const char* AliHLTMUONConstants::FieldIntegralsCDBPath()
461 {
462         // Returns the path to the CDB entry for magnetic field integrals.
463         static const char* fieldIntegralsCDBPath = "HLT/ConfigMUON/FieldIntegrals";
464         return fieldIntegralsCDBPath;
465 }
466
467
468 double AliHLTMUONConstants::DefaultNonBendingReso()
469 {
470         // Returns the typical X (non-bending plane) resolution of the hit reconstruction (units = cm).
471         static const double resolution = 0.144;
472         return resolution;
473 }
474
475
476 double AliHLTMUONConstants::DefaultBendingReso()
477 {
478         // Returns the typical Y (bending plane) resolution of the hit reconstruction (units = cm).
479         static const double resolution = 0.01;
480         return resolution;
481 }
482