#include <PFRecoTauTagInfoAlgorithm.h>

Public Member Functions
reco::PFTauTagInfo	buildPFTauTagInfo (const reco::PFJetRef &, const reco::PFCandidateRefVector &, const reco::TrackRefVector &, const reco::Vertex &)

	PFRecoTauTagInfoAlgorithm ()

	PFRecoTauTagInfoAlgorithm (const edm::ParameterSet &)

	~PFRecoTauTagInfoAlgorithm ()

Private Attributes
double	ChargedHadrCand_tkmaxChi2_

double	ChargedHadrCand_tkmaxipt_

int	ChargedHadrCand_tkminPixelHitsn_

double	ChargedHadrCand_tkminPt_

int	ChargedHadrCand_tkminTrackerHitsn_

double	ChargedHadrCand_tkPVmaxDZ_

double	ChargedHadronsAssociationCone_

double	GammaCand_EcalclusMinEt_

double	NeutrHadrCand_HcalclusMinEt_

double	tkmaxChi2_

double	tkmaxipt_

int	tkminPixelHitsn_

double	tkminPt_

int	tkminTrackerHitsn_

double	tkPVmaxDZ_

bool	UsePVconstraint_

Detailed Description

Definition at line 15 of file PFRecoTauTagInfoAlgorithm.h.

Constructor & Destructor Documentation

PFRecoTauTagInfoAlgorithm::PFRecoTauTagInfoAlgorithm ( )

inline

Definition at line 17 of file PFRecoTauTagInfoAlgorithm.h.

17 {}

PFRecoTauTagInfoAlgorithm::PFRecoTauTagInfoAlgorithm ( const edm::ParameterSet & parameters )

Definition at line 5 of file PFRecoTauTagInfoAlgorithm.cc.

References edm::ParameterSet::getParameter().

                                                                                      {
   // parameters of the considered charged hadr. PFCandidates, based on their rec. tk properties :
   ChargedHadronsAssociationCone_      = parameters.getParameter<double>("ChargedHadrCand_AssociationCone");
   ChargedHadrCand_tkminPt_            = parameters.getParameter<double>("ChargedHadrCand_tkminPt");
   ChargedHadrCand_tkminPixelHitsn_    = parameters.getParameter<int>("ChargedHadrCand_tkminPixelHitsn");
   ChargedHadrCand_tkminTrackerHitsn_  = parameters.getParameter<int>("ChargedHadrCand_tkminTrackerHitsn");
   ChargedHadrCand_tkmaxipt_           = parameters.getParameter<double>("ChargedHadrCand_tkmaxipt");
   ChargedHadrCand_tkmaxChi2_          = parameters.getParameter<double>("ChargedHadrCand_tkmaxChi2");
   // parameters of the considered neutral hadr. PFCandidates, based on their rec. HCAL clus. properties :
   NeutrHadrCand_HcalclusMinEt_         = parameters.getParameter<double>("NeutrHadrCand_HcalclusMinEt");
   // parameters of the considered gamma PFCandidates, based on their rec. ECAL clus. properties :
   GammaCand_EcalclusMinEt_             = parameters.getParameter<double>("GammaCand_EcalclusMinEt");
   // parameters of the considered rec. Tracks (these ones catched through a JetTracksAssociation object, not through the charged hadr. PFCandidates inside the PFJet ; the motivation for considering them is the need for checking that a selection by the charged hadr. PFCandidates is equivalent to a selection by the rec. Tracks.) :
   tkminPt_                            = parameters.getParameter<double>("tkminPt");
   tkminPixelHitsn_                    = parameters.getParameter<int>("tkminPixelHitsn");
   tkminTrackerHitsn_                  = parameters.getParameter<int>("tkminTrackerHitsn");
   tkmaxipt_                           = parameters.getParameter<double>("tkmaxipt");
   tkmaxChi2_                          = parameters.getParameter<double>("tkmaxChi2");
   //
   UsePVconstraint_                    = parameters.getParameter<bool>("UsePVconstraint");
   ChargedHadrCand_tkPVmaxDZ_          = parameters.getParameter<double>("ChargedHadrCand_tkPVmaxDZ");
   tkPVmaxDZ_                          = parameters.getParameter<double>("tkPVmaxDZ");
 }

