]>
Commit | Line | Data |
---|---|---|
26a4668d | 1 | /************************************************************************** |
1d8ae082 | 2 | * This file is property of and copyright by the ALICE HLT Project * |
e6357f88 | 3 | * All rights reserved. * |
26a4668d | 4 | * * |
e6357f88 | 5 | * Primary Authors: * |
6 | * Indranil Das <indra.das@saha.ac.in> * | |
7 | * Artur Szostak <artursz@iafrica.com> * | |
26a4668d | 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 * | |
1d8ae082 | 14 | * about the suitability of this software for any purpose. It is * |
26a4668d | 15 | * provided "as is" without express or implied warranty. * |
16 | **************************************************************************/ | |
17 | ||
1d8ae082 | 18 | // $Id$ |
26a4668d | 19 | |
20 | /** | |
21 | * @file AliHLTMUONConstants.cxx | |
22 | * @author Indranil Das <indra.das@saha.ac.in>, | |
23 | * Artur Szostak <artursz@iafrica.com> | |
4d76a068 | 24 | * @date 17 May 2007 |
26a4668d | 25 | * @brief Definitions of the various dimuon HLT constants. |
26 | */ | |
27 | ||
28 | #include "AliHLTMUONConstants.h" | |
b12fe461 | 29 | #include "AliHLTMUONTriggerRecordsBlockStruct.h" |
30 | #include "AliHLTMUONTrigRecsDebugBlockStruct.h" | |
b12fe461 | 31 | #include "AliHLTMUONRecHitsBlockStruct.h" |
32 | #include "AliHLTMUONClustersBlockStruct.h" | |
33 | #include "AliHLTMUONChannelsBlockStruct.h" | |
34 | #include "AliHLTMUONMansoTracksBlockStruct.h" | |
35 | #include "AliHLTMUONMansoCandidatesBlockStruct.h" | |
a8982f78 | 36 | #include "AliHLTMUONTracksBlockStruct.h" |
b12fe461 | 37 | #include "AliHLTMUONSinglesDecisionBlockStruct.h" |
38 | #include "AliHLTMUONPairsDecisionBlockStruct.h" | |
26a4668d | 39 | |
33b1e2f2 | 40 | ClassImp(AliHLTMUONConstants); |
910807dd | 41 | |
bfd48318 | 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 |