#include <PFTauVertexSelector.h>

Inheritance diagram for PFTauVertexSelector:

Public Member Functions
	PFTauVertexSelector (const edm::ParameterSet &iConfig)

	~PFTauVertexSelector ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDFilter ()

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 Member Functions
virtual bool	filter (edm::Event &, const edm::EventSetup &) override

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotSrc_

double	dZ_

uint32_t	filterOnNTaus_

std::vector< edm::EDGetTokenT < edm::View < reco::RecoCandidate > > >	recoCandidateSrc_

std::vector< edm::InputTag >	recoCandidateSrcIT_

edm::EDGetTokenT< edm::View < reco::PFTau > >	tauSrc_

std::vector< edm::EDGetTokenT < edm::View< reco::Track > > >	trackSrc_

std::vector< edm::InputTag >	trackSrcIT_

edm::EDGetTokenT < trigger::TriggerFilterObjectWithRefs >	triggerFilterElectronsSrc_

edm::EDGetTokenT < trigger::TriggerFilterObjectWithRefs >	triggerFilterMuonsSrc_

bool	useBeamSpot_

bool	useLeadingRecoCandidate_

bool	useLeadingTrack_

bool	useTriggerFilterElectrons_

bool	useTriggerFilterMuons_

bool	useVertex_

edm::EDGetTokenT< edm::View < reco::Vertex > >	vertexSrc_

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	ModuleType

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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)

Detailed Description

Definition at line 24 of file PFTauVertexSelector.h.

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 26 of file PFTauVertexSelector.h.

References beamSpotSrc_, dZ_, filterOnNTaus_, edm::ParameterSet::getParameter(), recoCandidateSrc_, recoCandidateSrcIT_, tauSrc_, trackSrc_, trackSrcIT_, triggerFilterElectronsSrc_, triggerFilterMuonsSrc_, useBeamSpot_, useLeadingRecoCandidate_, useLeadingTrack_, useTriggerFilterElectrons_, useTriggerFilterMuons_, useVertex_, and vertexSrc_.

                                                                   {   
          tauSrc_ = consumes<edm::View<reco::PFTau> >(iConfig.getParameter<edm::InputTag>("tauSrc"));
          useVertex_ = iConfig.getParameter<bool>("useVertex");
          vertexSrc_ = consumes<edm::View<reco::Vertex> >(iConfig.getParameter<edm::InputTag>("vertexSrc"));
          useBeamSpot_ = iConfig.getParameter<bool>("useBeamSpot");
          beamSpotSrc_ = consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpotSrc"));
          useLeadingTrack_ = iConfig.getParameter<bool>("useLeadingTrack");
          trackSrcIT_ = iConfig.getParameter<std::vector<edm::InputTag> >("trackSrc");
      for( std::vector<edm::InputTag>::const_iterator it = trackSrcIT_.begin(); it != trackSrcIT_.end(); ++it ) {
        edm::EDGetTokenT<edm::View<reco::Track> > aToken =  consumes<edm::View<reco::Track> >( *it );
        trackSrc_.push_back(aToken);
      }
          useLeadingRecoCandidate_ = iConfig.getParameter<bool>("useLeadingRecoCandidate");
          recoCandidateSrcIT_ = iConfig.getParameter<std::vector<edm::InputTag> >("recoCandidateSrc");
      for( std::vector<edm::InputTag>::const_iterator it =  recoCandidateSrcIT_.begin(); it != recoCandidateSrcIT_.end(); ++it ) {
        edm::EDGetTokenT<edm::View<reco::RecoCandidate> > aToken =  consumes<edm::View<reco::RecoCandidate> >( *it );
        recoCandidateSrc_.push_back(aToken);
      }
          useTriggerFilterElectrons_ = iConfig.getParameter<bool>("useTriggerFilterElectrons");
          triggerFilterElectronsSrc_ = consumes<trigger::TriggerFilterObjectWithRefs>(iConfig.getParameter<edm::InputTag>("triggerFilterElectronsSrc"));
          useTriggerFilterMuons_ = iConfig.getParameter<bool>("useTriggerFilterMuons");
          triggerFilterMuonsSrc_ = consumes<trigger::TriggerFilterObjectWithRefs>(iConfig.getParameter<edm::InputTag>("triggerFilterMuonsSrc"));
          dZ_ = iConfig.getParameter<double>("dZ");
          filterOnNTaus_ = iConfig.getParameter<uint32_t>("filterOnNTaus");
          produces<reco::PFTauCollection>();
       }

PFTauVertexSelector::~PFTauVertexSelector ( )

inline

Definition at line 52 of file PFTauVertexSelector.h.

52 {}

Member Function Documentation

bool PFTauVertexSelector::filter	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

overrideprivatevirtual

Implements edm::EDFilter.

Definition at line 15 of file PFTauVertexSelector.cc.

