PrimaryVertexAssignment.h

Go to the documentation of this file.

#ifndef CommonTools_PFCandProducer_PrimaryVertexAssignment_
#define CommonTools_PFCandProducer_PrimaryVertexAssignment_
 
#include "DataFormats/RecoCandidate/interface/RecoChargedRefCandidate.h"
 
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
#include "FWCore/Framework/interface/Event.h"
 
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
 
class PrimaryVertexAssignment {
public:
  enum Quality {
    UsedInFit = 7,
    PrimaryDz = 6,
    PrimaryV0 = 5,
    BTrack = 4,
    Unused = 3,
    OtherDz = 2,
    NotReconstructedPrimary = 1,
    Unassigned = 0
  };
 
  PrimaryVertexAssignment(const edm::ParameterSet& iConfig)
      : maxDzSigForPrimaryAssignment_(iConfig.getParameter<double>("maxDzSigForPrimaryAssignment")),
        maxDzForPrimaryAssignment_(iConfig.getParameter<double>("maxDzForPrimaryAssignment")),
        maxDzErrorForPrimaryAssignment_(iConfig.getParameter<double>("maxDzErrorForPrimaryAssignment")),
        maxDtSigForPrimaryAssignment_(iConfig.getParameter<double>("maxDtSigForPrimaryAssignment")),
        maxJetDeltaR_(iConfig.getParameter<double>("maxJetDeltaR")),
        minJetPt_(iConfig.getParameter<double>("minJetPt")),
        maxDistanceToJetAxis_(iConfig.getParameter<double>("maxDistanceToJetAxis")),
        maxDzForJetAxisAssigment_(iConfig.getParameter<double>("maxDzForJetAxisAssigment")),
        maxDxyForJetAxisAssigment_(iConfig.getParameter<double>("maxDxyForJetAxisAssigment")),
        maxDxySigForNotReconstructedPrimary_(iConfig.getParameter<double>("maxDxySigForNotReconstructedPrimary")),
        maxDxyForNotReconstructedPrimary_(iConfig.getParameter<double>("maxDxyForNotReconstructedPrimary")),
        useTiming_(iConfig.getParameter<bool>("useTiming")),
        preferHighRanked_(iConfig.getParameter<bool>("preferHighRanked")) {}
 
  ~PrimaryVertexAssignment() {}
 
  std::pair<int, PrimaryVertexAssignment::Quality> chargedHadronVertex(
      const reco::VertexCollection& vertices,
      const reco::TrackRef& trackRef,
      const reco::Track* track,
      float trackTime,
      float trackTimeResolution,  // <0 if timing not available for this object
      const edm::View<reco::Candidate>& jets,
      const TransientTrackBuilder& builder) const;
 
  std::pair<int, PrimaryVertexAssignment::Quality> chargedHadronVertex(
      const reco::VertexCollection& vertices,
      const reco::TrackRef& trackRef,
      float trackTime,
      float trackTimeResolution,  // <0 if timing not available for this object
      const edm::View<reco::Candidate>& jets,
      const TransientTrackBuilder& builder) const {
    return chargedHadronVertex(vertices, trackRef, &(*trackRef), trackTime, trackTimeResolution, jets, builder);
  }
 
  std::pair<int, PrimaryVertexAssignment::Quality> chargedHadronVertex(const reco::VertexCollection& vertices,
                                                                       const reco::PFCandidate& pfcand,
                                                                       const edm::View<reco::Candidate>& jets,
                                                                       const TransientTrackBuilder& builder) const {
    float time = 0, timeResolution = -1;
    if (useTiming_ && pfcand.isTimeValid()) {
      time = pfcand.time();
      timeResolution = pfcand.timeError();
    }
    if (pfcand.gsfTrackRef().isNull()) {
      if (pfcand.trackRef().isNull())
        return std::pair<int, PrimaryVertexAssignment::Quality>(-1, PrimaryVertexAssignment::Unassigned);
      else
        return chargedHadronVertex(vertices, pfcand.trackRef(), time, timeResolution, jets, builder);
    }
    return chargedHadronVertex(
        vertices, reco::TrackRef(), &(*pfcand.gsfTrackRef()), time, timeResolution, jets, builder);
  }
  std::pair<int, PrimaryVertexAssignment::Quality> chargedHadronVertex(const reco::VertexCollection& vertices,
                                                                       const reco::RecoChargedRefCandidate& chcand,
                                                                       const edm::ValueMap<float>* trackTimeTag,
                                                                       const edm::ValueMap<float>* trackTimeResoTag,
                                                                       const edm::View<reco::Candidate>& jets,
                                                                       const TransientTrackBuilder& builder) const {
    float time = 0, timeResolution = -1;
    if (useTiming_) {
      time = (*trackTimeTag)[chcand.track()];
      timeResolution = (*trackTimeResoTag)[chcand.track()];
    }
    if (chcand.track().isNull())
      return std::pair<int, PrimaryVertexAssignment::Quality>(-1, PrimaryVertexAssignment::Unassigned);
    return chargedHadronVertex(vertices, chcand.track(), time, timeResolution, jets, builder);
  }
 
private:
  double maxDzSigForPrimaryAssignment_;
  double maxDzForPrimaryAssignment_;
  double maxDzErrorForPrimaryAssignment_;
  double maxDtSigForPrimaryAssignment_;
  double maxJetDeltaR_;
  double minJetPt_;
  double maxDistanceToJetAxis_;
  double maxDzForJetAxisAssigment_;
  double maxDxyForJetAxisAssigment_;
  double maxDxySigForNotReconstructedPrimary_;
  double maxDxyForNotReconstructedPrimary_;
  bool useTiming_;
  bool preferHighRanked_;
};
 
#endif