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);
    
    virtual void produce(edm::Event &iEvent, edm::EventSetup const &iSetup);
    
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