Finds the origin of each heavy flavour hadron and associated jets to it. More...

#include <GenHFHadronMatcher.cc>

Inheritance diagram for GenHFHadronMatcher:

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

	~GenHFHadronMatcher () override

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 noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept final

bool	wantsStreamLuminosityBlocks () const noexcept final

bool	wantsStreamRuns () const noexcept 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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > 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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
	description of the run-time parameters More...

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
int	analyzeMothers (const reco::Candidate thisParticle, int &topDaughterQId, int &topBarDaughterQId, std::vector< const reco::Candidate > &hadMothers, std::vector< std::vector< int >> &hadMothersIndices, std::set< const reco::Candidate > analyzedParticles, const int prevPartIndex) const
	do a recursive search for the mother particles until the b-quark is found or the absolute mother is found More...

bool	checkForLoop (std::vector< const reco::Candidate > &particleChain, const reco::Candidate particle) const

std::vector< int >	findHadronJets (const reco::GenParticleCollection genParticles, const reco::JetFlavourInfoMatchingCollection jetFlavourInfos, std::vector< int > &hadIndex, std::vector< reco::GenParticle > &hadMothersGenPart, std::vector< std::vector< int >> &hadMothersIndices, std::vector< int > &hadLeptonIndex, std::vector< int > &hadLeptonHadIndex, std::vector< int > &hadLeptonViaTau, std::vector< int > &hadFlavour, std::vector< int > &hadFromTopWeakDecay, std::vector< int > &hadBHadronId) const
	identify the jets that contain b-hadrons More...

int	findInMothers (int idx, std::vector< int > &mothChains, const std::vector< std::vector< int >> &hadMothersIndices, const std::vector< reco::GenParticle > &hadMothers, int status, int pdgId, bool pdgAbs, int stopId, int firstLast, bool verbose) const
	helper function to find indices of particles with particular pdgId and status from the list of mothers of a given particle More...

bool	fixExtraSameFlavours (const unsigned int hadId, const std::vector< int > &hadIndices, const std::vector< reco::GenParticle > &hadMothers, const std::vector< std::vector< int >> &hadMothersIndices, const std::vector< int > &isFromTopWeakDecay, const std::vector< std::vector< int >> &LastQuarkIds, const std::vector< std::vector< int >> &LastQuarkMotherIds, std::vector< int > &lastQuarkIndices, std::vector< int > &hadronFlavour, std::set< int > &checkedHadronIds, const int lastQuarkIndex) const

int	flavourSign (const int pdgId) const
	Sign of the flavour (matter/antimatter) More...

std::string	getParticleName (int id) const

bool	hasHadronDaughter (const int flavour, const reco::Candidate *thisParticle) const
	Check if the particle has bHadron among daughters. More...

int	idInList (std::vector< const reco::Candidate > particleList, const reco::Candidate particle) const
	Check if the cpecified particle is already in the list of particles. More...

int	idInList (std::vector< int > list, const int value) const

bool	isBaryonPdgId (const int flavour, const int pdgId) const
	Check the pdgId if it represents a baryon of particular flavour. More...

bool	isHadron (const int flavour, const reco::Candidate *thisParticle) const
	Check the pdgId of a given particle if it is a hadron. More...

bool	isHadronPdgId (const int flavour, const int pdgId) const
	Check the pdgId if it represents a hadron of particular flavour. More...

bool	isMesonPdgId (const int flavour, const int pdgId) const
	Check the pdgId if it represents a meson of particular flavour. More...

bool	isNeutralPdg (int pdgId) const
	Check whether a given pdgId represents neutral particle. More...

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

bool	putMotherIndex (std::vector< std::vector< int >> &hadMothersIndices, int partIndex, int mothIndex) const
	puts mother index to the list of mothers of particle, if it isn't there already More...

Private Attributes
const edm::EDPutTokenT< std::vector< int > >	bHadronIdToken_

const int	flavour_

const std::string	flavourStr_

const edm::EDPutTokenT< std::vector< int > >	flavourToken_

const edm::EDPutTokenT< std::vector< int > >	fromTopWeakDecayToken_

const edm::EDGetTokenT< reco::GenParticleCollection >	genParticlesToken_

const edm::EDPutTokenT< std::vector< int > >	indexToken_

const edm::EDGetTokenT< reco::JetFlavourInfoMatchingCollection >	jetFlavourInfosToken_

const edm::EDPutTokenT< std::vector< int > >	jetIndexToken_

const edm::EDPutTokenT< std::vector< int > >	leptonHadronIndexToken_

const edm::EDPutTokenT< std::vector< int > >	leptonIndexToken_

const edm::EDPutTokenT< std::vector< int > >	leptonViaTauToken_

const bool	noBBbarResonances_

const bool	onlyJetClusteredHadrons_

const edm::EDPutTokenT< std::vector< std::vector< int > > >	plusMothersIndicesToken_

const edm::EDPutTokenT< std::vector< reco::GenParticle > >	plusMothersToken_

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

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

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<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
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)

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

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

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

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

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

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

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

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

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

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

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

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

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

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Finds the origin of each heavy flavour hadron and associated jets to it.

Starting from each consituent of each jet, tracks back in chain to find heavy flavour hadrons. From each hadron traces back until finds the b quark and its mother. For each hadron identifies the jet to which it was injected as a ghost hadron.

The description of the run-time parameters can be found at fillDescriptions()

The description of the products can be found at GenHFHadronMatcher()

Definition at line 53 of file GenHFHadronMatcher.cc.

Constructor & Destructor Documentation

◆ GenHFHadronMatcher()

GenHFHadronMatcher::GenHFHadronMatcher ( const edm::ParameterSet & cfg )

explicit

Definition at line 169 of file GenHFHadronMatcher.cc.

References funct::abs(), and looper::cfg.

     : genParticlesToken_(consumes<reco::GenParticleCollection>(cfg.getParameter<edm::InputTag>("genParticles"))),
       jetFlavourInfosToken_(
           consumes<reco::JetFlavourInfoMatchingCollection>(cfg.getParameter<edm::InputTag>("jetFlavourInfos"))),
       flavour_{std::abs(cfg.getParameter<int>("flavour"))},
       noBBbarResonances_{cfg.getParameter<bool>("noBBbarResonances")},
       onlyJetClusteredHadrons_{cfg.getParameter<bool>("onlyJetClusteredHadrons")},
       flavourStr_{flavourName(flavour_)},
       plusMothersToken_{produces<std::vector<reco::GenParticle>>(
           "gen" + flavourStr_ +
           "HadPlusMothers")},  // All mothers in all decay chains above any hadron of specified flavour
       plusMothersIndicesToken_{produces<std::vector<std::vector<int>>>(
           "gen" + flavourStr_ + "HadPlusMothersIndices")},  // Indices of mothers of each hadMother
       indexToken_{
           produces<std::vector<int>>("gen" + flavourStr_ + "HadIndex")},  // Index of hadron in the vector of hadMothers
       flavourToken_{produces<std::vector<int>>(
           "gen" + flavourStr_ +
           "HadFlavour")},  // PdgId of the first non-b(c) quark mother with sign corresponding to hadron charge
       jetIndexToken_{produces<std::vector<int>>(
           "gen" + flavourStr_ + "HadJetIndex")},  // Index of genJet matched to each hadron by jet clustering algorithm
       leptonIndexToken_{produces<std::vector<int>>(
           "gen" + flavourStr_ +
           "HadLeptonIndex")},  // Index of lepton found among the hadron decay products in the list of mothers
       leptonHadronIndexToken_{produces<std::vector<int>>(
           "gen" + flavourStr_ + "HadLeptonHadronIndex")},  // Index of hadron the lepton is associated to
       leptonViaTauToken_{produces<std::vector<int>>(
           "gen" + flavourStr_ + "HadLeptonViaTau")},  // Whether lepton comes directly from hadron or via tau decay
       fromTopWeakDecayToken_{produces<std::vector<int>>(
           "gen" + flavourStr_ +
           "HadFromTopWeakDecay")},  // Tells whether the hadron appears in the chain after top decay
       bHadronIdToken_{produces<std::vector<int>>("gen" + flavourStr_ + "HadBHadronId")}
 // Index of a b-hadron which the current hadron comes from (for c-hadrons)
 {
   // Hadron matching products
 }

