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   17 May 2007
  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 AliHLTMUONTrackStruct;
  44 struct AliHLTMUONTrackDecisionStruct;
  45 struct AliHLTMUONPairDecisionStruct;
  46 } // extern "C"
  47
  48 /**
  49  * AliHLTMUONConstants contains a list of global dimuon HLT specific constants
  50  * and constant structures used in the system.
  51  * Static methods are provided to access these values.
  52  */
  53 class AliHLTMUONConstants
  54 {
  55 public:
  56
  57         static const AliHLTMUONTriggerRecordStruct& NilTriggerRecordStruct()
  58         {
  59                 return fgkNilTriggerRecordStruct;
  60         }
  61
  62         static const AliHLTMUONTrigRecInfoStruct& NilTrigRecInfoStruct()
  63         {
  64                 return fgkNilTrigRecInfoStruct;
  65         }
  66
  67         static const AliHLTMUONRecHitStruct& NilRecHitStruct()
  68         {
  69                 return fgkNilRecHitStruct;
  70         }
  71
  72         static const AliHLTMUONChannelStruct& NilChannelStruct()
  73         {
  74                 return fgkNilChannelStruct;
  75         }
  76
  77         static const AliHLTMUONClusterStruct& NilClusterStruct()
  78         {
  79                 return fgkNilClusterStruct;
  80         }
  81
  82         static const AliHLTMUONMansoTrackStruct& NilMansoTrackStruct()
  83         {
  84                 return fgkNilMansoTrackStruct;
  85         }
  86
  87         static const AliHLTMUONMansoRoIStruct& NilMansoRoIStruct()
  88         {
  89                 return fgkNilMansoRoIStruct;
  90         }
  91
  92         static const AliHLTMUONMansoCandidateStruct& NilMansoCandidateStruct()
  93         {
  94                 return fgkNilMansoCandidateStruct;
  95         }
  96
  97         static const AliHLTMUONTrackStruct& NilTrackStruct()
  98         {
  99                 return fgkNilTrackStruct;
 100         }
 101
 102         static const AliHLTMUONTrackDecisionStruct& NilTrackDecisionStruct()
 103         {
 104                 return fgkNilTrackDecisionStruct;
 105         }
 106
 107         static const AliHLTMUONPairDecisionStruct& NilPairDecisionStruct()
 108         {
 109                 return fgkNilPairDecisionStruct;
 110         }
 111
 112         // Returns the raw data type for MUON DDLs. To figure out if the DDL format
 113         // will be for a tracking DDL or trigger DDL one needs to also check the
 114         // sepcification word of the input data block. If one of the first 20 least
 115         // significant bits are set then it is a tracker DDL otherwise if it is
 116         // the 21st or 22nd bit then it is from the muon trigger.
 117         static const AliHLTComponentDataType& DDLRawDataType()
 118         {
 119                 return fgkDDLRawDataType;
 120         }
 121
 122         static const AliHLTComponentDataType& TriggerRecordsBlockDataType()
 123         {
 124                 return fgkTriggerRecordsBlockDataType;
 125         }
 126
 127         static const AliHLTComponentDataType& TrigRecsDebugBlockDataType()
 128         {
 129                 return fgkTrigRecsDebugBlockDataType;
 130         }
 131
 132         static const AliHLTComponentDataType& RecHitsBlockDataType()
 133         {
 134                 return fgkRecHitsBlockDataType;
 135         }
 136
 137         static const AliHLTComponentDataType& ClusterBlockDataType()
 138         {
 139                 return fgkClusterBlockDataType;
 140         }
 141
 142         static const AliHLTComponentDataType& ChannelBlockDataType()
 143         {
 144                 return fgkChannelBlockDataType;
 145         }
 146
 147         static const AliHLTComponentDataType& MansoTracksBlockDataType()
 148         {
 149                 return fgkMansoTracksBlockDataType;
 150         }
 151
 152         static const AliHLTComponentDataType& MansoCandidatesBlockDataType()
 153         {
 154                 return fgkMansoCandidatesBlockDataType;
 155         }
 156
 157         static const AliHLTComponentDataType& TracksBlockDataType()
 158         {
 159                 return fgkTracksBlockDataType;
 160         }
 161
 162         static const AliHLTComponentDataType& SinglesDecisionBlockDataType()
 163         {
 164                 return fgkSinglesDecisionBlockDataType;
 165         }
 166
 167         static const AliHLTComponentDataType& PairsDecisionBlockDataType()
 168         {
 169                 return fgkPairsDecisionBlockDataType;
 170         }
 171
 172         static const AliHLTComponentDataType& RootifiedEventDataType()
 173         {
 174                 return fgkRootifiedEventDataType;
 175         }
 176
 177         static const AliHLTComponentDataType& ESDDataType()
 178         {
 179                 return fgkESDDataType;
 180         }
 181
 182         static const AliHLTComponentDataType& ClusterStoreDataType()
 183         {
 184                 return fgkClusterStoreDataType;
 185         }
 186
 187         static const AliHLTComponentDataType& HistogramDataType()
 188         {
 189                 return fgkHistogramDataType;
 190         }
 191
 192         static const char* RecHitsSourceId()
 193         {
 194                 return fgkRecHitsSourceId;
 195         }
 196
 197         static const char* TriggerRecordsSourceId()
 198         {
 199                 return fgkTriggerRecordsSourceId;
 200         }
 201
 202         static const char* TracksSourceId()
 203         {
 204                 return fgkTracksSourceId;
 205         }
 206
 207         static const char* DigitPublisherId()
 208         {
 209                 return fgkDigitPublisherId;
 210         }
 211
 212         static const char* TriggerReconstructorId()
 213         {
 214                 return fgkTriggerReconstructorId;
 215         }
 216
 217         static const char* HitReconstructorId()
 218         {
 219                 return fgkHitReconstructorId;
 220         }
 221
 222         static const char* MansoTrackerFSMId()
 223         {
 224                 return fgkMansoTrackerFSMId;
 225         }
 226
 227         static const char* FullTrackerId()
 228         {
 229                 return fgkFullTrackerId;
 230         }
 231
 232         static const char* DecisionComponentId()
 233         {
 234                 return fgkDecisionComponentId;
 235         }
 236
 237         static const char* ESDMakerId()
 238         {
 239                 return fgkESDMakerId;
 240         }
 241
 242         static const char* RootifierComponentId()
 243         {
 244                 return fgkRootifierComponentId;
 245         }
 246
 247         static const char* EmptyEventFilterComponentId()
 248         {
 249                 return fgkEmptyEventFilterComponentId;
 250         }
 251
 252         static const char* DataCheckerComponentId()
 253         {
 254                 return fgkDataCheckerComponentId;
 255         }
 256
 257         static const char* ClusterFinderId()
 258         {
 259                 return fgkClusterFinderId;
 260         }
 261
 262         static const char* RawDataHistogrammerId()
 263         {
 264                 return fgkRawDataHistogrammerId;
 265         }
 266
 267         static const char* ClusterHistogrammerId()
 268         {
 269                 return fgkClusterHistogrammerId;
 270         }
 271
 272         static const char* TriggerReconstructorCDBPath()
 273         {
 274                 return fgkTriggerReconstructorCDBPath;
 275         }
 276
 277         static const char* HitReconstructorCDBPath()
 278         {
 279                 return fgkHitReconstructorCDBPath;
 280         }
 281
 282         static const char* MansoTrackerFSMCDBPath()
 283         {
 284                 return fgkMansoTrackerFSMCDBPath;
 285         }
 286
 287         static const char* DecisionComponentCDBPath()
 288         {
 289                 return fgkDecisionComponentCDBPath;
 290         }
 291
 292         static const char* FieldIntegralsCDBPath()
 293         {
 294                 return fgkFieldIntegralsCDBPath;
 295         }
 296
 297         /// Returns the typical X (non-bending plane) resolution of the hit reconstruction (units = cm).
 298         static double DefaultNonBendingReso() { return 0.144; }
 299
 300         /// Returns the typical Y (bending plane) resolution of the hit reconstruction (units = cm).
 301         static double DefaultBendingReso() { return 0.01; }
 302
 303 private:
 304
 305         // Should never have to create, destroy or copy this object.
 306         AliHLTMUONConstants() {}
 307         AliHLTMUONConstants(const AliHLTMUONConstants& obj);
 308         virtual ~AliHLTMUONConstants() {}
 309         AliHLTMUONConstants& operator = (const AliHLTMUONConstants& obj);
 310
 311
 312         // The following are null/nil structures that can also be used as sentinels:
 313         static const AliHLTMUONTriggerRecordStruct fgkNilTriggerRecordStruct; // Nil trigger record.
 314         static const AliHLTMUONTrigRecInfoStruct fgkNilTrigRecInfoStruct; // Nil trigger record debug information.
 315         static const AliHLTMUONRecHitStruct fgkNilRecHitStruct; // Nil reconstructed hit.
 316         static const AliHLTMUONChannelStruct fgkNilChannelStruct; // Nil tracking chamber channel.
 317         static const AliHLTMUONClusterStruct fgkNilClusterStruct; // Nil tracking chamber cluster.
 318         static const AliHLTMUONMansoTrackStruct fgkNilMansoTrackStruct; // Nil manso track.
 319         static const AliHLTMUONMansoRoIStruct fgkNilMansoRoIStruct; // Nil manso region of interest.
 320         static const AliHLTMUONMansoCandidateStruct fgkNilMansoCandidateStruct; // Nil manso candidate track.
 321         static const AliHLTMUONTrackStruct fgkNilTrackStruct; // Nil track structure.
 322         static const AliHLTMUONTrackDecisionStruct fgkNilTrackDecisionStruct; // Nil decision for single track.
 323         static const AliHLTMUONPairDecisionStruct fgkNilPairDecisionStruct; // Nil decision for track pair.
 324
 325         // HLT component input and output data block types:
 326         static const AliHLTComponentDataType fgkDDLRawDataType; // DDL packed data block type from dimuon spectrometer.
 327         static const AliHLTComponentDataType fgkTriggerRecordsBlockDataType; // Trigger records block type generated by trigger DDL translation components.
 328         static const AliHLTComponentDataType fgkTrigRecsDebugBlockDataType; // Debugging information block type generated by trigger DDL translation components.
 329         static const AliHLTComponentDataType fgkRecHitsBlockDataType; // Reconstructed hits block type generated by hit reconstruction components.
 330         static const AliHLTComponentDataType fgkClusterBlockDataType; // Debugging information block type for reconstructed hit clusters.
 331         static const AliHLTComponentDataType fgkChannelBlockDataType; // Debugging information block type for channels corresponding to clusters.
 332         static const AliHLTComponentDataType fgkMansoTracksBlockDataType; // Manso tracks block type generated by Manso tracker components.
 333         static const AliHLTComponentDataType fgkMansoCandidatesBlockDataType; // Debugging information about a track candidate generated by the Manso algorithm.
 334         static const AliHLTComponentDataType fgkTracksBlockDataType; // Full tracks block type generated by the tracker components.
 335         static const AliHLTComponentDataType fgkSinglesDecisionBlockDataType; // Trigger decision block type for single track decisions.
 336         static const AliHLTComponentDataType fgkPairsDecisionBlockDataType; // Trigger decision block type for pairs of particles.
 337         static const AliHLTComponentDataType fgkRootifiedEventDataType; // An AliHLTMUONEvent ROOT object.
 338         static const AliHLTComponentDataType fgkESDDataType; // The ESD data type with origin equal to MUON.
 339         static const AliHLTComponentDataType fgkClusterStoreDataType; // Offline algorithm cluster store object.
 340         static const AliHLTComponentDataType fgkHistogramDataType; // TH1/2/3 histogram type.
 341
 342         // Component ID names:
 343         static const char* fgkRecHitsSourceId; // Name of source component for reconstructed hits for debugging.
 344         static const char* fgkTriggerRecordsSourceId; // Name of source component for trigger records for debugging.
 345         static const char* fgkTracksSourceId; // Name of source component for tracks for debugging.
 346         static const char* fgkDigitPublisherId; // Component name for publishing DDL streams from digits.
 347         static const char* fgkTriggerReconstructorId; // Trigger record reconstructor component name.
 348         static const char* fgkHitReconstructorId; // Centre of gravity cluster finder component name.
 349         static const char* fgkMansoTrackerFSMId; // Manso tracker FSM implementation component name.
 350         static const char* fgkFullTrackerId; // Full tracker implementation component name.
 351         static const char* fgkDecisionComponentId; // dHLT decision component name.
 352         static const char* fgkESDMakerId; // Name of ESD maker component which converts dHLT data to AliESDEvent classes.
 353         static const char* fgkRootifierComponentId; // The name of the event filter debugging component.
 354         static const char* fgkEmptyEventFilterComponentId; // The name of the event filter debugging component.
 355         static const char* fgkDataCheckerComponentId; // Name of data checking component for debugging.
 356         static const char* fgkClusterFinderId; // Name of cluster finder implementing offline algorithms.
 357         static const char* fgkRawDataHistogrammerId; // Raw data histogrammer component name.
 358         static const char* fgkClusterHistogrammerId; // Cluster data histogrammer component name.
 359
 360         // CDB path entries to configuration information.
 361         static const char* fgkTriggerReconstructorCDBPath; // Path to CDB entry for the trigger reconstruction component.
 362         static const char* fgkHitReconstructorCDBPath; // Path to CDB entry for the hit reconstruction component.
 363         static const char* fgkMansoTrackerFSMCDBPath; // Path to CDB entry for the Manso FSM tracker component.
 364         static const char* fgkDecisionComponentCDBPath; // Path to CDB entry for trigger decision component.
 365         static const char* fgkFieldIntegralsCDBPath; // Path to CDB entry for magnetic field integrals.
 366
 367         ClassDef(AliHLTMUONConstants, 0);  // Interface class to dHLT constants.
 368 };
 369
 370 #endif // ALIHLTMUONCONSTANTS_H