PFDisplacedVertex.h

Go to the documentation of this file.

#ifndef DataFormat_ParticleFlowReco_PFDisplacedVertex_h
#define DataFormat_ParticleFlowReco_PFDisplacedVertex_h
 
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/Math/interface/LorentzVector.h"
 
#include <vector>
#include <string>
#include <iostream>
 
namespace reco {
 
 
  class PFDisplacedVertex : public Vertex {
  public:
    typedef std::pair<unsigned int, unsigned int> PFTrackHitInfo;
    typedef std::pair<PFTrackHitInfo, PFTrackHitInfo> PFTrackHitFullInfo;
 
    enum M_Hypo { M_CUSTOM, M_MASSLESS, M_PION, M_KAON, M_LAMBDA };
 
    enum VertexTrackType { T_NOT_FROM_VERTEX, T_TO_VERTEX, T_FROM_VERTEX, T_MERGED };
 
    enum VertexType {
      ANY = 0,
      FAKE = 1,
      LOOPER = 2,
      NUCL = 10,
      NUCL_LOOSE = 11,
      NUCL_KINK = 12,
      CONVERSION = 20,
      CONVERSION_LOOSE = 21,
      CONVERTED_BREMM = 22,
      K0_DECAY = 30,
      LAMBDA_DECAY = 31,
      LAMBDABAR_DECAY = 32,
      KPLUS_DECAY = 40,
      KMINUS_DECAY = 41,
      KPLUS_DECAY_LOOSE = 42,
      KMINUS_DECAY_LOOSE = 43,
      BSM_VERTEX = 100
    };
 
    PFDisplacedVertex();
 
    PFDisplacedVertex(reco::Vertex&);
 
    void addElement(const TrackBaseRef& r,
                    const Track& refTrack,
                    const PFTrackHitFullInfo& hitInfo,
                    VertexTrackType trackType = T_NOT_FROM_VERTEX,
                    float w = 1.0);
 
    void cleanTracks();
 
    void setVertexType(VertexType vertexType) { vertexType_ = vertexType; }
 
    void setPrimaryDirection(const math::XYZPoint& pvtx);
 
    VertexType vertexType() { return vertexType_; }
 
    const std::vector<PFTrackHitFullInfo> trackHitFullInfos() const { return trackHitFullInfos_; }
 
    const std::vector<VertexTrackType> trackTypes() const { return trackTypes_; }
 
 
    const bool isTherePrimaryTracks() const { return isThereKindTracks(T_TO_VERTEX); }
 
    const bool isThereMergedTracks() const { return isThereKindTracks(T_MERGED); }
 
    const bool isThereSecondaryTracks() const { return isThereKindTracks(T_FROM_VERTEX); }
 
    const bool isThereNotFromVertexTracks() const { return isThereKindTracks(T_NOT_FROM_VERTEX); }
 
    const bool isPrimaryTrack(const reco::TrackBaseRef& originalTrack) const {
      size_t itrk = trackPosition(originalTrack);
      return isTrack(itrk, T_TO_VERTEX);
    }
 
    const bool isSecondaryTrack(const reco::TrackBaseRef& originalTrack) const {
      size_t itrk = trackPosition(originalTrack);
      return isTrack(itrk, T_FROM_VERTEX);
    }
 
    const bool isMergedTrack(const reco::TrackBaseRef& originalTrack) const {
      size_t itrk = trackPosition(originalTrack);
      return isTrack(itrk, T_MERGED);
    }
 
    const PFTrackHitFullInfo trackHitFullInfo(const reco::TrackBaseRef& originalTrack) const {
      size_t itrk = trackPosition(originalTrack);
      return trackHitFullInfos_[itrk];
    }
 
    const bool isIncomingTrack(const reco::TrackBaseRef& originalTrack) const {
      size_t itrk = trackPosition(originalTrack);
      return isTrack(itrk, T_MERGED) || isTrack(itrk, T_TO_VERTEX);
    }
 
    const bool isOutgoingTrack(const reco::TrackBaseRef& originalTrack) const {
      size_t itrk = trackPosition(originalTrack);
      return isTrack(itrk, T_FROM_VERTEX);
    }
 
    const int nPrimaryTracks() const { return nKindTracks(T_TO_VERTEX); }
 
    const int nMergedTracks() const { return nKindTracks(T_MERGED); }
 
