PFTauPrimaryVertexProducerBase Class Reference

#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_
edm::ESGetToken < TransientTrackBuilder, TransientTrackRecord >	transTrackBuilderToken_
bool	useBeamSpot_
bool	useSelectedTaus_
std::unique_ptr < reco::tau::RecoTauVertexAssociator >	vertexAssociator_

Detailed Description

Definition at line 43 of file PFTauPrimaryVertexProducerBase.h.

Member Typedef Documentation

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

Definition at line 55 of file PFTauPrimaryVertexProducerBase.h.

Member Enumeration Documentation

enum PFTauPrimaryVertexProducerBase::Alg

Enumerator
useInputPV
useFrontPV

Definition at line 45 of file PFTauPrimaryVertexProducerBase.h.

{ useInputPV = 0, useFrontPV };

Constructor & Destructor Documentation

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

explicit

Definition at line 17 of file PFTauPrimaryVertexProducerBase.cc.

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

    : 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"))),
      transTrackBuilderToken_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))),
      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());
}

PFTauPrimaryVertexProducerBase::~PFTauPrimaryVertexProducerBase ( )

override

Definition at line 54 of file PFTauPrimaryVertexProducerBase.cc.

{}

Member Function Documentation

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

inlinevirtual

Reimplemented in PFTauMiniAODPrimaryVertexProducer.

Definition at line 64 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

{}

edm::ParameterSetDescription PFTauPrimaryVertexProducerBase::getDescriptionsBase ( )

static

Definition at line 225 of file PFTauPrimaryVertexProducerBase.cc.

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

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

                                                                               {
  // 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;
}

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().

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

override

Definition at line 76 of file PFTauPrimaryVertexProducerBase.cc.

References algorithm_, beam_dqm_sourceclient-live_cfg::beamSpot, beamSpotToken_, beginEvent(), cut_, listHistos::discr, discriminators_, metsig::electron, HI_PhotonSkim_cff::electrons, electronToken_, edm::Event::getByToken(), edm::EventSetup::getData(), edm::Event::getRefBeforePut(), getTrack(), edm::Ptr< T >::isNonnull(), edm::HandleBase::isValid(), TransientVertex::isValid(), eostools::move(), HLT_FULL_cff::muon, patZpeak::muons, muonToken_, nonTauTracksInPV(), pfTaus_cff::pfTaus, pftauToken_, TransientVertex::position(), edm::Event::put(), pvToken_, edm::refToPtr(), removeElectronTracks_, removeMuonTracks_, AdaptiveVertexFitter::setWeightThreshold(), metsig::tau, HLT_FULL_cff::track, transTrackBuilderToken_, useBeamSpot_, useFrontPV, useInputPV, useSelectedTaus_, AdaptiveVertexFitter::vertex(), vertexAssociator_, beam_dqm_sourceclient-live_cfg::vertices, and PV3DBase< T, PVType, FrameType >::z().

                                                                                          {
  beginEvent(iEvent, iSetup);

  // Obtain Collections
  auto const& transTrackBuilder = iSetup.getData(transTrackBuilderToken_);

  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));
}

Member Data Documentation

int PFTauPrimaryVertexProducerBase::algorithm_

private

Definition at line 79 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

edm::EDGetTokenT<reco::BeamSpot> PFTauPrimaryVertexProducerBase::beamSpotToken_

private

Definition at line 77 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 86 of file PFTauPrimaryVertexProducerBase.h.

Referenced by PFTauPrimaryVertexProducerBase(), and produce().

DiscCutPairVec PFTauPrimaryVertexProducerBase::discriminators_

private

Definition at line 85 of file PFTauPrimaryVertexProducerBase.h.

Referenced by PFTauPrimaryVertexProducerBase(), and produce().

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

private

Definition at line 74 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 75 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 73 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

edm::EDGetTokenT<reco::VertexCollection> PFTauPrimaryVertexProducerBase::pvToken_

private

Definition at line 76 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

edm::ParameterSet PFTauPrimaryVertexProducerBase::qualityCutsPSet_

private

Definition at line 80 of file PFTauPrimaryVertexProducerBase.h.

Referenced by PFTauPrimaryVertexProducerBase().

bool PFTauPrimaryVertexProducerBase::removeElectronTracks_

private

Definition at line 84 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

bool PFTauPrimaryVertexProducerBase::removeMuonTracks_

private

Definition at line 83 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> PFTauPrimaryVertexProducerBase::transTrackBuilderToken_

private

Definition at line 78 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

bool PFTauPrimaryVertexProducerBase::useBeamSpot_

private

Definition at line 81 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

bool PFTauPrimaryVertexProducerBase::useSelectedTaus_

private

Definition at line 82 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 87 of file PFTauPrimaryVertexProducerBase.h.

Referenced by PFTauPrimaryVertexProducerBase(), and produce().