#include <HLTMuonTrkFilter.h>

Inheritance diagram for HLTMuonTrkFilter:

Public Member Functions
virtual bool	hltFilter (edm::Event &, const edm::EventSetup &, trigger::TriggerFilterObjectWithRefs &filterproduct) const override

	HLTMuonTrkFilter (const edm::ParameterSet &)

virtual	~HLTMuonTrkFilter ()

Public Member Functions inherited from HLTFilter
	HLTFilter (const edm::ParameterSet &config)

int	module (edm::Event const &) const

const std::string *	moduleLabel () const

int	path (edm::Event const &) const

const std::string *	pathName (edm::Event const &) const

std::pair< int, int >	pmid (edm::Event const &) const

bool	saveTags () const

virtual	~HLTFilter ()

Public Member Functions inherited from edm::global::EDFilter<>
	EDFilter ()=default

Public Member Functions inherited from edm::global::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDFilterBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	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
std::vector< ConsumesInfo >	consumesInfo () const

	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

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from HLTFilter
static void	makeHLTFilterDescription (edm::ParameterSetDescription &desc)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Attributes
unsigned int	m_allowedTypeMask

edm::InputTag	m_candsTag

edm::EDGetTokenT < reco::RecoChargedCandidateCollection >	m_candsToken

double	m_maxAbsEta

double	m_maxNormalizedChi2

int	m_minMuonHits

int	m_minMuonStations

unsigned int	m_minN

double	m_minPt

int	m_minTrkHits

edm::InputTag	m_muonsTag

edm::EDGetTokenT < reco::MuonCollection >	m_muonsToken

edm::InputTag	m_previousCandTag

edm::EDGetTokenT < trigger::TriggerFilterObjectWithRefs >	m_previousCandToken

unsigned int	m_requiredTypeMask

bool	m_saveTags

muon::SelectionType	m_trkMuonId

Additional Inherited Members
Public Types inherited from edm::global::EDFilterBase
typedef EDFilterBase	ModuleType

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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 14 of file HLTMuonTrkFilter.h.

Constructor & Destructor Documentation

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

Definition at line 30 of file HLTMuonTrkFilter.cc.

References edm::ParameterSet::getParameter(), m_allowedTypeMask, m_candsTag, m_candsToken, m_maxAbsEta, m_maxNormalizedChi2, m_minMuonHits, m_minMuonStations, m_minN, m_minPt, m_minTrkHits, m_muonsTag, m_muonsToken, m_previousCandTag, m_previousCandToken, m_requiredTypeMask, and m_trkMuonId.

                                                                  : HLTFilter(iConfig) {
   m_muonsTag          = iConfig.getParameter<edm::InputTag>("inputMuonCollection");
   m_muonsToken        = consumes<reco::MuonCollection>(m_muonsTag);
   m_candsTag          = iConfig.getParameter<edm::InputTag>("inputCandCollection");
   m_candsToken        = consumes<reco::RecoChargedCandidateCollection>(m_candsTag);
   m_previousCandTag   = iConfig.getParameter<edm::InputTag> ("previousCandTag");
   m_previousCandToken = consumes<trigger::TriggerFilterObjectWithRefs>(m_previousCandTag);
   m_minTrkHits        = iConfig.getParameter<int>("minTrkHits");
   m_minMuonHits       = iConfig.getParameter<int>("minMuonHits");
   m_minMuonStations   = iConfig.getParameter<int>("minMuonStations");
   m_maxNormalizedChi2 = iConfig.getParameter<double>("maxNormalizedChi2");
   m_allowedTypeMask   = iConfig.getParameter<unsigned int>("allowedTypeMask");
   m_requiredTypeMask  = iConfig.getParameter<unsigned int>("requiredTypeMask");
   m_trkMuonId         = muon::SelectionType(iConfig.getParameter<unsigned int>("trkMuonId"));
   m_minPt             = iConfig.getParameter<double>("minPt");
   m_minN              = iConfig.getParameter<unsigned int>("minN");
   m_maxAbsEta         = iConfig.getParameter<double>("maxAbsEta");
 }

virtual HLTMuonTrkFilter::~HLTMuonTrkFilter ( )

inlinevirtual

Definition at line 17 of file HLTMuonTrkFilter.h.

17 {}

Member Function Documentation

