Inheritance diagram for reco::tau::PFRecoTauChargedHadronFromTrackPlugin:

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

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

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

virtual	~PFRecoTauChargedHadronFromTrackPlugin ()

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

virtual	~PFRecoTauChargedHadronBuilderPlugin ()

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 &)

virtual	~RecoTauEventHolderPlugin ()

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

	RecoTauNamedPlugin (const edm::ParameterSet &pset)

virtual	~RecoTauNamedPlugin ()

Private Types
typedef std::vector< reco::PFCandidatePtr >	PFCandPtrs

Private Attributes
double	dRcone_

bool	dRconeLimitedToJetArea_

double	dRmergeNeutralHadron_

double	dRmergePhoton_

math::XYZVector	magneticFieldStrength_

int	maxWarnings_

int	numWarnings_

RecoTauQualityCuts *	qcuts_

edm::InputTag	srcTracks_

edm::EDGetTokenT< reco::TrackCollection >	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

Definition at line 46 of file PFRecoTauChargedHadronFromTrackPlugin.cc.

Member Typedef Documentation

typedef std::vector<reco::PFCandidatePtr> reco::tau::PFRecoTauChargedHadronFromTrackPlugin::PFCandPtrs

private

Definition at line 57 of file PFRecoTauChargedHadronFromTrackPlugin.cc.

Constructor & Destructor Documentation

reco::tau::PFRecoTauChargedHadronFromTrackPlugin::PFRecoTauChargedHadronFromTrackPlugin	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &&	iC
	)

explicit

Definition at line 79 of file PFRecoTauChargedHadronFromTrackPlugin.cc.

References dRcone_, dRconeLimitedToJetArea_, dRmergeNeutralHadron_, dRmergePhoton_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), maxWarnings_, numWarnings_, qcuts_, srcTracks_, Tracks_token, and verbosity_.

     : PFRecoTauChargedHadronBuilderPlugin(pset,std::move(iC)),
       vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts"),std::move(iC)),
     qcuts_(0)
 {
   edm::ParameterSet qcuts_pset = pset.getParameterSet("qualityCuts").getParameterSet("signalQualityCuts");
   qcuts_ = new RecoTauQualityCuts(qcuts_pset);
 
   srcTracks_ = pset.getParameter<edm::InputTag>("srcTracks");
   Tracks_token = iC.consumes<reco::TrackCollection>(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.exists("verbosity") ) ?
     pset.getParameter<int>("verbosity") : 0;
 }

reco::tau::PFRecoTauChargedHadronFromTrackPlugin::~PFRecoTauChargedHadronFromTrackPlugin ( )

virtual

Definition at line 102 of file PFRecoTauChargedHadronFromTrackPlugin.cc.

References qcuts_.

 {
   delete qcuts_;
 }

Member Function Documentation

void reco::tau::PFRecoTauChargedHadronFromTrackPlugin::beginEvent ( )

virtual

Hook called at the beginning of the event.

Reimplemented from reco::tau::PFRecoTauChargedHadronBuilderPlugin.

Definition at line 108 of file PFRecoTauChargedHadronFromTrackPlugin.cc.

References reco::tau::RecoTauEventHolderPlugin::evt(), reco::tau::RecoTauEventHolderPlugin::evtSetup(), edm::EventSetup::get(), MagneticField::inTesla(), DetachedQuadStep_cff::magneticField, magneticFieldStrength_, reco::tau::RecoTauVertexAssociator::setEvent(), and vertexAssociator_.

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

PFRecoTauChargedHadronFromTrackPlugin::return_type reco::tau::PFRecoTauChargedHadronFromTrackPlugin::operator() ( const reco::PFJet & ) const

virtual

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

Implements reco::tau::PFRecoTauChargedHadronBuilderPlugin.

Definition at line 131 of file PFRecoTauChargedHadronFromTrackPlugin.cc.