PFRecoTauTagInfoAlgorithm::~PFRecoTauTagInfoAlgorithm ( )

inline

Definition at line 19 of file PFRecoTauTagInfoAlgorithm.h.

19 {}

Member Function Documentation

PFTauTagInfo PFRecoTauTagInfoAlgorithm::buildPFTauTagInfo	(	const reco::PFJetRef &	thePFJet,
		const reco::PFCandidateRefVector &	thePFCandsInEvent,
		const reco::TrackRefVector &	theTracks,
		const reco::Vertex &	thePV
	)

Definition at line 29 of file PFRecoTauTagInfoAlgorithm.cc.

References delta, reco::deltaR2(), eta(), TauTagTools::filteredPFChargedHadrCands(), TauTagTools::filteredPFGammaCands(), TauTagTools::filteredPFNeutrHadrCands(), TauTagTools::filteredTracks(), reco::btau::jetEta, reco::btau::jetPhi, phi, edm::RefVector< C, T, F >::push_back(), reco::PFTauTagInfo::setPFChargedHadrCands(), reco::PFTauTagInfo::setPFGammaCands(), reco::PFTauTagInfo::setpfjetRef(), reco::PFTauTagInfo::setPFNeutrHadrCands(), reco::BaseTauTagInfo::setTracks(), and reco::Vertex::z().

                                                                                                                                                                                     {
   PFTauTagInfo resultExtended;
   resultExtended.setpfjetRef(thePFJet);
 
   PFCandidateRefVector thePFCands;
   const float jetPhi = (*thePFJet).phi();
   const float jetEta = (*thePFJet).eta();
   auto dr2 = [jetPhi,jetEta](float phi, float eta) { return reco::deltaR2(jetEta,jetPhi,eta,phi);};
   for (auto iPFCand : thePFCandsInEvent){
     float delta = dr2((*iPFCand).phi(),(*iPFCand).eta());
     if (delta < ChargedHadronsAssociationCone_*ChargedHadronsAssociationCone_)  thePFCands.push_back(iPFCand);
   }
   bool pvIsFake = (thePV.z() < -500.);
 
   PFCandidateRefVector theFilteredPFChargedHadrCands;
   if (UsePVconstraint_ && !pvIsFake) theFilteredPFChargedHadrCands=TauTagTools::filteredPFChargedHadrCands(thePFCands,ChargedHadrCand_tkminPt_,ChargedHadrCand_tkminPixelHitsn_,ChargedHadrCand_tkminTrackerHitsn_,ChargedHadrCand_tkmaxipt_,ChargedHadrCand_tkmaxChi2_,ChargedHadrCand_tkPVmaxDZ_, thePV, thePV.z());
   else theFilteredPFChargedHadrCands=TauTagTools::filteredPFChargedHadrCands(thePFCands,ChargedHadrCand_tkminPt_,ChargedHadrCand_tkminPixelHitsn_,ChargedHadrCand_tkminTrackerHitsn_,ChargedHadrCand_tkmaxipt_,ChargedHadrCand_tkmaxChi2_, thePV);
   resultExtended.setPFChargedHadrCands(theFilteredPFChargedHadrCands);
   resultExtended.setPFNeutrHadrCands(TauTagTools::filteredPFNeutrHadrCands(thePFCands,NeutrHadrCand_HcalclusMinEt_));
   resultExtended.setPFGammaCands(TauTagTools::filteredPFGammaCands(thePFCands,GammaCand_EcalclusMinEt_));
 
   TrackRefVector theFilteredTracks;
   if (UsePVconstraint_ && !pvIsFake) theFilteredTracks=TauTagTools::filteredTracks(theTracks,tkminPt_,tkminPixelHitsn_,tkminTrackerHitsn_,tkmaxipt_,tkmaxChi2_,tkPVmaxDZ_,thePV, thePV.z());
   else theFilteredTracks=TauTagTools::filteredTracks(theTracks,tkminPt_,tkminPixelHitsn_,tkminTrackerHitsn_,tkmaxipt_,tkmaxChi2_,thePV);
   resultExtended.setTracks(theFilteredTracks);
 
   return resultExtended;
 }