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

Inheritance diagram for GenTtbarCategorizer:

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

	~GenTtbarCategorizer ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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 &	itemsToGetFromEvent () 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

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

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)

Private Member Functions
virtual void	beginJob () override

virtual void	endJob () override

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

virtual 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
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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 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 75 of file GenTtbarCategorizer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 132 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 ( )

Definition at line 153 of file GenTtbarCategorizer.cc.

154 {}

Member Function Documentation

void GenTtbarCategorizer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 363 of file GenTtbarCategorizer.cc.

364 {}

void GenTtbarCategorizer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 368 of file GenTtbarCategorizer.cc.

369 {}

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

static

Definition at line 428 of file GenTtbarCategorizer.cc.

References edm::ConfigurationDescriptions::addDefault(), 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 404 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
	)

overrideprivatevirtual

Implements edm::EDProducer.

Definition at line 163 of file GenTtbarCategorizer.cc.

References funct::abs(), reco::flavour(), genBHadFlavourToken_, genBHadFromTopWeakDecayToken_, genBHadIndexToken_, genBHadJetIndexToken_, genBHadLeptonHadronIndexToken_, genBHadLeptonViaTauToken_, genBHadPlusMothersIndicesToken_, genBHadPlusMothersToken_, genCHadBHadronIdToken_, genCHadFlavourToken_, genCHadFromTopWeakDecayToken_, genCHadJetIndexToken_, genJetAbsEtaMax_, genJetPtMin_, genJetsToken_, edm::Event::getByToken(), bookConverter::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 104 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 105 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 108 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 103 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 109 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 110 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 107 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 106 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 115 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 113 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 114 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

Definition at line 112 of file GenTtbarCategorizer.cc.

Referenced by produce().

const double GenTtbarCategorizer::genJetAbsEtaMax_

private

Definition at line 98 of file GenTtbarCategorizer.cc.

Referenced by produce().

const double GenTtbarCategorizer::genJetPtMin_

private

Definition at line 97 of file GenTtbarCategorizer.cc.

Referenced by produce().

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

private

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