GenTtbarCategorizer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    TopQuarkAnalysis/TopTools
// Class:      GenTtbarCategorizer
//
//
// Original Author:  Johannes Hauk, Nazar Bartosik
//         Created:  Sun, 14 Jun 2015 19:42:58 GMT
//
//
 
// system include files
#include <memory>
#include <algorithm>
#include <functional>
 
// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/JetReco/interface/GenJetCollection.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
 
//
// class declaration
//
 
class GenTtbarCategorizer : public edm::EDProducer {
public:
  explicit GenTtbarCategorizer(const edm::ParameterSet&);
  ~GenTtbarCategorizer() override;
 
  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
private:
  void beginJob() override;
  void produce(edm::Event&, const edm::EventSetup&) override;
  void endJob() override;
 
  //virtual void beginRun(edm::Run const&, edm::EventSetup const&) override;
  //virtual void endRun(edm::Run const&, edm::EventSetup const&) override;
  //virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
  //virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
 
  std::vector<int> nHadronsOrderedJetIndices(const std::map<int, int>& m_jetIndex);
 
  // ----------member data ---------------------------
 
  // Jet configuration
  const double genJetPtMin_;
  const double genJetAbsEtaMax_;
 
  // Input tags
  const edm::EDGetTokenT<reco::GenJetCollection> genJetsToken_;
 
  const edm::EDGetTokenT<std::vector<int> > genBHadJetIndexToken_;
  const edm::EDGetTokenT<std::vector<int> > genBHadFlavourToken_;
  const edm::EDGetTokenT<std::vector<int> > genBHadFromTopWeakDecayToken_;
  const edm::EDGetTokenT<std::vector<reco::GenParticle> > genBHadPlusMothersToken_;
  const edm::EDGetTokenT<std::vector<std::vector<int> > > genBHadPlusMothersIndicesToken_;
  const edm::EDGetTokenT<std::vector<int> > genBHadIndexToken_;
  const edm::EDGetTokenT<std::vector<int> > genBHadLeptonHadronIndexToken_;
  const edm::EDGetTokenT<std::vector<int> > genBHadLeptonViaTauToken_;
 
  const edm::EDGetTokenT<std::vector<int> > genCHadJetIndexToken_;
  const edm::EDGetTokenT<std::vector<int> > genCHadFlavourToken_;
  const edm::EDGetTokenT<std::vector<int> > genCHadFromTopWeakDecayToken_;
  const edm::EDGetTokenT<std::vector<int> > genCHadBHadronIdToken_;
};
 
//
// constants, enums and typedefs
//
 
//
// static data member definitions
//
 
