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

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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

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 39 of file PFTauPrimaryVertexProducerBase.h.

Member Typedef Documentation

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

Definition at line 51 of file PFTauPrimaryVertexProducerBase.h.

Member Enumeration Documentation

enum PFTauPrimaryVertexProducerBase::Alg

Enumerator
useInputPV
useFrontPV

Definition at line 41 of file PFTauPrimaryVertexProducerBase.h.

{ useInputPV = 0, useFrontPV };

Constructor & Destructor Documentation

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

explicit

Definition at line 20 of file PFTauPrimaryVertexProducerBase.cc.

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_.

    : 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_.reset(new StringCutObjectSelector<reco::PFTau>(iConfig.getParameter<std::string>("cut")));
  produces<edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::VertexRef>>>();
  produces<reco::VertexCollection>("PFTauPrimaryVertices");

  vertexAssociator_.reset(new reco::tau::RecoTauVertexAssociator(qualityCutsPSet_, consumesCollector()));
}

PFTauPrimaryVertexProducerBase::~PFTauPrimaryVertexProducerBase ( )

override

Definition at line 56 of file PFTauPrimaryVertexProducerBase.cc.

References getTrack(), reco::PFCandidate::gsfTrackRef(), edm::Ref< C, T, F >::isNonnull(), edm::refToPtr(), and reco::PFCandidate::trackRef().

{}

Member Function Documentation

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

inlinevirtual

Reimplemented in PFTauMiniAODPrimaryVertexProducer.

Definition at line 60 of file PFTauPrimaryVertexProducerBase.h.

References nonTauTracksInPV().

Referenced by produce().

{}

edm::ParameterSetDescription PFTauPrimaryVertexProducerBase::getDescriptionsBase ( )

static

Definition at line 220 of file PFTauPrimaryVertexProducerBase.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addVPSet(), HLT_2018_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 pset_signalQualityCuts;
    pset_signalQualityCuts.add<double>("maxDeltaZ", 0.4);
    pset_signalQualityCuts.add<double>("minTrackPt", 0.5);
    pset_signalQualityCuts.add<double>("minTrackVertexWeight", -1.0);
    pset_signalQualityCuts.add<double>("maxTrackChi2", 100.0);
    pset_signalQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
    pset_signalQualityCuts.add<double>("minGammaEt", 1.0);
    pset_signalQualityCuts.add<unsigned int>("minTrackHits", 3);
    pset_signalQualityCuts.add<double>("minNeutralHadronEt", 30.0);
    pset_signalQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
    pset_signalQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");

    edm::ParameterSetDescription pset_vxAssocQualityCuts;
    pset_vxAssocQualityCuts.add<double>("minTrackPt", 0.5);
    pset_vxAssocQualityCuts.add<double>("minTrackVertexWeight", -1.0);
    pset_vxAssocQualityCuts.add<double>("maxTrackChi2", 100.0);
    pset_vxAssocQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
    pset_vxAssocQualityCuts.add<double>("minGammaEt", 1.0);
    pset_vxAssocQualityCuts.add<unsigned int>("minTrackHits", 3);
    pset_vxAssocQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
    pset_vxAssocQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");

    edm::ParameterSetDescription pset_isolationQualityCuts;
    pset_isolationQualityCuts.add<double>("maxDeltaZ", 0.2);
    pset_isolationQualityCuts.add<double>("minTrackPt", 1.0);
    pset_isolationQualityCuts.add<double>("minTrackVertexWeight", -1.0);
    pset_isolationQualityCuts.add<double>("maxTrackChi2", 100.0);
    pset_isolationQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
    pset_isolationQualityCuts.add<double>("minGammaEt", 1.5);
    pset_isolationQualityCuts.add<unsigned int>("minTrackHits", 8);
    pset_isolationQualityCuts.add<double>("maxTransverseImpactParameter", 0.03);
    pset_isolationQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");

    edm::ParameterSetDescription pset_qualityCuts;
    pset_qualityCuts.add<edm::ParameterSetDescription>("signalQualityCuts", pset_signalQualityCuts);
    pset_qualityCuts.add<edm::ParameterSetDescription>("vxAssocQualityCuts", pset_vxAssocQualityCuts);
    pset_qualityCuts.add<edm::ParameterSetDescription>("isolationQualityCuts", pset_isolationQualityCuts);
    pset_qualityCuts.add<std::string>("leadingTrkOrPFCandOption", "leadPFCand");
    pset_qualityCuts.add<std::string>("pvFindingAlgo", "closestInDeltaZ");
    pset_qualityCuts.add<edm::InputTag>("primaryVertexSrc", edm::InputTag("offlinePrimaryVertices"));
    pset_qualityCuts.add<bool>("vertexTrackFiltering", false);
    pset_qualityCuts.add<bool>("recoverLeadingTrk", false);

    desc.add<edm::ParameterSetDescription>("qualityCuts", pset_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 beginEvent(), and produce().

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

override

Definition at line 78 of file PFTauPrimaryVertexProducerBase.cc.

References algorithm_, pwdgSkimBPark_cfi::beamSpot, beamSpotToken_, beginEvent(), TransientTrackBuilder::build(), cut_, TtSemiLepEvtBuilder_cfi::disc, listHistos::discr, discriminators_, metsig::electron, pwdgSkimBPark_cfi::electrons, electronToken_, edm::EventSetup::get(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), getTrack(), edm::Ptr< T >::isNonnull(), edm::HandleBase::isValid(), eostools::move(), PDWG_BPHSkim_cff::muons, muonToken_, nonTauTracksInPV(), TriggerAnalyzer::passed, pfDeepBoostedJetPreprocessParams_cfi::pfcand, pftauToken_, edm::Event::put(), pvToken_, edm::refToPtr(), removeElectronTracks_, removeMuonTracks_, AdaptiveVertexFitter::setWeightThreshold(), recoTrackAccumulator_cfi::signalTracks, metsig::tau, HLT_2018_cff::track, useBeamSpot_, useFrontPV, useInputPV, useSelectedTaus_, AdaptiveVertexFitter::vertex(), vertexAssociator_, and pwdgSkimBPark_cfi::vertices.

                                                                                          {
  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;
        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);
          }
        } 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 74 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 73 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 81 of file PFTauPrimaryVertexProducerBase.h.

Referenced by PFTauPrimaryVertexProducerBase(), and produce().

DiscCutPairVec PFTauPrimaryVertexProducerBase::discriminators_

private

Definition at line 80 of file PFTauPrimaryVertexProducerBase.h.

Referenced by PFTauPrimaryVertexProducerBase(), and produce().

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

private

Definition at line 70 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 71 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 69 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 72 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

edm::ParameterSet PFTauPrimaryVertexProducerBase::qualityCutsPSet_

private

Definition at line 75 of file PFTauPrimaryVertexProducerBase.h.

Referenced by PFTauPrimaryVertexProducerBase().

bool PFTauPrimaryVertexProducerBase::removeElectronTracks_

private

Definition at line 79 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

bool PFTauPrimaryVertexProducerBase::removeMuonTracks_

private

Definition at line 78 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

bool PFTauPrimaryVertexProducerBase::useBeamSpot_

private

Definition at line 76 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

bool PFTauPrimaryVertexProducerBase::useSelectedTaus_

private

Definition at line 77 of file PFTauPrimaryVertexProducerBase.h.

Referenced by produce().

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

private

Definition at line 82 of file PFTauPrimaryVertexProducerBase.h.

Referenced by PFTauPrimaryVertexProducerBase(), and produce().