#include <FlavorHistoryProducer.h>

Inheritance diagram for FlavorHistoryProducer:

Public Member Functions
	FlavorHistoryProducer (const edm::ParameterSet &)
	constructor More...

	~FlavorHistoryProducer () override
	destructor More...

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)

Private Member Functions
void	getAncestors (const reco::Candidate &c, std::vector< reco::Candidate const * > &moms)

reco::CandidateView::const_iterator	getClosestJet (edm::Handle< reco::CandidateView > const &pJets, reco::Candidate const &parton) const

reco::Candidate const *	getSister (const reco::Candidate &c)

void	produce (edm::Event &e, const edm::EventSetup &) override
	process one event More...

Private Attributes
double	etaMaxParticle_

double	etaMaxShower_

std::string	flavorHistoryName_

double	matchDR_

edm::EDGetTokenT< reco::CandidateView >	matchedSrcToken_

int	pdgIdToSelect_

double	ptMinParticle_

double	ptMinShower_

edm::EDGetTokenT< reco::CandidateView >	srcToken_

bool	verbose_

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

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

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

class

Author: Stephen Mrenna, FNAL

Version: $Id: FlavorHistoryProducer.cc,v 1.0

Definition at line 55 of file FlavorHistoryProducer.h.

Constructor & Destructor Documentation

FlavorHistoryProducer::FlavorHistoryProducer ( const edm::ParameterSet & p )

constructor

Definition at line 37 of file FlavorHistoryProducer.cc.

References flavorHistoryName_.

     : srcToken_(consumes<CandidateView>(p.getParameter<InputTag>("src"))),
       matchedSrcToken_(consumes<CandidateView>(p.getParameter<InputTag>("matchedSrc"))),
       matchDR_(p.getParameter<double>("matchDR")),
       pdgIdToSelect_(p.getParameter<int>("pdgIdToSelect")),
       ptMinParticle_(p.getParameter<double>("ptMinParticle")),
       ptMinShower_(p.getParameter<double>("ptMinShower")),
       etaMaxParticle_(p.getParameter<double>("etaMaxParticle")),
       etaMaxShower_(p.getParameter<double>("etaMaxShower")),
       flavorHistoryName_(p.getParameter<string>("flavorHistoryName")),
       verbose_(p.getUntrackedParameter<bool>("verbose")) {
   produces<FlavorHistoryEvent>(flavorHistoryName_);
 }

FlavorHistoryProducer::~FlavorHistoryProducer ( )

override

destructor

Definition at line 51 of file FlavorHistoryProducer.cc.

51 {}

Member Function Documentation

void FlavorHistoryProducer::getAncestors	(	const reco::Candidate &	c,
		std::vector< reco::Candidate const * > &	moms
	)

private

Definition at line 341 of file FlavorHistoryProducer.cc.

References HltBtagPostValidation_cff::c, reco::Candidate::mother(), and reco::Candidate::numberOfMothers().

Referenced by produce().

                                                                                             {
   if (c.numberOfMothers() == 1) {
     const Candidate *dau = &c;
     const Candidate *mom = c.mother();
     while (dau->numberOfMothers() != 0) {
       moms.push_back(dau);
       dau = mom;
       mom = dau->mother();
     }
   }
 }

CandidateView::const_iterator FlavorHistoryProducer::getClosestJet	(	edm::Handle< reco::CandidateView > const &	pJets,
		reco::Candidate const &	parton
	)		const

private

Definition at line 353 of file FlavorHistoryProducer.cc.

References edm::View< T >::begin(), DEFINE_FWK_MODULE, PbPb_ZMuSkimMuonDPG_cff::deltaR, flavorHistoryFilter_cfi::dr, edm::View< T >::end(), dqmiolumiharvest::j, matchDR_, and reco::Candidate::p4().

Referenced by produce().

                                                                                                       {
   double dr = matchDR_;
   CandidateView::const_iterator j = pJets->begin(), jend = pJets->end();
   CandidateView::const_iterator bestJet = pJets->end();
   for (; j != jend; ++j) {
     double dri = deltaR(parton.p4(), j->p4());
     if (dri < dr) {
       dr = dri;
       bestJet = j;
     }
   }
   return bestJet;
 }

reco::Candidate const* FlavorHistoryProducer::getSister ( const reco::Candidate & c )

private

void FlavorHistoryProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &
	)

overrideprivate

process one event

Definition at line 53 of file FlavorHistoryProducer.cc.