    const int nSecondaryTracks() const { return nKindTracks(T_FROM_VERTEX); }
 
    const int nNotFromVertexTracks() const { return nKindTracks(T_NOT_FROM_VERTEX); }
 
    const int nTracks() const { return trackTypes_.size(); }
 
    //    const reco::VertexTrackType vertexTrackType(reco::TrackBaseRef tkRef) const;
 
    const math::XYZTLorentzVector secondaryMomentum(std::string massHypo = "PI",
                                                    bool useRefitted = true,
                                                    double mass = 0.0) const {
      return momentum(massHypo, T_FROM_VERTEX, useRefitted, mass);
    }
 
    const math::XYZTLorentzVector primaryMomentum(std::string massHypo = "PI",
                                                  bool useRefitted = true,
                                                  double mass = 0.0) const {
      return momentum(massHypo, T_TO_VERTEX, useRefitted, mass);
    }
 
    const math::XYZTLorentzVector secondaryMomentum(M_Hypo massHypo, bool useRefitted = true, double mass = 0.0) const {
      return momentum(massHypo, T_FROM_VERTEX, useRefitted, mass);
    }
 
    const math::XYZTLorentzVector primaryMomentum(M_Hypo massHypo, bool useRefitted = true, double mass = 0.0) const {
      return momentum(massHypo, T_TO_VERTEX, useRefitted, mass);
    }
 
    void calcKinematics() {
      defaultPrimaryMomentum_ = momentum("PI", T_TO_VERTEX, false, 0.0);
      defaultSecondaryMomentum_ = momentum("PI", T_FROM_VERTEX, true, 0.0);
    }
 
    const double secondaryPt() const { return defaultPrimaryMomentum_.Pt(); }
 
    const double primaryPt() const { return defaultSecondaryMomentum_.Pt(); }
 
    const int totalCharge() const;
 
    const double angle_io() const;
 
    const math::XYZVector primaryDirection() const;
 
    bool isFake() const { return vertexType_ == FAKE; }
    bool isLooper() const { return vertexType_ == LOOPER; }
    bool isNucl() const { return vertexType_ == NUCL; }
    bool isNucl_Loose() const { return vertexType_ == NUCL_LOOSE; }
    bool isNucl_Kink() const { return vertexType_ == NUCL_KINK; }
    bool isConv() const { return vertexType_ == CONVERSION; }
    bool isConv_Loose() const { return vertexType_ == CONVERSION_LOOSE; }
    bool isConvertedBremm() const { return vertexType_ == CONVERTED_BREMM; }
    bool isK0() const { return vertexType_ == K0_DECAY; }
    bool isLambda() const { return vertexType_ == LAMBDA_DECAY; }
    bool isLambdaBar() const { return vertexType_ == LAMBDABAR_DECAY; }
    bool isKplus() const { return vertexType_ == KPLUS_DECAY; }
    bool isKminus() const { return vertexType_ == KMINUS_DECAY; }
    bool isKplus_Loose() const { return vertexType_ == KPLUS_DECAY_LOOSE; }
    bool isKminus_Loose() const { return vertexType_ == KMINUS_DECAY_LOOSE; }
    bool isBSM() const { return vertexType_ == BSM_VERTEX; }
 
    std::string nameVertexType() const;
 
    void Dump(std::ostream& out = std::cout) const;
 
  private:
 
    const bool isThereKindTracks(VertexTrackType) const;
 
    const int nKindTracks(VertexTrackType) const;
 
    const math::XYZTLorentzVector momentum(std::string, VertexTrackType, bool, double mass) const;
 
    const math::XYZTLorentzVector momentum(M_Hypo massHypo, VertexTrackType, bool, double mass) const;
 
    const double getMass2(M_Hypo, double) const;
 
    const size_t trackPosition(const reco::TrackBaseRef& originalTrack) const;
 
    const bool isTrack(size_t itrk, VertexTrackType T) const { return trackTypes_[itrk] == T; }
 
 
    VertexType vertexType_;
 
    std::vector<VertexTrackType> trackTypes_;
 
    std::vector<PFTrackHitFullInfo> trackHitFullInfos_;
 
    math::XYZVector primaryDirection_;
 
    math::XYZTLorentzVector defaultPrimaryMomentum_;
    math::XYZTLorentzVector defaultSecondaryMomentum_;
  };
}  // namespace reco
 
#endif