◆ ~GenHFHadronMatcher()

GenHFHadronMatcher::~GenHFHadronMatcher ( )

override

Definition at line 205 of file GenHFHadronMatcher.cc.

205 {}

Member Function Documentation

◆ analyzeMothers()

int GenHFHadronMatcher::analyzeMothers	(	const reco::Candidate *	thisParticle,
		int &	topDaughterQId,
		int &	topBarDaughterQId,
		std::vector< const reco::Candidate *> &	hadMothers,
		std::vector< std::vector< int >> &	hadMothersIndices,
		std::set< const reco::Candidate >	analyzedParticles,
		const int	prevPartIndex
	)		const

private

do a recursive search for the mother particles until the b-quark is found or the absolute mother is found

the treatment of b-bar resonances depends on the global parameter noBBbarResonances_

Parameters

[in]	thisParticle	current particle from which starts the search of the hadron and all its mothers up to proton
[out]	hadron	the last hadron in the decay chain [that decays weekly]
[out]	lepton	lepton found in the current decay chain
[out]	topDaughterQId	Id of the top quark daughter b(c) quark
[out]	topBarDaughterQId	Id of the antitop quark daughter b(c) quark
[out]	hadMothers	list of all processed particles ending with proton
[out]	hadMothersIndices	list of i-vectors containing j-indices representing particles that are mothers of each i-particle from hadMothers
[out]	analyzedParticles	list of particles analysed in the chain [used for infinite loop detection]
[out]	prevPartIndex	index of the previous particle in the current chain [used for infinite loop detection]

Returns: index of hadron in the hadMothers list [-1 if no hadron found]

Definition at line 726 of file GenHFHadronMatcher.cc.

References funct::abs(), mps_fire::i, idInList(), reco::Candidate::mother(), reco::Candidate::numberOfMothers(), reco::Candidate::pdgId(), reco::Candidate::pt(), and putMotherIndex().

Referenced by findHadronJets().

                                                                       {
   // Getting the index of the particle which is a hadron in the first call
   int hadronIndex = -1;  // Index of the hadron that is returned by this function
   int index = idInList(hadMothers, thisParticle);
   if (index < 0) {  // If hadron is not in the list of mothers yet
     hadMothers.push_back(thisParticle);
     hadronIndex = hadMothers.size() - 1;
   } else {  // If hadron is in the list of mothers already
     hadronIndex = index;
   }
 
   int partIndex = -1;  // Index of particle being checked in the list of mothers
   partIndex = idInList(hadMothers, thisParticle);
 
   // Checking whether this particle is already in the chain of analyzed particles in order to identify a loop
   bool isLoop = false;
   if (!analyzedParticles) {
     analyzedParticles = new std::set<const reco::Candidate *>;
   }
   for (unsigned int i = 0; i < analyzedParticles->size(); i++) {
     if (analyzedParticles->count(thisParticle) <= 0) {
       continue;
     }
     isLoop = true;
     break;
   }
 
   // If a loop has been detected
   if (isLoop) {
     if (prevPartIndex >= 0) {
       putMotherIndex(hadMothersIndices, prevPartIndex, -1);  // Setting mother index of previous particle to -1
     }
     return hadronIndex;  // Stopping further processing of the current chain
   }
   analyzedParticles->insert(thisParticle);
 
   // Putting the mothers to the list of mothers
   for (size_t iMother = 0; iMother < thisParticle->numberOfMothers(); ++iMother) {
     const reco::Candidate *mother = thisParticle->mother(iMother);
     int mothIndex = idInList(hadMothers, mother);
     if (mothIndex == partIndex && partIndex >= 0) {
       continue;  // Skipping the mother that is its own daughter
     }
 
     // If this mother isn't yet in the list and hadron or lepton is in the list
     if (mothIndex < 0) {
       hadMothers.push_back(mother);
       mothIndex = hadMothers.size() - 1;
     }
     // If hadron has already been found in current chain and the mother isn't a duplicate of the particle being checked
     if (mothIndex != partIndex && partIndex >= 0) {
       putMotherIndex(hadMothersIndices, partIndex, mothIndex);  // Putting the index of mother for current particle
     }
     analyzeMothers(
         mother, topDaughterQId, topBarDaughterQId, hadMothers, hadMothersIndices, analyzedParticles, partIndex);
     // Setting the id of the particle which is a quark from the top decay
     if (std::abs(mother->pdgId()) == 6) {
       int &bId = mother->pdgId() < 0 ? topBarDaughterQId : topDaughterQId;
       int thisFlav = std::abs(thisParticle->pdgId());
       if (bId < 0) {
         if (thisFlav <= 5)
           bId = partIndex;
       } else {
         int bIdFlav = std::abs(hadMothers.at(bId)->pdgId());
         if (bIdFlav != 5 && thisFlav == 5)
           bId = partIndex;
         else if (thisFlav == 5 && thisParticle->pt() > hadMothers.at(bId)->pt())
           bId = partIndex;
       }  // If daughter quark of the top not found yet
     }  // If the mother is a top quark and hadron has been found
   }  // End of loop over mothers
 
   analyzedParticles->erase(thisParticle);  // Removing current particle from the current chain that is being analyzed
 
   if (partIndex < 0) {
     return hadronIndex;  // Safety check
   }
 
   // Adding -1 to the list of mother indices for current particle if it has no mothers (for consistency between numbering of indices and mothers)
   if ((int)thisParticle->numberOfMothers() <= 0) {
     putMotherIndex(hadMothersIndices, partIndex, -1);
   }
 
   return hadronIndex;
 }

◆ checkForLoop()

bool GenHFHadronMatcher::checkForLoop	(	std::vector< const reco::Candidate *> &	particleChain,
		const reco::Candidate *	particle
	)		const

private

◆ fillDescriptions()

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

static

description of the run-time parameters

