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& ESDDataType()
 162         {
 163                 return fgkESDDataType;
 164         }
 165
 166         static const AliHLTComponentDataType& ClusterStoreDataType()
 167         {
 168                 return fgkClusterStoreDataType;
 169         }
 170
 171         static const AliHLTComponentDataType& HistogramDataType()
 172         {
 173                 return fgkHistogramDataType;
 174         }
 175
 176         static const char* RecHitsSourceId()
 177         {
 178                 return fgkRecHitsSourceId;
 179         }
 180
 181         static const char* TriggerRecordsSourceId()
 182         {
 183                 return fgkTriggerRecordsSourceId;
 184         }
 185
 186         static const char* TracksSourceId()
 187         {
 188                 return fgkTracksSourceId;
 189         }
 190
 191         static const char* DigitPublisherId()
 192         {
 193                 return fgkDigitPublisherId;
 194         }
 195
 196         static const char* TriggerReconstructorId()
 197         {
 198                 return fgkTriggerReconstructorId;
 199         }
 200
 201         static const char* HitReconstructorId()
 202         {
 203                 return fgkHitReconstructorId;
 204         }
 205
 206         static const char* MansoTrackerFSMId()
 207         {
 208                 return fgkMansoTrackerFSMId;
 209         }
 210
 211         static const char* DecisionComponentId()
 212         {
 213                 return fgkDecisionComponentId;
 214         }
 215
 216         static const char* ESDMakerId()
 217         {
 218                 return fgkESDMakerId;
 219         }
 220
 221         static const char* RootifierComponentId()
 222         {
 223                 return fgkRootifierComponentId;
 224         }
 225
 226         static const char* EmptyEventFilterComponentId()
 227         {
 228                 return fgkEmptyEventFilterComponentId;
 229         }
 230
 231         static const char* DataCheckerComponentId()
 232         {
 233                 return fgkDataCheckerComponentId;
 234         }
 235
 236         static const char* ClusterFinderId()
 237         {
 238                 return fgkClusterFinderId;
 239         }
 240
 241         static const char* RawDataHistogrammerId()
 242         {
 243                 return fgkRawDataHistogrammerId;
 244         }
 245
 246         static const char* TriggerReconstructorCDBPath()
 247         {
 248                 return fgkTriggerReconstructorCDBPath;
 249         }
 250
 251         static const char* HitReconstructorCDBPath()
 252         {
 253                 return fgkHitReconstructorCDBPath;
 254         }
 255
 256         static const char* MansoTrackerFSMCDBPath()
 257         {
 258                 return fgkMansoTrackerFSMCDBPath;
 259         }
 260
 261         static const char* DecisionComponentCDBPath()
 262         {
 263                 return fgkDecisionComponentCDBPath;
 264         }
 265
 266         static double DefaultNonBendingReso() { return 0.01; }
 267
 268         static double DefaultBendingReso() { return 0.144; }
 269
 270 private:
 271
 272         // Should never have to create, destroy or copy this object.
 273         AliHLTMUONConstants() {}
 274         AliHLTMUONConstants(const AliHLTMUONConstants& obj);
 275         virtual ~AliHLTMUONConstants() {}
 276         AliHLTMUONConstants& operator = (const AliHLTMUONConstants& obj);
 277
 278
 279         // The following are null/nil structures that can also be used as sentinels:
 280         static const AliHLTMUONTriggerRecordStruct fgkNilTriggerRecordStruct; // Nil trigger record.
 281         static const AliHLTMUONTrigRecInfoStruct fgkNilTrigRecInfoStruct; // Nil trigger record debug information.
 282         static const AliHLTMUONRecHitStruct fgkNilRecHitStruct; // Nil reconstructed hit.
 283         static const AliHLTMUONChannelStruct fgkNilChannelStruct; // Nil tracking chamber channel.
 284         static const AliHLTMUONClusterStruct fgkNilClusterStruct; // Nil tracking chamber cluster.
 285         static const AliHLTMUONMansoTrackStruct fgkNilMansoTrackStruct; // Nil manso track.
 286         static const AliHLTMUONMansoRoIStruct fgkNilMansoRoIStruct; // Nil manso region of interest.
 287         static const AliHLTMUONMansoCandidateStruct fgkNilMansoCandidateStruct; // Nil manso candidate track.
 288         static const AliHLTMUONTrackDecisionStruct fgkNilTrackDecisionStruct; // Nil decision for single track.
 289         static const AliHLTMUONPairDecisionStruct fgkNilPairDecisionStruct; // Nil decision for track pair.
 290
 291         // HLT component input and output data block types:
 292         static const AliHLTComponentDataType fgkDDLRawDataType; // DDL packed data block type from dimuon spectrometer.
 293         static const AliHLTComponentDataType fgkTriggerRecordsBlockDataType; // Trigger records block type generated by trigger DDL translation components.
 294         static const AliHLTComponentDataType fgkTrigRecsDebugBlockDataType; // Debugging information block type generated by trigger DDL translation components.
 295         static const AliHLTComponentDataType fgkRecHitsBlockDataType; // Reconstructed hits block type generated by hit reconstruction components.
 296         static const AliHLTComponentDataType fgkClusterBlockDataType; // Debugging information block type for reconstructed hit clusters.
 297         static const AliHLTComponentDataType fgkChannelBlockDataType; // Debugging information block type for channels corresponding to clusters.
 298         static const AliHLTComponentDataType fgkMansoTracksBlockDataType; // Manso tracks block type generated by Manso tracker components.
 299         static const AliHLTComponentDataType fgkMansoCandidatesBlockDataType; // Debugging information about a track candidate generated by the Manso algorithm.
 300         static const AliHLTComponentDataType fgkSinglesDecisionBlockDataType; // Trigger decision block type for single track decisions.
 301         static const AliHLTComponentDataType fgkPairsDecisionBlockDataType; // Trigger decision block type for pairs of particles.
 302         static const AliHLTComponentDataType fgkESDDataType; // The ESD data type with origin equal to MUON.
 303         static const AliHLTComponentDataType fgkClusterStoreDataType; // Offline algorithm cluster store object.
 304         static const AliHLTComponentDataType fgkHistogramDataType; // TH1/2/3 histogram type.
 305
 306         // Component ID names:
 307         static const char* fgkRecHitsSourceId; // Name of source component for reconstructed hits for debugging.
 308         static const char* fgkTriggerRecordsSourceId; // Name of source component for trigger records for debugging.
 309         static const char* fgkTracksSourceId; // Name of source component for tracks for debugging.
 310         static const char* fgkDigitPublisherId; // Component name for publishing DDL streams from digits.
 311         static const char* fgkTriggerReconstructorId; // Trigger record reconstructor component name.
 312         static const char* fgkHitReconstructorId; // Centre of gravity cluster finder component name.
 313         static const char* fgkMansoTrackerFSMId; // Manso tracker FSM implementation component name.
 314         static const char* fgkDecisionComponentId; // dHLT decision component name.
 315         static const char* fgkESDMakerId; // Name of ESD maker component which converts dHLT data to AliESDEvent classes.
 316         static const char* fgkRootifierComponentId; // The name of the event filter debugging component.
 317         static const char* fgkEmptyEventFilterComponentId; // The name of the event filter debugging component.
 318         static const char* fgkDataCheckerComponentId; // Name of data checking component for debugging.
 319         static const char* fgkClusterFinderId; // Name of cluster finder implementing offline algorithms.
 320         static const char* fgkRawDataHistogrammerId; // Raw data histogrammer component name.
 321
 322         // CDB path entries to configuration information.
 323         static const char* fgkTriggerReconstructorCDBPath; // Path to CDB entry for the trigger reconstruction component.
 324         static const char* fgkHitReconstructorCDBPath; // Path to CDB entry for the hit reconstruction component.
 325         static const char* fgkMansoTrackerFSMCDBPath; // Path to CDB entry for the Manso FSM tracker component.
 326         static const char* fgkDecisionComponentCDBPath; // Path to CDB entry for trigger decision component.
 327
 328         ClassDef(AliHLTMUONConstants, 0);  // Interface class to dHLT constants.
 329 };
 330
 331 #endif // ALIHLTMUONCONSTANTS_H