Const.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/FrameworkExceptions.h>
 
#include <TObject.h>
 
#include <cstddef>
#include <stdexcept>
#include <string>
 
class TDatabasePDG;
class TParticlePDG;
 
namespace Belle2 {

  class Const {
 
  public:

    enum EDetector {
      invalidDetector = 0x0,
      PXD = 0x1,
      SVD = 0x2,
      CDC = 0x3,
      TOP = 0x4,
      ARICH = 0x5,
      ECL = 0x6,
      KLM = 0x7,
      BKLM = 0x100 + KLM,
      EKLM = 0x200 + KLM,
      IR = 0x8,
      TRG = 0x9,
      DAQ = 0xA,
      BEAST = 0xB,
      TEST = 0xC,
    };

    enum ERunType {
      c_Beam,
      c_Cosmic
    };

    static std::string parseDetectors(EDetector det);

    class DetectorSet {
    public:

      class Iterator {
 
      public:

        Iterator(int index, uint16_t detectorSetBits, uint16_t setBit) :
          m_Index(index),
          m_DetectorSetBits(detectorSetBits),
          m_SetBit(setBit)
        {
        }

        ~Iterator()
        {
        }

        Iterator& operator++();

        void increment()
        {
          ++(*this);
        }

        EDetector operator*() const
        {
          return DetectorSet::getDetector(m_SetBit);
        }

        EDetector getDetector() const
        {
          return *(*this);
        }

        bool operator==(const Iterator& iterator) const;

        bool operator!=(const Iterator& iterator) const;

        int getIndex() const
        {
          return m_Index;
        }

        uint16_t getSetBit() const
        {
          return m_SetBit;
        }
 
      private:

        int m_Index;

        uint16_t m_DetectorSetBits;

        uint16_t m_SetBit;
 
      };

      DetectorSet(): m_bits(0) {}
      DetectorSet(const DetectorSet&) = default;
      DetectorSet& operator=(const DetectorSet&) = default;

      // cppcheck-suppress noExplicitConstructor
      DetectorSet(EDetector det): m_bits(getBit(det)) {}

      virtual ~DetectorSet() {};

      Iterator begin() const;

      Iterator end() const;

      DetectorSet& operator += (const DetectorSet& set) {m_bits |= set.m_bits; return *this;}

      DetectorSet& operator -= (const DetectorSet& set) {m_bits &= ~set.m_bits; return *this;}

      bool operator == (const DetectorSet& set) const {return m_bits == set.m_bits;}

      bool operator != (const DetectorSet& set) const {return m_bits != set.m_bits;}

      bool contains(const DetectorSet& set) const {return (m_bits & set.m_bits) == set.m_bits;}

      bool contains(const Iterator& it) const
      {
        return (m_bits & it.getSetBit()) != 0;
      }

      int getIndex(EDetector det) const;

      size_t size() const;

      std::string __str__() const;
 
    private:

      explicit DetectorSet(uint16_t bits): m_bits(bits) {};

      static uint16_t getBit(EDetector det);

      static EDetector getDetector(uint16_t bit);

      uint16_t m_bits;

      ClassDef(DetectorSet, 1);
 
    };

    template <class ASetType> class RestrictedDetectorSet: public DetectorSet {
    public:

      BELLE2_DEFINE_EXCEPTION(InvalidDetectorTypeError, "The given detector is not a valid element of the set!")
 
      
      RestrictedDetectorSet(): DetectorSet() {}

      // cppcheck-suppress noExplicitConstructor
      RestrictedDetectorSet(const DetectorSet& set): DetectorSet(set) {checkSet();}

      // cppcheck-suppress noExplicitConstructor
      RestrictedDetectorSet(EDetector det): DetectorSet(det) {checkSet();}

      // cppcheck-suppress duplInheritedMember ; intentionally hides the base class member
      RestrictedDetectorSet& operator += (const DetectorSet& set) {DetectorSet::operator +=(set); checkSet(); return *this;}

      static DetectorSet set() {return ASetType::set();}
 
    private:

      void checkSet() const {if (!ASetType::set().contains(*this)) throw InvalidDetectorTypeError();}
    };
 

    class VXDDetectors {
    public:
      static DetectorSet set() {return c_set;}  
      static const DetectorSet c_set;           
    };
    typedef RestrictedDetectorSet<VXDDetectors> VXDDetectorSet;

    class TrackingDetectors {
    public:
      static DetectorSet set() {return c_set;}  
      static const DetectorSet c_set;           
    };
    typedef RestrictedDetectorSet<TrackingDetectors> TrackingDetectorSet;

    class PIDDetectors {
    public:
      static DetectorSet set() {return c_set;}  
      static const DetectorSet c_set;           
      static const size_t c_size = 6;           
    };
    typedef RestrictedDetectorSet<PIDDetectors> PIDDetectorSet;

    class ClusterDetectors {
    public:
      static DetectorSet set() {return c_set;}  
      static const DetectorSet c_set;           
      static const size_t c_size = 2;           
    };
    typedef RestrictedDetectorSet<ClusterDetectors> ClusterDetectorSet;
 

    static const DetectorSet allDetectors;
 
    class ParticleSet;

    class ParticleType {
    public:

      explicit ParticleType(int pdgCode, const ParticleSet* set = nullptr, int index = -1):
        m_pdgCode(pdgCode), m_set(set), m_index(index)  {}

      ParticleType(const ParticleType&) = default;
      ParticleType& operator=(const ParticleType&) = default;

