TOPRecBunch.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/datastore/RelationsObject.h>
#include <TH1F.h>
#include <vector>
#include <framework/gearbox/Const.h>
 
namespace Belle2 {

 
  class TOPRecBunch : public RelationsObject {
  public:

    enum EBucketStatus {
      c_Unknown = -1, 
      c_Empty = 0,    
      c_Filled = 1,   
    };
    enum EBucketStatus {…};

    TOPRecBunch()
    {}
    TOPRecBunch() {…}

    void clearReconstructed()
    {
      m_recBunchNo = 0;
      m_recTime = 0;
      m_currentOffset = 0;
      m_averageOffset = 0;
      m_currentOffsetError = 0;
      m_averageOffsetError = 0;
      m_numTracks = 0;
      m_usedTracks = 0;
      m_nodEdx = 0;
      m_fineSearch = false;
      m_histograms.clear();
      m_recValid = false;
      m_minChi2 = 0;
      m_detector = Const::invalidDetector;
      m_bucketNumber = c_Unknown;
      m_isBucketFilled = c_Unknown;
    }
    void clearReconstructed() {…}

    void setReconstructed(int bunchNo, double time,
                          double currentOffset, double currentOffsetError,
                          double averageOffset, double averageOffsetError,
                          Const::EDetector detector)
    {
      m_recBunchNo = bunchNo;
      m_recTime = time;
      m_currentOffset = currentOffset;
      m_averageOffset = averageOffset;
      m_currentOffsetError = currentOffsetError;
      m_averageOffsetError = averageOffsetError;
      m_fineSearch = true;
      m_recValid = true;
      m_detector = detector;
    }
    void setReconstructed(int bunchNo, double time, {…}

    void setNumTracks(int numTracks, int usedTracks, int nodEdx)
    {
      m_numTracks = numTracks;
      m_usedTracks = usedTracks;
      m_nodEdx = nodEdx;
    }
    void setNumTracks(int numTracks, int usedTracks, int nodEdx) {…}

    void setRevo9Counter(unsigned short revo9Counter) {m_revo9Counter = revo9Counter;}

    void setMinChi2(double minChi2) {m_minChi2 = minChi2;}

    void addHistogram(const TH1F& histo)
    {
      m_histograms.push_back(histo);
    }
    void addHistogram(const TH1F& histo) {…}

    void setSimulated(int bunchNo, double time)
    {
      m_simBunchNo = bunchNo;
      m_simTime = time;
      m_simValid = true;
    }
    void setSimulated(int bunchNo, double time) {…}

    void setBucketNumber(int bucketNumber) {m_bucketNumber = bucketNumber;}

    void setBucketFillStatus(bool isFilled) {m_isBucketFilled = isFilled ? c_Filled : c_Empty;}

    int getBunchNo() const {return m_recBunchNo;}

    static int getBucketNumber(int recBunchNo, int revo9Count, int offset, int RFBucketsPerRevolution)
    {
      int bn = (recBunchNo + revo9Count * 4 - offset) % RFBucketsPerRevolution;
      if (bn < 0) bn += RFBucketsPerRevolution;
      return bn;
    }
    static int getBucketNumber(int recBunchNo, int revo9Count, int offset, int RFBucketsPerRevolution) {…}

    int getBucketNumber(int offset, unsigned RFBucketsPerRevolution = 5120) const
    {
      return getBucketNumber(m_recBunchNo, m_revo9Counter, offset, RFBucketsPerRevolution);
    }
    int getBucketNumber(int offset, unsigned RFBucketsPerRevolution = 5120) const {…}

    int getBucketNumber() const {return m_bucketNumber;}

    EBucketStatus getBucketFillStatus() const {return m_isBucketFilled;}

    double getTime() const {return m_recTime;}

    double getCurrentOffset() const {return m_currentOffset;}

    double getCurrentOffsetError() const {return m_currentOffsetError;}

    double getMinChi2() const {return m_minChi2;}

    double getAverageOffset() const {return m_averageOffset;}

    double getAverageOffsetError() const {return m_averageOffsetError;}

    int getNumTracks() const {return m_numTracks;}

    int getUsedTracks() const {return m_usedTracks;}

    int getNodEdxTracks() const {return m_nodEdx;}

    const std::vector<TH1F>& getHistograms() const {return m_histograms;}

    bool isReconstructed() const {return m_recValid;}

    bool isFineSearch() const {return m_fineSearch;}

    int getMCBunchNo() const {return m_simBunchNo;}

    double getMCTime() const {return m_simTime;}

    bool isSimulated() const {return m_simValid;}

    unsigned short getRevo9Counter() const {return m_revo9Counter;}

    Const::EDetector getSeedingDetector() const {return m_detector;}
 
  private:
 
    int m_recBunchNo = 0; 
    float m_recTime = 0;  
    float m_currentOffset = 0; 
    float m_averageOffset = 0; 
    float m_currentOffsetError = 0; 
    float m_averageOffsetError = 0; 
    int m_numTracks = 0;  
    int m_usedTracks = 0;  
    int m_nodEdx = 0; 
    bool m_fineSearch = false; 
    std::vector<TH1F> m_histograms;  
    bool m_recValid = false;  
 
    int m_simBunchNo = 0; 
    float m_simTime = 0;  
    bool m_simValid = false;  
 
    unsigned short m_revo9Counter = 0xFFFF; 
    float m_minChi2 = 0; 
    Const::EDetector m_detector = Const::invalidDetector; 
 
    int m_bucketNumber = c_Unknown;   
    EBucketStatus m_isBucketFilled = c_Unknown; 
 
    ClassDef(TOPRecBunch, 7); 
 
  };
  class TOPRecBunch : public RelationsObject {…};
 

} // end namespace Belle2