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	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () 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_, pfDeepCMVADiscriminatorsJetTags_cfi::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 53 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 205 of file PFTauPrimaryVertexProducerBase.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addVPSet(), 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 72 of file PFTauPrimaryVertexProducerBase.cc.

References algorithm_, ecalDrivenElectronSeedsParameters_cff::beamSpot, beamSpotToken_, beginEvent(), TransientTrackBuilder::build(), cut_, TtSemiLepEvtBuilder_cfi::disc, listHistos::discr, discriminators_, metsig::electron, nano_cff::electrons, electronToken_, edm::EventSetup::get(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), getTrack(), edm::Ptr< T >::isNonnull(), edm::HandleBase::isValid(), TransientVertex::isValid(), eostools::move(), extraflags_cff::muons, muonToken_, nonTauTracksInPV(), TriggerAnalyzer::passed, pfDeepBoostedJetPreprocessParams_cfi::pfcand, pftauToken_, TransientVertex::position(), edm::Event::put(), pvToken_, edm::refToPtr(), removeElectronTracks_, removeMuonTracks_, AdaptiveVertexFitter::setWeightThreshold(), metsig::tau, HiIsolationCommonParameters_cff::track, useBeamSpot_, useFrontPV, useInputPV, useSelectedTaus_, AdaptiveVertexFitter::vertex(), vertexAssociator_, electrons_cff::vertices, and PV3DBase< T, PVType, FrameType >::z().

                                                                                        {
  
  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);
      }
      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 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().