HLTJetsCleanedFromLeadingLeptons.h

Go to the documentation of this file.

#ifndef HLTJetsCleanedFromLeadingLeptons_h
#define HLTJetsCleanedFromLeadingLeptons_h
 
#include <vector>
 
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 
#include "DataFormats/HLTReco/interface/TriggerFilterObjectWithRefs.h"
#include "HLTrigger/HLTcore/interface/defaultModuleLabel.h"
 
template <typename JetType>
class HLTJetsCleanedFromLeadingLeptons : public edm::stream::EDProducer<> {
public:
  typedef std::vector<JetType> JetCollection;
  typedef edm::Ref<JetCollection> JetRef;
  typedef edm::RefVector<JetCollection> JetRefVector;
 
  typedef std::vector<edm::RefVector<JetCollection, JetType, edm::refhelper::FindUsingAdvance<JetCollection, JetType>>>
      JetCollectionVector;
  //^ This is the type expected by HLTJetCollectionsFilter
 
private:
  class EtaPhiE {
  public:
    EtaPhiE(double eta, double phi, double e);
 
  public:
    double eta() const;
 
    double phi() const;
 
    double e() const;
 
    bool operator<(EtaPhiE const &rhs) const;
 
  private:
    double etaValue, phiValue;
 
    double eValue;
  };
 
public:
  HLTJetsCleanedFromLeadingLeptons(edm::ParameterSet const &iConfig);
 
public:
  static void fillDescriptions(edm::ConfigurationDescriptions &descriptions);
 
  void produce(edm::Event &iEvent, edm::EventSetup const &iSetup) override;
 
private:
  edm::EDGetTokenT<trigger::TriggerFilterObjectWithRefs> leptonToken;
 
  edm::EDGetTokenT<std::vector<JetType>> jetToken;
 
  double minDeltaR2;
 
  unsigned numLeptons;
};
 
// Implementation
 
#include "DataFormats/Common/interface/Handle.h"
 
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/RecoCandidate/interface/RecoEcalCandidate.h"
#include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
 
#include "DataFormats/Math/interface/deltaR.h"
 
template <typename JetType>
HLTJetsCleanedFromLeadingLeptons<JetType>::EtaPhiE::EtaPhiE(double eta, double phi, double e)
    : etaValue(eta), phiValue(phi), eValue(e) {}
 
template <typename JetType>
double HLTJetsCleanedFromLeadingLeptons<JetType>::EtaPhiE::eta() const {
  return etaValue;
}
 
template <typename JetType>
double HLTJetsCleanedFromLeadingLeptons<JetType>::EtaPhiE::phi() const {
  return phiValue;
}
 
template <typename JetType>
double HLTJetsCleanedFromLeadingLeptons<JetType>::EtaPhiE::e() const {
  return eValue;
}
 
template <typename JetType>
bool HLTJetsCleanedFromLeadingLeptons<JetType>::EtaPhiE::operator<(EtaPhiE const &rhs) const {
  return (eValue < rhs.eValue);
}
 
template <typename JetType>
HLTJetsCleanedFromLeadingLeptons<JetType>::HLTJetsCleanedFromLeadingLeptons(edm::ParameterSet const &iConfig)
    : 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>();
}
 
template <typename JetType>
void HLTJetsCleanedFromLeadingLeptons<JetType>::fillDescriptions(edm::ConfigurationDescriptions &descriptions) {
  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);
}
 
template <typename JetType>
void HLTJetsCleanedFromLeadingLeptons<JetType>::produce(edm::Event &iEvent, edm::EventSetup const &iSetup) {
  // 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));
}
 
#endif  // HLTJetsCleanedFromLeadingLeptons_h