SpacePointTrackCand.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
 
// framework
#include <framework/datastore/RelationsObject.h>
#include <framework/core/FrameworkExceptions.h>
 
// SpacePoint
#include <tracking/spacePointCreation/SpacePoint.h>
 
// stl
#include <vector>
 
// ROOT
#include <TVectorD.h>
#include <TMatrixD.h>
 
// USHRT_MAX
#include <climits>
 
namespace Belle2 {
  class SpacePointTrackCand final : public RelationsObject {
 
  public:
 
    BELLE2_DEFINE_EXCEPTION(UnsupportedDetType, "The Detector Type is not supported by this class. Supported are: PXD and SVD");
 
    BELLE2_DEFINE_EXCEPTION(SPTCIndexOutOfBounds, "Trying to acces a SpacePoint from a SpacePointTrackCand via an"\
                            " index that is out of bounds!");
 
    BELLE2_DEFINE_EXCEPTION(SPTCSortingParameterSizeInvalid,
                            "Trying to modify SortingParameters, but number of new SortingParameters differs from number of SpacePoints");
 
    enum RefereeStatusBit {
      c_checkedByReferee = 1,     
      c_checkedClean = 2,         
      c_hitsOnSameSensor = 4,     
      c_hitsLowDistance = 8,
      c_removedHits = 16,         
      c_checkedTrueHits =  32,    
      c_checkedSameSensors = 64,
      c_checkedMinDistance =  128,
      c_curlingTrack = 256,       
      c_omittedClusters = 512,    
      c_singleClustersSPs = 1024, 
      c_isActive =  2048,         
      c_isReserved = 4096,        
      c_hasFittedRecoTrack = 1 << 13,  
      c_initialState = 0 + c_isActive, 
    };
 
    SpacePointTrackCand() = default;
 
    explicit SpacePointTrackCand(const std::vector<const Belle2::SpacePoint*>& spacePoints, int pdgCode = 0, double charge = 0,
                                 int mcTrackID = -1);
 
 
    bool operator == (const SpacePointTrackCand& rhs) const;
 
 
    const std::vector<const Belle2::SpacePoint*>& getHits() const { return m_trackSpacePoints; }
 
    const std::vector<const Belle2::SpacePoint*> getSortedHits() const;
 
    std::vector<const Belle2::SpacePoint*>::const_iterator begin() const { return m_trackSpacePoints.begin(); }
 
    std::vector<const Belle2::SpacePoint*>::const_iterator end() const { return m_trackSpacePoints.end(); }
 
    const std::vector<const Belle2::SpacePoint*> getHitsInRange(int firstInd, int lastInd) const;
 
    unsigned int getNHits() const { return m_trackSpacePoints.size(); }
 
    unsigned int size() const { return m_trackSpacePoints.size(); }
 
    int getPdgCode() const { return m_pdg; }
 
    double getChargeSeed() const { return m_q; }
 
    const TMatrixDSym& getCovSeed() const { return m_cov6D; }
 
    const TVectorD& getStateSeed() const { return m_state6D; }
 
    const ROOT::Math::XYZVector getPosSeed() const { return ROOT::Math::XYZVector(m_state6D[0], m_state6D[1], m_state6D[2]); }
 
    const ROOT::Math::XYZVector getMomSeed() const { return ROOT::Math::XYZVector(m_state6D[3], m_state6D[4], m_state6D[5]); }
 
    const std::vector<double>& getSortingParameters() const { return m_sortingParameters; }
 
    const std::vector<double> getSortingParametersInRange(int firstIndex, int lastIndex) const;
 
    int getTrackStubIndex() const { return m_iTrackStub; }
 
    int getMcTrackID() const { return m_MCTrackID; }
 
    int getMcTrackId() const { return m_MCTrackID; }
 
    unsigned short int getRefereeStatus(unsigned short int bitmask = USHRT_MAX) const { return m_refereeStatus & bitmask; }
 
    bool hasRefereeStatus(unsigned int short bitmask) const { return (m_refereeStatus & bitmask) == bitmask; }
 
    double getQualityIndicator() const { return m_qualityIndicator; }
 
    bool hasHitsOnSameSensor() const { return hasRefereeStatus(c_hitsOnSameSensor); }
 
    bool checkedSameSensors() const { return hasRefereeStatus(c_checkedSameSensors); }
 
    bool hasHitsLowDistance() const { return hasRefereeStatus(c_hitsLowDistance); }
 
    bool checkedMinDistance() const { return hasRefereeStatus(c_checkedMinDistance); }
 
    bool hasRemovedHits() const { return hasRefereeStatus(c_removedHits); }
 
    bool isOutgoing() const { return m_flightDirection; }
 
    bool isCurling() const { return hasRefereeStatus(c_curlingTrack); }
 
    bool checkedForCurling() const { return m_iTrackStub != -1; }
 
    bool isPartOfCurlingTrack() const { return m_iTrackStub > 0; }
 
    void print(int debuglevel = 25, const Option_t* = "") const;
 
    std::string getRefereeStatusString(std::string delimiter = " ") const;
 
    short getFamily() const { return m_family; }
 
    void setFamily(short family) { m_family = family; }
 
    void setSortingParameters(const std::vector<double>& sortParams);
 
    void setPdgCode(int pdgCode);
 
    void setChargeSeed(double charge) { m_q = charge; }
 
    void set6DSeed(const TVectorD& state6D) { m_state6D = state6D; }
 
    void setCovSeed(const TMatrixDSym& cov) { m_cov6D = cov; }
 
    void setQualityIndicator(const double newIndicator) { m_qualityIndicator = newIndicator; }
 
    void addSpacePoint(const SpacePoint* newSP, double sortParam)
    {
      m_trackSpacePoints.push_back(newSP);
      m_sortingParameters.push_back(sortParam);
    }
 
    void setFlightDirection(bool direction) { m_flightDirection = direction; }
 
    void setTrackStubIndex(int trackStubInd) { m_iTrackStub = trackStubInd; }
 
    void setRefereeStatus(unsigned short int bitmask) { m_refereeStatus = bitmask; }
 
    void addRefereeStatus(unsigned short int bitmask) { m_refereeStatus |= bitmask; }
 
    void removeRefereeStatus(unsigned short int bitmask) { m_refereeStatus &= (~bitmask); }
 
    void clearRefereeStatus() { m_refereeStatus = 0; }
 
    void resetRefereeStatus() { m_refereeStatus = c_initialState; }
 
    void removeSpacePoint(int indexInTrackCand);
 
    bool operator <(const SpacePointTrackCand& rhs) const { return m_qualityIndicator < rhs.m_qualityIndicator; }
 
  protected:
    std::vector<const SpacePoint*> m_trackSpacePoints;
 
    std::vector<double> m_sortingParameters;
 
 
    short m_family = -1;
 
    int m_pdg = 0;
 
    int m_MCTrackID = -1;
 
    TVectorD m_state6D = TVectorD(6);
 
    TMatrixDSym m_cov6D = TMatrixDSym(6);
 
    double m_q = 0;
 
    bool m_flightDirection = true;
 
    int m_iTrackStub = -1;
 
    unsigned short int m_refereeStatus = c_isActive;
 
    double m_qualityIndicator = 0.5;
 
    // last members added: RefereeStatutsBit(5), m_refereeProperties(5) m_iTrackStub(4), m_flightDirection(3), m_sortingParameters (2), m_qualityIndicator
    ClassDef(SpacePointTrackCand, 10)
  };
}