#include <PFTauPrimaryVertexProducerBase.h>

Inheritance diagram for PFTauPrimaryVertexProducerBase:

Classes
struct	DiscCutPair

Public Types
enum	Alg { useInputPV = 0, useFrontPV }

typedef std::vector< DiscCutPair * >	DiscCutPairVec

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
virtual void	beginEvent (const edm::Event &, const edm::EventSetup &)

	PFTauPrimaryVertexProducerBase (const edm::ParameterSet &iConfig)

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

	~PFTauPrimaryVertexProducerBase () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static edm::ParameterSetDescription	getDescriptionsBase ()

Protected Member Functions
virtual void	nonTauTracksInPV (const reco::VertexRef &, const std::vector< edm::Ptr< reco::TrackBase > > &, std::vector< const reco::Track * > &)=0

Private Attributes
int	algorithm_

edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

std::unique_ptr< StringCutObjectSelector< reco::PFTau > >	cut_

DiscCutPairVec	discriminators_

edm::EDGetTokenT< edm::View< reco::Electron > >	electronToken_

edm::EDGetTokenT< edm::View< reco::Muon > >	muonToken_

edm::EDGetTokenT< std::vector< reco::PFTau > >	pftauToken_

edm::EDGetTokenT< reco::VertexCollection >	pvToken_

edm::ParameterSet	qualityCutsPSet_

bool	removeElectronTracks_

bool	removeMuonTracks_

bool	useBeamSpot_

bool	useSelectedTaus_

std::unique_ptr< reco::tau::RecoTauVertexAssociator >	vertexAssociator_

Detailed Description

Definition at line 40 of file PFTauPrimaryVertexProducerBase.h.

Member Typedef Documentation

◆ DiscCutPairVec

typedef std::vector<DiscCutPair*> PFTauPrimaryVertexProducerBase::DiscCutPairVec

Definition at line 52 of file PFTauPrimaryVertexProducerBase.h.

Member Enumeration Documentation

◆ Alg

enum PFTauPrimaryVertexProducerBase::Alg

Enumerator
useInputPV
useFrontPV

Definition at line 42 of file PFTauPrimaryVertexProducerBase.h.

42 { useInputPV = 0, useFrontPV };

Constructor & Destructor Documentation

◆ PFTauPrimaryVertexProducerBase()

PFTauPrimaryVertexProducerBase::PFTauPrimaryVertexProducerBase ( const edm::ParameterSet & iConfig )

explicit

Definition at line 20 of file PFTauPrimaryVertexProducerBase.cc.

     : pftauToken_(consumes<std::vector<reco::PFTau>>(iConfig.getParameter<edm::InputTag>("PFTauTag"))),
       electronToken_(consumes<edm::View<reco::Electron>>(iConfig.getParameter<edm::InputTag>("ElectronTag"))),
       muonToken_(consumes<edm::View<reco::Muon>>(iConfig.getParameter<edm::InputTag>("MuonTag"))),
       pvToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("PVTag"))),
       beamSpotToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpot"))),
       algorithm_(iConfig.getParameter<int>("Algorithm")),
       qualityCutsPSet_(iConfig.getParameter<edm::ParameterSet>("qualityCuts")),
       useBeamSpot_(iConfig.getParameter<bool>("useBeamSpot")),
       useSelectedTaus_(iConfig.getParameter<bool>("useSelectedTaus")),
       removeMuonTracks_(iConfig.getParameter<bool>("RemoveMuonTracks")),
       removeElectronTracks_(iConfig.getParameter<bool>("RemoveElectronTracks")) {
   std::vector<edm::ParameterSet> discriminators =
       iConfig.getParameter<std::vector<edm::ParameterSet>>("discriminators");
   // Build each of our cuts
   for (auto const& pset : discriminators) {
     DiscCutPair* newCut = new DiscCutPair();
     newCut->inputToken_ = consumes<reco::PFTauDiscriminator>(pset.getParameter<edm::InputTag>("discriminator"));
  
     if (pset.existsAs<std::string>("selectionCut"))
       newCut->cutFormula_ = new TFormula("selectionCut", pset.getParameter<std::string>("selectionCut").data());
     else
       newCut->cut_ = pset.getParameter<double>("selectionCut");
     discriminators_.push_back(newCut);
   }
   // Build a string cut if desired
   if (iConfig.exists("cut"))
     cut_ = std::make_unique<StringCutObjectSelector<reco::PFTau>>(iConfig.getParameter<std::string>("cut"));
   produces<edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::VertexRef>>>();
   produces<reco::VertexCollection>("PFTauPrimaryVertices");
  
   vertexAssociator_ = std::make_unique<reco::tau::RecoTauVertexAssociator>(qualityCutsPSet_, consumesCollector());
 }