References funct::abs(), edm::View< T >::begin(), gather_cfg::cout, edm::View< T >::end(), PVValHelper::eta, etaMaxShower_, spr::find(), flavorHistoryName_, newFWLiteAna::found, getAncestors(), edm::Event::getByToken(), getClosestJet(), mps_fire::i, cuy::ii, dqmiolumiharvest::j, findQualityFiles::jj, muonTagProbeFilters_cff::matched, matchedSrcToken_, eostools::move(), reco::Candidate::numberOfMothers(), AlCaHLTBitMon_ParallelJobs::p, ecalTrigSettings_cff::particles, EgammaValidation_cff::pdgId, reco::Candidate::pdgId(), pdgIdToSelect_, ptMinShower_, edm::Event::put(), srcToken_, mps_update::status, reco::Candidate::status(), and verbose_.

                                                                   {
   if (verbose_)
     cout << "---------- Hello from FlavorHistoryProducer! -----" << endl;
 
   // Get a handle to the particle collection (OwnVector)
   Handle<CandidateView> particlesViewH;
   evt.getByToken(srcToken_, particlesViewH);
 
   Handle<CandidateView> matchedView;
   evt.getByToken(matchedSrcToken_, matchedView);
 
   // Copy the View to an vector for easier iterator manipulation convenience
   vector<const Candidate *> particles;
   for (CandidateView::const_iterator p = particlesViewH->begin(); p != particlesViewH->end(); ++p) {
     particles.push_back(&*p);
   }
 
   // List of indices for the partons to add
   vector<int> partonIndices;
   // List of progenitors for those partons
   vector<int> progenitorIndices;
   // List of sisters for those partons
   vector<int> sisterIndices;
   // Flavor sources
   vector<FlavorHistory::FLAVOR_T> flavorSources;
 
   // Make a new flavor history vector
   auto flavorHistoryEvent = std::make_unique<FlavorHistoryEvent>();
 
   // ------------------------------------------------------------
   // Loop over partons
   // ------------------------------------------------------------
   vector<const Candidate *>::size_type j;
   vector<const Candidate *>::size_type j_max = particles.size();
   for (j = 0; j < j_max; ++j) {
     // Get the candidate
     const Candidate *p = particles[j];
     // Set up indices that we'll need for the flavor history
     vector<Candidate const *>::size_type partonIndex = j;
     vector<Candidate const *>::size_type progenitorIndex = j_max;
     bool foundProgenitor = false;
     FlavorHistory::FLAVOR_T flavorSource = FlavorHistory::FLAVOR_NULL;
 
     int idabs = std::abs((p)->pdgId());
     int nDa = (p)->numberOfDaughters();
 
     // Check if we have a status 2 or 3 particle, which is a parton before the string.
     // Only consider quarks.
     if (idabs <= FlavorHistory::tQuarkId && p->status() == 2 && idabs == pdgIdToSelect_) {
       // Ensure the parton in question has daughters
       if (nDa > 0) {
         // Ensure the parton passes some minimum kinematic cuts
         if ((p)->pt() > ptMinShower_ && fabs((p)->eta()) < etaMaxShower_) {
           if (verbose_)
             cout << "--------------------------" << endl;
           if (verbose_)
             cout << "Processing particle " << j << ", status = " << p->status() << ", pdg id = " << p->pdgId() << endl;
 
           //Main (but simple) workhorse to get all ancestors
           vector<Candidate const *> allParents;
           getAncestors(*p, allParents);
 
           if (verbose_) {
             cout << "Parents : " << endl;
             vector<Candidate const *>::const_iterator iprint = allParents.begin(), iprintend = allParents.end();
             for (; iprint != iprintend; ++iprint)
               cout << " status = " << (*iprint)->status() << ", pdg id = " << (*iprint)->pdgId()
                    << ", pt = " << (*iprint)->pt() << endl;
           }
 
           // -------------------------------------------------------------
           // Identify the ancestry of the Quark
           //
           //
           // Matrix Element:
           //    Status 3 parent with precisely 2 "grandparents" that
           //    is outside of the "initial" section (0-5) that has the
           //    same ID as the status 2 parton in question.
           //
           // Flavor excitation:
           //    If we find only one outgoing parton.
           //
           // Gluon splitting:
           //    Parent is a quark of a different flavor than the parton
           //    in question, or a gluon.
           //    Can come from either ISR or FSR.
           //
           // True decay:
           //    Decays from a resonance like top, Higgs, etc.
           // -------------------------------------------------------------
           vector<Candidate const *>::size_type a_size = allParents.size();
 
           //
           // Loop over all the ancestors of this parton and find the progenitor.
           //
           for (vector<Candidate const *>::size_type i = 0; i < a_size && !foundProgenitor; ++i) {
             const Candidate *aParent = allParents[i];
             vector<Candidate const *>::const_iterator found = find(particles.begin(), particles.end(), aParent);
 
             // Get the index of the progenitor candidate
             progenitorIndex = found - particles.begin();
 
             int aParentId = std::abs(aParent->pdgId());
 
             // -----------------------------------------------------------------------
             // Here we examine particles that were produced after the collision
             // -----------------------------------------------------------------------
             if (progenitorIndex > 5) {
               // Here is where we have a matrix element process.
               // The signature is to have a status 3 parent with precisely 2 parents
               // that is outside of the "initial" section (0-5) that has the
               // same ID as the status 2 parton in question.
               // NOTE: If this parton has no sister, then this will be classified as
               // a flavor excitation. Often the only difference is that the matrix element
               // cases have a sister, while the flavor excitation cases do not.
               // If we do not find a sister below, this will be classified as a flavor
               // excitation.
               if (aParent->numberOfMothers() == 2 && aParent->pdgId() == p->pdgId() && aParent->status() == 3) {
                 if (verbose_)
                   cout << "Matrix Element progenitor" << endl;
                 if (flavorSource == FlavorHistory::FLAVOR_NULL)
                   flavorSource = FlavorHistory::FLAVOR_ME;
                 foundProgenitor = true;
               }
               // Here we have a true decay. Parent is not a quark or a gluon.
               else if ((aParentId > pdgIdToSelect_ && aParentId < FlavorHistory::gluonId) ||
                        aParentId > FlavorHistory::gluonId) {
                 if (verbose_)
                   cout << "Flavor decay progenitor" << endl;
                 if (flavorSource == FlavorHistory::FLAVOR_NULL)
                   flavorSource = FlavorHistory::FLAVOR_DECAY;
                 foundProgenitor = true;
               }
             }  // end if progenitorIndex > 5
           }    // end loop over parents
 
           // Otherwise, classify it as gluon splitting. Take the first status 3 parton with 1 parent
           // that you see as the progenitor
           if (!foundProgenitor) {
             if (flavorSource == FlavorHistory::FLAVOR_NULL)
               flavorSource = FlavorHistory::FLAVOR_GS;
             // Now get the parton with only one parent (the proton) and that is the progenitor
             for (vector<Candidate const *>::size_type i = 0; i < a_size && !foundProgenitor; ++i) {
               const Candidate *aParent = allParents[i];
               vector<Candidate const *>::const_iterator found = find(particles.begin(), particles.end(), aParent);
               // Get the index of the progenitor candidate
               progenitorIndex = found - particles.begin();
 
               if (aParent->numberOfMothers() == 1 && aParent->status() == 3) {
                 foundProgenitor = true;
               }
             }  // end loop over parents
           }    // end if we haven't found a progenitor, and if we haven't found a status 3 parton of the same flavor
                // (i.e. end if examining gluon splitting)
         }      // End if this parton passes some minimal kinematic cuts
       }        // End if this particle is status 2 (has strings as daughters)
 
       // Make sure we've actually found a progenitor
       if (!foundProgenitor)
         progenitorIndex = j_max;
 
       // We've found the particle, add to the list
 
       partonIndices.push_back(partonIndex);
       progenitorIndices.push_back(progenitorIndex);
       flavorSources.push_back(flavorSource);
       sisterIndices.push_back(-1);  // set below
 
     }  // End if this particle was a status==2 parton
   }    // end loop over particles
 
   // Now add sisters.
   // Also if the event is preliminarily classified as "matrix element", check to
   // make sure that they have a sister. If not, it is flavor excitation.
 
   if (verbose_)
     cout << "Making sisters" << endl;
   // First make sure nothing went terribly wrong:
   if (partonIndices.size() == progenitorIndices.size() && !partonIndices.empty()) {
     // Now loop over the candidates
     for (unsigned int ii = 0; ii < partonIndices.size(); ++ii) {
       // Get the iith particle
       const Candidate *candi = particles[partonIndices[ii]];
       if (verbose_)
         cout << "   Sister candidate particle 1:  " << ii << ", pdgid = " << candi->pdgId()
              << ", status = " << candi->status() << endl;
       // Get the iith progenitor
       // Now loop over the other flavor history candidates and
       // attempt to find a sister to this one
       for (unsigned int jj = 0; jj < partonIndices.size(); ++jj) {
         if (ii != jj) {
           const Candidate *candj = particles[partonIndices[jj]];
           if (verbose_)
             cout << "   Sister candidate particle 2:  " << jj << ", pdgid = " << candj->pdgId()
                  << ", status = " << candj->status() << endl;
           // They should be opposite in pdgid and have the same status, and
           // the same progenitory.
           if (candi->pdgId() == -1 * candj->pdgId() && candi->status() == candj->status()) {
             sisterIndices[ii] = partonIndices[jj];
             if (verbose_)
               cout << "Parton " << partonIndices[ii] << " has sister " << sisterIndices[ii] << endl;
           }
         }
       }
 
       // Here, ensure that there is a sister. Otherwise this is "flavor excitation"
       if (sisterIndices[ii] < 0) {
         if (verbose_)
           cout << "No sister. Classified as flavor excitation" << endl;
         flavorSources[ii] = FlavorHistory::FLAVOR_EXC;
       }
 
       if (verbose_)
         cout << "Getting matched jet" << endl;
       // Get the closest match in the matched object collection
       CandidateView::const_iterator matched = getClosestJet(matchedView, *candi);
       CandidateView::const_iterator matchedBegin = matchedView->begin();
       CandidateView::const_iterator matchedEnd = matchedView->end();
 
       if (verbose_)
         cout << "Getting sister jet" << endl;
       // Get the closest sister in the matched object collection, if sister is found
       CandidateView::const_iterator sister =
           (sisterIndices[ii] >= 0 && static_cast<unsigned int>(sisterIndices[ii]) < particles.size())
               ? getClosestJet(matchedView, *particles[sisterIndices[ii]])
               : matchedEnd;
 
       if (verbose_)
         cout << "Making matched shallow clones : ";
       ShallowClonePtrCandidate matchedCand;
       if (matched != matchedEnd) {
         if (verbose_)
           cout << " found" << endl;
         matchedCand = ShallowClonePtrCandidate(CandidatePtr(matchedView, matched - matchedBegin));
       } else {
         if (verbose_)
           cout << " NOT found" << endl;
       }
 
       if (verbose_)
         cout << "Making sister shallow clones : ";
       ShallowClonePtrCandidate sisterCand;
       if (sister != matchedEnd) {
         if (verbose_)
           cout << " found" << endl;
         sisterCand = ShallowClonePtrCandidate(CandidatePtr(matchedView, sister - matchedBegin));
       } else {
         if (verbose_)
           cout << " NOT found" << endl;
       }
 
       if (verbose_)
         cout << "Making history object" << endl;
       // Now create the flavor history object
       FlavorHistory history(flavorSources[ii],
                             particlesViewH,
                             partonIndices[ii],
                             progenitorIndices[ii],
                             sisterIndices[ii],
                             matchedCand,
                             sisterCand);
       if (verbose_)
         cout << "Adding flavor history : " << history << endl;
       flavorHistoryEvent->push_back(history);
     }
   }
 
   // If we got any partons, cache them and then write them out
   if (flavorHistoryEvent->size() > 0) {
     // Calculate some nice variables for FlavorHistoryEvent
     if (verbose_)
       cout << "Caching flavor history event" << endl;
     flavorHistoryEvent->cache();
 
     if (verbose_) {
       cout << "Outputting pdg id = " << pdgIdToSelect_ << " with nelements = " << flavorHistoryEvent->size() << endl;
       vector<FlavorHistory>::const_iterator i = flavorHistoryEvent->begin(), iend = flavorHistoryEvent->end();
       for (; i != iend; ++i) {
         cout << *i << endl;
       }
     }
   }
 
   // Now add the flavor history to the event record
   evt.put(std::move(flavorHistoryEvent), flavorHistoryName_);
 }

