#include <MCTruthHelper.h>

Public Member Functions
int	absPdgId (const reco::GenParticle &p)

int	absPdgId (const HepMC::GenParticle &p)

const reco::GenParticle *	daughter (const reco::GenParticle &p, unsigned int idau)

const HepMC::GenParticle *	daughter (const HepMC::GenParticle &p, unsigned int idau)

void	fillGenStatusFlags (const P &p, reco::GenStatusFlags &statusFlags)

const P *	findDecayedMother (const P &p)

const P *	findDecayedMother (const P &p, int abspdgid)

const P *	firstCopy (const P &p)

bool	fromHardProcess (const P &p)

bool	fromHardProcessBeforeFSR (const P &p)

bool	fromHardProcessDecayed (const P &p)

bool	fromHardProcessFinalState (const P &p)

const P *	hardProcessMotherCopy (const P &p)

bool	isDecayedLeptonHadron (const P &p)

bool	isDirectHadronDecayProduct (const P &p)

bool	isDirectHardProcessTauDecayProduct (const P &p)

bool	isDirectPromptTauDecayProduct (const P &p)

bool	isDirectTauDecayProduct (const P &p)

bool	isFirstCopy (const P &p)

bool	isHadron (const P &p)

bool	isHardProcess (const P &p)

bool	isHardProcessTauDecayProduct (const P &p)

bool	isLastCopy (const P &p)

bool	isLastCopyBeforeFSR (const P &p)

bool	isMuonDecayProduct (const P &p)

bool	isPrompt (const P &p)

bool	isPromptDecayed (const P &p)

bool	isPromptFinalState (const P &p)

bool	isPromptMuonDecayProduct (const P &p)

bool	isPromptTauDecayProduct (const P &p)

bool	isTauDecayProduct (const P &p)

const P *	lastCopy (const P &p)

const P *	lastCopyBeforeFSR (const P &p)

const P *	lastDaughterCopyBeforeFSR (const P &p)

const reco::GenParticle *	mother (const reco::GenParticle &p, unsigned int imoth=0)

const HepMC::GenParticle *	mother (const HepMC::GenParticle &p, unsigned int imoth=0)

const P *	nextCopy (const P &p)

unsigned int	numberOfDaughters (const reco::GenParticle &p)

unsigned int	numberOfDaughters (const HepMC::GenParticle &p)

unsigned int	numberOfMothers (const reco::GenParticle &p)

unsigned int	numberOfMothers (const HepMC::GenParticle &p)

int	pdgId (const reco::GenParticle &p)

int	pdgId (const HepMC::GenParticle &p)

const P *	previousCopy (const P &p)

const P *	uniqueMother (const P &p)

Protected Attributes
std::unordered_set< const P * >	dupCheck_

Detailed Description

template<typename P>
class MCTruthHelper

Definition at line 14 of file MCTruthHelper.h.

Member Function Documentation

template<typename P >

int MCTruthHelper::absPdgId ( const reco::GenParticle & p )

Definition at line 576 of file MCTruthHelper.h.

References funct::abs(), and reco::LeafCandidate::pdgId().

                                                        {
   return std::abs(p.pdgId());
 }

template<typename P >

int MCTruthHelper::absPdgId ( const HepMC::GenParticle & p )

Definition at line 582 of file MCTruthHelper.h.

References funct::abs().

                                                         {
   return std::abs(p.pdg_id());
 }

template<typename P >

const reco::GenParticle * MCTruthHelper< P >::daughter	(	const reco::GenParticle &	p,
		unsigned int	idau
	)

Definition at line 624 of file MCTruthHelper.h.

References reco::CompositeRefCandidateT< D >::daughter().

                                                                                              {
   return static_cast<const reco::GenParticle*>(p.daughter(idau));
 }

template<typename P >

const HepMC::GenParticle * MCTruthHelper< P >::daughter	(	const HepMC::GenParticle &	p,
		unsigned int	idau
	)

Definition at line 630 of file MCTruthHelper.h.

                                                                                                {
   return *(p.end_vertex()->particles_out_const_begin() + idau);
 }

template<typename P>

void MCTruthHelper< P >::fillGenStatusFlags	(	const P &	p,
		reco::GenStatusFlags &	statusFlags
	)

Definition at line 636 of file MCTruthHelper.h.