References beamSpotSrc_, reco::TrackBase::dz(), dZ_, filterOnNTaus_, i, edm::HandleBase::isValid(), RecoTauCleanerPlugins::pt, recoCandidateSrc_, tauSrc_, testEve_cfg::tracks, trackSrc_, trigger::TriggerElectron, triggerFilterElectronsSrc_, triggerFilterMuonsSrc_, trigger::TriggerMuon, useBeamSpot_, useLeadingRecoCandidate_, useLeadingTrack_, useTriggerFilterElectrons_, useTriggerFilterMuons_, useVertex_, and vertexSrc_.

                                                                                  {
 
    math::XYZPoint vertexPoint;
    bool vertexAvailable=false;
    
    if(useBeamSpot_)
    {
        edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
        event.getByToken(beamSpotSrc_,recoBeamSpotHandle);
        if (recoBeamSpotHandle.isValid()){
          vertexPoint = recoBeamSpotHandle->position();
      vertexAvailable = true;
        }
    }
  
    if(useVertex_)
    {
        edm::Handle<edm::View<reco::Vertex> > recoVertexHandle;
        event.getByToken(vertexSrc_,recoVertexHandle);
        if ((recoVertexHandle.isValid()) && (recoVertexHandle->size()>0)){
          vertexPoint = recoVertexHandle->at(0).position();
      vertexAvailable = true;
        }
    }
  
    const reco::Track* track=0;
    double maxpt=0.;
    
    if (useLeadingTrack_)
    {
        edm::Handle<edm::View<reco::Track> > tracks;
        for( std::vector<edm::EDGetTokenT<edm::View<reco::Track> > >::const_iterator trackSrc = trackSrc_.begin(); trackSrc != trackSrc_.end(); ++ trackSrc ) {
            event.getByToken(*trackSrc, tracks);
            if ((tracks.isValid())&&(tracks->size()>0)){
                for (unsigned i = 0; i < tracks->size(); ++i) {
                   double pt=tracks->ptrAt(i)->pt();
                   if(pt>maxpt)
                   {
                       track = &*tracks->ptrAt(i);
                       maxpt=pt;
                   }
                }
            }
        }
    }
    
    if (useLeadingRecoCandidate_)
    {
        edm::Handle<edm::View<reco::RecoCandidate> > recocandidates;
        for( std::vector<edm::EDGetTokenT<edm::View<reco::RecoCandidate> > >::const_iterator recoCandidateSrc = recoCandidateSrc_.begin(); recoCandidateSrc != recoCandidateSrc_.end(); ++ recoCandidateSrc ) {
            event.getByToken(*recoCandidateSrc, recocandidates);
            if ((recocandidates.isValid())&&(recocandidates->size()>0)){
                for (unsigned i = 0; i < recocandidates->size(); ++i) {
                   double pt=recocandidates->ptrAt(i)->pt();
                   if(pt>maxpt)
                   {
                       track = dynamic_cast<const reco::Track*>(recocandidates->ptrAt(i)->bestTrack());
                       maxpt=pt;
                   }
                }
            }
        }
    }
    
    if (useTriggerFilterElectrons_)
    {
        edm::Handle<trigger::TriggerFilterObjectWithRefs> triggerfilter;
        event.getByToken(triggerFilterElectronsSrc_, triggerfilter);
        std::vector<reco::ElectronRef> recocandidates;
        triggerfilter->getObjects(trigger::TriggerElectron,recocandidates);
        if ((recocandidates.size()>0)){
            for (unsigned i = 0; i < recocandidates.size(); ++i) {
               double pt=recocandidates.at(i)->pt();
               if(pt>maxpt)
               {
               track = dynamic_cast<const reco::Track*>(recocandidates.at(i)->bestTrack());
               maxpt=pt;
               }
            }
        }
    }
    
    if (useTriggerFilterMuons_)
    {
        edm::Handle<trigger::TriggerFilterObjectWithRefs> triggerfilter;
        event.getByToken(triggerFilterMuonsSrc_, triggerfilter);
        std::vector<reco::RecoChargedCandidateRef> recocandidates;
        triggerfilter->getObjects(trigger::TriggerMuon,recocandidates);
        if ((recocandidates.size()>0)){
            for (unsigned i = 0; i < recocandidates.size(); ++i) {
               double pt=recocandidates.at(i)->pt();
               if(pt>maxpt)
               {
               track = dynamic_cast<const reco::Track*>(recocandidates.at(i)->bestTrack());
               maxpt=pt;
               }
            }
        }
    }
    
    reco::PFTauCollection* selTaus = new reco::PFTauCollection;
    edm::Handle<edm::View<reco::PFTau> > taus;
    event.getByToken(tauSrc_, taus);
    for( edm::View<reco::PFTau>::const_iterator pfTau = taus->begin(); pfTau != taus->end(); ++ pfTau ) {
        // if no leading track assigned skip
        if ((!pfTau->leadPFChargedHadrCand().isNonnull())||
            (!pfTau->leadPFChargedHadrCand()->trackRef().isNonnull()))
           continue;
 
        if(vertexAvailable)
        {
            // select by z position of leading track at vertex
            if ((useLeadingTrack_)||(useLeadingRecoCandidate_)||(useTriggerFilterElectrons_)||(useTriggerFilterMuons_))
            {
                if((track)&&(fabs(pfTau->leadPFChargedHadrCand()->trackRef()->dz(vertexPoint) - track->dz(vertexPoint)) < dZ_))
                    selTaus->push_back(*pfTau);
            }
            // select by z position of leading vertex
            else
            {
                if (fabs(pfTau->leadPFChargedHadrCand()->trackRef()->dz(vertexPoint))<dZ_)
                    selTaus->push_back(*pfTau);
            }
        }
        else
        {
            // select by z position of leading track at (0,0,0)
            if ((useLeadingTrack_)||(useLeadingRecoCandidate_)||(useTriggerFilterElectrons_)||(useTriggerFilterMuons_))
            {
                if((track)&&(fabs(pfTau->leadPFChargedHadrCand()->trackRef()->dz() - track->dz()) < dZ_))
                    selTaus->push_back(*pfTau);
            }
        }
    }
    unsigned filterTaus=selTaus->size();
    std::auto_ptr<reco::PFTauCollection> selectedTaus(selTaus);
    event.put(selectedTaus);
    
    return (filterTaus>=filterOnNTaus_);
 }