#include <PFRecoTauChargedHadron.h>

Inheritance diagram for reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >:

Public Member Functions
void	beginEvent () override
	Hook called at the beginning of the event. More...

return_type	operator() (const reco::Jet &) const override
	Build a collection of chargedHadrons from objects in the input jet. More...

	PFRecoTauChargedHadronFromGenericTrackPlugin (const edm::ParameterSet &, edm::ConsumesCollector &&iC)

	~PFRecoTauChargedHadronFromGenericTrackPlugin () override

Public Member Functions inherited from reco::tau::PFRecoTauChargedHadronBuilderPlugin
	PFRecoTauChargedHadronBuilderPlugin (const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)

	~PFRecoTauChargedHadronBuilderPlugin () override

Public Member Functions inherited from reco::tau::RecoTauEventHolderPlugin
const edm::Event *	evt () const

edm::Event *	evt ()

const edm::EventSetup *	evtSetup () const

	RecoTauEventHolderPlugin (const edm::ParameterSet &pset)

void	setup (edm::Event &, const edm::EventSetup &)

	~RecoTauEventHolderPlugin () override

Public Member Functions inherited from reco::tau::RecoTauNamedPlugin
const std::string &	name () const

	RecoTauNamedPlugin (const edm::ParameterSet &pset)

virtual	~RecoTauNamedPlugin ()

Private Member Functions
bool	filterTrack (const edm::Handle< std::vector< TrackClass > > &, size_t iTrack) const

template<>
bool	filterTrack (const edm::Handle< std::vector< reco::Track > > &tracks, size_t iTrack) const

template<>
bool	filterTrack (const edm::Handle< std::vector< pat::PackedCandidate > > &tracks, size_t iTrack) const

XYZTLorentzVector	getTrackPos (const TrackClass &track) const

template<>
XYZTLorentzVector	getTrackPos (const reco::Track &track) const

template<>
XYZTLorentzVector	getTrackPos (const pat::PackedCandidate &track) const

double	getTrackPtError (const TrackClass &track) const

template<>
double	getTrackPtError (const reco::Track &track) const

template<>
double	getTrackPtError (const pat::PackedCandidate &cand) const

void	setChargedHadronTrack (PFRecoTauChargedHadron &chargedHadron, const edm::Ptr< TrackClass > &track) const

template<>
void	setChargedHadronTrack (PFRecoTauChargedHadron &chargedHadron, const edm::Ptr< reco::Track > &track) const

template<>
void	setChargedHadronTrack (PFRecoTauChargedHadron &chargedHadron, const edm::Ptr< pat::PackedCandidate > &track) const

Private Attributes
double	dRcone_

bool	dRconeLimitedToJetArea_

double	dRmergeNeutralHadron_

double	dRmergePhoton_

math::XYZVector	magneticFieldStrength_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticFieldToken_

std::unique_ptr< RecoTauQualityCuts >	qcuts_

edm::InputTag	srcTracks_

edm::EDGetTokenT< std::vector< TrackClass > >	Tracks_token

int	verbosity_

RecoTauVertexAssociator	vertexAssociator_

Static Private Attributes
static constexpr unsigned int	maxWarnings_ = 3

static std::atomic< unsigned int >	numWarnings_ {0}

Additional Inherited Members
Public Types inherited from reco::tau::PFRecoTauChargedHadronBuilderPlugin
typedef std::vector< std::unique_ptr< PFRecoTauChargedHadron > >	ChargedHadronVector

typedef ChargedHadronVector	return_type

Detailed Description

template<class TrackClass>
class reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >

Definition at line 13 of file PFRecoTauChargedHadron.h.

Constructor & Destructor Documentation

◆ PFRecoTauChargedHadronFromGenericTrackPlugin()

template<class TrackClass >

reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::PFRecoTauChargedHadronFromGenericTrackPlugin	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &&	iC
	)

explicit

Definition at line 95 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

         : PFRecoTauChargedHadronBuilderPlugin(pset, std::move(iC)),
           vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts"), std::move(iC)),
           qcuts_(nullptr),
           magneticFieldToken_(iC.esConsumes()) {
       edm::ParameterSet qcuts_pset = pset.getParameterSet("qualityCuts").getParameterSet("signalQualityCuts");
       qcuts_ = std::make_unique<RecoTauQualityCuts>(qcuts_pset);
 
       srcTracks_ = pset.getParameter<edm::InputTag>("srcTracks");
       Tracks_token = iC.consumes<std::vector<TrackClass> >(srcTracks_);
       dRcone_ = pset.getParameter<double>("dRcone");
       dRconeLimitedToJetArea_ = pset.getParameter<bool>("dRconeLimitedToJetArea");
 
       dRmergeNeutralHadron_ = pset.getParameter<double>("dRmergeNeutralHadron");
       dRmergePhoton_ = pset.getParameter<double>("dRmergePhoton");
 
       verbosity_ = pset.getParameter<int>("verbosity");
     }