//
// constructors and destructor
//
GenTtbarCategorizer::GenTtbarCategorizer(const edm::ParameterSet& iConfig)
    : genJetPtMin_(iConfig.getParameter<double>("genJetPtMin")),
      genJetAbsEtaMax_(iConfig.getParameter<double>("genJetAbsEtaMax")),
      genJetsToken_(consumes<reco::GenJetCollection>(iConfig.getParameter<edm::InputTag>("genJets"))),
      genBHadJetIndexToken_(consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genBHadJetIndex"))),
      genBHadFlavourToken_(consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genBHadFlavour"))),
      genBHadFromTopWeakDecayToken_(
          consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genBHadFromTopWeakDecay"))),
      genBHadPlusMothersToken_(
          consumes<std::vector<reco::GenParticle> >(iConfig.getParameter<edm::InputTag>("genBHadPlusMothers"))),
      genBHadPlusMothersIndicesToken_(
          consumes<std::vector<std::vector<int> > >(iConfig.getParameter<edm::InputTag>("genBHadPlusMothersIndices"))),
      genBHadIndexToken_(consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genBHadIndex"))),
      genBHadLeptonHadronIndexToken_(
          consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genBHadLeptonHadronIndex"))),
      genBHadLeptonViaTauToken_(
          consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genBHadLeptonViaTau"))),
      genCHadJetIndexToken_(consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genCHadJetIndex"))),
      genCHadFlavourToken_(consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genCHadFlavour"))),
      genCHadFromTopWeakDecayToken_(
          consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genCHadFromTopWeakDecay"))),
      genCHadBHadronIdToken_(consumes<std::vector<int> >(iConfig.getParameter<edm::InputTag>("genCHadBHadronId"))) {
  produces<int>("genTtbarId");
}
 
GenTtbarCategorizer::~GenTtbarCategorizer() {}
 
//
// member functions
//
 
// ------------ method called to produce the data  ------------
void GenTtbarCategorizer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  // Access gen jets
  edm::Handle<reco::GenJetCollection> genJets;
  iEvent.getByToken(genJetsToken_, genJets);
 
  // Access B hadrons information
  edm::Handle<std::vector<int> > genBHadFlavour;
  iEvent.getByToken(genBHadFlavourToken_, genBHadFlavour);
 
  edm::Handle<std::vector<int> > genBHadJetIndex;
  iEvent.getByToken(genBHadJetIndexToken_, genBHadJetIndex);
 
  edm::Handle<std::vector<int> > genBHadFromTopWeakDecay;
  iEvent.getByToken(genBHadFromTopWeakDecayToken_, genBHadFromTopWeakDecay);
 
  edm::Handle<std::vector<reco::GenParticle> > genBHadPlusMothers;
  iEvent.getByToken(genBHadPlusMothersToken_, genBHadPlusMothers);
 
  edm::Handle<std::vector<std::vector<int> > > genBHadPlusMothersIndices;
  iEvent.getByToken(genBHadPlusMothersIndicesToken_, genBHadPlusMothersIndices);
 
  edm::Handle<std::vector<int> > genBHadIndex;
  iEvent.getByToken(genBHadIndexToken_, genBHadIndex);
 
  edm::Handle<std::vector<int> > genBHadLeptonHadronIndex;
  iEvent.getByToken(genBHadLeptonHadronIndexToken_, genBHadLeptonHadronIndex);
 
  edm::Handle<std::vector<int> > genBHadLeptonViaTau;
  iEvent.getByToken(genBHadLeptonViaTauToken_, genBHadLeptonViaTau);
 
  // Access C hadrons information
  edm::Handle<std::vector<int> > genCHadFlavour;
  iEvent.getByToken(genCHadFlavourToken_, genCHadFlavour);
 
  edm::Handle<std::vector<int> > genCHadJetIndex;
  iEvent.getByToken(genCHadJetIndexToken_, genCHadJetIndex);
 
  edm::Handle<std::vector<int> > genCHadFromTopWeakDecay;
  iEvent.getByToken(genCHadFromTopWeakDecayToken_, genCHadFromTopWeakDecay);
 
  edm::Handle<std::vector<int> > genCHadBHadronId;
  iEvent.getByToken(genCHadBHadronIdToken_, genCHadBHadronId);
 
  // Map <jet index, number of specific hadrons in jet>
  // B jets with b hadrons directly from t->b decay
  std::map<int, int> bJetFromTopIds;
  // B jets with b hadrons from W->b decay
  std::map<int, int> bJetFromWIds;
  // C jets with c hadrons from W->c decay
  std::map<int, int> cJetFromWIds;
  // B jets with b hadrons before top quark decay chain
  std::map<int, int> bJetAdditionalIds;
  // C jets with c hadrons before top quark decay chain
  std::map<int, int> cJetAdditionalIds;
 
  // Count number of specific b hadrons in each jet
  for (size_t hadronId = 0; hadronId < genBHadIndex->size(); ++hadronId) {
    // Index of jet associated to the hadron
    const int jetIndex = genBHadJetIndex->at(hadronId);
    // Skip hadrons which have no associated jet
    if (jetIndex < 0)
      continue;
    // Skip if jet is not in acceptance
    if (genJets->at(jetIndex).pt() < genJetPtMin_)
      continue;
    if (std::fabs(genJets->at(jetIndex).eta()) > genJetAbsEtaMax_)
      continue;
    // Flavour of the hadron's origin
    const int flavour = genBHadFlavour->at(hadronId);
    // Jet from t->b decay [pdgId(top)=6]
    if (std::abs(flavour) == 6) {
      if (bJetFromTopIds.count(jetIndex) < 1)
        bJetFromTopIds[jetIndex] = 1;
      else
        bJetFromTopIds[jetIndex]++;
      continue;
    }
    // Jet from W->b decay [pdgId(W)=24]
    if (std::abs(flavour) == 24) {
      if (bJetFromWIds.count(jetIndex) < 1)
        bJetFromWIds[jetIndex] = 1;
      else
        bJetFromWIds[jetIndex]++;
      continue;
    }
    // Identify jets with b hadrons not from top-quark or W-boson decay
    if (bJetAdditionalIds.count(jetIndex) < 1)
      bJetAdditionalIds[jetIndex] = 1;
    else
      bJetAdditionalIds[jetIndex]++;
  }
 
  // Cleaning up b jets from W->b decays
  for (std::map<int, int>::iterator it = bJetFromWIds.begin(); it != bJetFromWIds.end();) {
    // Cannot be a b jet from t->b decay
    if (bJetFromTopIds.count(it->first) > 0)
      bJetFromWIds.erase(it++);
    else
      ++it;
  }
 
  // Cleaning up additional b jets
  for (std::map<int, int>::iterator it = bJetAdditionalIds.begin(); it != bJetAdditionalIds.end();) {
    // Cannot be a b jet from t->b decay
    if (bJetFromTopIds.count(it->first) > 0)
      bJetAdditionalIds.erase(it++);
    // Cannot be a b jet from W->b decay
    else if (bJetFromWIds.count(it->first) > 0)
      bJetAdditionalIds.erase(it++);
    else
      ++it;
  }
 
  // Count number of specific c hadrons in each c jet
  for (size_t hadronId = 0; hadronId < genCHadJetIndex->size(); ++hadronId) {
    // Index of jet associated to the hadron
    const int jetIndex = genCHadJetIndex->at(hadronId);
    // Skip hadrons which have no associated jet
    if (jetIndex < 0)
      continue;
    // Skip c hadrons that are coming from b hadrons
    if (genCHadBHadronId->at(hadronId) >= 0)
      continue;
    // Skip if jet is not in acceptance
    if (genJets->at(jetIndex).pt() < genJetPtMin_)
      continue;
    if (std::fabs(genJets->at(jetIndex).eta()) > genJetAbsEtaMax_)
      continue;
    // Skip if jet contains a b hadron
    if (bJetFromTopIds.count(jetIndex) > 0)
      continue;
    if (bJetFromWIds.count(jetIndex) > 0)
      continue;
    if (bJetAdditionalIds.count(jetIndex) > 0)
      continue;
    // Flavour of the hadron's origin
    const int flavour = genCHadFlavour->at(hadronId);
    // Jet from W->c decay [pdgId(W)=24]
    if (std::abs(flavour) == 24) {
      if (cJetFromWIds.count(jetIndex) < 1)
        cJetFromWIds[jetIndex] = 1;
      else
        cJetFromWIds[jetIndex]++;
      continue;
    }
    // Identify jets with c hadrons not from W-boson decay
    if (cJetAdditionalIds.count(jetIndex) < 1)
      cJetAdditionalIds[jetIndex] = 1;
    else
      cJetAdditionalIds[jetIndex]++;
  }
 
  // Cleaning up additional c jets
  for (std::map<int, int>::iterator it = cJetAdditionalIds.begin(); it != cJetAdditionalIds.end();) {
    // Cannot be a c jet from W->c decay
    if (cJetFromWIds.count(it->first) > 0)
      cJetAdditionalIds.erase(it++);
    else
      ++it;
  }
 
  // Categorize event based on number of additional b/c jets
  // and number of corresponding hadrons in each of them
  int additionalJetEventId = bJetFromTopIds.size() * 100 + bJetFromWIds.size() * 1000 + cJetFromWIds.size() * 10000;
  // tt + 1 additional b jet
  if (bJetAdditionalIds.size() == 1) {
    const int nHadronsInJet = bJetAdditionalIds.begin()->second;
    // tt + 1 additional b jet from 1 additional b hadron
    if (nHadronsInJet == 1)
      additionalJetEventId += 51;
    // tt + 1 additional b jet from >=2 additional b hadrons
    else
      additionalJetEventId += 52;
  }
  // tt + >=2 additional b jets
  else if (bJetAdditionalIds.size() > 1) {
    // Check first two additional b jets (rare cases could have more)
    const std::vector<int> orderedJetIndices = nHadronsOrderedJetIndices(bJetAdditionalIds);
    int nHadronsInJet1 = bJetAdditionalIds.at(orderedJetIndices.at(0));
    int nHadronsInJet2 = bJetAdditionalIds.at(orderedJetIndices.at(1));
    // tt + >=2 additional b jets each from 1 additional b hadron
    if (std::max(nHadronsInJet1, nHadronsInJet2) == 1)
      additionalJetEventId += 53;
    // tt + >=2 additional b jets one of which from >=2 additional b hadrons
    else if (std::min(nHadronsInJet1, nHadronsInJet2) == 1 && std::max(nHadronsInJet1, nHadronsInJet2) > 1)
      additionalJetEventId += 54;
    // tt + >=2 additional b jets each from >=2 additional b hadrons
    else if (std::min(nHadronsInJet1, nHadronsInJet2) > 1)
      additionalJetEventId += 55;
  }
  // tt + no additional b jets
  else {
    // tt + 1 additional c jet
    if (cJetAdditionalIds.size() == 1) {
      const int nHadronsInJet = cJetAdditionalIds.begin()->second;
      // tt + 1 additional c jet from 1 additional c hadron
      if (nHadronsInJet == 1)
        additionalJetEventId += 41;
      // tt + 1 additional c jet from >=2 additional c hadrons
      else
        additionalJetEventId += 42;
    }
    // tt + >=2 additional c jets
    else if (cJetAdditionalIds.size() > 1) {
      // Check first two additional c jets (rare cases could have more)
      const std::vector<int> orderedJetIndices = nHadronsOrderedJetIndices(cJetAdditionalIds);
      int nHadronsInJet1 = cJetAdditionalIds.at(orderedJetIndices.at(0));
      int nHadronsInJet2 = cJetAdditionalIds.at(orderedJetIndices.at(1));
      // tt + >=2 additional c jets each from 1 additional c hadron
      if (std::max(nHadronsInJet1, nHadronsInJet2) == 1)
        additionalJetEventId += 43;
      // tt + >=2 additional c jets one of which from >=2 additional c hadrons
      else if (std::min(nHadronsInJet1, nHadronsInJet2) == 1 && std::max(nHadronsInJet1, nHadronsInJet2) > 1)
        additionalJetEventId += 44;
      // tt + >=2 additional c jets each from >=2 additional c hadrons
      else if (std::min(nHadronsInJet1, nHadronsInJet2) > 1)
        additionalJetEventId += 45;
    }
    // tt + no additional c jets
    else {
      // tt + light jets
      additionalJetEventId += 0;
    }
  }
 
  std::unique_ptr<int> ttbarId(new int);
  *ttbarId = additionalJetEventId;
  iEvent.put(std::move(ttbarId), "genTtbarId");
}
 
// ------------ method called once each job just before starting event loop  ------------
void GenTtbarCategorizer::beginJob() {}
 
// ------------ method called once each job just after ending the event loop  ------------
void GenTtbarCategorizer::endJob() {}
 
// ------------ method called when starting to processes a run  ------------
/*
void
GenTtbarCategorizer::beginRun(edm::Run const&, edm::EventSetup const&)
{
}
*/
 
// ------------ method called when ending the processing of a run  ------------
/*
void
GenTtbarCategorizer::endRun(edm::Run const&, edm::EventSetup const&)
{
}
*/
 
// ------------ method called when starting to processes a luminosity block  ------------
/*
void
GenTtbarCategorizer::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
{
}
*/
 
// ------------ method called when ending the processing of a luminosity block  ------------
/*
void
GenTtbarCategorizer::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
{
}
*/
 
// ------------ method returns a vector of jet indices from the given map, sorted by N hadrons in descending order  ------------
std::vector<int> GenTtbarCategorizer::nHadronsOrderedJetIndices(const std::map<int, int>& m_jetIndex) {
  const int nElements = m_jetIndex.size();
  std::vector<std::pair<int, int> > v_jetNhadIndexPair;
  v_jetNhadIndexPair.reserve(nElements);
  for (std::map<int, int>::const_iterator it = m_jetIndex.begin(); it != m_jetIndex.end(); ++it) {
    const int jetIndex = it->first;
    const int nHadrons = it->second;
    v_jetNhadIndexPair.push_back(std::pair<int, int>(nHadrons, jetIndex));
  }
  // Sorting the vector of pairs by their key value
  std::sort(v_jetNhadIndexPair.begin(), v_jetNhadIndexPair.end(), std::greater<std::pair<int, int> >());
  // Building the vector of indices in the proper order
  std::vector<int> v_orderedJetIndices;
  v_orderedJetIndices.reserve(nElements);
  for (std::vector<std::pair<int, int> >::const_iterator it = v_jetNhadIndexPair.begin();
       it != v_jetNhadIndexPair.end();
       ++it) {
    v_orderedJetIndices.push_back(it->second);
  }
 
  return v_orderedJetIndices;
}
 
// ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
void GenTtbarCategorizer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  //The following says we do not know what parameters are allowed so do no validation
  // Please change this to state exactly what you do use, even if it is no parameters
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);
}
 
//define this as a plug-in
DEFINE_FWK_MODULE(GenTtbarCategorizer);