References reco::tau::RecoTauVertexAssociator::associatedVertex(), muons2muons_cfi::chargedHadron, DEFINE_EDM_PLUGIN, reco::deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, dRcone_, dRconeLimitedToJetArea_, CaloRecoTauDiscriminationAgainstMuon_cfi::dRmatch, dRmergeNeutralHadron_, dRmergePhoton_, reco::LeafCandidate::eta(), reco::tau::RecoTauEventHolderPlugin::evt(), reco::tau::RecoTauQualityCuts::filterTrack(), reco::PFCandidate::gamma, edm::Event::getByToken(), reco::PFJet::getPFConstituents(), reco::PFCandidate::h0, edm::Ref< C, T, F >::isNonnull(), reco::Jet::jetArea(), reco::PFRecoTauChargedHadron::kTrack, magneticFieldStrength_, maxWarnings_, Min(), reco::tau::RecoTauNamedPlugin::name(), numWarnings_, convertSQLitetoXML_cfg::output, reco::LeafCandidate::phi(), Pi, reco::LeafCandidate::pt(), qcuts_, ctppsDiamondLocalTracks_cfi::resolution, RawParticle::setCharge(), reco::tau::setChargedHadronP4(), reco::tau::RecoTauQualityCuts::setPV(), mathSSE::sqrt(), HiIsolationCommonParameters_cff::track, l1t::tracks, Tracks_token, verbosity_, vertexAssociator_, and badGlobalMuonTaggersAOD_cff::vtx.

 {
   if ( verbosity_ ) {
     edm::LogPrint("TauChHFromTrack") << "<PFRecoTauChargedHadronFromTrackPlugin::operator()>:" ;
     edm::LogPrint("TauChHFromTrack") << " pluginName = " << name() ;
   }
 
   ChargedHadronVector output;
 
   const edm::Event& evt = (*this->evt());
 
   edm::Handle<reco::TrackCollection> 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 ) {
     reco::TrackRef 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 = TMath::Min(dRmatch, TMath::Sqrt(jetArea/TMath::Pi()));
       } else {
     if ( numWarnings_ < maxWarnings_ ) {
       edm::LogInfo("PFRecoTauChargedHadronFromTrackPlugin::operator()") 
         << "Jet: Pt = " << jet.pt() << ", eta = " << jet.eta() << ", phi = " << jet.phi() << " has area = " << jetArea << " !!" << std::endl;
       ++numWarnings_;
     }
     dRmatch = 0.1;
       }
     }
     if ( dR > dRmatch ) continue;
 
     // ignore tracks which fail quality cuts
     if ( !qcuts_->filterTrack(track) ) 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));
     chargedHadron->track_ = edm::Ptr<reco::Track>(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(track->referencePoint().x(), track->referencePoint().y(), track->referencePoint().z(), 0.);
     BaseParticlePropagator trackPropagator(RawParticle(chargedPionP4, chargedPionPos), 0., 0., magneticFieldStrength_.z());
     trackPropagator.setCharge(track->charge());
     trackPropagator.propagateToEcalEntrance(false);
     if ( trackPropagator.getSuccess() != 0 ) { 
       chargedHadron->positionAtECALEntrance_ = trackPropagator.vertex();
     } else {
       if ( chargedPionP4.pt() > 2. ) {
     edm::LogWarning("PFRecoTauChargedHadronFromTrackPlugin::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<PFCandidate_withDistance> neutralJetConstituents_withDistance;
     std::vector<reco::PFCandidatePtr> jetConstituents = jet.getPFConstituents();
     for ( std::vector<reco::PFCandidatePtr>::const_iterator jetConstituent = jetConstituents.begin();
       jetConstituent != jetConstituents.end(); ++jetConstituent ) {
       reco::PFCandidate::ParticleType jetConstituentType = (*jetConstituent)->particleId();
       if ( !(jetConstituentType == reco::PFCandidate::h0 || jetConstituentType == reco::PFCandidate::gamma) ) continue;
       double dR = deltaR((*jetConstituent)->positionAtECALEntrance(), chargedHadron->positionAtECALEntrance_);
       double dRmerge = -1.;      
       if      ( jetConstituentType == reco::PFCandidate::h0    ) dRmerge = dRmergeNeutralHadron_;
       else if ( jetConstituentType == reco::PFCandidate::gamma ) dRmerge = dRmergePhoton_;
       if ( dR < dRmerge ) {
     PFCandidate_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()*(track->ptError()/track->pt());
     double neutralEnSum = 0.;
     for ( std::vector<PFCandidate_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();
 }