#include <TopQuarkAnalysis/TopTools/plugins/GenTtbarCategorizer.cc>

Inheritance diagram for GenTtbarCategorizer:

Public Member Functions
	GenTtbarCategorizer (const edm::ParameterSet &)

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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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 &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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)

Private Member Functions
std::vector< int >	nHadronsOrderedJetIndices (const std::map< int, int > &m_jetIndex) const

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

Private Attributes
const edm::EDGetTokenT< std::vector< int > >	genBHadFlavourToken_

const edm::EDGetTokenT< std::vector< int > >	genBHadFromTopWeakDecayToken_

const edm::EDGetTokenT< std::vector< int > >	genBHadIndexToken_

const edm::EDGetTokenT< std::vector< int > >	genBHadJetIndexToken_

const edm::EDGetTokenT< std::vector< int > >	genBHadLeptonHadronIndexToken_

const edm::EDGetTokenT< std::vector< int > >	genBHadLeptonViaTauToken_

const edm::EDGetTokenT< std::vector< std::vector< int > > >	genBHadPlusMothersIndicesToken_

const edm::EDGetTokenT< std::vector< reco::GenParticle > >	genBHadPlusMothersToken_

const edm::EDGetTokenT< std::vector< int > >	genCHadBHadronIdToken_

const edm::EDGetTokenT< std::vector< int > >	genCHadFlavourToken_

const edm::EDGetTokenT< std::vector< int > >	genCHadFromTopWeakDecayToken_

const edm::EDGetTokenT< std::vector< int > >	genCHadJetIndexToken_

const double	genJetAbsEtaMax_

const double	genJetPtMin_

const edm::EDGetTokenT< reco::GenJetCollection >	genJetsToken_

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

Public Types inherited from edm::ProducerBase
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<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

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

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

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)

template<Transition B>
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 (std::string instanceName)

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

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

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

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

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Description: Categorization of different tt+xx processes, returning unique ID for each process as e.g. tt+bb, tt+b, tt+2b, tt+cc, ...

Implementation:

The classification scheme returns an ID per event, and works as follows:

All jets in the following need to be in the acceptance as given by the config parameters |eta|, pt.
A c jet must contain at least one c hadron and should contain no b hadrons

First, b jets from top are identified, i.e. jets containing a b hadron from t->b decay
They are encoded in the ID as numberOfBjetsFromTop*100, i.e.
0xx: no b jets from top in acceptance
1xx: 1 b jet from top in acceptance
2xx: both b jets from top in acceptance

Then, b jets from W are identified, i.e. jets containing a b hadron from W->b decay
They are encoded in the ID as numberOfBjetsFromW*1000, i.e.
0xxx: no b jets from W in acceptance
1xxx: 1 b jet from W in acceptance
2xxx: 2 b jets from W in acceptance

Then, c jets from W are identified, i.e. jets containing a c hadron from W->c decay, but no b hadrons
They are encoded in the ID as numberOfCjetsFromW*10000, i.e.
0xxxx: no c jets from W in acceptance
1xxxx: 1 c jet from W in acceptance
2xxxx: 2 c jets from W in acceptance

From the remaining jets, the ID is formed based on the additional b jets (IDs x5x) and c jets (IDs x4x) in the following order:
x55: at least 2 additional b jets with at least two of them having >= 2 b hadrons in each
x54: at least 2 additional b jets with one of them having >= 2 b hadrons, the others having =1 b hadron
x53: at least 2 additional b jets with all having =1 b hadron
x52: exactly 1 additional b jet having >=2 b hadrons
x51: exactly 1 additional b jet having =1 b hadron
x45: at least 2 additional c jets with at least two of them having >= 2 c hadrons in each
x44: at least 2 additional c jets with one of them having >= 2 c hadrons, the others having =1 c hadron
x43: at least 2 additional c jets with all having =1 c hadron
x42: exactly 1 additional c jet having >=2 c hadrons
x41: exactly 1 additional c jet having =1 c hadron
x00: No additional b or c jet, i.e. only light flavour jets or no additional jets

Definition at line 73 of file GenTtbarCategorizer.cc.

Constructor & Destructor Documentation

◆ GenTtbarCategorizer()

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

explicit

Definition at line 119 of file GenTtbarCategorizer.cc.

     : 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");
 }

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 404 of file GenTtbarCategorizer.cc.

                                                                                      {
   //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.add<double>("genJetPtMin", 20.);
   desc.add<double>("genJetAbsEtaMax", 2.4);
   desc.add<edm::InputTag>("genJets", edm::InputTag("ak4GenJets"));
   desc.add<edm::InputTag>("genBHadJetIndex", edm::InputTag("matchGenBHadron", "genBHadJetIndex"));
   desc.add<edm::InputTag>("genBHadFlavour", edm::InputTag("matchGenBHadron", "genBHadFlavour"));
   desc.add<edm::InputTag>("genBHadFromTopWeakDecay", edm::InputTag("matchGenBHadron", "genBHadFromTopWeakDecay"));
   desc.add<edm::InputTag>("genBHadPlusMothers", edm::InputTag("matchGenBHadron", "genBHadPlusMothers"));
   desc.add<edm::InputTag>("genBHadPlusMothersIndices", edm::InputTag("matchGenBHadron", "genBHadPlusMothersIndices"));
   desc.add<edm::InputTag>("genBHadIndex", edm::InputTag("matchGenBHadron", "genBHadIndex"));
   desc.add<edm::InputTag>("genBHadLeptonHadronIndex", edm::InputTag("matchGenBHadron", "genBHadLeptonHadronIndex"));
   desc.add<edm::InputTag>("genBHadLeptonViaTau", edm::InputTag("matchGenBHadron", "genBHadLeptonViaTau"));
  
   desc.add<edm::InputTag>("genCHadJetIndex", edm::InputTag("matchGenCHadron", "genCHadJetIndex"));
   desc.add<edm::InputTag>("genCHadFlavour", edm::InputTag("matchGenCHadron", "genCHadFlavour"));
   desc.add<edm::InputTag>("genCHadFromTopWeakDecay", edm::InputTag("matchGenCHadron", "genCHadFromTopWeakDecay"));
   desc.add<edm::InputTag>("genCHadBHadronId", edm::InputTag("matchGenCHadron", "genCHadBHadronId"));
  
   descriptions.add("categorizeGenTtbar", desc);
 }

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

