RecoHitInformation.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 <cdc/dataobjects/CDCHit.h>
#include <pxd/dataobjects/PXDCluster.h>
#include <svd/dataobjects/SVDCluster.h>
#include <klm/dataobjects/bklm/BKLMHit2d.h>
#include <klm/dataobjects/eklm/EKLMAlignmentHit.h>
 
#include <framework/datastore/RelationsObject.h>
 
namespace Belle2 {
  class RecoHitInformation : public RelationsObject {
  public:
 
    typedef SVDCluster UsedSVDHit;
 
    typedef PXDCluster UsedPXDHit;
 
    typedef CDCHit UsedCDCHit;
 
    typedef BKLMHit2d UsedBKLMHit;
 
    typedef EKLMAlignmentHit UsedEKLMHit;
 
    enum RightLeftInformation {
      c_undefinedRightLeftInformation,
      c_invalidRightLeftInformation,
      c_right,
      c_left
    };
 
    enum OriginTrackFinder {
      c_undefinedTrackFinder,
      // the Hit has been generated by the MCTrackFinder and its considered important
      // to find this hit by PR. Which hits get marked as priority and auxiliary solely
      // depends on the configuration of the TrackFinderMCRTruh
      c_MCTrackFinderPriorityHit,
      // the Hit has been generated by the MCTrackFinder and is considered to be of minor
      // importance to find, for example because it is in one of the downstream loops.
      // Which hits get marked as priority and auxiliary solely depends on the configuration
      // of the TrackFinderMCRTruh
      c_MCTrackFinderAuxiliaryHit,
      c_invalidTrackFinder,
      // non CKF-based track finders
      c_CDCTrackFinder,
      c_LocalTrackFinder,
      c_SegmentTrackCombiner,
      c_VXDTrackFinder,
      // track finders based on CKF
      c_SVDtoCDCCKF,
      c_ECLtoCDCCKF,
      c_CDCtoSVDCKF,
      c_SVDtoPXDCKF,
      // CDC hit finder implemented in the ReattachCDCWireHitsToRecoTracks module:
      // looks for CDC hits that are close to RecTracks, but that were rejected by the ADC/TOT based filter.
      c_ReattachCDCWireHitsToRecoTracks,
      // Belle I's track finder
      c_Trasan,
      c_other
    };
 
    enum RecoHitFlag {
      c_undefinedRecoHitFlag,
      c_dismissedByFit,
      c_pruned,
    };
 
    enum RecoHitDetector {
      c_undefinedTrackingDetector,
      c_invalidTrackingDetector,
      c_SVD,
      c_PXD,
      c_CDC,
      c_EKLM,
      c_BKLM
    };
 
  public:
    RecoHitInformation() {}
 
    RecoHitInformation(const UsedCDCHit* cdcHit, RightLeftInformation rightLeftInformation, OriginTrackFinder foundByTrackFinder,
                       unsigned int sortingParameter) :
      RecoHitInformation(cdcHit, RecoHitDetector::c_CDC, rightLeftInformation, foundByTrackFinder, sortingParameter)
    {
    }
 
    RecoHitInformation(const UsedPXDHit* pxdHit, OriginTrackFinder foundByTrackFinder,
                       unsigned int sortingParameter) :
      RecoHitInformation(pxdHit, RecoHitDetector::c_PXD, RightLeftInformation::c_invalidRightLeftInformation,
                         foundByTrackFinder, sortingParameter)
    {
    }
 
    RecoHitInformation(const UsedSVDHit* svdHit, OriginTrackFinder foundByTrackFinder,
                       unsigned int sortingParameter) :
      RecoHitInformation(svdHit, RecoHitDetector::c_SVD, RightLeftInformation::c_invalidRightLeftInformation,
                         foundByTrackFinder, sortingParameter)
    {
    }
 
    RecoHitInformation(const UsedEKLMHit* eklmHit, OriginTrackFinder foundByTrackFinder,
                       unsigned int sortingParameter) :
      RecoHitInformation(eklmHit, RecoHitDetector::c_EKLM, RightLeftInformation::c_invalidRightLeftInformation,
                         foundByTrackFinder, sortingParameter)
    {
    }
 
    RecoHitInformation(const UsedBKLMHit* bklmHit, OriginTrackFinder foundByTrackFinder,
                       unsigned int sortingParameter) :
      RecoHitInformation(bklmHit, RecoHitDetector::c_BKLM, RightLeftInformation::c_invalidRightLeftInformation,
                         foundByTrackFinder, sortingParameter)
    {
    }
 
    RecoHitFlag getFlag() const
    {
      return m_flag;
    }
 
    void setFlag(RecoHitFlag flag)
    {
      m_flag = flag;
    }
 
    OriginTrackFinder getFoundByTrackFinder() const
    {
      return m_foundByTrackFinder;
    }
 
    void setFoundByTrackFinder(OriginTrackFinder foundByTrackFinder)
    {
      m_foundByTrackFinder = foundByTrackFinder;
    }
 
    unsigned int getSortingParameter() const
    {
      return m_sortingParameter;
    }
 
    void setSortingParameter(unsigned int sortingParameter)
    {
      m_sortingParameter = sortingParameter;
    }
 
    RightLeftInformation getRightLeftInformation() const
    {
      return m_rightLeftInformation;
    }
 
    void setRightLeftInformation(RightLeftInformation rightLeftInformation)
    {
      m_rightLeftInformation = rightLeftInformation;
    }
 
    RecoHitDetector getTrackingDetector() const
    {
      return m_trackingDetector;
    }
 
    bool useInFit() const
    {
      return m_useInFit;
    }
 
    void setUseInFit(const bool useInFit = true)
    {
      m_useInFit = useInFit;
    }
 
    void setCreatedTrackPointID(int trackPointID)
    {
      m_createdTrackPointID = trackPointID;
    }
 
    int getCreatedTrackPointID() const
    {
      return m_createdTrackPointID;
    }
 
  private:
    RecoHitDetector m_trackingDetector = RecoHitDetector::c_undefinedTrackingDetector;
    RightLeftInformation m_rightLeftInformation = RightLeftInformation::c_undefinedRightLeftInformation;
 
    unsigned int m_sortingParameter = 0;
    OriginTrackFinder m_foundByTrackFinder = OriginTrackFinder::c_undefinedTrackFinder;
    RecoHitFlag m_flag = RecoHitFlag::c_undefinedRecoHitFlag;
    bool m_useInFit = true;
    int m_createdTrackPointID = -1;
 
    template <class HitType>
    RecoHitInformation(const HitType* hit,
                       RecoHitDetector trackingDetector,
                       RightLeftInformation rightLeftInformation,
                       OriginTrackFinder foundByTrackFinder,
                       unsigned int sortingParameter) :
      m_trackingDetector(trackingDetector),
      m_rightLeftInformation(rightLeftInformation),
      m_sortingParameter(sortingParameter),
      m_foundByTrackFinder(foundByTrackFinder),
      m_flag(RecoHitFlag::c_undefinedRecoHitFlag)
    {
      addRelationTo(hit);
    }
 
    ClassDef(RecoHitInformation, 6); 
  };
}