◆ ~PFRecoTauChargedHadronFromGenericTrackPlugin()

template<class TrackClass >

reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::~PFRecoTauChargedHadronFromGenericTrackPlugin ( )

override

Definition at line 116 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

116 {}

Member Function Documentation

◆ beginEvent()

template<class TrackClass >

void reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::beginEvent ( )

overridevirtual

Hook called at the beginning of the event.

Reimplemented from reco::tau::PFRecoTauChargedHadronBuilderPlugin.

Definition at line 120 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

                                                                               {
       vertexAssociator_.setEvent(*this->evt());
 
       magneticFieldStrength_ = evtSetup()->getData(magneticFieldToken_).inTesla(GlobalPoint(0., 0., 0.));
     }

◆ filterTrack() [1/3]

template<class TrackClass >

bool reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::filterTrack	(	const edm::Handle< std::vector< TrackClass > > &	,
		size_t	iTrack
	)		const

private

◆ filterTrack() [2/3]

template<>

bool reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< reco::Track >::filterTrack	(	const edm::Handle< std::vector< reco::Track > > &	tracks,
		size_t	iTrack
	)		const

private

Definition at line 127 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References DiMuonV_cfg::tracks.

                                                                              {
       // ignore tracks which fail quality cuts
       reco::TrackRef trackRef(tracks, iTrack);
       return qcuts_->filterTrack(trackRef);
     }

◆ filterTrack() [3/3]

template<>

bool reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< pat::PackedCandidate >::filterTrack	(	const edm::Handle< std::vector< pat::PackedCandidate > > &	tracks,
		size_t	iTrack
	)		const

private

Definition at line 135 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

                                                                                       {
       // ignore tracks which fail quality cuts
       const pat::PackedCandidate& cand = (*tracks)[iTrack];
       if (cand.charge() == 0)
         return false;
 
       return qcuts_->filterChargedCand(cand);
     }

◆ getTrackPos() [1/3]

template<class TrackClass >

XYZTLorentzVector reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::getTrackPos ( const TrackClass & track ) const

private

◆ getTrackPos() [2/3]

template<>

XYZTLorentzVector reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< reco::Track >::getTrackPos ( const reco::Track & track ) const

private

Definition at line 180 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References HLT_2024v12_cff::track.

                                       {
       return XYZTLorentzVector(track.referencePoint().x(), track.referencePoint().y(), track.referencePoint().z(), 0.);
     }

◆ getTrackPos() [3/3]

template<>

XYZTLorentzVector reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< pat::PackedCandidate >::getTrackPos ( const pat::PackedCandidate & track ) const

private

Definition at line 186 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References HLT_2024v12_cff::track.

                                                {
       return XYZTLorentzVector(track.vertex().x(), track.vertex().y(), track.vertex().z(), 0.);
     }

◆ getTrackPtError() [1/3]

template<class TrackClass >

double reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::getTrackPtError ( const TrackClass & track ) const

private

◆ getTrackPtError() [2/3]

template<>

double reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< reco::Track >::getTrackPtError ( const reco::Track & track ) const

private

Definition at line 158 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References HLT_2024v12_cff::track.

                                                                                                                 {
       return track.ptError();
     }

◆ getTrackPtError() [3/3]

template<>

double reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< pat::PackedCandidate >::getTrackPtError ( const pat::PackedCandidate & cand ) const

private

Definition at line 163 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References funct::abs(), and HLT_2024v12_cff::track.

                                               {
       double trackPtError =
           0.06;  // MB: Approximate avarage track PtError by 2.5% (barrel), 4% (transition), 6% (endcaps) lostTracks w/o detailed track information available (after TRK-11-001)
       const reco::Track* track(cand.bestTrack());
       if (track != nullptr) {
         trackPtError = track->ptError();
       } else {
         if (std::abs(cand.eta()) < 0.9)
           trackPtError = 0.025;
         else if (std::abs(cand.eta()) < 1.4)
           trackPtError = 0.04;
       }
       return trackPtError;
     }

◆ operator()()

template<class TrackClass >

PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::return_type reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::operator() ( const reco::Jet & ) const