      bool operator < (const ParticleType& other) const;

      bool operator==(const ParticleType& o) const { return m_pdgCode == o.m_pdgCode; }

      bool operator!=(const ParticleType& o) const { return !((*this) == o); }

      ParticleType& operator*() { return *this; }

      ParticleType& operator++();

      ParticleType operator++(int);

      operator ParticleSet() const { ParticleSet s; s.add(*this); return s; }

      int getIndex() const { return m_index; }

      const TParticlePDG* getParticlePDG() const;

      int getPDGCode() const {return m_pdgCode;};

      double getMass() const;

      std::string __repr__() const;
 
    private:
      int m_pdgCode;  
      const ParticleSet* m_set; 
      int m_index;    
    };

    class ParticleSet {
    public:
      ParticleSet() = default;

      ParticleSet(const ParticleSet& other)
      {
        for (const ParticleType& pdgIter : other) add(pdgIter);
      }

      ParticleSet& operator=(const ParticleSet& other)
      {
        m_particles.clear();
        for (const ParticleType& pdgIter : other) add(pdgIter);
        return *this;
      }

      void add(const ParticleType& p);

      bool contains(const ParticleType& p) const;

      unsigned int size() const { return m_particles.size(); }

      const ParticleType& at(unsigned int index) const
      {
        if (index < m_particles.size())
          return m_particles[index];
        return invalidParticle;
      }

      ParticleType begin() const
      {
        if (m_particles.empty())
          return end();
        return m_particles[0];
      }

      static ParticleType end()
      {
        return invalidParticle;
      }

      const ParticleType& find(int pdg) const
      {
        for (const ParticleType& pdgIter : *this) {
          if (pdgIter.getPDGCode() == pdg)
            return m_particles[pdgIter.getIndex()];
        }
 
        return invalidParticle;
      }
    private:
      std::vector<ParticleType> m_particles; 
    };

    class ChargedStable : public ParticleType {
    public:
      // cppcheck-suppress noExplicitConstructor
      ChargedStable(const ParticleType& p)
        : ParticleType(chargedStableSet.find(p.getPDGCode()))
      {
        if ((*this) == invalidParticle) {
          throw std::runtime_error("Given ParticleType is not a charged stable particle!");
        }
      }

      explicit ChargedStable(int pdg)
        : ParticleType(chargedStableSet.find(pdg))
      {
        if ((*this) == invalidParticle) {
          throw std::runtime_error("Given PDG code is not a charged stable particle!");
        }
      }
      static const unsigned int c_SetSize = 6; 
    };
 
    static const ParticleSet chargedStableSet; 
 

    class Cluster : public ParticleType {
    public:
      // cppcheck-suppress noExplicitConstructor
      Cluster(const ParticleType& p)
        : ParticleType(clusterSet.find(p.getPDGCode()))
      {
        if ((*this) == invalidParticle) {
          throw std::runtime_error("Given ParticleType is not a cluster particle!");
        }
      }

      explicit Cluster(int pdg)
        : ParticleType(clusterSet.find(pdg))
      {
        if ((*this) == invalidParticle) {
          throw std::runtime_error("Given PDG code is not a cluster particle!");
        }
      }
      static const unsigned int c_SetSize = 6; 
    };
 
    static const ParticleSet clusterSet; 
 
    static const ParticleSet finalStateParticlesSet; 
 
    static const ChargedStable electron;  
    static const ChargedStable muon;      
    static const ChargedStable pion;      
    static const ChargedStable kaon;      
    static const ChargedStable proton;    
    static const ChargedStable deuteron;  
 
    static const Cluster clusterphoton;   
    static const Cluster clusterKlong;    
    static const Cluster clusterelectron; 
    static const Cluster clusterpion;     
    static const Cluster clustermuon;     
    static const Cluster clusterjunk;     
 
    static const ParticleType photon;    
    static const ParticleType pi0;       
    static const ParticleType neutron;   
    static const ParticleType antiNeutron;   
    static const ParticleType Kshort;    
    static const ParticleType Klong;     
    static const ParticleType Lambda;    
    static const ParticleType antiLambda; 
    static const ParticleType invalidParticle;     
    static const ParticleType unspecifiedParticle;
 
    static const double electronMass;    
    static const double muonMass;        
    static const double pionMass;        
    static const double kaonMass;        
    static const double protonMass;      
    static const double deuteronMass;    
    static const double pi0Mass;         
    static const double neutronMass;     
    static const double K0Mass;          
 
    static const double speedOfLight; 
    static const double kBoltzmann;   
    static const double ehEnergy;     
    static const double fineStrConst; 
    static const double permSi;       
    static const double uTherm;       
    static const double eMobilitySi;  
 
    static const double doubleNaN; 
    static const float  floatNaN;  
 
  private:
    Const() = delete;
    Const(const Const&) = delete;
    Const& operator=(const Const&) = delete;
    ~Const() = delete;
 
  };
}

Belle2::Const::DetectorSet operator + (const Belle2::Const::DetectorSet& firstSet, const Belle2::Const::DetectorSet& secondSet);

Belle2::Const::DetectorSet operator - (const Belle2::Const::DetectorSet& firstSet, const Belle2::Const::DetectorSet& secondSet);

Belle2::Const::DetectorSet operator + (Belle2::Const::EDetector firstDet, Belle2::Const::EDetector secondDet);

Belle2::Const::ParticleSet operator + (const Belle2::Const::ParticleSet& firstSet, const Belle2::Const::ParticleSet& secondSet);