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>
 
namespace Belle2 {
  class TOPRecBunch : public RelationsObject {
  public:
 
    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;
    }
 
    void setReconstructed(int bunchNo, double time,
                          double currentOffset, double currentOffsetError,
                          double averageOffset, double averageOffsetError,
                          bool fineSearch)
    {
      m_recBunchNo = bunchNo;
      m_recTime = time;
      m_currentOffset = currentOffset;
      m_averageOffset = averageOffset;
      m_currentOffsetError = currentOffsetError;
      m_averageOffsetError = averageOffsetError;
      m_fineSearch = fineSearch;
      m_recValid = true;
    }
 
    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 addHistogram(const TH1F& histo)
    {
      m_histograms.push_back(histo);
    }
 
    void setSimulated(int bunchNo, double time)
    {
      m_simBunchNo = bunchNo;
      m_simTime = time;
      m_simValid = true;
    }
 
    int getBunchNo() const {return m_recBunchNo;}
 
    int getAbsoluteBunchNo(int offset) const
    {
      return (m_recBunchNo + m_revo9Counter * 4 - offset) % 5120;
    }
 
    double getTime() const {return m_recTime;}
 
    double getCurrentOffset() const {return m_currentOffset;}
 
    double getCurrentOffsetError() const {return m_currentOffsetError;}
 
    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;}
 
  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 = 0; 
    ClassDef(TOPRecBunch, 3); 
  };
 
 
} // end namespace Belle2