Inheritance diagram for PFRecoTauDiscriminationByFlight:

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

double	discriminate (const reco::PFTauRef &) override

	PFRecoTauDiscriminationByFlight (const edm::ParameterSet &pset)

virtual	~PFRecoTauDiscriminationByFlight ()

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

virtual void	endEvent (edm::Event &evt)

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

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

virtual	~TauDiscriminationProducerBase ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

edm::InputTag	TauProducer_

Detailed Description

Definition at line 14 of file RecoTauDiscriminationByFlight.cc.

Constructor & Destructor Documentation

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

Definition at line 31 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");
 }

virtual PFRecoTauDiscriminationByFlight::~PFRecoTauDiscriminationByFlight ( )

inlinevirtual

Definition at line 17 of file RecoTauDiscriminationByFlight.cc.

17 {}

Member Function Documentation

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

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 43 of file RecoTauDiscriminationByFlight.cc.

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

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

override

Definition at line 53 of file RecoTauDiscriminationByFlight.cc.

References beamspot_, TransientTrackBuilder::build(), builder_, reco::SecondaryVertex::computeDist2d(), edm::Ptr< T >::isNonnull(), TauDiscriminationProducerBase< TauType, TauDiscriminator >::prediscriminantFailValue_, refitPV_, IPTools::signedTransverseImpactParameter(), Measurement1D::significance(), python.multivaluedict::sort(), reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), and KalmanVertexFitter::vertex().

                              {
 
   KalmanVertexFitter kvf(true);
   const std::vector<reco::PFCandidatePtr>& signalTracks =
     tau->signalPFChargedHadrCands();
   std::vector<reco::TransientTrack> signalTransTracks;
   std::vector<reco::TrackRef> signalTrackPtrs;
   BOOST_FOREACH(const reco::PFCandidatePtr& 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
       BOOST_FOREACH(const reco::TrackRef& 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_;
   }
 }