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

int	maxWarnings_

int	numWarnings_

RecoTauQualityCuts *	qcuts_

edm::InputTag	srcTracks_

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

int	verbosity_

RecoTauVertexAssociator	vertexAssociator_

Additional Inherited Members
Public Types inherited from reco::tau::PFRecoTauChargedHadronBuilderPlugin
typedef boost::ptr_vector< PFRecoTauChargedHadron >	ChargedHadronVector

typedef std::auto_ptr< ChargedHadronVector >	return_type

Detailed Description

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

Definition at line 12 of file PFRecoTauChargedHadron.h.

Constructor & Destructor Documentation

template<class TrackClass >

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

explicit

Definition at line 91 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

     : PFRecoTauChargedHadronBuilderPlugin(pset,std::move(iC)),
       vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts"),std::move(iC)),
     qcuts_(nullptr)
 {
   edm::ParameterSet qcuts_pset = pset.getParameterSet("qualityCuts").getParameterSet("signalQualityCuts");
   qcuts_ = new 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");
 
   numWarnings_ = 0;
   maxWarnings_ = 3;
 
   verbosity_ = pset.getParameter<int>("verbosity");
 }

template<class TrackClass >

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

override

Definition at line 114 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::qcuts_.

 {
   delete qcuts_;
 }

Member Function Documentation

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 121 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References reco::tau::RecoTauEventHolderPlugin::evt(), reco::tau::RecoTauEventHolderPlugin::evtSetup(), edm::EventSetup::get(), MagneticField::inTesla(), seedCreatorFromRegionConsecutiveHitsEDProducer_cff::magneticField, reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::magneticFieldStrength_, reco::tau::RecoTauVertexAssociator::setEvent(), and reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::vertexAssociator_.

 {
   vertexAssociator_.setEvent(*this->evt());
 
   edm::ESHandle<MagneticField> magneticField;
   const edm::EventSetup* evtSetup(this->evtSetup());
   evtSetup->get<IdealMagneticFieldRecord>().get(magneticField);
   magneticFieldStrength_ = magneticField->inTesla(GlobalPoint(0.,0.,0.));
 }

template<class TrackClass >

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

private

Referenced by reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::operator()().

template<>

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

private

Definition at line 132 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References reco::tau::RecoTauQualityCuts::filterTrack(), reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::qcuts_, and l1t::tracks.

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

template<>

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

private

Definition at line 139 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References pat::PackedCandidate::charge(), reco::tau::RecoTauQualityCuts::filterChargedCand(), and reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::qcuts_.

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

template<class TrackClass >

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

private

Referenced by reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::operator()().

template<>

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

private

Definition at line 179 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References reco::TrackBase::referencePoint().

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

template<>

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

private

Definition at line 184 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References pat::PackedCandidate::vertex().

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

template<class TrackClass >

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

private

Referenced by reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::operator()().

template<>

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

private

Definition at line 159 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References reco::TrackBase::ptError().

                                                                                                             {
   return track.ptError();
 }

template<>

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

private

Definition at line 164 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References funct::abs(), pat::PackedCandidate::bestTrack(), pat::PackedCandidate::eta(), and HiIsolationCommonParameters_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;
 }

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.

 {
   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();
 
     std::auto_ptr<PFRecoTauChargedHadron> chargedHadron(new 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(chargedHadron);
   }
 
   return output.release();
 }

template<class TrackClass >

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

private

Referenced by reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::operator()().

template<>

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

private

Definition at line 149 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References HiIsolationCommonParameters_cff::track, and reco::PFRecoTauChargedHadron::track_.

                                                                                                                                                                {
   chargedHadron.track_ = track;
 }

template<>

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

private

Definition at line 154 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

References reco::PFRecoTauChargedHadron::lostTrackCandidate_, and HiIsolationCommonParameters_cff::track.

                                                                                                                                                                                  {
   chargedHadron.lostTrackCandidate_ = track;
 }