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

Inheritance diagram for GenTtbarCategorizer:

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

	~GenTtbarCategorizer () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () 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

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)

	~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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (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::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Private Member Functions
void	beginJob () override

void	endJob () override

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

void	produce (edm::Event &, const edm::EventSetup &) 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::EDProducer
typedef EDProducer	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
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

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<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, 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 ( const edm::ParameterSet & iConfig )

explicit

Definition at line 127 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");
 }

GenTtbarCategorizer::~GenTtbarCategorizer ( )

override

Definition at line 152 of file GenTtbarCategorizer.cc.

152 {}

Member Function Documentation

void GenTtbarCategorizer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 390 of file GenTtbarCategorizer.cc.

390 {}

void GenTtbarCategorizer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 393 of file GenTtbarCategorizer.cc.

393 {}

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

static

Definition at line 452 of file GenTtbarCategorizer.cc.

References edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, and edm::ParameterSetDescription::setUnknown().

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

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

private

Definition at line 428 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

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

overrideprivate

Definition at line 159 of file GenTtbarCategorizer.cc.

References funct::abs(), GenHFHadronMatcher_cff::flavour, ttHFGenFilter_cfi::genBHadFlavour, genBHadFlavourToken_, ttHFGenFilter_cfi::genBHadFromTopWeakDecay, genBHadFromTopWeakDecayToken_, ttHFGenFilter_cfi::genBHadIndex, genBHadIndexToken_, GenTtbarCategorizer_cfi::genBHadJetIndex, genBHadJetIndexToken_, GenTtbarCategorizer_cfi::genBHadLeptonHadronIndex, genBHadLeptonHadronIndexToken_, GenTtbarCategorizer_cfi::genBHadLeptonViaTau, genBHadLeptonViaTauToken_, ttHFGenFilter_cfi::genBHadPlusMothers, ttHFGenFilter_cfi::genBHadPlusMothersIndices, genBHadPlusMothersIndicesToken_, genBHadPlusMothersToken_, GenTtbarCategorizer_cfi::genCHadBHadronId, genCHadBHadronIdToken_, GenTtbarCategorizer_cfi::genCHadFlavour, genCHadFlavourToken_, GenTtbarCategorizer_cfi::genCHadFromTopWeakDecay, genCHadFromTopWeakDecayToken_, GenTtbarCategorizer_cfi::genCHadJetIndex, genCHadJetIndexToken_, genJetAbsEtaMax_, genJetPtMin_, ttbarCategorization_cff::genJets, genJetsToken_, edm::Event::getByToken(), SiStripPI::max, min(), eostools::move(), nHadronsOrderedJetIndices(), and edm::Event::put().

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

Member Data Documentation

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

private

Definition at line 102 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 103 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 106 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 101 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 107 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 108 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 105 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 104 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 113 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 111 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 112 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 110 of file GenTtbarCategorizer.cc.

Referenced by produce().

const double GenTtbarCategorizer::genJetAbsEtaMax_

private

Definition at line 96 of file GenTtbarCategorizer.cc.

Referenced by produce().

const double GenTtbarCategorizer::genJetPtMin_

private

Definition at line 95 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 99 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

Member Function Documentation

Member Data Documentation