Definition at line 212 of file GenHFHadronMatcher.cc.

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

                                                                                     {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("genParticles")
       ->setComment("Collection of GenParticle objects which contains all particles produced in the event");
   desc.add<edm::InputTag>("jetFlavourInfos")
       ->setComment(
           "Output from the JetFlavour tool. Contains information about partons/hadrons/leptons associated to jets");
   desc.add<bool>("noBBbarResonances", true)->setComment("Whether resonances should not be treated as hadrons");
   desc.add<bool>("onlyJetClusteredHadrons", false)
       ->setComment("Whether only hadrons that are matched to jets should be analysed. Runs x1000 faster in Sherpa");
   desc.add<int>("flavour", 5)->setComment("Flavour of weakly decaying hadron that should be analysed (4-c, 5-b)");
   descriptions.add("matchGenHFHadron", desc);
 }

◆ findHadronJets()

std::vector< int > GenHFHadronMatcher::findHadronJets	(	const reco::GenParticleCollection *	genParticles,
		const reco::JetFlavourInfoMatchingCollection *	jetFlavourInfos,
		std::vector< int > &	hadIndex,
		std::vector< reco::GenParticle > &	hadMothers,
		std::vector< std::vector< int >> &	hadMothersIndices,
		std::vector< int > &	hadLeptonIndex,
		std::vector< int > &	hadLeptonHadIndex,
		std::vector< int > &	hadLeptonViaTau,
		std::vector< int > &	hadFlavour,
		std::vector< int > &	hadFromTopWeakDecay,
		std::vector< int > &	hadBHadronId
	)		const

private

identify the jets that contain b-hadrons