Referenced by GenParticleProducer::convertParticle().

                                                                                      {
   statusFlags.setIsPrompt(isPrompt(p));
   statusFlags.setIsDecayedLeptonHadron(isDecayedLeptonHadron(p));
   statusFlags.setIsTauDecayProduct(isTauDecayProduct(p));
   statusFlags.setIsPromptTauDecayProduct(isPromptTauDecayProduct(p));
   statusFlags.setIsDirectTauDecayProduct(isDirectTauDecayProduct(p));
   statusFlags.setIsDirectPromptTauDecayProduct(isDirectPromptTauDecayProduct(p));
   statusFlags.setIsDirectHadronDecayProduct(isDirectHadronDecayProduct(p));
   statusFlags.setIsHardProcess(isHardProcess(p));
   statusFlags.setFromHardProcess(fromHardProcess(p));
   statusFlags.setIsHardProcessTauDecayProduct(isHardProcessTauDecayProduct(p));
   statusFlags.setIsDirectHardProcessTauDecayProduct(isDirectHardProcessTauDecayProduct(p));
   statusFlags.setFromHardProcessBeforeFSR(fromHardProcessBeforeFSR(p));
   statusFlags.setIsFirstCopy(isFirstCopy(p));
   statusFlags.setIsLastCopy(isLastCopy(p));
   statusFlags.setIsLastCopyBeforeFSR(isLastCopyBeforeFSR(p));
 }  

template<typename P>

const P * MCTruthHelper::findDecayedMother ( const P & p )

Definition at line 538 of file MCTruthHelper.h.

References P.

                                                        {
   const P *mo = mother(p);
   dupCheck_.clear();
   while (mo && !isDecayedLeptonHadron(*mo)) {
     dupCheck_.insert(mo);
     mo = mother(*mo);
     if (dupCheck_.count(mo)) return 0;
   }
   return mo;
 }  

template<typename P>

const P * MCTruthHelper< P >::findDecayedMother	(	const P &	p,
		int	abspdgid
	)

Definition at line 551 of file MCTruthHelper.h.

References P.

                                                                      {
   const P *mo = mother(p);
   dupCheck_.clear();
   while (mo && (absPdgId(*mo)!=abspdgid || !isDecayedLeptonHadron(*mo)) ) {
     dupCheck_.insert(mo);
     mo = mother(*mo);
     if (dupCheck_.count(mo)) return 0;
   }
   return mo;
 }

template<typename P>

const P * MCTruthHelper::firstCopy ( const P & p )

Definition at line 397 of file MCTruthHelper.h.

References P, and AlCaHLTBitMon_ParallelJobs::p.

                                                {
   const P *pcopy = &p;
   dupCheck_.clear();
   while (previousCopy(*pcopy)) {
     dupCheck_.insert(pcopy);
     pcopy = previousCopy(*pcopy);
     if (dupCheck_.count(pcopy)) return 0;
   }
   return pcopy;    
 }

template<typename P>

bool MCTruthHelper::fromHardProcess ( const P & p )

Definition at line 306 of file MCTruthHelper.h.

                                                  {
   return hardProcessMotherCopy(p) != 0;
 }

template<typename P>

bool MCTruthHelper::fromHardProcessBeforeFSR ( const P & p )

Definition at line 338 of file MCTruthHelper.h.

References P, and AlCaHLTBitMon_ParallelJobs::p.

                                                           {
   //pythia 6 documentation line roughly corresponds to this condition
   if (p.status()==3) return true;
   
   //check hard process mother properties
   const P *hpc = hardProcessMotherCopy(p);
   if (!hpc) return false;
       
   //for incoming partons in pythia8, more useful information is not
   //easily available, so take only the incoming parton itself
   if (hpc->status()==21 && (&p)==hpc) return true;
   
   //for intermediate particles in pythia 8, just take the last copy
   if (hpc->status()==22 && isLastCopy(p)) return true;
   
   //for outgoing particles in pythia 8, explicitly find the last copy
   //before FSR starting from the hardProcess particle, and take only
   //this one
   if ( (hpc->status()==23 || hpc->status()==1) && (&p)==lastDaughterCopyBeforeFSR(*hpc) ) return true;
   
   
   //didn't satisfy any of the conditions
   return false;
   
 }

template<typename P>

bool MCTruthHelper::fromHardProcessDecayed ( const P & p )

Definition at line 318 of file MCTruthHelper.h.

                                                         {
   return isDecayedLeptonHadron(p) && fromHardProcess(p);
 }

template<typename P>

bool MCTruthHelper::fromHardProcessFinalState ( const P & p )

Definition at line 312 of file MCTruthHelper.h.

                                                            {
   return p.status()==1 && fromHardProcess(p);
 }

template<typename P>

const P * MCTruthHelper::hardProcessMotherCopy ( const P & p )

Definition at line 490 of file MCTruthHelper.h.