References PFTauPrimaryVertexProducerBase::DiscCutPair::cut_, cut_, PFTauPrimaryVertexProducerBase::DiscCutPair::cutFormula_, PDWG_TauSkim_cff::discriminators, discriminators_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), PFTauPrimaryVertexProducerBase::DiscCutPair::inputToken_, muonDTDigis_cfi::pset, qualityCutsPSet_, AlCaHLTBitMon_QueryRunRegistry::string, and vertexAssociator_.

◆ ~PFTauPrimaryVertexProducerBase()

PFTauPrimaryVertexProducerBase::~PFTauPrimaryVertexProducerBase ( )

override

Definition at line 56 of file PFTauPrimaryVertexProducerBase.cc.

56 {}

Member Function Documentation

◆ beginEvent()

virtual void PFTauPrimaryVertexProducerBase::beginEvent	(	const edm::Event &	,
		const edm::EventSetup &
	)

inlinevirtual

Reimplemented in PFTauMiniAODPrimaryVertexProducer.

Definition at line 61 of file PFTauPrimaryVertexProducerBase.h.

61 {}

Referenced by produce().

◆ getDescriptionsBase()

edm::ParameterSetDescription PFTauPrimaryVertexProducerBase::getDescriptionsBase ( )

static

Definition at line 228 of file PFTauPrimaryVertexProducerBase.cc.

                                                                                {
   // PFTauPrimaryVertexProducerBase
   edm::ParameterSetDescription desc;
  
   {
     edm::ParameterSetDescription vpsd1;
     vpsd1.add<edm::InputTag>("discriminator");
     vpsd1.add<double>("selectionCut");
     desc.addVPSet("discriminators", vpsd1);
   }
  
   edm::ParameterSetDescription desc_qualityCuts;
   reco::tau::RecoTauQualityCuts::fillDescriptions(desc_qualityCuts);
   desc.add<edm::ParameterSetDescription>("qualityCuts", desc_qualityCuts);
  
   desc.add<std::string>("cut", "pt > 18.0 & abs(eta)<2.3");
   desc.add<int>("Algorithm", 0);
   desc.add<bool>("RemoveElectronTracks", false);
   desc.add<bool>("RemoveMuonTracks", false);
   desc.add<bool>("useBeamSpot", true);
   desc.add<bool>("useSelectedTaus", false);
   desc.add<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
   desc.add<edm::InputTag>("ElectronTag", edm::InputTag("MyElectrons"));
   desc.add<edm::InputTag>("PFTauTag", edm::InputTag("hpsPFTauProducer"));
   desc.add<edm::InputTag>("MuonTag", edm::InputTag("MyMuons"));
   desc.add<edm::InputTag>("PVTag", edm::InputTag("offlinePrimaryVertices"));
  
   return desc;
 }

References edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, reco::tau::RecoTauQualityCuts::fillDescriptions(), HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PFTauPrimaryVertexProducer::fillDescriptions(), and PFTauMiniAODPrimaryVertexProducer::fillDescriptions().

◆ nonTauTracksInPV()

virtual void PFTauPrimaryVertexProducerBase::nonTauTracksInPV	(	const reco::VertexRef &	,
		const std::vector< edm::Ptr< reco::TrackBase > > &	,
		std::vector< const reco::Track * > &
	)

protectedpure virtual

Implemented in PFTauMiniAODPrimaryVertexProducer, and PFTauPrimaryVertexProducer.

Referenced by produce().

◆ produce()