overridevirtual

Build a collection of chargedHadrons from objects in the input jet.

Implements reco::tau::PFRecoTauChargedHadronBuilderPlugin.

Definition at line 204 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References funct::abs(), reco::tau::atECALEntrance(), HPSPFTauProducerPuppi_cfi::chargedHadron, reco::deltaR(), HGC3DClusterGenMatchSelector_cfi::dR, edm::Event::getByToken(), metsig::jet, reco::PFRecoTauChargedHadron::kTrack, M_PI, SiStripPI::min, eostools::move(), Skims_PA_cff::name, convertSQLitetoXML_cfg::output, AlCaHLTBitMon_ParallelJobs::p, EgammaValidation_cff::pdgId, BaseParticlePropagator::propagateToEcalEntrance(), L1TObjectsTimingClient_cff::resolution, reco::tau::setChargedHadronP4(), jetUpdater_cfi::sort, mathSSE::sqrt(), HLT_2024v12_cff::track, DiMuonV_cfg::tracks, and L1BJetProducer_cff::vtx.

                                                                                                  {
       if (verbosity_) {
         edm::LogPrint("TauChHFromTrack") << "<PFRecoTauChargedHadronFromGenericTrackPlugin::operator()>:";
         edm::LogPrint("TauChHFromTrack") << " pluginName = " << name();
       }
 
       ChargedHadronVector output;
 
       const edm::Event& evt = (*this->evt());
 
       edm::Handle<std::vector<TrackClass> > tracks;
       evt.getByToken(Tracks_token, tracks);
 
       qcuts_->setPV(vertexAssociator_.associatedVertex(jet));
       float jEta = jet.eta();
       float jPhi = jet.phi();
       size_t numTracks = tracks->size();
       for (size_t iTrack = 0; iTrack < numTracks; ++iTrack) {
         const TrackClass& track = (*tracks)[iTrack];
 
         // consider tracks in vicinity of tau-jet candidate only
         double dR = deltaR(track.eta(), track.phi(), jEta, jPhi);
         double dRmatch = dRcone_;
         if (dRconeLimitedToJetArea_) {
           double jetArea = jet.jetArea();
           if (jetArea > 0.) {
             dRmatch = std::min(dRmatch, sqrt(jetArea / M_PI));
           } else {
             if (numWarnings_ < maxWarnings_) {
               edm::LogInfo("PFRecoTauChargedHadronFromGenericTrackPlugin::operator()")
                   << "Jet: Pt = " << jet.pt() << ", eta = " << jet.eta() << ", phi = " << jet.phi()
                   << " has area = " << jetArea << " !!" << std::endl;
               ++numWarnings_;
             }
             dRmatch = 0.1;
           }
         }
         if (dR > dRmatch)
           continue;
 
         if (!this->filterTrack(tracks, iTrack))
           continue;
 
         reco::Candidate::Charge trackCharge_int = 0;
         if (track.charge() > 0.)
           trackCharge_int = +1;
         else if (track.charge() < 0.)
           trackCharge_int = -1;
 
         const double chargedPionMass = 0.13957;  // GeV
         double chargedPionP = track.p();
         double chargedPionEn = TMath::Sqrt(chargedPionP * chargedPionP + chargedPionMass * chargedPionMass);
         reco::Candidate::LorentzVector chargedPionP4(track.px(), track.py(), track.pz(), chargedPionEn);
 
         reco::Vertex::Point vtx(0., 0., 0.);
         if (vertexAssociator_.associatedVertex(jet).isNonnull())
           vtx = vertexAssociator_.associatedVertex(jet)->position();
 
         auto chargedHadron = std::make_unique<PFRecoTauChargedHadron>(
             trackCharge_int, chargedPionP4, vtx, 0, true, PFRecoTauChargedHadron::kTrack);
 
         setChargedHadronTrack(*chargedHadron, edm::Ptr<TrackClass>(tracks, iTrack));
 
         // CV: Take code for propagating track to ECAL entrance
         //     from RecoParticleFlow/PFTracking/src/PFTrackTransformer.cc
         //     to make sure propagation is done in the same way as for charged PFCandidates.
         //
         //     The following replacements need to be made
         //       outerMomentum -> momentum
         //       outerPosition -> referencePoint
         //     in order to run on AOD input
         //    (outerMomentum and outerPosition require access to reco::TrackExtra objects, which are available in RECO only)
         //
         XYZTLorentzVector chargedPionPos(getTrackPos(track));
         RawParticle p(chargedPionP4, chargedPionPos);
         p.setCharge(track.charge());
         BaseParticlePropagator trackPropagator(p, 0., 0., magneticFieldStrength_.z());
         trackPropagator.propagateToEcalEntrance(false);
         if (trackPropagator.getSuccess() != 0) {
           chargedHadron->positionAtECALEntrance_ = trackPropagator.particle().vertex();
         } else {
           if (chargedPionP4.pt() > 2. and std::abs(chargedPionP4.eta()) < 3.) {
             edm::LogWarning("PFRecoTauChargedHadronFromGenericTrackPlugin::operator()")
                 << "Failed to propagate track: Pt = " << track.pt() << ", eta = " << track.eta()
                 << ", phi = " << track.phi() << " to ECAL entrance !!" << std::endl;
           }
           chargedHadron->positionAtECALEntrance_ = math::XYZPointF(0., 0., 0.);
         }
 
         std::vector<Candidate_withDistance> neutralJetConstituents_withDistance;
         for (const auto& jetConstituent : jet.daughterPtrVector()) {
           int pdgId = jetConstituent->pdgId();
           if (!(pdgId == 130 || pdgId == 22))
             continue;
           double dR = deltaR(atECALEntrance(&*jetConstituent, magneticFieldStrength_.z()),
                              chargedHadron->positionAtECALEntrance_);
           double dRmerge = -1.;
           if (pdgId == 130)
             dRmerge = dRmergeNeutralHadron_;
           else if (pdgId == 22)
             dRmerge = dRmergePhoton_;
           if (dR < dRmerge) {
             Candidate_withDistance jetConstituent_withDistance;
             jetConstituent_withDistance.pfCandidate_ = jetConstituent;
             jetConstituent_withDistance.distance_ = dR;
             neutralJetConstituents_withDistance.push_back(jetConstituent_withDistance);
             chargedHadron->addDaughter(jetConstituent);
           }
         }
         std::sort(
             neutralJetConstituents_withDistance.begin(), neutralJetConstituents_withDistance.end(), isSmallerDistance);
 
         const double caloResolutionCoeff =
             1.0;  // CV: approximate ECAL + HCAL calorimeter resolution for hadrons by 100%*sqrt(E)
         double resolutionTrackP = track.p() * (getTrackPtError(track) / track.pt());
         double neutralEnSum = 0.;
         for (std::vector<Candidate_withDistance>::const_iterator nextNeutral =
                  neutralJetConstituents_withDistance.begin();
              nextNeutral != neutralJetConstituents_withDistance.end();
              ++nextNeutral) {
           double nextNeutralEn = nextNeutral->pfCandidate_->energy();
           double resolutionCaloEn = caloResolutionCoeff * sqrt(neutralEnSum + nextNeutralEn);
           double resolution = sqrt(resolutionTrackP * resolutionTrackP + resolutionCaloEn * resolutionCaloEn);
           if ((neutralEnSum + nextNeutralEn) < (track.p() + 2. * resolution)) {
             chargedHadron->neutralPFCandidates_.push_back(nextNeutral->pfCandidate_);
             neutralEnSum += nextNeutralEn;
           } else {
             break;
           }
         }
 
         setChargedHadronP4(*chargedHadron);
 
         if (verbosity_) {
           edm::LogPrint("TauChHFromTrack") << *chargedHadron;
         }
 
         output.push_back(std::move(chargedHadron));
       }
 
       return output;
     }

◆ setChargedHadronTrack() [1/3]

template<class TrackClass >

void reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::setChargedHadronTrack	(	PFRecoTauChargedHadron &	chargedHadron,
		const edm::Ptr< TrackClass > &	track
	)		const

private

◆ setChargedHadronTrack() [2/3]

template<>

void reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< reco::Track >::setChargedHadronTrack	(	PFRecoTauChargedHadron &	chargedHadron,
		const edm::Ptr< reco::Track > &	track
	)		const

private

Definition at line 146 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References HPSPFTauProducerPuppi_cfi::chargedHadron, and HLT_2024v12_cff::track.

                                                                                      {
       chargedHadron.track_ = track;
     }

◆ setChargedHadronTrack() [3/3]

template<>

void reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< pat::PackedCandidate >::setChargedHadronTrack	(	PFRecoTauChargedHadron &	chargedHadron,
		const edm::Ptr< pat::PackedCandidate > &	track
	)		const

private

Definition at line 152 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References HPSPFTauProducerPuppi_cfi::chargedHadron, and HLT_2024v12_cff::track.

                                                                                               {
       chargedHadron.lostTrackCandidate_ = track;
     }