Produces a collection of jets cleaned against leading leptons. More...

#include <HLTJetsCleanedFromLeadingLeptons.h>

Inheritance diagram for HLTJetsCleanedFromLeadingLeptons< JetType >:

Classes
class	EtaPhiE
	An auxiliary class to store momentum parametrised in eta, phi, and energy. More...

Public Types
typedef std::vector< JetType >	JetCollection

typedef std::vector< edm::RefVector< JetCollection, JetType, edm::refhelper::FindUsingAdvance< JetCollection, JetType > > >	JetCollectionVector

typedef edm::Ref< JetCollection >	JetRef

typedef edm::RefVector< JetCollection >	JetRefVector

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
	HLTJetsCleanedFromLeadingLeptons (edm::ParameterSet const &iConfig)
	Constructor. More...

void	produce (edm::Event &iEvent, edm::EventSetup const &iSetup) override
	Produces jets cleaned against leptons. More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
	Describes configuration of the plugin. More...

Private Attributes
edm::EDGetTokenT< std::vector< JetType > >	jetToken
	Token to access a collection of jets. More...

edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	leptonToken
	Token to identify a collection of leptons that pass an HLT filter. More...

double	minDeltaR2
	A square of the minimal allowed angular separation between a lepton and a jet. More...

unsigned	numLeptons
	Number of leading leptons against which the jets are cleaned. More...

Detailed Description

template<typename JetType>
class HLTJetsCleanedFromLeadingLeptons< JetType >

Produces a collection of jets cleaned against leading leptons.

Author: Andrey Popov, inspired by code by Lukasz Kreczko Leptons (muons or electrons) are read from results of a previous HLT filter. They are ordered in energy, and the user can configure how many leading leptons are used to clean jets. If the requested number is larger than the total number of leptons, all of them are used.

The plugin loops over the given collection of jets and exclude ones that are close to one of the leading leptons. References to surviving jets are stored in the same format as expected by the HLTJetCollectionsFilter plugin.

Definition at line 28 of file HLTJetsCleanedFromLeadingLeptons.h.

Member Typedef Documentation

◆ JetCollection

template<typename JetType >

typedef std::vector<JetType> HLTJetsCleanedFromLeadingLeptons< JetType >::JetCollection

Definition at line 30 of file HLTJetsCleanedFromLeadingLeptons.h.

◆ JetCollectionVector

template<typename JetType >

typedef std::vector<edm::RefVector<JetCollection, JetType, edm::refhelper::FindUsingAdvance<JetCollection, JetType> > > HLTJetsCleanedFromLeadingLeptons< JetType >::JetCollectionVector

Definition at line 35 of file HLTJetsCleanedFromLeadingLeptons.h.

◆ JetRef

template<typename JetType >

typedef edm::Ref<JetCollection> HLTJetsCleanedFromLeadingLeptons< JetType >::JetRef

Definition at line 31 of file HLTJetsCleanedFromLeadingLeptons.h.

◆ JetRefVector

template<typename JetType >

typedef edm::RefVector<JetCollection> HLTJetsCleanedFromLeadingLeptons< JetType >::JetRefVector

Definition at line 32 of file HLTJetsCleanedFromLeadingLeptons.h.

Constructor & Destructor Documentation

◆ HLTJetsCleanedFromLeadingLeptons()

template<typename JetType >

HLTJetsCleanedFromLeadingLeptons< JetType >::HLTJetsCleanedFromLeadingLeptons ( edm::ParameterSet const & iConfig )

Constructor.

Definition at line 137 of file HLTJetsCleanedFromLeadingLeptons.h.

     : minDeltaR2(std::pow(iConfig.getParameter<double>("minDeltaR"), 2)),
       numLeptons(iConfig.getParameter<unsigned>("numLeptons")) {
   leptonToken = consumes<trigger::TriggerFilterObjectWithRefs>(iConfig.getParameter<edm::InputTag>("leptons"));
   jetToken = consumes<std::vector<JetType>>(iConfig.getParameter<edm::InputTag>("jets"));
  
   produces<JetCollectionVector>();
 }

References edm::ParameterSet::getParameter(), HLTJetsCleanedFromLeadingLeptons< JetType >::jetToken, and HLTJetsCleanedFromLeadingLeptons< JetType >::leptonToken.

Member Function Documentation

◆ fillDescriptions()

template<typename JetType >