◆ nHadronsOrderedJetIndices()

std::vector< int > GenTtbarCategorizer::nHadronsOrderedJetIndices ( const std::map< int, int > & m_jetIndex ) const

private

Definition at line 380 of file GenTtbarCategorizer.cc.

                                                                                                       {
   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;
 }

References jetUpdater_cfi::sort, and trackerHitRTTI::vector.

Referenced by produce().

◆ produce()

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

overrideprivatevirtual

Implements edm::global::EDProducerBase.

Definition at line 149 of file GenTtbarCategorizer.cc.

                                                                                                   {
   // 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");
 }

References funct::abs(), GenHFHadronMatcher_cff::flavour, ttHFGenFilter_cfi::genBHadFlavour, genBHadFlavourToken_, ttHFGenFilter_cfi::genBHadFromTopWeakDecay, genBHadFromTopWeakDecayToken_, ttHFGenFilter_cfi::genBHadIndex, genBHadIndexToken_, genBHadJetIndexToken_, genBHadLeptonHadronIndexToken_, genBHadLeptonViaTauToken_, ttHFGenFilter_cfi::genBHadPlusMothers, ttHFGenFilter_cfi::genBHadPlusMothersIndices, genBHadPlusMothersIndicesToken_, genBHadPlusMothersToken_, genCHadBHadronIdToken_, genCHadFlavourToken_, genCHadFromTopWeakDecayToken_, genCHadJetIndexToken_, genJetAbsEtaMax_, genJetPtMin_, ttbarCategorization_cff::genJets, genJetsToken_, iEvent, SiStripPI::max, min(), eostools::move(), and nHadronsOrderedJetIndices().

Member Data Documentation

◆ genBHadFlavourToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genBHadFlavourToken_

private

Definition at line 94 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genBHadFromTopWeakDecayToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genBHadFromTopWeakDecayToken_

private

Definition at line 95 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genBHadIndexToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genBHadIndexToken_

private

Definition at line 98 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genBHadJetIndexToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genBHadJetIndexToken_

private

Definition at line 93 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genBHadLeptonHadronIndexToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genBHadLeptonHadronIndexToken_

private

Definition at line 99 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genBHadLeptonViaTauToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genBHadLeptonViaTauToken_

private

Definition at line 100 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genBHadPlusMothersIndicesToken_

const edm::EDGetTokenT<std::vector<std::vector<int> > > GenTtbarCategorizer::genBHadPlusMothersIndicesToken_

private

Definition at line 97 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genBHadPlusMothersToken_

const edm::EDGetTokenT<std::vector<reco::GenParticle> > GenTtbarCategorizer::genBHadPlusMothersToken_

private

Definition at line 96 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genCHadBHadronIdToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genCHadBHadronIdToken_

private

Definition at line 105 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genCHadFlavourToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genCHadFlavourToken_

private

Definition at line 103 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genCHadFromTopWeakDecayToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genCHadFromTopWeakDecayToken_

private

Definition at line 104 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genCHadJetIndexToken_

const edm::EDGetTokenT<std::vector<int> > GenTtbarCategorizer::genCHadJetIndexToken_

private

Definition at line 102 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genJetAbsEtaMax_

const double GenTtbarCategorizer::genJetAbsEtaMax_

private

Definition at line 88 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genJetPtMin_

const double GenTtbarCategorizer::genJetPtMin_

private

Definition at line 87 of file GenTtbarCategorizer.cc.

Referenced by produce().

◆ genJetsToken_

const edm::EDGetTokenT<reco::GenJetCollection> GenTtbarCategorizer::genJetsToken_

private

Definition at line 91 of file GenTtbarCategorizer.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GenTtbarCategorizer()

Member Function Documentation

◆ fillDescriptions()

◆ nHadronsOrderedJetIndices()

◆ produce()

Member Data Documentation

◆ genBHadFlavourToken_

◆ genBHadFromTopWeakDecayToken_

◆ genBHadIndexToken_

◆ genBHadJetIndexToken_

◆ genBHadLeptonHadronIndexToken_

◆ genBHadLeptonViaTauToken_

◆ genBHadPlusMothersIndicesToken_

◆ genBHadPlusMothersToken_

◆ genCHadBHadronIdToken_

◆ genCHadFlavourToken_

◆ genCHadFromTopWeakDecayToken_

◆ genCHadJetIndexToken_

◆ genJetAbsEtaMax_

◆ genJetPtMin_

◆ genJetsToken_