#include <HLTTriMuonIsolation.h>

Inheritance diagram for HLTTriMuonIsolation:

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

void	produce (edm::StreamID, edm::Event &, const edm::EventSetup &) const override

	~HLTTriMuonIsolation () override=default

Public Member Functions inherited from edm::global::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

EDProducer &	operator= (const EDProducer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Static Private Member Functions
template<typename T >
static bool	ptComparer (const T &cand_1, const T &cand_2)

Private Attributes
edm::Handle< reco::RecoChargedCandidateCollection >	AllMuCands

const edm::EDGetTokenT< reco::RecoChargedCandidateCollection >	AllMuonsToken_

const double	ChargedAbsIsoCut_

const double	ChargedRelIsoCut_

const bool	EnableAbsIso_

const bool	EnableRelIso_

const double	IsoConeSize_

edm::Handle< reco::TrackCollection >	IsoTracks

const edm::EDGetTokenT< reco::TrackCollection >	IsoTracksToken_

edm::Handle< trigger::TriggerFilterObjectWithRefs >	L3DiMuonsFilterCands

const edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	L3DiMuonsFilterToken_

edm::Handle< reco::RecoChargedCandidateCollection >	L3MuCands

const edm::EDGetTokenT< reco::RecoChargedCandidateCollection >	L3MuonsToken_

const double	MatchingConeSize_

const double	MaxDZ_

const double	MaxTriMuonMass_

const double	MaxTriMuonRadius_

const double	MinTriMuonMass_

const double	Muon1PtCut_

const double	Muon2PtCut_

const double	Muon3PtCut_

edm::Handle< reco::RecoChargedCandidateRef >	PassedL3Muons

const int	TriMuonAbsCharge_

const double	TriMuonEtaCut_

const double	TriMuonPtCut_

const double	TwiceMuonMass_ = 2. * 0.1056583715

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

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 23 of file HLTTriMuonIsolation.h.

Constructor & Destructor Documentation

◆ HLTTriMuonIsolation()

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

inlineexplicit

Definition at line 67 of file HLTTriMuonIsolation.h.

     : L3MuonsToken_(consumes<reco::RecoChargedCandidateCollection>(iConfig.getParameter<edm::InputTag>("L3MuonsSrc"))),
       AllMuonsToken_(
           consumes<reco::RecoChargedCandidateCollection>(iConfig.getParameter<edm::InputTag>("AllMuonsSrc"))),
       L3DiMuonsFilterToken_(
           consumes<trigger::TriggerFilterObjectWithRefs>(iConfig.getParameter<edm::InputTag>("L3DiMuonsFilterSrc"))),
       IsoTracksToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("IsoTracksSrc"))),
       Muon1PtCut_(iConfig.getParameter<double>("Muon1PtCut")),
       Muon2PtCut_(iConfig.getParameter<double>("Muon2PtCut")),
       Muon3PtCut_(iConfig.getParameter<double>("Muon3PtCut")),
       TriMuonPtCut_(iConfig.getParameter<double>("TriMuonPtCut")),
       TriMuonEtaCut_(iConfig.getParameter<double>("TriMuonEtaCut")),
       ChargedRelIsoCut_(iConfig.getParameter<double>("ChargedRelIsoCut")),
       ChargedAbsIsoCut_(iConfig.getParameter<double>("ChargedAbsIsoCut")),
       IsoConeSize_(iConfig.getParameter<double>("IsoConeSize")),
       MatchingConeSize_(iConfig.getParameter<double>("MatchingConeSize")),
       MinTriMuonMass_(iConfig.getParameter<double>("MinTriMuonMass")),
       MaxTriMuonMass_(iConfig.getParameter<double>("MaxTriMuonMass")),
       MaxTriMuonRadius_(iConfig.getParameter<double>("MaxTriMuonRadius")),
       TriMuonAbsCharge_(iConfig.getParameter<int>("TriMuonAbsCharge")),
       MaxDZ_(iConfig.getParameter<double>("MaxDZ")),
       EnableRelIso_(iConfig.getParameter<bool>("EnableRelIso")),
       EnableAbsIso_(iConfig.getParameter<bool>("EnableAbsIso")) {
   //register products
   produces<reco::CompositeCandidateCollection>("Taus");
   produces<reco::CompositeCandidateCollection>("SelectedTaus");
 }

◆ ~HLTTriMuonIsolation()

HLTTriMuonIsolation::~HLTTriMuonIsolation ( )

overridedefault

Member Function Documentation

◆ fillDescriptions()

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

inlinestatic

Definition at line 269 of file HLTTriMuonIsolation.h.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                             {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("L3MuonsSrc", edm::InputTag("hltIterL3FromL2MuonCandidates"));
   desc.add<edm::InputTag>("AllMuonsSrc", edm::InputTag("hltGlbTrkMuonCands"));
   desc.add<edm::InputTag>("L3DiMuonsFilterSrc", edm::InputTag("hltDiMuonForTau3MuDzFiltered0p3"));
   desc.add<edm::InputTag>("IsoTracksSrc", edm::InputTag("hltIter2L3FromL2MuonMerged"));
   desc.add<double>("Muon1PtCut", 5.);
   desc.add<double>("Muon2PtCut", 3.);
   desc.add<double>("Muon3PtCut", 0.);
   desc.add<double>("TriMuonPtCut", 8.);
   desc.add<double>("TriMuonEtaCut", 2.5);
   desc.add<double>("ChargedAbsIsoCut", 3.0);
   desc.add<double>("ChargedRelIsoCut", 0.1);
   desc.add<double>("IsoConeSize", 0.5);
   desc.add<double>("MatchingConeSize", 0.03);
   desc.add<double>("MinTriMuonMass", 0.5);
   desc.add<double>("MaxTriMuonMass", 2.8);
   desc.add<double>("MaxTriMuonRadius", 0.6);
   desc.add<int>("TriMuonAbsCharge", -1);
   desc.add<double>("MaxDZ", 0.3);
   desc.add<bool>("EnableRelIso", false);
   desc.add<bool>("EnableAbsIso", true);
   descriptions.add("hltTriMuonIsolationProducer", desc);
 }

◆ produce()

void HLTTriMuonIsolation::produce	(	edm::StreamID	sid,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		const

inlineoverridevirtual

Implements edm::global::EDProducerBase.

Definition at line 95 of file HLTTriMuonIsolation.h.

References funct::abs(), AllMuCands, AllMuonsToken_, ALCARECOTkAlJpsiMuMu_cff::charge, ChargedAbsIsoCut_, ChargedRelIsoCut_, BPhysicsValidation_cfi::daughters, reco::deltaR2(), EnableAbsIso_, EnableRelIso_, trigger::TriggerRefsCollections::getObjects(), mps_fire::i, iEvent, infinity, IsoConeSize_, IsoTracks, IsoTracksToken_, dqmiolumiharvest::j, dqmdumpme::k, L3DiMuonsFilterCands, L3DiMuonsFilterToken_, L3MuCands, L3MuonsToken_, EgHLTOffHistBins_cfi::mass, MatchingConeSize_, MaxDZ_, MaxTriMuonMass_, MaxTriMuonRadius_, MinTriMuonMass_, eostools::move(), Muon1PtCut_, Muon2PtCut_, Muon3PtCut_, PassedL3Muons, DiDispStaMuonMonitor_cfi::pt, jetUpdater_cfi::sort, TtFullHadEvtBuilder_cfi::sumPt, metsig::tau, trigger::TriggerMuon, TriMuonAbsCharge_, TriMuonEtaCut_, TriMuonPtCut_, TwiceMuonMass_, and bphysicsOniaDQM_cfi::vertex.

                                                                                                              {
   std::unique_ptr<reco::CompositeCandidateCollection> Taus(new reco::CompositeCandidateCollection);
   std::unique_ptr<reco::CompositeCandidateCollection> SelectedTaus(new reco::CompositeCandidateCollection);
 
   // Get the L3 muon candidates
   edm::Handle<reco::RecoChargedCandidateCollection> L3MuCands;
   iEvent.getByToken(L3MuonsToken_, L3MuCands);
 
   // Get the L3 muon candidates that passed the filter
   edm::Handle<trigger::TriggerFilterObjectWithRefs> L3DiMuonsFilterCands;
   iEvent.getByToken(L3DiMuonsFilterToken_, L3DiMuonsFilterCands);
 
   std::vector<reco::RecoChargedCandidateRef> PassedL3Muons;
   L3DiMuonsFilterCands->getObjects(trigger::TriggerMuon, PassedL3Muons);
 
   // Get the Trk + L3 muon candidates (after merging)
   edm::Handle<reco::RecoChargedCandidateCollection> AllMuCands;
   iEvent.getByToken(AllMuonsToken_, AllMuCands);
 
   // Get iso tracks
   edm::Handle<reco::TrackCollection> IsoTracks;
   iEvent.getByToken(IsoTracksToken_, IsoTracks);
 
   if (AllMuCands->size() >= 3 && L3MuCands->size() >= 2) {
     // Create the 3-muon candidates
     // loop over L3/Trk muons and create all combinations
     auto AllMuCands_end = AllMuCands->end();
     for (auto i = AllMuCands->begin(); i != AllMuCands_end - 2; ++i) {
       // check that muon_i passes the previous filter
       bool passingPreviousFilter_1 = false;
       for (const auto& imu : PassedL3Muons) {
         if (reco::deltaR2(i->momentum(), imu->momentum()) < (MatchingConeSize_ * MatchingConeSize_))
           passingPreviousFilter_1 = true;
       }
       for (auto j = i + 1; j != AllMuCands_end - 1; ++j) {
         // check that muon_j passes the previous filter
         bool passingPreviousFilter_2 = false;
         for (const auto& jmu : PassedL3Muons) {
           if (reco::deltaR2(j->momentum(), jmu->momentum()) < (MatchingConeSize_ * MatchingConeSize_))
             passingPreviousFilter_2 = true;
         }
         // if, at this point, no muons passed the previous filter just skip to the next iteration
         if (!(passingPreviousFilter_1 || passingPreviousFilter_2))
           continue;
         for (auto k = j + 1; k != AllMuCands_end; ++k) {
           // check that muon_k passes the previous filter
           bool passingPreviousFilter_3 = false;
           for (const auto& kmu : PassedL3Muons) {
             if (reco::deltaR2(k->momentum(), kmu->momentum()) < (MatchingConeSize_ * MatchingConeSize_))
               passingPreviousFilter_3 = true;
           }
           // at least two muons must have passed the previous di-muon filter
           if (!((passingPreviousFilter_1 & passingPreviousFilter_2) ||
                 (passingPreviousFilter_1 & passingPreviousFilter_3) ||
                 (passingPreviousFilter_2 & passingPreviousFilter_3)))
             continue;
 
           // Create a composite candidate to be a tau
           reco::CompositeCandidate tau;
 
           // sort the muons by pt and add them to the tau
           reco::RecoChargedCandidateCollection daughters;
           daughters.reserve(3);
 
           daughters.push_back(*i);
           daughters.push_back(*j);
           daughters.push_back(*k);
 
           std::sort(daughters.begin(), daughters.end(), ptComparer<reco::RecoChargedCandidate>);
 
           // Muon kinematic selections
           if (daughters[0].pt() < Muon1PtCut_)
             continue;
           if (daughters[1].pt() < Muon2PtCut_)
             continue;
           if (daughters[2].pt() < Muon3PtCut_)
             continue;
 
           // assign the tau its daughters
           tau.addDaughter((daughters)[0], "Muon_1");
           tau.addDaughter((daughters)[1], "Muon_2");
           tau.addDaughter((daughters)[2], "Muon_3");
 
           // start building the tau
           int charge = daughters[0].charge() + daughters[1].charge() + daughters[2].charge();
           math::XYZTLorentzVectorD taup4 = daughters[0].p4() + daughters[1].p4() + daughters[2].p4();
           int tauPdgId = charge > 0 ? 15 : -15;
 
           tau.setP4(taup4);
           tau.setCharge(charge);
           tau.setPdgId(tauPdgId);
           tau.setVertex((daughters)[0].vertex());  // assign the leading muon vertex as tau vertex
 
           // the three muons must be close to each other in Z
           if (std::abs(tau.daughter(0)->vz() - tau.vz()) > MaxDZ_)
             continue;
           if (std::abs(tau.daughter(1)->vz() - tau.vz()) > MaxDZ_)
             continue;
           if (std::abs(tau.daughter(2)->vz() - tau.vz()) > MaxDZ_)
             continue;
 
           // require muons to be collimated
           bool collimated = true;
           for (auto const& idau : daughters) {
             if (reco::deltaR2(tau.p4(), idau.p4()) > MaxTriMuonRadius_ * MaxTriMuonRadius_) {
               collimated = false;
               break;
             }
           }
 
           if (!collimated)
             continue;
 
           // Tau kinematic selections
           if (tau.pt() < TriMuonPtCut_)
             continue;
           if (tau.mass() < MinTriMuonMass_)
             continue;
           if (tau.mass() > MaxTriMuonMass_)
             continue;
           if (std::abs(tau.eta()) > TriMuonEtaCut_)
             continue;
 
           // Tau charge selection
           if ((std::abs(tau.charge()) != TriMuonAbsCharge_) & (TriMuonAbsCharge_ >= 0))
             continue;
 
           // Sanity check against duplicates, di-muon masses must be > 2 * mass_mu
           if ((tau.daughter(0)->p4() + tau.daughter(1)->p4()).mass() < TwiceMuonMass_)
             continue;
           if ((tau.daughter(0)->p4() + tau.daughter(2)->p4()).mass() < TwiceMuonMass_)
             continue;
           if ((tau.daughter(1)->p4() + tau.daughter(2)->p4()).mass() < TwiceMuonMass_)
             continue;
 
           // a good tau, at last
           Taus->push_back(tau);
         }
       }
     }
 
     // Sort taus by pt
     std::sort(Taus->begin(), Taus->end(), ptComparer<reco::CompositeCandidate>);
 
     // Loop over taus and further select by isolation
     for (const auto& itau : *Taus) {
       // remove the candidate pt from the iso sum
       double sumPt = -itau.pt();
 
       // compute iso sum pT
       for (const auto& itrk : *IsoTracks) {
         if (reco::deltaR2(itrk.momentum(), itau.p4()) > IsoConeSize_ * IsoConeSize_)
           continue;
         if (std::abs(itrk.vz() - itau.vz()) > MaxDZ_)
           continue;
         sumPt += itrk.pt();
       }
 
       // apply the isolation cut
       double chAbsIsoCut = EnableAbsIso_ ? ChargedAbsIsoCut_ : std::numeric_limits<double>::infinity();
       double chRelIsoCut = EnableRelIso_ ? ChargedRelIsoCut_ * itau.pt() : std::numeric_limits<double>::infinity();
 
       if (!((sumPt < chAbsIsoCut) || (sumPt < chRelIsoCut)))
         continue;
 
       SelectedTaus->push_back(itau);
     }
   }
 
   // finally put the vector of 3-muon candidates in the event
   iEvent.put(std::move(Taus), "Taus");
   iEvent.put(std::move(SelectedTaus), "SelectedTaus");
 }

◆ ptComparer()

template<typename T >

static bool HLTTriMuonIsolation::ptComparer	(	const T &	cand_1,
		const T &	cand_2
	)

inlinestaticprivate

Definition at line 43 of file HLTTriMuonIsolation.h.

                                                            {
     return cand_1.pt() > cand_2.pt();
   }

Member Data Documentation

◆ AllMuCands

edm::Handle<reco::RecoChargedCandidateCollection> HLTTriMuonIsolation::AllMuCands

private

Definition at line 39 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ AllMuonsToken_

const edm::EDGetTokenT<reco::RecoChargedCandidateCollection> HLTTriMuonIsolation::AllMuonsToken_

private

Definition at line 32 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ ChargedAbsIsoCut_

const double HLTTriMuonIsolation::ChargedAbsIsoCut_

private

Definition at line 55 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ ChargedRelIsoCut_

const double HLTTriMuonIsolation::ChargedRelIsoCut_

private

Definition at line 54 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ EnableAbsIso_

const bool HLTTriMuonIsolation::EnableAbsIso_

private

Definition at line 64 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ EnableRelIso_

const bool HLTTriMuonIsolation::EnableRelIso_

private

Definition at line 63 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ IsoConeSize_

const double HLTTriMuonIsolation::IsoConeSize_

private

Definition at line 56 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ IsoTracks

edm::Handle<reco::TrackCollection> HLTTriMuonIsolation::IsoTracks

private

Definition at line 40 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ IsoTracksToken_

const edm::EDGetTokenT<reco::TrackCollection> HLTTriMuonIsolation::IsoTracksToken_

private

Definition at line 34 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ L3DiMuonsFilterCands

edm::Handle<trigger::TriggerFilterObjectWithRefs> HLTTriMuonIsolation::L3DiMuonsFilterCands

private

Definition at line 37 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ L3DiMuonsFilterToken_

const edm::EDGetTokenT<trigger::TriggerFilterObjectWithRefs> HLTTriMuonIsolation::L3DiMuonsFilterToken_

private

Definition at line 33 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ L3MuCands

edm::Handle<reco::RecoChargedCandidateCollection> HLTTriMuonIsolation::L3MuCands

private

Definition at line 36 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ L3MuonsToken_

const edm::EDGetTokenT<reco::RecoChargedCandidateCollection> HLTTriMuonIsolation::L3MuonsToken_

private

Definition at line 31 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ MatchingConeSize_

const double HLTTriMuonIsolation::MatchingConeSize_

private

Definition at line 57 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ MaxDZ_

const double HLTTriMuonIsolation::MaxDZ_

private

Definition at line 62 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ MaxTriMuonMass_

const double HLTTriMuonIsolation::MaxTriMuonMass_

private

Definition at line 59 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ MaxTriMuonRadius_

const double HLTTriMuonIsolation::MaxTriMuonRadius_

private

Definition at line 60 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ MinTriMuonMass_

const double HLTTriMuonIsolation::MinTriMuonMass_

private

Definition at line 58 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ Muon1PtCut_

const double HLTTriMuonIsolation::Muon1PtCut_

private

Definition at line 49 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ Muon2PtCut_

const double HLTTriMuonIsolation::Muon2PtCut_

private

Definition at line 50 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ Muon3PtCut_

const double HLTTriMuonIsolation::Muon3PtCut_

private

Definition at line 51 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ PassedL3Muons

edm::Handle<reco::RecoChargedCandidateRef> HLTTriMuonIsolation::PassedL3Muons

private

Definition at line 38 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ TriMuonAbsCharge_

const int HLTTriMuonIsolation::TriMuonAbsCharge_

private

Definition at line 61 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ TriMuonEtaCut_

const double HLTTriMuonIsolation::TriMuonEtaCut_

private

Definition at line 53 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ TriMuonPtCut_

const double HLTTriMuonIsolation::TriMuonPtCut_

private

Definition at line 52 of file HLTTriMuonIsolation.h.

Referenced by produce().

◆ TwiceMuonMass_

const double HLTTriMuonIsolation::TwiceMuonMass_ = 2. * 0.1056583715

private

Definition at line 47 of file HLTTriMuonIsolation.h.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HLTTriMuonIsolation()

◆ ~HLTTriMuonIsolation()

Member Function Documentation

◆ fillDescriptions()

◆ produce()

◆ ptComparer()

Member Data Documentation

◆ AllMuCands

◆ AllMuonsToken_

◆ ChargedAbsIsoCut_

◆ ChargedRelIsoCut_

◆ EnableAbsIso_

◆ EnableRelIso_

◆ IsoConeSize_

◆ IsoTracks

◆ IsoTracksToken_

◆ L3DiMuonsFilterCands

◆ L3DiMuonsFilterToken_

◆ L3MuCands

◆ L3MuonsToken_

◆ MatchingConeSize_

◆ MaxDZ_

◆ MaxTriMuonMass_

◆ MaxTriMuonRadius_

◆ MinTriMuonMass_

◆ Muon1PtCut_

◆ Muon2PtCut_

◆ Muon3PtCut_

◆ PassedL3Muons

◆ TriMuonAbsCharge_

◆ TriMuonEtaCut_

◆ TriMuonPtCut_

◆ TwiceMuonMass_