Member Data Documentation

double FlavorHistoryProducer::etaMaxParticle_

private

Definition at line 79 of file FlavorHistoryProducer.h.

double FlavorHistoryProducer::etaMaxShower_

private

Definition at line 80 of file FlavorHistoryProducer.h.

Referenced by produce().

std::string FlavorHistoryProducer::flavorHistoryName_

private

Definition at line 81 of file FlavorHistoryProducer.h.

Referenced by FlavorHistoryProducer(), and produce().

double FlavorHistoryProducer::matchDR_

private

Definition at line 75 of file FlavorHistoryProducer.h.

Referenced by getClosestJet().

edm::EDGetTokenT<reco::CandidateView> FlavorHistoryProducer::matchedSrcToken_

private

Definition at line 74 of file FlavorHistoryProducer.h.

Referenced by produce().

int FlavorHistoryProducer::pdgIdToSelect_

private

Definition at line 76 of file FlavorHistoryProducer.h.

Referenced by produce().

double FlavorHistoryProducer::ptMinParticle_

private

Definition at line 77 of file FlavorHistoryProducer.h.

double FlavorHistoryProducer::ptMinShower_

private

Definition at line 78 of file FlavorHistoryProducer.h.

Referenced by produce().

edm::EDGetTokenT<reco::CandidateView> FlavorHistoryProducer::srcToken_

private

Definition at line 73 of file FlavorHistoryProducer.h.

Referenced by produce().

bool FlavorHistoryProducer::verbose_

private

Definition at line 82 of file FlavorHistoryProducer.h.

Referenced by produce().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation