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,   
    };
 
    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 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 setNumTracks(int numTracks, int usedTracks, int nodEdx)
    {
      m_numTracks = numTracks;
      m_usedTracks = usedTracks;
      m_nodEdx = 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 setSimulated(int bunchNo, double time)
    {
      m_simBunchNo = bunchNo;
      m_simTime = time;
      m_simValid = true;
    }
 
    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;
    }
 
    int getBucketNumber(int offset, unsigned RFBucketsPerRevolution = 5120) const
    {
      return getBucketNumber(m_recBunchNo, m_revo9Counter, offset, RFBucketsPerRevolution);
    }
 
    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); 
  };
 
 
} // end namespace Belle2