void HLTMuonTrkFilter::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 50 of file HLTMuonTrkFilter.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_25ns14e33_v1_cff::InputTag, and HLTFilter::makeHLTFilterDescription().

                                                                              {
   edm::ParameterSetDescription desc;
   makeHLTFilterDescription(desc);
   desc.add<edm::InputTag>("inputMuonCollection",edm::InputTag(""));
   desc.add<edm::InputTag>("inputCandCollection",edm::InputTag(""));
   desc.add<edm::InputTag>("previousCandTag",edm::InputTag(""));
   desc.add<int>("minTrkHits",-1);
   desc.add<int>("minMuonHits",-1);
   desc.add<int>("minMuonStations",-1);
   desc.add<double>("maxNormalizedChi2",1e99);
   desc.add<unsigned int>("allowedTypeMask",255);
   desc.add<unsigned int>("requiredTypeMask",0);
   desc.add<unsigned int>("trkMuonId",0);
   desc.add<double>("minPt",24);
   desc.add<unsigned int>("minN",1);
   desc.add<double>("maxAbsEta",1e99);
   descriptions.add("hltMuonTrkFilter",desc);
 }

bool HLTMuonTrkFilter::hltFilter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		trigger::TriggerFilterObjectWithRefs &	filterproduct
	)		const

overridevirtual

Implements HLTFilter.

Definition at line 70 of file HLTMuonTrkFilter.cc.

References funct::abs(), trigger::TriggerFilterObjectWithRefs::addCollectionTag(), trigger::TriggerRefsCollections::addObject(), edm::errors::Configuration, deltaR(), edm::Event::getByToken(), i, muon::isGoodMuon(), m_allowedTypeMask, m_candsTag, m_candsToken, m_maxAbsEta, m_maxNormalizedChi2, m_minMuonHits, m_minMuonStations, m_minN, m_minPt, m_minTrkHits, m_muonsToken, m_previousCandTag, m_previousCandToken, m_requiredTypeMask, m_trkMuonId, metsig::muon, patZpeak::muons, HLTFilter::saveTags(), trigger::TriggerL1Mu, and trigger::TriggerMuon.

 {
   edm::Handle<reco::MuonCollection> muons;
   iEvent.getByToken(m_muonsToken,muons);
   edm::Handle<reco::RecoChargedCandidateCollection> cands;
   iEvent.getByToken(m_candsToken,cands);
   if ( saveTags() ) filterproduct.addCollectionTag(m_candsTag);
   if ( cands->size() != muons->size() )
     throw edm::Exception(edm::errors::Configuration) << "Both input collection must be aligned and represent same physical muon objects";
   
   edm::Handle<trigger::TriggerFilterObjectWithRefs> previousLevelCands;
   std::vector<l1extra::L1MuonParticleRef> vl1cands;
   std::vector<l1extra::L1MuonParticleRef>::iterator vl1cands_begin;
   std::vector<l1extra::L1MuonParticleRef>::iterator vl1cands_end;
   
   bool check_l1match = true;
   if (m_previousCandTag == edm::InputTag("")) check_l1match = false;
   if (check_l1match) {
     iEvent.getByToken(m_previousCandToken,previousLevelCands);
     previousLevelCands->getObjects(trigger::TriggerL1Mu,vl1cands);
     vl1cands_begin = vl1cands.begin();
     vl1cands_end = vl1cands.end();
   }
   
   std::vector<unsigned int> filteredMuons;
   for ( unsigned int i=0; i<muons->size(); ++i ){
     const reco::Muon& muon(muons->at(i));
     // check for dR match to L1 muons
     if (check_l1match) {
       bool matchl1 = false;
       for (std::vector<l1extra::L1MuonParticleRef>::iterator l1cand = vl1cands_begin; l1cand != vl1cands_end; ++l1cand) {
         if (deltaR(muon,**l1cand) < 0.3) {
           matchl1 = true;
           break;
         }
       }
       if (!matchl1) continue;
     }
     if ( (muon.type() & m_allowedTypeMask) == 0 ) continue;
     if ( (muon.type() & m_requiredTypeMask) != m_requiredTypeMask ) continue;
     if ( muon.numberOfMatchedStations()<m_minMuonStations ) continue;
     if ( !muon.innerTrack().isNull() ){
       if (muon.innerTrack()->numberOfValidHits()<m_minTrkHits) continue;
     }
     if ( !muon.globalTrack().isNull() ){
       if (muon.globalTrack()->normalizedChi2()>m_maxNormalizedChi2) continue;
       if (muon.globalTrack()->hitPattern().numberOfValidMuonHits()<m_minMuonHits) continue;
     }
     if ( muon.isTrackerMuon() && !muon::isGoodMuon(muon,m_trkMuonId) ) continue;
     if ( muon.pt() < m_minPt ) continue;
     if ( std::abs(muon.eta()) > m_maxAbsEta ) continue;
     filteredMuons.push_back(i);
   }
   
   for ( std::vector<unsigned int>::const_iterator itr = filteredMuons.begin(); itr != filteredMuons.end(); ++itr )
     filterproduct.addObject(trigger::TriggerMuon, reco::RecoChargedCandidateRef(cands,*itr));
   
   return filteredMuons.size()>=m_minN;
 }