For each hadron all mothers from all levels and chains are analysed to find the quark or gluon from which the hadron has originated. This is done by searching through the generator particle decay tree starting from the hadron, performing checks for flavour and kinematic consistency. The hadrons that are not last in the decay chain (don't decay weakly) are skipped. Additionally for each hadron it is checked whether it comes from the top weak decay branch and whether it comes from some other b-hadron decay

b-bbar (c-cbar) resonances can either be considered as hadrons or not, depending on the configuration.

Parameters

[out]	hadIndex	vector of indices of found hadrons in hadMothers
[out]	hadMothers	vector of all mothers at all levels of each found hadron
[out]	hadMothersIndices	connection between each particle from hadMothers and its mothers
[out]	hadLeptonIndex	index of lepton among the hadMothers
[out]	hadLeptonHadIndex	index of hadron associated to each lepton
[out]	hadLeptonViaTau	whether lepton is from direct hadron->lepton or hadron->tau->lepton
[out]	hadFlavour	flavour of each found hadron
[out]	hadFromTopWeakDecay	whether each hadron contains the top quark in its decay chain [works only for B-Hadrons]
[out]	hadBHadronId	for each hadron - index of the ancestor b-hadron [-1 if hadron doesn't come from another b-hdaron]

Returns: vector of jet indices that were matched to each hadron [by the jet clustering algorithm]

Definition at line 299 of file GenHFHadronMatcher.cc.

References funct::abs(), analyzeMothers(), edm::RefVector< C, T, F >::begin(), eleIsoSequence_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, edm::RefVector< C, T, F >::end(), spr::find(), findInMothers(), fixExtraSameFlavours(), flavour_, flavourSign(), AJJGenJetFilter_cfi::genParticles, reco::JetFlavourInfo::getbHadrons(), reco::JetFlavourInfo::getcHadrons(), custom_jme_cff::hadronFlavour, hasHadronDaughter(), mps_fire::i, createfilelist::int, isHadron(), GenHFHadronMatcher_cfi::jetFlavourInfos, reco::CompositeRefCandidateT< D >::mother(), reco::Candidate::mother(), onlyJetClusteredHadrons_, or, EgammaValidation_cff::pdgId, reco::Candidate::pdgId(), reco::LeafCandidate::pdgId(), and jetUpdater_cfi::sort.

Referenced by produce().

                                                                                         {
   std::vector<int> hadJetIndex;
   std::vector<const reco::Candidate *> hadMothersCand;
 
   int topDaughterQId = -1;
   int topBarDaughterQId = -1;
 
   // Looping over all jets to get hadrons associated to them
   for (reco::JetFlavourInfoMatchingCollection::const_iterator i_info = jetFlavourInfos->begin();
        i_info != jetFlavourInfos->end();
        ++i_info) {
     reco::JetFlavourInfo jetInfo = i_info->second;
     const int jetIndex = i_info - jetFlavourInfos->begin();
     // Looping over each hadron associated with the jet and finding its origin
     const reco::GenParticleRefVector &hadronsInJet = flavour_ == 5   ? jetInfo.getbHadrons()
                                                      : flavour_ == 4 ? jetInfo.getcHadrons()
                                                                      : reco::GenParticleRefVector();
     for (reco::GenParticleRefVector::const_iterator hadron = hadronsInJet.begin(); hadron != hadronsInJet.end();
          ++hadron) {
       // Check that the hadron satisfies criteria configured in the module
       if (!isHadron(flavour_, (&**hadron)))
         continue;
       if (hasHadronDaughter(flavour_, (reco::Candidate *)(&**hadron)))
         continue;
       // Scanning the chain starting from the hadron
       int hadronIndex = analyzeMothers((reco::Candidate *)(&**hadron),
                                        topDaughterQId,
                                        topBarDaughterQId,
                                        hadMothersCand,
                                        hadMothersIndices,
                                        nullptr,
                                        -1);
       // Storing the index of the hadron to the list
       hadIndex.push_back(hadronIndex);
       hadJetIndex.push_back(jetIndex);  // Putting jet index to the result list
     }
   }  // End of loop over jets
 
   // Access all hadrons which are not associated with jets, if requested
   if (!onlyJetClusteredHadrons_) {
     for (reco::GenParticleCollection::const_iterator i_particle = genParticles->begin();
          i_particle != genParticles->end();
          ++i_particle) {
       const reco::GenParticle *thisParticle = &*i_particle;
       if (!isHadron(flavour_, thisParticle))
         continue;
       // Skipping the hadron if it was already found directly from jets
       if (std::find(hadMothersCand.begin(), hadMothersCand.end(), thisParticle) != hadMothersCand.end())
         continue;
 
       // Scanning the chain starting from the hadron
       int hadronIndex = analyzeMothers(
           thisParticle, topDaughterQId, topBarDaughterQId, hadMothersCand, hadMothersIndices, nullptr, -1);
       // Storing the index of the hadron to the list
       hadIndex.push_back(hadronIndex);
       hadJetIndex.push_back(-1);  // Jet index undefined
     }
   }
 
   // Transfering Candidates to the list of processed particles for further analysis
   for (int i = 0; i < (int)hadMothersCand.size(); i++) {
     const reco::GenParticle *particle = dynamic_cast<const reco::GenParticle *>(hadMothersCand.at(i));
     hadMothers.push_back(*particle);
   }
 
   // Adding leptons from hadron decays
   for (reco::GenParticleCollection::const_iterator i_particle = genParticles->begin();
        i_particle != genParticles->end();
        ++i_particle) {
     const reco::GenParticle &lepton = *i_particle;
     const int pdg_abs = lepton.pdgId();
     // Skipping if not a lepton: e/mu
     if (pdg_abs != 11 && pdg_abs != 13)
       continue;
     bool leptonViaTau = false;
     const reco::Candidate *leptonMother = lepton.mother();
     if (!leptonMother)
       continue;
     // Taking next mother if direct mother is a tau
     if (std::abs(leptonMother->pdgId()) == 15) {
       leptonViaTau = true;
       leptonMother = leptonMother->mother();
     }
     // Skipping this lepton if its mother is not a proper hadron
     if (leptonMother == nullptr or !isHadron(flavour_, leptonMother))
       continue;
     // Finding the index of this hadron in the list of analysed particles
     size_t leptonHadronParticleIndex =
         std::find(hadMothersCand.begin(), hadMothersCand.end(), leptonMother) - hadMothersCand.begin();
     if (leptonHadronParticleIndex >= hadMothersCand.size())
       continue;
     // Finding the actual hadron index among those that were found
     size_t leptonHadronIndex =
         std::find(hadIndex.begin(), hadIndex.end(), leptonHadronParticleIndex) - hadIndex.begin();
     if (leptonHadronIndex >= hadIndex.size())
       continue;
     // Putting the lepton, its index and hadron index to the corresponding lists
     hadMothers.push_back(lepton);
     const int leptonIndex = hadMothersCand.size() - 1;
     hadLeptonIndex.push_back(leptonIndex);
     hadLeptonViaTau.push_back(leptonViaTau);
     hadLeptonHadIndex.push_back(leptonHadronIndex);
   }
 
   // Checking mothers of hadrons in order to assign flags (where the hadron comes from)
   unsigned int nHad = hadIndex.size();
 
   std::vector<std::vector<int>> LastQuarkMotherIds;
   std::vector<std::vector<int>> LastQuarkIds;
   std::vector<int> lastQuarkIndices(nHad, -1);
 
   // Looping over all hadrons
   for (unsigned int hadNum = 0; hadNum < nHad; hadNum++) {
     unsigned int hadIdx = hadIndex.at(hadNum);  // Index of hadron in the hadMothers
 
     std::vector<int> FirstQuarkId;
     std::vector<int> LastQuarkId;
     std::vector<int> LastQuarkMotherId;
 
     const int hadronFlavourSign = flavourSign(hadMothers.at(hadIdx).pdgId());
 
     // Searching only first quark in the chain with the same flavour as hadron
     if (hadronFlavourSign != 0) {
       findInMothers(
           hadIdx, FirstQuarkId, hadMothersIndices, hadMothers, 0, hadronFlavourSign * flavour_, false, -1, 1, false);
     }
     // Searching for quarks with both flavours since it is a bb/cc resonance
     else {
       findInMothers(hadIdx, FirstQuarkId, hadMothersIndices, hadMothers, 0, flavour_, false, -1, 1, false);
       findInMothers(hadIdx, FirstQuarkId, hadMothersIndices, hadMothers, 0, -1 * flavour_, false, -1, 1, false);
     }
 
     // Finding last quark for each first quark
     for (unsigned int qId = 0; qId < FirstQuarkId.size(); qId++) {
       // Identifying the flavour of the first quark to find the last quark of the same flavour
       const int quarkFlavourSign = flavourSign(hadMothers.at(FirstQuarkId.at(qId)).pdgId());
       // Finding last quark of the hadron starting from the first quark
       findInMothers(FirstQuarkId.at(qId),
                     LastQuarkId,
                     hadMothersIndices,
                     hadMothers,
                     0,
                     quarkFlavourSign * flavour_,
                     false,
                     -1,
                     2,
                     false);
     }  // End of loop over all first quarks of the hadron
 
     // Setting initial flavour of the hadron
     int hadronFlavour = 0;
 
     // Initialising pairs of last quark index and its distance from the hadron (to sort by distance)
     std::vector<std::pair<double, int>> lastQuark_dR_id_pairs;
 
     // Finding the closest quark in dR
     for (unsigned int qId = 0; qId < LastQuarkId.size(); qId++) {
       int qIdx = LastQuarkId.at(qId);
       // Calculating the dR between hadron and quark
       float dR = deltaR(hadMothers.at(hadIdx).eta(),
                         hadMothers.at(hadIdx).phi(),
                         hadMothers.at(qIdx).eta(),
                         hadMothers.at(qIdx).phi());
 
       std::pair<double, int> dR_hadId_pair(dR, qIdx);
       lastQuark_dR_id_pairs.push_back(dR_hadId_pair);
     }  // End of loop over all last quarks of the hadron
 
     std::sort(lastQuark_dR_id_pairs.begin(), lastQuark_dR_id_pairs.end());
 
     if (lastQuark_dR_id_pairs.size() > 1) {
       double dRratio =
           (lastQuark_dR_id_pairs.at(1).first - lastQuark_dR_id_pairs.at(0).first) / lastQuark_dR_id_pairs.at(1).first;
       int qIdx_closest = lastQuark_dR_id_pairs.at(0).second;
       LastQuarkId.clear();
       if (dRratio > 0.5)
         LastQuarkId.push_back(qIdx_closest);
       else
         for (std::pair<double, int> qIdDrPair : lastQuark_dR_id_pairs)
           LastQuarkId.push_back(qIdDrPair.second);
     }
     for (int qIdx : LastQuarkId) {
       int qmIdx = hadMothersIndices.at(qIdx).at(0);
       LastQuarkMotherId.push_back(qmIdx);
     }
 
     if ((int)LastQuarkId.size() > 0)
       lastQuarkIndices.at(hadNum) = 0;  // Setting the first quark in array as a candidate if it exists
 
     LastQuarkIds.push_back(LastQuarkId);
 
     LastQuarkMotherIds.push_back(LastQuarkMotherId);
 
     if (LastQuarkMotherId.empty()) {
       hadronFlavour = 0;
     } else {
       int qIdx = LastQuarkId.at(lastQuarkIndices.at(hadNum));
       int qFlav = flavourSign(hadMothers.at(qIdx).pdgId());
       hadronFlavour = qFlav * std::abs(hadMothers.at(LastQuarkMotherId.at(lastQuarkIndices.at(hadNum))).pdgId());
     }
     hadFlavour.push_back(hadronFlavour);  // Adding hadron flavour to the list of flavours
 
     // Checking whether hadron comes from the Top weak decay
     int isFromTopWeakDecay = 1;
     std::vector<int> checkedParticles;
     if (hadFlavour.at(hadNum) != 0) {
       int lastQIndex = LastQuarkId.at(lastQuarkIndices.at(hadNum));
       bool fromTB = topDaughterQId >= 0 ? findInMothers(lastQIndex,
                                                         checkedParticles,
                                                         hadMothersIndices,
                                                         hadMothers,
                                                         -1,
                                                         0,
                                                         false,
                                                         topDaughterQId,
                                                         2,
                                                         false) >= 0
                                         : false;
       checkedParticles.clear();
       bool fromTbarB = topBarDaughterQId >= 0 ? findInMothers(lastQIndex,
                                                               checkedParticles,
                                                               hadMothersIndices,
                                                               hadMothers,
                                                               -1,
                                                               0,
                                                               false,
                                                               topBarDaughterQId,
                                                               2,
                                                               false) >= 0
                                               : false;
       checkedParticles.clear();
       if (!fromTB && !fromTbarB) {
         isFromTopWeakDecay = 0;
       }
     } else
       isFromTopWeakDecay = 2;
     hadFromTopWeakDecay.push_back(isFromTopWeakDecay);
     int bHadronMotherId =
         findInMothers(hadIdx, checkedParticles, hadMothersIndices, hadMothers, 0, 555555, true, -1, 1, false);
     hadBHadronId.push_back(bHadronMotherId);
 
     if (!LastQuarkMotherId.empty()) {
       std::set<int> checkedHadronIds;
       fixExtraSameFlavours(hadNum,
                            hadIndex,
                            hadMothers,
                            hadMothersIndices,
                            hadFromTopWeakDecay,
                            LastQuarkIds,
                            LastQuarkMotherIds,
                            lastQuarkIndices,
                            hadFlavour,
                            checkedHadronIds,
                            0);
     }
 
   }  // End of loop over all hadrons
 
   return hadJetIndex;
 }

◆ findInMothers()

int GenHFHadronMatcher::findInMothers	(	int	idx,
		std::vector< int > &	mothChains,
		const std::vector< std::vector< int >> &	hadMothersIndices,
		const std::vector< reco::GenParticle > &	hadMothers,
		int	status,
		int	pdgId,
		bool	pdgAbs = `false`,
		int	stopId = `-1`,
		int	firstLast = `0`,
		bool	verbose = `false`
	)		const

private

helper function to find indices of particles with particular pdgId and status from the list of mothers of a given particle

Parameters

[in]	idx	index of particle, mothers of which should be searched
[in]	mothChains	vector of indices where the found mothers are stored
[in]	hadMothersIndices	list of indices pointing to mothers of each particle from list of mothers
[in]	hadMothers	vector of all hadron mother particles of all levels
[in]	status	status of mother that is being looked for
[in]	pdgId	pdgId of mother that is being looked for [flavour*111111 used to identify hadrons of particular flavour]
[in]	pdgAbs	whether the sign of pdgId should be taken into account
[in]	stopId	id of the particle in the hadMothers array after which the checking should stop
[in]	firstLast	should all(0), first(1) or last(2) occurances of the searched particle be stored
[in]	verbose	option to print every particle that is processed during the search

Returns: index of the found particle in the hadMothers array [-1 if the specified particle not found]

Definition at line 880 of file GenHFHadronMatcher.cc.

References funct::abs(), spr::find(), mps_fire::i, heavyIonCSV_trainingSettings::idx, isHadronPdgId(), EgammaValidation_cff::pdgId, mps_update::status, and verbose.

Referenced by findHadronJets().

                                                                   {
   int foundStopId = -1;
   int pdg_1 = hadMothers.at(idx).pdgId();
 
   if ((int)hadMothersIndices.size() <= idx) {
     if (verbose) {
       printf(" Stopping checking particle %d. No mothers are stored.\n", idx);
     }
     return -1;  // Skipping if no mothers are stored for this particle
   }
 
   if (std::abs(hadMothers.at(idx).pdgId()) > 10 && std::abs(hadMothers.at(idx).pdgId()) < 19)
     printf("Lepton: %d\n", hadMothers.at(idx).pdgId());
 
   std::vector<int> mothers = hadMothersIndices.at(idx);
   unsigned int nMothers = mothers.size();
   bool isCorrect = false;  // Whether current particle is what is being searched
   if (verbose) {
     if (std::abs(hadMothers.at(idx).pdgId()) == 2212) {
       printf("Chk:  %d\tpdg: %d\tstatus: %d", idx, hadMothers.at(idx).pdgId(), hadMothers.at(idx).status());
     } else {
       printf(" Chk:  %d(%d mothers)\tpdg: %d\tstatus: %d\tPt: %.3f\tEta: %.3f",
              idx,
              nMothers,
              hadMothers.at(idx).pdgId(),
              hadMothers.at(idx).status(),
              hadMothers.at(idx).pt(),
              hadMothers.at(idx).eta());
     }
   }
   bool hasCorrectMothers = true;
   if (nMothers < 1)
     hasCorrectMothers = false;
   else if (mothers.at(0) < 0)
     hasCorrectMothers = false;
   if (!hasCorrectMothers) {
     if (verbose)
       printf("    NO CORRECT MOTHER\n");
     return -1;
   }
   // Stopping if the particular particle has been found
   if (stopId >= 0 && idx == stopId)
     return idx;
 
   // Stopping if the hadron of particular flavour has been found
   if (pdgId % 111111 == 0 && pdgId != 0) {
     if (isHadronPdgId(pdgId / 111111, hadMothers.at(idx).pdgId())) {
       return idx;
     }
   }
 
   // Checking whether current mother satisfies selection criteria
   if (((hadMothers.at(idx).pdgId() == pdgId && pdgAbs == false) ||
        (std::abs(hadMothers.at(idx).pdgId()) == std::abs(pdgId) && pdgAbs == true)) &&
       (hadMothers.at(idx).status() == status || status == 0) && hasCorrectMothers) {
     isCorrect = true;
     // Adding to the list of candidates if not there and if mother of this quark has correct flavour sign
     const bool inList = std::find(mothChains.begin(), mothChains.end(), idx) != mothChains.end();
     if (!inList && mothers.at(0) >= 0 && (hadMothers.at(idx).pdgId() * pdgId > 0 || !pdgAbs)) {
       if (firstLast == 0 || firstLast == 1) {
         mothChains.push_back(idx);
       }
       if (verbose) {
         printf("   *");
       }
     }
     if (verbose) {
       printf("   +++");
     }
   }
   if (verbose) {
     printf("\n");
   }
 
   if (isCorrect && firstLast == 1) {
     return -1;  // Stopping if only the first particle in the chain is looked for
   }
 
   // Checking next level mothers
   unsigned int nDifferingMothers = 0;
   for (unsigned int i = 0; i < nMothers; i++) {
     int idx2 = mothers.at(i);
     if (idx2 < 0) {
       if (verbose)
         printf("^^^ Has no mother\n");
       continue;  // Skipping if mother's id is -1 (no mother), that means current particle is a proton
     }
     if (idx2 == idx) {
       if (verbose)
         printf("^^^ Stored as its own mother\n");
       continue;  // Skipping if particle is stored as its own mother
     }
     int pdg_2 = hadMothers[idx2].pdgId();
     // Inverting the flavour if bb oscillation detected
     if (isHadronPdgId(pdgId, pdg_1) && isHadronPdgId(pdgId, pdg_2) && pdg_1 * pdg_2 < 0) {
       pdgId *= -1;
       if (verbose)
         printf("######### Inverting flavour of the hadron\n");
     }
     // Counting how many mothers are different from this particle
     if ((std::abs(pdg_2) != std::abs(pdgId) && pdgAbs == true) || (pdg_2 != pdgId && pdgAbs == false)) {
       nDifferingMothers++;
     }
 
     // Checking next level mother
     if (verbose) {
       printf("Checking mother %d out of %d mothers (%d -> %d), looking for pdgId: %d\n", i, nMothers, idx, idx2, pdgId);
     }
     if (firstLast == 2 && pdg_1 != pdg_2)
       continue;  // Requiring the same flavour when finding the last quark
     foundStopId = findInMothers(
         idx2, mothChains, hadMothersIndices, hadMothers, status, pdgId, pdgAbs, stopId, firstLast, verbose);
   }
   // Storing this particle if all its mothers are of another type and the last of its kind should be stored
   if (firstLast == 2 && isCorrect && nDifferingMothers >= nMothers) {
     if (verbose) {
       printf("Checking particle %d once more to store it as the last quark\n", idx);
     }
     foundStopId = findInMothers(idx, mothChains, hadMothersIndices, hadMothers, 0, pdgId, pdgAbs, stopId, 1, verbose);
   }
 
   return foundStopId;
 }

◆ fixExtraSameFlavours()

bool GenHFHadronMatcher::fixExtraSameFlavours	(	const unsigned int	hadId,
		const std::vector< int > &	hadIndices,
		const std::vector< reco::GenParticle > &	hadMothers,
		const std::vector< std::vector< int >> &	hadMothersIndices,
		const std::vector< int > &	isFromTopWeakDecay,
		const std::vector< std::vector< int >> &	LastQuarkIds,
		const std::vector< std::vector< int >> &	LastQuarkMotherIds,
		std::vector< int > &	lastQuarkIndices,
		std::vector< int > &	hadronFlavour,
		std::set< int > &	checkedHadronIds,
		const int	lastQuarkIndex
	)		const

private

Finds hadrons that have the same flavour and origin and resolve this ambiguity fixExtraSameFlavours

Parameters

hadId	Index of the hadron being checked
hadIndex	Vector of indices of each hadron pointing to the hadMothers
hadMothers	Vector of gen particles (contain hadrons and all its ancestors)
hadMothersIndices	Vector of indices for each particle from hadMothers
isFromTopWeakDecay	Vector of values showing whether particle comes from the top weak decay
LastQuarkIds	Vector of indices of last quarks for each hadron
LastQuarkMotherIds	Vector of indices of mothers for each last quark from LastQuarkIds
lastQuakIndices	Vector of indices pointing to particular index from the LastQuarkIds and LastQuarkMotherIds to be used for each hadron
lastQuarkIndex	Index from the LastQuarkIds and LastQuarkMotherIds for this particular hadron with index hadId

Returns: Whether other mother with unique association has been found for the hadrons

Definition at line 1044 of file GenHFHadronMatcher.cc.

References funct::abs(), custom_jme_cff::hadronFlavour, and isNeutralPdg().

Referenced by findHadronJets().

                                                                               {
   if (checkedHadronIds.count(hadId) != 0)
     return false;                  // Hadron already checked previously and should be skipped
   checkedHadronIds.insert(hadId);  // Putting hadron to the list of checked ones in this run
 
   if (lastQuarkIndex < 0)
     return false;
   if ((int)LastQuarkIds.at(hadId).size() < lastQuarkIndex + 1)
     return false;
   int LastQuarkId = LastQuarkIds.at(hadId).at(lastQuarkIndex);
   int LastQuarkMotherId = LastQuarkMotherIds.at(hadId).at(lastQuarkIndex);
   int qmFlav = hadMothers.at(LastQuarkId).pdgId() < 0 ? -1 : 1;
   int hadFlavour = qmFlav * std::abs(hadMothers.at(LastQuarkMotherId).pdgId());
   bool ambiguityResolved = true;
   // If last quark has inconsistent flavour with its mother, setting the hadron flavour to gluon
   if ((hadMothers.at(LastQuarkId).pdgId() * hadMothers.at(LastQuarkMotherId).pdgId() < 0 &&
        !isNeutralPdg(hadMothers.at(LastQuarkMotherId).pdgId())) ||
       // If particle not coming from the Top weak decay has Top flavour
       (std::abs(hadronFlavour.at(hadId)) == 6 && isFromTopWeakDecay.at(hadId) == 0)) {
     if ((int)LastQuarkIds.at(hadId).size() > lastQuarkIndex + 1)
       fixExtraSameFlavours(hadId,
                            hadIndices,
                            hadMothers,
                            hadMothersIndices,
                            isFromTopWeakDecay,
                            LastQuarkIds,
                            LastQuarkMotherIds,
                            lastQuarkIndices,
                            hadronFlavour,
                            checkedHadronIds,
                            lastQuarkIndex + 1);
     else
       hadronFlavour.at(hadId) = qmFlav * 21;
     return true;
   }
 
   int nSameFlavourHadrons = 0;
   // Looping over all previous hadrons
   for (unsigned int iHad = 0; iHad < hadronFlavour.size(); iHad++) {
     if (iHad == hadId)
       continue;
     int theLastQuarkIndex = lastQuarkIndices.at(iHad);
     if (theLastQuarkIndex < 0)
       continue;
     if ((int)LastQuarkMotherIds.at(iHad).size() <= theLastQuarkIndex)
       continue;
     int theLastQuarkMotherId = LastQuarkMotherIds.at(iHad).at(theLastQuarkIndex);
     int theHadFlavour = hadronFlavour.at(iHad);
     // Skipping hadrons with different flavour
     if (theHadFlavour == 0 || std::abs(theHadFlavour) == 21)
       continue;
     if (theHadFlavour != hadFlavour || theLastQuarkMotherId != LastQuarkMotherId)
       continue;
     ambiguityResolved = false;
     nSameFlavourHadrons++;
 
     // Checking other b-quark mother candidates of this hadron
     if ((int)LastQuarkIds.at(hadId).size() > lastQuarkIndex + 1) {
       if (fixExtraSameFlavours(hadId,
                                hadIndices,
                                hadMothers,
                                hadMothersIndices,
                                isFromTopWeakDecay,
                                LastQuarkIds,
                                LastQuarkMotherIds,
                                lastQuarkIndices,
                                hadronFlavour,
                                checkedHadronIds,
                                lastQuarkIndex + 1)) {
         ambiguityResolved = true;
         break;
       }
     } else
       // Checking other b-quark mother candidates of the particular previous hadron
       if ((int)LastQuarkIds.at(iHad).size() > theLastQuarkIndex + 1) {
         if (fixExtraSameFlavours(iHad,
                                  hadIndices,
                                  hadMothers,
                                  hadMothersIndices,
                                  isFromTopWeakDecay,
                                  LastQuarkIds,
                                  LastQuarkMotherIds,
                                  lastQuarkIndices,
                                  hadronFlavour,
                                  checkedHadronIds,
                                  theLastQuarkIndex + 1)) {
           ambiguityResolved = true;
           break;
         };
       }
 
   }  // End of loop over all previous hadrons
 
   checkedHadronIds.erase(hadId);  // Removing the hadron from the list of checked hadrons
   if (nSameFlavourHadrons > 0 && !ambiguityResolved) {
     hadronFlavour.at(hadId) = qmFlav * 21;
     return true;
   }
   lastQuarkIndices.at(hadId) = lastQuarkIndex;
   hadronFlavour.at(hadId) = hadFlavour;
   return true;
 }

◆ flavourSign()

int GenHFHadronMatcher::flavourSign ( const int pdgId ) const

private

Sign of the flavour (matter/antimatter)

Parameters

[in] pdgId pdgId to be checked

Returns: +1/-1/0 matter/antimatter/undefined

Definition at line 675 of file GenHFHadronMatcher.cc.

References funct::abs(), isMesonPdgId(), and EgammaValidation_cff::pdgId.

Referenced by findHadronJets().

                                                          {
   int flavourSign = pdgId / std::abs(pdgId);
   // B mesons have opposite sign
   if (isMesonPdgId(5, pdgId))
     flavourSign *= -1;
   // Returning 0 for bb/cc resonances
   if (pdgId % 1000 / 10 / 11 > 0)
     flavourSign = 0;
 
   return flavourSign;
 }

◆ getParticleName()

std::string GenHFHadronMatcher::getParticleName ( int id ) const

private

◆ hasHadronDaughter()

bool GenHFHadronMatcher::hasHadronDaughter	(	const int	flavour,
		const reco::Candidate *	thisParticle
	)		const

private

Check if the particle has bHadron among daughters.

Parameters

[in]	flavour	flavour of a hadron that is being searched (5-B, 4-C)
[in]	thisParticle	a particle that is to be analysed

Returns: whether the particle has a hadron among its daughters

Definition at line 695 of file GenHFHadronMatcher.cc.

References reco::Candidate::daughter(), createfilelist::int, isHadron(), isotrackApplyRegressor::k, and reco::Candidate::numberOfDaughters().

Referenced by findHadronJets().

                                                                                                      {
   // Looping through daughters of the particle
   bool hasDaughter = false;
   for (int k = 0; k < (int)thisParticle->numberOfDaughters(); k++) {
     if (!isHadron(flavour, thisParticle->daughter(k))) {
       continue;
     }
     hasDaughter = true;
     break;
   }
 
   return hasDaughter;
 }

◆ idInList() [1/2]

int GenHFHadronMatcher::idInList	(	std::vector< const reco::Candidate *>	particleList,
		const reco::Candidate *	particle
	)		const

private

Check if the cpecified particle is already in the list of particles.

Parameters

[in]	particleList	list of particles to be checked
[in]	particle	particle that should be checked

Returns: the index of the particle in the list [-1 if particle not found]

Definition at line 578 of file GenHFHadronMatcher.cc.

References spr::find(), and position.

Referenced by analyzeMothers().

                                                                       {
   const unsigned int position = std::find(particleList.begin(), particleList.end(), particle) - particleList.begin();
   if (position >= particleList.size())
     return -1;
 
   return position;
 }

◆ idInList() [2/2]

int GenHFHadronMatcher::idInList	(	std::vector< int >	list,
		const int	value
	)		const

private

Definition at line 587 of file GenHFHadronMatcher.cc.

References spr::find(), position, and relativeConstraints::value.

                                                                            {
   const unsigned int position = std::find(list.begin(), list.end(), value) - list.begin();
   if (position >= list.size())
     return -1;
 
   return position;
 }

◆ isBaryonPdgId()

bool GenHFHadronMatcher::isBaryonPdgId	(	const int	flavour,
		const int	pdgId
	)		const

private

Check the pdgId if it represents a baryon of particular flavour.

Parameters

[in]	flavour	flavour of a hadron that is being searched (5-B, 4-C)
[in]	pdgId	pdgId to be checked

Returns: true if the pdgId represents a baryon of specified flavour

Definition at line 656 of file GenHFHadronMatcher.cc.

References funct::abs(), and EgammaValidation_cff::pdgId.

Referenced by isHadronPdgId().

                                                                                {
   const int flavour_abs = std::abs(flavour);
   if (flavour_abs != 5 && flavour_abs != 4)
     return false;
   const int pdgId_abs = std::abs(pdgId);
 
   if (pdgId_abs / 1000 != flavour_abs)
     return false;
 
   return true;
 }

◆ isHadron()

bool GenHFHadronMatcher::isHadron	(	const int	flavour,
		const reco::Candidate *	thisParticle
	)		const

private

Check the pdgId of a given particle if it is a hadron.

Parameters

[in]	flavour	flavour of a hadron that is being searched (5-B, 4-C)
[in]	thisParticle	a particle that is to be analysed

Returns: whether the particle is a hadron of specified flavour

Definition at line 603 of file GenHFHadronMatcher.cc.

References isHadronPdgId(), and reco::Candidate::pdgId().

Referenced by findHadronJets(), and hasHadronDaughter().

                                                                                             {
   return isHadronPdgId(flavour, thisParticle->pdgId());
 }

◆ isHadronPdgId()

bool GenHFHadronMatcher::isHadronPdgId	(	const int	flavour,
		const int	pdgId
	)		const

private

Check the pdgId if it represents a hadron of particular flavour.

Parameters

[in]	flavour	flavour of a hadron that is being searched (5-B, 4-C)
[in]	pdgId	pdgId to be checked

Returns: true if the pdgId represents a hadron of specified flavour

Definition at line 615 of file GenHFHadronMatcher.cc.

References isBaryonPdgId(), isMesonPdgId(), and EgammaValidation_cff::pdgId.

Referenced by findInMothers(), and isHadron().

                                                                                {
   if (isBaryonPdgId(flavour, pdgId) || isMesonPdgId(flavour, pdgId))
     return true;
 
   return false;
 }

◆ isMesonPdgId()

bool GenHFHadronMatcher::isMesonPdgId	(	const int	flavour,
		const int	pdgId
	)		const

private

Check the pdgId if it represents a meson of particular flavour.

Parameters

[in]	flavour	flavour of a hadron that is being searched (5-B, 4-C)
[in]	pdgId	pdgId to be checked

Returns: true if the pdgId represents a meson of specified flavour

Definition at line 630 of file GenHFHadronMatcher.cc.

References funct::abs(), noBBbarResonances_, and EgammaValidation_cff::pdgId.

Referenced by flavourSign(), and isHadronPdgId().

                                                                               {
   const int flavour_abs = std::abs(flavour);
   if (flavour_abs != 5 && flavour_abs != 4)
     return false;
   const int pdgId_abs = std::abs(pdgId);
 
   if (pdgId_abs / 100 % 10 != flavour_abs)
     return false;
   // Excluding baryons
   if (pdgId_abs / 1000 == flavour_abs)
     return false;
   // Excluding bb/cc resonances if required
   if (noBBbarResonances_ && pdgId_abs / 10 % 100 == 11 * flavour_abs)
     return false;
 
   return true;
 }

◆ isNeutralPdg()

bool GenHFHadronMatcher::isNeutralPdg ( int pdgId ) const

private

Check whether a given pdgId represents neutral particle.

Parameters

[in]	pdgId
[in]	thisParticle	- a particle that is to be analysed

Returns: if the particle has a hadron among its daughters

Definition at line 1021 of file GenHFHadronMatcher.cc.

References funct::abs(), spr::find(), and EgammaValidation_cff::pdgId.

Referenced by fixExtraSameFlavours().

                                                      {
   const int neutralPdgs_array[] = {9, 21, 22, 23, 25};
   const std::vector<int> neutralPdgs(neutralPdgs_array, neutralPdgs_array + sizeof(neutralPdgs_array) / sizeof(int));
   if (std::find(neutralPdgs.begin(), neutralPdgs.end(), std::abs(pdgId)) == neutralPdgs.end())
     return false;
 
   return true;
 }

◆ produce()

void GenHFHadronMatcher::produce	(	edm::StreamID	,
		edm::Event &	evt,
		const edm::EventSetup &	setup
	)		const

overrideprivatevirtual

Implements edm::global::EDProducerBase.

Definition at line 231 of file GenHFHadronMatcher.cc.

References bHadronIdToken_, edm::Event::emplace(), findHadronJets(), flavourToken_, fromTopWeakDecayToken_, AJJGenJetFilter_cfi::genParticles, genParticlesToken_, edm::Event::getByToken(), indexToken_, GenHFHadronMatcher_cfi::jetFlavourInfos, jetFlavourInfosToken_, jetIndexToken_, leptonHadronIndexToken_, leptonIndexToken_, leptonViaTauToken_, eostools::move(), plusMothersIndicesToken_, and plusMothersToken_.

                                                                                              {
   using namespace edm;
 
   edm::Handle<reco::GenParticleCollection> genParticles;
   evt.getByToken(genParticlesToken_, genParticles);
 
   edm::Handle<reco::JetFlavourInfoMatchingCollection> jetFlavourInfos;
   evt.getByToken(jetFlavourInfosToken_, jetFlavourInfos);
 
   // Defining adron matching variables
   std::vector<reco::GenParticle> hadMothers;
   std::vector<std::vector<int>> hadMothersIndices;
   std::vector<int> hadIndex;
   std::vector<int> hadFlavour;
   std::vector<int> hadJetIndex;
   std::vector<int> hadLeptonIndex;
   std::vector<int> hadLeptonHadIndex;
   std::vector<int> hadLeptonViaTau;
   std::vector<int> hadFromTopWeakDecay;
   std::vector<int> hadBHadronId;
 
   hadJetIndex = findHadronJets(genParticles.product(),
                                jetFlavourInfos.product(),
                                hadIndex,
                                hadMothers,
                                hadMothersIndices,
                                hadLeptonIndex,
                                hadLeptonHadIndex,
                                hadLeptonViaTau,
                                hadFlavour,
                                hadFromTopWeakDecay,
                                hadBHadronId);
 
   // Putting products to the event
   evt.emplace(plusMothersToken_, std::move(hadMothers));
   evt.emplace(plusMothersIndicesToken_, std::move(hadMothersIndices));
   evt.emplace(indexToken_, std::move(hadIndex));
   evt.emplace(flavourToken_, std::move(hadFlavour));
   evt.emplace(jetIndexToken_, std::move(hadJetIndex));
   evt.emplace(leptonIndexToken_, std::move(hadLeptonIndex));
   evt.emplace(leptonHadronIndexToken_, std::move(hadLeptonHadIndex));
   evt.emplace(leptonViaTauToken_, std::move(hadLeptonViaTau));
   evt.emplace(fromTopWeakDecayToken_, std::move(hadFromTopWeakDecay));
   evt.emplace(bHadronIdToken_, std::move(hadBHadronId));
 }

◆ putMotherIndex()

bool GenHFHadronMatcher::putMotherIndex	(	std::vector< std::vector< int >> &	hadMothersIndices,
		int	partIndex,
		int	mothIndex
	)		const

private

puts mother index to the list of mothers of particle, if it isn't there already

Parameters

[in]	hadMothersIndices	vector of indices of mothers for each particle
[in]	partIndex	index of the particle for which the mother index should be stored
[in]	mothIndex	index of mother that should be stored for current particle

Returns: whether the particle index was alreade in the list

Definition at line 827 of file GenHFHadronMatcher.cc.

References createfilelist::int, and isotrackApplyRegressor::k.

Referenced by analyzeMothers().

                                                              {
   // Putting vector of mothers indices for the given particle
   bool inList = false;
   if (partIndex < 0) {
     return false;
   }
 
   while ((int)hadMothersIndices.size() <= partIndex) {  // If there is no list of mothers for current particle yet
     std::vector<int> mothersIndices;
     hadMothersIndices.push_back(mothersIndices);
   }
 
   std::vector<int> *hadMotherIndices = &hadMothersIndices.at(partIndex);
   // Removing other mothers if particle must have no mothers
   if (mothIndex == -1) {
     hadMotherIndices->clear();
   } else {
     // Checking if current mother is already in the list of theParticle's mothers
     for (int k = 0; k < (int)hadMotherIndices->size(); k++) {
       if (hadMotherIndices->at(k) != mothIndex && hadMotherIndices->at(k) != -1) {
         continue;
       }
       inList = true;
       break;
     }
   }
   // Adding current mother to the list of mothers of this particle
   if (!inList) {
     hadMotherIndices->push_back(mothIndex);
   }
 
   return inList;
 }

const edm::EDPutTokenT<std::vector<std::vector<int> > > GenHFHadronMatcher::plusMothersIndicesToken_

private

Definition at line 126 of file GenHFHadronMatcher.cc.

Referenced by produce().

◆ plusMothersToken_

const edm::EDPutTokenT<std::vector<reco::GenParticle> > GenHFHadronMatcher::plusMothersToken_

private

Definition at line 125 of file GenHFHadronMatcher.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GenHFHadronMatcher()

◆ ~GenHFHadronMatcher()

Member Function Documentation

◆ analyzeMothers()

◆ checkForLoop()

◆ fillDescriptions()

◆ findHadronJets()

◆ findInMothers()

◆ fixExtraSameFlavours()

◆ flavourSign()

◆ getParticleName()

◆ hasHadronDaughter()

◆ idInList() [1/2]

◆ idInList() [2/2]

◆ isBaryonPdgId()

◆ isHadron()

◆ isHadronPdgId()

◆ isMesonPdgId()

◆ isNeutralPdg()

◆ produce()

◆ putMotherIndex()

Member Data Documentation

◆ bHadronIdToken_

◆ flavour_

◆ flavourStr_

◆ flavourToken_

◆ fromTopWeakDecayToken_

◆ genParticlesToken_

◆ indexToken_

◆ jetFlavourInfosToken_

◆ jetIndexToken_

◆ leptonHadronIndexToken_

◆ leptonIndexToken_

◆ leptonViaTauToken_

◆ noBBbarResonances_

◆ onlyJetClusteredHadrons_

◆ plusMothersIndicesToken_

◆ plusMothersToken_