Inheritance diagram for PFRecoTauDiscriminationByFlight:

Public Member Functions
void	beginEvent (const edm::Event &evt, const edm::EventSetup &es) override

double	discriminate (const reco::PFTauRef &) const override

	PFRecoTauDiscriminationByFlight (const edm::ParameterSet &pset)

	~PFRecoTauDiscriminationByFlight () override

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
virtual double	discriminate (const TauRef &tau) const =0

virtual void	endEvent (edm::Event &)

void	produce (edm::Event &, const edm::EventSetup &) override

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

	~TauDiscriminationProducerBase () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Private Attributes
edm::Handle< reco::BeamSpot >	beamspot_

edm::InputTag	bsSource_

const TransientTrackBuilder *	builder_

double	oneProngSig_

bool	refitPV_

double	threeProngSig_

edm::InputTag	vertexSource_

edm::Handle< reco::VertexCollection >	vertices_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
typedef std::vector< TauType >	TauCollection

typedef edm::Ref< TauCollection >	TauRef

typedef edm::RefProd< TauCollection >	TauRefProd

Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string	moduleLabel_

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 13 of file RecoTauDiscriminationByFlight.cc.

Constructor & Destructor Documentation

PFRecoTauDiscriminationByFlight::PFRecoTauDiscriminationByFlight ( const edm::ParameterSet & pset )

Definition at line 30 of file RecoTauDiscriminationByFlight.cc.

References bsSource_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), oneProngSig_, refitPV_, threeProngSig_, and vertexSource_.

                                 :PFTauDiscriminationProducerBase(pset) {
   vertexSource_ = pset.getParameter<edm::InputTag>("vertexSource");
   oneProngSig_ = pset.exists("oneProngSigCut") ?
     pset.getParameter<double>("oneProngSigCut") : -1.;
   threeProngSig_ = pset.exists("threeProngSigCut") ?
     pset.getParameter<double>("threeProngSigCut") : -1.;
   refitPV_ = pset.getParameter<bool>("refitPV");
   if (refitPV_)
     bsSource_ = pset.getParameter<edm::InputTag>("beamspot");
 }

PFRecoTauDiscriminationByFlight::~PFRecoTauDiscriminationByFlight ( )

inlineoverride

Definition at line 16 of file RecoTauDiscriminationByFlight.cc.

References beginEvent(), and discriminate().

16 {}

Member Function Documentation

void PFRecoTauDiscriminationByFlight::beginEvent	(	const edm::Event &	evt,
		const edm::EventSetup &	es
	)

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 42 of file RecoTauDiscriminationByFlight.cc.

References beamspot_, bsSource_, builder_, edm::EventSetup::get(), edm::Event::getByLabel(), edm::ESHandle< T >::product(), refitPV_, vertexSource_, and vertices_.

Referenced by ~PFRecoTauDiscriminationByFlight().

                                                   {
   evt.getByLabel(vertexSource_, vertices_);
   if (refitPV_)
     evt.getByLabel(bsSource_, beamspot_);
   edm::ESHandle<TransientTrackBuilder> transTrackBuilder;
   es.get<TransientTrackRecord>().get("TransientTrackBuilder",transTrackBuilder);
   builder_ = transTrackBuilder.product();
 }

double PFRecoTauDiscriminationByFlight::discriminate ( const reco::PFTauRef & tau ) const

override

Definition at line 52 of file RecoTauDiscriminationByFlight.cc.

References beamspot_, TransientTrackBuilder::build(), builder_, reco::TemplatedSecondaryVertex< SV >::computeDist2d(), DEFINE_FWK_MODULE, TauDiscriminationProducerBase< TauType, TauDiscriminator >::prediscriminantFailValue_, MetAnalyzer::pv(), refitPV_, IPTools::signedTransverseImpactParameter(), Measurement1D::significance(), pfDeepBoostedJetPreprocessParams_cfi::sv, HiIsolationCommonParameters_cff::track, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), and KalmanVertexFitter::vertex().

Referenced by ~PFRecoTauDiscriminationByFlight().

                                    {
 
   KalmanVertexFitter kvf(true);
   const std::vector<reco::PFCandidatePtr>& signalTracks =
     tau->signalPFChargedHadrCands();
   std::vector<reco::TransientTrack> signalTransTracks;
   std::vector<reco::TrackRef> signalTrackPtrs;
   for(auto const& pftrack : signalTracks) {
     if (pftrack->trackRef().isNonnull()) {
       signalTransTracks.push_back(
           builder_->build(pftrack->trackRef()));
       signalTrackPtrs.push_back(pftrack->trackRef());
     }
   }
 
   reco::Vertex pv = (*vertices_)[0];
 
   if (refitPV_) {
     std::vector<reco::TrackRef> pvTrackRefs;
     for (reco::Vertex::trackRef_iterator pvTrack = pv.tracks_begin();
         pvTrack != pv.tracks_end(); ++pvTrack ) {
       pvTrackRefs.push_back(pvTrack->castTo<reco::TrackRef>());
     }
     // Get PV tracks not associated to the tau
     std::sort(signalTrackPtrs.begin(), signalTrackPtrs.end());
     std::sort(pvTrackRefs.begin(), pvTrackRefs.end());
     std::vector<reco::TrackRef> uniquePVTracks;
     uniquePVTracks.reserve(pvTrackRefs.size());
     std::set_difference(pvTrackRefs.begin(), pvTrackRefs.end(),
         signalTrackPtrs.begin(), signalTrackPtrs.end(),
         std::back_inserter(uniquePVTracks));
     // Check if we need to refit
     if (uniquePVTracks.size() != pvTrackRefs.size()) {
       std::vector<reco::TransientTrack> pvTransTracks;
       // Build all our unique transient tracks in the PV
       for(auto const& track : pvTrackRefs) {
         pvTransTracks.push_back(builder_->build(track));
       }
       // Refit our PV
       TransientVertex newPV = kvf.vertex(pvTransTracks, *beamspot_);
       pv = newPV;
     }
   }
 
   // The tau direction, to determine the sign of the IP.
   // In the case that it is a one prong, take the jet direction.
   // This may give better result due to out-of-cone stuff.
   GlobalVector direction = (tau->signalPFCands().size() == 1 ?
       GlobalVector(
           tau->jetRef()->px(), tau->jetRef()->py(), tau->jetRef()->pz()) :
       GlobalVector(tau->px(), tau->py(), tau->pz()));
 
   // Now figure out of we are doing a SV fit or an IP significance
   if (signalTransTracks.size() == 1) {
     reco::TransientTrack track = signalTransTracks.front();
     std::pair<bool,Measurement1D> ipsig =
       IPTools::signedTransverseImpactParameter(track, direction, pv);
     if (ipsig.first)
       return ipsig.second.significance();
     else
       return prediscriminantFailValue_;
   } else if (signalTransTracks.size() == 3) {
     // Fit the decay vertex of the three prong
     TransientVertex sv = kvf.vertex(signalTransTracks);
     // the true parameter indicates include PV errors
     Measurement1D svDist = reco::SecondaryVertex::computeDist2d(
         pv, sv, direction, true);
     double significance = svDist.significance();
     // Make sure it is a sane value
     if (significance > 40)
       significance = 40;
     if (significance < -20)
       significance = -20;
     return significance;
   } else  {
     // Weird two prong or something
     return prediscriminantFailValue_;
   }
 }