/data/refman/pasoursint/CMSSW_6_1_2_SLHC4_patch1/src/RecoParticleFlow/PFTracking/interface/PFDisplacedVertexHelper.h

Go to the documentation of this file.

#ifndef RecoParticleFlow_PFTracking_PFDisplacedVertexHelper_h
#define RecoParticleFlow_PFTracking_PFDisplacedVertexHelper_h 

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedVertex.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/TrackReco/interface/Track.h"


class PFDisplacedVertexHelper {

 public:

  PFDisplacedVertexHelper(); 
  ~PFDisplacedVertexHelper();

  void setTracksSelector(const edm::ParameterSet& ps){
    tracksSelector_ = TracksSelector(ps);
  };

  void setVertexIdentifier(const edm::ParameterSet& ps){
    vertexIdentifier_ = VertexIdentifier(ps);
  };

  void setPrimaryVertex(edm::Handle< reco::VertexCollection > mainVertexHandle, 
                        edm::Handle< reco::BeamSpot > beamSpotHandle);


  bool isTrackSelected(const reco::Track& trk, 
                       const reco::PFDisplacedVertex::VertexTrackType vertexTrackType) const;

  reco::PFDisplacedVertex::VertexType identifyVertex(const reco::PFDisplacedVertex& v) const;

  math::XYZPoint primaryVertex() const { return pvtx_;}

  void Dump(std::ostream& out = std::cout) const;

 private:


  int    lambdaCP(const reco::PFDisplacedVertex& v) const;
  bool isKaonMass(const reco::PFDisplacedVertex& v) const;


  struct TracksSelector {
    TracksSelector() : 
      bSelectTracks_(false),
      nChi2_min_(0), nChi2_max_(100), 
      pt_min_(0), dxy_min_(0), 
      nHits_min_(3), nOuterHits_max_(100),
      quality_("loose"){}
  
    TracksSelector(const edm::ParameterSet& ps){
      bSelectTracks_  = ps.getParameter<bool>("bSelectTracks");
      nChi2_min_      = ps.getParameter<double>("nChi2_min");
      nChi2_max_      = ps.getParameter<double>("nChi2_max");
      pt_min_         = ps.getParameter<double>("pt_min");
      dxy_min_        = ps.getParameter<double>("dxy_min");
      nHits_min_      = ps.getParameter<int>("nHits_min");
      nOuterHits_max_ = ps.getParameter<int>("nOuterHits_max");
      std::string quality_ = ps.getParameter<std::string>("quality");
    }
    
    bool selectTracks() const {return bSelectTracks_;}
    double nChi2_min() const {return nChi2_min_;}
    double nChi2_max() const {return nChi2_max_;}
    double pt_min() const {return pt_min_;}
    double dxy_min() const {return dxy_min_;}
    int nHits_min() const {return nHits_min_;}
    int nOuterHits_max() const {return nOuterHits_max_;}
    std::string quality() const {return quality_;}
    double dxy(const reco::Track& trk) const {return trk.dxy(pvtx_);}

    bool bSelectTracks_;
    double nChi2_min_;
    double nChi2_max_;
    double pt_min_;
    double dxy_min_;
    int nHits_min_;
    int nOuterHits_max_;
    math::XYZPoint pvtx_;
    std::string quality_;

    void Dump(std::ostream& out = std::cout) const {
      if(! out ) return;
      std::string s =  bSelectTracks_ ? "On" : "Off";

      out << "" << std::endl;
      out << "      ==== The TrackerSelector is " << s.data() << " ====    " << std::endl;

      out << " nChi2_min_ = " << nChi2_min_
          << " nChi2_max_ = " << nChi2_max_ << std::endl
          << " pt_min_ = " << pt_min_
          << " dxy_min_ = " << dxy_min_ << std::endl
          << " nHits_min_ = " << nHits_min_  
          << " nOuterHits_max_ = " << nOuterHits_max_ << std::endl
          << " quality = " << quality_ << std::endl; 
    
    }

  };

  struct VertexIdentifier {
    VertexIdentifier():
      bIdentifyVertices_(false),
      pt_min_(0.2),
      pt_kink_min_(1.4),
      looper_eta_max_(0.1),
      logPrimSec_min_(0.2){

      double m[] = {0.050, 0.470, 0.525, 0.470, 0.525, 1.107, 1.125, 0.200};
      std::vector< double > masses(m, m+8);
      masses_ = masses;

      double a[] = {60, 40};
      std::vector< double > angles(a, a+1);
      angles_ = angles;

    };
  
    VertexIdentifier(const edm::ParameterSet& ps){
      bIdentifyVertices_  = ps.getParameter<bool>("bIdentifyVertices");
      angles_             = ps.getParameter< std::vector<double> >("angles");
      masses_             = ps.getParameter< std::vector<double> >("masses");
      pt_min_             = ps.getParameter<double>("pt_min");
      pt_kink_min_        = ps.getParameter<double>("pt_kink_min");
      looper_eta_max_     = ps.getParameter<double>("looper_eta_max");
      logPrimSec_min_     = ps.getParameter<double>("logPrimSec_min");
    }

    bool identifyVertices() const {return bIdentifyVertices_;}

    double angle_max() const {return angles_[0];}
    double angle_V0Conv_max() const {return angles_[1];}
    
    double pt_min() const {return pt_min_;}
    double pt_kink_min() const {return pt_kink_min_;}

    double mConv_max() const {return masses_[0];}
    double mK0_min() const {return masses_[1];}
    double mK0_max() const {return masses_[2];}
    double mK_min() const {return masses_[3];}
    double mK_max() const {return masses_[4];}
    double mLambda_min() const {return masses_[5];}
    double mLambda_max() const {return masses_[6];}
    double mNucl_min() const {return masses_[7];}
    
    double looper_eta_max() const {return looper_eta_max_;}
    double logPrimSec_min() const {return logPrimSec_min_;}

    bool bIdentifyVertices_;
    std::vector<double> angles_;
    std::vector<double> masses_;
    double pt_min_;
    double pt_kink_min_;
    double looper_eta_max_;
    double logPrimSec_min_;

    void Dump(std::ostream& out = std::cout) const {
      if(! out ) return;
      std::string s =  bIdentifyVertices_ ? "On" : "Off";
      out << "" << std::endl;
      out << "      ==== The Vertex Identifier is " << s.data() << " ====    " << std::endl;

      out << " pt_min_ = " << pt_min_
          << " pt_kink_min_ = " << pt_kink_min_ << std::endl
          << " looper_eta_max_ = " << looper_eta_max_  
          << " log10(P_Prim/P_Sec)_min " << logPrimSec_min_ << std::endl   
          << " Mass_conv > " << mConv_max() << std::endl
          << " " << mK0_min() << " < Mass_K0 < " << mK0_max() << std::endl
          << " " << mK_min() << " < Mass_K+- < " << mK_max() << std::endl
          << " " << mLambda_min() << " < Mass_Lambda < " << mLambda_max() << std::endl
          << " Mass_Nucl_ee > " << mNucl_min() << std::endl
          << " angle_max = " << angle_max() 
          << " angle_V0Conv_max = " << angle_V0Conv_max()  << std::endl; 
    
    }



  };


  TracksSelector tracksSelector_;
  VertexIdentifier vertexIdentifier_;
  math::XYZPoint pvtx_;

  static const double pion_mass2;
  static const double muon_mass2;
  static const double proton_mass2;

};

#endif