References P, and AlCaHLTBitMon_ParallelJobs::p.

                                                            {
   //is particle itself is hard process particle
   if (isHardProcess(p)) return &p;
   
   //check if any other copies are hard process particles
   const P *pcopy = &p;
   dupCheck_.clear();
   while (previousCopy(*pcopy)) {
     dupCheck_.insert(pcopy);
     pcopy = previousCopy(*pcopy);
     if (isHardProcess(*pcopy)) return pcopy;
     if (dupCheck_.count(pcopy)) break;
   }
   return 0;
 }

template<typename P>

bool MCTruthHelper::isDecayedLeptonHadron ( const P & p )

Definition at line 208 of file MCTruthHelper.h.

                                                        {
   return p.status()==2  && (isHadron(p) || absPdgId(p)==13 || absPdgId(p)==15) && isLastCopy(p);
 }

template<typename P>

bool MCTruthHelper::isDirectHadronDecayProduct ( const P & p )

Definition at line 261 of file MCTruthHelper.h.

References P.

                                                             {
   const P *um = uniqueMother(p);
   return um && isHadron(*um) && isDecayedLeptonHadron(*um);
 }  

template<typename P>

bool MCTruthHelper::isDirectHardProcessTauDecayProduct ( const P & p )

Definition at line 331 of file MCTruthHelper.h.

References P, and metsig::tau.

                                                                     {
   const P *tau = findDecayedMother(p,15);
   const P *dm = findDecayedMother(p);
   return tau && tau==dm && fromHardProcess(*tau);    
 }  

template<typename P>

bool MCTruthHelper::isDirectPromptTauDecayProduct ( const P & p )

Definition at line 240 of file MCTruthHelper.h.

References P, and metsig::tau.

                                                                {
   const P *tau = findDecayedMother(p,15);
   const P *dm = findDecayedMother(p);
   return tau && tau==dm && isPrompt(*tau);
 }

template<typename P>

bool MCTruthHelper::isDirectTauDecayProduct ( const P & p )

Definition at line 232 of file MCTruthHelper.h.

References P, and metsig::tau.

                                                          {
   const P *tau = findDecayedMother(p,15);
   const P *dm = findDecayedMother(p);
   return tau && tau==dm;
 }

template<typename P>

bool MCTruthHelper::isFirstCopy ( const P & p )

Definition at line 366 of file MCTruthHelper.h.

                                              {
   return &p == firstCopy(p);
 }  

template<typename P>

bool MCTruthHelper::isHadron ( const P & p )

Definition at line 268 of file MCTruthHelper.h.

References benchmark_cfg::pdgId.

                                           {
   HepPDT::ParticleID heppdtid(pdgId(p));
   return heppdtid.isHadron();
 }

template<typename P>

bool MCTruthHelper::isHardProcess ( const P & p )

Definition at line 275 of file MCTruthHelper.h.

References P.

                                                {
   
   //status 3 in pythia6 means hard process;
   if (p.status()==3) return true;
   
   //hard process codes for pythia8 are 21-29 inclusive (currently 21,22,23,24 are used)
   if (p.status()>20 && p.status()<30) return true;
   
   //if this is a final state or decayed particle,
   //check if direct mother is a resonance decay in pythia8 but exclude FSR branchings
   //(In pythia8 if a resonance decay product did not undergo any further branchings
   //it will be directly stored as status 1 or 2 without any status 23 copy)
   if (p.status()==1 || p.status()==2) {
     const P *um = mother(p);
     if (um) {
       const P *firstcopy = firstCopy(*um);
       bool fromResonance = firstcopy && firstcopy->status()==22;
       
       const P *umNext = nextCopy(*um);
       bool fsrBranching = umNext && umNext->status()>50 && umNext->status()<60;
       
       if (fromResonance && !fsrBranching) return true;
     }
   }
   
   return false;
   
 }

template<typename P>

bool MCTruthHelper::isHardProcessTauDecayProduct ( const P & p )

Definition at line 324 of file MCTruthHelper.h.

References P, and metsig::tau.

                                                               {
   const P *tau = findDecayedMother(p,15);
   return tau && fromHardProcessDecayed(*tau);    
 }

template<typename P>

bool MCTruthHelper::isLastCopy ( const P & p )

Definition at line 372 of file MCTruthHelper.h.

                                             {
   return &p == lastCopy(p);
 }

template<typename P>

bool MCTruthHelper::isLastCopyBeforeFSR ( const P & p )

Definition at line 378 of file MCTruthHelper.h.

                                                      {
   return &p == lastCopyBeforeFSR(p);
 }  

template<typename P>

bool MCTruthHelper::isMuonDecayProduct ( const P & p )