void HLTJetsCleanedFromLeadingLeptons< JetType >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Describes configuration of the plugin.

Definition at line 147 of file HLTJetsCleanedFromLeadingLeptons.h.

                                                                                                            {
   edm::ParameterSetDescription desc;
  
   desc.add<edm::InputTag>("leptons", edm::InputTag("triggerFilterObjectWithRefs"))
       ->setComment("A collection of leptons that pass an HLT filter");
   desc.add<edm::InputTag>("jets", edm::InputTag("jetCollection"))->setComment("A collection of jets");
   desc.add<double>("minDeltaR", 0.3)->setComment("Minimal allowed angular separation between a jet and a lepton");
   desc.add<unsigned>("numLeptons", 1)->setComment("Number of leading leptons against which the jets are cleaned");
  
   descriptions.add(defaultModuleLabel<HLTJetsCleanedFromLeadingLeptons<JetType>>(), desc);
 }

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

◆ produce()

template<typename JetType >

void HLTJetsCleanedFromLeadingLeptons< JetType >::produce	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

override

Produces jets cleaned against leptons.

Definition at line 160 of file HLTJetsCleanedFromLeadingLeptons.h.

                                                                                                      {
   // Read results of the lepton filter
   edm::Handle<trigger::TriggerFilterObjectWithRefs> filterOutput;
   iEvent.getByToken(leptonToken, filterOutput);
  
   // Momenta of the leptons that passed the filter will be pushed into a vector
   std::vector<EtaPhiE> leptonMomenta;
  
   // First, assume these are muons and try to store their momenta
   trigger::VRmuon muons;
   filterOutput->getObjects(trigger::TriggerMuon, muons);
  
   for (auto const &muRef : muons)  // the collection might be empty
     leptonMomenta.emplace_back(muRef->eta(), muRef->phi(), muRef->energy());
  
   // Then get the momenta as if these are electrons. Electrons are tricky because they can be
   //stored with three types of trigger objects: TriggerElectron, TriggerPhoton, and
   //TriggerCluster. Try them one by one.
   trigger::VRelectron electrons;
   filterOutput->getObjects(trigger::TriggerElectron, electrons);
  
   for (auto const &eRef : electrons)  // the collection might be empty
   {
     auto const &sc = eRef->superCluster();
     leptonMomenta.emplace_back(sc->eta(), sc->phi(), sc->energy());
   }
  
   trigger::VRphoton photons;
   filterOutput->getObjects(trigger::TriggerPhoton, photons);
  
   for (auto const &eRef : photons)  // the collection might be empty
   {
     auto const &sc = eRef->superCluster();
     leptonMomenta.emplace_back(sc->eta(), sc->phi(), sc->energy());
   }
  
   trigger::VRphoton clusters;
   filterOutput->getObjects(trigger::TriggerCluster, clusters);
  
   for (auto const &eRef : clusters)  // the collection might be empty
   {
     auto const &sc = eRef->superCluster();
     leptonMomenta.emplace_back(sc->eta(), sc->phi(), sc->energy());
   }
  
   // Make sure the momenta are sorted
   std::sort(leptonMomenta.rbegin(), leptonMomenta.rend());
  
   // Read the source collection of jets
   edm::Handle<JetCollection> jetHandle;
   iEvent.getByToken(jetToken, jetHandle);
   JetCollection const &jets = *jetHandle;
  
   // Put references to jets that are not matched to leptons into a dedicated collection
   JetRefVector cleanedJetRefs;
   unsigned const numLeptonsToLoop = std::min<unsigned>(leptonMomenta.size(), numLeptons);
  
   for (unsigned iJet = 0; iJet < jets.size(); ++iJet) {
     bool overlap = false;
  
     for (unsigned iLepton = 0; iLepton < numLeptonsToLoop; ++iLepton)
       if (reco::deltaR2(leptonMomenta.at(iLepton), jets.at(iJet)) < minDeltaR2) {
         overlap = true;
         break;
       }
  
     if (not overlap)
       cleanedJetRefs.push_back(JetRef(jetHandle, iJet));
   }
  
   // Store the collection in the event
   std::unique_ptr<JetCollectionVector> product(new JetCollectionVector);
   //^ Have to use the depricated unique_ptr here because this is what edm::Event::put expects
   product->emplace_back(cleanedJetRefs);
   iEvent.put(std::move(product));
 }