Line data Source code
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 6 : ClassImp(AliHLTMUONConstants);
41 :
42 :
43 : const AliHLTMUONTriggerRecordStruct& AliHLTMUONConstants::NilTriggerRecordStruct()
44 : {
45 : // Returns a nil trigger record structure.
46 0 : static const AliHLTMUONTriggerRecordStruct nilTriggerRecordStruct = {
47 : 0, 0, 0, 0, 0,
48 : {
49 0 : AliHLTMUONConstants::NilRecHitStruct(),
50 0 : AliHLTMUONConstants::NilRecHitStruct(),
51 0 : AliHLTMUONConstants::NilRecHitStruct(),
52 0 : AliHLTMUONConstants::NilRecHitStruct()
53 : }
54 : };
55 0 : 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 0 : 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 0 : 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 0 : return nilChannelStruct;
83 : }
84 :
85 :
86 : const AliHLTMUONClusterStruct& AliHLTMUONConstants::NilClusterStruct()
87 : {
88 : // Returns a nil tracking chamber cluster.
89 0 : static const AliHLTMUONClusterStruct nilClusterStruct = {
90 0 : 0, AliHLTMUONConstants::NilRecHitStruct(), 0, 0, 0, 0, 0
91 : };
92 0 : return nilClusterStruct;
93 : }
94 :
95 :
96 : const AliHLTMUONMansoTrackStruct& AliHLTMUONConstants::NilMansoTrackStruct()
97 : {
98 : // Returns a nil Manso track structure.
99 0 : static const AliHLTMUONMansoTrackStruct nilMansoTrackStruct = {
100 : 0, 0, 0, 0, 0, 0, 0,
101 : {
102 0 : AliHLTMUONConstants::NilRecHitStruct(),
103 0 : AliHLTMUONConstants::NilRecHitStruct(),
104 0 : AliHLTMUONConstants::NilRecHitStruct(),
105 0 : AliHLTMUONConstants::NilRecHitStruct()
106 : }
107 : };
108 0 : 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 0 : return nilMansoRoIStruct;
117 : }
118 :
119 :
120 : const AliHLTMUONMansoCandidateStruct& AliHLTMUONConstants::NilMansoCandidateStruct()
121 : {
122 : // Returns a nil Manso candidate track structure.
123 0 : static const AliHLTMUONMansoCandidateStruct nilMansoCandidateStruct = {
124 0 : AliHLTMUONConstants::NilMansoTrackStruct(),
125 : {
126 0 : AliHLTMUONConstants::NilMansoRoIStruct(),
127 0 : AliHLTMUONConstants::NilMansoRoIStruct(),
128 0 : AliHLTMUONConstants::NilMansoRoIStruct(),
129 0 : AliHLTMUONConstants::NilMansoRoIStruct()
130 : },
131 : 0, 0
132 : };
133 0 : return nilMansoCandidateStruct;
134 0 : }
135 :
136 :
137 : const AliHLTMUONTrackStruct& AliHLTMUONConstants::NilTrackStruct()
138 : {
139 : // Returns a nil track structure.
140 0 : static const AliHLTMUONTrackStruct nilTrackStruct = {
141 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
142 : {
143 0 : AliHLTMUONConstants::NilRecHitStruct(),
144 0 : AliHLTMUONConstants::NilRecHitStruct(),
145 0 : AliHLTMUONConstants::NilRecHitStruct(),
146 0 : AliHLTMUONConstants::NilRecHitStruct(),
147 0 : AliHLTMUONConstants::NilRecHitStruct(),
148 0 : AliHLTMUONConstants::NilRecHitStruct(),
149 0 : AliHLTMUONConstants::NilRecHitStruct(),
150 0 : AliHLTMUONConstants::NilRecHitStruct(),
151 0 : AliHLTMUONConstants::NilRecHitStruct(),
152 0 : AliHLTMUONConstants::NilRecHitStruct(),
153 0 : AliHLTMUONConstants::NilRecHitStruct(),
154 0 : AliHLTMUONConstants::NilRecHitStruct(),
155 0 : AliHLTMUONConstants::NilRecHitStruct(),
156 0 : AliHLTMUONConstants::NilRecHitStruct(),
157 0 : AliHLTMUONConstants::NilRecHitStruct(),
158 0 : AliHLTMUONConstants::NilRecHitStruct()
159 : }
160 : };
161 0 : 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 0 : 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 0 : return nilPairDecisionStruct;
178 : }
179 :
180 :
181 : const AliHLTComponentDataType& AliHLTMUONConstants::DDLRawDataType()
182 : {
183 : // Returns the raw data type for MUON DDLs.
184 0 : static const AliHLTComponentDataType ddlRawDataType = AliHLTComponentDataTypeInitializer(kAliHLTDataTypeDDLRaw.fID, kAliHLTDataOriginMUON);
185 0 : 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 0 : static const AliHLTComponentDataType triggerRecordsBlockDataType = AliHLTComponentDataTypeInitializer("TRIGRECS", kAliHLTDataOriginMUON);
193 0 : 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 0 : static const AliHLTComponentDataType trigRecsDebugBlockDataType = AliHLTComponentDataTypeInitializer("TRIGRDBG", kAliHLTDataOriginMUON);
201 0 : return trigRecsDebugBlockDataType;
202 : }
203 :
204 :
205 : const AliHLTComponentDataType& AliHLTMUONConstants::RecHitsBlockDataType()
206 : {
207 : // Returns a reconstructed hits block type generated by hit reconstruction components.
208 0 : static const AliHLTComponentDataType recHitsBlockDataType = AliHLTComponentDataTypeInitializer("RECHITS ", kAliHLTDataOriginMUON);
209 0 : return recHitsBlockDataType;
210 : }
211 :
212 :
213 : const AliHLTComponentDataType& AliHLTMUONConstants::ClusterBlockDataType()
214 : {
215 : // Returns a debugging information block type for reconstructed hit clusters.
216 0 : static const AliHLTComponentDataType clusterBlockDataType = AliHLTComponentDataTypeInitializer("CLUSTERS", kAliHLTDataOriginMUON);
217 0 : return clusterBlockDataType;
218 : }
219 :
220 :
221 : const AliHLTComponentDataType& AliHLTMUONConstants::ChannelBlockDataType()
222 : {
223 : // Returns a debugging information block type for channels corresponding to clusters.
224 0 : static const AliHLTComponentDataType channelBlockDataType = AliHLTComponentDataTypeInitializer("CHANNELS", kAliHLTDataOriginMUON);
225 0 : return channelBlockDataType;
226 : }
227 :
228 :
229 : const AliHLTComponentDataType& AliHLTMUONConstants::MansoTracksBlockDataType()
230 : {
231 : // Returns a Manso tracks block type generated by Manso tracker components.
232 0 : static const AliHLTComponentDataType mansoTracksBlockDataType = AliHLTComponentDataTypeInitializer("MANTRACK", kAliHLTDataOriginMUON);
233 0 : 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 0 : static const AliHLTComponentDataType mansoCandidatesBlockDataType = AliHLTComponentDataTypeInitializer("MNCANDID", kAliHLTDataOriginMUON);
241 0 : return mansoCandidatesBlockDataType;
242 : }
243 :
244 :
245 : const AliHLTComponentDataType& AliHLTMUONConstants::TracksBlockDataType()
246 : {
247 : // Returns a full tracks block type generated by the tracker components.
248 0 : static const AliHLTComponentDataType tracksBlockDataType = AliHLTComponentDataTypeInitializer("TRACKS ", kAliHLTDataOriginMUON);
249 0 : return tracksBlockDataType;
250 : }
251 :
252 :
253 : const AliHLTComponentDataType& AliHLTMUONConstants::SinglesDecisionBlockDataType()
254 : {
255 : // Returns a trigger decision block type for single track decisions.
256 0 : static const AliHLTComponentDataType singlesDecisionBlockDataType = AliHLTComponentDataTypeInitializer("DECIDSIN", kAliHLTDataOriginMUON);
257 0 : return singlesDecisionBlockDataType;
258 : }
259 :
260 :
261 : const AliHLTComponentDataType& AliHLTMUONConstants::PairsDecisionBlockDataType()
262 : {
263 : // Returns a trigger decision block type for pairs of particles.
264 0 : static const AliHLTComponentDataType pairsDecisionBlockDataType = AliHLTComponentDataTypeInitializer("DECIDPAR", kAliHLTDataOriginMUON);
265 0 : return pairsDecisionBlockDataType;
266 : }
267 :
268 :
269 : const AliHLTComponentDataType& AliHLTMUONConstants::RootifiedEventDataType()
270 : {
271 : // Returns an AliHLTMUONEvent ROOT object data type.
272 0 : static const AliHLTComponentDataType rootifiedEventDataType = AliHLTComponentDataTypeInitializer("ROOTEVNT", kAliHLTDataOriginMUON);
273 0 : return rootifiedEventDataType;
274 : }
275 :
276 :
277 : const AliHLTComponentDataType& AliHLTMUONConstants::ESDDataType()
278 : {
279 : // Returns the ESD data type with origin equal to MUON.
280 0 : static const AliHLTComponentDataType esdDataType = AliHLTComponentDataTypeInitializer(kAliHLTDataTypeESDObject.fID, kAliHLTDataOriginMUON);
281 0 : return esdDataType;
282 : }
283 :
284 :
285 : const AliHLTComponentDataType& AliHLTMUONConstants::ClusterStoreDataType()
286 : {
287 : // Returns the offline algorithm's cluster store object type.
288 0 : static const AliHLTComponentDataType clusterStoreDataType = AliHLTComponentDataTypeInitializer("CLUSTORE", kAliHLTDataOriginMUON);
289 0 : return clusterStoreDataType;
290 : }
291 :
292 :
293 : const AliHLTComponentDataType& AliHLTMUONConstants::HistogramDataType()
294 : {
295 : // Returns the TH1/2/3 histogram data type.
296 0 : static const AliHLTComponentDataType histogramDataType = AliHLTComponentDataTypeInitializer("ROOTHIST", kAliHLTDataOriginMUON);
297 0 : 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 252 : 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 246 : 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 0 : 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 240 : 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 222 : 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 228 : 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 216 : 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 210 : 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 204 : 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 198 : 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 234 : 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 192 : 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 186 : 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 180 : 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 174 : 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 168 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : return resolution;
481 : }
482 :
|