Definition at line 248 of file MCTruthHelper.h.

                                                     {
   return findDecayedMother(p,13) != 0;
 }

template<typename P>

bool MCTruthHelper::isPrompt ( const P & p )

Definition at line 194 of file MCTruthHelper.h.

                                           {
   //particle from hadron/muon/tau decay -> not prompt
   //checking all the way up the chain treats properly the radiated photon
   //case as well
   return findDecayedMother(p) == 0;
 }

template<typename P>

bool MCTruthHelper::isPromptDecayed ( const P & p )

Definition at line 213 of file MCTruthHelper.h.

                                                  {
   return isDecayedLeptonHadron(p) && isPrompt(p);
 }

template<typename P>

bool MCTruthHelper::isPromptFinalState ( const P & p )

Definition at line 203 of file MCTruthHelper.h.

                                                     {
   return p.status()==1 && isPrompt(p);
 }

template<typename P>

bool MCTruthHelper::isPromptMuonDecayProduct ( const P & p )

Definition at line 254 of file MCTruthHelper.h.

References RPCpg::mu, and P.

                                                           {
   const P *mu = findDecayedMother(p,13);
   return mu && isPrompt(*mu);
 }  

template<typename P>

bool MCTruthHelper::isPromptTauDecayProduct ( const P & p )

Definition at line 225 of file MCTruthHelper.h.

References P, and metsig::tau.

                                                          {
   const P *tau = findDecayedMother(p,15);
   return tau && isPrompt(*tau);
 }

template<typename P>

bool MCTruthHelper::isTauDecayProduct ( const P & p )

Definition at line 219 of file MCTruthHelper.h.

                                                    {
   return findDecayedMother(p,15) != 0;
 }

template<typename P>

const P * MCTruthHelper::lastCopy ( const P & p )

Definition at line 410 of file MCTruthHelper.h.

References P, and AlCaHLTBitMon_ParallelJobs::p.

                                               {
   const P *pcopy = &p;
   dupCheck_.clear();
   while (nextCopy(*pcopy)) {
     dupCheck_.insert(pcopy);
     pcopy = nextCopy(*pcopy);
     if (dupCheck_.count(pcopy)) return 0;
   }
   return pcopy;    
 }

template<typename P>

const P * MCTruthHelper::lastCopyBeforeFSR ( const P & p )

Definition at line 423 of file MCTruthHelper.h.

References P, and benchmark_cfg::pdgId.

                                                        {
   //start with first copy and then walk down until there is FSR
   const P *pcopy = firstCopy(p);
   if (!pcopy) return 0;
   bool hasDaughterCopy = true;
   dupCheck_.clear();
   while (hasDaughterCopy) {
     dupCheck_.insert(pcopy);
     hasDaughterCopy = false;
     const unsigned int ndau = numberOfDaughters(*pcopy);
     //look for FSR
     for (unsigned int idau = 0; idau<ndau; ++idau) {
       const P *dau = daughter(*pcopy,idau);
       if (pdgId(*dau)==21 || pdgId(*dau)==22) {
         //has fsr (or else decayed and is the last copy by construction)
         return pcopy;
       }        
     }
     //look for daughter copy
     for (unsigned int idau = 0; idau<ndau; ++idau) {
       const P *dau = daughter(*pcopy,idau);
       if (pdgId(*dau)==pdgId(p)) {
         pcopy = dau;
         hasDaughterCopy = true;
         break;
       }
     }
     if (dupCheck_.count(pcopy)) return 0;
   }
   return pcopy;       
 }

template<typename P>

const P * MCTruthHelper::lastDaughterCopyBeforeFSR ( const P & p )

Definition at line 457 of file MCTruthHelper.h.

References P, AlCaHLTBitMon_ParallelJobs::p, and benchmark_cfg::pdgId.

                                                                {
   //start with this particle and then walk down until there is FSR
   const P *pcopy = &p;
   bool hasDaughterCopy = true;
   dupCheck_.clear();
   while (hasDaughterCopy) {
     dupCheck_.insert(pcopy);
     hasDaughterCopy = false;
     const unsigned int ndau = numberOfDaughters(*pcopy);
     //look for FSR
     for (unsigned int idau = 0; idau<ndau; ++idau) {
       const P *dau = daughter(*pcopy,idau);
       if (pdgId(*dau)==21 || pdgId(*dau)==22) {
         //has fsr (or else decayed and is the last copy by construction)
         return pcopy;
       }        
     }
     //look for daughter copy
     for (unsigned int idau = 0; idau<ndau; ++idau) {
       const P *dau = daughter(*pcopy,idau);
       if (pdgId(*dau)==pdgId(p)) {
         pcopy = dau;
         hasDaughterCopy = true;
         break;
       }
     }
     if (dupCheck_.count(pcopy)) return 0;
   }
   return pcopy;       
 }  

