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