CbmDefs.h

Go to the documentation of this file.

/* Copyright (C) 2017-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Florian Uhlig, Volker Friese [committer], Semen Lebedev */
 
#ifndef CBMDEFS_H
#define CBMDEFS_H 1
 
#include <iosfwd>  // for ostream
#include <string>
#include <type_traits>  // for underlying_type
 
#include <xpu/defines.h>  // for XPU_D
 
// 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>
XPU_D 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,  
  kBmon       = 11,  //< Bmon Counter
  kTrd2d      = 12,  
  kFsd        = 13,  
  kNofSystems = 14,  
  kMagnet     = 17,  
  kTarget     = 18,  
  kPipe       = 19,  
  kShield     = 20,  
                     //  kBmon       = 21,  ///< Bmon counter, hallo detector BMON
  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&);
 
// conversion functions between ECbmModuleId and std::string
std::string ToString(ECbmModuleId modId);
ECbmModuleId ToCbmModuleId(std::string modIdStr);
ECbmModuleId ToCbmModuleIdCaseInsensitive(std::string modIdStr);
 
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,
  kRichTrackParamZ,
  kRichTrackProjection,  // 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,
  kTofUHit,
  kTofTracklet,  // TOF
  kPsdPoint = ToIntegralType(ECbmModuleId::kPsd) * 100,
  kPsdDigi,
  kPsdHit,  // PSD
  kBmonPoint = ToIntegralType(ECbmModuleId::kBmon) * 100,
  kBmonDigi,
  kBmonCalDigi,
  kBmonHit,  // BMON
  kFsdPoint = ToIntegralType(ECbmModuleId::kFsd) * 100,
  kFsdDigi,
  kFsdHit,             // Fsd
  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
};
 
enum class ECbmRecoMode
{
  Timeslice,
  EventByEvent,
  Undefined
};
 
namespace cbm::algo::ca
{
  enum class EDetectorID
  {
    kMvd = 0,
    kSts,
    kMuch,
    kTrd,
    kTof,
    END
  };
 
  ECbmModuleId ToCbmModuleId(EDetectorID detID);
 
  EDetectorID ToCaDetectorID(ECbmModuleId modId);
 
}  // namespace cbm::algo::ca
 
 
inline double CbmProtonMass() { return 0.938272046; }
inline double CbmNeutronMass() { return 0.939565379; }
inline double CbmElectronMass() { return 0.000510998928; }
 
#endif