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_;

    
  };
}

#endif