template<typename P >

const reco::GenParticle * MCTruthHelper< P >::mother	(	const reco::GenParticle &	p,
		unsigned int	imoth = `0`
	)

Definition at line 600 of file MCTruthHelper.h.

References reco::CompositeRefCandidateT< D >::mother().

                                                                                             {
   return static_cast<const reco::GenParticle*>(p.mother(imoth));
 }

template<typename P >

const HepMC::GenParticle * MCTruthHelper< P >::mother	(	const HepMC::GenParticle &	p,
		unsigned int	imoth = `0`
	)

Definition at line 606 of file MCTruthHelper.h.

                                                                                               {
   return p.production_vertex() && p.production_vertex()->particles_in_size() ? *(p.production_vertex()->particles_in_const_begin() + imoth) : 0;
 }

template<typename P>

const P * MCTruthHelper::nextCopy ( const P & p )

Definition at line 523 of file MCTruthHelper.h.

References P, and benchmark_cfg::pdgId.

                                               {
   
   const unsigned int ndau = numberOfDaughters(p);
   for (unsigned int idau = 0; idau<ndau; ++idau) {
     const P *dau = daughter(p,idau);
     if (pdgId(*dau)==pdgId(p)) {
       return dau;
     }
   }
   
   return 0;     
 }  

template<typename P >

unsigned int MCTruthHelper::numberOfDaughters ( const reco::GenParticle & p )

Definition at line 612 of file MCTruthHelper.h.

References reco::CompositeRefCandidateT< D >::numberOfDaughters().

                                                                          {
   return p.numberOfDaughters();
 }

template<typename P >

unsigned int MCTruthHelper::numberOfDaughters ( const HepMC::GenParticle & p )

Definition at line 618 of file MCTruthHelper.h.

                                                                           {
   return p.end_vertex() ? p.end_vertex()->particles_out_size() : 0;
 }

template<typename P >

unsigned int MCTruthHelper::numberOfMothers ( const reco::GenParticle & p )

Definition at line 588 of file MCTruthHelper.h.

References reco::CompositeRefCandidateT< D >::numberOfMothers().

                                                                        {
   return p.numberOfMothers();
 }

template<typename P >

unsigned int MCTruthHelper::numberOfMothers ( const HepMC::GenParticle & p )

Definition at line 594 of file MCTruthHelper.h.

                                                                         {
   return p.production_vertex() ? p.production_vertex()->particles_in_size() : 0;
 }

template<typename P >

int MCTruthHelper::pdgId ( const reco::GenParticle & p )

Definition at line 564 of file MCTruthHelper.h.

References reco::LeafCandidate::pdgId().

Referenced by Particle.Particle::__str__().

                                                     {
   return p.pdgId();
 }

template<typename P >

int MCTruthHelper::pdgId ( const HepMC::GenParticle & p )

Definition at line 570 of file MCTruthHelper.h.

Referenced by Particle.Particle::__str__().

                                                      {
   return p.pdg_id();
 }  

template<typename P>

const P * MCTruthHelper::previousCopy ( const P & p )

Definition at line 508 of file MCTruthHelper.h.

References P, and benchmark_cfg::pdgId.

                                                   {
   
   const unsigned int nmoth = numberOfMothers(p);
   for (unsigned int imoth = 0; imoth<nmoth; ++imoth) {
     const P *moth = mother(p,imoth);
     if (pdgId(*moth)==pdgId(p)) {
       return moth;
     }
   }
   
   return 0;     
 }   

template<typename P>

const P * MCTruthHelper::uniqueMother ( const P & p )

Definition at line 384 of file MCTruthHelper.h.

References P, AlCaHLTBitMon_ParallelJobs::p, and benchmark_cfg::pdgId.

                                                   {
   const P *mo = &p;
   dupCheck_.clear();
   while (mo && pdgId(*mo)==pdgId(p)) {
     dupCheck_.insert(mo);
     mo = mother(*mo);
     if (dupCheck_.count(mo)) return 0;
   }
   return mo;
 }

Member Data Documentation

template<typename P>

std::unordered_set<const P*> MCTruthHelper::dupCheck_

protected

Definition at line 183 of file MCTruthHelper.h.

Public Member Functions

Protected Attributes

Detailed Description

template<typename P> class MCTruthHelper< P >

Member Function Documentation

Member Data Documentation

template<typename P>
class MCTruthHelper< P >