void PFTauPrimaryVertexProducerBase::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 78 of file PFTauPrimaryVertexProducerBase.cc.

                                                                                           {
   beginEvent(iEvent, iSetup);
  
   // Obtain Collections
   edm::ESHandle<TransientTrackBuilder> transTrackBuilder;
   iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", transTrackBuilder);
  
   edm::Handle<std::vector<reco::PFTau>> pfTaus;
   iEvent.getByToken(pftauToken_, pfTaus);
  
   edm::Handle<edm::View<reco::Electron>> electrons;
   if (removeElectronTracks_)
     iEvent.getByToken(electronToken_, electrons);
  
   edm::Handle<edm::View<reco::Muon>> muons;
   if (removeMuonTracks_)
     iEvent.getByToken(muonToken_, muons);
  
   edm::Handle<reco::VertexCollection> vertices;
   iEvent.getByToken(pvToken_, vertices);
  
   edm::Handle<reco::BeamSpot> beamSpot;
   if (useBeamSpot_)
     iEvent.getByToken(beamSpotToken_, beamSpot);
  
   // Set Association Map
   auto avPFTauPV = std::make_unique<edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::VertexRef>>>(
       reco::PFTauRefProd(pfTaus));
   auto vertexCollection_out = std::make_unique<reco::VertexCollection>();
   reco::VertexRefProd vertexRefProd_out = iEvent.getRefBeforePut<reco::VertexCollection>("PFTauPrimaryVertices");
  
   // Load each discriminator
   for (auto& disc : discriminators_) {
     edm::Handle<reco::PFTauDiscriminator> discr;
     iEvent.getByToken(disc->inputToken_, discr);
     disc->discr_ = &(*discr);
   }
  
   // Set event for VerexAssociator if needed
   if (useInputPV == algorithm_)
     vertexAssociator_->setEvent(iEvent);
  
   // For each Tau Run Algorithim
   if (pfTaus.isValid()) {
     for (reco::PFTauCollection::size_type iPFTau = 0; iPFTau < pfTaus->size(); iPFTau++) {
       reco::PFTauRef tau(pfTaus, iPFTau);
       reco::VertexRef thePVRef;
       if (useInputPV == algorithm_) {
         thePVRef = vertexAssociator_->associatedVertex(*tau);
       } else if (useFrontPV == algorithm_) {
         thePVRef = reco::VertexRef(vertices, 0);
       }
       reco::Vertex thePV = *thePVRef;
       // Check if it passed all the discrimiantors
       bool passed(true);
       for (auto const& disc : discriminators_) {
         // Check this discriminator passes
         bool passedDisc = true;
         if (disc->cutFormula_)
           passedDisc = (disc->cutFormula_->Eval((*disc->discr_)[tau]) > 0.5);
         else
           passedDisc = ((*disc->discr_)[tau] > disc->cut_);
         if (!passedDisc) {
           passed = false;
           break;
         }
       }
       if (passed && cut_.get()) {
         passed = (*cut_)(*tau);
       }
       if (passed) {
         std::vector<edm::Ptr<reco::TrackBase>> signalTracks;
         for (reco::PFTauCollection::size_type jPFTau = 0; jPFTau < pfTaus->size(); jPFTau++) {
           if (useSelectedTaus_ || iPFTau == jPFTau) {
             reco::PFTauRef pfTauRef(pfTaus, jPFTau);
             // Get tracks from PFTau daughters
             for (const auto& pfcand : pfTauRef->signalChargedHadrCands()) {
               if (pfcand.isNull())
                 continue;
               const edm::Ptr<reco::TrackBase>& trackPtr = getTrack(*pfcand);
               if (trackPtr.isNonnull())
                 signalTracks.push_back(trackPtr);
             }
           }
         }
         // Get Muon tracks
         if (removeMuonTracks_) {
           if (muons.isValid()) {
             for (const auto& muon : *muons) {
               if (muon.track().isNonnull())
                 signalTracks.push_back(edm::refToPtr(muon.track()));
             }
           }
         }
         // Get Electron Tracks
         if (removeElectronTracks_) {
           if (electrons.isValid()) {
             for (const auto& electron : *electrons) {
               if (electron.track().isNonnull())
                 signalTracks.push_back(edm::refToPtr(electron.track()));
               if (electron.gsfTrack().isNonnull())
                 signalTracks.push_back(edm::refToPtr(electron.gsfTrack()));
             }
           }
         }
         // Get Non-Tau tracks
         std::vector<const reco::Track*> nonTauTracks;
         nonTauTracksInPV(thePVRef, signalTracks, nonTauTracks);
  
         // Refit the vertex
         TransientVertex transVtx;
         std::vector<reco::TransientTrack> transTracks;
         transTracks.reserve(nonTauTracks.size());
         for (const auto track : nonTauTracks) {
           transTracks.push_back(transTrackBuilder->build(*track));
         }
         bool fitOK(true);
         if (transTracks.size() >= 2) {
           AdaptiveVertexFitter avf;
           avf.setWeightThreshold(0.1);  //weight per track. allow almost every fit, else --> exception
           if (!useBeamSpot_) {
             transVtx = avf.vertex(transTracks);
           } else {
             transVtx = avf.vertex(transTracks, *beamSpot);
           }
           if (!transVtx.isValid()) {
             fitOK = false;
           } else {
             //MB: protect against rare cases when transVtx is valid but its position is ill-defined
             if (!std::isfinite(transVtx.position().z()))  //MB: it is enough to check one coordinate (?)
               fitOK = false;
           }
         } else
           fitOK = false;
         if (fitOK)
           thePV = transVtx;
       }
       reco::VertexRef vtxRef = reco::VertexRef(vertexRefProd_out, vertexCollection_out->size());
       vertexCollection_out->push_back(thePV);
       avPFTauPV->setValue(iPFTau, vtxRef);
     }
   }
   iEvent.put(std::move(vertexCollection_out), "PFTauPrimaryVertices");
   iEvent.put(std::move(avPFTauPV));
 }