CbmDefs.h

Go to the documentation of this file.

 
#ifndef CBMDEFS_H
#define CBMDEFS_H 1
 
#include <RtypesCore.h>  // for Double_t
 
#include <iostream>     // for ostream
#include <type_traits>  // for underlying_type
 
// Convert an element of enum class to its underlying intergral type
// since with C++11 the return type can't be deduced automatically it has
// to be put explicitely
// constexpr should result in a compile time evaluation of the function
// call where possible
// E.g. ToIntegralType(ECbmModuleId::KSts) should be evaluated at compile
// time and should not affect the run time performance at all
template<typename T>
constexpr auto ToIntegralType(T enumerator) ->
  typename std::underlying_type<T>::type {
  return static_cast<typename std::underlying_type<T>::type>(enumerator);
}
 
enum class ECbmModuleId {
  kRef        = 0,   
  kMvd        = 1,   
  kSts        = 2,   
  kRich       = 3,   
  kMuch       = 4,   
  kTrd        = 5,   
  kTof        = 6,   
  kEcal       = 7,   
  kPsd        = 8,   
  kHodo       = 9,   
  kDummyDet   = 10,  
  kT0         = 11,  
  kNofSystems = 12,  
  kMagnet     = 17,  
  kTarget     = 18,  
  kPipe       = 19,  
  kShield     = 20,  
  kPlatform   = 21,  
  kCave       = 22,  
  kLastModule = 23,  
  kNotExist   = -1   
};
 
// operator ++ for ECbmModuleId for convenient usage in loops
// This operator is tuned for ECbmModuleID. It takes into account non
// continuous values for the enum. Since the detectorID which is stored
// in the generated output has only 4 bit the maximum number of detectors
// can be 16 (0-15). To avoid that the enum class has to be changed again
// the values 11-15 are reserved for future detectors.
// The ids of the passive modules are only relevant at run time so they can
// be shifted easily
// The opeartor takes care about the non continuous values for the enum
// When it reaches the last detector it automatically continuous with the
// first passive module
ECbmModuleId& operator++(ECbmModuleId&);
 
// operator << for convenient output to std::ostream.
// Converts the enum value to a string which is put in the stream
std::ostream& operator<<(std::ostream&, const ECbmModuleId&);
 
 
enum class ECbmDataType {
  kUnknown  = -1,
  kMCTrack  = 0,
  kMvdPoint = ToIntegralType(ECbmModuleId::kMvd) * 100,
  kMvdDigi,
  kMvdCluster,
  kMvdHit,  // MVD
  kStsPoint = ToIntegralType(ECbmModuleId::kSts) * 100,
  kStsDigi,
  kStsCluster,
  kStsHit,
  kStsTrack,  // STS
  kRichPoint = ToIntegralType(ECbmModuleId::kRich) * 100,
  kRichDigi,
  kRichHit,
  kRichRing,  // RICH
  kMuchPoint = ToIntegralType(ECbmModuleId::kMuch) * 100,
  kMuchDigi,
  kMuchCluster,
  kMuchPixelHit,
  kMuchStrawHit,
  kMuchTrack,  // MUCH
  kTrdPoint = ToIntegralType(ECbmModuleId::kTrd) * 100,
  kTrdDigi,
  kTrdCluster,
  kTrdHit,
  kTrdTrack,  // TRD
  kTofPoint = ToIntegralType(ECbmModuleId::kTof) * 100,
  kTofDigi,
  kTofCalDigi,
  kTofHit,
  kTofTrack,  // TOF
  kPsdPoint = ToIntegralType(ECbmModuleId::kPsd) * 100,
  kPsdDigi,
  kPsdHit,  // PSD
  kT0Point = ToIntegralType(ECbmModuleId::kT0) * 100,
  kT0Digi,
  kT0CalDigi,
  kT0Hit,              // T0
  kGlobalTrack = 2000  // Global
};
 
// operator << for convenient output to std::ostream.
// Converts the enum value to a string which is put in the stream
std::ostream& operator<<(std::ostream&, const ECbmDataType&);
 
enum class ECbmTreeAccess { kRegular, kRepeat, kRandom };
 
 
inline Double_t CbmProtonMass() { return 0.938272046; }
inline Double_t CbmNeutronMass() { return 0.939565379; }
inline Double_t CbmElectronMass() { return 0.000510998928; }
 
#endif