EventLevelTrackingInfo.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 <mdst/dataobjects/HitPatternCDC.h>
 
#include <framework/logging/Logger.h>
 
#include <TObject.h>
 
#include <algorithm>
#include <bitset>
 
namespace Belle2 {
  class EventLevelTrackingInfo : public TObject {
  public:
    EventLevelTrackingInfo() = default;
 
    //--- CDC related Stuff -------------------------------------------------------------------------------------------
    uint16_t getNCDCHitsNotAssigned() const
    {
      return m_nCDCHitsNotAssigned;
    }
 
    void setNCDCHitsNotAssigned(uint16_t const nCDCHitsNotAssigned)
    {
      m_nCDCHitsNotAssigned = nCDCHitsNotAssigned;
    }
 
    uint16_t getNCDCHitsNotAssignedPostCleaning() const
    {
      return m_nCDCHitsNotAssignedPostCleaning;
    }
 
    void setNCDCHitsNotAssignedPostCleaning(uint16_t const nCDCHitsNotAssignedPostCleaning)
    {
      m_nCDCHitsNotAssignedPostCleaning = nCDCHitsNotAssignedPostCleaning;
    }
 
    bool hasCDCLayer(uint16_t const cdcLayer) const
    {
      return HitPatternCDC(m_hitPatternCDCInitializer).hasLayer(cdcLayer);
    }
 
    void setCDCLayer(uint16_t const cdcLayer)
    {
      HitPatternCDC hitPatternCDC(m_hitPatternCDCInitializer);
      hitPatternCDC.setLayer(cdcLayer);
      m_hitPatternCDCInitializer = hitPatternCDC.getInteger();
    }
 
    bool hasCDCSLayer(uint16_t const cdcSLayer) const
    {
      return HitPatternCDC(m_hitPatternCDCInitializer).hasSLayer(cdcSLayer);
    }
 
    uint16_t getNCDCSegments() const
    {
      return HitPatternCDC(m_hitPatternCDCInitializer).getNHits();
    }
 
    void setNCDCSegments(uint16_t nHits)
    {
      HitPatternCDC hitPatternCDC(m_hitPatternCDCInitializer);
      hitPatternCDC.setNHits(nHits);
      m_hitPatternCDCInitializer = hitPatternCDC.getInteger();
    }
 
    //--- VXD related stuff -------------------------------------------------------------------------------------------
    uint16_t getNVXDClustersInLayer(uint16_t const layer, bool const isU)
    {
      if (layer == 1 or layer == 2) {
        return m_nPXDClusters[layer - 1];
      }
      if (layer > 2 and layer < 7) {
        return m_nSVDClusters[layer - 3 + 4 * isU];
      }
      B2FATAL("The VXD only has layer 1 to 6, but you asked for " << layer);
    }
 
    uint16_t getNVXDClustersInLayer(uint16_t const layer)
    {
      if (layer == 1 or layer == 2) {
        return getNVXDClustersInLayer(layer, true);
      }
      return getNVXDClustersInLayer(layer, true) + getNVXDClustersInLayer(layer, false);
    }
 
    void setNVXDClustersInLayer(uint16_t const layer, bool const isU, uint16_t const nClusters)
    {
      if (layer == 1 or layer == 2) {
        m_nPXDClusters[layer - 1] = nClusters;
        return;
      }
      if (layer > 2 and layer < 7) {
        m_nSVDClusters[layer - 3 + 4 * isU] = std::min(nClusters, static_cast<unsigned short>(255U));
        return;
      }
      B2FATAL("The VXD only has layer 1 to 6, but you asked for " << layer);
    }
 
    int8_t getSVDFirstSampleTime() const
    {
      return m_sampleTime;
    }
 
    void setSVDFirstSampleTime(int8_t const sampleTime)
    {
      m_sampleTime = sampleTime;
    }
 
    //--- Flag Block related stuff ------------------------------------------------------------------------------------
    bool hasAnErrorFlag() const
    {
      return m_flagBlock.any();
    }
 
    bool hasUnspecifiedTrackFindingFailure() const
    {
      return m_flagBlock[c_unspecifiedError];
    }
 
    void setUnspecifiedTrackFindingFailure()
    {
      m_flagBlock.set(c_unspecifiedError);
    }
 
    bool hasVXDTF2AbortionFlag() const
    {
      return m_flagBlock[c_vxdtf2Abortion];
    }
 
    void setVXDTF2AbortionFlag()
    {
      m_flagBlock.set(c_vxdtf2Abortion);
    }
 
    bool hasSVDCKFAbortionFlag() const
    {
      return m_flagBlock[c_svdckfAbortion];
    }
 
    void setSVDCKFAbortionFlag()
    {
      m_flagBlock.set(c_svdckfAbortion);
    }
 
    bool hasPXDCKFAbortionFlag() const
    {
      return m_flagBlock[c_pxdckfAbortion];
    }
 
    void setPXDCKFAbortionFlag()
    {
      m_flagBlock.set(c_pxdckfAbortion);
    }
 
    bool hasSVDSpacePointCreatorAbortionFlag() const
    {
      return m_flagBlock[c_svdSpacePointAbortion];
    }
 
    void setSVDSpacePointCreatorAbortionFlag()
    {
      m_flagBlock.set(c_svdSpacePointAbortion);
    }
 
  private:
    enum ETrackingErrorFlags {
      c_unspecifiedError = 0, 
      c_vxdtf2Abortion   = 1, 
      c_svdckfAbortion   = 2, 
      c_pxdckfAbortion   = 3, 
      c_svdSpacePointAbortion   = 4, 
    };
 
    uint16_t m_nCDCHitsNotAssigned {0};
 
    uint16_t m_nCDCHitsNotAssignedPostCleaning {0};
 
    uint64_t m_hitPatternCDCInitializer {0};
 
    uint16_t m_nPXDClusters[2] {0, 0};
 
    uint8_t m_nSVDClusters[8] {0, 0, 0, 0, 0, 0, 0, 0};
 
    int8_t m_sampleTime {0};
 
    std::bitset<16> m_flagBlock;
 
    ClassDef(EventLevelTrackingInfo, 2); 
  };
}