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 // Forward declare structures.
  31 extern "C" {
  32 struct AliHLTComponentDataType;
  33 struct AliHLTMUONTriggerRecordStruct;
  34 struct AliHLTMUONTrigRecInfoStruct;
  35 struct AliHLTMUONRecHitStruct;
  36 struct AliHLTMUONChannelStruct;
  37 struct AliHLTMUONClusterStruct;
  38 struct AliHLTMUONMansoTrackStruct;
  39 struct AliHLTMUONMansoRoIStruct;
  40 struct AliHLTMUONMansoCandidateStruct;
  41 struct AliHLTMUONTrackDecisionStruct;
  42 struct AliHLTMUONPairDecisionStruct;
  43 } // extern "C"
  44
  45 /**
  46  * AliHLTMUONConstants contains a list of global dimuon HLT specific constants
  47  * and constant structures used in the system.
  48  * Static methods are provided to access these values.
  49  */
  50 class AliHLTMUONConstants
  51 {
  52 public:
  53
  54         static const AliHLTMUONTriggerRecordStruct& NilTriggerRecordStruct()
  55         {
  56                 return fgkNilTriggerRecordStruct;
  57         }
  58
  59         static const AliHLTMUONTrigRecInfoStruct& NilTrigRecInfoStruct()
  60         {
  61                 return fgkNilTrigRecInfoStruct;
  62         }
  63
  64         static const AliHLTMUONRecHitStruct& NilRecHitStruct()
  65         {
  66                 return fgkNilRecHitStruct;
  67         }
  68
  69         static const AliHLTMUONChannelStruct& NilChannelStruct()
  70         {
  71                 return fgkNilChannelStruct;
  72         }
  73
  74         static const AliHLTMUONClusterStruct& NilClusterStruct()
  75         {
  76                 return fgkNilClusterStruct;
  77         }
  78
  79         static const AliHLTMUONMansoTrackStruct& NilMansoTrackStruct()
  80         {
  81                 return fgkNilMansoTrackStruct;
  82         }
  83
  84         static const AliHLTMUONMansoRoIStruct& NilMansoRoIStruct()
  85         {
  86                 return fgkNilMansoRoIStruct;
  87         }
  88
  89         static const AliHLTMUONMansoCandidateStruct& NilMansoCandidateStruct()
  90         {
  91                 return fgkNilMansoCandidateStruct;
  92         }
  93
  94         static const AliHLTMUONTrackDecisionStruct& NilTrackDecisionStruct()
  95         {
  96                 return fgkNilTrackDecisionStruct;
  97         }
  98
  99         static const AliHLTMUONPairDecisionStruct& NilPairDecisionStruct()
 100         {
 101                 return fgkNilPairDecisionStruct;
 102         }
 103
 104         // Returns the raw data type for MUON DDLs. To figure out if the DDL format
 105         // will be for a tracking DDL or trigger DDL one needs to also check the
 106         // sepcification word of the input data block. If one of the first 20 least
 107         // significant bits are set then it is a tracker DDL otherwise if it is
 108         // the 21st or 22nd bit then it is from the muon trigger.
 109         static const AliHLTComponentDataType& DDLRawDataType()
 110         {
 111                 return fgkDDLRawDataType;
 112         }
 113
 114         static const AliHLTComponentDataType& TriggerRecordsBlockDataType()
 115         {
 116                 return fgkTriggerRecordsBlockDataType;
 117         }
 118
 119         static const AliHLTComponentDataType& TrigRecsDebugBlockDataType()
 120         {
 121                 return fgkTrigRecsDebugBlockDataType;
 122         }
 123
 124         static const AliHLTComponentDataType& RecHitsBlockDataType()
 125         {
 126                 return fgkRecHitsBlockDataType;
 127         }
 128
 129         static const AliHLTComponentDataType& ClusterBlockDataType()
 130         {
 131                 return fgkClusterBlockDataType;
 132         }
 133
 134         static const AliHLTComponentDataType& ChannelBlockDataType()
 135         {
 136                 return fgkChannelBlockDataType;
 137         }
 138
 139         static const AliHLTComponentDataType& MansoTracksBlockDataType()
 140         {
 141                 return fgkMansoTracksBlockDataType;
 142         }
 143
 144         static const AliHLTComponentDataType& MansoCandidatesBlockDataType()
 145         {
 146                 return fgkMansoCandidatesBlockDataType;
 147         }
 148
 149         static const AliHLTComponentDataType& SinglesDecisionBlockDataType()
 150         {
 151                 return fgkSinglesDecisionBlockDataType;
 152         }
 153
 154         static const AliHLTComponentDataType& PairsDecisionBlockDataType()
 155         {
 156                 return fgkPairsDecisionBlockDataType;
 157         }
 158
 159         static const char* RecHitsSourceId()
 160         {
 161                 return fgkRecHitsSourceId;
 162         }
 163
 164         static const char* TriggerRecordsSourceId()
 165         {
 166                 return fgkTriggerRecordsSourceId;
 167         }
 168
 169         static const char* TracksSourceId()
 170         {
 171                 return fgkTracksSourceId;
 172         }
 173
 174         static const char* DigitPublisherId()
 175         {
 176                 return fgkDigitPublisherId;
 177         }
 178
 179         static const char* TriggerReconstructorId()
 180         {
 181                 return fgkTriggerReconstructorId;
 182         }
 183
 184         static const char* HitReconstructorId()
 185         {
 186                 return fgkHitReconstructorId;
 187         }
 188
 189         static const char* MansoTrackerFSMId()
 190         {
 191                 return fgkMansoTrackerFSMId;
 192         }
 193
 194         static const char* DecisionComponentId()
 195         {
 196                 return fgkDecisionComponentId;
 197         }
 198
 199         static const char* RootifierComponentId()
 200         {
 201                 return fgkRootifierComponentId;
 202         }
 203
 204         static const char* EmptyEventFilterComponentId()
 205         {
 206                 return fgkEmptyEventFilterComponentId;
 207         }
 208
 209         static const char* DataCheckerComponentId()
 210         {
 211                 return fgkDataCheckerComponentId;
 212         }
 213
 214         static const char* HitReconstructorCDBPath()
 215         {
 216                 return fgkHitReconstructorCDBPath;
 217         }
 218
 219         static const char* MansoTrackerFSMCDBPath()
 220         {
 221                 return fgkMansoTrackerFSMCDBPath;
 222         }
 223
 224         static const char* DecisionComponentCDBPath()
 225         {
 226                 return fgkDecisionComponentCDBPath;
 227         }
 228
 229 private:
 230
 231         // Should never have to create, destroy or copy this object.
 232         AliHLTMUONConstants();
 233         AliHLTMUONConstants(const AliHLTMUONConstants& obj);
 234         ~AliHLTMUONConstants();
 235         AliHLTMUONConstants& operator = (const AliHLTMUONConstants& obj);
 236
 237         // The following are null/nil structures that can also be used as sentinels:
 238         static const AliHLTMUONTriggerRecordStruct fgkNilTriggerRecordStruct; // Nil trigger record.
 239         static const AliHLTMUONTrigRecInfoStruct fgkNilTrigRecInfoStruct; // Nil trigger record debug information.
 240         static const AliHLTMUONRecHitStruct fgkNilRecHitStruct; // Nil reconstructed hit.
 241         static const AliHLTMUONChannelStruct fgkNilChannelStruct; // Nil tracking chamber channel.
 242         static const AliHLTMUONClusterStruct fgkNilClusterStruct; // Nil tracking chamber cluster.
 243         static const AliHLTMUONMansoTrackStruct fgkNilMansoTrackStruct; // Nil manso track.
 244         static const AliHLTMUONMansoRoIStruct fgkNilMansoRoIStruct; // Nil manso region of interest.
 245         static const AliHLTMUONMansoCandidateStruct fgkNilMansoCandidateStruct; // Nil manso candidate track.
 246         static const AliHLTMUONTrackDecisionStruct fgkNilTrackDecisionStruct; // Nil decision for single track.
 247         static const AliHLTMUONPairDecisionStruct fgkNilPairDecisionStruct; // Nil decision for track pair.
 248
 249         // HLT component input and output data block types:
 250         static const AliHLTComponentDataType fgkDDLRawDataType; // DDL packed data block type from dimuon spectrometer.
 251         static const AliHLTComponentDataType fgkTriggerRecordsBlockDataType; // Trigger records block type generated by trigger DDL translation components.
 252         static const AliHLTComponentDataType fgkTrigRecsDebugBlockDataType; // Debugging information block type generated by trigger DDL translation components.
 253         static const AliHLTComponentDataType fgkRecHitsBlockDataType; // Reconstructed hits block type generated by hit reconstruction components.
 254         static const AliHLTComponentDataType fgkClusterBlockDataType; // Debugging information block type for reconstructed hit clusters.
 255         static const AliHLTComponentDataType fgkChannelBlockDataType; // Debugging information block type for channels corresponding to clusters.
 256         static const AliHLTComponentDataType fgkMansoTracksBlockDataType; // Manso tracks block type generated by Manso tracker components.
 257         static const AliHLTComponentDataType fgkMansoCandidatesBlockDataType; // Debugging information about a track candidate generated by the Manso algorithm.
 258         static const AliHLTComponentDataType fgkSinglesDecisionBlockDataType; // Trigger decision block type for single track decisions.
 259         static const AliHLTComponentDataType fgkPairsDecisionBlockDataType; // Trigger decision block type for pairs of particles.
 260
 261         // Component ID names:
 262         static const char* fgkRecHitsSourceId; // Name of source component for reconstructed hits for debugging.
 263         static const char* fgkTriggerRecordsSourceId; // Name of source component for trigger records for debugging.
 264         static const char* fgkTracksSourceId; // Name of source component for tracks for debugging.
 265         static const char* fgkDigitPublisherId; // Component name for publishing DDL streams from digits.
 266         static const char* fgkTriggerReconstructorId; // Trigger record reconstructor component name.
 267         static const char* fgkHitReconstructorId; // Centre of gravity cluster finder component name.
 268         static const char* fgkMansoTrackerFSMId; // Manso tracker FSM implementation component name.
 269         static const char* fgkDecisionComponentId; // dHLT decision component name.
 270         static const char* fgkRootifierComponentId; // The name of the event filter debugging component.
 271         static const char* fgkEmptyEventFilterComponentId; // The name of the event filter debugging component.
 272         static const char* fgkDataCheckerComponentId; // Name of data checking component for debugging.
 273
 274         // CDB path entries to configuration information.
 275         static const char* fgkHitReconstructorCDBPath; // Path to CDB entry for the hit reconstruction component.
 276         static const char* fgkMansoTrackerFSMCDBPath; // Path to CDB entry for the Manso FSM tracker component.
 277         static const char* fgkDecisionComponentCDBPath; // Path to CDB entry for trigger decision component.
 278 };
 279
 280 #endif // ALIHLTMUONCONSTANTS_H